govuk_publishing_components 12.13.0 → 12.14.0

data/node_modules/preact/src/h.js

@@ -0,0 +1,86 @@
+import { VNode } from './vnode';
+import options from './options';
+
+
+const stack = [];
+
+const EMPTY_CHILDREN = [];
+
+/**
+ * JSX/hyperscript reviver.
+ * @see http://jasonformat.com/wtf-is-jsx
+ * Benchmarks: https://esbench.com/bench/57ee8f8e330ab09900a1a1a0
+ *
+ * Note: this is exported as both `h()` and `createElement()` for compatibility
+ * reasons.
+ *
+ * Creates a VNode (virtual DOM element). A tree of VNodes can be used as a
+ * lightweight representation of the structure of a DOM tree. This structure can
+ * be realized by recursively comparing it against the current _actual_ DOM
+ * structure, and applying only the differences.
+ *
+ * `h()`/`createElement()` accepts an element name, a list of attributes/props,
+ * and optionally children to append to the element.
+ *
+ * @example The following DOM tree
+ *
+ * `<div id="foo" name="bar">Hello!</div>`
+ *
+ * can be constructed using this function as:
+ *
+ * `h('div', { id: 'foo', name : 'bar' }, 'Hello!');`
+ *
+ * @param {string | function} nodeName An element name. Ex: `div`, `a`, `span`, etc.
+ * @param {object | null} attributes Any attributes/props to set on the created element.
+ * @param {VNode[]} [rest] Additional arguments are taken to be children to
+ *  append. Can be infinitely nested Arrays.
+ *
+ * @public
+ */
+export function h(nodeName, attributes) {
+	let children=EMPTY_CHILDREN, lastSimple, child, simple, i;
+	for (i=arguments.length; i-- > 2; ) {
+		stack.push(arguments[i]);
+	}
+	if (attributes && attributes.children!=null) {
+		if (!stack.length) stack.push(attributes.children);
+		delete attributes.children;
+	}
+	while (stack.length) {
+		if ((child = stack.pop()) && child.pop!==undefined) {
+			for (i=child.length; i--; ) stack.push(child[i]);
+		}
+		else {
+			if (typeof child==='boolean') child = null;
+
+			if ((simple = typeof nodeName!=='function')) {
+				if (child==null) child = '';
+				else if (typeof child==='number') child = String(child);
+				else if (typeof child!=='string') simple = false;
+			}
+
+			if (simple && lastSimple) {
+				children[children.length-1] += child;
+			}
+			else if (children===EMPTY_CHILDREN) {
+				children = [child];
+			}
+			else {
+				children.push(child);
+			}
+
+			lastSimple = simple;
+		}
+	}
+
+	let p = new VNode();
+	p.nodeName = nodeName;
+	p.children = children;
+	p.attributes = attributes==null ? undefined : attributes;
+	p.key = attributes==null ? undefined : attributes.key;
+
+	// if a "vnode hook" is defined, pass every created VNode to it
+	if (options.vnode!==undefined) options.vnode(p);
+
+	return p;
+}

data/node_modules/preact/src/options.js

@@ -0,0 +1,22 @@
+/**
+ * @typedef {import('./component').Component} Component
+ * @typedef {import('./vnode').VNode} VNode
+ */
+
+/**
+ * Global options
+ * @public
+ * @typedef Options
+ * @property {boolean} [syncComponentUpdates] If `true`, `prop` changes trigger synchronous component updates. Defaults to true.
+ * @property {(vnode: VNode) => void} [vnode] Processes all created VNodes.
+ * @property {(component: Component) => void} [afterMount] Hook invoked after a component is mounted.
+ * @property {(component: Component) => void} [afterUpdate] Hook invoked after the DOM is updated with a component's latest render.
+ * @property {(component: Component) => void} [beforeUnmount] Hook invoked immediately before a component is unmounted.
+ * @property {(rerender: function) => void} [debounceRendering] Hook invoked whenever a rerender is requested. Can be used to debounce rerenders.
+ * @property {(event: Event) => Event | void} [event] Hook invoked before any Preact event listeners. The return value (if any) replaces the native browser event given to event listeners
+ */
+
+/** @type {Options}  */
+const options = {};
+
+export default options;

data/node_modules/preact/src/preact.d.ts

@@ -0,0 +1,891 @@
+export = preact;
+export as namespace preact;
+
+declare namespace preact {
+	type Key = string | number;
+	type Ref<T> = (instance: T) => void;
+	type ComponentChild = VNode<any> | string | number | null;
+	type ComponentChildren = ComponentChild[] | ComponentChild | object | string | number | null;
+
+	/**
+	 * @deprecated
+	 *
+	 * Use Attributes instead
+	 */
+	type ComponentProps = Attributes;
+
+	/**
+	 * @deprecated
+	 *
+	 * Use ClassAttributes instead
+	 */
+	type PreactHTMLAttributes = ClassAttributes<any>;
+
+	interface Attributes {
+		key?: string | number | any;
+		jsx?: boolean;
+	}
+
+	interface ClassAttributes<T> extends Attributes {
+		ref?: Ref<T>;
+	}
+
+	interface PreactDOMAttributes {
+		children?: ComponentChildren;
+		dangerouslySetInnerHTML?: {
+			__html: string;
+		};
+	}
+
+	type ComponentFactory<P> = ComponentConstructor<P> | FunctionalComponent<P>;
+	/**
+	 * Define the contract for a virtual node in preact.
+	 *
+	 * A virtual node has a name, a map of attributes, an array
+	 * of child {VNode}s and a key. The key is used by preact for
+	 * internal purposes.
+	 */
+	interface VNode<P = any> {
+		nodeName: ComponentFactory<P> | string;
+		attributes: P;
+		children: Array<VNode<any> | string>;
+		key?: Key | null;
+	}
+
+	type RenderableProps<P, RefType = any> = Readonly<
+		P & Attributes & { children?: ComponentChildren; ref?: Ref<RefType> }
+	>;
+
+	interface FunctionalComponent<P = {}> {
+		(props: RenderableProps<P>, context?: any): VNode<any> | null;
+		displayName?: string;
+		defaultProps?: Partial<P>;
+	}
+
+	interface ComponentConstructor<P = {}, S = {}> {
+		new (props: P, context?: any): Component<P, S>;
+		displayName?: string;
+		defaultProps?: Partial<P>;
+	}
+
+	// Type alias for a component considered generally, whether stateless or stateful.
+	type AnyComponent<P = {}, S = {}> = FunctionalComponent<P> | Component<P, S>;
+
+	interface Component<P = {}, S = {}> {
+		componentWillMount?(): void;
+		componentDidMount?(): void;
+		componentWillUnmount?(): void;
+		getChildContext?(): object;
+		componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+		shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): boolean;
+		componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
+		componentDidUpdate?(previousProps: Readonly<P>, previousState: Readonly<S>, previousContext: any): void;
+	}
+
+	abstract class Component<P, S> {
+		constructor(props?: P, context?: any);
+
+		static displayName?: string;
+		static defaultProps?: any;
+
+		state: Readonly<S>;
+		props: RenderableProps<P>;
+		context: any;
+		base?: HTMLElement;
+
+		setState<K extends keyof S>(state: Pick<S, K>, callback?: () => void): void;
+		setState<K extends keyof S>(fn: (prevState: S, props: P) => Pick<S, K>, callback?: () => void): void;
+
+		forceUpdate(callback?: () => void): void;
+
+		abstract render(props?: RenderableProps<P>, state?: Readonly<S>, context?: any): ComponentChild;
+	}
+
+	function h<P>(
+		node: ComponentFactory<P>,
+		params: Attributes & P | null,
+		...children: ComponentChildren[]
+	): VNode<any>;
+	function h(
+		node: string,
+		params: JSX.HTMLAttributes & JSX.SVGAttributes & Record<string, any> | null,
+		...children: ComponentChildren[]
+	): VNode<any>;
+
+	function render(node: ComponentChild, parent: Element | Document | ShadowRoot | DocumentFragment, mergeWith?: Element): Element;
+	function rerender(): void;
+	function cloneElement(element: JSX.Element, props: any): JSX.Element;
+
+	var options: {
+		syncComponentUpdates?: boolean;
+		debounceRendering?: (render: () => void) => void;
+		vnode?: (vnode: VNode<any>) => void;
+		event?: (event: Event) => Event;
+	};
+}
+
+declare global {
+	namespace JSX {
+		interface Element extends preact.VNode<any> {
+		}
+
+		interface ElementClass extends preact.Component<any, any> {
+		}
+
+		interface ElementAttributesProperty {
+			props: any;
+		}
+
+		interface ElementChildrenAttribute {
+			children: any;
+		}
+
+		interface SVGAttributes extends HTMLAttributes {
+			accentHeight?: number | string;
+			accumulate?: "none" | "sum";
+			additive?: "replace" | "sum";
+			alignmentBaseline?: "auto" | "baseline" | "before-edge" | "text-before-edge" | "middle" | "central" | "after-edge" | "text-after-edge" | "ideographic" | "alphabetic" | "hanging" | "mathematical" | "inherit";
+			allowReorder?: "no" | "yes";
+			alphabetic?: number | string;
+			amplitude?: number | string;
+			arabicForm?: "initial" | "medial" | "terminal" | "isolated";
+			ascent?: number | string;
+			attributeName?: string;
+			attributeType?: string;
+			autoReverse?: number | string;
+			azimuth?: number | string;
+			baseFrequency?: number | string;
+			baselineShift?: number | string;
+			baseProfile?: number | string;
+			bbox?: number | string;
+			begin?: number | string;
+			bias?: number | string;
+			by?: number | string;
+			calcMode?: number | string;
+			capHeight?: number | string;
+			clip?: number | string;
+			clipPath?: string;
+			clipPathUnits?: number | string;
+			clipRule?: number | string;
+			colorInterpolation?: number | string;
+			colorInterpolationFilters?: "auto" | "sRGB" | "linearRGB" | "inherit";
+			colorProfile?: number | string;
+			colorRendering?: number | string;
+			contentScriptType?: number | string;
+			contentStyleType?: number | string;
+			cursor?: number | string;
+			cx?: number | string;
+			cy?: number | string;
+			d?: string;
+			decelerate?: number | string;
+			descent?: number | string;
+			diffuseConstant?: number | string;
+			direction?: number | string;
+			display?: number | string;
+			divisor?: number | string;
+			dominantBaseline?: number | string;
+			dur?: number | string;
+			dx?: number | string;
+			dy?: number | string;
+			edgeMode?: number | string;
+			elevation?: number | string;
+			enableBackground?: number | string;
+			end?: number | string;
+			exponent?: number | string;
+			externalResourcesRequired?: number | string;
+			fill?: string;
+			fillOpacity?: number | string;
+			fillRule?: "nonzero" | "evenodd" | "inherit";
+			filter?: string;
+			filterRes?: number | string;
+			filterUnits?: number | string;
+			floodColor?: number | string;
+			floodOpacity?: number | string;
+			focusable?: number | string;
+			fontFamily?: string;
+			fontSize?: number | string;
+			fontSizeAdjust?: number | string;
+			fontStretch?: number | string;
+			fontStyle?: number | string;
+			fontVariant?: number | string;
+			fontWeight?: number | string;
+			format?: number | string;
+			from?: number | string;
+			fx?: number | string;
+			fy?: number | string;
+			g1?: number | string;
+			g2?: number | string;
+			glyphName?: number | string;
+			glyphOrientationHorizontal?: number | string;
+			glyphOrientationVertical?: number | string;
+			glyphRef?: number | string;
+			gradientTransform?: string;
+			gradientUnits?: string;
+			hanging?: number | string;
+			horizAdvX?: number | string;
+			horizOriginX?: number | string;
+			ideographic?: number | string;
+			imageRendering?: number | string;
+			in2?: number | string;
+			in?: string;
+			intercept?: number | string;
+			k1?: number | string;
+			k2?: number | string;
+			k3?: number | string;
+			k4?: number | string;
+			k?: number | string;
+			kernelMatrix?: number | string;
+			kernelUnitLength?: number | string;
+			kerning?: number | string;
+			keyPoints?: number | string;
+			keySplines?: number | string;
+			keyTimes?: number | string;
+			lengthAdjust?: number | string;
+			letterSpacing?: number | string;
+			lightingColor?: number | string;
+			limitingConeAngle?: number | string;
+			local?: number | string;
+			markerEnd?: string;
+			markerHeight?: number | string;
+			markerMid?: string;
+			markerStart?: string;
+			markerUnits?: number | string;
+			markerWidth?: number | string;
+			mask?: string;
+			maskContentUnits?: number | string;
+			maskUnits?: number | string;
+			mathematical?: number | string;
+			mode?: number | string;
+			numOctaves?: number | string;
+			offset?: number | string;
+			opacity?: number | string;
+			operator?: number | string;
+			order?: number | string;
+			orient?: number | string;
+			orientation?: number | string;
+			origin?: number | string;
+			overflow?: number | string;
+			overlinePosition?: number | string;
+			overlineThickness?: number | string;
+			paintOrder?: number | string;
+			panose1?: number | string;
+			pathLength?: number | string;
+			patternContentUnits?: string;
+			patternTransform?: number | string;
+			patternUnits?: string;
+			pointerEvents?: number | string;
+			points?: string;
+			pointsAtX?: number | string;
+			pointsAtY?: number | string;
+			pointsAtZ?: number | string;
+			preserveAlpha?: number | string;
+			preserveAspectRatio?: string;
+			primitiveUnits?: number | string;
+			r?: number | string;
+			radius?: number | string;
+			refX?: number | string;
+			refY?: number | string;
+			renderingIntent?: number | string;
+			repeatCount?: number | string;
+			repeatDur?: number | string;
+			requiredExtensions?: number | string;
+			requiredFeatures?: number | string;
+			restart?: number | string;
+			result?: string;
+			rotate?: number | string;
+			rx?: number | string;
+			ry?: number | string;
+			scale?: number | string;
+			seed?: number | string;
+			shapeRendering?: number | string;
+			slope?: number | string;
+			spacing?: number | string;
+			specularConstant?: number | string;
+			specularExponent?: number | string;
+			speed?: number | string;
+			spreadMethod?: string;
+			startOffset?: number | string;
+			stdDeviation?: number | string;
+			stemh?: number | string;
+			stemv?: number | string;
+			stitchTiles?: number | string;
+			stopColor?: string;
+			stopOpacity?: number | string;
+			strikethroughPosition?: number | string;
+			strikethroughThickness?: number | string;
+			string?: number | string;
+			stroke?: string;
+			strokeDasharray?: string | number;
+			strokeDashoffset?: string | number;
+			strokeLinecap?: "butt" | "round" | "square" | "inherit";
+			strokeLinejoin?: "miter" | "round" | "bevel" | "inherit";
+			strokeMiterlimit?: string;
+			strokeOpacity?: number | string;
+			strokeWidth?: number | string;
+			surfaceScale?: number | string;
+			systemLanguage?: number | string;
+			tableValues?: number | string;
+			targetX?: number | string;
+			targetY?: number | string;
+			textAnchor?: string;
+			textDecoration?: number | string;
+			textLength?: number | string;
+			textRendering?: number | string;
+			to?: number | string;
+			transform?: string;
+			u1?: number | string;
+			u2?: number | string;
+			underlinePosition?: number | string;
+			underlineThickness?: number | string;
+			unicode?: number | string;
+			unicodeBidi?: number | string;
+			unicodeRange?: number | string;
+			unitsPerEm?: number | string;
+			vAlphabetic?: number | string;
+			values?: string;
+			vectorEffect?: number | string;
+			version?: string;
+			vertAdvY?: number | string;
+			vertOriginX?: number | string;
+			vertOriginY?: number | string;
+			vHanging?: number | string;
+			vIdeographic?: number | string;
+			viewBox?: string;
+			viewTarget?: number | string;
+			visibility?: number | string;
+			vMathematical?: number | string;
+			widths?: number | string;
+			wordSpacing?: number | string;
+			writingMode?: number | string;
+			x1?: number | string;
+			x2?: number | string;
+			x?: number | string;
+			xChannelSelector?: string;
+			xHeight?: number | string;
+			xlinkActuate?: string;
+			xlinkArcrole?: string;
+			xlinkHref?: string;
+			xlinkRole?: string;
+			xlinkShow?: string;
+			xlinkTitle?: string;
+			xlinkType?: string;
+			xmlBase?: string;
+			xmlLang?: string;
+			xmlns?: string;
+			xmlnsXlink?: string;
+			xmlSpace?: string;
+			y1?: number | string;
+			y2?: number | string;
+			y?: number | string;
+			yChannelSelector?: string;
+			z?: number | string;
+			zoomAndPan?: string;
+		}
+
+		interface PathAttributes {
+			d: string;
+		}
+
+		interface EventHandler<E extends Event> {
+			(event: E): void;
+		}
+
+		type ClipboardEventHandler = EventHandler<ClipboardEvent>;
+		type CompositionEventHandler = EventHandler<CompositionEvent>;
+		type DragEventHandler = EventHandler<DragEvent>;
+		type FocusEventHandler = EventHandler<FocusEvent>;
+		type KeyboardEventHandler = EventHandler<KeyboardEvent>;
+		type MouseEventHandler = EventHandler<MouseEvent>;
+		type TouchEventHandler = EventHandler<TouchEvent>;
+		type UIEventHandler = EventHandler<UIEvent>;
+		type WheelEventHandler = EventHandler<WheelEvent>;
+		type AnimationEventHandler = EventHandler<AnimationEvent>;
+		type TransitionEventHandler = EventHandler<TransitionEvent>;
+		type GenericEventHandler = EventHandler<Event>;
+		type PointerEventHandler = EventHandler<PointerEvent>;
+
+		interface DOMAttributes extends preact.PreactDOMAttributes {
+			// Image Events
+			onLoad?: GenericEventHandler;
+			onLoadCapture?: GenericEventHandler;
+
+			// Clipboard Events
+			onCopy?: ClipboardEventHandler;
+			onCopyCapture?: ClipboardEventHandler;
+			onCut?: ClipboardEventHandler;
+			onCutCapture?: ClipboardEventHandler;
+			onPaste?: ClipboardEventHandler;
+			onPasteCapture?: ClipboardEventHandler;
+
+			// Composition Events
+			onCompositionEnd?: CompositionEventHandler;
+			onCompositionEndCapture?: CompositionEventHandler;
+			onCompositionStart?: CompositionEventHandler;
+			onCompositionStartCapture?: CompositionEventHandler;
+			onCompositionUpdate?: CompositionEventHandler;
+			onCompositionUpdateCapture?: CompositionEventHandler;
+
+			// Focus Events
+			onFocus?: FocusEventHandler;
+			onFocusCapture?: FocusEventHandler;
+			onBlur?: FocusEventHandler;
+			onBlurCapture?: FocusEventHandler;
+
+			// Form Events
+			onChange?: GenericEventHandler;
+			onChangeCapture?: GenericEventHandler;
+			onInput?: GenericEventHandler;
+			onInputCapture?: GenericEventHandler;
+			onSearch?: GenericEventHandler;
+			onSearchCapture?: GenericEventHandler;
+			onSubmit?: GenericEventHandler;
+			onSubmitCapture?: GenericEventHandler;
+
+			// Keyboard Events
+			onKeyDown?: KeyboardEventHandler;
+			onKeyDownCapture?: KeyboardEventHandler;
+			onKeyPress?: KeyboardEventHandler;
+			onKeyPressCapture?: KeyboardEventHandler;
+			onKeyUp?: KeyboardEventHandler;
+			onKeyUpCapture?: KeyboardEventHandler;
+
+			// Media Events
+			onAbort?: GenericEventHandler;
+			onAbortCapture?: GenericEventHandler;
+			onCanPlay?: GenericEventHandler;
+			onCanPlayCapture?: GenericEventHandler;
+			onCanPlayThrough?: GenericEventHandler;
+			onCanPlayThroughCapture?: GenericEventHandler;
+			onDurationChange?: GenericEventHandler;
+			onDurationChangeCapture?: GenericEventHandler;
+			onEmptied?: GenericEventHandler;
+			onEmptiedCapture?: GenericEventHandler;
+			onEncrypted?: GenericEventHandler;
+			onEncryptedCapture?: GenericEventHandler;
+			onEnded?: GenericEventHandler;
+			onEndedCapture?: GenericEventHandler;
+			onLoadedData?: GenericEventHandler;
+			onLoadedDataCapture?: GenericEventHandler;
+			onLoadedMetadata?: GenericEventHandler;
+			onLoadedMetadataCapture?: GenericEventHandler;
+			onLoadStart?: GenericEventHandler;
+			onLoadStartCapture?: GenericEventHandler;
+			onPause?: GenericEventHandler;
+			onPauseCapture?: GenericEventHandler;
+			onPlay?: GenericEventHandler;
+			onPlayCapture?: GenericEventHandler;
+			onPlaying?: GenericEventHandler;
+			onPlayingCapture?: GenericEventHandler;
+			onProgress?: GenericEventHandler;
+			onProgressCapture?: GenericEventHandler;
+			onRateChange?: GenericEventHandler;
+			onRateChangeCapture?: GenericEventHandler;
+			onSeeked?: GenericEventHandler;
+			onSeekedCapture?: GenericEventHandler;
+			onSeeking?: GenericEventHandler;
+			onSeekingCapture?: GenericEventHandler;
+			onStalled?: GenericEventHandler;
+			onStalledCapture?: GenericEventHandler;
+			onSuspend?: GenericEventHandler;
+			onSuspendCapture?: GenericEventHandler;
+			onTimeUpdate?: GenericEventHandler;
+			onTimeUpdateCapture?: GenericEventHandler;
+			onVolumeChange?: GenericEventHandler;
+			onVolumeChangeCapture?: GenericEventHandler;
+			onWaiting?: GenericEventHandler;
+			onWaitingCapture?: GenericEventHandler;
+
+			// MouseEvents
+			onClick?: MouseEventHandler;
+			onClickCapture?: MouseEventHandler;
+			onContextMenu?: MouseEventHandler;
+			onContextMenuCapture?: MouseEventHandler;
+			onDblClick?: MouseEventHandler;
+			onDblClickCapture?: MouseEventHandler;
+			onDrag?: DragEventHandler;
+			onDragCapture?: DragEventHandler;
+			onDragEnd?: DragEventHandler;
+			onDragEndCapture?: DragEventHandler;
+			onDragEnter?: DragEventHandler;
+			onDragEnterCapture?: DragEventHandler;
+			onDragExit?: DragEventHandler;
+			onDragExitCapture?: DragEventHandler;
+			onDragLeave?: DragEventHandler;
+			onDragLeaveCapture?: DragEventHandler;
+			onDragOver?: DragEventHandler;
+			onDragOverCapture?: DragEventHandler;
+			onDragStart?: DragEventHandler;
+			onDragStartCapture?: DragEventHandler;
+			onDrop?: DragEventHandler;
+			onDropCapture?: DragEventHandler;
+			onMouseDown?: MouseEventHandler;
+			onMouseDownCapture?: MouseEventHandler;
+			onMouseEnter?: MouseEventHandler;
+			onMouseEnterCapture?: MouseEventHandler;
+			onMouseLeave?: MouseEventHandler;
+			onMouseLeaveCapture?: MouseEventHandler;
+			onMouseMove?: MouseEventHandler;
+			onMouseMoveCapture?: MouseEventHandler;
+			onMouseOut?: MouseEventHandler;
+			onMouseOutCapture?: MouseEventHandler;
+			onMouseOver?: MouseEventHandler;
+			onMouseOverCapture?: MouseEventHandler;
+			onMouseUp?: MouseEventHandler;
+			onMouseUpCapture?: MouseEventHandler;
+
+			// Selection Events
+			onSelect?: GenericEventHandler;
+			onSelectCapture?: GenericEventHandler;
+
+			// Touch Events
+			onTouchCancel?: TouchEventHandler;
+			onTouchCancelCapture?: TouchEventHandler;
+			onTouchEnd?: TouchEventHandler;
+			onTouchEndCapture?: TouchEventHandler;
+			onTouchMove?: TouchEventHandler;
+			onTouchMoveCapture?: TouchEventHandler;
+			onTouchStart?: TouchEventHandler;
+			onTouchStartCapture?: TouchEventHandler;
+
+			// Pointer Events
+			onPointerOver?: PointerEventHandler;
+			onPointerOverCapture?: PointerEventHandler;
+			onPointerEnter?: PointerEventHandler;
+			onPointerEnterCapture?: PointerEventHandler;
+			onPointerDown?: PointerEventHandler;
+			onPointerDownCapture?: PointerEventHandler;
+			onPointerMove?: PointerEventHandler;
+			onPointerMoveCapture?: PointerEventHandler;
+			onPointerUp?: PointerEventHandler;
+			onPointerUpCapture?: PointerEventHandler;
+			onPointerCancel?: PointerEventHandler;
+			onPointerCancelCapture?: PointerEventHandler;
+			onPointerOut?: PointerEventHandler;
+			onPointerOutCapture?: PointerEventHandler;
+			onPointerLeave?: PointerEventHandler;
+			onPointerLeaveCapture?: PointerEventHandler;
+			onGotPointerCapture?: PointerEventHandler;
+			onGotPointerCaptureCapture?: PointerEventHandler;
+			onLostPointerCapture?: PointerEventHandler;
+			onLostPointerCaptureCapture?: PointerEventHandler;
+
+			// UI Events
+			onScroll?: UIEventHandler;
+			onScrollCapture?: UIEventHandler;
+
+			// Wheel Events
+			onWheel?: WheelEventHandler;
+			onWheelCapture?: WheelEventHandler;
+
+			// Animation Events
+			onAnimationStart?: AnimationEventHandler;
+			onAnimationStartCapture?: AnimationEventHandler;
+			onAnimationEnd?: AnimationEventHandler;
+			onAnimationEndCapture?: AnimationEventHandler;
+			onAnimationIteration?: AnimationEventHandler;
+			onAnimationIterationCapture?: AnimationEventHandler;
+
+			// Transition Events
+			onTransitionEnd?: TransitionEventHandler;
+			onTransitionEndCapture?: TransitionEventHandler;
+		}
+
+		interface HTMLAttributes extends preact.PreactHTMLAttributes, DOMAttributes {
+			// Standard HTML Attributes
+			accept?: string;
+			acceptCharset?: string;
+			accessKey?: string;
+			action?: string;
+			allowFullScreen?: boolean;
+			allowTransparency?: boolean;
+			alt?: string;
+			async?: boolean;
+			autocomplete?: string;
+			autofocus?: boolean;
+			autoPlay?: boolean;
+			capture?: boolean;
+			cellPadding?: number | string;
+			cellSpacing?: number | string;
+			charSet?: string;
+			challenge?: string;
+			checked?: boolean;
+			class?: string;
+			className?: string;
+			cols?: number;
+			colSpan?: number;
+			content?: string;
+			contentEditable?: boolean;
+			contextMenu?: string;
+			controls?: boolean;
+			controlsList?: string;
+			coords?: string;
+			crossOrigin?: string;
+			data?: string;
+			dateTime?: string;
+			default?: boolean;
+			defer?: boolean;
+			dir?: string;
+			disabled?: boolean;
+			download?: any;
+			draggable?: boolean;
+			encType?: string;
+			form?: string;
+			formAction?: string;
+			formEncType?: string;
+			formMethod?: string;
+			formNoValidate?: boolean;
+			formTarget?: string;
+			frameBorder?: number | string;
+			headers?: string;
+			height?: number | string;
+			hidden?: boolean;
+			high?: number;
+			href?: string;
+			hrefLang?: string;
+			for?: string;
+			httpEquiv?: string;
+			icon?: string;
+			id?: string;
+			inputMode?: string;
+			integrity?: string;
+			is?: string;
+			keyParams?: string;
+			keyType?: string;
+			kind?: string;
+			label?: string;
+			lang?: string;
+			list?: string;
+			loop?: boolean;
+			low?: number;
+			manifest?: string;
+			marginHeight?: number;
+			marginWidth?: number;
+			max?: number | string;
+			maxLength?: number;
+			media?: string;
+			mediaGroup?: string;
+			method?: string;
+			min?: number | string;
+			minLength?: number;
+			multiple?: boolean;
+			muted?: boolean;
+			name?: string;
+			noValidate?: boolean;
+			open?: boolean;
+			optimum?: number;
+			pattern?: string;
+			placeholder?: string;
+			playsInline?: boolean;
+			poster?: string;
+			preload?: string;
+			radioGroup?: string;
+			readOnly?: boolean;
+			rel?: string;
+			required?: boolean;
+			role?: string;
+			rows?: number;
+			rowSpan?: number;
+			sandbox?: string;
+			scope?: string;
+			scoped?: boolean;
+			scrolling?: string;
+			seamless?: boolean;
+			selected?: boolean;
+			shape?: string;
+			size?: number;
+			sizes?: string;
+			slot?: string;
+			span?: number;
+			spellcheck?: boolean;
+			src?: string;
+			srcset?: string;
+			srcDoc?: string;
+			srcLang?: string;
+			srcSet?: string;
+			start?: number;
+			step?: number | string;
+			style?: any;
+			summary?: string;
+			tabIndex?: number;
+			target?: string;
+			title?: string;
+			type?: string;
+			useMap?: string;
+			value?: string | string[] | number;
+			width?: number | string;
+			wmode?: string;
+			wrap?: string;
+
+			// RDFa Attributes
+			about?: string;
+			datatype?: string;
+			inlist?: any;
+			prefix?: string;
+			property?: string;
+			resource?: string;
+			typeof?: string;
+			vocab?: string;
+		}
+
+		interface IntrinsicElements {
+			// HTML
+			a: HTMLAttributes;
+			abbr: HTMLAttributes;
+			address: HTMLAttributes;
+			area: HTMLAttributes;
+			article: HTMLAttributes;
+			aside: HTMLAttributes;
+			audio: HTMLAttributes;
+			b: HTMLAttributes;
+			base: HTMLAttributes;
+			bdi: HTMLAttributes;
+			bdo: HTMLAttributes;
+			big: HTMLAttributes;
+			blockquote: HTMLAttributes;
+			body: HTMLAttributes;
+			br: HTMLAttributes;
+			button: HTMLAttributes;
+			canvas: HTMLAttributes;
+			caption: HTMLAttributes;
+			cite: HTMLAttributes;
+			code: HTMLAttributes;
+			col: HTMLAttributes;
+			colgroup: HTMLAttributes;
+			data: HTMLAttributes;
+			datalist: HTMLAttributes;
+			dd: HTMLAttributes;
+			del: HTMLAttributes;
+			details: HTMLAttributes;
+			dfn: HTMLAttributes;
+			dialog: HTMLAttributes;
+			div: HTMLAttributes;
+			dl: HTMLAttributes;
+			dt: HTMLAttributes;
+			em: HTMLAttributes;
+			embed: HTMLAttributes;
+			fieldset: HTMLAttributes;
+			figcaption: HTMLAttributes;
+			figure: HTMLAttributes;
+			footer: HTMLAttributes;
+			form: HTMLAttributes;
+			h1: HTMLAttributes;
+			h2: HTMLAttributes;
+			h3: HTMLAttributes;
+			h4: HTMLAttributes;
+			h5: HTMLAttributes;
+			h6: HTMLAttributes;
+			head: HTMLAttributes;
+			header: HTMLAttributes;
+			hr: HTMLAttributes;
+			html: HTMLAttributes;
+			i: HTMLAttributes;
+			iframe: HTMLAttributes;
+			img: HTMLAttributes;
+			input: HTMLAttributes;
+			ins: HTMLAttributes;
+			kbd: HTMLAttributes;
+			keygen: HTMLAttributes;
+			label: HTMLAttributes;
+			legend: HTMLAttributes;
+			li: HTMLAttributes;
+			link: HTMLAttributes;
+			main: HTMLAttributes;
+			map: HTMLAttributes;
+			mark: HTMLAttributes;
+			menu: HTMLAttributes;
+			menuitem: HTMLAttributes;
+			meta: HTMLAttributes;
+			meter: HTMLAttributes;
+			nav: HTMLAttributes;
+			noscript: HTMLAttributes;
+			object: HTMLAttributes;
+			ol: HTMLAttributes;
+			optgroup: HTMLAttributes;
+			option: HTMLAttributes;
+			output: HTMLAttributes;
+			p: HTMLAttributes;
+			param: HTMLAttributes;
+			picture: HTMLAttributes;
+			pre: HTMLAttributes;
+			progress: HTMLAttributes;
+			q: HTMLAttributes;
+			rp: HTMLAttributes;
+			rt: HTMLAttributes;
+			ruby: HTMLAttributes;
+			s: HTMLAttributes;
+			samp: HTMLAttributes;
+			script: HTMLAttributes;
+			section: HTMLAttributes;
+			select: HTMLAttributes;
+			slot: HTMLAttributes;
+			small: HTMLAttributes;
+			source: HTMLAttributes;
+			span: HTMLAttributes;
+			strong: HTMLAttributes;
+			style: HTMLAttributes;
+			sub: HTMLAttributes;
+			summary: HTMLAttributes;
+			sup: HTMLAttributes;
+			table: HTMLAttributes;
+			tbody: HTMLAttributes;
+			td: HTMLAttributes;
+			textarea: HTMLAttributes;
+			tfoot: HTMLAttributes;
+			th: HTMLAttributes;
+			thead: HTMLAttributes;
+			time: HTMLAttributes;
+			title: HTMLAttributes;
+			tr: HTMLAttributes;
+			track: HTMLAttributes;
+			u: HTMLAttributes;
+			ul: HTMLAttributes;
+			"var": HTMLAttributes;
+			video: HTMLAttributes;
+			wbr: HTMLAttributes;
+
+			//SVG
+			svg: SVGAttributes;
+			animate: SVGAttributes;
+			circle: SVGAttributes;
+			clipPath: SVGAttributes;
+			defs: SVGAttributes;
+			ellipse: SVGAttributes;
+			feBlend: SVGAttributes;
+			feColorMatrix: SVGAttributes;
+			feComponentTransfer: SVGAttributes;
+			feComposite: SVGAttributes;
+			feConvolveMatrix: SVGAttributes;
+			feDiffuseLighting: SVGAttributes;
+			feDisplacementMap: SVGAttributes;
+			feFlood: SVGAttributes;
+			feGaussianBlur: SVGAttributes;
+			feImage: SVGAttributes;
+			feMerge: SVGAttributes;
+			feMergeNode: SVGAttributes;
+			feMorphology: SVGAttributes;
+			feOffset: SVGAttributes;
+			feSpecularLighting: SVGAttributes;
+			feTile: SVGAttributes;
+			feTurbulence: SVGAttributes;
+			filter: SVGAttributes;
+			foreignObject: SVGAttributes;
+			g: SVGAttributes;
+			image: SVGAttributes;
+			line: SVGAttributes;
+			linearGradient: SVGAttributes;
+			marker: SVGAttributes;
+			mask: SVGAttributes;
+			path: SVGAttributes;
+			pattern: SVGAttributes;
+			polygon: SVGAttributes;
+			polyline: SVGAttributes;
+			radialGradient: SVGAttributes;
+			rect: SVGAttributes;
+			stop: SVGAttributes;
+			symbol: SVGAttributes;
+			text: SVGAttributes;
+			tspan: SVGAttributes;
+			use: SVGAttributes;
+		}
+	}
+}