snapse 0.0.0-stage → 0.9.0

package/dist/DOM/domFunctions.d.ts

@@ -0,0 +1,12 @@
+import { ChildProp, ComponentFactory, ComponentFunctionBody, ComponentProps, DOMElementArguments, DOMElementAttributes, ElementOptions, RootOptions } from './types.js';
+import { ElementController } from './nodeControllers/ElementController.js';
+import { SVGElementController } from './nodeControllers/SVGElementController.js';
+import { RootController } from './nodeControllers/RootController.js';
+export declare const component: <T = ComponentProps>(definition: ComponentFunctionBody<T & {
+    children: ChildProp[];
+}>) => ComponentFactory;
+export declare const domElement: <U extends ElementOptions = DOMElementAttributes>(elementName: string) => <T extends DOMElementArguments<U>>(...args: NoInfer<T>) => ElementController;
+export declare const svgElement: <U extends ElementOptions = DOMElementAttributes>(elementName: string) => <T extends DOMElementArguments<U>>(...args: NoInfer<T>) => SVGElementController;
+type RootArguments = ChildProp[] | [RootOptions?, ...ChildProp[]];
+export declare const SnapseRoot: (...args: RootArguments) => RootController;
+export {};

package/dist/DOM/elements/DOMElements.d.ts

@@ -0,0 +1,141 @@
+import { ElementController } from '../nodeControllers/ElementController.js';
+import { DOMElementArguments } from '../types.js';
+import { ElementAttributesOf } from './elementAttributeTypes.js';
+import { State } from '../../state/types/types.js';
+type NumericHTMLInputElement = Omit<HTMLInputElement, 'value' | 'type'> & {
+    value: number;
+    type: 'number' | 'range';
+};
+type CheckboxHTMLInputElement = Omit<HTMLInputElement, 'type'> & {
+    type: 'checkbox' | 'radio';
+};
+type StandardInputType = 'text' | 'search' | 'tel' | 'url' | 'email' | 'password' | 'date' | 'month' | 'week' | 'time' | 'datetime-local' | 'file' | 'color' | 'hidden' | 'submit' | 'reset' | 'button' | 'image';
+type StandardHTMLInputElement = Omit<HTMLInputElement, 'type'> & {
+    type: StandardInputType;
+};
+type ExcludeAutoBind<Attrs, Excluded> = {
+    [K in 'change' | 'input']?: Exclude<Attrs[K & keyof Attrs], Excluded>;
+};
+type NumericInputAttributes = Omit<ElementAttributesOf<NumericHTMLInputElement>, 'change' | 'input'> & ExcludeAutoBind<ElementAttributesOf<NumericHTMLInputElement>, State<boolean | null | undefined>> & {
+    type: 'number' | 'range';
+};
+type CheckboxInputAttributes = Omit<ElementAttributesOf<CheckboxHTMLInputElement>, 'change' | 'input'> & ExcludeAutoBind<ElementAttributesOf<CheckboxHTMLInputElement>, State<string | null | undefined>> & {
+    type: 'checkbox' | 'radio';
+};
+type StandardInputAttributes = Omit<ElementAttributesOf<StandardHTMLInputElement>, 'change' | 'input'> & ExcludeAutoBind<ElementAttributesOf<StandardHTMLInputElement>, State<boolean | null | undefined>>;
+declare function inputFactory(...args: DOMElementArguments<NumericInputAttributes>): ElementController;
+declare function inputFactory(...args: DOMElementArguments<CheckboxInputAttributes>): ElementController;
+declare function inputFactory(...args: DOMElementArguments<StandardInputAttributes>): ElementController;
+export declare const a: <T extends DOMElementArguments<ElementAttributesOf<HTMLAnchorElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const abbr: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const address: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const area: <T extends DOMElementArguments<ElementAttributesOf<HTMLAreaElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const article: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const aside: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const audio: <T extends DOMElementArguments<ElementAttributesOf<HTMLAudioElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const b: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const base: <T extends DOMElementArguments<ElementAttributesOf<HTMLBaseElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const bdi: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const bdo: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const blockquote: <T extends DOMElementArguments<ElementAttributesOf<HTMLQuoteElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const body: <T extends DOMElementArguments<ElementAttributesOf<HTMLBodyElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const br: <T extends DOMElementArguments<ElementAttributesOf<HTMLBRElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const button: <T extends DOMElementArguments<ElementAttributesOf<HTMLButtonElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const canvas: <T extends DOMElementArguments<ElementAttributesOf<HTMLCanvasElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const caption: <T extends DOMElementArguments<ElementAttributesOf<HTMLTableCaptionElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const cite: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const code: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const col: <T extends DOMElementArguments<ElementAttributesOf<HTMLTableColElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const colgroup: <T extends DOMElementArguments<ElementAttributesOf<HTMLTableColElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const data: <T extends DOMElementArguments<ElementAttributesOf<HTMLDataElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const datalist: <T extends DOMElementArguments<ElementAttributesOf<HTMLDataListElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const dd: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const del: <T extends DOMElementArguments<ElementAttributesOf<HTMLModElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const details: <T extends DOMElementArguments<ElementAttributesOf<HTMLDetailsElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const dfn: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const dialog: <T extends DOMElementArguments<ElementAttributesOf<HTMLDialogElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const div: <T extends DOMElementArguments<ElementAttributesOf<HTMLDivElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const dl: <T extends DOMElementArguments<ElementAttributesOf<HTMLDListElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const dt: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const em: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const embed: <T extends DOMElementArguments<ElementAttributesOf<HTMLEmbedElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const fieldset: <T extends DOMElementArguments<ElementAttributesOf<HTMLFieldSetElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const figcaption: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const figure: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const footer: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const form: <T extends DOMElementArguments<ElementAttributesOf<HTMLFormElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const h1: <T extends DOMElementArguments<ElementAttributesOf<HTMLHeadingElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const h2: <T extends DOMElementArguments<ElementAttributesOf<HTMLHeadingElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const h3: <T extends DOMElementArguments<ElementAttributesOf<HTMLHeadingElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const h4: <T extends DOMElementArguments<ElementAttributesOf<HTMLHeadingElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const h5: <T extends DOMElementArguments<ElementAttributesOf<HTMLHeadingElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const h6: <T extends DOMElementArguments<ElementAttributesOf<HTMLHeadingElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const head: <T extends DOMElementArguments<ElementAttributesOf<HTMLHeadElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const header: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const hgroup: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const hr: <T extends DOMElementArguments<ElementAttributesOf<HTMLHRElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const html: <T extends DOMElementArguments<ElementAttributesOf<HTMLHtmlElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const i: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const iframe: <T extends DOMElementArguments<ElementAttributesOf<HTMLIFrameElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const img: <T extends DOMElementArguments<ElementAttributesOf<HTMLImageElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const input: typeof inputFactory;
+export declare const ins: <T extends DOMElementArguments<ElementAttributesOf<HTMLModElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const kbd: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const label: <T extends DOMElementArguments<ElementAttributesOf<HTMLLabelElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const legend: <T extends DOMElementArguments<ElementAttributesOf<HTMLLegendElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const li: <T extends DOMElementArguments<ElementAttributesOf<HTMLLIElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const link: <T extends DOMElementArguments<ElementAttributesOf<HTMLLinkElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const main: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const map: <T extends DOMElementArguments<ElementAttributesOf<HTMLMapElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const mark: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const menu: <T extends DOMElementArguments<ElementAttributesOf<HTMLMenuElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const meta: <T extends DOMElementArguments<ElementAttributesOf<HTMLMetaElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const meter: <T extends DOMElementArguments<ElementAttributesOf<HTMLMeterElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const nav: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const noscript: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const object: <T extends DOMElementArguments<ElementAttributesOf<HTMLObjectElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const ol: <T extends DOMElementArguments<ElementAttributesOf<HTMLOListElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const optgroup: <T extends DOMElementArguments<ElementAttributesOf<HTMLOptGroupElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const option: <T extends DOMElementArguments<ElementAttributesOf<HTMLOptionElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const output: <T extends DOMElementArguments<ElementAttributesOf<HTMLOutputElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const p: <T extends DOMElementArguments<ElementAttributesOf<HTMLParagraphElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const picture: <T extends DOMElementArguments<ElementAttributesOf<HTMLPictureElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const pre: <T extends DOMElementArguments<ElementAttributesOf<HTMLPreElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const progress: <T extends DOMElementArguments<ElementAttributesOf<HTMLProgressElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const q: <T extends DOMElementArguments<ElementAttributesOf<HTMLQuoteElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const rp: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const rt: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const ruby: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const s: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const samp: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const script: <T extends DOMElementArguments<ElementAttributesOf<HTMLScriptElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const search: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const section: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const select: <T extends DOMElementArguments<ElementAttributesOf<HTMLSelectElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const slot: <T extends DOMElementArguments<ElementAttributesOf<HTMLSlotElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const small: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const source: <T extends DOMElementArguments<ElementAttributesOf<HTMLSourceElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const span: <T extends DOMElementArguments<ElementAttributesOf<HTMLSpanElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const strong: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const style: <T extends DOMElementArguments<ElementAttributesOf<HTMLStyleElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const sub: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const summary: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const sup: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const table: <T extends DOMElementArguments<ElementAttributesOf<HTMLTableElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const tbody: <T extends DOMElementArguments<ElementAttributesOf<HTMLTableSectionElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const td: <T extends DOMElementArguments<ElementAttributesOf<HTMLTableCellElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const template: <T extends DOMElementArguments<ElementAttributesOf<HTMLTemplateElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const textarea: <T extends DOMElementArguments<ElementAttributesOf<HTMLTextAreaElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const tfoot: <T extends DOMElementArguments<ElementAttributesOf<HTMLTableSectionElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const th: <T extends DOMElementArguments<ElementAttributesOf<HTMLTableCellElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const thead: <T extends DOMElementArguments<ElementAttributesOf<HTMLTableSectionElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const time: <T extends DOMElementArguments<ElementAttributesOf<HTMLTimeElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const title: <T extends DOMElementArguments<ElementAttributesOf<HTMLTitleElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const tr: <T extends DOMElementArguments<ElementAttributesOf<HTMLTableRowElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const track: <T extends DOMElementArguments<ElementAttributesOf<HTMLTrackElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const u: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const ul: <T extends DOMElementArguments<ElementAttributesOf<HTMLUListElement>>>(...args: NoInfer<T>) => ElementController;
+declare const cvar: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;
+export { cvar as var };
+export declare const video: <T extends DOMElementArguments<ElementAttributesOf<HTMLVideoElement>>>(...args: NoInfer<T>) => ElementController;
+export declare const wbr: <T extends DOMElementArguments<ElementAttributesOf<HTMLElement>>>(...args: NoInfer<T>) => ElementController;

package/dist/DOM/elements/SVGElements.d.ts

@@ -0,0 +1,65 @@
+import { ElementAttributesOf } from './elementAttributeTypes.js';
+export declare const a: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGAElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const animate: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGAnimateElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const animateMotion: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGAnimateMotionElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const animateTransform: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGAnimateTransformElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const circle: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGCircleElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const clipPath: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGClipPathElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const defs: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGDefsElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const desc: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGDescElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const ellipse: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGEllipseElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feBlend: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEBlendElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feColorMatrix: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEColorMatrixElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feComponentTransfer: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEComponentTransferElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feComposite: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFECompositeElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feConvolveMatrix: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEConvolveMatrixElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feDiffuseLighting: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEDiffuseLightingElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feDisplacementMap: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEDisplacementMapElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feDistantLight: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEDistantLightElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feDropShadow: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEDropShadowElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feFlood: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEFloodElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feFuncA: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEFuncAElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feFuncB: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEFuncBElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feFuncG: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEFuncGElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feFuncR: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEFuncRElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feGaussianBlur: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEGaussianBlurElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feImage: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEImageElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feMerge: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEMergeElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feMergeNode: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEMergeNodeElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feMorphology: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEMorphologyElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feOffset: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEOffsetElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const fePointLight: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFEPointLightElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feSpecularLighting: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFESpecularLightingElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feSpotLight: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFESpotLightElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feTile: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFETileElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const feTurbulence: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFETurbulenceElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const filter: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGFilterElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const foreignObject: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGForeignObjectElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const g: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGGElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const image: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGImageElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const line: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGLineElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const linearGradient: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGLinearGradientElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const marker: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGMarkerElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const mask: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGMaskElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const metadata: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGMetadataElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const mpath: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGMPathElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const path: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGPathElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const pattern: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGPatternElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const polygon: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGPolygonElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const polyline: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGPolylineElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const radialGradient: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGRadialGradientElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const rect: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGRectElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const script: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGScriptElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const set: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGSetElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const stop: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGStopElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const style: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGStyleElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const svg: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGSVGElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+declare const cswitch: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGSwitchElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export { cswitch as switch };
+export declare const symbol: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGSymbolElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const text: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGTextElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const textPath: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGTextPathElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const title: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGTitleElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const tspan: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGTSpanElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const use: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGUseElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;
+export declare const view: <T extends import('../types.ts').DOMElementArguments<ElementAttributesOf<SVGViewElement>>>(...args: NoInfer<T>) => import('../nodeControllers/SVGElementController.ts').SVGElementController;

package/dist/DOM/elements/elementAttributeTypes.d.ts

@@ -0,0 +1,100 @@
+import { ObjectStateOf, State } from '../../state/types/types.js';
+import { CSSStyleDeclaration, ElementClassValue, MaybeState, StringablePrimitive } from '../types.js';
+type EventHandlerKeys<E> = {
+    [K in keyof E]-?: K extends `on${string}` ? NonNullable<E[K]> extends (this: any, ev: infer _Ev) => any ? K : never : never;
+}[keyof E];
+type RawElementEventMap<E> = {
+    [K in EventHandlerKeys<E> as K extends `on${infer Name}` ? Name : never]: NonNullable<E[K]> extends (this: any, ev: infer Ev) => any ? Ev : never;
+};
+type EventsWithoutHandlerProperty<E> = E extends GlobalEventHandlers ? Omit<GlobalEventHandlersEventMap, keyof RawElementEventMap<E>> : object;
+type EventMapOf<E> = RawElementEventMap<E> & EventsWithoutHandlerProperty<E>;
+type NarrowedEventMap<E> = {
+    [K in keyof EventMapOf<E>]: EventMapOf<E>[K] & {
+        target: E;
+        currentTarget: E;
+    };
+};
+type EventListenerOptionsArg = AddEventListenerOptions | boolean;
+type EventListenerTuple<Ev> = readonly [((ev: Ev) => void) | EventListenerObject, EventListenerOptionsArg?];
+type BareEventListenerValue<Ev> = ((ev: Ev) => void) | EventListenerTuple<Ev>;
+type AutoBindableEventKey = 'change' | 'input';
+type ValueTypeOf<E> = E extends {
+    value: infer V;
+} ? V : never;
+type CheckedTypeOf<E> = E extends {
+    checked: infer C;
+} ? C : never;
+type EventListenersOf<E> = {
+    [K in keyof NarrowedEventMap<E>]?: BareEventListenerValue<NarrowedEventMap<E>[K]> | State<BareEventListenerValue<NarrowedEventMap<E>[K]> | null | undefined> | (K extends AutoBindableEventKey ? (ValueTypeOf<E> extends (string | number) ? State<ValueTypeOf<E> | null | undefined> : never) : never) | (K extends AutoBindableEventKey ? (CheckedTypeOf<E> extends boolean ? State<CheckedTypeOf<E> | null | undefined> : never) : never);
+};
+type IsReadonlyKey<E, K extends keyof E> = (<T>() => T extends {
+    [P in K]: E[K];
+} ? 1 : 2) extends (<T>() => T extends {
+    -readonly [P in K]: E[K];
+} ? 1 : 2) ? false : true;
+type Nullish = null | undefined;
+type PrimitiveSubvalue = string | number | bigint | boolean | Nullish;
+type SettableKeys<E> = {
+    [K in keyof E]-?: K extends `on${string}` ? never : IsReadonlyKey<E, K> extends true ? never : E[K] extends PrimitiveSubvalue ? K : never;
+}[keyof E];
+type ExcludedAttrKeys = 'className' | 'htmlFor' | 'acceptCharset' | 'httpEquiv';
+type IsAnimatedWrapper<T> = T extends {
+    baseVal: unknown;
+} ? true : false;
+type ReflectedSvgKeys<E> = {
+    [K in keyof E]-?: K extends `on${string}` ? never : IsAnimatedWrapper<NonNullable<E[K]>> extends true ? K : never;
+}[keyof E];
+type TokenListKeys<E> = {
+    [K in keyof E]-?: K extends `${string}List` ? never : NonNullable<E[K]> extends DOMTokenList ? K : never;
+}[keyof E];
+type AttrsOf<E> = Partial<Pick<E, Exclude<SettableKeys<E>, ExcludedAttrKeys>>> & {
+    [K in ReflectedSvgKeys<E>]?: string | number | boolean;
+} & {
+    [K in Exclude<TokenListKeys<E>, ExcludedAttrKeys>]?: string;
+};
+type InterpolatedAttrValue = readonly MaybeState<PrimitiveSubvalue>[];
+type Stringlike<T> = T extends string ? T | number | bigint : T;
+type ReactiveAttrsOf<E> = {
+    [K in keyof AttrsOf<E>]: MaybeState<Stringlike<AttrsOf<E>[K]>> | InterpolatedAttrValue;
+};
+type SvgPresentationAttrs = {
+    d?: MaybeState<string>;
+    points?: MaybeState<string>;
+    fill?: MaybeState<string>;
+    stroke?: MaybeState<string>;
+    'stroke-width'?: MaybeState<string | number>;
+    'stroke-dasharray'?: MaybeState<string>;
+    'stroke-linecap'?: MaybeState<string>;
+    'stroke-linejoin'?: MaybeState<string>;
+    'stroke-opacity'?: MaybeState<string | number>;
+    'fill-opacity'?: MaybeState<string | number>;
+    opacity?: MaybeState<string | number>;
+    offset?: MaybeState<string | number>;
+    'stop-color'?: MaybeState<string>;
+    'stop-opacity'?: MaybeState<string | number>;
+    'text-anchor'?: MaybeState<string>;
+    'font-family'?: MaybeState<string>;
+    'font-size'?: MaybeState<string | number>;
+    'clip-path'?: MaybeState<string>;
+    'dominant-baseline'?: MaybeState<string>;
+};
+type SvgOnly<E> = E extends SVGElement ? SvgPresentationAttrs : object;
+export type FrameworkProps<E> = {
+    class?: ElementClassValue;
+    style?: CSSStyleDeclaration | ObjectStateOf<CSSStyleDeclaration>;
+    nodeCreated?: (a: {
+        target?: E;
+    }) => void;
+    nodeInserted?: (a: {
+        target?: E;
+    }) => void;
+    nodeRemoved?: (a: {
+        target?: E;
+    }) => void;
+    part?: MaybeState<string>;
+} & {
+    [key: `aria-${string}`]: MaybeState<StringablePrimitive | boolean | Nullish>;
+    [key: `data-${string}`]: MaybeState<StringablePrimitive | boolean | Nullish>;
+};
+export type ElementAttributesOf<E> = ReactiveAttrsOf<E> & EventListenersOf<E> & FrameworkProps<E> & SvgOnly<E>;
+export {};

package/dist/DOM/nodeControllers/ComponentController.d.ts

@@ -0,0 +1,10 @@
+import { NodeController } from './NodeController.js';
+import { ChildProp, ComponentOptions } from '../types.js';
+import { RenderError } from '../util/RenderError.js';
+import { State } from '../../state/types/types.js';
+export declare class ComponentController extends NodeController {
+    orValue: ChildProp;
+    renderError?: RenderError;
+    protected buildNode(properties: ComponentOptions | undefined, namedStates?: Record<PropertyKey, State>, stateContext?: NodeController): Record<PropertyKey, import('../../state/types/types.js').PrimitiveState<unknown, unknown>> | undefined;
+    or(v: ChildProp): this;
+}

package/dist/DOM/nodeControllers/ElementController.d.ts

@@ -0,0 +1,14 @@
+import { NodeController } from './NodeController.js';
+import { DOMElementAttributes, HydrationContext } from '../types.js';
+export declare class ElementController extends NodeController {
+    private eventListeners?;
+    protected makeElement(tagName: string): HTMLElement | SVGElement;
+    remove(removeNode?: boolean): void;
+    protected buildNode(properties: DOMElementAttributes | undefined, _namedStates: unknown, stateContext: NodeController | undefined, hydrationContext: HydrationContext): void;
+    private joinPropArray;
+    private handleProp;
+    private static propertyChanged;
+    private applyUpdate;
+    private updateProperty;
+    private deferUntilConnected;
+}

package/dist/DOM/nodeControllers/NodeController.d.ts

@@ -0,0 +1,81 @@
+import { CatchFallback, ChildNode, ComponentOptions, DOMElementAttributes, DOMNodeDefinition, FindNodeResult, HydrationContext, NodeArguments, NodeContext, TreeNode } from '../types.js';
+import { State } from '../../state/types/types.js';
+import { CallbackTransform } from '../../state/transforms/CallbackTransform.js';
+import { StateController } from './StateController.js';
+import { ComponentController } from './ComponentController.js';
+import { LightState } from '../../state/stateInternals/LightState.js';
+import { RenderError } from '../util/RenderError.js';
+export declare const TEXT_NODE = 42;
+export type StateControllersByState = {
+    lookup(ls: LightState): StateController | undefined;
+};
+export declare const MODE_CSR = 0;
+export declare const MODE_HYDRATE = 1;
+export declare const MODE_RENDER = 2;
+export declare const CONTROLLER_FLAG_IS_CONTEXT_TRANSPARENT = 1;
+export declare const CONTROLLER_FLAG_IS_STATE_CONTROLLER = 2;
+export declare const CONTROLLER_FLAG_IS_ELEMENT = 4;
+export declare const CONTROLLER_FLAG_OPAQUE_SUBTREE = 8;
+export declare const CONTROLLER_FLAG_REBUILDS_FROM_ARGS = 16;
+type CatchParams = {
+    fbValue: CatchFallback;
+    stateContext?: NodeController;
+    namedStates?: Record<PropertyKey, State>;
+    lvl: number;
+};
+export declare abstract class NodeController {
+    ctx?: NodeContext;
+    el?: HTMLElement | SVGElement;
+    par?: NodeController;
+    nc: number;
+    flg: number;
+    pnc: number;
+    cid: number;
+    protected args?: unknown[];
+    protected c?: ChildNode[];
+    protected subs?: ((() => void) | CallbackTransform)[];
+    protected def?: DOMNodeDefinition;
+    catchParams?: CatchParams;
+    protected abstract buildNode(properties?: DOMElementAttributes | ComponentOptions, namedStates?: Record<PropertyKey, State>, stateContext?: NodeController, hydrationContext?: HydrationContext, level?: number): Record<PropertyKey, State> | void;
+    private static StateController?;
+    static setStateController(stateController: typeof StateController): void;
+    private static ComponentController?;
+    static setComponentController(componentController: typeof ComponentController): void;
+    private static mightBeReplayedFromArgs;
+    private static stateMightReuseArgs;
+    private static invokeDetached;
+    constructor(definition: DOMNodeDefinition, args?: NodeArguments);
+    private parseArgsRecursive;
+    protected createTextChild(value: unknown): ChildNode;
+    protected parseArgs(args: NodeArguments, previousStateControllers?: StateControllersByState): DOMElementAttributes | ComponentOptions | undefined;
+    catch(v: CatchFallback): this;
+    build(parentController?: NodeController, DOMContext?: FindNodeResult, stateContext?: NodeController, namedStates?: Record<PropertyKey, State>, hydrationContext?: HydrationContext, level?: number): void;
+    triggerCatch(cause: unknown): RenderError;
+    private renderFallback;
+    protected createChildren(parentController?: NodeController, DOMContext?: FindNodeResult, stateContext?: NodeController, namedStates?: Record<PropertyKey, State> | undefined, hydrationContext?: HydrationContext, level?: number): void;
+    protected getMountElement(): HTMLElement | SVGElement | undefined;
+    protected inheritContext(ctx?: NodeContext): NodeContext | undefined;
+    protected getNodes(p: TreeNode): Node[];
+    isSoleChild(child: NodeController): boolean;
+    isSpent(): boolean;
+    isMounted(): boolean;
+    heldForm(): TreeNode;
+    getFirstNode(node: TreeNode): Node | undefined;
+    private classifyChild;
+    private dropNode;
+    protected removeExcessNodes(hydrationContext: HydrationContext): void;
+    private crossJunction;
+    protected resolveChild(child: NodeController, isStateController: boolean): ChildNode | ChildNode[];
+    protected addChildren(DOMContext: FindNodeResult, hydrationContext?: HydrationContext, stateContext?: NodeController, namedStates?: Record<PropertyKey, State>, level?: number): number;
+    protected getParallelNodeCount(childrenNodeCount: number): number;
+    protected updateNodeCount(newCount: number): void;
+    protected enclosingMountElement(): Node | undefined;
+    protected handleReactiveError(e: unknown): void;
+    addCleanup(fn: () => void): void;
+    protected addSub(transform: CallbackTransform, target?: NodeController): void;
+    protected unsubscribeAll(): void;
+    remove(removeNode?: boolean): void;
+    removeChildren(removeNodes?: boolean): void;
+    findNode(referenceNode: ChildNode, nodeIndex?: number, startChildIndex?: number, startNode?: Node | null, startNodeIndex?: number): FindNodeResult;
+}
+export {};

package/dist/DOM/nodeControllers/RootController.d.ts

@@ -0,0 +1,12 @@
+import { NodeController } from './NodeController.js';
+import { DOMNodeDefinition, NodeArguments, RenderContext } from '../types.js';
+export declare class RootController extends NodeController {
+    private rootEl?;
+    constructor(definition: DOMNodeDefinition, args?: NodeArguments);
+    protected buildNode(properties: RenderContext | undefined): void;
+    protected getMountElement(): HTMLElement | SVGElement | undefined;
+    protected getParallelNodeCount(): number;
+    createRoot(): void;
+    renderedRoot(): HTMLElement | SVGElement;
+    remove(): void;
+}

package/dist/DOM/nodeControllers/SVGElementController.d.ts

@@ -0,0 +1,4 @@
+import { ElementController } from './ElementController.js';
+export declare class SVGElementController extends ElementController {
+    protected makeElement(tagName: string): SVGElement;
+}

package/dist/DOM/nodeControllers/StateController.d.ts

@@ -0,0 +1,43 @@
+import { NodeController } from './NodeController.js';
+import { State } from '../../state/types/types.js';
+import { Transform } from '../../state/transforms/Transform.js';
+import { FindNodeResult, HydrationContext } from '../types.js';
+export declare class StateController extends NodeController {
+    private nst?;
+    private nxt?;
+    private insertionParent?;
+    private nestLevel;
+    private namedStates?;
+    private static pendingDestroy;
+    private static idleDestroy;
+    private static pendingClears;
+    private static idleClears;
+    private static pendingCalls;
+    private static idleCalls;
+    private static previousStateControllers;
+    private static movableControllersByDef;
+    get tfm(): Transform | undefined;
+    build(parentController?: NodeController, DOMContext?: FindNodeResult, stateContext?: NodeController, namedStates?: Record<PropertyKey, State>, hydrationContext?: HydrationContext, level?: number): void;
+    remove(removeNode?: boolean): void;
+    private static registerMovableChildren;
+    private static detachFromDonor;
+    private hasMovableChildren;
+    static registerPendingCall(fn: () => void): void;
+    static flushPendingWork(): void;
+    protected buildNode(_properties: unknown, namedStates?: Record<PropertyKey, State>, _stateContext?: NodeController, _hydrationContext?: unknown, level?: number): void;
+    private childArgs;
+    private checkNodeStateType;
+    private static stateChanged;
+    private onStateChange;
+    private updateBody;
+    private clearAll;
+    private detachCleared;
+    private adoptBareChild;
+    private detachChild;
+    private insertChild;
+    private static insertNode;
+    private moveChild;
+    private nextDomNode;
+    private mutateRange;
+    private applyMutation;
+}

package/dist/DOM/server/serialize.d.ts

@@ -0,0 +1,2 @@
+import { ServerElement } from './serverNodes.js';
+export declare const serializeChildren: (el: ServerElement) => string;

package/dist/DOM/server/serverNodes.d.ts

@@ -0,0 +1,41 @@
+import { NodeFactory } from '../types.js';
+export declare abstract class ServerNode {
+    abstract get nodeType(): number;
+    parentNode?: ServerElement;
+    remove(): void;
+}
+declare abstract class CharacterDataNode extends ServerNode {
+    data: string;
+    constructor(data: string);
+    get textContent(): string;
+    set textContent(value: string);
+}
+export declare class ServerText extends CharacterDataNode {
+    get nodeType(): number;
+}
+export declare class ServerComment extends CharacterDataNode {
+    get nodeType(): number;
+}
+declare class ServerStyle {
+    private readonly el;
+    private readonly props;
+    constructor(el: ServerElement);
+    setProperty(name: string, value: string | null): void;
+}
+export type ChildOfServerElement = ServerNode | Node;
+export declare class ServerElement extends ServerNode {
+    readonly tagName: string;
+    readonly attrs: Map<string, string>;
+    readonly childNodes: ChildOfServerElement[];
+    readonly style: ServerStyle;
+    html?: string;
+    constructor(tagName: string);
+    get nodeType(): number;
+    setAttribute(name: string, value: string): void;
+    removeAttribute(name: string): void;
+    set innerHTML(markup: string);
+    insertBefore(node: ChildOfServerElement, ref?: ChildOfServerElement | null): ChildOfServerElement;
+    removeChild(node: ChildOfServerElement): ChildOfServerElement;
+}
+export declare const serverDocument: NodeFactory;
+export {};