@oscarpalmer/toretto 0.28.0 → 0.30.0

package/dist/toretto.full.js

@@ -1,48 +1,34 @@
-//
 function getSupport() {
-    if (window == null || navigator == null) {
-        return false;
-    }
-    if ('matchMedia' in window) {
-        const media = matchMedia?.('(pointer: coarse)');
-        if (typeof media?.matches === 'boolean' && media.matches) {
-            return true;
-        }
-    }
-    if ('ontouchstart' in window) {
-        return true;
-    }
-    if (typeof navigator.maxTouchPoints === 'number' && navigator.maxTouchPoints > 0) {
-        return true;
-    }
-    if (typeof navigator.msMaxTouchPoints === 'number' &&
-        navigator.msMaxTouchPoints > 0) {
-        return true;
-    }
-    return false;
-}
-//
+	if (window == null || navigator == null) return false;
+	if ("matchMedia" in window) {
+		const media = matchMedia?.("(pointer: coarse)");
+		if (typeof media?.matches === "boolean" && media.matches) return true;
+	}
+	if ("ontouchstart" in window) return true;
+	if (typeof navigator.maxTouchPoints === "number" && navigator.maxTouchPoints > 0) return true;
+	if (typeof navigator.msMaxTouchPoints === "number" && navigator.msMaxTouchPoints > 0) return true;
+	return false;
+}
 /**
- * Does the device support touch events?
- */
+* Does the device support touch events?
+*/
 const supportsTouch = (() => {
-    let support = getSupport();
-    const instance = Object.create({
-        get() {
-            return support;
-        },
-        update() {
-            support = getSupport();
-            return support;
-        },
-    });
-    Object.defineProperty(instance, 'value', {
-        get() {
-            return support;
-        },
-    });
-    return instance;
+	let support = getSupport();
+	const instance = Object.create({
+		get() {
+			return support;
+		},
+		update() {
+			support = getSupport();
+			return support;
+		}
+	});
+	Object.defineProperty(instance, "value", { get() {
+		return support;
+	} });
+	return instance;
 })();
+var touch_default = supportsTouch;
 
 function isPlainObject(value) {
 	if (value === null || typeof value !== "object") return false;
@@ -50,14 +36,28 @@ function isPlainObject(value) {
 	const prototype = Object.getPrototypeOf(value);
 	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
 }
+var TYPED_ARRAYS = new Set([
+	Int8Array,
+	Uint8Array,
+	Uint8ClampedArray,
+	Int16Array,
+	Uint16Array,
+	Int32Array,
+	Uint32Array,
+	Float32Array,
+	Float64Array,
+	BigInt64Array,
+	BigUint64Array
+]);
 
 function compact(array, strict) {
 	if (!Array.isArray(array)) return [];
 	const { length } = array;
+	const isStrict = strict ?? false;
 	const compacted = [];
 	for (let index = 0; index < length; index += 1) {
 		const item = array[index];
-		if (item != null) compacted.push(item);
+		if (isStrict && !!item || !isStrict && item != null) compacted.push(item);
 	}
 	return compacted;
 }
@@ -79,19 +79,19 @@ function words(value) {
 var EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
 
 function isNullableOrWhitespace(value) {
-	return value == null || EXPRESSION_WHITESPACE.test(getString(value));
+	return value == null || EXPRESSION_WHITESPACE$1.test(getString(value));
 }
-var EXPRESSION_WHITESPACE = /^\s*$/;
+var EXPRESSION_WHITESPACE$1 = /^\s*$/;
 
 function camelCase(value) {
-	return toCase(value, "", true);
+	return toCase(value, "", true, false);
 }
 function capitalize(value) {
 	if (typeof value !== "string" || value.length === 0) return "";
 	return value.length === 1 ? value.toLocaleUpperCase() : `${value.charAt(0).toLocaleUpperCase()}${value.slice(1).toLocaleLowerCase()}`;
 }
 function kebabCase(value) {
-	return toCase(value, "-", false);
+	return toCase(value, "-", false, false);
 }
 function toCase(value, delimiter, capitalizeAny, capitalizeFirst) {
 	if (typeof value !== "string") return "";
@@ -107,7 +107,7 @@ function toCase(value, delimiter, capitalizeAny, capitalizeFirst) {
 		for (let itemIndex = 0; itemIndex < itemsLength; itemIndex += 1) {
 			const item = items[itemIndex];
 			if (item.length === 0) continue;
-			if (!capitalizeAny || itemCount === 0 && partIndex === 0 && true) partResult.push(item.toLocaleLowerCase());
+			if (!capitalizeAny || itemCount === 0 && partIndex === 0 && !capitalizeFirst) partResult.push(item.toLocaleLowerCase());
 			else partResult.push(capitalize(item));
 			itemCount += 1;
 		}
@@ -127,298 +127,198 @@ function parse(value, reviver) {
 }
 
 /**
- * Is the value an event target?
- * @param value Value to check
- * @returns `true` if it's an event target, otherwise `false`
- */
+* Is the value an event target?
+* @param value Value to check
+* @returns `true` if it's an event target, otherwise `false`
+*/
 function isEventTarget(value) {
-    return (typeof value === 'object' &&
-        value != null &&
-        typeof value.addEventListener === 'function' &&
-        typeof value.removeEventListener === 'function' &&
-        typeof value.dispatchEvent === 'function');
+	return typeof value === "object" && value != null && typeof value.addEventListener === "function" && typeof value.removeEventListener === "function" && typeof value.dispatchEvent === "function";
 }
 /**
- * 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`
- */
+* 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`
+*/
 function isHTMLOrSVGElement(value) {
-    return value instanceof HTMLElement || value instanceof SVGElement;
+	return value instanceof HTMLElement || value instanceof SVGElement;
 }
 
+function badAttributeHandler(name, value) {
+	if (name == null || value == null) return true;
+	if (EXPRESSION_CLOBBERED_NAME.test(name) && (value in document || value in formElement) || EXPRESSION_EVENT_NAME.test(name)) return true;
+	if (EXPRESSION_SKIP_NAME.test(name) || EXPRESSION_URI_VALUE.test(value) || isValidSourceAttribute(name, value)) return false;
+	return EXPRESSION_DATA_OR_SCRIPT.test(value);
+}
+function booleanAttributeHandler(name, value) {
+	if (name == null || value == null) return true;
+	if (!booleanAttributesSet.has(name)) return false;
+	const normalized = value.toLowerCase().trim();
+	return !(normalized.length === 0 || normalized === name);
+}
+function decodeAttribute(value) {
+	textArea ??= document.createElement("textarea");
+	textArea.innerHTML = value;
+	return decodeURIComponent(textArea.value);
+}
+function handleAttribute(callback, decode, first, second) {
+	let name;
+	let value;
+	if (isAttribute(first)) {
+		name = first.name;
+		value = String(first.value);
+	} else if (typeof first === "string" && typeof second === "string") {
+		name = first;
+		value = second;
+	}
+	if (decode && value != null) value = decodeAttribute(value);
+	return callback(name, value?.replace(EXPRESSION_WHITESPACE, ""));
+}
 function isAttribute(value) {
-    return (value instanceof Attr ||
-        (isPlainObject(value) &&
-            typeof value.name === 'string' &&
-            typeof value.value === 'string'));
+	return value instanceof Attr || isPlainObject(value) && typeof value.name === "string" && typeof value.value === "string";
 }
-function isBadAttribute(first, second) {
-    return isValidAttribute(attribute => attribute == null ||
-        EXPRESSION_ON_PREFIX.test(attribute.name) ||
-        (EXPRESSION_SOURCE_PREFIX.test(attribute.name) &&
-            EXPRESSION_VALUE_PREFIX.test(String(attribute.value))), first, second);
+function isBadAttribute$1(first, second, decode) {
+	return handleAttribute(badAttributeHandler, decode, first, second);
 }
-function isBooleanAttribute(value) {
-    return isValidAttribute(attribute => attribute != null && booleanAttributes.includes(attribute.name.toLowerCase()), value, '');
+function isBooleanAttribute$1(first, decode) {
+	return handleAttribute((name) => booleanAttributesSet.has(name?.toLowerCase()), decode, first, "");
 }
-function isEmptyNonBooleanAttribute(first, second) {
-    return isValidAttribute(attribute => attribute != null &&
-        !booleanAttributes.includes(attribute.name) &&
-        String(attribute.value).trim().length === 0, first, second);
+function isEmptyNonBooleanAttribute$1(first, second, decode) {
+	return handleAttribute((name, value) => name != null && value != null && !booleanAttributesSet.has(name) && value.trim().length === 0, decode, first, second);
 }
-function isInvalidBooleanAttribute(first, second) {
-    return isValidAttribute(attribute => {
-        if (attribute == null) {
-            return true;
-        }
-        if (!booleanAttributes.includes(attribute.name)) {
-            return false;
-        }
-        const normalized = String(attribute.value).toLowerCase().trim();
-        return !(normalized.length === 0 || normalized === attribute.name);
-    }, first, second);
-}
-function isProperty(value) {
-    return isPlainObject(value) && typeof value.name === 'string';
-}
-function isValidAttribute(callback, first, second) {
-    let attribute;
-    if (isAttribute(first)) {
-        attribute = first;
-    }
-    else if (typeof first === 'string' && typeof second === 'string') {
-        attribute = { name: first, value: second };
-    }
-    return callback(attribute);
-}
-function updateAttribute(element, name, value) {
-    const isBoolean = booleanAttributes.includes(name.toLowerCase());
-    if (isBoolean) {
-        updateProperty(element, name, value);
-    }
-    if (isBoolean ? value !== true : value == null) {
-        element.removeAttribute(name);
-    }
-    else {
-        element.setAttribute(name, isBoolean ? '' : getString(value));
-    }
-}
-function updateProperty(element, name, value) {
-    const actual = name.toLowerCase();
-    element[actual] =
-        value === '' || (typeof value === 'string' && value.toLowerCase() === actual) || value === true;
-}
-function updateValue(element, first, second) {
-    if (!isHTMLOrSVGElement(element)) {
-        return;
-    }
-    if (isProperty(first)) {
-        updateAttribute(element, first.name, first.value);
-    }
-    else if (typeof first === 'string') {
-        updateAttribute(element, first, second);
-    }
-}
-function updateValues(element, values) {
-    if (!isHTMLOrSVGElement(element)) {
-        return;
-    }
-    const isArray = Array.isArray(values);
-    const entries = Object.entries(values);
-    const { length } = entries;
-    for (let index = 0; index < length; index += 1) {
-        const entry = entries[index];
-        if (isArray) {
-            updateAttribute(element, entry[1].name, entry[1].value);
-        }
-        else {
-            updateAttribute(element, entry[0], entry[1]);
-        }
-    }
-}
-//
-const EXPRESSION_ON_PREFIX = /^on/i;
-const EXPRESSION_SOURCE_PREFIX = /^(href|src|xlink:href)$/i;
-const EXPRESSION_VALUE_PREFIX = /(data:text\/html|javascript:)/i;
+function isInvalidBooleanAttribute$1(first, second, decode) {
+	return handleAttribute(booleanAttributeHandler, decode, first, second);
+}
+function isValidSourceAttribute(name, value) {
+	return EXPRESSION_SOURCE_NAME.test(name) && EXPRESSION_SOURCE_VALUE.test(value);
+}
+const EXPRESSION_CLOBBERED_NAME = /^(id|name)$/i;
+const EXPRESSION_DATA_OR_SCRIPT = /^(?:data|\w+script):/i;
+const EXPRESSION_EVENT_NAME = /^on/i;
+const EXPRESSION_SKIP_NAME = /^(aria-[-\w]+|data-[-\w.\u00B7-\uFFFF]+)$/i;
+const EXPRESSION_SOURCE_NAME = /^src$/i;
+const EXPRESSION_SOURCE_VALUE = /^data:/i;
+const EXPRESSION_URI_VALUE = /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.-]+(?:[^a-z+.\-:]|$))/i;
+const EXPRESSION_WHITESPACE = /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g;
 /**
- * List of boolean attributes
- */
+* List of boolean attributes
+*/
 const 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',
+	"async",
+	"autofocus",
+	"autoplay",
+	"checked",
+	"controls",
+	"default",
+	"defer",
+	"disabled",
+	"formnovalidate",
+	"hidden",
+	"inert",
+	"ismap",
+	"itemscope",
+	"loop",
+	"multiple",
+	"muted",
+	"nomodule",
+	"novalidate",
+	"open",
+	"playsinline",
+	"readonly",
+	"required",
+	"reversed",
+	"selected"
 ]);
+const booleanAttributesSet = new Set(booleanAttributes);
+const formElement = document.createElement("form");
+let textArea;
 
 function getBoolean(value, defaultValue) {
-    return typeof value === 'boolean' ? value : (defaultValue ?? false);
-}
-function getAttributeValue(element, name, parseValue) {
-    const normalized = kebabCase(name);
-    const attribute = element.attributes[normalized];
-    const value = attribute instanceof Attr ? attribute.value : undefined;
-    return EXPRESSION_DATA_PREFIX.test(normalized) && typeof value === 'string' && parseValue
-        ? (parse(value) ?? value)
-        : value;
+	return typeof value === "boolean" ? value : defaultValue ?? false;
 }
 function getStyleValue(element, property, computed) {
-    const name = camelCase(property);
-    return computed ? getComputedStyle(element)[name] : element.style[name];
+	const name = camelCase(property);
+	return computed ? getComputedStyle(element)[name] : element.style[name];
 }
 const EXPRESSION_DATA_PREFIX = /^data-/i;
 
-function getAttribute(element, name, parseValues) {
-    if (isHTMLOrSVGElement(element) && typeof name === 'string') {
-        return getAttributeValue(element, name, parseValues !== false);
-    }
-}
-/**
- * Get specific attributes from an element
- * @param element Element to get attributes from
- * @param names Attribute names
- * @param parseData Parse data values? _(defaults to `true`)_
- * @returns Object of named attributes
- */
-function getAttributes(element, names, parseData) {
-    const attributes = {};
-    if (!(isHTMLOrSVGElement(element) && Array.isArray(names))) {
-        return attributes;
-    }
-    const shouldParse = parseData !== false;
-    const { length } = names;
-    for (let index = 0; index < length; index += 1) {
-        const name = names[index];
-        if (typeof name === 'string') {
-            attributes[name] = getAttributeValue(element, name, shouldParse);
-        }
-    }
-    return attributes;
-}
-
-function setAttribute(element, first, second) {
-    updateValue(element, first, second);
+function isBadAttribute(first, second) {
+	return isBadAttribute$1(first, second, true);
 }
-function setAttributes(element, attributes) {
-    updateValues(element, attributes);
+function isBooleanAttribute(first) {
+	return isBooleanAttribute$1(first, true);
 }
-function setProperty(element, first, second) {
-    updateValue(element, first, second);
+function isEmptyNonBooleanAttribute(first, second) {
+	return isEmptyNonBooleanAttribute$1(first, second, true);
 }
-function setProperties(element, properties) {
-    updateValues(element, properties);
+function isInvalidBooleanAttribute(first, second) {
+	return isInvalidBooleanAttribute$1(first, second, true);
 }
 
 /**
- * Is the value a child node?
- * @param value Value to check
- * @returns `true` if it's a child node, otherwise `false`
- */
+* Is the value a child node?
+* @param value Value to check
+* @returns `true` if it's a child node, otherwise `false`
+*/
 function isChildNode(value) {
-    return value instanceof Node && CHILD_NODE_TYPES.has(value.nodeType);
-}
-function isInDocument(node, document) {
-    if (!(node instanceof Node)) {
-        return false;
-    }
-    if (!(document instanceof Document)) {
-        return node.ownerDocument?.contains(node) ?? true;
-    }
-    return node.ownerDocument == null
-        ? node === document
-        : node.ownerDocument === document && document.contains(node);
-}
-//
+	return value instanceof Node && CHILD_NODE_TYPES.has(value.nodeType);
+}
+function isInDocument(node, document$1) {
+	if (!(node instanceof Node)) return false;
+	if (!(document$1 instanceof Document)) return node.ownerDocument?.contains(node) ?? true;
+	return node.ownerDocument == null ? node === document$1 : node.ownerDocument === document$1 && document$1.contains(node);
+}
 const CHILD_NODE_TYPES = new Set([
-    Node.ELEMENT_NODE,
-    Node.TEXT_NODE,
-    Node.PROCESSING_INSTRUCTION_NODE,
-    Node.COMMENT_NODE,
-    Node.DOCUMENT_TYPE_NODE,
+	Node.ELEMENT_NODE,
+	Node.TEXT_NODE,
+	Node.PROCESSING_INSTRUCTION_NODE,
+	Node.COMMENT_NODE,
+	Node.DOCUMENT_TYPE_NODE
 ]);
 
 function setElementValues(element, first, second, callback) {
-    if (!isHTMLOrSVGElement(element)) {
-        return;
-    }
-    if (isPlainObject(first)) {
-        const entries = Object.entries(first);
-        const { length } = entries;
-        for (let index = 0; index < length; index += 1) {
-            const [key, value] = entries[index];
-            callback(element, key, value);
-        }
-    }
-    else if (typeof first === 'string') {
-        callback(element, first, second);
-    }
+	if (!isHTMLOrSVGElement(element)) return;
+	if (isPlainObject(first)) {
+		const entries = Object.entries(first);
+		const { length } = entries;
+		for (let index = 0; index < length; index += 1) {
+			const [key, value] = entries[index];
+			callback(element, key, value);
+		}
+	} else if (typeof first === "string") callback(element, first, second);
 }
 function updateElementValue(element, key, value, set, remove, json) {
-    if (isNullableOrWhitespace(value)) {
-        remove.call(element, key);
-    }
-    else {
-        set.call(element, key, json ? JSON.stringify(value) : String(value));
-    }
+	if (isNullableOrWhitespace(value)) remove.call(element, key);
+	else set.call(element, key, json ? JSON.stringify(value) : String(value));
 }
 
 function getData(element, keys, parseValues) {
-    if (!isHTMLOrSVGElement(element)) {
-        return;
-    }
-    const shouldParse = parseValues !== false;
-    if (typeof keys === 'string') {
-        const value = element.dataset[keys];
-        if (value === undefined) {
-            return;
-        }
-        return shouldParse ? parse(value) : value;
-    }
-    const { length } = keys;
-    const data = {};
-    for (let index = 0; index < length; index += 1) {
-        const key = keys[index];
-        const value = element.dataset[key];
-        if (value == null) {
-            data[key] = undefined;
-        }
-        else {
-            data[key] = shouldParse ? parse(value) : value;
-        }
-    }
-    return data;
+	if (!isHTMLOrSVGElement(element)) return;
+	const shouldParse = parseValues !== false;
+	if (typeof keys === "string") {
+		const value = element.dataset[keys];
+		if (value === void 0) return;
+		return shouldParse ? parse(value) : value;
+	}
+	const { length } = keys;
+	const data = {};
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		const value = element.dataset[key];
+		if (value == null) data[key] = void 0;
+		else data[key] = shouldParse ? parse(value) : value;
+	}
+	return data;
 }
 function getName(original) {
-    return `${ATTRIBUTE_DATA_PREFIX}${kebabCase(original).replace(EXPRESSION_DATA_PREFIX, '')}`;
+	return `${ATTRIBUTE_DATA_PREFIX}${kebabCase(original).replace(EXPRESSION_DATA_PREFIX, "")}`;
 }
 function setData(element, first, second) {
-    setElementValues(element, first, second, updateDataAttribute);
+	setElementValues(element, first, second, updateDataAttribute);
 }
 function updateDataAttribute(element, key, value) {
-    updateElementValue(element, getName(key), value, element.setAttribute, element.removeAttribute, true);
+	updateElementValue(element, getName(key), value, element.setAttribute, element.removeAttribute, true);
 }
-//
-const ATTRIBUTE_DATA_PREFIX = 'data-';
+const ATTRIBUTE_DATA_PREFIX = "data-";
 
 function calculate() {
 	return new Promise((resolve) => {
@@ -436,881 +336,715 @@ function calculate() {
 function noop() {}
 var CALCULATION_TOTAL = 10;
 var CALCULATION_TRIM = 4;
+let milliseconds = 1e3 / 60;
 calculate().then((value) => {
+	milliseconds = value;
 });
 
-function addDelegatedHandler(document, type, name, passive) {
-    const count = `${name}${COUNT_SUFFIX}`;
-    if (document[count] != null) {
-        document[count] += 1;
-        return;
-    }
-    document[count] = 1;
-    document.addEventListener(type, passive ? HANDLER_PASSIVE : HANDLER_ACTIVE, {
-        passive,
-    });
+function addDelegatedHandler(document$1, type, name, passive) {
+	const count = `${name}${COUNT_SUFFIX}`;
+	if (document$1[count] != null) {
+		document$1[count] += 1;
+		return;
+	}
+	document$1[count] = 1;
+	document$1.addEventListener(type, passive ? HANDLER_PASSIVE : HANDLER_ACTIVE, { passive });
 }
 function addDelegatedListener(target, type, name, listener, passive) {
-    target[name] ??= new Set();
-    target[name]?.add(listener);
-    addDelegatedHandler(document, type, name, passive);
-    return () => {
-        removeDelegatedListener(target, type, name, listener, passive);
-    };
+	target[name] ??= /* @__PURE__ */ new Set();
+	target[name]?.add(listener);
+	addDelegatedHandler(document, type, name, passive);
+	return () => {
+		removeDelegatedListener(target, type, name, listener, passive);
+	};
 }
 function delegatedEventHandler(event) {
-    const key = `${EVENT_PREFIX}${event.type}${this ? EVENT_SUFFIX_PASSIVE : EVENT_SUFFIX_ACTIVE}`;
-    const items = event.composedPath();
-    const { length } = items;
-    Object.defineProperty(event, 'target', {
-        configurable: true,
-        value: items[0],
-    });
-    for (let index = 0; index < length; index += 1) {
-        const item = items[index];
-        const listeners = item[key];
-        if (item.disabled || listeners == null) {
-            continue;
-        }
-        Object.defineProperty(event, 'currentTarget', {
-            configurable: true,
-            value: item,
-        });
-        for (const listener of listeners) {
-            listener.call(item, event);
-            if (event.cancelBubble) {
-                return;
-            }
-        }
-    }
+	const key = `${EVENT_PREFIX}${event.type}${this ? EVENT_SUFFIX_PASSIVE : EVENT_SUFFIX_ACTIVE}`;
+	const items = event.composedPath();
+	const { length } = items;
+	Object.defineProperty(event, "target", {
+		configurable: true,
+		value: items[0]
+	});
+	for (let index = 0; index < length; index += 1) {
+		const item = items[index];
+		const listeners = item[key];
+		if (item.disabled || listeners == null) continue;
+		Object.defineProperty(event, "currentTarget", {
+			configurable: true,
+			value: item
+		});
+		for (const listener of listeners) {
+			listener.call(item, event);
+			if (event.cancelBubble) return;
+		}
+	}
 }
 function getDelegatedName(target, type, options) {
-    if (isEventTarget(target) &&
-        EVENT_TYPES.has(type) &&
-        !options.capture &&
-        !options.once &&
-        options.signal == null) {
-        return `${EVENT_PREFIX}${type}${options.passive ? EVENT_SUFFIX_PASSIVE : EVENT_SUFFIX_ACTIVE}`;
-    }
-}
-function removeDelegatedHandler(document, type, name, passive) {
-    const count = `${name}${COUNT_SUFFIX}`;
-    document[count] -= 1;
-    if (document[count] < 1) {
-        document[count] = undefined;
-        document.removeEventListener(type, passive ? HANDLER_PASSIVE : HANDLER_ACTIVE);
-    }
+	if (isEventTarget(target) && EVENT_TYPES.has(type) && !options.capture && !options.once && options.signal == null) return `${EVENT_PREFIX}${type}${options.passive ? EVENT_SUFFIX_PASSIVE : EVENT_SUFFIX_ACTIVE}`;
+}
+function removeDelegatedHandler(document$1, type, name, passive) {
+	const count = `${name}${COUNT_SUFFIX}`;
+	document$1[count] -= 1;
+	if (document$1[count] < 1) {
+		document$1[count] = void 0;
+		document$1.removeEventListener(type, passive ? HANDLER_PASSIVE : HANDLER_ACTIVE);
+	}
 }
 function removeDelegatedListener(target, type, name, listener, passive) {
-    const handlers = target[name];
-    if (handlers == null || !handlers.has(listener)) {
-        return false;
-    }
-    handlers.delete(listener);
-    if (handlers.size === 0) {
-        target[name] = undefined;
-    }
-    removeDelegatedHandler(document, type, name, passive);
-    return true;
-}
-//
-const COUNT_SUFFIX = '.count';
-const EVENT_PREFIX = '@';
-const EVENT_SUFFIX_ACTIVE = ':active';
-const EVENT_SUFFIX_PASSIVE = ':passive';
+	const handlers = target[name];
+	if (handlers == null || !handlers.has(listener)) return false;
+	handlers.delete(listener);
+	if (handlers.size === 0) target[name] = void 0;
+	removeDelegatedHandler(document, type, name, passive);
+	return true;
+}
+const COUNT_SUFFIX = ".count";
+const EVENT_PREFIX = "@";
+const EVENT_SUFFIX_ACTIVE = ":active";
+const EVENT_SUFFIX_PASSIVE = ":passive";
 const EVENT_TYPES = new Set([
-    'beforeinput',
-    'click',
-    'dblclick',
-    'contextmenu',
-    'focusin',
-    'focusout',
-    'input',
-    'keydown',
-    'keyup',
-    'mousedown',
-    'mousemove',
-    'mouseout',
-    'mouseover',
-    'mouseup',
-    'pointerdown',
-    'pointermove',
-    'pointerout',
-    'pointerover',
-    'pointerup',
-    'touchend',
-    'touchmove',
-    'touchstart',
+	"beforeinput",
+	"click",
+	"dblclick",
+	"contextmenu",
+	"focusin",
+	"focusout",
+	"input",
+	"keydown",
+	"keyup",
+	"mousedown",
+	"mousemove",
+	"mouseout",
+	"mouseover",
+	"mouseup",
+	"pointerdown",
+	"pointermove",
+	"pointerout",
+	"pointerover",
+	"pointerup",
+	"touchend",
+	"touchmove",
+	"touchstart"
 ]);
 const HANDLER_ACTIVE = delegatedEventHandler.bind(false);
 const HANDLER_PASSIVE = delegatedEventHandler.bind(true);
 
-//
 function createDispatchOptions(options) {
-    return {
-        bubbles: getBoolean(options?.bubbles, true),
-        cancelable: getBoolean(options?.cancelable, true),
-        composed: getBoolean(options?.composed),
-    };
+	return {
+		bubbles: getBoolean(options?.bubbles, true),
+		cancelable: getBoolean(options?.cancelable, true),
+		composed: getBoolean(options?.composed)
+	};
 }
 function createEvent(type, options) {
-    const hasOptions = isPlainObject(options);
-    if (hasOptions && PROPERTY_DETAIL in options) {
-        return new CustomEvent(type, {
-            ...createDispatchOptions(options),
-            detail: options?.detail,
-        });
-    }
-    return new Event(type, createDispatchOptions(hasOptions ? options : {}));
+	const hasOptions = isPlainObject(options);
+	if (hasOptions && PROPERTY_DETAIL in options) return new CustomEvent(type, {
+		...createDispatchOptions(options),
+		detail: options?.detail
+	});
+	return new Event(type, createDispatchOptions(hasOptions ? options : {}));
 }
 function createEventOptions(options) {
-    return {
-        capture: getBoolean(options?.capture),
-        once: getBoolean(options?.once),
-        passive: getBoolean(options?.passive, true),
-        signal: options?.signal instanceof AbortSignal ? options.signal : undefined,
-    };
+	return {
+		capture: getBoolean(options?.capture),
+		once: getBoolean(options?.once),
+		passive: getBoolean(options?.passive, true),
+		signal: options?.signal instanceof AbortSignal ? options.signal : void 0
+	};
 }
 function dispatch(target, type, options) {
-    if (isEventTarget(target) && typeof type === 'string') {
-        target.dispatchEvent(createEvent(type, options));
-    }
+	if (isEventTarget(target) && typeof type === "string") target.dispatchEvent(createEvent(type, options));
 }
 /**
- * Get the X- and Y-coordinates from a pointer event
- * @param event Pointer event
- * @returns X- and Y-coordinates
- */
+* Get the X- and Y-coordinates from a pointer event
+* @param event Pointer event
+* @returns X- and Y-coordinates
+*/
 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;
+	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
+	} : void 0;
 }
 /**
- * Remove an event listener
- * @param target Event target
- * @param type Type of event
- * @param listener Event listener
- * @param options Options for event
- */
+* Remove an event listener
+* @param target Event target
+* @param type Type of event
+* @param listener Event listener
+* @param options Options for event
+*/
 function off(target, type, listener, options) {
-    if (!isEventTarget(target) || typeof type !== 'string' || typeof listener !== 'function') {
-        return;
-    }
-    const extended = createEventOptions(options);
-    const delegated = getDelegatedName(target, type, extended);
-    if (delegated == null ||
-        !removeDelegatedListener(target, type, delegated, listener, extended.passive)) {
-        target.removeEventListener(type, listener, extended);
-    }
+	if (!isEventTarget(target) || typeof type !== "string" || typeof listener !== "function") return;
+	const extended = createEventOptions(options);
+	const delegated = getDelegatedName(target, type, extended);
+	if (delegated == null || !removeDelegatedListener(target, type, delegated, listener, extended.passive)) target.removeEventListener(type, listener, extended);
 }
 function on(target, type, listener, options) {
-    if (!isEventTarget(target) || typeof type !== 'string' || typeof listener !== 'function') {
-        return noop;
-    }
-    const extended = createEventOptions(options);
-    const delegated = getDelegatedName(target, type, extended);
-    if (delegated != null) {
-        return addDelegatedListener(target, type, delegated, listener, extended.passive);
-    }
-    target.addEventListener(type, listener, extended);
-    if (extended.once) {
-        return noop;
-    }
-    return () => {
-        target.removeEventListener(type, listener, extended);
-    };
-}
-//
-const PROPERTY_DETAIL = 'detail';
+	if (!isEventTarget(target) || typeof type !== "string" || typeof listener !== "function") return noop;
+	const extended = createEventOptions(options);
+	const delegated = getDelegatedName(target, type, extended);
+	if (delegated != null) return addDelegatedListener(target, type, delegated, listener, extended.passive);
+	target.addEventListener(type, listener, extended);
+	if (extended.once) return noop;
+	return () => {
+		target.removeEventListener(type, listener, extended);
+	};
+}
+const PROPERTY_DETAIL = "detail";
 
 /**
- * - Get the distance between two elements _(i.e., the amount of nodes of between them)_
- * - If the distance cannot be calculated, `-1` is returned
- */
+* - Get the distance between two elements _(i.e., the amount of nodes of between them)_
+* - If the distance cannot be calculated, `-1` is returned
+*/
 function getDistanceBetweenElements(origin, target) {
-    if (origin === target || origin.parentElement === target) {
-        return 0;
-    }
-    const comparison = origin.compareDocumentPosition(target);
-    const children = [...(origin.parentElement?.children ?? [])];
-    if (children.includes(target)) {
-        return Math.abs(children.indexOf(origin) - children.indexOf(target));
-    }
-    const beforeOrInside = !!(comparison & 2 || comparison & 8);
-    if (beforeOrInside || !!(comparison & 4 || comparison & 16)) {
-        return traverse(beforeOrInside ? origin : target, beforeOrInside ? target : origin) ?? -1;
-    }
+	if (origin === target || origin.parentElement === target) return 0;
+	const comparison = origin.compareDocumentPosition(target);
+	const children = [...origin.parentElement?.children ?? []];
+	if (children.includes(target)) return Math.abs(children.indexOf(origin) - children.indexOf(target));
+	const beforeOrInside = !!(comparison & 2 || comparison & 8);
+	if (beforeOrInside || !!(comparison & 4 || comparison & 16)) return traverse(beforeOrInside ? origin : target, beforeOrInside ? target : origin) ?? -1;
 }
 /**
- * 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 Element to start from
- * @param selector Selector to match
- * @returns Found ancestor or `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 Element to start from
+* @param selector Selector to match
+* @returns Found ancestor or `null`
+*/
 function findAncestor(origin, selector) {
-    if (!(origin instanceof Element) || selector == null) {
-        return null;
-    }
-    if (typeof selector === 'string') {
-        if (origin.matches?.(selector)) {
-            return origin;
-        }
-        return origin.closest(selector);
-    }
-    if (typeof selector !== 'function') {
-        return null;
-    }
-    if (selector(origin)) {
-        return origin;
-    }
-    let parent = origin.parentElement;
-    while (parent != null && !selector(parent)) {
-        if (parent === document.body) {
-            return null;
-        }
-        parent = parent.parentElement;
-    }
-    return parent;
+	if (!(origin instanceof Element) || selector == null) return null;
+	if (typeof selector === "string") {
+		if (origin.matches?.(selector)) return origin;
+		return origin.closest(selector);
+	}
+	if (typeof selector !== "function") return null;
+	if (selector(origin)) return origin;
+	let parent = origin.parentElement;
+	while (parent != null && !selector(parent)) {
+		if (parent === document.body) return null;
+		parent = parent.parentElement;
+	}
+	return parent;
 }
 /**
- * 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
- */
+* 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
+*/
 function findRelatives(origin, selector, context) {
-    if (!(origin instanceof Element) || typeof selector !== 'string') {
-        return [];
-    }
-    if (origin.matches(selector)) {
-        return [origin];
-    }
-    const elements = [
-        ...(context instanceof Document || context instanceof Element
-            ? context
-            : document).querySelectorAll(selector),
-    ];
-    const { length } = elements;
-    if (length === 0) {
-        return [];
-    }
-    if (length === 1) {
-        return [elements[0]];
-    }
-    const distances = [];
-    let minimum;
-    for (let index = 0; index < length; index += 1) {
-        const element = elements[index];
-        const distance = getDistanceBetweenElements(origin, element) ?? -1;
-        if (distance > -1) {
-            if (minimum == null || distance < minimum) {
-                minimum = distance;
-            }
-            distances.push({
-                distance,
-                element,
-            });
-        }
-    }
-    return minimum == null
-        ? []
-        : distances.filter(found => found.distance === minimum).map(found => found.element);
+	if (!(origin instanceof Element) || typeof selector !== "string") return [];
+	if (origin.matches(selector)) return [origin];
+	const elements = [...(context instanceof Document || context instanceof Element ? context : document).querySelectorAll(selector)];
+	const { length } = elements;
+	if (length === 0) return [];
+	if (length === 1) return [elements[0]];
+	const distances = [];
+	let minimum;
+	for (let index = 0; index < length; index += 1) {
+		const element = elements[index];
+		const distance = getDistanceBetweenElements(origin, element) ?? -1;
+		if (distance > -1) {
+			if (minimum == null || distance < minimum) minimum = distance;
+			distances.push({
+				distance,
+				element
+			});
+		}
+	}
+	return minimum == null ? [] : distances.filter((found) => found.distance === minimum).map((found) => found.element);
 }
 function traverse(from, to) {
-    let index = [...to.children].indexOf(from);
-    if (index > -1) {
-        return index + 1;
-    }
-    let current = from;
-    let distance = 0;
-    let parent = from.parentElement;
-    while (parent != null) {
-        if (parent === to) {
-            return distance + 1;
-        }
-        const children = [...(parent.children ?? [])];
-        if (children.includes(to)) {
-            return distance + Math.abs(children.indexOf(current) - children.indexOf(to));
-        }
-        index = children.findIndex(child => child.contains(to));
-        if (index > -1) {
-            const traversed = traverse(current, children[index]) ?? -1;
-            return traversed === -1
-                ? -1
-                : distance + Math.abs(index - children.indexOf(current)) + traversed;
-        }
-        current = parent;
-        distance += 1;
-        parent = parent.parentElement;
-    }
+	let index = [...to.children].indexOf(from);
+	if (index > -1) return index + 1;
+	let current = from;
+	let distance = 0;
+	let parent = from.parentElement;
+	while (parent != null) {
+		if (parent === to) return distance + 1;
+		const children = [...parent.children ?? []];
+		if (children.includes(to)) return distance + Math.abs(children.indexOf(current) - children.indexOf(to));
+		index = children.findIndex((child) => child.contains(to));
+		if (index > -1) {
+			const traversed = traverse(current, children[index]) ?? -1;
+			return traversed === -1 ? -1 : distance + Math.abs(index - children.indexOf(current)) + traversed;
+		}
+		current = parent;
+		distance += 1;
+		parent = parent.parentElement;
+	}
 }
 
 /**
- * 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`
- */
+* 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`
+*/
 function findElement(selector, context) {
-    return findElementOrElements(selector, context, true);
+	return findElementOrElements(selector, context, true);
 }
 function findElementOrElements(selector, context, single) {
-    const callback = single ? QUERY_SELECTOR_SINGLE : QUERY_SELECTOR_ALL;
-    const contexts = context == null
-        ? [document]
-        : findElementOrElements(context, undefined, false).filter(isContext);
-    if (typeof selector === 'string') {
-        return findElementOrElementsForSelector(selector, contexts, callback, single);
-    }
-    let array;
-    if (Array.isArray(selector)) {
-        array = selector;
-    }
-    else {
-        array = selector instanceof Node ? [selector] : [...selector];
-    }
-    return findElementOrElementsFromNodes(array, context, contexts);
+	const callback = single ? QUERY_SELECTOR_SINGLE : QUERY_SELECTOR_ALL;
+	const contexts = context == null ? [document] : findElementOrElements(context, void 0, false).filter(isContext);
+	if (typeof selector === "string") return findElementOrElementsForSelector(selector, contexts, callback, single);
+	let array;
+	if (Array.isArray(selector)) array = selector;
+	else array = selector instanceof Node ? [selector] : [...selector];
+	return findElementOrElementsFromNodes(array, context, contexts);
 }
 function findElementOrElementsForSelector(selector, contexts, callback, single) {
-    const { length } = contexts;
-    const result = [];
-    for (let index = 0; index < length; index += 1) {
-        const value = contexts[index][callback](selector);
-        if (single) {
-            if (value == null) {
-                continue;
-            }
-            return value;
-        }
-        result.push(...Array.from(value));
-    }
-    return single ? null : result.filter((value, index, array) => array.indexOf(value) === index);
+	const { length } = contexts;
+	const result = [];
+	for (let index = 0; index < length; index += 1) {
+		const value = contexts[index][callback](selector);
+		if (single) {
+			if (value == null) continue;
+			return value;
+		}
+		result.push(...Array.from(value));
+	}
+	return single ? null : result.filter((value, index, array) => array.indexOf(value) === index);
 }
 function findElementOrElementsFromNodes(array, context, contexts) {
-    const result = [];
-    const nodes = array.filter(node => node instanceof Node);
-    const { length } = nodes;
-    for (let index = 0; index < length; index += 1) {
-        const node = nodes[index];
-        let element;
-        if (node instanceof Document) {
-            element = node.body;
-        }
-        else {
-            element = node instanceof Element ? node : undefined;
-        }
-        if (element != null &&
-            (context == null ||
-                contexts.length === 0 ||
-                contexts.some(context => context === element || context.contains(element))) &&
-            !result.includes(element)) {
-            result.push(element);
-        }
-    }
-    return result;
+	const result = [];
+	const nodes = array.filter((node) => node instanceof Node);
+	const { length } = nodes;
+	for (let index = 0; index < length; index += 1) {
+		const node = nodes[index];
+		let element;
+		if (node instanceof Document) element = node.body;
+		else element = node instanceof Element ? node : void 0;
+		if (element != null && (context == null || contexts.length === 0 || contexts.some((context$1) => context$1 === element || context$1.contains(element))) && !result.includes(element)) result.push(element);
+	}
+	return result;
 }
 /**
- * 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
- */
+* 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
+*/
 function findElements(selector, context) {
-    return findElementOrElements(selector, context, false);
+	return findElementOrElements(selector, context, false);
 }
 /**
- * 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`
- */
+* 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`
+*/
 function getElementUnderPointer(skipIgnore) {
-    const elements = [...document.querySelectorAll(SUFFIX_HOVER)];
-    const { length } = elements;
-    const returned = [];
-    for (let index = 0; index < length; index += 1) {
-        const element = elements[index];
-        if (element.tagName === TAG_HEAD) {
-            continue;
-        }
-        const style = getComputedStyle(element);
-        if (skipIgnore === true ||
-            (style.pointerEvents !== STYLE_NONE$1 && style.visibility !== STYLE_HIDDEN$1)) {
-            returned.push(element);
-        }
-    }
-    return returned.at(-1) ?? null;
+	const elements = [...document.querySelectorAll(SUFFIX_HOVER)];
+	const { length } = elements;
+	const returned = [];
+	for (let index = 0; index < length; index += 1) {
+		const element = elements[index];
+		if (element.tagName === TAG_HEAD) continue;
+		const style = getComputedStyle(element);
+		if (skipIgnore === true || style.pointerEvents !== STYLE_NONE$1 && style.visibility !== STYLE_HIDDEN$1) returned.push(element);
+	}
+	return returned.at(-1) ?? null;
 }
 function isContext(value) {
-    return (typeof value?.querySelector === 'function' &&
-        typeof value?.querySelectorAll === 'function');
-}
-//
-const QUERY_SELECTOR_ALL = 'querySelectorAll';
-const QUERY_SELECTOR_SINGLE = 'querySelector';
-const STYLE_HIDDEN$1 = 'hidden';
-const STYLE_NONE$1 = 'none';
-const SUFFIX_HOVER = ':hover';
-const TAG_HEAD = 'HEAD';
+	return typeof value?.querySelector === "function" && typeof value?.querySelectorAll === "function";
+}
+const QUERY_SELECTOR_ALL = "querySelectorAll";
+const QUERY_SELECTOR_SINGLE = "querySelector";
+const STYLE_HIDDEN$1 = "hidden";
+const STYLE_NONE$1 = "none";
+const SUFFIX_HOVER = ":hover";
+const TAG_HEAD = "HEAD";
 
-// Based on https://github.com/focus-trap/tabbable :-)
-//
 /**
- * Get a list of focusable elements within a parent element
- * @param parent Parent element
- * @returns Focusable elements
- */
+* Get a list of focusable elements within a parent element
+* @param parent Parent element
+* @returns Focusable elements
+*/
 function getFocusable(parent) {
-    return getValidElements(parent, FILTERS_FOCUSABLE, false);
+	return getValidElements(parent, FILTERS_FOCUSABLE, false);
 }
 function getItem(element, tabbable) {
-    return {
-        element,
-        tabIndex: tabbable ? getTabIndex(element) : TABINDEX_DEFAULT,
-    };
+	return {
+		element,
+		tabIndex: tabbable ? getTabIndex(element) : TABINDEX_DEFAULT
+	};
 }
 /**
- * Get a list of tabbable elements within a parent element
- * @param parent Parent element
- * @returns Tabbable elements
- */
+* Get a list of tabbable elements within a parent element
+* @param parent Parent element
+* @returns Tabbable elements
+*/
 function getTabbable(parent) {
-    return getValidElements(parent, FILTERS_TABBABLE, true);
+	return getValidElements(parent, FILTERS_TABBABLE, true);
 }
 function getTabIndex(element) {
-    const tabIndex = element?.tabIndex ?? TABINDEX_DEFAULT;
-    if (tabIndex < TABINDEX_BASE &&
-        (EXPRESSION_SPECIAL_TABINDEX.test(element.tagName) || isEditable(element)) &&
-        !hasTabIndex(element)) {
-        return TABINDEX_BASE;
-    }
-    return tabIndex;
+	const tabIndex = element?.tabIndex ?? TABINDEX_DEFAULT;
+	if (tabIndex < TABINDEX_BASE && (EXPRESSION_SPECIAL_TABINDEX.test(element.tagName) || isEditable(element)) && !hasTabIndex(element)) return TABINDEX_BASE;
+	return tabIndex;
 }
 function getValidElements(parent, filters, tabbable) {
-    if (!(parent instanceof Element)) {
-        return [];
-    }
-    const elements = [...parent.querySelectorAll(SELECTOR_FULL)];
-    const items = [];
-    let { length } = elements;
-    for (let index = 0; index < length; index += 1) {
-        const item = getItem(elements[index], tabbable);
-        if (!filters.some(filter => filter(item))) {
-            items.push(item);
-        }
-    }
-    if (!tabbable) {
-        return items.map(item => item.element);
-    }
-    const indiced = [];
-    const zeroed = [];
-    length = items.length;
-    for (let index = 0; index < length; index += 1) {
-        const item = items[index];
-        if (item.tabIndex === TABINDEX_BASE) {
-            zeroed.push(item.element);
-        }
-        else {
-            indiced[item.tabIndex] = [...(indiced[item.tabIndex] ?? []), item.element];
-        }
-    }
-    return [...indiced.flat(), ...zeroed];
+	if (!(parent instanceof Element)) return [];
+	const elements = [...parent.querySelectorAll(SELECTOR_FULL)];
+	const items = [];
+	let { length } = elements;
+	for (let index = 0; index < length; index += 1) {
+		const item = getItem(elements[index], tabbable);
+		if (!filters.some((filter) => filter(item))) items.push(item);
+	}
+	if (!tabbable) return items.map((item) => item.element);
+	const indiced = [];
+	const zeroed = [];
+	length = items.length;
+	for (let index = 0; index < length; index += 1) {
+		const item = items[index];
+		if (item.tabIndex === TABINDEX_BASE) zeroed.push(item.element);
+		else indiced[item.tabIndex] = [...indiced[item.tabIndex] ?? [], item.element];
+	}
+	return [...indiced.flat(), ...zeroed];
 }
 function hasTabIndex(element) {
-    return !Number.isNaN(Number.parseInt(element.getAttribute(ATTRIBUTE_TABINDEX), 10));
+	return !Number.isNaN(Number.parseInt(element.getAttribute(ATTRIBUTE_TABINDEX), 10));
 }
 function isDisabled(item) {
-    if (EXPRESSION_DISABLEABLE.test(item.element.tagName) && isDisabledFromFieldset(item.element)) {
-        return true;
-    }
-    return item.element.disabled ?? false;
+	if (EXPRESSION_DISABLEABLE.test(item.element.tagName) && isDisabledFromFieldset(item.element)) return true;
+	return item.element.disabled ?? false;
 }
 function isDisabledFromFieldset(element) {
-    let parent = element.parentElement;
-    while (parent != null) {
-        if (parent instanceof HTMLFieldSetElement && parent.disabled) {
-            const children = Array.from(parent.children);
-            const { length } = children;
-            for (let index = 0; index < length; index += 1) {
-                const child = children[index];
-                if (child instanceof HTMLLegendElement) {
-                    return parent.matches(SELECTOR_FIELDSET_DISABLED) || !child.contains(element);
-                }
-            }
-            return true;
-        }
-        parent = parent.parentElement;
-    }
-    return false;
+	let parent = element.parentElement;
+	while (parent != null) {
+		if (parent instanceof HTMLFieldSetElement && parent.disabled) {
+			const children = Array.from(parent.children);
+			const { length } = children;
+			for (let index = 0; index < length; index += 1) {
+				const child = children[index];
+				if (child instanceof HTMLLegendElement) return parent.matches(SELECTOR_FIELDSET_DISABLED) || !child.contains(element);
+			}
+			return true;
+		}
+		parent = parent.parentElement;
+	}
+	return false;
 }
 function isEditable(element) {
-    return EXPRESSION_TRUEISH.test(element.getAttribute(ATTRIBUTE_CONTENTEDITABLE));
+	return EXPRESSION_TRUEISH.test(element.getAttribute(ATTRIBUTE_CONTENTEDITABLE));
 }
 /**
- * Is the element focusable?
- * @param element Element to check
- * @returns `true` if focusable, otherwise `false`
- */
+* Is the element focusable?
+* @param element Element to check
+* @returns `true` if focusable, otherwise `false`
+*/
 function isFocusable(element) {
-    return element instanceof Element ? isValidElement(element, FILTERS_FOCUSABLE, false) : false;
+	return element instanceof Element ? isValidElement(element, FILTERS_FOCUSABLE, false) : false;
 }
 function isHidden(item) {
-    if ((item.element.hidden ?? false) ||
-        (item.element instanceof HTMLInputElement && item.element.type === STYLE_HIDDEN)) {
-        return true;
-    }
-    const isDirectSummary = item.element.matches(SELECTOR_SUMMARY_FIRST);
-    const nodeUnderDetails = isDirectSummary ? item.element.parentElement : item.element;
-    if (nodeUnderDetails?.matches(SELECTOR_DETAILS_CLOSED_CHILDREN) ?? false) {
-        return true;
-    }
-    const style = getComputedStyle(item.element);
-    if (style.display === STYLE_NONE || style.visibility === STYLE_HIDDEN) {
-        return true;
-    }
-    const { height, width } = item.element.getBoundingClientRect();
-    return height === 0 && width === 0;
+	if ((item.element.hidden ?? false) || item.element instanceof HTMLInputElement && item.element.type === STYLE_HIDDEN) return true;
+	if ((item.element.matches(SELECTOR_SUMMARY_FIRST) ? item.element.parentElement : item.element)?.matches(SELECTOR_DETAILS_CLOSED_CHILDREN) ?? false) return true;
+	const style = getComputedStyle(item.element);
+	if (style.display === STYLE_NONE || style.visibility === STYLE_HIDDEN) return true;
+	const { height, width } = item.element.getBoundingClientRect();
+	return height === 0 && width === 0;
 }
 function isInert(item) {
-    return ((item.element.inert ?? false) ||
-        EXPRESSION_TRUEISH.test(item.element.getAttribute(ATTRIBUTE_INERT)) ||
-        (item.element.parentElement != null &&
-            isInert({
-                element: item.element.parentElement})));
+	return (item.element.inert ?? false) || EXPRESSION_TRUEISH.test(item.element.getAttribute(ATTRIBUTE_INERT)) || item.element.parentElement != null && isInert({
+		element: item.element.parentElement,
+		tabIndex: TABINDEX_DEFAULT
+	});
 }
 function isNotTabbable(item) {
-    return (item.tabIndex ?? TABINDEX_DEFAULT) < TABINDEX_BASE;
+	return (item.tabIndex ?? TABINDEX_DEFAULT) < TABINDEX_BASE;
 }
 function isNotTabbableRadio(item) {
-    if (!(item.element instanceof HTMLInputElement) ||
-        item.element.type !== TYPE_RADIO ||
-        !item.element.name ||
-        item.element.checked) {
-        return false;
-    }
-    const parent = item.element.form ?? item.element.getRootNode?.() ?? item.element.ownerDocument;
-    const realName = CSS?.escape?.(item.element.name) ?? item.element.name;
-    const radios = [
-        ...parent.querySelectorAll(`${SELECTOR_RADIO_PREFIX}${realName}${SELECTOR_RADIO_SUFFIX}`),
-    ];
-    const checked = radios.find(radio => radio.checked);
-    return checked != null && checked !== item.element;
+	if (!(item.element instanceof HTMLInputElement) || item.element.type !== TYPE_RADIO || !item.element.name || item.element.checked) return false;
+	const parent = item.element.form ?? item.element.getRootNode?.() ?? item.element.ownerDocument;
+	const realName = CSS?.escape?.(item.element.name) ?? item.element.name;
+	const checked = [...parent.querySelectorAll(`${SELECTOR_RADIO_PREFIX}${realName}${SELECTOR_RADIO_SUFFIX}`)].find((radio) => radio.checked);
+	return checked != null && checked !== item.element;
 }
 function isSummarised(item) {
-    return (item.element instanceof HTMLDetailsElement &&
-        [...item.element.children].some(child => EXPRESSION_SUMMARY.test(child.tagName)));
+	return item.element instanceof HTMLDetailsElement && [...item.element.children].some((child) => EXPRESSION_SUMMARY.test(child.tagName));
 }
 /**
- * Is the element tabbable?
- * @param element Element to check
- * @returns `true` if tabbable, otherwise `false`
- */
+* Is the element tabbable?
+* @param element Element to check
+* @returns `true` if tabbable, otherwise `false`
+*/
 function isTabbable(element) {
-    return element instanceof Element ? isValidElement(element, FILTERS_TABBABLE, true) : false;
+	return element instanceof Element ? isValidElement(element, FILTERS_TABBABLE, true) : false;
 }
 function isValidElement(element, filters, tabbable) {
-    const item = getItem(element, tabbable);
-    return !filters.some(filter => filter(item));
+	const item = getItem(element, tabbable);
+	return !filters.some((filter) => filter(item));
 }
-//
-const ATTRIBUTE_CONTENTEDITABLE = 'contenteditable';
-const ATTRIBUTE_INERT = 'inert';
-const ATTRIBUTE_TABINDEX = 'tabindex';
+const ATTRIBUTE_CONTENTEDITABLE = "contenteditable";
+const ATTRIBUTE_INERT = "inert";
+const ATTRIBUTE_TABINDEX = "tabindex";
 const EXPRESSION_DISABLEABLE = /^(button|input|select|textarea)$/i;
 const EXPRESSION_SPECIAL_TABINDEX = /^(audio|details|video)$/i;
 const EXPRESSION_SUMMARY = /^summary$/i;
 const EXPRESSION_TRUEISH = /^(|true)$/i;
 const FILTERS_FOCUSABLE = [
-    isDisabled,
-    isInert,
-    isHidden,
-    isSummarised,
+	isDisabled,
+	isInert,
+	isHidden,
+	isSummarised
 ];
 const FILTERS_TABBABLE = [
-    isNotTabbable,
-    isNotTabbableRadio,
-    ...FILTERS_FOCUSABLE,
+	isNotTabbable,
+	isNotTabbableRadio,
+	...FILTERS_FOCUSABLE
 ];
-const SELECTOR_DETAILS_CLOSED_CHILDREN = 'details:not([open]) *';
-const SELECTOR_FIELDSET_DISABLED = 'fieldset[disabled] *';
-const SELECTOR_SUMMARY_FIRST = 'details > summary:first-of-type';
-const SELECTOR_RADIO_PREFIX = 'input[type="radio"][name="';
-const SELECTOR_RADIO_SUFFIX = '"]';
+const SELECTOR_DETAILS_CLOSED_CHILDREN = "details:not([open]) *";
+const SELECTOR_FIELDSET_DISABLED = "fieldset[disabled] *";
+const SELECTOR_SUMMARY_FIRST = "details > summary:first-of-type";
+const SELECTOR_RADIO_PREFIX = "input[type=\"radio\"][name=\"";
+const SELECTOR_RADIO_SUFFIX = "\"]";
 const SELECTOR_FULL = [
-    '[contenteditable]:not([contenteditable="false"])',
-    '[tabindex]:not(slot)',
-    'a[href]',
-    'audio[controls]',
-    'button',
-    'details',
-    SELECTOR_SUMMARY_FIRST,
-    'input',
-    'select',
-    'textarea',
-    'video[controls]',
-]
-    .map(selector => `${selector}:not([inert])`)
-    .join(',');
-const STYLE_HIDDEN = 'hidden';
-const STYLE_NONE = 'none';
+	"[contenteditable]:not([contenteditable=\"false\"])",
+	"[tabindex]:not(slot)",
+	"a[href]",
+	"audio[controls]",
+	"button",
+	"details",
+	SELECTOR_SUMMARY_FIRST,
+	"input",
+	"select",
+	"textarea",
+	"video[controls]"
+].map((selector) => `${selector}:not([inert])`).join(",");
+const STYLE_HIDDEN = "hidden";
+const STYLE_NONE = "none";
 const TABINDEX_BASE = 0;
 const TABINDEX_DEFAULT = -1;
-const TYPE_RADIO = 'radio';
+const TYPE_RADIO = "radio";
 
-//
-function getSanitizeOptions(input) {
-    const options = isPlainObject(input) ? input : {};
-    options.sanitizeBooleanAttributes =
-        typeof options.sanitizeBooleanAttributes === 'boolean'
-            ? options.sanitizeBooleanAttributes
-            : true;
-    return options;
-}
-function sanitizeAttributes(element, attributes, options) {
-    const { length } = attributes;
-    for (let index = 0; index < length; index += 1) {
-        const attribute = attributes[index];
-        if (isBadAttribute(attribute) || isEmptyNonBooleanAttribute(attribute)) {
-            element.removeAttribute(attribute.name);
-        }
-        else if (options.sanitizeBooleanAttributes && isInvalidBooleanAttribute(attribute)) {
-            element.setAttribute(attribute.name, '');
-        }
-    }
-}
-function sanitizeNodes(nodes, options) {
-    const actual = nodes.filter(node => node instanceof Node);
-    const { length } = nodes;
-    for (let index = 0; index < length; index += 1) {
-        const node = actual[index];
-        if (node instanceof Element) {
-            const scripts = node.querySelectorAll('script');
-            for (const script of scripts) {
-                script.remove();
-            }
-            sanitizeAttributes(node, [...node.attributes], options);
-        }
-        if (node.hasChildNodes()) {
-            sanitizeNodes([...node.childNodes], options);
-        }
-    }
-    return nodes;
+function handleElement(element, depth) {
+	if (isClobbered(element)) {
+		element.remove();
+		return true;
+	}
+	if (depth === 0) {
+		const scripts = element.querySelectorAll("script");
+		for (const script of scripts) script.remove();
+	}
+	sanitizeAttributes(element, [...element.attributes]);
+	return false;
+}
+/**
+* Is the element clobbered?
+*
+* Thanks, DOMPurify _(https://github.com/cure53/DOMPurify)_
+*/
+function isClobbered(element) {
+	return element instanceof HTMLFormElement && (typeof element.nodeName !== "string" || typeof element.textContent !== "string" || typeof element.removeChild !== "function" || !(element.attributes instanceof NamedNodeMap) || typeof element.removeAttribute !== "function" || typeof element.setAttribute !== "function" || typeof element.namespaceURI !== "string" || typeof element.insertBefore !== "function" || typeof element.hasChildNodes !== "function");
+}
+function sanitizeAttributes(element, attributes) {
+	const { length } = attributes;
+	for (let index = 0; index < length; index += 1) {
+		const { name, value } = attributes[index];
+		if (isBadAttribute$1(name, value, false) || isEmptyNonBooleanAttribute$1(name, value, false)) element.removeAttribute(name);
+		else if (isInvalidBooleanAttribute$1(name, value, false)) element.setAttribute(name, "");
+	}
+}
+function sanitizeNodes(nodes, depth) {
+	const actual = nodes.filter((node) => node instanceof Node);
+	let { length } = nodes;
+	for (let index = 0; index < length; index += 1) {
+		const node = actual[index];
+		if (node instanceof Element && handleElement(node, depth)) {
+			actual.splice(index, 1);
+			length -= 1;
+			index -= 1;
+			continue;
+		}
+		if (node.hasChildNodes()) sanitizeNodes([...node.childNodes], depth + 1);
+	}
+	return nodes;
 }
 
-//
-function createTemplate(html, ignore) {
-    const template = document.createElement('template');
-    template.innerHTML = html;
-    if (!ignore) {
-        templates[html] = template;
-    }
-    return template;
-}
-function getHtml(value, options) {
-    if (typeof value !== 'string' && !(value instanceof HTMLTemplateElement)) {
-        return [];
-    }
-    const template = value instanceof HTMLTemplateElement ? value : getTemplate(value, options.ignoreCache);
-    if (template == null) {
-        return [];
-    }
-    const cloned = template.content.cloneNode(true);
-    const scripts = cloned.querySelectorAll('script');
-    for (const script of scripts) {
-        script.remove();
-    }
-    cloned.normalize();
-    return sanitizeNodes([...cloned.childNodes], options);
+function createHtml(value) {
+	const html$1 = getParser().parseFromString(typeof value === "string" ? value : value.innerHTML, HTML_PARSE_TYPE);
+	html$1.body.normalize();
+	sanitizeNodes([html$1.body], 0);
+	return html$1.body.innerHTML;
+}
+function createTemplate(value, options) {
+	const template = document.createElement(TEMPLATE_TAG);
+	template.innerHTML = createHtml(value);
+	if (typeof value === "string" && options.cache) templates[value] = template;
+	return template;
+}
+function getNodes(value, options) {
+	if (typeof value !== "string" && !(value instanceof HTMLTemplateElement)) return [];
+	const template = getTemplate(value, options);
+	return template == null ? [] : [...template.content.cloneNode(true).childNodes];
 }
 function getOptions(input) {
-    const options = isPlainObject(input) ? input : {};
-    options.ignoreCache = typeof options.ignoreCache === 'boolean' ? options.ignoreCache : false;
-    options.sanitizeBooleanAttributes =
-        typeof options.sanitizeBooleanAttributes === 'boolean'
-            ? options.sanitizeBooleanAttributes
-            : true;
-    return options;
-}
-function getTemplate(value, ignore) {
-    if (typeof value !== 'string' || value.trim().length === 0) {
-        return;
-    }
-    let template = templates[value];
-    if (template != null) {
-        return template;
-    }
-    const element = EXPRESSION_ID.test(value) ? document.querySelector(`#${value}`) : null;
-    template = element instanceof HTMLTemplateElement ? element : createTemplate(value, ignore);
-    return template;
+	const options = isPlainObject(input) ? input : {};
+	options.cache = typeof options.cache === "boolean" ? options.cache : true;
+	return options;
+}
+function getParser() {
+	parser ??= new DOMParser();
+	return parser;
+}
+function getTemplate(value, options) {
+	if (value instanceof HTMLTemplateElement) return createTemplate(value, options);
+	if (typeof value !== "string" || value.trim().length === 0) return;
+	let template = templates[value];
+	if (template != null) return template;
+	const element = EXPRESSION_ID.test(value) ? document.querySelector(`#${value}`) : null;
+	template = element instanceof HTMLTemplateElement ? element : createTemplate(value, options);
+	return template;
 }
 const html = ((value, options) => {
-    return getHtml(value, getOptions(options));
+	return getNodes(value, getOptions(options));
 });
 html.clear = () => {
-    templates = {};
+	templates = {};
 };
 html.remove = (template) => {
-    if (typeof template !== 'string' || templates[template] == null) {
-        return;
-    }
-    const keys = Object.keys(templates);
-    const { length } = keys;
-    const updated = {};
-    for (let index = 0; index < length; index += 1) {
-        const key = keys[index];
-        if (key !== template) {
-            updated[key] = templates[key];
-        }
-    }
-    templates = updated;
+	if (typeof template !== "string" || templates[template] == null) return;
+	const keys = Object.keys(templates);
+	const { length } = keys;
+	const updated = {};
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		if (key !== template) updated[key] = templates[key];
+	}
+	templates = updated;
 };
 /**
- * Sanitize one or more nodes, recursively
- * @param value Node or nodes to sanitize
- * @param options Sanitization options
- * @returns Sanitized nodes
- */
-function sanitize(value, options) {
-    return sanitizeNodes(Array.isArray(value) ? value : [value], getSanitizeOptions(options));
-}
-//
+* Sanitize one or more nodes, recursively
+* @param value Node or nodes to sanitize
+* @param options Sanitization options
+* @returns Sanitized nodes
+*/
+function sanitize(value) {
+	return sanitizeNodes(Array.isArray(value) ? value : [value], 0);
+}
 const EXPRESSION_ID = /^[a-z][\w-]*$/i;
+const HTML_PARSE_TYPE = "text/html";
+const TEMPLATE_TAG = "template";
+let parser;
 let templates = {};
 
 /**
- * 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
- */
+* 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
+*/
 function getStyle(element, property, computed) {
-    if (!isHTMLOrSVGElement(element) || typeof property !== 'string') {
-        return undefined;
-    }
-    return getStyleValue(element, property, computed === true);
+	if (!isHTMLOrSVGElement(element) || typeof property !== "string") return;
+	return getStyleValue(element, property, computed === true);
 }
 /**
- * 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
- */
+* 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
+*/
 function getStyles(element, properties, computed) {
-    const styles = {};
-    if (!(isHTMLOrSVGElement(element) && Array.isArray(properties))) {
-        return styles;
-    }
-    const { length } = properties;
-    for (let index = 0; index < length; index += 1) {
-        const property = properties[index];
-        if (typeof property === 'string') {
-            styles[property] = getStyleValue(element, property, computed === true);
-        }
-    }
-    return styles;
+	const styles = {};
+	if (!(isHTMLOrSVGElement(element) && Array.isArray(properties))) return styles;
+	const { length } = properties;
+	for (let index = 0; index < length; index += 1) {
+		const property = properties[index];
+		if (typeof property === "string") styles[property] = getStyleValue(element, property, computed === true);
+	}
+	return styles;
 }
 /**
- * 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
- */
+* 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
+*/
 function getTextDirection(element, computed) {
-    if (!(element instanceof Element)) {
-        return undefined;
-    }
-    const direction = element.getAttribute(ATTRIBUTE_DIRECTION);
-    if (direction != null && EXPRESSION_DIRECTION.test(direction)) {
-        return direction.toLowerCase();
-    }
-    const value = getStyleValue(element, 'direction', computed === true);
-    return value === 'rtl' ? value : 'ltr';
+	if (!(element instanceof Element)) return;
+	const direction = element.getAttribute(ATTRIBUTE_DIRECTION);
+	if (direction != null && EXPRESSION_DIRECTION.test(direction)) return direction.toLowerCase();
+	const value = getStyleValue(element, "direction", computed === true);
+	return value === "rtl" ? value : "ltr";
 }
 /**
- * Set a style on an element
- * @param element Element to set the style on
- * @param property Style name
- * @param value Style value
- */
+* Set a style on an element
+* @param element Element to set the style on
+* @param property Style name
+* @param value Style value
+*/
 function setStyle(element, property, value) {
-    setElementValues(element, property, value, updateStyleProperty);
+	setElementValues(element, property, value, updateStyleProperty);
 }
 /**
- * Set styles on an element
- * @param element Element to set the styles on
- * @param styles Styles to set
- */
+* Set styles on an element
+* @param element Element to set the styles on
+* @param styles Styles to set
+*/
 function setStyles(element, styles) {
-    setElementValues(element, styles, null, updateStyleProperty);
+	setElementValues(element, styles, null, updateStyleProperty);
 }
 /**
- * Toggle styles for an element
- * @param element Element to style
- * @param styles Styles to be set or removed
- * @returns Style toggler
- */
+* Toggle styles for an element
+* @param element Element to style
+* @param styles Styles to be set or removed
+* @returns Style toggler
+*/
 function toggleStyles(element, styles) {
-    function toggle(set) {
-        hasSet = set;
-        let next;
-        if (set) {
-            values = getStyles(element, keys);
-            next = styles;
-        }
-        else {
-            next = { ...values };
-            values = {};
-            for (const key of keys) {
-                values[key] = undefined;
-            }
-        }
-        setStyles(element, next);
-    }
-    const keys = Object.keys(styles);
-    let hasSet = false;
-    let values = {};
-    return {
-        set() {
-            if (!hasSet) {
-                toggle(true);
-            }
-        },
-        remove() {
-            if (hasSet) {
-                toggle(false);
-            }
-        },
-    };
+	function toggle(set) {
+		hasSet = set;
+		let next;
+		if (set) {
+			values = getStyles(element, keys);
+			next = styles;
+		} else {
+			next = { ...values };
+			values = {};
+			for (const key of keys) values[key] = void 0;
+		}
+		setStyles(element, next);
+	}
+	const keys = Object.keys(styles);
+	let hasSet = false;
+	let values = {};
+	return {
+		set() {
+			if (!hasSet) toggle(true);
+		},
+		remove() {
+			if (hasSet) toggle(false);
+		}
+	};
 }
 function updateStyleProperty(element, key, value) {
-    updateElementValue(element, key, value, function (property, value) {
-        this.style[property] = value;
-    }, function (property) {
-        this.style[property] = '';
-    }, false);
-}
-//
-const ATTRIBUTE_DIRECTION = 'dir';
+	updateElementValue(element, key, value, function(property, value$1) {
+		this.style[property] = value$1;
+	}, function(property) {
+		this.style[property] = "";
+	}, false);
+}
+const ATTRIBUTE_DIRECTION = "dir";
 const EXPRESSION_DIRECTION = /^(ltr|rtl)$/i;
 
-export { findElement as $, findElements as $$, booleanAttributes, dispatch, findAncestor, findElement, findElements, findRelatives, getAttribute, getAttributes, getData, getElementUnderPointer, getFocusable, getPosition, getStyle, getStyles, getTabbable, getTextDirection, html, isBadAttribute, isBooleanAttribute, isChildNode, isEmptyNonBooleanAttribute, isEventTarget, isFocusable, isHTMLOrSVGElement, isInDocument, isInvalidBooleanAttribute, isTabbable, off, on, sanitize, setAttribute, setAttributes, setData, setProperties, setProperty, setStyle, setStyles, supportsTouch, toggleStyles };
+export { findElement as $, findElement, findElements as $$, findElements, dispatch, findAncestor, findRelatives, getData, getElementUnderPointer, getFocusable, getPosition, getStyle, getStyles, getTabbable, getTextDirection, html, isBadAttribute, isBooleanAttribute, isChildNode, isEmptyNonBooleanAttribute, isEventTarget, isFocusable, isHTMLOrSVGElement, isInDocument, isInvalidBooleanAttribute, isTabbable, off, on, sanitize, setData, setStyle, setStyles, touch_default as supportsTouch, toggleStyles };