@oscarpalmer/toretto 0.24.0 → 0.25.0

package/dist/html.js

@@ -1,38 +1,51 @@
-import { sanitize } from "./sanitize.js";
-function createTemplate(html$1) {
+import { sanitizeNodes } from "./internal/sanitize.js";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
+function createTemplate(html$1, ignore) {
 	const template = document.createElement("template");
 	template.innerHTML = html$1;
-	templates[html$1] = template;
+	if (!ignore) templates[html$1] = template;
 	return template;
 }
-function getTemplate(value) {
+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 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);
-	templates[value] = template;
+	template = element instanceof HTMLTemplateElement ? element : createTemplate(value, ignore);
 	return template;
 }
-var html = ((value, sanitization) => {
-	if (typeof value !== "string" && !(value instanceof HTMLTemplateElement)) return [];
-	let options;
-	if (sanitization == null || sanitization === true) options = {};
-	else options = sanitization === false ? void 0 : sanitization;
-	const template = value instanceof HTMLTemplateElement ? value : getTemplate(value);
-	if (template == null) return [];
-	const cloned = template.content.cloneNode(true);
-	const scripts = cloned.querySelectorAll("script");
-	const { length } = scripts;
-	for (let index = 0; index < length; index += 1) scripts[index].remove();
-	cloned.normalize();
-	return options != null ? sanitize([...cloned.childNodes], options) : [...cloned.childNodes];
+var html = ((value, options) => {
+	return getHtml(value, getOptions(options));
 });
 html.clear = () => {
 	templates = {};
 };
 html.remove = (template) => {
-	if (typeof template === "string") templates[template] = void 0;
+	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;
 };
 var EXPRESSION_ID = /^[a-z][\w-]*$/i;
 var templates = {};

package/dist/internal/sanitize.js

@@ -0,0 +1,30 @@
+import { isBadAttribute, isEmptyNonBooleanAttribute, isInvalidBooleanAttribute } from "../attribute.js";
+import { isPlainObject } from "@oscarpalmer/atoms/is";
+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;
+}
+export { getSanitizeOptions, sanitizeAttributes, sanitizeNodes };

package/dist/sanitize.js

@@ -1,29 +1,5 @@
-import { isBadAttribute, isEmptyNonBooleanAttribute, isInvalidBooleanAttribute } from "./attribute.js";
-import { isPlainObject } from "@oscarpalmer/atoms/is";
-function getOptions(input) {
-	const options = isPlainObject(input) ? input : {};
-	options.sanitizeBooleanAttributes = typeof options.sanitizeBooleanAttributes === "boolean" ? options.sanitizeBooleanAttributes : true;
-	return options;
-}
+import { getSanitizeOptions, sanitizeNodes } from "./internal/sanitize.js";
 function sanitize(value, options) {
-	return sanitizeNodes(Array.isArray(value) ? value : [value], getOptions(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) sanitizeAttributes(node, [...node.attributes], options);
-		if (node.hasChildNodes()) sanitizeNodes([...node.childNodes], options);
-	}
-	return nodes;
+	return sanitizeNodes(Array.isArray(value) ? value : [value], getSanitizeOptions(options));
 }
 export { sanitize };

package/dist/toretto.full.js

@@ -437,10 +437,8 @@ function calculate() {
 		function step(now) {
 			if (last != null) values.push(now - last);
 			last = now;
-			if (values.length >= CALCULATION_TOTAL) {
-				const median = values.sort().slice(2, -2).reduce((first, second) => first + second, 0) / (values.length - CALCULATION_TRIM);
-				resolve(median);
-			} else requestAnimationFrame(step);
+			if (values.length >= CALCULATION_TOTAL) resolve(values.sort().slice(2, -2).reduce((first, second) => first + second, 0) / (values.length - CALCULATION_TRIM));
+			else requestAnimationFrame(step);
 		}
 		requestAnimationFrame(step);
 	});
@@ -988,7 +986,8 @@ const TABINDEX_BASE = 0;
 const TABINDEX_DEFAULT = -1;
 const TYPE_RADIO = 'radio';
 
-function getOptions(input) {
+//
+function getSanitizeOptions(input) {
     const options = isPlainObject(input) ? input : {};
     options.sanitizeBooleanAttributes =
         typeof options.sanitizeBooleanAttributes === 'boolean'
@@ -996,15 +995,6 @@ function getOptions(input) {
             : true;
     return options;
 }
-/**
- * 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], getOptions(options));
-}
 function sanitizeAttributes(element, attributes, options) {
     const { length } = attributes;
     for (let index = 0; index < length; index += 1) {
@@ -1024,6 +1014,10 @@ function sanitizeNodes(nodes, options) {
     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()) {
@@ -1034,13 +1028,43 @@ function sanitizeNodes(nodes, options) {
 }
 
 //
-function createTemplate(html) {
+function createTemplate(html, ignore) {
     const template = document.createElement('template');
     template.innerHTML = html;
-    templates[html] = template;
+    if (!ignore) {
+        templates[html] = template;
+    }
     return template;
 }
-function getTemplate(value) {
+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 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;
     }
@@ -1052,48 +1076,46 @@ function getTemplate(value) {
         ? document.querySelector(`#${value}`)
         : null;
     template =
-        element instanceof HTMLTemplateElement ? element : createTemplate(value);
-    templates[value] = template;
+        element instanceof HTMLTemplateElement
+            ? element
+            : createTemplate(value, ignore);
     return template;
 }
-const html = ((value, sanitization) => {
-    if (typeof value !== 'string' && !(value instanceof HTMLTemplateElement)) {
-        return [];
-    }
-    let options;
-    if (sanitization == null || sanitization === true) {
-        options = {};
-    }
-    else {
-        options = sanitization === false ? undefined : sanitization;
-    }
-    const template = value instanceof HTMLTemplateElement ? value : getTemplate(value);
-    if (template == null) {
-        return [];
-    }
-    const cloned = template.content.cloneNode(true);
-    const scripts = cloned.querySelectorAll('script');
-    const { length } = scripts;
-    for (let index = 0; index < length; index += 1) {
-        scripts[index].remove();
-    }
-    cloned.normalize();
-    return options != null
-        ? sanitize([...cloned.childNodes], options)
-        : [...cloned.childNodes];
+const html = ((value, options) => {
+    return getHtml(value, getOptions(options));
 });
 html.clear = () => {
     templates = {};
 };
 html.remove = (template) => {
-    if (typeof template === 'string') {
-        templates[template] = undefined;
+    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;
 };
 //
 const EXPRESSION_ID = /^[a-z][\w-]*$/i;
 let templates = {};
 
+/**
+ * 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));
+}
+
 /**
  * Get a style from an element
  * @param element Element to get the style from

package/package.json

@@ -4,21 +4,22 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.112"
+		"@oscarpalmer/atoms": "^0.114"
 	},
 	"description": "A collection of badass DOM utilities.",
 	"devDependencies": {
-		"@biomejs/biome": "^2.2",
+		"@biomejs/biome": "^2.3",
 		"@rollup/plugin-node-resolve": "^16",
-		"@rollup/plugin-typescript": "^12.1",
-		"@types/node": "^24.7",
-		"@vitest/coverage-istanbul": "^3.2",
-		"jsdom": "^27.0",
+		"@rollup/plugin-typescript": "^12.3",
+		"@types/node": "^24.10",
+		"@vitest/coverage-istanbul": "^4",
+		"glob": "^11",
+		"jsdom": "^27.1",
 		"rollup": "^4.52",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
 		"vite": "npm:rolldown-vite@latest",
-		"vitest": "^3.2"
+		"vitest": "^4"
 	},
 	"exports": {
 		"./package.json": "./package.json",
@@ -96,5 +97,5 @@
 	},
 	"type": "module",
 	"types": "types/index.d.ts",
-	"version": "0.24.0"
+	"version": "0.25.0"
 }

package/src/html.ts

@@ -1,4 +1,5 @@
-import {type SanitizeOptions, sanitize} from './sanitize';
+import {isPlainObject} from '@oscarpalmer/atoms/is';
+import {type SanitizeOptions, sanitizeNodes} from './internal/sanitize';
 
 //
 
@@ -6,21 +7,18 @@ type Html = {
 	/**
 	 * Create nodes from an HTML string or a template element
 	 * @param value HTML string or id for a template element
-	 * @param sanitization Sanitization options
+	 * @param options Options for creating nodes
 	 * @returns Created nodes
 	 */
-	(value: string, sanitization?: boolean | SanitizeOptions): Node[];
+	(value: string, options?: HtmlOptions): Node[];
 
 	/**
 	 * Create nodes from a template element
 	 * @param template Template element
-	 * @param sanitization Sanitization options
+	 * @param options Options for creating nodes
 	 * @returns Created nodes
 	 */
-	(
-		template: HTMLTemplateElement,
-		sanitization?: boolean | SanitizeOptions,
-	): Node[];
+	(template: HTMLTemplateElement, options?: HtmlOptions): Node[];
 
 	/**
 	 * Clear cache of template elements
@@ -34,19 +32,77 @@ type Html = {
 	remove(template: string): void;
 };
 
+type HtmlOptions = {
+	/**
+	 * Ignore caching the template element for the HTML string? _(defaults to `false`)_
+	 */
+	ignoreCache?: boolean;
+} & SanitizeOptions;
+
+type Options = Required<HtmlOptions>;
+
 //
 
-function createTemplate(html: string): HTMLTemplateElement {
+function createTemplate(html: string, ignore: boolean): HTMLTemplateElement {
 	const template = document.createElement('template');
 
 	template.innerHTML = html;
 
-	templates[html] = template;
+	if (!ignore) {
+		templates[html] = template;
+	}
 
 	return template;
 }
 
-function getTemplate(value: string): HTMLTemplateElement | undefined {
+function getHtml(
+	value: string | HTMLTemplateElement,
+	options: Options,
+): Node[] {
+	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) as DocumentFragment;
+
+	const scripts = cloned.querySelectorAll('script');
+
+	for (const script of scripts) {
+		script.remove();
+	}
+
+	cloned.normalize();
+
+	return sanitizeNodes([...cloned.childNodes], options);
+}
+
+function getOptions(input?: HtmlOptions): Options {
+	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 as Options;
+}
+
+function getTemplate(
+	value: string,
+	ignore: boolean,
+): HTMLTemplateElement | undefined {
 	if (typeof value !== 'string' || value.trim().length === 0) {
 		return;
 	}
@@ -62,66 +118,50 @@ function getTemplate(value: string): HTMLTemplateElement | undefined {
 		: null;
 
 	template =
-		element instanceof HTMLTemplateElement ? element : createTemplate(value);
-
-	templates[value] = template;
+		element instanceof HTMLTemplateElement
+			? element
+			: createTemplate(value, ignore);
 
 	return template;
 }
 
 const html = ((
 	value: string | HTMLTemplateElement,
-	sanitization?: boolean | SanitizeOptions,
+	options?: Options,
 ): Node[] => {
-	if (typeof value !== 'string' && !(value instanceof HTMLTemplateElement)) {
-		return [];
-	}
+	return getHtml(value, getOptions(options));
+}) as Html;
 
-	let options: SanitizeOptions | undefined;
+html.clear = (): void => {
+	templates = {};
+};
 
-	if (sanitization == null || sanitization === true) {
-		options = {};
-	} else {
-		options = sanitization === false ? undefined : sanitization;
+html.remove = (template: string): void => {
+	if (typeof template !== 'string' || templates[template] == null) {
+		return;
 	}
 
-	const template =
-		value instanceof HTMLTemplateElement ? value : getTemplate(value);
+	const keys = Object.keys(templates);
+	const {length} = keys;
 
-	if (template == null) {
-		return [];
-	}
-
-	const cloned = template.content.cloneNode(true) as DocumentFragment;
-	const scripts = cloned.querySelectorAll('script');
-	const {length} = scripts;
+	const updated: Record<string, HTMLTemplateElement> = {};
 
 	for (let index = 0; index < length; index += 1) {
-		scripts[index].remove();
-	}
-
-	cloned.normalize();
-
-	return options != null
-		? sanitize([...cloned.childNodes], options)
-		: [...cloned.childNodes];
-}) as Html;
+		const key = keys[index];
 
-html.clear = (): void => {
-	templates = {};
-};
-
-html.remove = (template: string): void => {
-	if (typeof template === 'string') {
-		templates[template] = undefined;
+		if (key !== template) {
+			updated[key] = templates[key];
+		}
 	}
+
+	templates = updated;
 };
 
 //
 
 const EXPRESSION_ID = /^[a-z][\w-]*$/i;
 
-let templates: Record<string, HTMLTemplateElement | undefined> = {};
+let templates: Record<string, HTMLTemplateElement> = {};
 
 //
 

package/src/internal/sanitize.ts

@@ -0,0 +1,78 @@
+import {isPlainObject} from '@oscarpalmer/atoms/is';
+import {
+	isBadAttribute,
+	isEmptyNonBooleanAttribute,
+	isInvalidBooleanAttribute,
+} from '../attribute';
+
+//
+
+type Options = Required<SanitizeOptions>;
+
+export type SanitizeOptions = {
+	/**
+	 * Sanitize boolean attributes? _(Defaults to `true`)_
+	 *
+	 * E.g. `checked="abc"` => `checked=""`
+	 */
+	sanitizeBooleanAttributes?: boolean;
+};
+
+//
+
+export function getSanitizeOptions(input?: SanitizeOptions): Options {
+	const options = isPlainObject(input) ? input : {};
+
+	options.sanitizeBooleanAttributes =
+		typeof options.sanitizeBooleanAttributes === 'boolean'
+			? options.sanitizeBooleanAttributes
+			: true;
+
+	return options as Options;
+}
+
+export function sanitizeAttributes(
+	element: Element,
+	attributes: Attr[],
+	options: Options,
+): void {
+	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, '');
+		}
+	}
+}
+
+export function sanitizeNodes(nodes: Node[], options: Options): Node[] {
+	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;
+}

package/src/sanitize.ts

@@ -1,30 +1,8 @@
-import {isPlainObject} from '@oscarpalmer/atoms/is';
 import {
-	isBadAttribute,
-	isEmptyNonBooleanAttribute,
-	isInvalidBooleanAttribute,
-} from './attribute';
-
-type Options = Required<SanitizeOptions>;
-
-export type SanitizeOptions = {
-	/**
-	 * - Sanitize boolean attributes? _(Defaults to `true`)_
-	 * - E.g. `checked="abc"` => `checked=""`
-	 */
-	sanitizeBooleanAttributes?: boolean;
-};
-
-function getOptions(input?: SanitizeOptions): Options {
-	const options = isPlainObject(input) ? input : {};
-
-	options.sanitizeBooleanAttributes =
-		typeof options.sanitizeBooleanAttributes === 'boolean'
-			? options.sanitizeBooleanAttributes
-			: true;
-
-	return options as Options;
-}
+	getSanitizeOptions,
+	type SanitizeOptions,
+	sanitizeNodes,
+} from './internal/sanitize';
 
 /**
  * Sanitize one or more nodes, recursively
@@ -34,50 +12,10 @@ function getOptions(input?: SanitizeOptions): Options {
  */
 export function sanitize(
 	value: Node | Node[],
-	options?: Partial<SanitizeOptions>,
+	options?: SanitizeOptions,
 ): Node[] {
 	return sanitizeNodes(
 		Array.isArray(value) ? value : [value],
-		getOptions(options),
+		getSanitizeOptions(options),
 	);
 }
-
-function sanitizeAttributes(
-	element: Element,
-	attributes: Attr[],
-	options: SanitizeOptions,
-): void {
-	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: Node[], options: SanitizeOptions): Node[] {
-	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) {
-			sanitizeAttributes(node, [...node.attributes], options);
-		}
-
-		if (node.hasChildNodes()) {
-			sanitizeNodes([...node.childNodes], options);
-		}
-	}
-
-	return nodes;
-}

package/types/html.d.ts

@@ -1,19 +1,19 @@
-import { type SanitizeOptions } from './sanitize';
+import { type SanitizeOptions } from './internal/sanitize';
 type Html = {
     /**
      * Create nodes from an HTML string or a template element
      * @param value HTML string or id for a template element
-     * @param sanitization Sanitization options
+     * @param options Options for creating nodes
      * @returns Created nodes
      */
-    (value: string, sanitization?: boolean | SanitizeOptions): Node[];
+    (value: string, options?: HtmlOptions): Node[];
     /**
      * Create nodes from a template element
      * @param template Template element
-     * @param sanitization Sanitization options
+     * @param options Options for creating nodes
      * @returns Created nodes
      */
-    (template: HTMLTemplateElement, sanitization?: boolean | SanitizeOptions): Node[];
+    (template: HTMLTemplateElement, options?: HtmlOptions): Node[];
     /**
      * Clear cache of template elements
      */
@@ -24,5 +24,11 @@ type Html = {
      */
     remove(template: string): void;
 };
+type HtmlOptions = {
+    /**
+     * Ignore caching the template element for the HTML string? _(defaults to `false`)_
+     */
+    ignoreCache?: boolean;
+} & SanitizeOptions;
 declare const html: Html;
 export { html };

package/types/internal/sanitize.d.ts

@@ -0,0 +1,13 @@
+type Options = Required<SanitizeOptions>;
+export type SanitizeOptions = {
+    /**
+     * Sanitize boolean attributes? _(Defaults to `true`)_
+     *
+     * E.g. `checked="abc"` => `checked=""`
+     */
+    sanitizeBooleanAttributes?: boolean;
+};
+export declare function getSanitizeOptions(input?: SanitizeOptions): Options;
+export declare function sanitizeAttributes(element: Element, attributes: Attr[], options: Options): void;
+export declare function sanitizeNodes(nodes: Node[], options: Options): Node[];
+export {};

package/types/sanitize.d.ts

@@ -1,14 +1,8 @@
-export type SanitizeOptions = {
-    /**
-     * - Sanitize boolean attributes? _(Defaults to `true`)_
-     * - E.g. `checked="abc"` => `checked=""`
-     */
-    sanitizeBooleanAttributes?: boolean;
-};
+import { type SanitizeOptions } from './internal/sanitize';
 /**
  * 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[], options?: Partial<SanitizeOptions>): Node[];
+export declare function sanitize(value: Node | Node[], options?: SanitizeOptions): Node[];