@oscarpalmer/toretto 0.9.0 → 0.11.0

package/dist/event.js

@@ -0,0 +1,75 @@
+// node_modules/@oscarpalmer/atoms/dist/js/is.mjs
+function isPlainObject(value2) {
+  if (typeof value2 !== "object" || value2 === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value2);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value2) && !(Symbol.iterator in value2);
+}
+
+// src/event.ts
+function createDispatchOptions(options) {
+  return {
+    bubbles: getBoolean(options?.bubbles),
+    cancelable: getBoolean(options?.cancelable),
+    composed: getBoolean(options?.composed)
+  };
+}
+function createEvent(type, options) {
+  const hasOptions = isPlainObject(options);
+  if (hasOptions && "detail" in options) {
+    return new CustomEvent(type, {
+      ...createDispatchOptions(options),
+      detail: options?.detail
+    });
+  }
+  return new Event(type, createDispatchOptions(hasOptions ? options : {}));
+}
+function createEventOptions(options) {
+  if (isPlainObject(options)) {
+    return {
+      capture: getBoolean(options.capture),
+      once: getBoolean(options.once),
+      passive: getBoolean(options.passive, true)
+    };
+  }
+  return {
+    capture: getBoolean(options),
+    once: false,
+    passive: true
+  };
+}
+function dispatch(target, type, options) {
+  target.dispatchEvent(createEvent(type, options));
+}
+function getBoolean(value2, defaultValue) {
+  return typeof value2 === "boolean" ? value2 : defaultValue ?? false;
+}
+function getPosition(event) {
+  let x;
+  let y;
+  if (event instanceof MouseEvent) {
+    x = event.clientX;
+    y = event.clientY;
+  } else if (event instanceof TouchEvent) {
+    x = event.touches[0]?.clientX;
+    y = event.touches[0]?.clientY;
+  }
+  return typeof x === "number" && typeof y === "number" ? { x, y } : undefined;
+}
+function off(target, type, listener, options) {
+  target.removeEventListener(type, listener, createEventOptions(options));
+}
+function on(target, type, listener, options) {
+  const extended = createEventOptions(options);
+  target.addEventListener(type, listener, extended);
+  return () => {
+    target.removeEventListener(type, listener, extended);
+  };
+}
+export {
+  on,
+  off,
+  getPosition,
+  dispatch
+};

package/dist/event.mjs

@@ -0,0 +1,67 @@
+// src/event.ts
+import {isPlainObject} from "@oscarpalmer/atoms/is";
+function createDispatchOptions(options) {
+  return {
+    bubbles: getBoolean(options?.bubbles),
+    cancelable: getBoolean(options?.cancelable),
+    composed: getBoolean(options?.composed)
+  };
+}
+function createEvent(type, options) {
+  const hasOptions = isPlainObject(options);
+  if (hasOptions && "detail" in options) {
+    return new CustomEvent(type, {
+      ...createDispatchOptions(options),
+      detail: options?.detail
+    });
+  }
+  return new Event(type, createDispatchOptions(hasOptions ? options : {}));
+}
+function createEventOptions(options) {
+  if (isPlainObject(options)) {
+    return {
+      capture: getBoolean(options.capture),
+      once: getBoolean(options.once),
+      passive: getBoolean(options.passive, true)
+    };
+  }
+  return {
+    capture: getBoolean(options),
+    once: false,
+    passive: true
+  };
+}
+function dispatch(target, type, options) {
+  target.dispatchEvent(createEvent(type, options));
+}
+function getBoolean(value, defaultValue) {
+  return typeof value === "boolean" ? value : defaultValue ?? false;
+}
+function getPosition(event) {
+  let x;
+  let y;
+  if (event instanceof MouseEvent) {
+    x = event.clientX;
+    y = event.clientY;
+  } else if (event instanceof TouchEvent) {
+    x = event.touches[0]?.clientX;
+    y = event.touches[0]?.clientY;
+  }
+  return typeof x === "number" && typeof y === "number" ? { x, y } : undefined;
+}
+function off(target, type, listener, options) {
+  target.removeEventListener(type, listener, createEventOptions(options));
+}
+function on(target, type, listener, options) {
+  const extended = createEventOptions(options);
+  target.addEventListener(type, listener, extended);
+  return () => {
+    target.removeEventListener(type, listener, extended);
+  };
+}
+export {
+  on,
+  off,
+  getPosition,
+  dispatch
+};

package/dist/html.js

@@ -0,0 +1,121 @@
+// node_modules/@oscarpalmer/atoms/dist/js/is.mjs
+function isPlainObject(value2) {
+  if (typeof value2 !== "object" || value2 === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value2);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value2) && !(Symbol.iterator in value2);
+}
+
+// src/attribute.ts
+function isBadAttribute(attribute) {
+  return onPrefix.test(attribute.name) || sourcePrefix.test(attribute.name) && valuePrefix.test(attribute.value);
+}
+function isEmptyNonBooleanAttribute(attribute) {
+  return !booleanAttributes.includes(attribute.name) && attribute.value.trim().length === 0;
+}
+function isInvalidBooleanAttribute(attribute) {
+  if (!booleanAttributes.includes(attribute.name)) {
+    return true;
+  }
+  const normalised = attribute.value.toLowerCase().trim();
+  return !(normalised.length === 0 || normalised === attribute.name || attribute.name === "hidden" && normalised === "until-found");
+}
+var booleanAttributes = Object.freeze([
+  "async",
+  "autofocus",
+  "autoplay",
+  "checked",
+  "controls",
+  "default",
+  "defer",
+  "disabled",
+  "formnovalidate",
+  "hidden",
+  "inert",
+  "ismap",
+  "itemscope",
+  "loop",
+  "multiple",
+  "muted",
+  "nomodule",
+  "novalidate",
+  "open",
+  "playsinline",
+  "readonly",
+  "required",
+  "reversed",
+  "selected"
+]);
+var onPrefix = /^on/i;
+var sourcePrefix = /^(href|src|xlink:href)$/i;
+var valuePrefix = /(data:text\/html|javascript:)/i;
+
+// src/sanitise.ts
+function sanitise(value2, options) {
+  return sanitiseNodes(Array.isArray(value2) ? value2 : [value2], {
+    sanitiseBooleanAttributes: options?.sanitiseBooleanAttributes ?? true
+  });
+}
+function sanitiseAttributes(element, attributes, options) {
+  const { length } = attributes;
+  for (let index = 0;index < length; index += 1) {
+    const attribute2 = attributes[index];
+    if (isBadAttribute(attribute2) || isEmptyNonBooleanAttribute(attribute2)) {
+      element.removeAttribute(attribute2.name);
+    } else if (options.sanitiseBooleanAttributes && isInvalidBooleanAttribute(attribute2)) {
+      element.setAttribute(attribute2.name, "");
+    }
+  }
+}
+function sanitiseNodes(nodes, options) {
+  const { length } = nodes;
+  for (let index = 0;index < length; index += 1) {
+    const node = nodes[index];
+    if (node instanceof Element) {
+      sanitiseAttributes(node, [...node.attributes], options);
+    }
+    sanitiseNodes([...node.childNodes], options);
+  }
+  return nodes;
+}
+
+// src/html.ts
+function createTemplate(html) {
+  const template2 = document.createElement("template");
+  template2.innerHTML = html;
+  templates[html] = template2;
+  return template2;
+}
+function getTemplate(value2) {
+  if (value2.trim().length === 0) {
+    return;
+  }
+  let template2;
+  if (/^[\w-]+$/.test(value2)) {
+    template2 = document.querySelector(`#${value2}`);
+  }
+  if (template2 instanceof HTMLTemplateElement) {
+    return template2;
+  }
+  return templates[value2] ?? createTemplate(value2);
+}
+function html(value2, sanitisation) {
+  const options = sanitisation == null || sanitisation === true ? {} : isPlainObject(sanitisation) ? { ...sanitisation } : null;
+  const template2 = value2 instanceof HTMLTemplateElement ? value2 : typeof value2 === "string" ? getTemplate(value2) : null;
+  if (template2 == null) {
+    return [];
+  }
+  const cloned = template2.content.cloneNode(true);
+  const scripts = cloned.querySelectorAll("script");
+  const { length } = scripts;
+  for (let index = 0;index < length; index += 1) {
+    scripts[index].remove();
+  }
+  cloned.normalize();
+  return options != null ? sanitise([...cloned.childNodes], options) : [...cloned.childNodes];
+}
+var templates = {};
+export {
+  html
+};

package/dist/html.mjs

@@ -0,0 +1,41 @@
+// src/html.ts
+import {isPlainObject} from "@oscarpalmer/atoms/is";
+import {sanitise as sanitise2} from "./sanitise";
+function createTemplate(html) {
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  templates[html] = template;
+  return template;
+}
+function getTemplate(value) {
+  if (value.trim().length === 0) {
+    return;
+  }
+  let template;
+  if (/^[\w-]+$/.test(value)) {
+    template = document.querySelector(`#${value}`);
+  }
+  if (template instanceof HTMLTemplateElement) {
+    return template;
+  }
+  return templates[value] ?? createTemplate(value);
+}
+function html(value, sanitisation) {
+  const options = sanitisation == null || sanitisation === true ? {} : isPlainObject(sanitisation) ? { ...sanitisation } : null;
+  const template = value instanceof HTMLTemplateElement ? value : typeof value === "string" ? getTemplate(value) : null;
+  if (template == null) {
+    return [];
+  }
+  const cloned = template.content.cloneNode(true);
+  const scripts = cloned.querySelectorAll("script");
+  const { length } = scripts;
+  for (let index = 0;index < length; index += 1) {
+    scripts[index].remove();
+  }
+  cloned.normalize();
+  return options != null ? sanitise2([...cloned.childNodes], options) : [...cloned.childNodes];
+}
+var templates = {};
+export {
+  html
+};

package/dist/index.js

@@ -147,6 +147,66 @@ function setData(element, first, second) {
 function updateDataAttribute(element, key, value2) {
   updateElementValue(element, `data-${key}`, value2, element.setAttribute, element.removeAttribute, true);
 }
+// src/event.ts
+function createDispatchOptions(options) {
+  return {
+    bubbles: getBoolean(options?.bubbles),
+    cancelable: getBoolean(options?.cancelable),
+    composed: getBoolean(options?.composed)
+  };
+}
+function createEvent(type, options) {
+  const hasOptions = isPlainObject(options);
+  if (hasOptions && "detail" in options) {
+    return new CustomEvent(type, {
+      ...createDispatchOptions(options),
+      detail: options?.detail
+    });
+  }
+  return new Event(type, createDispatchOptions(hasOptions ? options : {}));
+}
+function createEventOptions(options) {
+  if (isPlainObject(options)) {
+    return {
+      capture: getBoolean(options.capture),
+      once: getBoolean(options.once),
+      passive: getBoolean(options.passive, true)
+    };
+  }
+  return {
+    capture: getBoolean(options),
+    once: false,
+    passive: true
+  };
+}
+function dispatch(target, type, options) {
+  target.dispatchEvent(createEvent(type, options));
+}
+function getBoolean(value2, defaultValue) {
+  return typeof value2 === "boolean" ? value2 : defaultValue ?? false;
+}
+function getPosition(event) {
+  let x;
+  let y;
+  if (event instanceof MouseEvent) {
+    x = event.clientX;
+    y = event.clientY;
+  } else if (event instanceof TouchEvent) {
+    x = event.touches[0]?.clientX;
+    y = event.touches[0]?.clientY;
+  }
+  return typeof x === "number" && typeof y === "number" ? { x, y } : undefined;
+}
+function off(target, type, listener, options) {
+  target.removeEventListener(type, listener, createEventOptions(options));
+}
+function on(target, type, listener, options) {
+  const extended = createEventOptions(options);
+  target.addEventListener(type, listener, extended);
+  return () => {
+    target.removeEventListener(type, listener, extended);
+  };
+}
 // src/find.ts
 function calculateDistance(origin, target) {
   if (origin === target || origin.parentElement === target) {
@@ -465,6 +525,43 @@ function sanitiseNodes(nodes, options) {
   }
   return nodes;
 }
+
+// src/html.ts
+function createTemplate(html) {
+  const template2 = document.createElement("template");
+  template2.innerHTML = html;
+  templates[html] = template2;
+  return template2;
+}
+function getTemplate(value2) {
+  if (value2.trim().length === 0) {
+    return;
+  }
+  let template2;
+  if (/^[\w-]+$/.test(value2)) {
+    template2 = document.querySelector(`#${value2}`);
+  }
+  if (template2 instanceof HTMLTemplateElement) {
+    return template2;
+  }
+  return templates[value2] ?? createTemplate(value2);
+}
+function html(value2, sanitisation) {
+  const options = sanitisation == null || sanitisation === true ? {} : isPlainObject(sanitisation) ? { ...sanitisation } : null;
+  const template2 = value2 instanceof HTMLTemplateElement ? value2 : typeof value2 === "string" ? getTemplate(value2) : null;
+  if (template2 == null) {
+    return [];
+  }
+  const cloned = template2.content.cloneNode(true);
+  const scripts = cloned.querySelectorAll("script");
+  const { length } = scripts;
+  for (let index = 0;index < length; index += 1) {
+    scripts[index].remove();
+  }
+  cloned.normalize();
+  return options != null ? sanitise([...cloned.childNodes], options) : [...cloned.childNodes];
+}
+var templates = {};
 // src/style.ts
 function getStyle(element, property) {
   return element.style[property];
@@ -505,16 +602,20 @@ export {
   setAttributes,
   setAttribute,
   sanitise,
+  on,
+  off,
   isTabbable,
   isInvalidBooleanAttribute,
   isFocusable,
   isEmptyNonBooleanAttribute,
   isBooleanAttribute,
   isBadAttribute,
+  html,
   getTextDirection,
   getTabbable,
   getStyles,
   getStyle,
+  getPosition,
   getFocusable,
   getElementUnderPointer,
   getData,
@@ -522,6 +623,7 @@ export {
   findElements,
   findElement,
   findAncestor,
+  dispatch,
   booleanAttributes,
   findElements as $$,
   findElement as $

package/dist/index.mjs

@@ -1,8 +1,10 @@
 // src/index.ts
 export * from "./attribute";
 export * from "./data";
+export * from "./event";
 export * from "./find";
 export * from "./focusable";
+export * from "./html";
 export * from "./models";
 export * from "./sanitise";
 export * from "./style";

package/package.json

@@ -11,7 +11,7 @@
 		"@biomejs/biome": "^1.8.3",
 		"@happy-dom/global-registrator": "^14.12.3",
 		"@types/bun": "^1.1.6",
-		"bun": "^1.1.21",
+		"bun": "^1.1.22",
 		"dts-bundle-generator": "^9.5.1",
 		"typescript": "^5.5.4"
 	},
@@ -39,6 +39,12 @@
 			"import": "./dist/data.mjs",
 			"require": "./dist/data.js"
 		},
+		"./event": {
+			"types": "./types/event.d.ts",
+			"bun": "./src/event.ts",
+			"import": "./dist/event.mjs",
+			"require": "./dist/event.js"
+		},
 		"./find": {
 			"types": "./types/find.d.ts",
 			"bun": "./src/find.ts",
@@ -51,6 +57,12 @@
 			"import": "./dist/focusable.mjs",
 			"require": "./dist/focusable.js"
 		},
+		"./html": {
+			"types": "./types/html.d.ts",
+			"bun": "./src/html.ts",
+			"import": "./dist/html.mjs",
+			"require": "./dist/html.js"
+		},
 		"./models": {
 			"types": "./types/models.d.ts",
 			"bun": "./src/models.ts"
@@ -97,5 +109,5 @@
 	},
 	"type": "module",
 	"types": "types/index.d.cts",
-	"version": "0.9.0"
+	"version": "0.11.0"
 }

package/src/event.ts

@@ -0,0 +1,165 @@
+import {isPlainObject} from '@oscarpalmer/atoms/is';
+import type {
+	CustomDispatchOptions,
+	DispatchOptions,
+	EventPosition,
+} from './models';
+
+/**
+ * Remove the current event listener
+ */
+type RemoveEventListener = () => void;
+
+function createDispatchOptions(options: DispatchOptions): DispatchOptions {
+	return {
+		bubbles: getBoolean(options?.bubbles),
+		cancelable: getBoolean(options?.cancelable),
+		composed: getBoolean(options?.composed),
+	};
+}
+
+function createEvent(type: string, options?: DispatchOptions): Event {
+	const hasOptions = isPlainObject(options);
+
+	if (hasOptions && 'detail' in options) {
+		return new CustomEvent(type, {
+			...createDispatchOptions(options),
+			detail: options?.detail,
+		});
+	}
+
+	return new Event(type, createDispatchOptions(hasOptions ? options : {}));
+}
+
+function createEventOptions(
+	options?: boolean | AddEventListenerOptions,
+): AddEventListenerOptions {
+	if (isPlainObject(options)) {
+		return {
+			capture: getBoolean(options.capture),
+			once: getBoolean(options.once),
+			passive: getBoolean(options.passive, true),
+		};
+	}
+
+	return {
+		capture: getBoolean(options),
+		once: false,
+		passive: true,
+	};
+}
+
+/**
+ * Dispatch an event for a target
+ */
+export function dispatch<Type extends keyof HTMLElementEventMap>(
+	target: EventTarget,
+	type: Type,
+	options?: DispatchOptions,
+): void;
+
+/**
+ * Dispatch an event for a target
+ */
+export function dispatch<Type extends keyof HTMLElementEventMap>(
+	target: EventTarget,
+	type: Type,
+	options?: CustomDispatchOptions,
+): void;
+
+/**
+ * Dispatch an event for a target
+ */
+export function dispatch(
+	target: EventTarget,
+	type: string,
+	options?: DispatchOptions,
+): void;
+
+/**
+ * Dispatch an event for a target
+ */
+export function dispatch(
+	target: EventTarget,
+	type: string,
+	options?: CustomDispatchOptions,
+): void;
+
+export function dispatch(
+	target: EventTarget,
+	type: string,
+	options?: DispatchOptions,
+): void {
+	target.dispatchEvent(createEvent(type, options));
+}
+
+function getBoolean(value: unknown, defaultValue?: boolean): boolean {
+	return typeof value === 'boolean' ? value : defaultValue ?? false;
+}
+
+/**
+ * Get the X- and Y-coordinates from a pointer event
+ */
+export function getPosition(
+	event: MouseEvent | TouchEvent,
+): EventPosition | undefined {
+	let x: number | undefined;
+	let y: number | undefined;
+
+	if (event instanceof MouseEvent) {
+		x = event.clientX;
+		y = event.clientY;
+	} else if (event instanceof TouchEvent) {
+		x = event.touches[0]?.clientX;
+		y = event.touches[0]?.clientY;
+	}
+
+	return typeof x === 'number' && typeof y === 'number' ? {x, y} : undefined;
+}
+
+/**
+ * Remove an event listener
+ */
+export function off(
+	target: EventTarget,
+	type: string,
+	listener: EventListener,
+	options?: boolean | EventListenerOptions,
+): void {
+	target.removeEventListener(type, listener, createEventOptions(options));
+}
+
+/**
+ * Add an event listener
+ */
+export function on<Type extends keyof HTMLElementEventMap>(
+	target: EventTarget,
+	type: Type,
+	listener: (event: HTMLElementEventMap[Type]) => void,
+	options?: boolean | AddEventListenerOptions,
+): RemoveEventListener;
+
+/**
+ * Add an event listener
+ */
+export function on(
+	target: EventTarget,
+	type: string,
+	listener: EventListener,
+	options?: boolean | AddEventListenerOptions,
+): RemoveEventListener;
+
+export function on(
+	target: EventTarget,
+	type: string,
+	listener: EventListener,
+	options?: boolean | AddEventListenerOptions,
+): RemoveEventListener {
+	const extended = createEventOptions(options);
+
+	target.addEventListener(type, listener, extended);
+
+	return () => {
+		target.removeEventListener(type, listener, extended);
+	};
+}

package/src/find.ts

@@ -286,3 +286,4 @@ function traverse(from: Element, to: Element): number {
 }
 
 export {findElement as $, findElements as $$};
+

package/src/html.ts

@@ -0,0 +1,90 @@
+import {isPlainObject} from '@oscarpalmer/atoms/is';
+import {type SanitiseOptions, sanitise} from './sanitise';
+
+const templates: Record<string, HTMLTemplateElement> = {};
+
+function createTemplate(html: string): HTMLTemplateElement {
+	const template = document.createElement('template');
+
+	template.innerHTML = html;
+
+	templates[html] = template;
+
+	return template;
+}
+
+function getTemplate(value: string): HTMLTemplateElement | undefined {
+	if (value.trim().length === 0) {
+		return;
+	}
+
+	let template: unknown;
+
+	if (/^[\w-]+$/.test(value)) {
+		template = document.querySelector(`#${value}`);
+	}
+
+	if (template instanceof HTMLTemplateElement) {
+		return template;
+	}
+
+	return templates[value] ?? createTemplate(value);
+}
+
+/**
+ * - Create nodes from a string of _HTML_ or a template element
+ * - If `value` doesn't contain any whitespace, it will be treated as an _ID_ before falling back to being treated as _HTML_
+ * - If `sanitisation` is not provided, `true`, or an options object, bad markup will be sanitised or removed
+ * - Regardless of the value of `sanitisation`, scripts will always be removed
+ */
+export function html(
+	value: string,
+	sanitisation?: boolean | SanitiseOptions,
+): Node[];
+
+/**
+ * - Create nodes from a template element
+ * - If `sanitisation` is not provided, `true`, or an options object, bad markup will be sanitised or removed
+ * - Regardless of the value of `sanitisation`, scripts will always be removed
+ */
+export function html(
+	value: HTMLTemplateElement,
+	sanitisation?: boolean | SanitiseOptions,
+): Node[];
+
+export function html(
+	value: string | HTMLTemplateElement,
+	sanitisation?: boolean | SanitiseOptions,
+): Node[] {
+	const options =
+		sanitisation == null || sanitisation === true
+			? {}
+			: isPlainObject(sanitisation)
+				? {...sanitisation}
+				: null;
+
+	const template =
+		value instanceof HTMLTemplateElement
+			? value
+			: typeof value === 'string'
+				? getTemplate(value)
+				: null;
+
+	if (template == null) {
+		return [];
+	}
+
+	const cloned = template.content.cloneNode(true) as DocumentFragment;
+	const scripts = cloned.querySelectorAll('script');
+	const {length} = scripts;
+
+	for (let index = 0; index < length; index += 1) {
+		scripts[index].remove();
+	}
+
+	cloned.normalize();
+
+	return options != null
+		? sanitise([...cloned.childNodes], options)
+		: [...cloned.childNodes];
+}

package/src/index.ts

@@ -1,7 +1,10 @@
 export * from './attribute';
 export * from './data';
+export * from './event';
 export * from './find';
 export * from './focusable';
+export * from './html';
 export * from './models';
 export * from './sanitise';
 export * from './style';
+

package/src/models.ts

@@ -3,6 +3,21 @@ export type Attribute<Value = unknown> = {
 	value: Value;
 };
 
+export type CustomDispatchOptions = {
+	detail?: unknown;
+} & DispatchOptions;
+
+export type DispatchOptions = {
+	bubbles?: boolean;
+	cancelable?: boolean;
+	composed?: boolean;
+};
+
+export type EventPosition = {
+	x: number;
+	y: number;
+};
+
 export type Selector = string | Document | Element | Element[] | NodeList;
 
 export type TextDirection = 'ltr' | 'rtl';

package/src/sanitise.ts

@@ -60,4 +60,4 @@ function sanitiseNodes(nodes: Node[], options: SanitiseOptions): Node[] {
 	}
 
 	return nodes;
-}
+}

package/types/event.d.ts

@@ -0,0 +1,38 @@
+import type { CustomDispatchOptions, DispatchOptions, EventPosition } from './models';
+/**
+ * Remove the current event listener
+ */
+type RemoveEventListener = () => void;
+/**
+ * Dispatch an event for a target
+ */
+export declare function dispatch<Type extends keyof HTMLElementEventMap>(target: EventTarget, type: Type, options?: DispatchOptions): void;
+/**
+ * Dispatch an event for a target
+ */
+export declare function dispatch<Type extends keyof HTMLElementEventMap>(target: EventTarget, type: Type, options?: CustomDispatchOptions): void;
+/**
+ * Dispatch an event for a target
+ */
+export declare function dispatch(target: EventTarget, type: string, options?: DispatchOptions): void;
+/**
+ * Dispatch an event for a target
+ */
+export declare function dispatch(target: EventTarget, type: string, options?: CustomDispatchOptions): void;
+/**
+ * Get the X- and Y-coordinates from a pointer event
+ */
+export declare function getPosition(event: MouseEvent | TouchEvent): EventPosition | undefined;
+/**
+ * Remove an event listener
+ */
+export declare function off(target: EventTarget, type: string, listener: EventListener, options?: boolean | EventListenerOptions): void;
+/**
+ * Add an event listener
+ */
+export declare function on<Type extends keyof HTMLElementEventMap>(target: EventTarget, type: Type, listener: (event: HTMLElementEventMap[Type]) => void, options?: boolean | AddEventListenerOptions): RemoveEventListener;
+/**
+ * Add an event listener
+ */
+export declare function on(target: EventTarget, type: string, listener: EventListener, options?: boolean | AddEventListenerOptions): RemoveEventListener;
+export {};

package/types/html.d.ts

@@ -0,0 +1,14 @@
+import { type SanitiseOptions } from './sanitise';
+/**
+ * - Create nodes from a string of _HTML_ or a template element
+ * - If `value` doesn't contain any whitespace, it will be treated as an _ID_ before falling back to being treated as _HTML_
+ * - If `sanitisation` is not provided, `true`, or an options object, bad markup will be sanitised or removed
+ * - Regardless of the value of `sanitisation`, scripts will always be removed
+ */
+export declare function html(value: string, sanitisation?: boolean | SanitiseOptions): Node[];
+/**
+ * - Create nodes from a template element
+ * - If `sanitisation` is not provided, `true`, or an options object, bad markup will be sanitised or removed
+ * - Regardless of the value of `sanitisation`, scripts will always be removed
+ */
+export declare function html(value: HTMLTemplateElement, sanitisation?: boolean | SanitiseOptions): Node[];

package/types/index.d.cts

@@ -4,6 +4,18 @@ export type Attribute<Value = unknown> = {
 	name: string;
 	value: Value;
 };
+export type CustomDispatchOptions = {
+	detail?: unknown;
+} & DispatchOptions;
+export type DispatchOptions = {
+	bubbles?: boolean;
+	cancelable?: boolean;
+	composed?: boolean;
+};
+export type EventPosition = {
+	x: number;
+	y: number;
+};
 export type Selector = string | Document | Element | Element[] | NodeList;
 export type TextDirection = "ltr" | "rtl";
 /**
@@ -91,6 +103,42 @@ export declare function setData(element: HTMLElement, data: PlainObject): void;
  * Set a data value on an element
  */
 export declare function setData(element: HTMLElement, key: string, value: unknown): void;
+/**
+ * Remove the current event listener
+ */
+export type RemoveEventListener = () => void;
+/**
+ * Dispatch an event for a target
+ */
+export declare function dispatch<Type extends keyof HTMLElementEventMap>(target: EventTarget, type: Type, options?: DispatchOptions): void;
+/**
+ * Dispatch an event for a target
+ */
+export declare function dispatch<Type extends keyof HTMLElementEventMap>(target: EventTarget, type: Type, options?: CustomDispatchOptions): void;
+/**
+ * Dispatch an event for a target
+ */
+export declare function dispatch(target: EventTarget, type: string, options?: DispatchOptions): void;
+/**
+ * Dispatch an event for a target
+ */
+export declare function dispatch(target: EventTarget, type: string, options?: CustomDispatchOptions): void;
+/**
+ * Get the X- and Y-coordinates from a pointer event
+ */
+export declare function getPosition(event: MouseEvent | TouchEvent): EventPosition | undefined;
+/**
+ * Remove an event listener
+ */
+export declare function off(target: EventTarget, type: string, listener: EventListener, options?: boolean | EventListenerOptions): void;
+/**
+ * Add an event listener
+ */
+export declare function on<Type extends keyof HTMLElementEventMap>(target: EventTarget, type: Type, listener: (event: HTMLElementEventMap[Type]) => void, options?: boolean | AddEventListenerOptions): RemoveEventListener;
+/**
+ * Add an event listener
+ */
+export declare function on(target: EventTarget, type: string, listener: EventListener, options?: boolean | AddEventListenerOptions): RemoveEventListener;
 /**
  * - Find the closest ancestor element that matches the selector
  * - Matches may be found by a query string or a callback
@@ -149,6 +197,19 @@ export type SanitiseOptions = {
  * - Removes or sanitises bad attributes
  */
 export declare function sanitise(value: Node | Node[], options?: Partial<SanitiseOptions>): Node[];
+/**
+ * - Create nodes from a string of _HTML_ or a template element
+ * - If `value` doesn't contain any whitespace, it will be treated as an _ID_ before falling back to being treated as _HTML_
+ * - If `sanitisation` is not provided, `true`, or an options object, bad markup will be sanitised or removed
+ * - Regardless of the value of `sanitisation`, scripts will always be removed
+ */
+export declare function html(value: string, sanitisation?: boolean | SanitiseOptions): Node[];
+/**
+ * - Create nodes from a template element
+ * - If `sanitisation` is not provided, `true`, or an options object, bad markup will be sanitised or removed
+ * - Regardless of the value of `sanitisation`, scripts will always be removed
+ */
+export declare function html(value: HTMLTemplateElement, sanitisation?: boolean | SanitiseOptions): Node[];
 /**
  * Get a style from an element
  */

package/types/index.d.ts

@@ -1,7 +1,9 @@
 export * from './attribute';
 export * from './data';
+export * from './event';
 export * from './find';
 export * from './focusable';
+export * from './html';
 export * from './models';
 export * from './sanitise';
 export * from './style';

package/types/models.d.ts

@@ -2,5 +2,17 @@ export type Attribute<Value = unknown> = {
     name: string;
     value: Value;
 };
+export type CustomDispatchOptions = {
+    detail?: unknown;
+} & DispatchOptions;
+export type DispatchOptions = {
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+};
+export type EventPosition = {
+    x: number;
+    y: number;
+};
 export type Selector = string | Document | Element | Element[] | NodeList;
 export type TextDirection = 'ltr' | 'rtl';