@oscarpalmer/toretto 0.38.0 → 0.39.1

package/dist/attribute/get.js

@@ -1,5 +1,6 @@
 import { getAttributeValue } from "../internal/get-value.js";
 import { isHTMLOrSVGElement } from "../internal/is.js";
+//#region src/attribute/get.ts
 function getAttribute(element, name, parseValues) {
 	if (isHTMLOrSVGElement(element) && typeof name === "string") return getAttributeValue(element, name, parseValues !== false);
 }
@@ -21,4 +22,5 @@ function getAttributes(element, names, parseData) {
 	}
 	return attributes;
 }
+//#endregion
 export { getAttribute, getAttributes };

package/dist/attribute/index.js

@@ -1,6 +1,7 @@
 import { getAttribute, getAttributes } from "./get.js";
 import { _isBadAttribute, _isBooleanAttribute, _isEmptyNonBooleanAttribute, _isInvalidBooleanAttribute, booleanAttributes } from "../internal/attribute.js";
 import { setAttribute, setAttributes } from "./set.js";
+//#region src/attribute/index.ts
 function isBadAttribute(first, second) {
 	return _isBadAttribute(first, second, true);
 }
@@ -13,4 +14,5 @@ function isEmptyNonBooleanAttribute(first, second) {
 function isInvalidBooleanAttribute(first, second) {
 	return _isInvalidBooleanAttribute(first, second, true);
 }
+//#endregion
 export { booleanAttributes, getAttribute, getAttributes, isBadAttribute, isBooleanAttribute, isEmptyNonBooleanAttribute, isInvalidBooleanAttribute, setAttribute, setAttributes };

package/dist/attribute/set.js

@@ -1,9 +1,11 @@
 import { setElementValue, setElementValues } from "../internal/element-value.js";
 import { updateAttribute } from "../internal/attribute.js";
+//#region src/attribute/set.ts
 function setAttribute(element, first, second, third) {
 	setElementValue(element, first, second, third, updateAttribute);
 }
 function setAttributes(element, attributes, dispatch) {
 	setElementValues(element, attributes, null, dispatch, updateAttribute);
 }
+//#endregion
 export { setAttribute, setAttributes };

package/dist/data.js

@@ -3,6 +3,7 @@ import { isHTMLOrSVGElement } from "./internal/is.js";
 import { setElementValues, updateElementValue } from "./internal/element-value.js";
 import { parse } from "@oscarpalmer/atoms/string";
 import { kebabCase } from "@oscarpalmer/atoms/string/case";
+//#region src/data.ts
 function getData(element, keys, parseValues) {
 	if (!isHTMLOrSVGElement(element)) return;
 	const shouldParse = parseValues !== false;
@@ -31,4 +32,5 @@ function updateDataAttribute(element, key, value) {
 	updateElementValue(element, getName(key), value, element.setAttribute, element.removeAttribute, false, true);
 }
 var ATTRIBUTE_DATA_PREFIX = "data-";
+//#endregion
 export { getData, setData };

package/dist/event/delegation.js

@@ -1,4 +1,5 @@
 import { isEventTarget } from "../internal/is.js";
+//#region src/event/delegation.ts
 function addDelegatedHandler(doc, type, name, passive) {
 	if (DELEGATED.has(name)) return;
 	DELEGATED.add(name);
@@ -80,4 +81,5 @@ var EVENT_TYPES = new Set([
 ]);
 var HANDLER_ACTIVE = delegatedEventHandler.bind(false);
 var HANDLER_PASSIVE = delegatedEventHandler.bind(true);
+//#endregion
 export { addDelegatedListener, getDelegatedName, removeDelegatedListener };

package/dist/event/index.js

@@ -3,6 +3,7 @@ import { isEventTarget } from "../internal/is.js";
 import { addDelegatedListener, getDelegatedName, removeDelegatedListener } from "./delegation.js";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
 import { noop } from "@oscarpalmer/atoms/function";
+//#region src/event/index.ts
 function createDispatchOptions(options) {
 	return {
 		bubbles: getBoolean(options?.bubbles, true),
@@ -74,4 +75,5 @@ function on(target, type, listener, options) {
 	};
 }
 var PROPERTY_DETAIL = "detail";
+//#endregion
 export { dispatch, getPosition, off, on };

package/dist/find/index.js

@@ -1,4 +1,5 @@
 import { findAncestor, findRelatives, getDistance } from "./relative.js";
+//#region src/find/index.ts
 function findElement(selector, context) {
 	return findElementOrElements(selector, context, true);
 }
@@ -69,4 +70,5 @@ var STYLE_HIDDEN = "hidden";
 var STYLE_NONE = "none";
 var SUFFIX_HOVER = ":hover";
 var TAG_HEAD = "HEAD";
+//#endregion
 export { findElement as $, findElement, findElements as $$, findElements, findAncestor, findRelatives, getDistance, getElementUnderPointer };

package/dist/find/relative.js

@@ -1,3 +1,4 @@
+//#region src/find/relative.ts
 function findAncestor(origin, selector) {
 	const element = getElement(origin);
 	if (element == null || selector == null) return null;
@@ -74,4 +75,5 @@ function traverse(from, to) {
 		parent = parent.parentElement;
 	}
 }
+//#endregion
 export { findAncestor, findRelatives, getDistance };

package/dist/focusable.js

@@ -1,3 +1,4 @@
+//#region src/focusable.ts
 /**
 * Get a list of focusable elements within a parent element
 * @param parent Parent element
@@ -159,4 +160,5 @@ var STYLE_NONE = "none";
 var TABINDEX_BASE = 0;
 var TABINDEX_DEFAULT = -1;
 var TYPE_RADIO = "radio";
+//#endregion
 export { getFocusable, getTabbable, isFocusable, isTabbable };

package/dist/html/index.js

@@ -1,5 +1,6 @@
 import { sanitizeNodes } from "./sanitize.js";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
+//#region src/html/index.ts
 function createHtml(value) {
 	const parsed = getParser().parseFromString(getHtml(value), PARSE_TYPE_HTML);
 	parsed.body.normalize();
@@ -69,4 +70,5 @@ var TEMPLATE_TAG = "template";
 var TEMPORARY_ELEMENT = "<toretto-temporary></toretto-temporary>";
 var parser;
 var templates = {};
+//#endregion
 export { html, sanitize };

package/dist/html/sanitize.js

@@ -1,5 +1,6 @@
 import { _isBadAttribute, _isEmptyNonBooleanAttribute, _isInvalidBooleanAttribute } from "../internal/attribute.js";
 import { setAttribute } from "../attribute/set.js";
+//#region src/html/sanitize.ts
 function handleElement(element, depth) {
 	if (depth === 0) {
 		const removable = element.querySelectorAll(REMOVE_SELECTOR);
@@ -57,4 +58,5 @@ function sanitizeNodes(nodes, depth) {
 }
 var COMMENT_HARMFUL = /<[/\w]/g;
 var REMOVE_SELECTOR = "script, toretto-temporary";
+//#endregion
 export { sanitizeAttributes, sanitizeNodes };

package/dist/internal/attribute.js

@@ -1,5 +1,6 @@
 import { updateElementValue } from "./element-value.js";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
+//#region src/internal/attribute.ts
 function badAttributeHandler(name, value) {
 	if (typeof name !== "string" || name.trim().length === 0 || typeof value !== "string") return true;
 	if (EXPRESSION_CLOBBERED_NAME.test(name) && (value in document || value in formElement) || EXPRESSION_EVENT_NAME.test(name)) return true;
@@ -73,7 +74,7 @@ var EXPRESSION_WHITESPACE = /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F
 /**
 * List of boolean attributes
 */
-const booleanAttributes = Object.freeze([
+var booleanAttributes = Object.freeze([
 	"async",
 	"autofocus",
 	"autoplay",
@@ -111,4 +112,5 @@ var elementEvents = {
 };
 var formElement = document.createElement("form");
 var textArea;
+//#endregion
 export { _isBadAttribute, _isBooleanAttribute, _isEmptyNonBooleanAttribute, _isInvalidBooleanAttribute, booleanAttributes, isAttribute, updateAttribute };

package/dist/internal/element-value.js

@@ -2,6 +2,7 @@ import { isHTMLOrSVGElement } from "./is.js";
 import "../is.js";
 import { isAttribute } from "./attribute.js";
 import { isNullableOrWhitespace } from "@oscarpalmer/atoms/is";
+//#region src/internal/element-value.ts
 function setElementValue(element, first, second, third, callback) {
 	if (!isHTMLOrSVGElement(element)) return;
 	if (typeof first === "string") setElementValues(element, first, second, third, callback);
@@ -29,4 +30,5 @@ function updateElementValue(element, key, value, set, remove, isBoolean, json) {
 	if (isBoolean ? value == null : isNullableOrWhitespace(value)) remove.call(element, key);
 	else set.call(element, key, json ? JSON.stringify(value) : String(value));
 }
+//#endregion
 export { setElementValue, setElementValues, updateElementValue };

package/dist/internal/get-value.js

@@ -1,5 +1,6 @@
 import { parse } from "@oscarpalmer/atoms/string";
 import { camelCase, kebabCase } from "@oscarpalmer/atoms/string/case";
+//#region src/internal/get-value.ts
 function getBoolean(value, defaultValue) {
 	return typeof value === "boolean" ? value : defaultValue ?? false;
 }
@@ -13,5 +14,6 @@ function getStyleValue(element, property, computed) {
 	const name = camelCase(property);
 	return computed ? getComputedStyle(element)[name] : element.style[name];
 }
-const EXPRESSION_DATA_PREFIX = /^data-/i;
+var EXPRESSION_DATA_PREFIX = /^data-/i;
+//#endregion
 export { EXPRESSION_DATA_PREFIX, getAttributeValue, getBoolean, getStyleValue };

package/dist/internal/is.js

@@ -1,3 +1,4 @@
+//#region src/internal/is.ts
 /**
 * Is the value an event target?
 * @param value Value to check
@@ -14,4 +15,5 @@ function isEventTarget(value) {
 function isHTMLOrSVGElement(value) {
 	return value instanceof HTMLElement || value instanceof SVGElement;
 }
+//#endregion
 export { isEventTarget, isHTMLOrSVGElement };

package/dist/is.js

@@ -1,4 +1,5 @@
 import { isEventTarget, isHTMLOrSVGElement } from "./internal/is.js";
+//#region src/is.ts
 /**
 * Is the value a child node?
 * @param value Value to check
@@ -19,4 +20,5 @@ var CHILD_NODE_TYPES = new Set([
 	Node.COMMENT_NODE,
 	Node.DOCUMENT_TYPE_NODE
 ]);
+//#endregion
 export { isChildNode, isEventTarget, isHTMLOrSVGElement, isInDocument };

package/dist/style.js

@@ -1,6 +1,7 @@
 import { getStyleValue } from "./internal/get-value.js";
 import { isHTMLOrSVGElement } from "./internal/is.js";
 import { setElementValues, updateElementValue } from "./internal/element-value.js";
+//#region src/style.ts
 /**
 * Get a style from an element
 * @param element Element to get the style from
@@ -100,4 +101,5 @@ function updateStyleProperty(element, key, value) {
 }
 var ATTRIBUTE_DIRECTION = "dir";
 var EXPRESSION_DIRECTION = /^(ltr|rtl)$/i;
+//#endregion
 export { getStyle, getStyles, getTextDirection, setStyle, setStyles, toggleStyles };

package/dist/toretto.full.js

@@ -373,7 +373,7 @@ var Memoized = class {
 	constructor(callback, options) {
 		const cache = new SizedMap(options.cacheSize);
 		const getter = (...parameters) => {
-			const key = options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), "_"));
+			const key = options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), SEPARATOR));
 			if (cache.has(key)) return cache.get(key);
 			const value = callback(...parameters);
 			cache.set(key, value);
@@ -449,13 +449,14 @@ function memoize(callback, options) {
 	return new Memoized(callback, getMemoizationOptions(options));
 }
 var DEFAULT_CACHE_SIZE = 1024;
+var SEPARATOR = "_";
 /**
 * Convert a string to camel case _(thisIsCamelCase)_
 * @param value String to convert
 * @returns Camel-cased string
 */
 function camelCase(value) {
-	return toCase("camel", value, true, false);
+	return toCase(CASE_CAMEL, value, true, false);
 }
 /**
 * Capitalize the first letter of a string _(and lowercase the rest)_
@@ -473,7 +474,7 @@ function capitalize(value) {
 * @returns Kebab-cased string
 */
 function kebabCase(value) {
-	return toCase("kebab", value, false, false);
+	return toCase(CASE_KEBAB, value, false, false);
 }
 function toCase(type, value, capitalizeAny, capitalizeFirst) {
 	caseMemoizers[type] ??= memoize(toCaseCallback.bind({
@@ -491,7 +492,7 @@ function toCaseCallback(value) {
 	const partsLength = parts.length;
 	const cased = [];
 	for (let partIndex = 0; partIndex < partsLength; partIndex += 1) {
-		const items = parts[partIndex].replace(EXPRESSION_ACRONYM, (full, one, two, three) => three === "s" ? full : `${one}-${two}${three}`).replace(EXPRESSION_CAMEL_CASE, REPLACEMENT_CAMEL_CASE).split("-");
+		const items = parts[partIndex].replace(EXPRESSION_ACRONYM, (full, one, two, three) => three === S ? full : `${one}-${two}${three}`).replace(EXPRESSION_CAMEL_CASE, REPLACEMENT_CAMEL_CASE).split("-");
 		const itemsLength = items.length;
 		const partResult = [];
 		let itemCount = 0;
@@ -506,16 +507,24 @@ function toCaseCallback(value) {
 	}
 	return join(cased, delimiters[type]);
 }
-var caseMemoizers = {};
-var delimiters = {
-	camel: "",
-	kebab: "-",
-	pascal: "",
-	snake: "_"
-};
+var CASE_CAMEL = "camel";
+var CASE_KEBAB = "kebab";
+var CASE_PASCAL = "pascal";
+var CASE_SNAKE = "snake";
+var DELIMTER_EMPTY = "";
+var DELIMITER_HYPHEN = "-";
+var DELIMITER_UNDERSCORE = "_";
 var EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
 var EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
 var REPLACEMENT_CAMEL_CASE = "$1-$2";
+var S = "s";
+var caseMemoizers = {};
+var delimiters = {
+	[CASE_CAMEL]: DELIMTER_EMPTY,
+	[CASE_KEBAB]: DELIMITER_HYPHEN,
+	[CASE_PASCAL]: DELIMTER_EMPTY,
+	[CASE_SNAKE]: DELIMITER_UNDERSCORE
+};
 var memoizedCapitalize;
 function getBoolean(value, defaultValue) {
 	return typeof value === "boolean" ? value : defaultValue ?? false;
@@ -572,6 +581,159 @@ const ATTRIBUTE_DATA_PREFIX = "data-";
 * A function that does nothing, which can be useful, I guess…
 */
 function noop() {}
+/**
+* Asserts that a condition is true, throwing an error if it is not
+* @param condition Condition to assert
+* @param message Error message
+* @param error Error constructor
+*/
+function assert(condition, message, error) {
+	if (!condition()) throw new (error ?? Error)(message);
+}
+assert.condition = assertCondition;
+assert.defined = assertDefined;
+assert.instanceOf = assertInstanceOf;
+assert.is = assertIs;
+/**
+* Creates an asserter that asserts a condition is true, throwing an error if it is not
+* @param condition Condition to assert
+* @param message Error message
+* @param error Error constructor
+* @returns Asserter
+*/
+function assertCondition(condition, message, error) {
+	return (value) => {
+		assert(() => condition(value), message, error);
+	};
+}
+/**
+* Asserts that a value is defined throwing an error if it is not
+* @param value Value to assert
+* @param message Error message
+*/
+function assertDefined(value, message) {
+	assert(() => value != null, message ?? MESSAGE_VALUE_DEFINED);
+}
+/**
+* Creates an asserter that asserts a value is an instance of a constructor, throwing an error if it is not
+* @param constructor Constructor to check against
+* @param message Error message
+* @param error Error constructor
+* @returns Asserter
+*/
+function assertInstanceOf(constructor, message, error) {
+	return (value) => {
+		assert(() => value instanceof constructor, message, error);
+	};
+}
+/**
+* Creates an asserter that asserts a value is of a specific type, throwing an error if it is not
+* @param condition Type guard function to check the value
+* @param message Error message
+* @param error Error constructor
+* @returns Asserter
+*/
+function assertIs(condition, message, error) {
+	return (value) => {
+		assert(() => condition(value), message, error);
+	};
+}
+var MESSAGE_VALUE_DEFINED = "Expected value to be defined";
+/**
+* Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
+* @param callback Callback to use once
+* @returns Once callback
+*/
+function asyncOnce(callback) {
+	assert(() => typeof callback === "function", MESSAGE_EXPECTATION);
+	const state = {
+		called: false,
+		cleared: false,
+		error: false,
+		finished: false,
+		items: [],
+		value: void 0
+	};
+	const fn = (...parameters) => {
+		if (state.cleared) return Promise.reject(new Error(MESSAGE_CLEARED));
+		if (state.finished) return state.error ? Promise.reject(state.value) : Promise.resolve(state.value);
+		if (state.called) return new Promise((resolve, reject) => {
+			state.items.push({
+				reject,
+				resolve
+			});
+		});
+		state.called = true;
+		return new Promise((resolve, reject) => {
+			state.items.push({
+				reject,
+				resolve
+			});
+			callback(...parameters).then((value) => {
+				handleResult(state, value, false);
+			}).catch((error) => {
+				handleResult(state, error, true);
+			});
+		});
+	};
+	Object.defineProperties(fn, {
+		called: { get: () => state.called },
+		cleared: { get: () => state.cleared },
+		error: { get: () => state.error },
+		finished: { get: () => state.finished }
+	});
+	fn.clear = () => {
+		if (!state.called || !state.finished || state.cleared) return;
+		state.cleared = true;
+		state.value = void 0;
+	};
+	return fn;
+}
+function handleResult(state, value, error) {
+	state.error = error;
+	state.finished = true;
+	state.value = value;
+	const items = state.items.splice(0);
+	const { length } = items;
+	for (let index = 0; index < length; index += 1) {
+		const { reject, resolve } = items[index];
+		if (error) reject(value);
+		else resolve(value);
+	}
+}
+/**
+* Create a function that can only be called once, returning the same value on subsequent calls
+* @param callback Callback to use once
+* @returns Once callback
+*/
+function once(callback) {
+	assert(() => typeof callback === "function", MESSAGE_EXPECTATION);
+	const state = {
+		called: false,
+		cleared: false,
+		value: void 0
+	};
+	const fn = (...parameters) => {
+		if (state.cleared) throw new Error(MESSAGE_CLEARED);
+		if (state.called) return state.value;
+		state.called = true;
+		state.value = callback(...parameters);
+		return state.value;
+	};
+	Object.defineProperties(fn, {
+		called: { get: () => state.called },
+		cleared: { get: () => state.cleared }
+	});
+	fn.clear = () => {
+		if (!state.called || state.cleared) return;
+		state.cleared = true;
+		state.value = void 0;
+	};
+	return fn;
+}
+once.async = asyncOnce;
+var MESSAGE_CLEARED = "Once has been cleared";
+var MESSAGE_EXPECTATION = "Once expected a function";
 function addDelegatedHandler(doc, type, name, passive) {
 	if (DELEGATED.has(name)) return;
 	DELEGATED.add(name);

package/dist/touch.js

@@ -1,3 +1,4 @@
+//#region src/touch.ts
 function getSupport() {
 	if (window == null || navigator == null) return false;
 	if ("matchMedia" in window) {
@@ -28,4 +29,5 @@ var supportsTouch = (() => {
 	} });
 	return instance;
 })();
+//#endregion
 export { supportsTouch as default };

package/package.json

@@ -4,26 +4,27 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.157"
+		"@oscarpalmer/atoms": "^0.162"
 	},
 	"description": "A collection of badass DOM utilities.",
 	"devDependencies": {
-		"@types/node": "^25.3",
+		"@types/node": "^25.4",
 		"@vitest/coverage-istanbul": "^4",
+		"dts-bundle-generator": "^9.5",
 		"jsdom": "^28.1",
-		"oxfmt": "^0.36",
-		"oxlint": "^1.51",
-		"rolldown": "1.0.0-rc.7",
+		"oxfmt": "^0.39",
+		"oxlint": "^1.54",
+		"rolldown": "1.0.0-rc.9",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
-		"vite": "8.0.0-beta.16",
+		"vite": "8.0.0-beta.17",
 		"vitest": "^4"
 	},
 	"exports": {
 		"./package.json": "./package.json",
 		".": {
 			"types": "./types/index.d.ts",
-			"default": "./dist/index.js"
+			"default": "./dist/toretto.full.js"
 		},
 		"./attribute": {
 			"types": "./types/attribute/index.d.ts",
@@ -84,7 +85,7 @@
 		"url": "git+https://github.com/oscarpalmer/toretto.git"
 	},
 	"scripts": {
-		"build": "npm run clean && npx vite build && npm run rolldown:build && npx tsc",
+		"build": "npm run clean && npx vite build && npm run rolldown:build && npx tsc && npx dts-bundle-generator --config ./dts.config.ts --silent",
 		"clean": "rm -rf ./dist && rm -rf ./types && rm -f ./tsconfig.tsbuildinfo",
 		"rolldown:build": "npx rolldown -c",
 		"rolldown:watch": "npx rolldown -c ./rolldown.config.js --watch",
@@ -93,5 +94,5 @@
 	},
 	"type": "module",
 	"types": "types/index.d.ts",
-	"version": "0.38.0"
+	"version": "0.39.1"
 }

package/src/find/index.ts

@@ -1,4 +1,4 @@
-import type {PlainObject} from '@oscarpalmer/atoms/models';
+import type {PlainObject} from '@oscarpalmer/atoms';
 import type {Selector} from '../models';
 
 /**

package/src/internal/attribute.ts

@@ -1,4 +1,4 @@
-import type {PlainObject} from '@oscarpalmer/atoms/models';
+import type {PlainObject} from '@oscarpalmer/atoms';
 import {isPlainObject} from '@oscarpalmer/atoms/is';
 import type {Attribute} from '../models';
 import {updateElementValue} from './element-value';

package/types/index.d.ts

@@ -1,11 +1,428 @@
-import supportsTouch from './touch';
-export { isBadAttribute, isBooleanAttribute, isEmptyNonBooleanAttribute, isInvalidBooleanAttribute, } from './attribute/index';
-export * from './data';
-export * from './event/index';
-export * from './find/index';
-export * from './focusable';
-export * from './html/index';
-export * from './is';
-export * from './models';
-export * from './style';
-export { supportsTouch };
+// Generated by dts-bundle-generator v9.5.1
+
+export type SupporsTouch = {
+	/**
+	 * Are touch events supported?
+	 */
+	readonly value: boolean;
+	/**
+	 * Are touch events supported?
+	 */
+	get(): boolean;
+	/**
+	 * Re-evaluate if touch events are supported
+	 */
+	update(): boolean;
+};
+/**
+ * Does the device support touch events?
+ */
+export declare const supportsTouch: SupporsTouch;
+/**
+ * Attribute for an element
+ */
+export type Attribute = {
+	name: string;
+	value: unknown;
+};
+/**
+ * Event listener for custom events
+ */
+export type CustomEventListener = (event: CustomEvent) => void;
+/**
+ * The position of an event
+ */
+export type EventPosition = {
+	x: number;
+	y: number;
+};
+/**
+ * Event listener that can be removed
+ */
+export type RemovableEventListener = () => void;
+/**
+ * Selector that be searched for
+ */
+export type Selector = string | Node | Node[] | NodeList;
+/**
+ * Text direction for an element
+ */
+export type TextDirection = "ltr" | "rtl";
+/**
+ * Is the attribute considered bad and potentially harmful?
+ * @param attribute Attribute to check
+ * @returns `true` if attribute is considered bad
+ */
+export declare function isBadAttribute(attribute: Attr | Attribute): boolean;
+/**
+ * Is the attribute considered bad and potentially harmful?
+ * @param name Attribute name
+ * @param value Attribute value
+ * @returns `true` if attribute is considered bad
+ */
+export declare function isBadAttribute(name: string, value: string): boolean;
+/**
+ * Is the attribute a boolean attribute?
+ * @param name Attribute to check
+ * @returns `true` if attribute is a boolean attribute
+ */
+export declare function isBooleanAttribute(attribute: Attr | Attribute): boolean;
+/**
+ * Is the attribute a boolean attribute?
+ * @param name Attribute name
+ * @returns `true` if attribute is a boolean attribute
+ */
+export declare function isBooleanAttribute(name: string): boolean;
+/**
+ * Is the attribute empty and not a boolean attribute?
+ * @param attribute Attribute to check
+ * @returns `true` if attribute is empty and not a boolean attribute
+ */
+export declare function isEmptyNonBooleanAttribute(attribute: Attr | Attribute): boolean;
+/**
+ * Is the attribute empty and not a boolean attribute?
+ * @param name Attribute name
+ * @param value Attribute value
+ * @returns `true` if attribute is empty and not a boolean attribute
+ */
+export declare function isEmptyNonBooleanAttribute(name: string, value: string): boolean;
+/**
+ * Is the attribute an invalid boolean attribute?
+ *
+ * _(I.e., its value is not empty or the same as its name)_
+ * @param attribute Attribute to check
+ * @returns `true` if attribute is an invalid boolean attribute
+ */
+export declare function isInvalidBooleanAttribute(attribute: Attr | Attribute): boolean;
+/**
+ * Is the attribute an invalid boolean attribute?
+ *
+ * _(I.e., its value is not empty or the same as its name)_
+ * @param name Attribute name
+ * @param value Attribute value
+ * @returns `true` if attribute is an invalid boolean attribute
+ */
+export declare function isInvalidBooleanAttribute(name: string, value: string): boolean;
+/**
+ * A generic object
+ */
+export type PlainObject = Record<PropertyKey, unknown>;
+/**
+ * Get a keyed data value from an element
+ * @param element Element to get data from
+ * @param key Data key
+ * @param parse Parse values? _(defaults to `true`)_
+ * @returns Data value
+ */
+export declare function getData(element: Element, key: string, parse?: boolean): unknown;
+/**
+ * Get keyed data values from an element
+ * @param element Element to get data from
+ * @param keys Keys of the data values to get
+ * @param parse Parse values? _(defaults to `true`)_
+ * @returns Keyed data values
+ */
+export declare function getData<Key extends string>(element: Element, keys: Key[], parse?: boolean): Record<Key, unknown>;
+/**
+ * Set data values on an element
+ * @param element Element to set data on
+ * @param data Data to set
+ */
+export declare function setData(element: Element, data: PlainObject): void;
+/**
+ * Set a data value on an element
+ * @param element Element to set data on
+ * @param key Data key
+ * @param value Data value
+ */
+export declare function setData(element: Element, key: string, value: unknown): void;
+/**
+ * Dispatch an event for a target
+ * @param target Event target
+ * @param type Type of event
+ * @param options Options for event _(bubbles and is cancelable by default)_
+ */
+export declare function dispatch<Type extends keyof HTMLElementEventMap>(target: EventTarget, type: Type, options?: CustomEventInit): void;
+/**
+ * Dispatch an event for a target
+ * @param target Event target
+ * @param type Type of event
+ * @param options Options for event _(bubbles and is cancelable by default)_
+ */
+export declare function dispatch(target: EventTarget, type: string, options?: CustomEventInit): void;
+/**
+ * Get the X- and Y-coordinates from a pointer event
+ * @param event Pointer event
+ * @returns X- and Y-coordinates
+ */
+export declare function getPosition(event: MouseEvent | TouchEvent): EventPosition | undefined;
+/**
+ * Remove an event listener
+ * @param target Event target
+ * @param type Type of event
+ * @param listener Event listener
+ * @param options Options for event
+ */
+export declare function off(target: EventTarget, type: keyof HTMLElementEventMap, listener: EventListener | CustomEventListener, options?: EventListenerOptions): void;
+/**
+ * Remove an event listener
+ * @param target Event target
+ * @param type Type of event
+ * @param listener Event listener
+ * @param options Options for event
+ */
+export declare function off(target: EventTarget, type: string, listener: EventListener | CustomEventListener, options?: EventListenerOptions): void;
+/**
+ * Add an event listener
+ * @param target Event target
+ * @param type Type of event
+ * @param listener Event listener
+ * @param options Options for event _(passive by default)_
+ */
+export declare function on<Type extends keyof HTMLElementEventMap>(target: EventTarget, type: Type, listener: (event: HTMLElementEventMap[Type]) => void, options?: AddEventListenerOptions): RemovableEventListener;
+/**
+ * Add an event listener
+ * @param target Event target
+ * @param type Type of event
+ * @param listener Event listener
+ * @param options Options for event _(passive by default)_
+ */
+export declare function on(target: EventTarget, type: string, listener: EventListener | CustomEventListener, options?: AddEventListenerOptions): RemovableEventListener;
+/**
+ * Find the closest ancestor element that matches the tag name
+ *
+ * - If no match is found, `null` is returned
+ * - _(If you want to search upwards, downwards, and sideways, use {@link findRelatives})_
+ * @param origin Origin to start from
+ * @param tagName Tag name to match
+ * @returns Found ancestor or `null`
+ */
+export declare function findAncestor<TagName extends keyof HTMLElementTagNameMap>(origin: Element | Event | EventTarget, tagName: TagName): HTMLElementTagNameMap[TagName] | null;
+/**
+ * Find the closest ancestor element that matches the selector _(string or callback)_
+ *
+ * - If no match is found, `null` is returned
+ * - _(If you want to search upwards, downwards, and sideways, use {@link findRelatives})_
+ * @param origin Origin to start from
+ * @param selector Selector to match
+ * @returns Found ancestor or `null`
+ */
+export declare function findAncestor(origin: Element | Event | EventTarget, selector: string | ((element: Element) => boolean)): Element | null;
+/**
+ * Finds the closest elements to the origin element that matches the tag name
+ *
+ * Traverses up, down, and sideways in the _DOM_-tree. _(If you only want to traverse up, use {@link findAncestor})_
+ * @param origin Element to start from
+ * @param tagName Tag name to match
+ * @param context Context to search within
+ * @returns Found elements
+ */
+export declare function findRelatives<TagName extends keyof HTMLElementTagNameMap>(origin: Element, tagName: TagName, context?: Document | Element): HTMLElementTagNameMap[TagName][];
+/**
+ * Finds the closest elements to the origin element that matches the selector
+ *
+ * Traverses up, down, and sideways in the _DOM_-tree. _(If you only want to traverse up, use {@link findAncestor})_
+ * @param origin Element to start from
+ * @param selector Selector to match
+ * @param context Context to search within
+ * @returns Found elements
+ */
+export declare function findRelatives(origin: Element, selector: string, context?: Document | Element): Element[];
+/**
+ * Get the distance between two elements _(i.e., the amount of nodes of between them)_
+ * @param origin Origin element
+ * @param target Target element
+ * @returns Distance between elements, or `-1` if distance cannot be calculated
+ */
+export declare function getDistance(origin: Element, target: Element): number;
+/**
+ * Find the first element that matches the tag name
+ * @param tagName Tag name of element to find
+ * @param context Context to search within _(defaults to `document`)_
+ * @returns Found element or `null`
+ */
+export declare function findElement<TagName extends keyof HTMLElementTagNameMap>(tagName: TagName, context?: Selector | null): HTMLElementTagNameMap[TagName] | null;
+/**
+ * Find the first element that matches the selector
+ * @param selector Selector to find element for
+ * @param context Context to search within _(defaults to `document`)_
+ * @returns Found element or `null`
+ */
+export declare function findElement(selector: string, context?: Selector | null): Element | null;
+/**
+ * Find elements that match the selector
+ * @param tagName tagName to find elements for
+ * @param context Context to search within _(defaults to `document`)_
+ * @returns Found elements
+ */
+export declare function findElements(tagName: keyof HTMLElementTagNameMap, context?: Selector | null): HTMLElementTagNameMap[typeof tagName][];
+/**
+ * Find elements that match the selector
+ * @param selector Selector to find elements for
+ * @param context Context to search within _(defaults to `document`)_
+ * @returns Found elements
+ */
+export declare function findElements(selector: Selector, context?: Selector | null): Element[];
+/**
+ * Get the most specific element under the pointer
+ *
+ * - Ignores elements with `pointer-events: none` and `visibility: hidden`
+ * - _(If `skipIgnore` is `true`, no elements are ignored)_
+ * @param skipIgnore Skip ignored elements?
+ * @returns Found element or `null`
+ */
+export declare function getElementUnderPointer(skipIgnore?: boolean): Element | null;
+/**
+ * Get a list of focusable elements within a parent element
+ * @param parent Parent element
+ * @returns Focusable elements
+ */
+export declare function getFocusable(parent: Element): Element[];
+/**
+ * Get a list of tabbable elements within a parent element
+ * @param parent Parent element
+ * @returns Tabbable elements
+ */
+export declare function getTabbable(parent: Element): Element[];
+/**
+ * Is the element focusable?
+ * @param element Element to check
+ * @returns `true` if focusable, otherwise `false`
+ */
+export declare function isFocusable(element: Element): boolean;
+/**
+ * Is the element tabbable?
+ * @param element Element to check
+ * @returns `true` if tabbable, otherwise `false`
+ */
+export declare function isTabbable(element: Element): boolean;
+export type Html = {
+	/**
+	 * Create nodes from an HTML string or a template element
+	 * @param value HTML string or id for a template element
+	 * @param options Options for creating nodes
+	 * @returns Created nodes
+	 */
+	(value: string, options?: HtmlOptions): Node[];
+	/**
+	 * Create nodes from a template element
+	 * @param template Template element
+	 * @param options Options for creating nodes
+	 * @returns Created nodes
+	 */
+	(template: HTMLTemplateElement, options?: HtmlOptions): Node[];
+	/**
+	 * Clear cache of template elements
+	 */
+	clear(): void;
+	/**
+	 * Remove cached template element for an HTML string or id
+	 * @param template HTML string or id for a template element
+	 */
+	remove(template: string): void;
+};
+export type HtmlOptions = {
+	/**
+	 * Cache template element for the HTML string? _(defaults to `true`)_
+	 */
+	cache?: boolean;
+};
+export declare const html: Html;
+/**
+ * Sanitize one or more nodes, recursively
+ * @param value Node or nodes to sanitize
+ * @param options Sanitization options
+ * @returns Sanitized nodes
+ */
+export declare function sanitize(value: Node | Node[]): Node[];
+/**
+ * Is the value an event target?
+ * @param value Value to check
+ * @returns `true` if it's an event target, otherwise `false`
+ */
+export declare function isEventTarget(value: unknown): value is EventTarget;
+/**
+ * Is the value an HTML or SVG element?
+ * @param value Value to check
+ * @returns `true` if it's an HTML or SVG element, otherwise `false`
+ */
+export declare function isHTMLOrSVGElement(value: unknown): value is HTMLElement | SVGElement;
+/**
+ * Is the value a child node?
+ * @param value Value to check
+ * @returns `true` if it's a child node, otherwise `false`
+ */
+export declare function isChildNode(value: unknown): value is ChildNode;
+/**
+ * Is the node inside a document?
+ * @param node Node to check
+ * @returns `true` if it's inside a document, otherwise `false`
+ */
+export declare function isInDocument(node: Node): boolean;
+/**
+ * Is the node inside a specific document?
+ * @param node Node to check
+ * @param document Document to check within
+ * @returns `true` if it's inside the document, otherwise `false`
+ */
+export declare function isInDocument(node: Node, document: Document): boolean;
+export type StyleToggler = {
+	/**
+	 * Set the provided styles on the element
+	 */
+	set(): void;
+	/**
+	 * Remove the provided styles from the element _(and sets any previous styles)_
+	 */
+	remove(): void;
+};
+/**
+ * Get a style from an element
+ * @param element Element to get the style from
+ * @param property Style name
+ * @param computed Get the computed style? _(defaults to `false`)_
+ * @returns Style value
+ */
+export declare function getStyle(element: Element, property: keyof CSSStyleDeclaration, computed?: boolean): string | undefined;
+/**
+ * Get styles from an element
+ * @param element Element to get the styles from
+ * @param properties Styles to get
+ * @param computed Get the computed styles? _(defaults to `false`)_
+ * @returns Style values
+ */
+export declare function getStyles<Property extends keyof CSSStyleDeclaration>(element: Element, properties: Property[], computed?: boolean): Record<Property, string | undefined>;
+/**
+ * Get the text direction of an element
+ * @param element Element to get the text direction from
+ * @param computed Get the computed text direction? _(defaults to `false`)_
+ * @returns Text direction
+ */
+export declare function getTextDirection(element: Element, computed?: boolean): TextDirection;
+/**
+ * Set a style on an element
+ * @param element Element to set the style on
+ * @param property Style name
+ * @param value Style value
+ */
+export declare function setStyle(element: Element, property: keyof CSSStyleDeclaration, value?: string): void;
+/**
+ * Set styles on an element
+ * @param element Element to set the styles on
+ * @param styles Styles to set
+ */
+export declare function setStyles(element: Element, styles: Partial<CSSStyleDeclaration>): void;
+/**
+ * Toggle styles for an element
+ * @param element Element to style
+ * @param styles Styles to be set or removed
+ * @returns Style toggler
+ */
+export declare function toggleStyles(element: Element, styles: Partial<CSSStyleDeclaration>): StyleToggler;
+
+export {
+	findElement as $,
+	findElements as $$,
+};
+
+export {};