🔤

.gitignore

@@ -1,4 +1,5 @@
 dist/docs/
+dist/.*
 # Logs
 logs
 *.log

README.md

@@ -86,7 +86,10 @@ To balance these requirements, numerous compromises have been made. To summarize
 	- [dist/](dist/) (`https://cdn.jsdelivr.net/gh/jaandrle/deka-dom-el/dist/`…)
 
 ## Signals
-- [Signals — whats going on behind the scenes \| by Ryan Hoffnan \| ITNEXT](https://itnext.io/signals-whats-going-on-behind-the-scenes-ec858589ea63)
+- [Signals — whats going on behind the scenes \| by Ryan Hoffnan \|
-- [The Evolution of Signals in JavaScript - DEV Community](https://dev.to/this-is-learning/the-evolution-of-signals-in-javascript-8ob)
+	ITNEXT](https://itnext.io/signals-whats-going-on-behind-the-scenes-ec858589ea63)
-- there is also [tc39/proposal-signals: A proposal to add signals to JavaScript.](https://github.com/tc39/proposal-signals)
+- [The Evolution of Signals in JavaScript - DEV
+	Community](https://dev.to/this-is-learning/the-evolution-of-signals-in-javascript-8ob)
+- there is also [tc39/proposal-signals:
+	A proposal to add signals to JavaScript.](https://github.com/tc39/proposal-signals)
 - [Observer pattern - Wikipedia](https://en.wikipedia.org/wiki/Observer_pattern)

bs/build.js

@@ -1,71 +1,37 @@
 #!/usr/bin/env -S npx nodejsscript
-import { bundle as bundleDTS } from "dts-bundler";
+import { build } from "./dev/.build.js"
 const files= [ "index", "index-with-signals" ];
-const filesOut= (file, mark= "esm")=> "dist/"+file.replace("index", mark);
-const css= echo.css`
-	.info{ color: gray; }
-`;
 
-$.api("", true)
+$.api("")
-.option("--minify", "Level of minification [ no, full, partial (default) ]")
+.command("main", "Build main files", { default: true })
-.action(async function main({ minify= "partial" }){
+.action(async function main(){
-	for(const file_root of files){
+	const regular = await build({
-		const file= file_root+".js";
+		files,
-		echo("Processing: "+ file);
+		filesOut,
-		const out= filesOut(file);
+		minify: "no",
-		const esbuild_output= s.$().run([
+	});
-			"npx esbuild '::file::'",
+	const min = await build({
-			"--platform=neutral",
+		files,
-			"--bundle",
+		filesOut(file, mark= "esm"){
-			minifyOption(minify),
+			const out= filesOut(file, mark);
-			"--legal-comments=inline",
+			const idx= out.lastIndexOf(".");
-			"--packages=external",
+			return out.slice(0, idx)+".min"+out.slice(idx);
-			"--outfile='::out::'"
+		},
-		].filter(Boolean).join(" "), { file, out });
+		minify: "full",
-		if(esbuild_output.code)
+	});
-			return $.exit(esbuild_output.code, echo(esbuild_output.stderr));
+	return $.exit(regular + min);
-		echoVariant(esbuild_output.stderr.split("\n")[1].trim()+ " (esbuild)");
+})
-		pipe(
+.command("signals", "Build only signals (for example for analysis)")
-			f=> f.replace(/^ +/gm, m=> "\t".repeat(m.length/2)),
+.action(async function signals(){
-			f=> s.echo(f).to(out)
+	const regular = await build({
-		)(s.cat(out));
+		files: [ "signals" ],
-
+		filesOut(file){ return "dist/."+file; },
-		const file_dts= file_root+".d.ts";
+		minify: "no",
-		const file_dts_out= filesOut(file_dts);
+		dde: false,
-		echoVariant(file_dts_out);
+	});
-		s.echo(bundleDTS(file_dts)).to(file_dts_out);
+	return $.exit(regular);
-
-		await toDDE(out, file_root);
-	}
-	$.exit(0);
-
-	async function toDDE(file, file_root){
-		const name= "dde";
-		const out= filesOut(file_root+".js", name);
-		echoVariant(`${out} (${file} → globalThis.${name})`)
-
-		let content= s.cat(file).toString().split(/export ?{/);
-		content.splice(1, 0, `\nglobalThis.${name}= {`);
-		content[2]= content[2]
-			.replace(/,(?!\n)/g, ",\n")
-			.replace(/(?<!\n)}/, "\n}")
-			.replace(/^(\t*)(.*) as ([^,\n]*)(,?)$/mg, "$1$3: $2$4");
-		s.echo([
-			`//deka-dom-el library is available via global namespace \`${name}\``,
-			"(()=> {",
-			content.join(""),
-			"})();"
-		].join("\n")).to(out);
-	}
 })
 .parse();
 
-/** @param {"no"|"full"|"partial"} level */
+
-function minifyOption(level= "partial"){
+function filesOut(file, mark= "esm"){ return "dist/"+file.replace("index", mark); }
-	if("no"===level) return undefined;
-	if("full"===level) return "--minify";
-	return "--minify-syntax --minify-identifiers";
-}
-function echoVariant(name){
-	return echo("%c✓ "+name, css.info+css);
-}

bs/dev/.build.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env -S npx nodejsscript
+import { bundle as bundleDTS } from "dts-bundler";
+const css= echo.css`
+	.info{ color: gray; }
+`;
+
+export async function build({ files, filesOut, minify= "partiala", dde= true }){
+	for(const file_root of files){
+		const file= file_root+".js";
+		echo(`Processing ${file} (minified: ${minify})`);
+		const out= filesOut(file);
+		const esbuild_output= s.$().run([
+			"npx esbuild '::file::'",
+			"--platform=neutral",
+			"--bundle",
+			minifyOption(minify),
+			"--legal-comments=inline",
+			"--packages=external",
+			"--outfile='::out::'"
+		].filter(Boolean).join(" "), { file, out });
+		if(esbuild_output.code)
+			return $.exit(esbuild_output.code, echo(esbuild_output.stderr));
+		echoVariant(esbuild_output.stderr.split("\n")[1].trim()+ " (esbuild)");
+		pipe(
+			f=> f.replace(/^ +/gm, m=> "\t".repeat(m.length/2)),
+			f=> s.echo(f).to(out)
+		)(s.cat(out));
+
+		const file_dts= file_root+".d.ts";
+		const file_dts_out= filesOut(file_dts);
+		echoVariant(file_dts_out);
+		s.echo(bundleDTS(file_dts)).to(file_dts_out);
+
+		if(dde) await toDDE(out, file_root);
+	}
+	return 0;
+
+	async function toDDE(file, file_root){
+		const name= "dde";
+		const out= filesOut(file_root+".js", name);
+		echoVariant(`${out} (${file} → globalThis.${name})`)
+
+		let content= s.cat(file).toString().split(/export ?{/);
+		content.splice(1, 0, `\nglobalThis.${name}= {`);
+		content[2]= content[2]
+			.replace(/,(?!\n)/g, ",\n")
+			.replace(/(?<!\n)}/, "\n}")
+			.replace(/^(\t*)(.*) as ([^,\n]*)(,?)$/mg, "$1$3: $2$4");
+		s.echo([
+			`//deka-dom-el library is available via global namespace \`${name}\``,
+			"(()=> {",
+			content.join(""),
+			"})();"
+		].join("\n")).to(out);
+	}
+}
+/** @param {"no"|"full"|"partial"} level */
+function minifyOption(level= "partial"){
+	if("no"===level) return undefined;
+	if("full"===level) return "--minify";
+	return "--minify-syntax --minify-identifiers";
+}
+function echoVariant(name){
+	return echo("%c✓ "+name, css.info+css);
+}

dist/dde-with-signals.js

@@ -461,7 +461,6 @@ function connectionsChangesObserverConstructor() {
 		offDisconnected(element, listener) {
 			if (!store.has(element)) return;
 			const ls = store.get(element);
-			if (!ls.disconnected.has(listener)) return;
 			ls.disconnected.delete(listener);
 			ls.length_d -= 1;
 			cleanWhenOff(element, ls);

dist/dde.js

@@ -438,7 +438,6 @@ function connectionsChangesObserverConstructor() {
 		offDisconnected(element, listener) {
 			if (!store.has(element)) return;
 			const ls = store.get(element);
-			if (!ls.disconnected.has(listener)) return;
 			ls.disconnected.delete(listener);
 			ls.length_d -= 1;
 			cleanWhenOff(element, ls);

dist/esm-with-signals.d.min.ts

@@ -0,0 +1,593 @@
+declare global{ /* ddeSignal */ }
+type CustomElementTagNameMap= { '#text': Text, '#comment': Comment }
+type SupportedElement=
+		HTMLElementTagNameMap[keyof HTMLElementTagNameMap]
+	|	SVGElementTagNameMap[keyof SVGElementTagNameMap]
+	|	MathMLElementTagNameMap[keyof MathMLElementTagNameMap]
+	|	CustomElementTagNameMap[keyof CustomElementTagNameMap]
+declare global {
+	type ddeComponentAttributes= Record<any, any> | undefined;
+	type ddeElementAddon<El extends SupportedElement | DocumentFragment | Node>= (element: El)=> any;
+	type ddeString= string | ddeSignal<string>
+	type ddeStringable= ddeString | number | ddeSignal<number>
+}
+type PascalCase=
+`${Capitalize<string>}${string}`;
+type AttrsModified= {
+	/**
+	 * Use string like in HTML (internally uses `*.setAttribute("style", *)`), or object representation (like DOM API).
+	 */
+	style: Partial<CSSStyleDeclaration> | ddeString
+		| Partial<{ [K in keyof CSSStyleDeclaration]: ddeSignal<CSSStyleDeclaration[K]> }>
+	/**
+	 * Provide option to add/remove/toggle CSS clasess (index of object) using 1/0/-1.
+	 * In fact `el.classList.toggle(class_name)` for `-1` and `el.classList.toggle(class_name, Boolean(...))`
+	 * for others.
+	 */
+	classList: Record<string,-1|0|1|boolean|ddeSignal<-1|0|1|boolean>>,
+	/**
+	 * Used by the dataset HTML attribute to represent data for custom attributes added to elements.
+	 * Values are converted to string (see {@link DOMStringMap}).
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMStringMap)
+	 * */
+	dataset: Record<string, ddeStringable>,
+	/**
+	 * Sets `aria-*` simiraly to `dataset`
+	 * */
+	ariaset: Record<string, ddeString>,
+}	& Record<`=${string}` | `data${PascalCase}` | `aria${PascalCase}`, ddeString>
+	& Record<`.${string}`, any>
+type _fromElsInterfaces<EL extends SupportedElement>= Omit<EL, keyof AttrsModified>;
+type IsReadonly<T, K extends keyof T> =
+	T extends { readonly [P in K]: T[K] } ? true : false;
+/**
+ * Just element attributtes
+ *
+ * In most cases, you can use native propertie such as
+ * [MDN WEB/API/Element](https://developer.mozilla.org/en-US/docs/Web/API/Element) and so on
+ * (e.g. [`Text`](https://developer.mozilla.org/en-US/docs/Web/API/Text)).
+ *
+ * There is added support for `data[A-Z].*`/`aria[A-Z].*` to be converted to the kebab-case alternatives.
+ * @private
+ */
+type ElementAttributes<T extends SupportedElement>= Partial<{
+	[K in keyof _fromElsInterfaces<T>]:
+		_fromElsInterfaces<T>[K] extends ((...p: any[])=> any)
+			? _fromElsInterfaces<T>[K] | ((...p: Parameters<_fromElsInterfaces<T>[K]>)=> ddeSignal<ReturnType<_fromElsInterfaces<T>[K]>>)
+			: (IsReadonly<_fromElsInterfaces<T>, K> extends false
+				? _fromElsInterfaces<T>[K] | ddeSignal<_fromElsInterfaces<T>[K]>
+				: ddeStringable)
+} & AttrsModified> & Record<string, any>;
+export function classListDeclarative<El extends SupportedElement>(
+	element: El,
+	classList: AttrsModified["classList"]
+): El
+export function assign<El extends SupportedElement>(element: El, ...attrs_array: ElementAttributes<El>[]): El
+export function assignAttribute<El extends SupportedElement, ATT extends keyof ElementAttributes<El>>(
+	element: El,
+	attr: ATT,
+	value: ElementAttributes<El>[ATT]
+): ElementAttributes<El>[ATT]
+
+type ExtendedHTMLElementTagNameMap= HTMLElementTagNameMap & CustomElementTagNameMap;
+export function el<
+	TAG extends keyof ExtendedHTMLElementTagNameMap,
+>(
+	tag_name: TAG,
+	attrs?: ElementAttributes<ExtendedHTMLElementTagNameMap[NoInfer<TAG>]> | ddeStringable,
+	...addons: ddeElementAddon<
+		ExtendedHTMLElementTagNameMap[NoInfer<TAG>]
+	>[], // TODO: for now addons must have the same element
+): TAG extends keyof ddeHTMLElementTagNameMap ? ddeHTMLElementTagNameMap[TAG] : ddeHTMLElement
+export function el(
+	tag_name?: "<>",
+): ddeDocumentFragment
+export function el(
+	tag_name: string,
+	attrs?: ElementAttributes<HTMLElement> | ddeStringable,
+	...addons: ddeElementAddon<HTMLElement>[]
+): ddeHTMLElement
+
+export function el<
+	C extends (attr: ddeComponentAttributes)=> SupportedElement | ddeDocumentFragment
+>(
+	component: C,
+	attrs?: Parameters<C>[0] | ddeStringable,
+	...addons: ddeElementAddon<ReturnType<C>>[]
+): ReturnType<C> extends ddeHTMLElementTagNameMap[keyof ddeHTMLElementTagNameMap]
+	? ReturnType<C>
+	: ( ReturnType<C> extends ddeDocumentFragment ? ReturnType<C> : ddeHTMLElement )
+export { el as createElement }
+
+export function elNS(
+	namespace: "http://www.w3.org/2000/svg"
+): <
+	TAG extends keyof SVGElementTagNameMap & string,
+	EL extends ( TAG extends keyof SVGElementTagNameMap ? SVGElementTagNameMap[TAG] : SVGElement ),
+>(
+	tag_name: TAG,
+	attrs?: ElementAttributes<NoInfer<EL>> | ddeStringable,
+	...addons: ddeElementAddon<NoInfer<EL>>[]
+)=>  TAG extends keyof ddeSVGElementTagNameMap ? ddeSVGElementTagNameMap[TAG] : ddeSVGElement
+export function elNS(
+	namespace: "http://www.w3.org/1998/Math/MathML"
+): <
+	TAG extends keyof MathMLElementTagNameMap & string,
+	EL extends ( TAG extends keyof MathMLElementTagNameMap ? MathMLElementTagNameMap[TAG] : MathMLElement ),
+>(
+	tag_name: TAG,
+	attrs?: ddeStringable | Partial<{
+		[key in keyof EL]: EL[key] | ddeSignal<EL[key]> | string | number | boolean
+	}>,
+	...addons: ddeElementAddon<NoInfer<EL>>[]
+)=> ddeMathMLElement
+export function elNS(
+	namespace: string
+): (
+	tag_name: string,
+	attrs?: string | ddeStringable | Record<string, any>,
+	...addons: ddeElementAddon<SupportedElement>[]
+)=> SupportedElement
+export { elNS as createElementNS }
+
+export function chainableAppend<EL extends SupportedElement>(el: EL): EL;
+/** Simulate slots for ddeComponents */
+export function simulateSlots<EL extends SupportedElement | DocumentFragment>(
+	root: EL,
+): EL
+/**
+ * Simulate slots in Custom Elements without using `shadowRoot`.
+ * @param el Custom Element root element
+ * @param body Body of the custom element
+ * */
+export function simulateSlots<EL extends SupportedElement | DocumentFragment>(
+	el: HTMLElement,
+	body: EL,
+): EL
+
+export function dispatchEvent(name: keyof DocumentEventMap | string, options?: EventInit):
+	(element: SupportedElement, data?: any)=> void;
+export function dispatchEvent(
+	name: keyof DocumentEventMap | string,
+	options: EventInit | null,
+	element: SupportedElement | (()=> SupportedElement)
+): (data?: any)=> void;
+interface On{
+	/** Listens to the DOM event. See {@link Document.addEventListener} */
+	<
+		Event extends keyof DocumentEventMap,
+		EE extends ddeElementAddon<SupportedElement>= ddeElementAddon<HTMLElement>,
+		>(
+			type: Event,
+			listener: (this: EE extends ddeElementAddon<infer El> ? El : never, ev: DocumentEventMap[Event]) => any,
+			options?: AddEventListenerOptions
+		) : EE;
+	<
+		EE extends ddeElementAddon<SupportedElement>= ddeElementAddon<HTMLElement>,
+		>(
+			type: string,
+			listener: (this: EE extends ddeElementAddon<infer El> ? El : never, ev: Event | CustomEvent ) => any,
+			options?: AddEventListenerOptions
+		) : EE;
+	/** Listens to the element is connected to the live DOM. In case of custom elements uses [`connectedCallback`](https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_custom_elements#custom_element_lifecycle_callbacks), or {@link MutationObserver} else where */// editorconfig-checker-disable-line
+	connected<
+		EE extends ddeElementAddon<SupportedElement>,
+		El extends ( EE extends ddeElementAddon<infer El> ? El : never )
+		>(
+			listener: (this: El, event: CustomEvent<El>) => any,
+			options?: AddEventListenerOptions
+		) : EE;
+	/** Listens to the element is disconnected from the live DOM. In case of custom elements uses [`disconnectedCallback`](https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_custom_elements#custom_element_lifecycle_callbacks), or {@link MutationObserver} else where */// editorconfig-checker-disable-line
+	disconnected<
+		EE extends ddeElementAddon<SupportedElement>,
+		El extends ( EE extends ddeElementAddon<infer El> ? El : never )
+		>(
+			listener: (this: El, event: CustomEvent<void>) => any,
+			options?: AddEventListenerOptions
+		) : EE;
+	/** Listens to the element attribute changes. In case of custom elements uses [`attributeChangedCallback`](https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_custom_elements#custom_element_lifecycle_callbacks), or {@link MutationObserver} else where */// editorconfig-checker-disable-line
+	attributeChanged<
+		EE extends ddeElementAddon<SupportedElement>,
+		El extends ( EE extends ddeElementAddon<infer El> ? El : never )
+		>(
+			listener: (this: El, event: CustomEvent<[ string, string ]>) => any,
+			options?: AddEventListenerOptions
+		) : EE;
+}
+export const on: On;
+
+type Scope= {
+	scope: Node | Function | Object,
+	host: ddeElementAddon<any>,
+	custom_element: false | HTMLElement,
+	prevent: boolean
+};
+/** Current scope created last time the `el(Function)` was invoke. (Or {@link scope.push}) */
+export const scope: {
+	current: Scope,
+	/** Stops all automatizations. E. g. signals used as attributes in current scope
+	 * registers removing these listeners (and clean signal if no other listeners are detected)
+	 * on `disconnected` event. */
+	preventDefault<T extends boolean>(prevent: T): T,
+	/**
+	 * This represents reference to the current host element — `scope.host()`.
+	 * It can be also used to register Addon(s) (functions to be called when component is initized)
+	 * — `scope.host(on.connected(console.log))`.
+	 * */
+	host: (...addons: ddeElementAddon<SupportedElement>[])=> HTMLElement,
+
+	state: Scope[],
+	/** Adds new child scope. All attributes are inherited by default. */
+	push(scope: Partial<Scope>): ReturnType<Array<Scope>["push"]>,
+	/** Adds root scope as a child of the current scope. */
+	pushRoot(): ReturnType<Array<Scope>["push"]>,
+	/** Removes last/current child scope. */
+	pop(): ReturnType<Array<Scope>["pop"]>,
+};
+
+export function customElementRender<
+	EL extends HTMLElement,
+	P extends any = Record<string, string | ddeSignal<string>>
+>(
+	target: ShadowRoot | EL,
+	render: (props: P)=> SupportedElement | DocumentFragment,
+	props?: P | ((el: EL)=> P)
+): EL
+export function customElementWithDDE<EL extends (new ()=> HTMLElement)>(custom_element: EL): EL
+export function lifecyclesToEvents<EL extends (new ()=> HTMLElement)>(custom_element: EL): EL
+export function observedAttributes(custom_element: HTMLElement): Record<string, string>
+
+/* TypeScript MEH */
+declare global{
+	type ddeAppend<el>= (...nodes: (Node | string)[])=> el;
+
+	interface ddeDocumentFragment extends DocumentFragment{ append: ddeAppend<ddeDocumentFragment>; }
+	interface ddeHTMLElement extends HTMLElement{ append: ddeAppend<ddeHTMLElement>; }
+	interface ddeSVGElement extends SVGElement{ append: ddeAppend<ddeSVGElement>; }
+	interface ddeMathMLElement extends MathMLElement{ append: ddeAppend<ddeMathMLElement>; }
+
+	interface ddeHTMLElementTagNameMap {
+		"a": ddeHTMLAnchorElement;
+		"area": ddeHTMLAreaElement;
+		"audio": ddeHTMLAudioElement;
+		"base": ddeHTMLBaseElement;
+		"blockquote": ddeHTMLQuoteElement;
+		"body": ddeHTMLBodyElement;
+		"br": ddeHTMLBRElement;
+		"button": ddeHTMLButtonElement;
+		"canvas": ddeHTMLCanvasElement;
+		"caption": ddeHTMLTableCaptionElement;
+		"col": ddeHTMLTableColElement;
+		"colgroup": ddeHTMLTableColElement;
+		"data": ddeHTMLDataElement;
+		"datalist": ddeHTMLDataListElement;
+		"del": ddeHTMLModElement;
+		"details": ddeHTMLDetailsElement;
+		"dialog": ddeHTMLDialogElement;
+		"div": ddeHTMLDivElement;
+		"dl": ddeHTMLDListElement;
+		"embed": ddeHTMLEmbedElement;
+		"fieldset": ddeHTMLFieldSetElement;
+		"form": ddeHTMLFormElement;
+		"h1": ddeHTMLHeadingElement;
+		"h2": ddeHTMLHeadingElement;
+		"h3": ddeHTMLHeadingElement;
+		"h4": ddeHTMLHeadingElement;
+		"h5": ddeHTMLHeadingElement;
+		"h6": ddeHTMLHeadingElement;
+		"head": ddeHTMLHeadElement;
+		"hr": ddeHTMLHRElement;
+		"html": ddeHTMLHtmlElement;
+		"iframe": ddeHTMLIFrameElement;
+		"img": ddeHTMLImageElement;
+		"input": ddeHTMLInputElement;
+		"ins": ddeHTMLModElement;
+		"label": ddeHTMLLabelElement;
+		"legend": ddeHTMLLegendElement;
+		"li": ddeHTMLLIElement;
+		"link": ddeHTMLLinkElement;
+		"map": ddeHTMLMapElement;
+		"menu": ddeHTMLMenuElement;
+		"meta": ddeHTMLMetaElement;
+		"meter": ddeHTMLMeterElement;
+		"object": ddeHTMLObjectElement;
+		"ol": ddeHTMLOListElement;
+		"optgroup": ddeHTMLOptGroupElement;
+		"option": ddeHTMLOptionElement;
+		"output": ddeHTMLOutputElement;
+		"p": ddeHTMLParagraphElement;
+		"picture": ddeHTMLPictureElement;
+		"pre": ddeHTMLPreElement;
+		"progress": ddeHTMLProgressElement;
+		"q": ddeHTMLQuoteElement;
+		"script": ddeHTMLScriptElement;
+		"select": ddeHTMLSelectElement;
+		"slot": ddeHTMLSlotElement;
+		"source": ddeHTMLSourceElement;
+		"span": ddeHTMLSpanElement;
+		"style": ddeHTMLStyleElement;
+		"table": ddeHTMLTableElement;
+		"tbody": ddeHTMLTableSectionElement;
+		"td": ddeHTMLTableCellElement;
+		"template": ddeHTMLTemplateElement;
+		"textarea": ddeHTMLTextAreaElement;
+		"tfoot": ddeHTMLTableSectionElement;
+		"th": ddeHTMLTableCellElement;
+		"thead": ddeHTMLTableSectionElement;
+		"time": ddeHTMLTimeElement;
+		"title": ddeHTMLTitleElement;
+		"tr": ddeHTMLTableRowElement;
+		"track": ddeHTMLTrackElement;
+		"ul": ddeHTMLUListElement;
+		"video": ddeHTMLVideoElement;
+	}
+	interface ddeSVGElementTagNameMap {
+		"a": ddeSVGAElement;
+		"animate": ddeSVGAnimateElement;
+		"animateMotion": ddeSVGAnimateMotionElement;
+		"animateTransform": ddeSVGAnimateTransformElement;
+		"circle": ddeSVGCircleElement;
+		"clipPath": ddeSVGClipPathElement;
+		"defs": ddeSVGDefsElement;
+		"desc": ddeSVGDescElement;
+		"ellipse": ddeSVGEllipseElement;
+		"feBlend": ddeSVGFEBlendElement;
+		"feColorMatrix": ddeSVGFEColorMatrixElement;
+		"feComponentTransfer": ddeSVGFEComponentTransferElement;
+		"feComposite": ddeSVGFECompositeElement;
+		"feConvolveMatrix": ddeSVGFEConvolveMatrixElement;
+		"feDiffuseLighting": ddeSVGFEDiffuseLightingElement;
+		"feDisplacementMap": ddeSVGFEDisplacementMapElement;
+		"feDistantLight": ddeSVGFEDistantLightElement;
+		"feDropShadow": ddeSVGFEDropShadowElement;
+		"feFlood": ddeSVGFEFloodElement;
+		"feFuncA": ddeSVGFEFuncAElement;
+		"feFuncB": ddeSVGFEFuncBElement;
+		"feFuncG": ddeSVGFEFuncGElement;
+		"feFuncR": ddeSVGFEFuncRElement;
+		"feGaussianBlur": ddeSVGFEGaussianBlurElement;
+		"feImage": ddeSVGFEImageElement;
+		"feMerge": ddeSVGFEMergeElement;
+		"feMergeNode": ddeSVGFEMergeNodeElement;
+		"feMorphology": ddeSVGFEMorphologyElement;
+		"feOffset": ddeSVGFEOffsetElement;
+		"fePointLight": ddeSVGFEPointLightElement;
+		"feSpecularLighting": ddeSVGFESpecularLightingElement;
+		"feSpotLight": ddeSVGFESpotLightElement;
+		"feTile": ddeSVGFETileElement;
+		"feTurbulence": ddeSVGFETurbulenceElement;
+		"filter": ddeSVGFilterElement;
+		"foreignObject": ddeSVGForeignObjectElement;
+		"g": ddeSVGGElement;
+		"image": ddeSVGImageElement;
+		"line": ddeSVGLineElement;
+		"linearGradient": ddeSVGLinearGradientElement;
+		"marker": ddeSVGMarkerElement;
+		"mask": ddeSVGMaskElement;
+		"metadata": ddeSVGMetadataElement;
+		"mpath": ddeSVGMPathElement;
+		"path": ddeSVGPathElement;
+		"pattern": ddeSVGPatternElement;
+		"polygon": ddeSVGPolygonElement;
+		"polyline": ddeSVGPolylineElement;
+		"radialGradient": ddeSVGRadialGradientElement;
+		"rect": ddeSVGRectElement;
+		"script": ddeSVGScriptElement;
+		"set": ddeSVGSetElement;
+		"stop": ddeSVGStopElement;
+		"style": ddeSVGStyleElement;
+		"svg": ddeSVGSVGElement;
+		"switch": ddeSVGSwitchElement;
+		"symbol": ddeSVGSymbolElement;
+		"text": ddeSVGTextElement;
+		"textPath": ddeSVGTextPathElement;
+		"title": ddeSVGTitleElement;
+		"tspan": ddeSVGTSpanElement;
+		"use": ddeSVGUseElement;
+		"view": ddeSVGViewElement;
+	}
+}
+
+// editorconfig-checker-disable
+interface ddeHTMLAnchorElement extends HTMLAnchorElement{ append: ddeAppend<ddeHTMLAnchorElement>; }
+interface ddeHTMLAreaElement extends HTMLAreaElement{ append: ddeAppend<ddeHTMLAreaElement>; }
+interface ddeHTMLAudioElement extends HTMLAudioElement{ append: ddeAppend<ddeHTMLAudioElement>; }
+interface ddeHTMLBaseElement extends HTMLBaseElement{ append: ddeAppend<ddeHTMLBaseElement>; }
+interface ddeHTMLQuoteElement extends HTMLQuoteElement{ append: ddeAppend<ddeHTMLQuoteElement>; }
+interface ddeHTMLBodyElement extends HTMLBodyElement{ append: ddeAppend<ddeHTMLBodyElement>; }
+interface ddeHTMLBRElement extends HTMLBRElement{ append: ddeAppend<ddeHTMLBRElement>; }
+interface ddeHTMLButtonElement extends HTMLButtonElement{ append: ddeAppend<ddeHTMLButtonElement>; }
+interface ddeHTMLCanvasElement extends HTMLCanvasElement{ append: ddeAppend<ddeHTMLCanvasElement>; }
+interface ddeHTMLTableCaptionElement extends HTMLTableCaptionElement{ append: ddeAppend<ddeHTMLTableCaptionElement>; }
+interface ddeHTMLTableColElement extends HTMLTableColElement{ append: ddeAppend<ddeHTMLTableColElement>; }
+interface ddeHTMLTableColElement extends HTMLTableColElement{ append: ddeAppend<ddeHTMLTableColElement>; }
+interface ddeHTMLDataElement extends HTMLDataElement{ append: ddeAppend<ddeHTMLDataElement>; }
+interface ddeHTMLDataListElement extends HTMLDataListElement{ append: ddeAppend<ddeHTMLDataListElement>; }
+interface ddeHTMLModElement extends HTMLModElement{ append: ddeAppend<ddeHTMLModElement>; }
+interface ddeHTMLDetailsElement extends HTMLDetailsElement{ append: ddeAppend<ddeHTMLDetailsElement>; }
+interface ddeHTMLDialogElement extends HTMLDialogElement{ append: ddeAppend<ddeHTMLDialogElement>; }
+interface ddeHTMLDivElement extends HTMLDivElement{ append: ddeAppend<ddeHTMLDivElement>; }
+interface ddeHTMLDListElement extends HTMLDListElement{ append: ddeAppend<ddeHTMLDListElement>; }
+interface ddeHTMLEmbedElement extends HTMLEmbedElement{ append: ddeAppend<ddeHTMLEmbedElement>; }
+interface ddeHTMLFieldSetElement extends HTMLFieldSetElement{ append: ddeAppend<ddeHTMLFieldSetElement>; }
+interface ddeHTMLFormElement extends HTMLFormElement{ append: ddeAppend<ddeHTMLFormElement>; }
+interface ddeHTMLHeadingElement extends HTMLHeadingElement{ append: ddeAppend<ddeHTMLHeadingElement>; }
+interface ddeHTMLHeadElement extends HTMLHeadElement{ append: ddeAppend<ddeHTMLHeadElement>; }
+interface ddeHTMLHRElement extends HTMLHRElement{ append: ddeAppend<ddeHTMLHRElement>; }
+interface ddeHTMLHtmlElement extends HTMLHtmlElement{ append: ddeAppend<ddeHTMLHtmlElement>; }
+interface ddeHTMLIFrameElement extends HTMLIFrameElement{ append: ddeAppend<ddeHTMLIFrameElement>; }
+interface ddeHTMLImageElement extends HTMLImageElement{ append: ddeAppend<ddeHTMLImageElement>; }
+interface ddeHTMLInputElement extends HTMLInputElement{ append: ddeAppend<ddeHTMLInputElement>; }
+interface ddeHTMLLabelElement extends HTMLLabelElement{ append: ddeAppend<ddeHTMLLabelElement>; }
+interface ddeHTMLLegendElement extends HTMLLegendElement{ append: ddeAppend<ddeHTMLLegendElement>; }
+interface ddeHTMLLIElement extends HTMLLIElement{ append: ddeAppend<ddeHTMLLIElement>; }
+interface ddeHTMLLinkElement extends HTMLLinkElement{ append: ddeAppend<ddeHTMLLinkElement>; }
+interface ddeHTMLMapElement extends HTMLMapElement{ append: ddeAppend<ddeHTMLMapElement>; }
+interface ddeHTMLMenuElement extends HTMLMenuElement{ append: ddeAppend<ddeHTMLMenuElement>; }
+interface ddeHTMLMetaElement extends HTMLMetaElement{ append: ddeAppend<ddeHTMLMetaElement>; }
+interface ddeHTMLMeterElement extends HTMLMeterElement{ append: ddeAppend<ddeHTMLMeterElement>; }
+interface ddeHTMLObjectElement extends HTMLObjectElement{ append: ddeAppend<ddeHTMLObjectElement>; }
+interface ddeHTMLOListElement extends HTMLOListElement{ append: ddeAppend<ddeHTMLOListElement>; }
+interface ddeHTMLOptGroupElement extends HTMLOptGroupElement{ append: ddeAppend<ddeHTMLOptGroupElement>; }
+interface ddeHTMLOptionElement extends HTMLOptionElement{ append: ddeAppend<ddeHTMLOptionElement>; }
+interface ddeHTMLOutputElement extends HTMLOutputElement{ append: ddeAppend<ddeHTMLOutputElement>; }
+interface ddeHTMLParagraphElement extends HTMLParagraphElement{ append: ddeAppend<ddeHTMLParagraphElement>; }
+interface ddeHTMLPictureElement extends HTMLPictureElement{ append: ddeAppend<ddeHTMLPictureElement>; }
+interface ddeHTMLPreElement extends HTMLPreElement{ append: ddeAppend<ddeHTMLPreElement>; }
+interface ddeHTMLProgressElement extends HTMLProgressElement{ append: ddeAppend<ddeHTMLProgressElement>; }
+interface ddeHTMLScriptElement extends HTMLScriptElement{ append: ddeAppend<ddeHTMLScriptElement>; }
+interface ddeHTMLSelectElement extends HTMLSelectElement{ append: ddeAppend<ddeHTMLSelectElement>; }
+interface ddeHTMLSlotElement extends HTMLSlotElement{ append: ddeAppend<ddeHTMLSlotElement>; }
+interface ddeHTMLSourceElement extends HTMLSourceElement{ append: ddeAppend<ddeHTMLSourceElement>; }
+interface ddeHTMLSpanElement extends HTMLSpanElement{ append: ddeAppend<ddeHTMLSpanElement>; }
+interface ddeHTMLStyleElement extends HTMLStyleElement{ append: ddeAppend<ddeHTMLStyleElement>; }
+interface ddeHTMLTableElement extends HTMLTableElement{ append: ddeAppend<ddeHTMLTableElement>; }
+interface ddeHTMLTableSectionElement extends HTMLTableSectionElement{ append: ddeAppend<ddeHTMLTableSectionElement>; }
+interface ddeHTMLTableCellElement extends HTMLTableCellElement{ append: ddeAppend<ddeHTMLTableCellElement>; }
+interface ddeHTMLTemplateElement extends HTMLTemplateElement{ append: ddeAppend<ddeHTMLTemplateElement>; }
+interface ddeHTMLTextAreaElement extends HTMLTextAreaElement{ append: ddeAppend<ddeHTMLTextAreaElement>; }
+interface ddeHTMLTableCellElement extends HTMLTableCellElement{ append: ddeAppend<ddeHTMLTableCellElement>; }
+interface ddeHTMLTimeElement extends HTMLTimeElement{ append: ddeAppend<ddeHTMLTimeElement>; }
+interface ddeHTMLTitleElement extends HTMLTitleElement{ append: ddeAppend<ddeHTMLTitleElement>; }
+interface ddeHTMLTableRowElement extends HTMLTableRowElement{ append: ddeAppend<ddeHTMLTableRowElement>; }
+interface ddeHTMLTrackElement extends HTMLTrackElement{ append: ddeAppend<ddeHTMLTrackElement>; }
+interface ddeHTMLUListElement extends HTMLUListElement{ append: ddeAppend<ddeHTMLUListElement>; }
+interface ddeHTMLVideoElement extends HTMLVideoElement{ append: ddeAppend<ddeHTMLVideoElement>; }
+interface ddeSVGAElement extends SVGAElement{ append: ddeAppend<ddeSVGAElement>; }
+interface ddeSVGAnimateElement extends SVGAnimateElement{ append: ddeAppend<ddeSVGAnimateElement>; }
+interface ddeSVGAnimateMotionElement extends SVGAnimateMotionElement{ append: ddeAppend<ddeSVGAnimateMotionElement>; }
+interface ddeSVGAnimateTransformElement extends SVGAnimateTransformElement{ append: ddeAppend<ddeSVGAnimateTransformElement>; }
+interface ddeSVGCircleElement extends SVGCircleElement{ append: ddeAppend<ddeSVGCircleElement>; }
+interface ddeSVGClipPathElement extends SVGClipPathElement{ append: ddeAppend<ddeSVGClipPathElement>; }
+interface ddeSVGDefsElement extends SVGDefsElement{ append: ddeAppend<ddeSVGDefsElement>; }
+interface ddeSVGDescElement extends SVGDescElement{ append: ddeAppend<ddeSVGDescElement>; }
+interface ddeSVGEllipseElement extends SVGEllipseElement{ append: ddeAppend<ddeSVGEllipseElement>; }
+interface ddeSVGFEBlendElement extends SVGFEBlendElement{ append: ddeAppend<ddeSVGFEBlendElement>; }
+interface ddeSVGFEColorMatrixElement extends SVGFEColorMatrixElement{ append: ddeAppend<ddeSVGFEColorMatrixElement>; }
+interface ddeSVGFEComponentTransferElement extends SVGFEComponentTransferElement{ append: ddeAppend<ddeSVGFEComponentTransferElement>; }
+interface ddeSVGFECompositeElement extends SVGFECompositeElement{ append: ddeAppend<ddeSVGFECompositeElement>; }
+interface ddeSVGFEConvolveMatrixElement extends SVGFEConvolveMatrixElement{ append: ddeAppend<ddeSVGFEConvolveMatrixElement>; }
+interface ddeSVGFEDiffuseLightingElement extends SVGFEDiffuseLightingElement{ append: ddeAppend<ddeSVGFEDiffuseLightingElement>; }
+interface ddeSVGFEDisplacementMapElement extends SVGFEDisplacementMapElement{ append: ddeAppend<ddeSVGFEDisplacementMapElement>; }
+interface ddeSVGFEDistantLightElement extends SVGFEDistantLightElement{ append: ddeAppend<ddeSVGFEDistantLightElement>; }
+interface ddeSVGFEDropShadowElement extends SVGFEDropShadowElement{ append: ddeAppend<ddeSVGFEDropShadowElement>; }
+interface ddeSVGFEFloodElement extends SVGFEFloodElement{ append: ddeAppend<ddeSVGFEFloodElement>; }
+interface ddeSVGFEFuncAElement extends SVGFEFuncAElement{ append: ddeAppend<ddeSVGFEFuncAElement>; }
+interface ddeSVGFEFuncBElement extends SVGFEFuncBElement{ append: ddeAppend<ddeSVGFEFuncBElement>; }
+interface ddeSVGFEFuncGElement extends SVGFEFuncGElement{ append: ddeAppend<ddeSVGFEFuncGElement>; }
+interface ddeSVGFEFuncRElement extends SVGFEFuncRElement{ append: ddeAppend<ddeSVGFEFuncRElement>; }
+interface ddeSVGFEGaussianBlurElement extends SVGFEGaussianBlurElement{ append: ddeAppend<ddeSVGFEGaussianBlurElement>; }
+interface ddeSVGFEImageElement extends SVGFEImageElement{ append: ddeAppend<ddeSVGFEImageElement>; }
+interface ddeSVGFEMergeElement extends SVGFEMergeElement{ append: ddeAppend<ddeSVGFEMergeElement>; }
+interface ddeSVGFEMergeNodeElement extends SVGFEMergeNodeElement{ append: ddeAppend<ddeSVGFEMergeNodeElement>; }
+interface ddeSVGFEMorphologyElement extends SVGFEMorphologyElement{ append: ddeAppend<ddeSVGFEMorphologyElement>; }
+interface ddeSVGFEOffsetElement extends SVGFEOffsetElement{ append: ddeAppend<ddeSVGFEOffsetElement>; }
+interface ddeSVGFEPointLightElement extends SVGFEPointLightElement{ append: ddeAppend<ddeSVGFEPointLightElement>; }
+interface ddeSVGFESpecularLightingElement extends SVGFESpecularLightingElement{ append: ddeAppend<ddeSVGFESpecularLightingElement>; }
+interface ddeSVGFESpotLightElement extends SVGFESpotLightElement{ append: ddeAppend<ddeSVGFESpotLightElement>; }
+interface ddeSVGFETileElement extends SVGFETileElement{ append: ddeAppend<ddeSVGFETileElement>; }
+interface ddeSVGFETurbulenceElement extends SVGFETurbulenceElement{ append: ddeAppend<ddeSVGFETurbulenceElement>; }
+interface ddeSVGFilterElement extends SVGFilterElement{ append: ddeAppend<ddeSVGFilterElement>; }
+interface ddeSVGForeignObjectElement extends SVGForeignObjectElement{ append: ddeAppend<ddeSVGForeignObjectElement>; }
+interface ddeSVGGElement extends SVGGElement{ append: ddeAppend<ddeSVGGElement>; }
+interface ddeSVGImageElement extends SVGImageElement{ append: ddeAppend<ddeSVGImageElement>; }
+interface ddeSVGLineElement extends SVGLineElement{ append: ddeAppend<ddeSVGLineElement>; }
+interface ddeSVGLinearGradientElement extends SVGLinearGradientElement{ append: ddeAppend<ddeSVGLinearGradientElement>; }
+interface ddeSVGMarkerElement extends SVGMarkerElement{ append: ddeAppend<ddeSVGMarkerElement>; }
+interface ddeSVGMaskElement extends SVGMaskElement{ append: ddeAppend<ddeSVGMaskElement>; }
+interface ddeSVGMetadataElement extends SVGMetadataElement{ append: ddeAppend<ddeSVGMetadataElement>; }
+interface ddeSVGMPathElement extends SVGMPathElement{ append: ddeAppend<ddeSVGMPathElement>; }
+interface ddeSVGPathElement extends SVGPathElement{ append: ddeAppend<ddeSVGPathElement>; }
+interface ddeSVGPatternElement extends SVGPatternElement{ append: ddeAppend<ddeSVGPatternElement>; }
+interface ddeSVGPolygonElement extends SVGPolygonElement{ append: ddeAppend<ddeSVGPolygonElement>; }
+interface ddeSVGPolylineElement extends SVGPolylineElement{ append: ddeAppend<ddeSVGPolylineElement>; }
+interface ddeSVGRadialGradientElement extends SVGRadialGradientElement{ append: ddeAppend<ddeSVGRadialGradientElement>; }
+interface ddeSVGRectElement extends SVGRectElement{ append: ddeAppend<ddeSVGRectElement>; }
+interface ddeSVGScriptElement extends SVGScriptElement{ append: ddeAppend<ddeSVGScriptElement>; }
+interface ddeSVGSetElement extends SVGSetElement{ append: ddeAppend<ddeSVGSetElement>; }
+interface ddeSVGStopElement extends SVGStopElement{ append: ddeAppend<ddeSVGStopElement>; }
+interface ddeSVGStyleElement extends SVGStyleElement{ append: ddeAppend<ddeSVGStyleElement>; }
+interface ddeSVGSVGElement extends SVGSVGElement{ append: ddeAppend<ddeSVGSVGElement>; }
+interface ddeSVGSwitchElement extends SVGSwitchElement{ append: ddeAppend<ddeSVGSwitchElement>; }
+interface ddeSVGSymbolElement extends SVGSymbolElement{ append: ddeAppend<ddeSVGSymbolElement>; }
+interface ddeSVGTextElement extends SVGTextElement{ append: ddeAppend<ddeSVGTextElement>; }
+interface ddeSVGTextPathElement extends SVGTextPathElement{ append: ddeAppend<ddeSVGTextPathElement>; }
+interface ddeSVGTitleElement extends SVGTitleElement{ append: ddeAppend<ddeSVGTitleElement>; }
+interface ddeSVGTSpanElement extends SVGTSpanElement{ append: ddeAppend<ddeSVGTSpanElement>; }
+interface ddeSVGUseElement extends SVGUseElement{ append: ddeAppend<ddeSVGUseElement>; }
+interface ddeSVGViewElement extends SVGViewElement{ append: ddeAppend<ddeSVGViewElement>; }
+// editorconfig-checker-enable
+export interface Signal<V, A> {
+	/** The current value of the signal */
+	get(): V;
+	/** Set new value of the signal */
+	set(value: V): V;
+	toJSON(): V;
+	valueOf(): V;
+}
+type Action<V>= (this: { value: V, stopPropagation(): void }, ...a: any[])=> typeof signal._ | void;
+//type SymbolSignal= Symbol;
+type SymbolOnclear= symbol;
+type Actions<V>= Record<string | SymbolOnclear, Action<V>>;
+type OnListenerOptions= Pick<AddEventListenerOptions, "signal"> & { first_time?: boolean };
+interface signal{
+	_: Symbol
+	/**
+	 * Computations signal. This creates a signal which is computed from other signals.
+	 * */
+	<V extends ()=> any>(computation: V): Signal<ReturnType<V>, {}>
+	/**
+	 * Simple example:
+	 * ```js
+	 * const hello= S("Hello Signal");
+	 * ```
+	 * …simple todo signal:
+	 * ```js
+	 * const todos= S([], {
+	 * 	add(v){ this.value.push(S(v)); },
+	 * 	remove(i){ this.value.splice(i, 1); },
+	 * 	[S.symbols.onclear](){ S.clear(...this.value); },
+	 * });
+	 * ```
+	 * …computed signal:
+	 * ```js
+	 * const name= S("Jan");
+	 * const surname= S("Andrle");
+	 * const fullname= S(()=> name.get()+" "+surname.get());
+	 * ```
+	 * @param value Initial signal value. Or function computing value from other signals.
+	 * @param actions Use to define actions on the signal. Such as add item to the array.
+	 *		There is also a reserved function `S.symbol.onclear` which is called when the signal is cleared
+	 *		by `S.clear`.
+	 * */
+	<V, A extends Actions<V>>(value: V, actions?: A): Signal<V, A>;
+	action<S extends Signal<any, Actions<any>>, A extends (S extends Signal<any, infer A> ? A : never), N extends keyof A>(
+		signal: S,
+		name: N,
+		...params: A[N] extends (...args: infer P)=> any ? P : never
+	): void;
+	clear(...signals: Signal<any, any>[]): void;
+	on<T>(signal: Signal<T, any>, onchange: (a: T)=> void, options?: OnListenerOptions): void;
+	symbols: {
+		//signal: SymbolSignal;
+		onclear: SymbolOnclear;
+	}
+	/**
+	 * Reactive element, which is rendered based on the given signal.
+	 * ```js
+	 * S.el(signal, value=> value ? el("b", "True") : el("i", "False"));
+	 * S.el(listS, list=> list.map(li=> el("li", li)));
+	 * ```
+	 * */
+	el<S extends any>(signal: Signal<S, any>, el: (v: S)=> Element | Element[] | DocumentFragment): DocumentFragment;
+
+	observedAttributes(custom_element: HTMLElement): Record<string, Signal<string, {}>>;
+}
+export const signal: signal;
+export const S: signal;
+declare global {
+	type ddeSignal<T, A= {}>= Signal<T, A>;
+	type ddeAction<V>= Action<V>
+	type ddeActions<V>= Actions<V>
+}

dist/esm-with-signals.js

@@ -459,7 +459,6 @@ function connectionsChangesObserverConstructor() {
 		offDisconnected(element, listener) {
 			if (!store.has(element)) return;
 			const ls = store.get(element);
-			if (!ls.disconnected.has(listener)) return;
 			ls.disconnected.delete(listener);
 			ls.length_d -= 1;
 			cleanWhenOff(element, ls);

dist/esm.d.min.ts

@@ -0,0 +1,520 @@
+declare global{ /* ddeSignal */ }
+type CustomElementTagNameMap= { '#text': Text, '#comment': Comment }
+type SupportedElement=
+		HTMLElementTagNameMap[keyof HTMLElementTagNameMap]
+	|	SVGElementTagNameMap[keyof SVGElementTagNameMap]
+	|	MathMLElementTagNameMap[keyof MathMLElementTagNameMap]
+	|	CustomElementTagNameMap[keyof CustomElementTagNameMap]
+declare global {
+	type ddeComponentAttributes= Record<any, any> | undefined;
+	type ddeElementAddon<El extends SupportedElement | DocumentFragment | Node>= (element: El)=> any;
+	type ddeString= string | ddeSignal<string>
+	type ddeStringable= ddeString | number | ddeSignal<number>
+}
+type PascalCase=
+`${Capitalize<string>}${string}`;
+type AttrsModified= {
+	/**
+	 * Use string like in HTML (internally uses `*.setAttribute("style", *)`), or object representation (like DOM API).
+	 */
+	style: Partial<CSSStyleDeclaration> | ddeString
+		| Partial<{ [K in keyof CSSStyleDeclaration]: ddeSignal<CSSStyleDeclaration[K]> }>
+	/**
+	 * Provide option to add/remove/toggle CSS clasess (index of object) using 1/0/-1.
+	 * In fact `el.classList.toggle(class_name)` for `-1` and `el.classList.toggle(class_name, Boolean(...))`
+	 * for others.
+	 */
+	classList: Record<string,-1|0|1|boolean|ddeSignal<-1|0|1|boolean>>,
+	/**
+	 * Used by the dataset HTML attribute to represent data for custom attributes added to elements.
+	 * Values are converted to string (see {@link DOMStringMap}).
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMStringMap)
+	 * */
+	dataset: Record<string, ddeStringable>,
+	/**
+	 * Sets `aria-*` simiraly to `dataset`
+	 * */
+	ariaset: Record<string, ddeString>,
+}	& Record<`=${string}` | `data${PascalCase}` | `aria${PascalCase}`, ddeString>
+	& Record<`.${string}`, any>
+type _fromElsInterfaces<EL extends SupportedElement>= Omit<EL, keyof AttrsModified>;
+type IsReadonly<T, K extends keyof T> =
+	T extends { readonly [P in K]: T[K] } ? true : false;
+/**
+ * Just element attributtes
+ *
+ * In most cases, you can use native propertie such as
+ * [MDN WEB/API/Element](https://developer.mozilla.org/en-US/docs/Web/API/Element) and so on
+ * (e.g. [`Text`](https://developer.mozilla.org/en-US/docs/Web/API/Text)).
+ *
+ * There is added support for `data[A-Z].*`/`aria[A-Z].*` to be converted to the kebab-case alternatives.
+ * @private
+ */
+type ElementAttributes<T extends SupportedElement>= Partial<{
+	[K in keyof _fromElsInterfaces<T>]:
+		_fromElsInterfaces<T>[K] extends ((...p: any[])=> any)
+			? _fromElsInterfaces<T>[K] | ((...p: Parameters<_fromElsInterfaces<T>[K]>)=> ddeSignal<ReturnType<_fromElsInterfaces<T>[K]>>)
+			: (IsReadonly<_fromElsInterfaces<T>, K> extends false
+				? _fromElsInterfaces<T>[K] | ddeSignal<_fromElsInterfaces<T>[K]>
+				: ddeStringable)
+} & AttrsModified> & Record<string, any>;
+export function classListDeclarative<El extends SupportedElement>(
+	element: El,
+	classList: AttrsModified["classList"]
+): El
+export function assign<El extends SupportedElement>(element: El, ...attrs_array: ElementAttributes<El>[]): El
+export function assignAttribute<El extends SupportedElement, ATT extends keyof ElementAttributes<El>>(
+	element: El,
+	attr: ATT,
+	value: ElementAttributes<El>[ATT]
+): ElementAttributes<El>[ATT]
+
+type ExtendedHTMLElementTagNameMap= HTMLElementTagNameMap & CustomElementTagNameMap;
+export function el<
+	TAG extends keyof ExtendedHTMLElementTagNameMap,
+>(
+	tag_name: TAG,
+	attrs?: ElementAttributes<ExtendedHTMLElementTagNameMap[NoInfer<TAG>]> | ddeStringable,
+	...addons: ddeElementAddon<
+		ExtendedHTMLElementTagNameMap[NoInfer<TAG>]
+	>[], // TODO: for now addons must have the same element
+): TAG extends keyof ddeHTMLElementTagNameMap ? ddeHTMLElementTagNameMap[TAG] : ddeHTMLElement
+export function el(
+	tag_name?: "<>",
+): ddeDocumentFragment
+export function el(
+	tag_name: string,
+	attrs?: ElementAttributes<HTMLElement> | ddeStringable,
+	...addons: ddeElementAddon<HTMLElement>[]
+): ddeHTMLElement
+
+export function el<
+	C extends (attr: ddeComponentAttributes)=> SupportedElement | ddeDocumentFragment
+>(
+	component: C,
+	attrs?: Parameters<C>[0] | ddeStringable,
+	...addons: ddeElementAddon<ReturnType<C>>[]
+): ReturnType<C> extends ddeHTMLElementTagNameMap[keyof ddeHTMLElementTagNameMap]
+	? ReturnType<C>
+	: ( ReturnType<C> extends ddeDocumentFragment ? ReturnType<C> : ddeHTMLElement )
+export { el as createElement }
+
+export function elNS(
+	namespace: "http://www.w3.org/2000/svg"
+): <
+	TAG extends keyof SVGElementTagNameMap & string,
+	EL extends ( TAG extends keyof SVGElementTagNameMap ? SVGElementTagNameMap[TAG] : SVGElement ),
+>(
+	tag_name: TAG,
+	attrs?: ElementAttributes<NoInfer<EL>> | ddeStringable,
+	...addons: ddeElementAddon<NoInfer<EL>>[]
+)=>  TAG extends keyof ddeSVGElementTagNameMap ? ddeSVGElementTagNameMap[TAG] : ddeSVGElement
+export function elNS(
+	namespace: "http://www.w3.org/1998/Math/MathML"
+): <
+	TAG extends keyof MathMLElementTagNameMap & string,
+	EL extends ( TAG extends keyof MathMLElementTagNameMap ? MathMLElementTagNameMap[TAG] : MathMLElement ),
+>(
+	tag_name: TAG,
+	attrs?: ddeStringable | Partial<{
+		[key in keyof EL]: EL[key] | ddeSignal<EL[key]> | string | number | boolean
+	}>,
+	...addons: ddeElementAddon<NoInfer<EL>>[]
+)=> ddeMathMLElement
+export function elNS(
+	namespace: string
+): (
+	tag_name: string,
+	attrs?: string | ddeStringable | Record<string, any>,
+	...addons: ddeElementAddon<SupportedElement>[]
+)=> SupportedElement
+export { elNS as createElementNS }
+
+export function chainableAppend<EL extends SupportedElement>(el: EL): EL;
+/** Simulate slots for ddeComponents */
+export function simulateSlots<EL extends SupportedElement | DocumentFragment>(
+	root: EL,
+): EL
+/**
+ * Simulate slots in Custom Elements without using `shadowRoot`.
+ * @param el Custom Element root element
+ * @param body Body of the custom element
+ * */
+export function simulateSlots<EL extends SupportedElement | DocumentFragment>(
+	el: HTMLElement,
+	body: EL,
+): EL
+
+export function dispatchEvent(name: keyof DocumentEventMap | string, options?: EventInit):
+	(element: SupportedElement, data?: any)=> void;
+export function dispatchEvent(
+	name: keyof DocumentEventMap | string,
+	options: EventInit | null,
+	element: SupportedElement | (()=> SupportedElement)
+): (data?: any)=> void;
+interface On{
+	/** Listens to the DOM event. See {@link Document.addEventListener} */
+	<
+		Event extends keyof DocumentEventMap,
+		EE extends ddeElementAddon<SupportedElement>= ddeElementAddon<HTMLElement>,
+		>(
+			type: Event,
+			listener: (this: EE extends ddeElementAddon<infer El> ? El : never, ev: DocumentEventMap[Event]) => any,
+			options?: AddEventListenerOptions
+		) : EE;
+	<
+		EE extends ddeElementAddon<SupportedElement>= ddeElementAddon<HTMLElement>,
+		>(
+			type: string,
+			listener: (this: EE extends ddeElementAddon<infer El> ? El : never, ev: Event | CustomEvent ) => any,
+			options?: AddEventListenerOptions
+		) : EE;
+	/** Listens to the element is connected to the live DOM. In case of custom elements uses [`connectedCallback`](https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_custom_elements#custom_element_lifecycle_callbacks), or {@link MutationObserver} else where */// editorconfig-checker-disable-line
+	connected<
+		EE extends ddeElementAddon<SupportedElement>,
+		El extends ( EE extends ddeElementAddon<infer El> ? El : never )
+		>(
+			listener: (this: El, event: CustomEvent<El>) => any,
+			options?: AddEventListenerOptions
+		) : EE;
+	/** Listens to the element is disconnected from the live DOM. In case of custom elements uses [`disconnectedCallback`](https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_custom_elements#custom_element_lifecycle_callbacks), or {@link MutationObserver} else where */// editorconfig-checker-disable-line
+	disconnected<
+		EE extends ddeElementAddon<SupportedElement>,
+		El extends ( EE extends ddeElementAddon<infer El> ? El : never )
+		>(
+			listener: (this: El, event: CustomEvent<void>) => any,
+			options?: AddEventListenerOptions
+		) : EE;
+	/** Listens to the element attribute changes. In case of custom elements uses [`attributeChangedCallback`](https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_custom_elements#custom_element_lifecycle_callbacks), or {@link MutationObserver} else where */// editorconfig-checker-disable-line
+	attributeChanged<
+		EE extends ddeElementAddon<SupportedElement>,
+		El extends ( EE extends ddeElementAddon<infer El> ? El : never )
+		>(
+			listener: (this: El, event: CustomEvent<[ string, string ]>) => any,
+			options?: AddEventListenerOptions
+		) : EE;
+}
+export const on: On;
+
+type Scope= {
+	scope: Node | Function | Object,
+	host: ddeElementAddon<any>,
+	custom_element: false | HTMLElement,
+	prevent: boolean
+};
+/** Current scope created last time the `el(Function)` was invoke. (Or {@link scope.push}) */
+export const scope: {
+	current: Scope,
+	/** Stops all automatizations. E. g. signals used as attributes in current scope
+	 * registers removing these listeners (and clean signal if no other listeners are detected)
+	 * on `disconnected` event. */
+	preventDefault<T extends boolean>(prevent: T): T,
+	/**
+	 * This represents reference to the current host element — `scope.host()`.
+	 * It can be also used to register Addon(s) (functions to be called when component is initized)
+	 * — `scope.host(on.connected(console.log))`.
+	 * */
+	host: (...addons: ddeElementAddon<SupportedElement>[])=> HTMLElement,
+
+	state: Scope[],
+	/** Adds new child scope. All attributes are inherited by default. */
+	push(scope: Partial<Scope>): ReturnType<Array<Scope>["push"]>,
+	/** Adds root scope as a child of the current scope. */
+	pushRoot(): ReturnType<Array<Scope>["push"]>,
+	/** Removes last/current child scope. */
+	pop(): ReturnType<Array<Scope>["pop"]>,
+};
+
+export function customElementRender<
+	EL extends HTMLElement,
+	P extends any = Record<string, string | ddeSignal<string>>
+>(
+	target: ShadowRoot | EL,
+	render: (props: P)=> SupportedElement | DocumentFragment,
+	props?: P | ((el: EL)=> P)
+): EL
+export function customElementWithDDE<EL extends (new ()=> HTMLElement)>(custom_element: EL): EL
+export function lifecyclesToEvents<EL extends (new ()=> HTMLElement)>(custom_element: EL): EL
+export function observedAttributes(custom_element: HTMLElement): Record<string, string>
+
+/* TypeScript MEH */
+declare global{
+	type ddeAppend<el>= (...nodes: (Node | string)[])=> el;
+
+	interface ddeDocumentFragment extends DocumentFragment{ append: ddeAppend<ddeDocumentFragment>; }
+	interface ddeHTMLElement extends HTMLElement{ append: ddeAppend<ddeHTMLElement>; }
+	interface ddeSVGElement extends SVGElement{ append: ddeAppend<ddeSVGElement>; }
+	interface ddeMathMLElement extends MathMLElement{ append: ddeAppend<ddeMathMLElement>; }
+
+	interface ddeHTMLElementTagNameMap {
+		"a": ddeHTMLAnchorElement;
+		"area": ddeHTMLAreaElement;
+		"audio": ddeHTMLAudioElement;
+		"base": ddeHTMLBaseElement;
+		"blockquote": ddeHTMLQuoteElement;
+		"body": ddeHTMLBodyElement;
+		"br": ddeHTMLBRElement;
+		"button": ddeHTMLButtonElement;
+		"canvas": ddeHTMLCanvasElement;
+		"caption": ddeHTMLTableCaptionElement;
+		"col": ddeHTMLTableColElement;
+		"colgroup": ddeHTMLTableColElement;
+		"data": ddeHTMLDataElement;
+		"datalist": ddeHTMLDataListElement;
+		"del": ddeHTMLModElement;
+		"details": ddeHTMLDetailsElement;
+		"dialog": ddeHTMLDialogElement;
+		"div": ddeHTMLDivElement;
+		"dl": ddeHTMLDListElement;
+		"embed": ddeHTMLEmbedElement;
+		"fieldset": ddeHTMLFieldSetElement;
+		"form": ddeHTMLFormElement;
+		"h1": ddeHTMLHeadingElement;
+		"h2": ddeHTMLHeadingElement;
+		"h3": ddeHTMLHeadingElement;
+		"h4": ddeHTMLHeadingElement;
+		"h5": ddeHTMLHeadingElement;
+		"h6": ddeHTMLHeadingElement;
+		"head": ddeHTMLHeadElement;
+		"hr": ddeHTMLHRElement;
+		"html": ddeHTMLHtmlElement;
+		"iframe": ddeHTMLIFrameElement;
+		"img": ddeHTMLImageElement;
+		"input": ddeHTMLInputElement;
+		"ins": ddeHTMLModElement;
+		"label": ddeHTMLLabelElement;
+		"legend": ddeHTMLLegendElement;
+		"li": ddeHTMLLIElement;
+		"link": ddeHTMLLinkElement;
+		"map": ddeHTMLMapElement;
+		"menu": ddeHTMLMenuElement;
+		"meta": ddeHTMLMetaElement;
+		"meter": ddeHTMLMeterElement;
+		"object": ddeHTMLObjectElement;
+		"ol": ddeHTMLOListElement;
+		"optgroup": ddeHTMLOptGroupElement;
+		"option": ddeHTMLOptionElement;
+		"output": ddeHTMLOutputElement;
+		"p": ddeHTMLParagraphElement;
+		"picture": ddeHTMLPictureElement;
+		"pre": ddeHTMLPreElement;
+		"progress": ddeHTMLProgressElement;
+		"q": ddeHTMLQuoteElement;
+		"script": ddeHTMLScriptElement;
+		"select": ddeHTMLSelectElement;
+		"slot": ddeHTMLSlotElement;
+		"source": ddeHTMLSourceElement;
+		"span": ddeHTMLSpanElement;
+		"style": ddeHTMLStyleElement;
+		"table": ddeHTMLTableElement;
+		"tbody": ddeHTMLTableSectionElement;
+		"td": ddeHTMLTableCellElement;
+		"template": ddeHTMLTemplateElement;
+		"textarea": ddeHTMLTextAreaElement;
+		"tfoot": ddeHTMLTableSectionElement;
+		"th": ddeHTMLTableCellElement;
+		"thead": ddeHTMLTableSectionElement;
+		"time": ddeHTMLTimeElement;
+		"title": ddeHTMLTitleElement;
+		"tr": ddeHTMLTableRowElement;
+		"track": ddeHTMLTrackElement;
+		"ul": ddeHTMLUListElement;
+		"video": ddeHTMLVideoElement;
+	}
+	interface ddeSVGElementTagNameMap {
+		"a": ddeSVGAElement;
+		"animate": ddeSVGAnimateElement;
+		"animateMotion": ddeSVGAnimateMotionElement;
+		"animateTransform": ddeSVGAnimateTransformElement;
+		"circle": ddeSVGCircleElement;
+		"clipPath": ddeSVGClipPathElement;
+		"defs": ddeSVGDefsElement;
+		"desc": ddeSVGDescElement;
+		"ellipse": ddeSVGEllipseElement;
+		"feBlend": ddeSVGFEBlendElement;
+		"feColorMatrix": ddeSVGFEColorMatrixElement;
+		"feComponentTransfer": ddeSVGFEComponentTransferElement;
+		"feComposite": ddeSVGFECompositeElement;
+		"feConvolveMatrix": ddeSVGFEConvolveMatrixElement;
+		"feDiffuseLighting": ddeSVGFEDiffuseLightingElement;
+		"feDisplacementMap": ddeSVGFEDisplacementMapElement;
+		"feDistantLight": ddeSVGFEDistantLightElement;
+		"feDropShadow": ddeSVGFEDropShadowElement;
+		"feFlood": ddeSVGFEFloodElement;
+		"feFuncA": ddeSVGFEFuncAElement;
+		"feFuncB": ddeSVGFEFuncBElement;
+		"feFuncG": ddeSVGFEFuncGElement;
+		"feFuncR": ddeSVGFEFuncRElement;
+		"feGaussianBlur": ddeSVGFEGaussianBlurElement;
+		"feImage": ddeSVGFEImageElement;
+		"feMerge": ddeSVGFEMergeElement;
+		"feMergeNode": ddeSVGFEMergeNodeElement;
+		"feMorphology": ddeSVGFEMorphologyElement;
+		"feOffset": ddeSVGFEOffsetElement;
+		"fePointLight": ddeSVGFEPointLightElement;
+		"feSpecularLighting": ddeSVGFESpecularLightingElement;
+		"feSpotLight": ddeSVGFESpotLightElement;
+		"feTile": ddeSVGFETileElement;
+		"feTurbulence": ddeSVGFETurbulenceElement;
+		"filter": ddeSVGFilterElement;
+		"foreignObject": ddeSVGForeignObjectElement;
+		"g": ddeSVGGElement;
+		"image": ddeSVGImageElement;
+		"line": ddeSVGLineElement;
+		"linearGradient": ddeSVGLinearGradientElement;
+		"marker": ddeSVGMarkerElement;
+		"mask": ddeSVGMaskElement;
+		"metadata": ddeSVGMetadataElement;
+		"mpath": ddeSVGMPathElement;
+		"path": ddeSVGPathElement;
+		"pattern": ddeSVGPatternElement;
+		"polygon": ddeSVGPolygonElement;
+		"polyline": ddeSVGPolylineElement;
+		"radialGradient": ddeSVGRadialGradientElement;
+		"rect": ddeSVGRectElement;
+		"script": ddeSVGScriptElement;
+		"set": ddeSVGSetElement;
+		"stop": ddeSVGStopElement;
+		"style": ddeSVGStyleElement;
+		"svg": ddeSVGSVGElement;
+		"switch": ddeSVGSwitchElement;
+		"symbol": ddeSVGSymbolElement;
+		"text": ddeSVGTextElement;
+		"textPath": ddeSVGTextPathElement;
+		"title": ddeSVGTitleElement;
+		"tspan": ddeSVGTSpanElement;
+		"use": ddeSVGUseElement;
+		"view": ddeSVGViewElement;
+	}
+}
+
+// editorconfig-checker-disable
+interface ddeHTMLAnchorElement extends HTMLAnchorElement{ append: ddeAppend<ddeHTMLAnchorElement>; }
+interface ddeHTMLAreaElement extends HTMLAreaElement{ append: ddeAppend<ddeHTMLAreaElement>; }
+interface ddeHTMLAudioElement extends HTMLAudioElement{ append: ddeAppend<ddeHTMLAudioElement>; }
+interface ddeHTMLBaseElement extends HTMLBaseElement{ append: ddeAppend<ddeHTMLBaseElement>; }
+interface ddeHTMLQuoteElement extends HTMLQuoteElement{ append: ddeAppend<ddeHTMLQuoteElement>; }
+interface ddeHTMLBodyElement extends HTMLBodyElement{ append: ddeAppend<ddeHTMLBodyElement>; }
+interface ddeHTMLBRElement extends HTMLBRElement{ append: ddeAppend<ddeHTMLBRElement>; }
+interface ddeHTMLButtonElement extends HTMLButtonElement{ append: ddeAppend<ddeHTMLButtonElement>; }
+interface ddeHTMLCanvasElement extends HTMLCanvasElement{ append: ddeAppend<ddeHTMLCanvasElement>; }
+interface ddeHTMLTableCaptionElement extends HTMLTableCaptionElement{ append: ddeAppend<ddeHTMLTableCaptionElement>; }
+interface ddeHTMLTableColElement extends HTMLTableColElement{ append: ddeAppend<ddeHTMLTableColElement>; }
+interface ddeHTMLTableColElement extends HTMLTableColElement{ append: ddeAppend<ddeHTMLTableColElement>; }
+interface ddeHTMLDataElement extends HTMLDataElement{ append: ddeAppend<ddeHTMLDataElement>; }
+interface ddeHTMLDataListElement extends HTMLDataListElement{ append: ddeAppend<ddeHTMLDataListElement>; }
+interface ddeHTMLModElement extends HTMLModElement{ append: ddeAppend<ddeHTMLModElement>; }
+interface ddeHTMLDetailsElement extends HTMLDetailsElement{ append: ddeAppend<ddeHTMLDetailsElement>; }
+interface ddeHTMLDialogElement extends HTMLDialogElement{ append: ddeAppend<ddeHTMLDialogElement>; }
+interface ddeHTMLDivElement extends HTMLDivElement{ append: ddeAppend<ddeHTMLDivElement>; }
+interface ddeHTMLDListElement extends HTMLDListElement{ append: ddeAppend<ddeHTMLDListElement>; }
+interface ddeHTMLEmbedElement extends HTMLEmbedElement{ append: ddeAppend<ddeHTMLEmbedElement>; }
+interface ddeHTMLFieldSetElement extends HTMLFieldSetElement{ append: ddeAppend<ddeHTMLFieldSetElement>; }
+interface ddeHTMLFormElement extends HTMLFormElement{ append: ddeAppend<ddeHTMLFormElement>; }
+interface ddeHTMLHeadingElement extends HTMLHeadingElement{ append: ddeAppend<ddeHTMLHeadingElement>; }
+interface ddeHTMLHeadElement extends HTMLHeadElement{ append: ddeAppend<ddeHTMLHeadElement>; }
+interface ddeHTMLHRElement extends HTMLHRElement{ append: ddeAppend<ddeHTMLHRElement>; }
+interface ddeHTMLHtmlElement extends HTMLHtmlElement{ append: ddeAppend<ddeHTMLHtmlElement>; }
+interface ddeHTMLIFrameElement extends HTMLIFrameElement{ append: ddeAppend<ddeHTMLIFrameElement>; }
+interface ddeHTMLImageElement extends HTMLImageElement{ append: ddeAppend<ddeHTMLImageElement>; }
+interface ddeHTMLInputElement extends HTMLInputElement{ append: ddeAppend<ddeHTMLInputElement>; }
+interface ddeHTMLLabelElement extends HTMLLabelElement{ append: ddeAppend<ddeHTMLLabelElement>; }
+interface ddeHTMLLegendElement extends HTMLLegendElement{ append: ddeAppend<ddeHTMLLegendElement>; }
+interface ddeHTMLLIElement extends HTMLLIElement{ append: ddeAppend<ddeHTMLLIElement>; }
+interface ddeHTMLLinkElement extends HTMLLinkElement{ append: ddeAppend<ddeHTMLLinkElement>; }
+interface ddeHTMLMapElement extends HTMLMapElement{ append: ddeAppend<ddeHTMLMapElement>; }
+interface ddeHTMLMenuElement extends HTMLMenuElement{ append: ddeAppend<ddeHTMLMenuElement>; }
+interface ddeHTMLMetaElement extends HTMLMetaElement{ append: ddeAppend<ddeHTMLMetaElement>; }
+interface ddeHTMLMeterElement extends HTMLMeterElement{ append: ddeAppend<ddeHTMLMeterElement>; }
+interface ddeHTMLObjectElement extends HTMLObjectElement{ append: ddeAppend<ddeHTMLObjectElement>; }
+interface ddeHTMLOListElement extends HTMLOListElement{ append: ddeAppend<ddeHTMLOListElement>; }
+interface ddeHTMLOptGroupElement extends HTMLOptGroupElement{ append: ddeAppend<ddeHTMLOptGroupElement>; }
+interface ddeHTMLOptionElement extends HTMLOptionElement{ append: ddeAppend<ddeHTMLOptionElement>; }
+interface ddeHTMLOutputElement extends HTMLOutputElement{ append: ddeAppend<ddeHTMLOutputElement>; }
+interface ddeHTMLParagraphElement extends HTMLParagraphElement{ append: ddeAppend<ddeHTMLParagraphElement>; }
+interface ddeHTMLPictureElement extends HTMLPictureElement{ append: ddeAppend<ddeHTMLPictureElement>; }
+interface ddeHTMLPreElement extends HTMLPreElement{ append: ddeAppend<ddeHTMLPreElement>; }
+interface ddeHTMLProgressElement extends HTMLProgressElement{ append: ddeAppend<ddeHTMLProgressElement>; }
+interface ddeHTMLScriptElement extends HTMLScriptElement{ append: ddeAppend<ddeHTMLScriptElement>; }
+interface ddeHTMLSelectElement extends HTMLSelectElement{ append: ddeAppend<ddeHTMLSelectElement>; }
+interface ddeHTMLSlotElement extends HTMLSlotElement{ append: ddeAppend<ddeHTMLSlotElement>; }
+interface ddeHTMLSourceElement extends HTMLSourceElement{ append: ddeAppend<ddeHTMLSourceElement>; }
+interface ddeHTMLSpanElement extends HTMLSpanElement{ append: ddeAppend<ddeHTMLSpanElement>; }
+interface ddeHTMLStyleElement extends HTMLStyleElement{ append: ddeAppend<ddeHTMLStyleElement>; }
+interface ddeHTMLTableElement extends HTMLTableElement{ append: ddeAppend<ddeHTMLTableElement>; }
+interface ddeHTMLTableSectionElement extends HTMLTableSectionElement{ append: ddeAppend<ddeHTMLTableSectionElement>; }
+interface ddeHTMLTableCellElement extends HTMLTableCellElement{ append: ddeAppend<ddeHTMLTableCellElement>; }
+interface ddeHTMLTemplateElement extends HTMLTemplateElement{ append: ddeAppend<ddeHTMLTemplateElement>; }
+interface ddeHTMLTextAreaElement extends HTMLTextAreaElement{ append: ddeAppend<ddeHTMLTextAreaElement>; }
+interface ddeHTMLTableCellElement extends HTMLTableCellElement{ append: ddeAppend<ddeHTMLTableCellElement>; }
+interface ddeHTMLTimeElement extends HTMLTimeElement{ append: ddeAppend<ddeHTMLTimeElement>; }
+interface ddeHTMLTitleElement extends HTMLTitleElement{ append: ddeAppend<ddeHTMLTitleElement>; }
+interface ddeHTMLTableRowElement extends HTMLTableRowElement{ append: ddeAppend<ddeHTMLTableRowElement>; }
+interface ddeHTMLTrackElement extends HTMLTrackElement{ append: ddeAppend<ddeHTMLTrackElement>; }
+interface ddeHTMLUListElement extends HTMLUListElement{ append: ddeAppend<ddeHTMLUListElement>; }
+interface ddeHTMLVideoElement extends HTMLVideoElement{ append: ddeAppend<ddeHTMLVideoElement>; }
+interface ddeSVGAElement extends SVGAElement{ append: ddeAppend<ddeSVGAElement>; }
+interface ddeSVGAnimateElement extends SVGAnimateElement{ append: ddeAppend<ddeSVGAnimateElement>; }
+interface ddeSVGAnimateMotionElement extends SVGAnimateMotionElement{ append: ddeAppend<ddeSVGAnimateMotionElement>; }
+interface ddeSVGAnimateTransformElement extends SVGAnimateTransformElement{ append: ddeAppend<ddeSVGAnimateTransformElement>; }
+interface ddeSVGCircleElement extends SVGCircleElement{ append: ddeAppend<ddeSVGCircleElement>; }
+interface ddeSVGClipPathElement extends SVGClipPathElement{ append: ddeAppend<ddeSVGClipPathElement>; }
+interface ddeSVGDefsElement extends SVGDefsElement{ append: ddeAppend<ddeSVGDefsElement>; }
+interface ddeSVGDescElement extends SVGDescElement{ append: ddeAppend<ddeSVGDescElement>; }
+interface ddeSVGEllipseElement extends SVGEllipseElement{ append: ddeAppend<ddeSVGEllipseElement>; }
+interface ddeSVGFEBlendElement extends SVGFEBlendElement{ append: ddeAppend<ddeSVGFEBlendElement>; }
+interface ddeSVGFEColorMatrixElement extends SVGFEColorMatrixElement{ append: ddeAppend<ddeSVGFEColorMatrixElement>; }
+interface ddeSVGFEComponentTransferElement extends SVGFEComponentTransferElement{ append: ddeAppend<ddeSVGFEComponentTransferElement>; }
+interface ddeSVGFECompositeElement extends SVGFECompositeElement{ append: ddeAppend<ddeSVGFECompositeElement>; }
+interface ddeSVGFEConvolveMatrixElement extends SVGFEConvolveMatrixElement{ append: ddeAppend<ddeSVGFEConvolveMatrixElement>; }
+interface ddeSVGFEDiffuseLightingElement extends SVGFEDiffuseLightingElement{ append: ddeAppend<ddeSVGFEDiffuseLightingElement>; }
+interface ddeSVGFEDisplacementMapElement extends SVGFEDisplacementMapElement{ append: ddeAppend<ddeSVGFEDisplacementMapElement>; }
+interface ddeSVGFEDistantLightElement extends SVGFEDistantLightElement{ append: ddeAppend<ddeSVGFEDistantLightElement>; }
+interface ddeSVGFEDropShadowElement extends SVGFEDropShadowElement{ append: ddeAppend<ddeSVGFEDropShadowElement>; }
+interface ddeSVGFEFloodElement extends SVGFEFloodElement{ append: ddeAppend<ddeSVGFEFloodElement>; }
+interface ddeSVGFEFuncAElement extends SVGFEFuncAElement{ append: ddeAppend<ddeSVGFEFuncAElement>; }
+interface ddeSVGFEFuncBElement extends SVGFEFuncBElement{ append: ddeAppend<ddeSVGFEFuncBElement>; }
+interface ddeSVGFEFuncGElement extends SVGFEFuncGElement{ append: ddeAppend<ddeSVGFEFuncGElement>; }
+interface ddeSVGFEFuncRElement extends SVGFEFuncRElement{ append: ddeAppend<ddeSVGFEFuncRElement>; }
+interface ddeSVGFEGaussianBlurElement extends SVGFEGaussianBlurElement{ append: ddeAppend<ddeSVGFEGaussianBlurElement>; }
+interface ddeSVGFEImageElement extends SVGFEImageElement{ append: ddeAppend<ddeSVGFEImageElement>; }
+interface ddeSVGFEMergeElement extends SVGFEMergeElement{ append: ddeAppend<ddeSVGFEMergeElement>; }
+interface ddeSVGFEMergeNodeElement extends SVGFEMergeNodeElement{ append: ddeAppend<ddeSVGFEMergeNodeElement>; }
+interface ddeSVGFEMorphologyElement extends SVGFEMorphologyElement{ append: ddeAppend<ddeSVGFEMorphologyElement>; }
+interface ddeSVGFEOffsetElement extends SVGFEOffsetElement{ append: ddeAppend<ddeSVGFEOffsetElement>; }
+interface ddeSVGFEPointLightElement extends SVGFEPointLightElement{ append: ddeAppend<ddeSVGFEPointLightElement>; }
+interface ddeSVGFESpecularLightingElement extends SVGFESpecularLightingElement{ append: ddeAppend<ddeSVGFESpecularLightingElement>; }
+interface ddeSVGFESpotLightElement extends SVGFESpotLightElement{ append: ddeAppend<ddeSVGFESpotLightElement>; }
+interface ddeSVGFETileElement extends SVGFETileElement{ append: ddeAppend<ddeSVGFETileElement>; }
+interface ddeSVGFETurbulenceElement extends SVGFETurbulenceElement{ append: ddeAppend<ddeSVGFETurbulenceElement>; }
+interface ddeSVGFilterElement extends SVGFilterElement{ append: ddeAppend<ddeSVGFilterElement>; }
+interface ddeSVGForeignObjectElement extends SVGForeignObjectElement{ append: ddeAppend<ddeSVGForeignObjectElement>; }
+interface ddeSVGGElement extends SVGGElement{ append: ddeAppend<ddeSVGGElement>; }
+interface ddeSVGImageElement extends SVGImageElement{ append: ddeAppend<ddeSVGImageElement>; }
+interface ddeSVGLineElement extends SVGLineElement{ append: ddeAppend<ddeSVGLineElement>; }
+interface ddeSVGLinearGradientElement extends SVGLinearGradientElement{ append: ddeAppend<ddeSVGLinearGradientElement>; }
+interface ddeSVGMarkerElement extends SVGMarkerElement{ append: ddeAppend<ddeSVGMarkerElement>; }
+interface ddeSVGMaskElement extends SVGMaskElement{ append: ddeAppend<ddeSVGMaskElement>; }
+interface ddeSVGMetadataElement extends SVGMetadataElement{ append: ddeAppend<ddeSVGMetadataElement>; }
+interface ddeSVGMPathElement extends SVGMPathElement{ append: ddeAppend<ddeSVGMPathElement>; }
+interface ddeSVGPathElement extends SVGPathElement{ append: ddeAppend<ddeSVGPathElement>; }
+interface ddeSVGPatternElement extends SVGPatternElement{ append: ddeAppend<ddeSVGPatternElement>; }
+interface ddeSVGPolygonElement extends SVGPolygonElement{ append: ddeAppend<ddeSVGPolygonElement>; }
+interface ddeSVGPolylineElement extends SVGPolylineElement{ append: ddeAppend<ddeSVGPolylineElement>; }
+interface ddeSVGRadialGradientElement extends SVGRadialGradientElement{ append: ddeAppend<ddeSVGRadialGradientElement>; }
+interface ddeSVGRectElement extends SVGRectElement{ append: ddeAppend<ddeSVGRectElement>; }
+interface ddeSVGScriptElement extends SVGScriptElement{ append: ddeAppend<ddeSVGScriptElement>; }
+interface ddeSVGSetElement extends SVGSetElement{ append: ddeAppend<ddeSVGSetElement>; }
+interface ddeSVGStopElement extends SVGStopElement{ append: ddeAppend<ddeSVGStopElement>; }
+interface ddeSVGStyleElement extends SVGStyleElement{ append: ddeAppend<ddeSVGStyleElement>; }
+interface ddeSVGSVGElement extends SVGSVGElement{ append: ddeAppend<ddeSVGSVGElement>; }
+interface ddeSVGSwitchElement extends SVGSwitchElement{ append: ddeAppend<ddeSVGSwitchElement>; }
+interface ddeSVGSymbolElement extends SVGSymbolElement{ append: ddeAppend<ddeSVGSymbolElement>; }
+interface ddeSVGTextElement extends SVGTextElement{ append: ddeAppend<ddeSVGTextElement>; }
+interface ddeSVGTextPathElement extends SVGTextPathElement{ append: ddeAppend<ddeSVGTextPathElement>; }
+interface ddeSVGTitleElement extends SVGTitleElement{ append: ddeAppend<ddeSVGTitleElement>; }
+interface ddeSVGTSpanElement extends SVGTSpanElement{ append: ddeAppend<ddeSVGTSpanElement>; }
+interface ddeSVGUseElement extends SVGUseElement{ append: ddeAppend<ddeSVGUseElement>; }
+interface ddeSVGViewElement extends SVGViewElement{ append: ddeAppend<ddeSVGViewElement>; }
+// editorconfig-checker-enable

dist/esm.js

@@ -436,7 +436,6 @@ function connectionsChangesObserverConstructor() {
 		offDisconnected(element, listener) {
 			if (!store.has(element)) return;
 			const ls = store.get(element);
-			if (!ls.disconnected.has(listener)) return;
 			ls.disconnected.delete(listener);
 			ls.length_d -= 1;
 			cleanWhenOff(element, ls);

docs/components/examples/debugging/consoleLog.js

@@ -0,0 +1,14 @@
+// Debugging a (derived) signal with `console.log`
+import { S } from "deka-dom-el/signals";
+const name= S("Alice");
+const greeting = S(() => {
+	// log derived signals
+	const log = "Hello, " + name.get();
+	console.log(log);
+	return log;
+});
+
+// log signals in general
+S.on(greeting, value => console.log("Greeting changed to:", value));
+
+name.set("Bob"); // Should trigger computation and listener`)

docs/components/examples/debugging/debouncing.js

@@ -0,0 +1,15 @@
+import { S } from "deka-dom-el/signals";
+// Debouncing signal updates
+function debounce(func, wait) {
+	let timeout;
+	return (...args)=> {
+		clearTimeout(timeout);
+		timeout= setTimeout(() => func(...args), wait);
+	};
+}
+
+const inputSignal= S("");
+const debouncedSet= debounce(value => inputSignal.set(value), 300);
+
+// In your input handler
+inputElement.addEventListener("input", e=> debouncedSet(e.target.value));

docs/components/examples/debugging/dom-reactive-mark.js

@@ -0,0 +1,4 @@
+// Example of reactive element marker
+<!--<dde:mark type=\"reactive\" source=\"...\">-->
+<!-- content that updates when signal changes -->
+<!--</dde:mark>-->

docs/components/examples/debugging/mutations.js

@@ -0,0 +1,15 @@
+import { S } from "deka-dom-el/signals";
+// Wrong - direct mutation doesn't trigger updates
+const todos1 = S([{ text: "Learn signals", completed: false }]);
+todos1.get().push({ text: "Debug signals", completed: false }); // Won't trigger updates!
+
+// Correct - using .set() with a new array
+todos1.set([...todos1.get(), { text: "Debug signals", completed: false }]);
+
+// Better - using actions
+const todos2 = S([], {
+	add(text) {
+		this.value.push({ text, completed: false });
+	}
+});
+S.action(todos2, "add", "Debug signals");

docs/components/examples/signals/debugging-console.js

@@ -0,0 +1,20 @@
+import { S } from "deka-dom-el/signals";
+
+// Debugging a derived signal
+const name = S('Alice');
+const greeting = S(() => {
+	console.log('Computing greeting...');
+	return 'Hello, ' + name.get();
+});
+
+// Monitor the derived signal
+S.on(greeting, value => console.log('Greeting changed to:', value));
+
+// Later update the dependency
+name.set('Bob'); // Should trigger computation and listener
+
+// Console output:
+// Computing greeting...
+// Greeting changed to: Hello, Alice
+// Computing greeting...
+// Greeting changed to: Hello, Bob

docs/components/examples/signals/debugging-dom.js

@@ -0,0 +1,38 @@
+import { el, on, scope } from "deka-dom-el";
+import { S } from "deka-dom-el/signals";
+
+// Create a component with reactive elements
+function ReactiveCounter() {
+	const count = S(0);
+		scope.host(on.connected(ev=>
+				console.log(ev.target.__dde_reactive)
+		));
+
+	const counter = el('div', {
+		// This element will be added into the __dde_reactive property
+		textContent: count,
+	});
+
+	const incrementBtn = el('button', {
+		textContent: 'Increment',
+		onclick: () => count.set(count.get() + 1)
+	});
+
+	// Dynamic section will be added into __dde_signal property
+	const counterInfo = S.el(count, value =>
+		el('p', `Current count is ${value}`)
+	);
+
+	return el('div', { id: 'counter' }).append(
+		counter,
+		incrementBtn,
+		counterInfo
+	);
+}
+document.body.append(
+	el(ReactiveCounter),
+);
+
+// In DevTools console:
+const counter = document.querySelector('#counter');
+setTimeout(()=> console.log(counter.__dde_reactive), 1000); // See reactive bindings

docs/components/examples/signals/derived.js

@@ -0,0 +1,13 @@
+import { S } from "deka-dom-el/signals";
+
+// Create base signals
+const firstName = S("John");
+const lastName = S("Doe");
+
+// Create a derived signal
+const fullName = S(() => firstName.get() + " " + lastName.get());
+
+// The fullName signal updates automatically when either dependency changes
+S.on(fullName, name => console.log("Name changed to:", name));
+
+firstName.set("Jane"); // logs: "Name changed to: Jane Doe"

docs/components/examples/ssr/async-data.js

@@ -0,0 +1,43 @@
+// Handling async data in SSR
+import { JSDOM } from "jsdom";
+import { S } from "deka-dom-el/signals";
+import { register, queue } from "deka-dom-el/jsdom";
+
+async function renderWithAsyncData() {
+	const dom = new JSDOM("<!DOCTYPE html><html><body></body></html>");
+	const { el } = await register(dom);
+
+	// Create a component that fetches data
+	function AsyncComponent() {
+			const title= S("-");
+			const description= S("-");
+
+		// Use the queue to track the async operation
+		queue(fetch("https://api.example.com/data")
+			.then(response => response.json())
+			.then(data => {
+				title.set(data.title);
+				description.set(data.description);
+			}));
+
+		return el("div", { className: "async-content" }).append(
+				el("h2", title),
+				el("p", description)
+		);
+	}
+
+	// Render the page
+	dom.window.document.body.append(
+		el("h1", "Page with Async Data"),
+		el(AsyncComponent)
+	);
+
+	// IMPORTANT: Wait for all queued operations to complete
+	await queue();
+
+	// Now the HTML includes all async content
+	const html = dom.serialize();
+	console.log(html);
+}
+
+renderWithAsyncData();

docs/components/examples/ssr/basic-example.js

@@ -0,0 +1,47 @@
+// Basic SSR Example
+import { JSDOM } from "jsdom";
+import { register, queue } from "deka-dom-el/jsdom";
+import { writeFileSync } from "node:fs";
+
+async function renderPage() {
+	// Create a jsdom instance
+	const dom = new JSDOM("<!DOCTYPE html><html><head><meta charset=\"utf-8\"></head><body></body></html>");
+
+	// Register with deka-dom-el and get the el function
+	const { el } = await register(dom);
+
+	// Create a simple header component
+	function Header({ title }) {
+		return el("header").append(
+			el("h1", title),
+			el("nav").append(
+				el("ul").append(
+					el("li").append(el("a", { href: "/" }, "Home")),
+					el("li").append(el("a", { href: "/about" }, "About")),
+					el("li").append(el("a", { href: "/contact" }, "Contact"))
+				)
+			)
+		);
+	}
+
+	// Create the page content
+	dom.window.document.body.append(
+		el(Header, { title: "My Static Site" }),
+		el("main").append(
+			el("h2", "Welcome!"),
+			el("p", "This page was rendered with deka-dom-el on the server.")
+		),
+		el("footer", "© 2025 My Company")
+	);
+
+	// Wait for any async operations
+	await queue();
+
+	// Get the HTML and write it to a file
+	const html = dom.serialize();
+	writeFileSync("index.html", html);
+
+	console.log("Page rendered successfully!");
+}
+
+renderPage().catch(console.error);

docs/components/examples/ssr/intro.js

@@ -0,0 +1,2 @@
+// use NPM or for example https://cdn.jsdelivr.net/gh/jaandrle/deka-dom-el/dist/esm-with-signals.js
+import { register, unregister, queue } from "deka-dom-el/jsdom";

docs/components/examples/ssr/pages.js

@@ -0,0 +1,35 @@
+// ❌ WRONG: Static imports are hoisted and will register before JSDOM is created
+import { register } from "deka-dom-el/jsdom";
+import { el } from "deka-dom-el";
+import { Header } from "./components/Header.js";
+
+// ✅ CORRECT: Use dynamic imports to ensure proper initialization order
+import { JSDOM } from "jsdom";
+
+async function renderPage() {
+	// 1. Create JSDOM instance first
+	const dom = new JSDOM(`<!DOCTYPE html><html><body></body></html>`);
+
+	// 2. Dynamically import jsdom module
+	const { register, queue } = await import("deka-dom-el/jsdom");
+
+	// 3. Register and get el function
+	const { el } = await register(dom);
+
+	// 4. Dynamically import page components
+	const { Header } = await import("./components/Header.js");
+	const { Content } = await import("./components/Content.js");
+
+	// 5. Render components
+	const body = dom.window.document.body;
+	el(body).append(
+		el(Header, { title: "My Page" }),
+		el(Content, { text: "This is server-rendered content" })
+	);
+
+	// 6. Wait for async operations
+	await queue();
+
+	// 7. Get HTML and clean up
+	return dom.serialize();
+}

docs/components/examples/ssr/start.js

@@ -0,0 +1,27 @@
+// Basic jsdom integration example
+import { JSDOM } from "jsdom";
+import { register, unregister, queue } from "deka-dom-el/jsdom.js";
+
+// Create a jsdom instance
+const dom = new JSDOM("<!DOCTYPE html><html><body></body></html>");
+
+// Register the dom with deka-dom-el
+const { el } = await register(dom);
+
+// Use deka-dom-el normally
+dom.window.document.body.append(
+	el("div", { className: "container" }).append(
+		el("h1", "Hello, SSR World!"),
+		el("p", "This content was rendered on the server.")
+	)
+);
+
+// Wait for any async operations to complete
+await queue();
+
+// Get the rendered HTML
+const html = dom.serialize();
+console.log(html);
+
+// Clean up when done
+unregister();

docs/components/examples/ssr/static-site-generator.js

@@ -0,0 +1,44 @@
+// Building a simple static site generator
+import { JSDOM } from "jsdom";
+import { register, queue } from "deka-dom-el/jsdom";
+import { writeFileSync, mkdirSync } from "node:fs";
+
+async function buildSite() {
+	// Define pages to build
+	const pages = [
+		{ id: "index", title: "Home", component: "./pages/home.js" },
+		{ id: "about", title: "About", component: "./pages/about.js" },
+		{ id: "docs", title: "Documentation", component: "./pages/docs.js" }
+	];
+
+	// Create output directory
+	mkdirSync("./dist", { recursive: true });
+
+	// Build each page
+	for (const page of pages) {
+		// Create a fresh jsdom instance for each page
+		const dom = new JSDOM("<!DOCTYPE html><html><head><meta charset=\"utf-8\"></head><body></body></html>");
+
+		// Register with deka-dom-el
+		const { el } = await register(dom);
+
+		// Import the page component
+		const { default: PageComponent } = await import(page.component);
+
+		// Render the page with its metadata
+		dom.window.document.body.append(
+			el(PageComponent, { title: page.title, pages })
+		);
+
+		// Wait for any async operations
+		await queue();
+
+		// Write the HTML to a file
+		const html = dom.serialize();
+		writeFileSync(`./dist/${page.id}.html`, html);
+
+		console.log(`Built page: ${page.id}.html`);
+	}
+}
+
+buildSite().catch(console.error);

docs/global.css.js

@@ -10,8 +10,10 @@ styles.css`
 	--secondary-dark: #4a0027;
 	--secondary-rgb: 112, 0, 55;
 
-	--font-main: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+	--font-main: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI',
-	--font-mono: 'Fira Code', 'JetBrains Mono', 'SF Mono', SFMono-Regular, Consolas, 'Liberation Mono', Menlo, monospace;
+		Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+	--font-mono: 'Fira Code', 'JetBrains Mono', 'SF Mono',
+		SFMono-Regular, Consolas, 'Liberation Mono', Menlo, monospace;
 
 	--body-max-width: 40rem;
 	--sidebar-width: 20rem;
@@ -68,8 +70,6 @@ styles.css`
 /* Base styling */
 * {
 	box-sizing: border-box;
-	margin: 0;
-	padding: 0;
 }
 
 html {
@@ -135,6 +135,7 @@ body {
 		"sidebar"
 		"content";
 	min-height: 100vh;
+	margin: 0;
 }
 
 ::selection {
@@ -160,13 +161,6 @@ h1 > a {
 	color: unset;
 }
 
-h2 {
-	font-size: 1.5rem;
-	border-bottom: 2px solid var(--border);
-	padding-bottom: 0.5rem;
-	color: var(--primary);
-}
-
 h3 {
 	font-size: 1.25rem;
 	color: var(--secondary);

docs/layout/head.html.js

@@ -14,7 +14,10 @@ ${host} {
 	background-color: var(--primary);
 	color: white;
 	box-shadow: var(--shadow);
-	min-height: var(--header-height);
+	min-height: calc(var(--header-height) - 1em);
+	--_m: .75em;
+	margin: var(--_m) var(--_m) 0 var(--_m);
+	border-radius: var(--border-radius);
 }
 
 ${host} .header-title {

docs/p04-signals.html.js

@@ -1,6 +1,6 @@
 import { T, t } from "./utils/index.js";
 export const info= {
-	title: t`Signals and reactivity`,
+	title: t`Signals and Reactivity`,
 	description: t`Managing reactive UI state with signals.`,
 };
 
@@ -43,86 +43,243 @@ const references= {
 export function page({ pkg, info }){
 	const page_id= info.id;
 	return el(simplePage, { info, pkg }).append(
-		el("h2", t`Using signals to manage reactivity`),
+		el("h2", t`Building Reactive UIs with Signals`),
 		el("p").append(...T`
-			How a program responds to variable data or user interactions is one of the fundamental problems of
+			Signals provide a simple yet powerful way to create reactive applications with DDE. They handle the
-			programming. If we desire to solve the issue in a declarative manner, signals may be a viable approach.
+			fundamental challenge of keeping your UI in sync with changing data in a declarative, efficient way.
 		`),
+		el("div", { class: "dde-callout" }).append(
+			el("h4", t`What Makes Signals Special?`),
+			el("ul").append(
+				el("li", t`Fine-grained reactivity without complex state management`),
+				el("li", t`Automatic UI updates when data changes`),
+				el("li", t`Clean separation between data, logic, and UI`),
+				el("li", t`Small runtime with minimal overhead`),
+				el("li", t`Works seamlessly with DDE's DOM creation`),
+				el("li", t`No dependencies or framework lock-in`)
+			)
+		),
 		el(code, { src: fileURL("./components/examples/signals/intro.js"), page_id }),
 
-		el(h3, t`Introducing signals`),
+		el(h3, t`The 3-Part Structure of Signals`),
 		el("p").append(...T`
-			Let’s re-introduce
+			Signals organize your code into three distinct parts, following the
-			${el("a", { textContent: t`3PS principle`, href: "./#h-event-driven-programming--parts-separation--ps" })}.
+			${el("a", { textContent: t`3PS principle`, href: "./#h-event-driven-programming--parts-separation--ps" })}:
-		`),
-		el("p").append(...T`
-			Using signals, we split program logic into the three parts. Firstly (α), we create a variable (constant)
-			representing reactive value. Somewhere later, we can register (β) a logic reacting to the signal value
-			changes. Similarly, in a remaining part (γ), we can update the signal value.
 		`),
+		el("div", { class: "dde-signal-diagram" }).append(
+			el("div", { class: "signal-part" }).append(
+				el("h4", t`α: Create Signal`),
+				el(code, { content: "const count = S(0);", page_id }),
+				el("p", t`Define a reactive value that can be observed and changed`)
+			),
+			el("div", { class: "signal-part" }).append(
+				el("h4", t`β: React to Changes`),
+				el(code, { content: "S.on(count, value => updateUI(value));", page_id }),
+				el("p", t`Subscribe to signal changes with callbacks or effects`)
+			),
+			el("div", { class: "signal-part" }).append(
+				el("h4", t`γ: Update Signal`),
+				el(code, { content: "count.set(count.get() + 1);", page_id }),
+				el("p", t`Modify the signal value, which automatically triggers updates`)
+			)
+		),
 		el(example, { src: fileURL("./components/examples/signals/signals.js"), page_id }),
+
+		el("div", { class: "dde-note" }).append(
+			el("p").append(...T`
+				Signals implement the ${el("a", { textContent: t`Publish–subscribe pattern`, ...references.wiki_pubsub })},
+				a form of ${el("a", { textContent: t`Event-driven programming`, ...references.wiki_event_driven })}.
+				This architecture allows different parts of your application to stay synchronized through a shared signal,
+				without direct dependencies on each other.
+			`)
+		),
+
+		el(h3, t`Signal Essentials: Core API`),
+		el("div", { class: "dde-function-table" }).append(
+			el("dl").append(
+				el("dt", t`Creating a Signal`),
+				el("dd", t`S(initialValue) → creates a signal with the given value`),
+
+				el("dt", t`Reading a Signal`),
+				el("dd", t`signal.get() → returns the current value`),
+
+				el("dt", t`Writing to a Signal`),
+				el("dd", t`signal.set(newValue) → updates the value and notifies subscribers`),
+
+				el("dt", t`Subscribing to Changes`),
+				el("dd", t`S.on(signal, callback) → runs callback whenever signal changes`),
+
+				el("dt", t`Unsubscribing`),
+				el("dd", t`S.on(signal, callback, { signal: abortController.signal })`)
+			)
+		),
 		el("p").append(...T`
-			All this is just an example of
+			Signals can be created with any type of value, but they work best with
-			${el("a", { textContent: t`Event-driven programming`, ...references.wiki_event_driven })} and
+			${el("a", { textContent: t`primitive types`, ...references.mdn_primitive })} like strings, numbers, and booleans.
-			${el("a", { textContent: t`Publish–subscribe pattern`, ...references.wiki_pubsub })} (compare for example
+			For complex data types like objects and arrays, you'll want to use Actions (covered below).
-			with ${el("a", { textContent: t`fpubsub library`, ...references.fpubsub })}). All three parts can be in
-			some manner independent and still connected to the same reactive entity.
 		`),
+
+		el(h3, t`Derived Signals: Computed Values`),
 		el("p").append(...T`
-			Signals are implemented in the library as objects with methods. To see current value of signal,
+			Computed values (also called derived signals) automatically update when their dependencies change.
-			call the get method ${el("code", "console.log(signal.get())")}. To update the signal value, use the set method
+			Create them by passing a function to S():
-			${el("code", `signal.set('${t`a new value`}')`)}. For listenning the signal value changes, use
-			${el("code", "S.on(signal, console.log)")}.
 		`),
+		el(example, { src: fileURL("./components/examples/signals/derived.js"), page_id }),
 		el("p").append(...T`
-			Similarly to the ${el("code", "on")} function to register DOM events listener. You can use
+			Derived signals are read-only - you can't call .set() on them. Their value is always computed
-			${el("code", "AbortController")}/${el("code", "AbortSignal")} to ${el("em", "off")}/stop listenning. In
+			from their dependencies. They're perfect for transforming or combining data from other signals.
-			example, you also found the way for representing “live” piece of code computation pattern (derived signal):
 		`),
 		el(example, { src: fileURL("./components/examples/signals/computations-abort.js"), page_id }),
 
-		el(h3, t`Signals and actions`),
+		el(h3, t`Signal Actions: For Complex State`),
 		el("p").append(...T`
-			${el("code", `S(/* ${t`primitive`} */)`)} allows you to declare simple reactive variables, typically, around
+			When working with objects, arrays, or other complex data structures, Signal Actions provide
-			${el("em", t`immutable`)} ${el("a", { textContent: t`primitive types`, ...references.mdn_primitive })}.
+			a structured way to modify state while maintaining reactivity.
-			However, it may also be necessary to use reactive arrays, objects, or other complex reactive structures.
 		`),
+		el("div", { class: "dde-illustration" }).append(
+			el("h4", t`Actions vs. Direct Mutation`),
+			el("div", { class: "comparison" }).append(
+				el("div", { class: "bad-practice" }).append(
+					el("h5", t`❌ Without Actions`),
+					el(code, { content: `
+const todos = S([]);
+// Directly mutating the array
+const items = todos.get();
+items.push("New todo");
+// This WON'T trigger updates!`, page_id }))
+				),
+				el("div", { class: "good-practice" }).append(
+					el("h5", t`✅ With Actions`),
+					el(code, { content: `const todos = S([], {
+	add(text) {
+		this.value.push(text);
+		// Subscribers notified automatically
+	}
+});
+
+// Use the action
+S.action(todos, "add", "New todo");`, page_id })
+				)
+		),
 		el(example, { src: fileURL("./components/examples/signals/actions-demo.js"), page_id }),
-		el("p", t`…but typical user-case is object/array (maps, sets and other mutable objects):`),
+
-		el(example, { src: fileURL("./components/examples/signals/actions-todos.js"), page_id }),
 		el("p").append(...T`
-			In some way, you can compare it with ${el("a", { textContent: "useReducer", ...references.mdn_use_reducer })}
+			Actions provide these benefits:
-			hook from React. So, the ${el("code", "S(<data>, <actions>)")} pattern creates a store “machine”. We can
+		`),
-			then invoke (dispatch) registered action by calling ${el("code", "S.action(<signal>, <name>, ...<args>)")}
+		el("ul").append(
-			after the action call the signal calls all its listeners. This can be stopped by calling
+			el("li", t`Encapsulate state change logic in named methods`),
-			${el("code", "this.stopPropagation()")} in the method representing the given action. As it can be seen in
+			el("li", t`Guarantee notifications when state changes`),
-			examples, the “store” value is available also in the function for given action (${el("code", "this.value")}).
+			el("li", t`Prevent accidental direct mutations`),
+			el("li", t`Act similar to reducers in other state management libraries`)
+		),
+		el("p").append(...T`
+			Here's a more complete example of a todo list using signal actions:
+		`),
+		el(example, { src: fileURL("./components/examples/signals/actions-todos.js"), page_id }),
+
+		el("div", { class: "dde-tip" }).append(
+			el("p").append(...T`
+				${el("strong", "Special Action Methods")}: Signal actions can implement special lifecycle hooks:
+			`),
+			el("ul").append(
+				el("li", t`[S.symbols.onclear]() - Called when the signal is cleared`),
+				el("li", t`[S.symbols.onget]() - Called when the signal value is read`),
+				el("li", t`[S.symbols.onset]() - Called after the signal value is changed`)
+			)
+		),
+
+		el(h3, t`Connecting Signals to the DOM`),
+		el("p").append(...T`
+			Signals really shine when connected to your UI. DDE provides several ways to bind signals to DOM elements:
 		`),
 
-		el(h3, t`Reactive DOM attributes and elements`),
+		el("div", { class: "dde-tabs" }).append(
-		el("p", t`There are two fundamental ways to make your DOM reactive with signals:`),
+			el("div", { class: "tab", "data-tab": "attributes" }).append(
-		el("ol").append(
+				el("h4", t`Reactive Attributes`),
-			el("li", t`Reactive attributes: Update properties, attributes, and styles of existing elements`),
+				el("p", t`Bind signal values directly to element attributes, properties, or styles:`),
-			el("li", t`Reactive elements: Dynamically create or update DOM elements based on data changes (for conditions and loops)`)
+				el(code, { content: `// Create a signal
+const color = S("blue");
+
+// Bind it to an element's style
+el("div", {
+	style: {
+		color, // Updates when signal changes
+		fontWeight: S(() => color.get() === "red" ? "bold" : "normal")
+	}
+}, "This text changes color");
+
+// Later:
+color.set("red"); // UI updates automatically`, page_id })
+			),
+			el("div", { class: "tab", "data-tab": "elements" }).append(
+				el("h4", t`Reactive Elements`),
+				el("p", t`Dynamically create or update elements based on signal values:`),
+				el(code, { content: `// Create an array signal
+const items = S(["Apple", "Banana", "Cherry"]);
+
+// Create a dynamic list that updates when items change
+el("ul").append(
+	S.el(items, items =>
+		items.map(item => el("li", item))
+	)
+);
+
+// Later:
+S.action(items, "push", "Dragonfruit"); // List updates automatically`, page_id })
+			)
 		),
+
 		el(example, { src: fileURL("./components/examples/signals/dom-attrs.js"), page_id }),
 		el("p").append(...T`
-			To derived attribute based on value of signal variable just use the signal as a value of the attribute
+			The ${el("code", "assign")} and ${el("code", "el")} functions detect signals automatically and handle binding.
-			(${el("code", "assign(element, { attribute: S('value') })")}). ${el("code", "assign")}/${el("code", "el")}
+			You can use special properties like ${el("code", "dataset")}, ${el("code", "ariaset")}, and
-			provides ways to glue reactive attributes/classes more granularly into the DOM. Just use dedicated build-in
+			${el("code", "classList")} for fine-grained control over specific attribute types.
-			attributes ${el("code", "dataset")}, ${el("code", "ariaset")} and ${el("code", "classList")}.
 		`),
+
 		el("p").append(...T`
-			For computation, you can use the “derived signal” (see above) like
+			${el("code", "S.el()")} is especially powerful for conditional rendering and lists:
-			${el("code", "assign(element, { textContent: S(()=> 'Hello '+WorldSignal.get()) })")}. This is read-only signal
-			its value is computed based on given function and updated when any signal used in the function changes.
-		`),
-		el("p").append(...T`
-			To represent part of the template filled dynamically based on the signal value use
-			${el("code", "S.el(signal, DOMgenerator)")}. This was already used in the todo example above or see:
 		`),
 		el(example, { src: fileURL("./components/examples/signals/dom-el.js"), page_id }),
 
+		el(h3, t`Best Practices for Signals`),
+		el("p").append(...T`
+			Follow these guidelines to get the most out of signals:
+		`),
+		el("ol").append(
+			el("li").append(...T`
+				${el("strong", "Keep signals small and focused")}: Use many small signals rather than a few large ones
+			`),
+			el("li").append(...T`
+				${el("strong", "Use derived signals for computations")}: Don't recompute values in multiple places
+			`),
+			el("li").append(...T`
+				${el("strong", "Clean up signal subscriptions")}: Use AbortController or scope.host() to prevent memory leaks
+			`),
+			el("li").append(...T`
+				${el("strong", "Use actions for complex state")}: Don't directly mutate objects or arrays in signals
+			`),
+			el("li").append(...T`
+				${el("strong", "Avoid infinite loops")}: Be careful when one signal updates another in a subscription
+			`)
+		),
+
+		el("div", { class: "dde-troubleshooting" }).append(
+			el("h4", t`Common Signal Pitfalls`),
+			el("dl").append(
+				el("dt", t`UI not updating when array/object changes`),
+				el("dd", t`Use signal actions instead of direct mutation`),
+
+				el("dt", t`Infinite update loops`),
+				el("dd", t`Check for circular dependencies between signals`),
+
+				el("dt", t`Memory leaks`),
+				el("dd", t`Use AbortController or scope.host() to clean up subscriptions`),
+
+				el("dt", t`Multiple elements updating unnecessarily`),
+				el("dd", t`Split large signals into smaller, more focused ones`)
+			)
+		),
+
 		el(mnemonic)
 	);
 }

docs/p05-scopes.html.js

@@ -1,7 +1,7 @@
 import { T, t } from "./utils/index.js";
 export const info= {
-	title: t`Scopes and components`,
+	title: t`Scopes and Components`,
-	description: t`Organizing UI into components`,
+	description: t`Organizing UI into reusable, manageable components`,
 };
 
 import { el } from "deka-dom-el";
@@ -28,60 +28,226 @@ const references= {
 export function page({ pkg, info }){
 	const page_id= info.id;
 	return el(simplePage, { info, pkg }).append(
-		el("h2", t`Using functions as UI components`),
+		el("h2", t`Building Maintainable UIs with Scopes and Components`),
 		el("p").append(...T`
-			For state-less components we can use functions as UI components (see “Elements” page). But in real life,
+			Scopes provide a structured way to organize your UI code into reusable components that properly
-			we may need to handle the component live-cycle and provide JavaScript the way to properly use
+			manage their lifecycle, handle cleanup, and maintain clear boundaries between different parts of your application.
-			the ${el("a", { textContent: t`Garbage collection`, ...references.garbage_collection })}.
 		`),
+		el("div", { class: "dde-callout" }).append(
+			el("h4", t`Why Use Scopes?`),
+			el("ul").append(
+				el("li", t`Automatic resource cleanup when components are removed from DOM`),
+				el("li", t`Clear component boundaries with explicit host elements`),
+				el("li", t`Simplified event handling with proper "this" binding`),
+				el("li", t`Seamless integration with signals for reactive components`),
+				el("li", t`Better memory management with ${el("a", { textContent: t`GC`, ...references.garbage_collection })}`)
+			)
+		),
 		el(code, { src: fileURL("./components/examples/scopes/intro.js"), page_id }),
-		el("p").append(...T`The library therefore use ${el("em", t`scopes`)} to provide these functionalities.`),
 
-		el(h3, t`Scopes and hosts`),
+		el(h3, t`Understanding Host Elements and Scopes`),
+		el("div", { class: "dde-illustration" }).append(
+			el("h4", t`Component Anatomy`),
+			el("pre").append(el("code", `
+┌─────────────────────────────────┐
+│ // 1. Component scope created   │
+│ el(MyComponent);                │
+│                                 │
+│ function MyComponent() {        │
+│   // 2. access the host element │
+│   const { host } = scope;       │
+│                                 │
+│   // 3. Add behavior to host    │
+│   host(                         │
+│     on.click(handleClick)       │
+│   );                            │
+│                                 │
+│   // 4. Return the host element │
+│   return el("div", {           │
+│     className: "my-component"   │
+│   }).append(                    │
+│     el("h2", "Title"),          │
+│     el("p", "Content")          │
+│   );                            │
+│ }                               │
+└─────────────────────────────────┘
+			`))
+		),
 		el("p").append(...T`
-			The ${el("strong", "host")} is the name for the element representing the component. This is typically
+			The ${el("strong", "host element")} is the root element of your component - typically the element returned
-			element returned by function. To get reference, you can use ${el("code", "scope.host()")} to applly addons
+			by your component function. It serves as the identity of your component in the DOM.
-			just use ${el("code", "scope.host(...<addons>)")}.
 		`),
+		el("div", { class: "dde-function-table" }).append(
+			el("h4", t`scope.host()`),
+			el("dl").append(
+				el("dt", t`When called with no arguments`),
+				el("dd", t`Returns a reference to the host element (the root element of your component)`),
+
+				el("dt", t`When called with addons/callbacks`),
+				el("dd", t`Applies the addons to the host element and returns the host element`)
+			)
+		),
 		el(example, { src: fileURL("./components/examples/scopes/scopes-and-hosts.js"), page_id }),
+
+		el("div", { class: "dde-tip" }).append(
+			el("p").append(...T`
+				${el("strong", "Best Practice:")} Always capture the host reference at the beginning of your component function
+				using ${el("code", "const { host } = scope")} to avoid scope-related issues, especially with asynchronous code.
+			`)
+		),
+
+		el(h3, t`Class-Based Components`),
 		el("p").append(...T`
-			To better understanding we implement function ${el("code", "elClass")} helping to create component as
+			While functional components are the primary pattern in DDE, you can also create class-based components
-			class instances.
+			for more structured organization of component logic.
 		`),
 		el(example, { src: fileURL("./components/examples/scopes/class-component.js"), page_id }),
+
 		el("p").append(...T`
-			As you can see, the ${el("code", "scope.host()")} is stored temporarily and synchronously. Therefore, at
+			This pattern can be useful when:
-			least in the beginning of using library, it is the good practise to store ${el("code", "host")} in the root
-			of your component. As it may be changed, typically when there is asynchronous code in the component.
 		`),
+		el("ul").append(
+			el("li", t`You have complex component logic that benefits from object-oriented organization`),
+			el("li", t`You need private methods and properties for your component`),
+			el("li", t`You're transitioning from another class-based component system`)
+		),
+		el("div", { class: "dde-tip" }).append(
+			el("p").append(...T`
+				${el("strong", "Note:")} Even with class-based components, follow the best practice of storing the host reference
+				early in your component code. This ensures proper access to the host throughout the component's lifecycle.
+			`)
+		),
 		el(code, { src: fileURL("./components/examples/scopes/good-practise.js"), page_id }),
 
-		el(h3, t`Scopes, signals and cleaning magic`),
+		el(h3, t`Automatic Cleanup with Scopes`),
 		el("p").append(...T`
-			The ${el("code", "host")} is internally used to register the cleaning procedure, when the component
+			One of the most powerful features of scopes is automatic cleanup when components are removed from the DOM.
-			(${el("code", "host")} element) is removed from the DOM.
+			This prevents memory leaks and ensures resources are properly released.
 		`),
+		el("div", { class: "dde-illustration" }).append(
+			el("h4", t`Lifecycle Flow`),
+			el("pre").append(el("code", `
+1. Component created → scope established
+2. Component added to DOM → connected event
+3. Component interactions happen
+4. Component removed from DOM → disconnected event
+5. Automatic cleanup of:
+	- Event listeners
+	- Signal subscriptions
+	- Custom cleanup code
+			`))
+		),
 		el(example, { src: fileURL("./components/examples/scopes/cleaning.js"), page_id }),
+
+		el("div", { class: "dde-note" }).append(
+			el("p").append(...T`
+				In this example, when you click "Remove", the component is removed from the DOM, and all its associated
+				resources are automatically cleaned up, including the signal subscription that updates the text content.
+				This happens because the library internally registers a disconnected event handler on the host element.
+			`)
+		),
+
+		el(h3, t`Declarative vs Imperative Components`),
 		el("p").append(...T`
-			The text content of the paragraph is changing when the value of the signal ${el("code", "textContent")}
+			Scopes work best with a declarative approach to UI building, especially when combined
-			is changed. Internally, there is association between ${el("code", "textContent")} and the paragraph,
+			with ${el("a", { textContent: "signals", ...references.signals })} for state management.
-			similar to using ${el("code", `S.on(textContent, /* ${t`update the paragraph`} */)`)}.
-		`),
-		el("p").append(...T`
-			This listener must be removed when the component is removed from the DOM. To do it, the library assign
-			internally ${el("code", `on.disconnected(/* ${t`remove the listener`} */)(host())`)} to the host element.
-		`),
-		el("p", { className: "notice" }).append(...T`
-			The library DOM API and signals works ideally when used declaratively. It means, you split your app logic
-			into three parts as it was itroduced in ${el("a", { textContent: "Signals", ...references.signals })}.
 		`),
+		el("div", { class: "dde-tabs" }).append(
+			el("div", { class: "tab", "data-tab": "declarative" }).append(
+				el("h4", t`✅ Declarative Approach`),
+				el("p", t`Define what your UI should look like based on state:`),
+				el("pre").append(el("code", `function Counter() {
+	const { host } = scope;
+
+	// Define state
+	const count = S(0);
+
+	// Define behavior
+	const increment = () => count.set(count.get() + 1);
+
+	// UI automatically updates when count changes
+	return el("div").append(
+		el("p", S(() => "Count: " + count.get())),
+		el("button", {
+			onclick: increment,
+			textContent: "Increment"
+		})
+	);
+}`))
+			),
+			el("div", { class: "tab", "data-tab": "imperative" }).append(
+				el("h4", t`⚠️ Imperative Approach`),
+				el("p", t`Manually update the DOM in response to events:`),
+				el("pre").append(el("code", `function Counter() {
+	const { host } = scope;
+
+	let count = 0;
+	const counterText = el("p", "Count: 0");
+
+	// Manually update DOM element
+	const increment = () => {
+		count++;
+		counterText.textContent = "Count: " + count;
+	};
+
+	return el("div").append(
+		counterText,
+		el("button", {
+			onclick: increment,
+			textContent: "Increment"
+		})
+	);
+}`))
+			)
+		),
+
 		el(code, { src: fileURL("./components/examples/scopes/declarative.js"), page_id }),
-		el("p").append(...T`
+
-			Strictly speaking, the imperative way of using the library is not prohibited. Just be careful (rather avoid)
+		el("div", { class: "dde-note" }).append(
-			mixing declarative approach (using signals) and imperative manipulation of elements.
+			el("p").append(...T`
-		`),
+				While DDE supports both declarative and imperative approaches, the declarative style is recommended
+				as it leads to more maintainable code with fewer opportunities for bugs. Signals handle the complexity
+				of keeping your UI in sync with your data.
+			`)
+		),
 		el(code, { src: fileURL("./components/examples/scopes/imperative.js"), page_id }),
 
+		el(h3, t`Best Practices for Scopes and Components`),
+		el("ol").append(
+			el("li").append(...T`
+				${el("strong", "Capture host early:")} Use ${el("code", "const { host } = scope")} at component start
+			`),
+			el("li").append(...T`
+				${el("strong", "Return a single root element:")} Components should have one host element that contains all others
+			`),
+			el("li").append(...T`
+				${el("strong", "Prefer declarative patterns:")} Use signals to drive UI updates rather than manual DOM manipulation
+			`),
+			el("li").append(...T`
+				${el("strong", "Keep components focused:")} Each component should do one thing well
+			`),
+			el("li").append(...T`
+				${el("strong", "Add explicit cleanup:")} For resources not managed by DDE, use ${el("code", "on.disconnected")}
+			`)
+		),
+
+		el("div", { class: "dde-troubleshooting" }).append(
+			el("h4", t`Common Scope Pitfalls`),
+			el("dl").append(
+				el("dt", t`Losing host reference in async code`),
+				el("dd", t`Store host reference early with const { host } = scope`),
+
+				el("dt", t`Memory leaks from custom resources`),
+				el("dd", t`Use host(on.disconnected(cleanup)) for manual resource cleanup`),
+
+				el("dt", t`Event handlers with incorrect 'this'`),
+				el("dd", t`Use arrow functions or .bind() to preserve context`),
+
+				el("dt", t`Mixing declarative and imperative styles`),
+				el("dd", t`Choose one approach and be consistent throughout a component`)
+			)
+		),
+
 		el(mnemonic)
 	);
 }

docs/p06-customElement.html.js

@@ -53,90 +53,236 @@ const references= {
 export function page({ pkg, info }){
 	const page_id= info.id;
 	return el(simplePage, { info, pkg }).append(
-		el("h2", t`Using web components in combinantion with DDE`),
+		el("h2", t`Using Web Components with DDE: Better Together`),
 		el("p").append(...T`
-			The DDE library allows for use within ${el("a", references.mdn_web_components).append( el("strong",
+			DDE pairs powerfully with ${el("a", references.mdn_web_components).append(el("strong", t`Web Components`))}
-			t`Web Components`) )} for dom-tree generation. However, in order to be able to use signals (possibly
+			to create reusable, encapsulated custom elements with all the benefits of DDE's declarative DOM
-			mapping to registered ${el("a", references.mdn_observedAttributes).append( el("code", "observedAttributes")
+			construction and reactivity system.
-			)}) and additional functionality is (unfortunately) required to use helpers provided by the library.
 		`),
+		el("div", { class: "dde-callout" }).append(
+			el("h4", t`Why Combine DDE with Web Components?`),
+			el("ul").append(
+				el("li", t`Declarative DOM creation within your components`),
+				el("li", t`Reactive attribute updates through signals`),
+				el("li", t`Simplified event handling with the same events API`),
+				el("li", t`Clean component lifecycle management`),
+				el("li", t`Improved code organization with scopes`)
+			)
+		),
 		el(code, { src: fileURL("./components/examples/customElement/intro.js"), page_id }),
 
-		el(h3, t`Custom Elements Introduction`),
+		el(h3, t`Getting Started: Web Components Basics`),
 		el("p").append(...T`
-			Web Components, specifically Custom Elements, are a set of web platform APIs that allow you to create
+			Web Components are a set of standard browser APIs that let you create custom HTML elements with
-			new HTML tags with custom functionality encapsulated within them. This allows for the creation of reusable
+			encapsulated functionality. They consist of three main technologies:
-			components that can be used across web applications.
-		`),
-		el("p").append(...T`
-			To start with, let’s see how to use native Custom Elements. As starting point please read
-			${el("a", references.mdn_custom_elements).append( el("strong", t`Using Custom Elements`), t` on MDN` )}.
-			To sum up and for mnemonic see following code overview:
-		`),
-		el(code, { src: fileURL("./components/examples/customElement/native-basic.js"), page_id }),
-		el("p").append(...T`
-			For more advanced use of Custom Elements, the summary ${el("a", references.custom_elements_tips)
-			.append( el("strong", t`Handy Custom Elements Patterns`) )} may be useful. Especially pay attention to
-			linking HTML attributes and defining setters/getters, this is very helpful to use in combination with
-			the library (${el("code", `el(HTMLCustomElement.tagName, { customAttribute: "${t`new-value`}" });`)}).
-		`),
-		el("p").append(...T`
-			Also see the Life Cycle Events sections, very similarly we would like to use
-			${el("a", { textContent: t`DDE events`, href: "./p03-events.html", title: t`See events part of the library
-			documentation` })}. To do it, the library provides function ${el("code", "customElementWithDDE")}…
-		`),
-		el(example, { src: fileURL("./components/examples/customElement/customElementWithDDE.js"), page_id }),
-
-		el("h3", t`Custom Elements with DDE`),
-		el("p").append(...T`
-			The ${el("code", "customElementWithDDE")} function is only (small) part of the inregration of the library.
-			More important for coexistence is render component function as a body of the Custom Element. For that, you
-			can use ${el("code", "customElementRender")} with arguments instance reference, target for connection,
-			render function and optional properties (will be passed to the render function) see later…
-		`),
-		el(example, { src: fileURL("./components/examples/customElement/dde.js"), page_id }),
-		el("p").append(...T`
-			…as you can see, you can use components created based on the documentation previously introduced. To unlock
-			full potential, use with combination ${el("code", "customElementWithDDE")} (allows to use livecycle events)
-			and ${el("code", "observedAttributes")} (converts attributes to render function arguments —
-			${el("em", "default")}) or ${el("code", "S.observedAttributes")} (converts attributes to signals).
-		`),
-		el(example, { src: fileURL("./components/examples/customElement/observedAttributes.js"), page_id }),
-
-
-		el(h3, t`Shadow DOM`),
-		el("p").append(...T`
-			Shadow DOM is a web platform feature that allows for the encapsulation of a component’s internal DOM tree
-			from the rest of the document. This means that styles and scripts applied to the document will not affect
-			the component’s internal DOM, and vice versa.
-		`),
-		el(example, { src: fileURL("./components/examples/customElement/shadowRoot.js"), page_id }),
-		el("p").append(...T`
-			Regarding to ${el("code", "this.attachShadow({ mode: 'open' })")} see quick overview
-			${el("a", { textContent: t`Using Shadow DOM`, ...references.mdn_shadow_dom_depth })}. An another source of
-			information can be ${el("a", { textContent: t`Shadow DOM in Depth`, ...references.shadow_dom_depth })}.
-		`),
-		el("p").append(...T`
-			Besides the encapsulation, the Shadow DOM allows for using the ${el("a", references.mdn_shadow_dom_slot).append(
-			el("strong", t`<slot>`), t` element(s)`)}. You can simulate this feature using ${el("code", "simulateSlots")}:
-		`),
-		el(example, { src: fileURL("./components/examples/customElement/simulateSlots.js"), page_id }),
-		el("p").append(...T`
-			To sum up:
 		`),
 		el("ul").append(
 			el("li").append(...T`
-				The use of shadow DOM to encapsulate the internal structure of the custom element, which affects how
+				${el("strong", "Custom Elements:")} Create your own HTML tags with JS-defined behavior
-				the custom element can be styled and modified using JavaScript and CSS.
 			`),
 			el("li").append(...T`
-				The ability to access and modify the internal structure of the custom element using JavaScript, which
+				${el("strong", "Shadow DOM:")} Encapsulate styles and markup within a component
-				is affected by the use of shadow DOM and the mode of the shadow DOM.
 			`),
 			el("li").append(...T`
-				The use of slots to allow for the insertion of content from the parent document into the custom
+				${el("strong", "HTML Templates:")} Define reusable markup structures
-				element, which is affected by the use of shadow DOM and the mode of the shadow DOM.
+			`)
+		),
+		el("p").append(...T`
+			Let's start with a basic Custom Element example without DDE to establish the foundation:
+		`),
+		el(code, { src: fileURL("./components/examples/customElement/native-basic.js"), page_id }),
+
+		el("div", { class: "dde-note" }).append(
+			el("p").append(...T`
+				For complete information on Web Components, see the
+				${el("a", references.mdn_custom_elements).append(el("strong", t`MDN documentation`))}.
+				Also, ${el("a", references.custom_elements_tips).append(el("strong", t`Handy Custom Elements Patterns`))}
+				provides useful techniques for connecting attributes with properties.
+			`)
+		),
+
+		el(h3, t`DDE Integration: Step 1 - Event Handling`),
+		el("p").append(...T`
+			The first step in integrating DDE with Web Components is enabling DDE's event system to work with your
+			Custom Elements. This is done with ${el("code", "customElementWithDDE")}, which makes your Custom Element
+			compatible with DDE's event handling.
+		`),
+		el("div", { class: "dde-function-table" }).append(
+			el("h4", t`customElementWithDDE`),
+			el("dl").append(
+				el("dt", t`Purpose`),
+				el("dd", t`Enables DDE's event system to work with your Custom Element`),
+				el("dt", t`Usage`),
+				el("dd", t`customElementWithDDE(YourElementClass)`),
+				el("dt", t`Benefits`),
+				el("dd", t`Allows using on.connected(), on.disconnected(), etc. with your element`)
+			)
+		),
+		el(example, { src: fileURL("./components/examples/customElement/customElementWithDDE.js"), page_id }),
+
+		el("div", { class: "dde-tip" }).append(
+			el("p").append(...T`
+				${el("strong", "Key Point:")} The ${el("code", "customElementWithDDE")} function adds event dispatching
+				to your Custom Element lifecycle methods, making them work seamlessly with DDE's event system.
+			`)
+		),
+
+		el(h3, t`DDE Integration: Step 2 - Rendering Components`),
+		el("p").append(...T`
+			The next step is to use DDE's component rendering within your Custom Element. This is done with
+			${el("code", "customElementRender")}, which connects your DDE component function to the Custom Element.
+		`),
+		el("div", { class: "dde-function-table" }).append(
+			el("h4", t`customElementRender`),
+			el("dl").append(
+				el("dt", t`Purpose`),
+				el("dd", t`Connects a DDE component function to a Custom Element`),
+				el("dt", t`Parameters`),
+				el("dd").append(
+					el("ol").append(
+						el("li", t`Target (usually this or this.shadowRoot)`),
+						el("li", t`Component function that returns a DOM tree`),
+						el("li", t`Optional: Attributes transformer function (default or S.observedAttributes)`)
+					)
+				),
+				el("dt", t`Returns`),
+				el("dd", t`The rendered DOM tree`)
+			)
+		),
+		el(example, { src: fileURL("./components/examples/customElement/dde.js"), page_id }),
+
+		el("div", { class: "dde-note" }).append(
+			el("p").append(...T`
+				In this example, we're using Shadow DOM (${el("code", "this.attachShadow()")}) for encapsulation,
+				but you can also render directly to the element with ${el("code", "customElementRender(this, ...)")}.
+			`)
+		),
+
+		el(h3, t`Reactive Web Components with Signals`),
+		el("p").append(...T`
+			One of the most powerful features of integrating DDE with Web Components is connecting HTML attributes
+			to DDE's reactive signals system. This creates truly reactive custom elements.
+		`),
+		el("div", { class: "dde-tip" }).append(
+			el("p").append(...T`
+				${el("strong", "Two Ways to Handle Attributes:")}
 			`),
+			el("ol").append(
+				el("li").append(...T`
+					${el("code", "observedAttributes")} - Passes attributes as regular values (static)
+				`),
+				el("li").append(...T`
+					${el("code", "S.observedAttributes")} - Transforms attributes into signals (reactive)
+				`)
+			)
+		),
+		el("p").append(...T`
+			Using ${el("code", "S.observedAttributes")} creates a reactive connection between your element's attributes
+			and its internal rendering. When attributes change, your component automatically updates!
+		`),
+		el(example, { src: fileURL("./components/examples/customElement/observedAttributes.js"), page_id }),
+
+		el("div", { class: "dde-callout" }).append(
+			el("h4", t`How S.observedAttributes Works`),
+			el("p").append(...T`
+				1. Takes each attribute listed in static observedAttributes
+				2. Creates a DDE signal for each one
+				3. Automatically updates these signals when attributes change
+				4. Passes the signals to your component function
+				5. Your component reacts to changes through signal subscriptions
+			`)
+		),
+
+		el(h3, t`Working with Shadow DOM`),
+		el("p").append(...T`
+			Shadow DOM provides encapsulation for your component's styles and markup. When using DDE with Shadow DOM,
+			you get the best of both worlds: encapsulation plus declarative DOM creation.
+		`),
+		el("div", { class: "dde-illustration" }).append(
+			el("h4", t`Shadow DOM Encapsulation`),
+			el("pre").append(el("code", `
+┌─────────────────────────────────┐
+│ <my-custom-element>             │
+│                                 │
+│  ┌─────────────────────────┐    │
+│  │ #shadow-root           │    │
+│  │                         │    │
+│  │  Created with DDE:      │    │
+│  │  ┌─────────────────┐    │    │
+│  │  │ <div>           │    │    │
+│  │  │   <h2>Title</h2> │    │    │
+│  │  │   <p>Content</p> │    │    │
+│  │  └─────────────────┘    │    │
+│  │                         │    │
+│  └─────────────────────────┘    │
+│                                 │
+└─────────────────────────────────┘
+			`))
+		),
+		el(example, { src: fileURL("./components/examples/customElement/shadowRoot.js"), page_id }),
+
+		el("p").append(...T`
+			For more information on Shadow DOM, see
+			${el("a", { textContent: t`Using Shadow DOM`, ...references.mdn_shadow_dom_depth })}, or the comprehensive
+			${el("a", { textContent: t`Shadow DOM in Depth`, ...references.shadow_dom_depth })}.
+		`),
+
+		el(h3, t`Working with Slots`),
+		el("p").append(...T`
+			Slots allow users of your component to insert content inside it. When using DDE, you can simulate the
+			slot mechanism with the ${el("code", "simulateSlots")} function:
+		`),
+		el("div", { class: "dde-function-table" }).append(
+			el("h4", t`simulateSlots`),
+			el("dl").append(
+				el("dt", t`Purpose`),
+				el("dd", t`Provides slot functionality when you cannot/do not want to use shadow DOM`),
+				el("dt", t`Parameters`),
+				el("dd", t`A mapping object of slot names to DOM elements`)
+			)
+		),
+		el(example, { src: fileURL("./components/examples/customElement/simulateSlots.js"), page_id }),
+
+		el("div", { class: "dde-tip" }).append(
+			el("p").append(...T`
+				${el("strong", "When to use simulateSlots:")} This approach is useful when you need to distribute
+				content from the light DOM into specific locations in the shadow DOM, particularly in environments
+				where native slots might not be fully supported.
+			`)
+		),
+
+		el(h3, t`Best Practices for Web Components with DDE`),
+		el("p").append(...T`
+			When combining DDE with Web Components, follow these recommendations:
+		`),
+		el("ol").append(
+			el("li").append(...T`
+				${el("strong", "Always use customElementWithDDE")} to enable event integration
+			`),
+			el("li").append(...T`
+				${el("strong", "Prefer S.observedAttributes")} for reactive attribute connections
+			`),
+			el("li").append(...T`
+				${el("strong", "Create reusable component functions")} that your custom elements render
+			`),
+			el("li").append(...T`
+				${el("strong", "Use scope.host()")} to clean up event listeners and subscriptions
+			`),
+			el("li").append(...T`
+				${el("strong", "Add setters and getters")} for better property access to your element
+			`)
+		),
+
+		el("div", { class: "dde-troubleshooting" }).append(
+			el("h4", t`Common Issues`),
+			el("dl").append(
+				el("dt", t`Events not firing properly`),
+				el("dd", t`Make sure you called customElementWithDDE before defining the element`),
+				el("dt", t`Attributes not updating`),
+				el("dd", t`Check that you've properly listed them in static observedAttributes`),
+				el("dt", t`Component not rendering`),
+				el("dd", t`Verify customElementRender is called in connectedCallback, not constructor`)
+			)
 		),
 
 		el(mnemonic)

docs/p07-debugging.html.js

@@ -0,0 +1,186 @@
+import { T, t } from "./utils/index.js";
+export const info= {
+	title: t`Debugging`,
+	description: t`Techniques for debugging applications using deka-dom-el, especially signals.`,
+};
+
+import { el } from "deka-dom-el";
+import { simplePage } from "./layout/simplePage.html.js";
+import { example } from "./components/example.html.js";
+import { h3 } from "./components/pageUtils.html.js";
+import { code } from "./components/code.html.js";
+/** @param {string} url */
+const fileURL= url=> new URL(url, import.meta.url);
+
+/** @param {import("./types.d.ts").PageAttrs} attrs */
+export function page({ pkg, info }){
+	const page_id= info.id;
+	return el(simplePage, { info, pkg }).append(
+		el("h2", t`Debugging applications with deka-dom-el`),
+		el("p").append(...T`
+			Debugging is an essential part of application development. This guide provides techniques
+			and best practices for debugging applications built with deka-dom-el, with a focus on signals.
+		`),
+
+		el(h3, t`Debugging signals`),
+		el("p").append(...T`
+			Signals are reactive primitives that update the UI when their values change. When debugging signals,
+			you need to track their values, understand their dependencies, and identify why updates are or aren't happening.
+		`),
+
+		el("h4", t`Inspecting signal values`),
+		el("p").append(...T`
+			The simplest way to debug a signal is to log its current value by calling the get method:
+		`),
+		el(code, { content: "const signal = S(0);\nconsole.log('Current value:', signal.get());", page_id }),
+		el("p").append(...T`
+			You can also monitor signal changes by adding a listener:
+		`),
+		el(code, {
+			content:
+			"// Log every time the signal changes\nS.on(signal, value => console.log('Signal changed:', value));",
+			page_id }),
+
+		el("h4", t`Debugging derived signals`),
+		el("p").append(...T`
+			With derived signals (created with S(() => computation)), debugging is a bit more complex
+			because the value depends on other signals. To understand why a derived signal isn't updating correctly:
+		`),
+		el("ol").append(
+			el("li", t`Check that all dependency signals are updating correctly`),
+			el("li", t`Add logging inside the computation function to see when it runs`),
+			el("li", t`Verify that the computation function actually accesses the signal values with .get()`)
+		),
+		el(example, { src: fileURL("./components/examples/debugging/consoleLog.js"), page_id }),
+
+		el(h3, t`Common signal debugging issues`),
+		el("h4", t`Signal updates not triggering UI changes`),
+		el("p").append(...T`
+			If signal updates aren't reflected in the UI, check:
+		`),
+		el("ul").append(
+			el("li", t`That you're using signal.set() to update the value, not modifying objects/arrays directly`),
+			el("li", t`For mutable objects, ensure you're using actions or making proper copies before updating`),
+			el("li", t`That the signal is actually connected to the DOM element (check your S.el or attribute binding code)`)
+		),
+		el(code, { src: fileURL("./components/examples/debugging/mutations.js"), page_id }),
+
+		el("h4", t`Memory leaks with signal listeners`),
+		el("p").append(...T`
+			Signal listeners can cause memory leaks if not properly cleaned up. Always use AbortSignal
+			to cancel listeners.
+		`),
+
+		el("h4", t`Performance issues with frequently updating signals`),
+		el("p").append(...T`
+			If you notice performance issues with signals that update very frequently:
+		`),
+		el("ul").append(
+			el("li", t`Consider debouncing or throttling signal updates`),
+			el("li", t`Make sure derived signals don't perform expensive calculations unnecessarily`),
+			el("li", t`Keep signal computations focused and minimal`)
+		),
+		el(code, { src: fileURL("./components/examples/debugging/debouncing.js"), page_id }),
+
+		el(h3, t`Browser DevTools tips for deka-dom-el`),
+		el("p").append(...T`
+			When debugging in the browser, deka-dom-el provides several helpful DevTools-friendly features:
+		`),
+
+		el("h4", t`Identifying components in the DOM`),
+		el("p").append(...T`
+			deka-dom-el marks components in the DOM with special comment nodes to help you identify component boundaries.
+			Components created with ${el("code", "el(ComponentFunction)")} are marked with comment nodes
+			${el("code", "<!--<dde:mark type=\"component\" name=\"MyComponent\" host=\"parentElement\"/>-->")} and
+			includes:
+		`),
+		el("ul").append(
+			el("li", "type - Identifies the type of marker (\"component\", \"reactive\", or \"later\")"),
+			el("li", "name - The name of the component function"),
+			el("li", "host - Indicates whether the host is \"this\" (for DocumentFragments) or \"parentElement\""),
+		),
+
+		el("h4", t`Finding reactive elements in the DOM`),
+		el("p").append(...T`
+			When using ${el("code", "S.el()")}, deka-dom-el creates reactive elements in the DOM
+			that are automatically updated when signal values change. These elements are wrapped in special
+			comment nodes for debugging (to be true they are also used internaly, so please do not edit them by hand):
+		`),
+		el(code, { src: fileURL("./components/examples/debugging/dom-reactive-mark.js"), page_id }),
+		el("p").append(...T`
+			This is particularly useful when debugging why a reactive section isn't updating as expected.
+			You can inspect the elements between the comment nodes to see their current state and the
+			signal connections through \`__dde_reactive\` of the host element.
+		`),
+
+		el("h4", t`DOM inspection properties`),
+		el("p").append(...T`
+			Elements created with the deka-dom-el library have special properties to aid in debugging:
+		`),
+		el("ul").append(
+			el("li").append(...T`
+				${el("code", "__dde_reactive")} - An array property on DOM elements that tracks signal-to-element relationships.
+				This allows you to quickly identify which elements are reactive and what signals they're bound to.
+				Each entry in the array contains:
+			`),
+			el("ul").append(
+				el("li", "A pair of signal and listener function: [signal, listener]"),
+				el("li", "Additional context information about the element or attribute"),
+				el("li", "Automatically managed by signal.el(), signal.observedAttributes(), and processReactiveAttribute()")
+			),
+			el("li").append(...T`
+				${el("code", "__dde_signal")} - A Symbol property used to identify and store the internal state of signal objects.
+				It contains the following information:
+			`),
+			el("ul").append(
+				el("li", "value: The current value of the signal"),
+				el("li", "listeners: A Set of functions called when the signal value changes"),
+				el("li", "actions: Custom actions that can be performed on the signal"),
+				el("li", "onclear: Functions to run when the signal is cleared"),
+				el("li", "host: Reference to the host element or scope"),
+				el("li", "defined: Stack trace information for debugging"),
+				el("li", "readonly: Boolean flag indicating if the signal is read-only")
+			),
+		),
+		el("p").append(...T`
+			These properties make it easier to understand the reactive structure of your application when inspecting elements.
+		`),
+		el(example, { src: fileURL("./components/examples/signals/debugging-dom.js"), page_id }),
+
+		el("h4", t`Examining signal connections`),
+		el("p").append(...T`
+			You can inspect signal relationships and bindings in the DevTools console using ${el("code", "$0.__dde_reactive")}.
+			In console you will see list of ${el("code", "[ [ signal, listener ], element, property ]")}, where:
+		`),
+		el("ul").append(
+			el("li", "signal — the signal triggering the changes"),
+			el("li", "listener — the listener function (this is internal function for dde)"),
+			el("li", "element — the DOM element that is bound to the signal"),
+			el("li", "property — the attribute or property name which is changing based on the signal"),
+		),
+		el("p").append(...T`
+			…the structure of \`__dde_reactive\` use the behavior of the browser that packs the first field,
+			so you can see the element and property that changes in the console right away
+		`),
+
+		el("h4", t`Debugging with breakpoints`),
+		el("p").append(...T`
+			Effective use of breakpoints can help track signal flow:
+		`),
+		el("ul").append(
+			el("li").append(...T`
+				Set breakpoints in signal update methods to track when values change
+			`),
+			el("li").append(...T`
+				Use conditional breakpoints to only break when specific signals change to certain values
+			`),
+			el("li").append(...T`
+				Set breakpoints in your signal computation functions to see when derived signals recalculate
+			`),
+			el("li").append(...T`
+				Use performance profiling to identify bottlenecks in signal updates
+			`)
+		),
+
+	);
+}

docs/p07-debugging.html.old.js

@@ -0,0 +1,102 @@
+import { T, t } from "./utils/index.js";
+export const info= {
+	title: t`Debugging`,
+	description: t`Techniques for debugging applications using deka-dom-el, especially signals.`,
+};
+
+import { el } from "deka-dom-el";
+import { simplePage } from "./layout/simplePage.html.js";
+import { example } from "./components/example.html.js";
+import { h3 } from "./components/pageUtils.html.js";
+import { code } from "./components/code.html.js";
+/** @param {string} url */
+const fileURL= url=> new URL(url, import.meta.url);
+
+/** @param {import("./types.d.ts").PageAttrs} attrs */
+export function page({ pkg, info }){
+	const page_id= info.id;
+	return el(simplePage, { info, pkg }).append(
+		el("h2", t`Debugging applications with deka-dom-el`),
+		el("p").append(...T`
+			Debugging is an essential part of application development. This guide provides techniques
+			and best practices for debugging applications built with deka-dom-el, with a focus on signals.
+		`),
+
+		el(h3, t`Debugging signals`),
+		el("p").append(...T`
+			Signals are reactive primitives that update the UI when their values change. When debugging signals,
+			you need to track their values, understand their dependencies, and identify why updates are or aren't happening.
+		`),
+
+		el("h4", t`Inspecting signal values`),
+		el("p").append(...T`
+			The simplest way to debug a signal is to log its current value by calling the get method:
+		`),
+		el("pre").append(
+			el("code", "const signal = S(0);\nconsole.log('Current value:', signal.get());")
+		),
+		el("p").append(...T`
+			You can also monitor signal changes by adding a listener:
+		`),
+		el("pre").append(
+			el("code", "// Log every time the signal changes\nS.on(signal, value => console.log('Signal changed:', value));")
+		),
+
+		el("h4", t`Debugging derived signals`),
+		el("p").append(...T`
+			With derived signals (created with S(() => computation)), debugging is a bit more complex
+			because the value depends on other signals. To understand why a derived signal isn't updating correctly:
+		`),
+		el("ol").append(
+			el("li", t`Check that all dependency signals are updating correctly`),
+			el("li", t`Add logging inside the computation function to see when it runs`),
+			el("li", t`Verify that the computation function actually accesses the signal values with .get()`)
+		),
+		el(example, { src: fileURL("./components/examples/debugging/consoleLog.js"), page_id }),
+
+		el(h3, t`Common signal debugging issues`),
+		el("h4", t`Signal updates not triggering UI changes`),
+		el("p").append(...T`
+			If signal updates aren't reflected in the UI, check:
+		`),
+		el("ul").append(
+			el("li", t`That you're using signal.set() to update the value, not modifying objects/arrays directly`),
+			el("li", t`For mutable objects, ensure you're using actions or making proper copies before updating`),
+			el("li", t`That the signal is actually connected to the DOM element (check your S.el or attribute binding code)`)
+		),
+		el(code, { src: fileURL("./components/examples/debugging/mutations.js"), page_id }),
+
+		el("h4", t`Memory leaks with signal listeners`),
+		el("p").append(...T`
+			Signal listeners can cause memory leaks if not properly cleaned up. Always use AbortSignal
+			to cancel listeners.
+		`),
+
+		el("h4", t`Performance issues with frequently updating signals`),
+		el("p").append(...T`
+			If you notice performance issues with signals that update very frequently:
+		`),
+		el("ul").append(
+			el("li", t`Consider debouncing or throttling signal updates`),
+			el("li", t`Make sure derived signals don't perform expensive calculations unnecessarily`),
+			el("li", t`Keep signal computations focused and minimal`)
+		),
+		el(code, { src: fileURL("./components/examples/debugging/debouncing.js"), page_id }),
+
+		el(h3, t`Browser DevTools tips for deka-dom-el`),
+		el("p").append(...T`
+			When debugging in the browser, here are some helpful techniques:
+		`),
+		el("ul").append(
+			el("li").append(...T`
+				Use the Elements panel to inspect the DOM structure created by deka-dom-el
+			`),
+			el("li").append(...T`
+				Set breakpoints in your signal handlers and actions
+			`),
+			el("li").append(...T`
+				Use performance profiling to identify bottlenecks in signal updates
+			`),
+		),
+	);
+}

docs/p08-ssr.html.js

@@ -0,0 +1,129 @@
+import { T, t } from "./utils/index.js";
+export const info= {
+	title: t`Server-Side Rendering (SSR)`,
+	description: t`Using deka-dom-el for server-side rendering with jsdom to generate static HTML.`,
+};
+
+import { el } from "deka-dom-el";
+import { simplePage } from "./layout/simplePage.html.js";
+import { h3 } from "./components/pageUtils.html.js";
+import { code } from "./components/code.html.js";
+/** @param {string} url */
+const fileURL= url=> new URL(url, import.meta.url);
+
+/** @param {import("./types.d.ts").PageAttrs} attrs */
+export function page({ pkg, info }){
+	const page_id= info.id;
+	return el(simplePage, { info, pkg }).append(
+		el("h2", t`Server-Side Rendering with deka-dom-el`),
+		el("p").append(...T`
+			deka-dom-el isn't limited to browser environments. Thanks to its flexible architecture,
+			it can be used for server-side rendering (SSR) to generate static HTML files.
+			This is achieved through integration with for example ${el("a", { href: "https://github.com/tmpvar/jsdom",
+			textContent: "jsdom" })}, a JavaScript implementation of web standards for Node.js.
+		`),
+		el(code, { src: fileURL("./components/examples/ssr/intro.js"), page_id }),
+
+		el(h3, t`Why Server-Side Rendering?`),
+		el("p").append(...T`
+			SSR offers several benefits:
+		`),
+		el("ul").append(
+			el("li", t`Improved SEO - Search engines can easily index fully rendered content`),
+			el("li", t`Faster initial page load - Users see content immediately without waiting for JavaScript to load`),
+			el("li", t`Better performance on low-powered devices - Less JavaScript processing on the client`),
+			el("li", t`Content available without JavaScript - Useful for users who have disabled JavaScript`),
+			el("li", t`Static site generation - Build files once, serve them many times`)
+		),
+
+		el(h3, t`How jsdom Integration Works`),
+		el("p").append(...T`
+			The jsdom export in deka-dom-el provides the necessary tools to use the library in Node.js
+			by integrating with jsdom. Here's what it does:
+		`),
+		el("ol").append(
+			el("li", t`Creates a virtual DOM environment in Node.js using jsdom`),
+			el("li", t`Registers DOM globals like HTMLElement, document, etc. for deka-dom-el to use`),
+			el("li", t`Sets an SSR flag in the environment to enable SSR-specific behaviors`),
+			el("li", t`Provides a promise queue system for managing async operations during rendering`),
+			el("li", t`Handles DOM property/attribute mapping differences between browsers and jsdom`)
+		),
+		el(code, { src: fileURL("./components/examples/ssr/start.js"), page_id }),
+
+		el(h3, t`Basic SSR Example`),
+		el("p").append(...T`
+			Here's a simple example of how to use deka-dom-el for server-side rendering in a Node.js script:
+		`),
+		el(code, { src: fileURL("./components/examples/ssr/basic-example.js"), page_id }),
+
+		el(h3, t`Building a Static Site Generator`),
+		el("p").append(...T`
+			You can build a complete static site generator with deka-dom-el. In fact, this documentation site
+			is built using deka-dom-el for server-side rendering! Here's how the documentation build process works:
+		`),
+		el(code, { src: fileURL("./components/examples/ssr/static-site-generator.js"), page_id }),
+
+		el(h3, t`Working with Async Content in SSR`),
+		el("p").append(...T`
+			The jsdom export includes a queue system to handle asynchronous operations during rendering.
+			This is crucial for components that fetch data or perform other async tasks.
+		`),
+		el(code, { src: fileURL("./components/examples/ssr/async-data.js"), page_id }),
+
+		el(h3, t`Working with Dynamic Imports for SSR`),
+		el("p").append(...T`
+			When structuring server-side rendering code, a crucial pattern to follow is using dynamic imports
+			for both the deka-dom-el/jsdom module and your page components.
+		`),
+		el("p").append(...T`
+			Why is this important?
+		`),
+		el("ul").append(
+			el("li").append(...T`
+				${el("strong", "Static imports are hoisted:")} JavaScript hoists import statements to the top of the file,
+				executing them before any other code
+			`),
+			el("li").append(...T`
+				${el("strong", "Environment registration timing:")} The jsdom module auto-registers the DOM environment
+				when imported, which must happen ${el("em", "after")} you've created your JSDOM instance and
+				${el("em", "before")} you import your components using ${el("code", "import { el } from \"deka-dom-el\";")}.
+			`),
+			el("li").append(...T`
+				${el("strong", "Correct initialization order:")} You need to control the exact sequence of:
+				create JSDOM → register environment → import components
+			`)
+		),
+		el("p").append(...T`
+			Follow this pattern when creating server-side rendered pages:
+		`),
+		el(code, { src: fileURL("./components/examples/ssr/pages.js"), page_id }),
+
+		el(h3, t`SSR Considerations and Limitations`),
+		el("p").append(...T`
+			When using deka-dom-el for SSR, keep these considerations in mind:
+		`),
+		el("ul").append(
+			el("li", t`Browser-specific APIs like window.localStorage are not available in jsdom by default`),
+			el("li", t`Event listeners added during SSR won't be functional in the final HTML unless hydrated on the client`),
+			el("li", t`Some DOM features may behave differently in jsdom compared to real browsers`),
+			el("li", t`For large sites, you may need to optimize memory usage by creating a new jsdom instance for each page`)
+		),
+		el("p").append(...T`
+			For advanced SSR applications, consider implementing hydration on the client-side to restore
+			interactivity after the initial render.
+		`),
+
+		el(h3, t`Real Example: How This Documentation is Built`),
+		el("p").append(...T`
+			This documentation site itself is built using deka-dom-el's SSR capabilities.
+			The build process collects all page components, renders them with jsdom, and outputs static HTML files.
+		`),
+		el(code, { src: fileURL("./components/examples/ssr/static-site-generator.js"), page_id }),
+
+		el("p").append(...T`
+			The resulting static files can be deployed to any static hosting service,
+			providing fast loading times and excellent SEO without the need for client-side JavaScript
+			to render the initial content.
+		`),
+	);
+}

index.d.ts

@@ -54,7 +54,8 @@ type IsReadonly<T, K extends keyof T> =
 type ElementAttributes<T extends SupportedElement>= Partial<{
 	[K in keyof _fromElsInterfaces<T>]:
 		_fromElsInterfaces<T>[K] extends ((...p: any[])=> any)
-			? _fromElsInterfaces<T>[K] | ((...p: Parameters<_fromElsInterfaces<T>[K]>)=> ddeSignal<ReturnType<_fromElsInterfaces<T>[K]>>)
+			? _fromElsInterfaces<T>[K] | ((...p: Parameters<_fromElsInterfaces<T>[K]>)=>
+																	ddeSignal<ReturnType<_fromElsInterfaces<T>[K]>>)
 			: (IsReadonly<_fromElsInterfaces<T>, K> extends false
 				? _fromElsInterfaces<T>[K] | ddeSignal<_fromElsInterfaces<T>[K]>
 				: ddeStringable)

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "deka-dom-el",
-	"version": "0.8.0",
+	"version": "0.9.0",
 	"description": "A low-code library that simplifies the creation of native DOM elements/components using small wrappers and tweaks.",
 	"author": "Jan Andrle <andrle.jan@centrum.cz>",
 	"license": "MIT",
@@ -92,11 +92,11 @@
 		"typescript"
 	],
 	"devDependencies": {
-		"@size-limit/preset-small-lib": "~11.0",
+		"@size-limit/preset-small-lib": "~11.2",
 		"dts-bundler": "~0.1",
 		"editorconfig-checker": "~6.0",
-		"esbuild": "~0.24",
+		"esbuild": "~0.25",
-		"jsdom": "~25.0",
+		"jsdom": "~26.0",
 		"jshint": "~2.13",
 		"nodejsscript": "^1.0.2",
 		"size-limit-node-esbuild": "~0.3"

src/events-observer.js

@@ -96,7 +96,6 @@ function connectionsChangesObserverConstructor(){
 		offDisconnected(element, listener){
 			if(!store.has(element)) return;
 			const ls= store.get(element);
-			if(!ls.disconnected.has(listener)) return;
 			ls.disconnected.delete(listener);
 			ls.length_d-= 1;
 			cleanWhenOff(element, ls);