diff --git a/src/html.js b/src/html.js
new file mode 100644
index 000000000..80f37d133
--- /dev/null
+++ b/src/html.js
@@ -0,0 +1,547 @@
+/**
+ * @fileoverview A simple HTML parser and helper functions for handling HTML nodes in Markdown rules.
+ * @author Json Miller, Nate Moore, 루밀LuMir(lumirlumir)
+ * @license MIT
+ *
+ * ---
+ *
+ * Portions of this code were borrowed from `ultrahtml` - https://github.com/natemoo-re/ultrahtml
+ *
+ * MIT License Copyright (c) 2022 Nate Moore
+ *
+ * Permission is hereby granted, free of
+ * charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ * The above copyright notice and this permission notice
+ * (including the next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ * ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+ * EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * ---
+ *
+ * Portions of this code were borrowed from `htmlParser` - https://github.com/developit/htmlParser
+ *
+ * The MIT License (MIT) Copyright (c) 2013 Jason Miller
+ *
+ * Permission is hereby granted, free of
+ * charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ * ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+ * EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// TODO: if (selector.content === "*") return true;
+// TODO: getElementByTagName, getElementById, getElementsByClassName, getElementByName
+
+//-----------------------------------------------------------------------------
+// Type Definitions
+//-----------------------------------------------------------------------------
+
+/**
+ * @import { HtmlNode, HtmlParentNode, HtmlTextNode, HtmlCommentNode, HtmlDoctypeNode, HtmlDocumentNode } from "./types.js";
+ */
+
+//-----------------------------------------------------------------------------
+// Helpers: Constants
+//-----------------------------------------------------------------------------
+
+/** @type {Set<string>} */
+const VOID_TAGS = new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"keygen",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr",
+]);
+/** @type {Set<string>} */
+const RAW_TAGS = new Set(["script", "style"]);
+
+const DOM_PARSER_RE =
+	/(?:<(\/?)([a-zA-Z][a-zA-Z0-9:-]*)(?:\s([^>]*?))?((?:\s*\/)?)>|(<!--)([\s\S]*?)(-->)|(<!)([\s\S]*?)(>))/gmu;
+const ATTR_KEY_IDENTIFIER_RE = /[@.a-z0-9_:-]/iu;
+
+//-----------------------------------------------------------------------------
+// Helpers: Functions
+//-----------------------------------------------------------------------------
+
+/**
+ * TODO
+ * @param {HtmlNode} node TODO
+ * @returns {boolean} TODO
+ */
+function canSelfClose(node) {
+	if (node.children.length === 0) {
+		/** @type {HtmlNode | undefined} */
+		let n = node;
+
+		while ((n = n.parent)) {
+			if (n.name === "svg") {
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+/**
+ * Parses a string of HTML attributes into an object.
+ * @param {string} str The string to parse.
+ * @returns {Record<string, string>} The parsed attributes as an object.
+ * @example
+ * ```js
+ * import { parseAttrs } from "path/to/html.js";
+ *
+ * const attrs = parseAttrs('id="my-id" class="my-class" data-custom="value"');
+ * console.log(attrs);
+ * // { id: "my-id", class: "my-class", data-custom: "value" }
+ * ```
+ *
+ */
+export function parseAttrs(str) {
+	/** @type {Record<string, string>} */
+	const obj = {};
+
+	if (str) {
+		/** @type {'none' | 'key' | 'value'} */
+		let state = "none";
+		/** @type {string | undefined} */
+		let currentKey;
+		/** @type {string} */
+		let currentValue = "";
+		/** @type {number | undefined} */
+		let tokenStartIndex;
+		/** @type {'"' | "'" | undefined} */
+		let valueDelimiter;
+
+		for (let currentIndex = 0; currentIndex < str.length; currentIndex++) {
+			const currentChar = str[currentIndex];
+
+			if (state === "none") {
+				if (ATTR_KEY_IDENTIFIER_RE.test(currentChar)) {
+					// add attribute
+					if (currentKey) {
+						obj[currentKey] = currentValue;
+						currentKey = undefined;
+						currentValue = "";
+					}
+
+					tokenStartIndex = currentIndex;
+					state = "key";
+				} else if (currentKey && currentChar === "=") {
+					state = "value";
+				}
+			} else if (state === "key") {
+				if (!ATTR_KEY_IDENTIFIER_RE.test(currentChar)) {
+					currentKey = str.slice(tokenStartIndex, currentIndex);
+
+					if (currentChar === "=") {
+						state = "value";
+					} else {
+						state = "none";
+					}
+				}
+			} else {
+				if (
+					valueDelimiter === currentChar &&
+					currentIndex > 0 &&
+					str[currentIndex - 1] !== "\\" // if not escaped
+				) {
+					currentValue = str.slice(tokenStartIndex, currentIndex);
+					valueDelimiter = undefined;
+					state = "none";
+				} else if (
+					!valueDelimiter &&
+					(currentChar === '"' || currentChar === "'")
+				) {
+					tokenStartIndex = currentIndex + 1;
+					valueDelimiter = currentChar;
+				}
+			}
+		}
+
+		if (
+			state === "key" &&
+			tokenStartIndex !== undefined &&
+			tokenStartIndex < str.length
+		) {
+			currentKey = str.slice(tokenStartIndex, str.length);
+		}
+
+		if (currentKey) {
+			obj[currentKey] = currentValue;
+		}
+	}
+
+	return obj;
+}
+
+/**
+ * Stringifies an object of HTML attributes into a string.
+ * @param {Record<string, string>} attributes The attributes to stringify.
+ * @returns {string} The stringified attributes.
+ */
+export function stringifyAttrs(attributes) {
+	let attrStr = "";
+
+	for (const [key, value] of Object.entries(attributes)) {
+		attrStr += ` ${key}="${value}"`;
+	}
+
+	return attrStr;
+}
+
+/**
+ * The `parse` function takes a string of HTML and returns an AST (Abstract Syntax Tree).
+ * @param {string} input TODO
+ * @returns {HtmlNode} TODO
+ * @example
+ * ```js
+ * import { parse } from "path/to/html.js";
+ *
+ * const ast = parse(`<h1>Hello world!</h1>`);
+ * console.log(ast);
+ * // {
+ * //   type: "document",
+ * //   children: [
+ * //     ...
+ * //   ],
+ * // }
+ * ```
+ *
+ */
+export function parse(input) {
+	/** @type {HtmlNode} */
+	let doc;
+	/** @type {HtmlNode} */
+	let parent;
+	/** @type {RegExpExecArray | null} */
+	let token;
+	/** @type {string} */
+	let text;
+	/** @type {number} */
+	let i;
+	/** @type {string} */
+	let bStart;
+	/** @type {string} */
+	let bText;
+	/** @type {string} */
+	let bEnd;
+	/** @type {HtmlNode} */
+	let tag;
+	/** @type {number} */
+	let lastIndex = 0;
+
+	/** @type {string} */
+	const str = input;
+	/** @type {HtmlNode[]} */
+	const tags = [];
+
+	/**
+	 * TODO
+	 * @returns {void}
+	 */
+	function commitTextNode() {
+		// eslint-disable-next-line unicorn/prefer-string-slice, no-restricted-properties -- TODO
+		text = str.substring(
+			lastIndex,
+			DOM_PARSER_RE.lastIndex - token[0].length,
+		);
+
+		if (text) {
+			parent.children.push(
+				/** @type {HtmlTextNode} */ ({
+					type: "text",
+					value: text,
+					parent,
+				}),
+			);
+		}
+	}
+
+	DOM_PARSER_RE.lastIndex = 0;
+
+	parent = doc = /** @type {any} */ ({
+		type: "document",
+		children: [],
+	});
+
+	while ((token = DOM_PARSER_RE.exec(str))) {
+		bStart = token[5] || token[8];
+		bText = token[6] || token[9];
+		bEnd = token[7] || token[10];
+
+		if (RAW_TAGS.has(parent.name) && token[2] !== parent.name) {
+			// eslint-disable-next-line no-useless-assignment -- TODO
+			i = DOM_PARSER_RE.lastIndex - token[0].length;
+			if (parent.children.length > 0) {
+				parent.children[0].value += token[0];
+			}
+			continue;
+		} else if (bStart === "<!--") {
+			i = DOM_PARSER_RE.lastIndex - token[0].length;
+			if (RAW_TAGS.has(parent.name)) {
+				continue;
+			}
+			tag = /** @type {HtmlCommentNode} */ {
+				type: "comment",
+				value: bText,
+				parent,
+				loc: [
+					{
+						start: i,
+						end: i + bStart.length,
+					},
+					{
+						start: DOM_PARSER_RE.lastIndex - bEnd.length,
+						end: DOM_PARSER_RE.lastIndex,
+					},
+				],
+			};
+			tags.push(tag);
+			tag.parent.children.push(tag);
+		} else if (bStart === "<!") {
+			i = DOM_PARSER_RE.lastIndex - token[0].length;
+			tag = /** @type {HtmlDoctypeNode} */ {
+				type: "doctype",
+				value: bText,
+				parent,
+				loc: [
+					{
+						start: i,
+						end: i + bStart.length,
+					},
+					{
+						start: DOM_PARSER_RE.lastIndex - bEnd.length,
+						end: DOM_PARSER_RE.lastIndex,
+					},
+				],
+			};
+			tags.push(tag);
+			tag.parent.children.push(tag);
+		} else if (token[1] !== "/") {
+			commitTextNode();
+			if (RAW_TAGS.has(parent.name)) {
+				lastIndex = DOM_PARSER_RE.lastIndex;
+				commitTextNode();
+				continue;
+			} else {
+				tag = {
+					type: "element",
+					name: `${token[2]}`,
+					attributes: parseAttrs(token[3]),
+					parent,
+					children: [],
+					loc: /** @type {any} */ ([
+						{
+							start: DOM_PARSER_RE.lastIndex - token[0].length,
+							end: DOM_PARSER_RE.lastIndex,
+						},
+					]),
+				};
+				tags.push(tag);
+				tag.parent.children.push(tag);
+				if (
+					// @ts-expect-error -- TODO
+					(token[4] && token[4].includes("/") > -1) ||
+					VOID_TAGS.has(tag.name)
+				) {
+					tag.loc[1] = tag.loc[0];
+					tag.isSelfClosingTag = true;
+				} else {
+					parent = tag;
+				}
+			}
+		} else {
+			commitTextNode();
+			// Close parent node if end-tag matches
+			if (`${token[2]}` === parent.name) {
+				tag = parent;
+				parent = tag.parent;
+				tag.loc.push({
+					start: DOM_PARSER_RE.lastIndex - token[0].length,
+					end: DOM_PARSER_RE.lastIndex,
+				});
+				// eslint-disable-next-line unicorn/prefer-string-slice, no-restricted-properties -- TODO
+				text = str.substring(tag.loc[0].end, tag.loc[1].start);
+				if (tag.children.length === 0) {
+					tag.children.push({
+						type: "text",
+						value: text,
+						parent,
+					});
+				}
+			}
+			// account for abuse of self-closing tags when an end-tag is also provided:
+			else if (
+				`${token[2]}` === tags.at(-1).name &&
+				tags.at(-1).isSelfClosingTag === true
+			) {
+				tag = tags.at(-1);
+				tag.loc.push({
+					start: DOM_PARSER_RE.lastIndex - token[0].length,
+					end: DOM_PARSER_RE.lastIndex,
+				});
+			}
+		}
+
+		lastIndex = DOM_PARSER_RE.lastIndex;
+	}
+
+	text = str.slice(lastIndex);
+
+	parent.children.push({
+		type: "text",
+		value: text,
+		parent,
+	});
+
+	return doc;
+}
+
+/**
+ * The `walk` function provides full control over the AST.
+ * It can be used to scan for text, elements, components,
+ * or any other validation you might want to do.
+ *
+ * `walk` is **synchronous**. This should only be used
+ * when it is guaranteed there are no `async` components in the tree.
+ * @param {HtmlNode} node TODO
+ * @param {(node: HtmlNode, parent?: HtmlNode, index?: number) => void} callback TODO
+ * @returns {void}
+ * @example
+ * ```js
+ * import { parse, walk } from "path/to/html.js";
+ *
+ * const ast = parse(`<h1>Hello world!</h1>`);
+ * walk(ast, (node) => {
+ *   if (node.type === "element" && node.name === "script") {
+ *     throw new Error("Found a script!");
+ *   }
+ * });
+ * ```
+ *
+ */
+export function walk(node, callback) {
+	/**
+	 * TODO
+	 * @param {HtmlNode} n TODO
+	 * @param {HtmlNode} [parent] TODO
+	 * @param {number} [index] TODO
+	 * @returns {void}
+	 */
+	function visit(n, parent, index) {
+		// eslint-disable-next-line n/callback-return -- TODO
+		callback(n, parent, index);
+
+		if (Array.isArray(n.children)) {
+			for (let i = 0; i < n.children.length; i++) {
+				const child = n.children[i];
+				visit(child, n, i);
+			}
+		}
+	}
+
+	return visit(node);
+}
+
+/**
+ * The `render` function allows you to serialize an AST back into a string.
+ * @param {HtmlNode} node TODO
+ * @returns {string} TODO
+ * @throws {Error} TODO
+ * @example
+ * ```js
+ * import { parse, render } from "path/to/html.js";
+ *
+ * const ast = parse(`<h1>Hello world!</h1>`);
+ * console.log(render(ast)); // <h1>Hello world!</h1>
+ * ```
+ *
+ */
+export function render(node) {
+	switch (node.type) {
+		case "document":
+			return node.children
+				.map((/** @type {HtmlNode} */ child) => render(child))
+				.join("");
+		case "element": {
+			const { name, attributes = {} } = node;
+			const children = node.children
+				.map((/** @type {HtmlNode} */ child) => render(child))
+				.join("");
+			const isSelfClosing = canSelfClose(node);
+			if (isSelfClosing || VOID_TAGS.has(name)) {
+				return `<${node.name}${stringifyAttrs(attributes)}${
+					isSelfClosing ? " /" : ""
+				}>`;
+			}
+			return `<${node.name}${stringifyAttrs(attributes)}>${children}</${node.name}>`;
+		}
+		case "text":
+			return `${node.value}`;
+		case "comment":
+			return `<!--${node.value}-->`;
+		case "doctype":
+			return `<!${node.value}>`;
+		default:
+			throw new Error(`Unknown node type: ${node}`); // TODO
+	}
+}
+
+/**
+ * TODO
+ * @param {HtmlNode} node TODO
+ * @param {string} selector TODO
+ * @returns {HtmlNode[]} TODO
+ */ // eslint-disable-next-line no-unused-vars -- TODO
+export function querySelectorAll(node, selector) {
+	/** @type {HtmlNode[]} */
+	const nodes = [];
+
+	walk(node, n => {
+		if (n && n.type !== "element") {
+			return;
+		}
+		nodes.push(n);
+	});
+
+	return nodes;
+}
diff --git a/src/types.ts b/src/types.ts
index c7b75adf3..0e69a7d93 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -1,3 +1,8 @@
+/**
+ * @fileoverview Additional types for this package.
+ * @author Nicholas C. Zakas
+ */
+
 //------------------------------------------------------------------------------
 // Imports
 //------------------------------------------------------------------------------
@@ -59,7 +64,7 @@ type WithExit<RuleVisitorType extends RuleVisitor> = {
 };
 
 //------------------------------------------------------------------------------
-// Exports
+// Exports: Processor
 //------------------------------------------------------------------------------
 
 export interface RangeMap {
@@ -78,6 +83,72 @@ export interface Block extends Node, BlockBase {
 	meta: string | null;
 }
 
+//------------------------------------------------------------------------------
+// Exports: HTML
+//------------------------------------------------------------------------------
+
+export type HtmlNode =
+	| HtmlDocumentNode
+	| HtmlElementNode
+	| HtmlTextNode
+	| HtmlCommentNode
+	| HtmlDoctypeNode;
+
+export type HtmlNodeType =
+	| HtmlDocumentNode["type"]
+	| HtmlElementNode["type"]
+	| HtmlTextNode["type"]
+	| HtmlCommentNode["type"]
+	| HtmlDoctypeNode["type"];
+
+export interface HtmlLocation {
+	start: number;
+	end: number;
+}
+
+interface HtmlBaseNode {
+	type: HtmlNodeType;
+	loc: [HtmlLocation, HtmlLocation];
+	parent: HtmlNode;
+	[key: string]: any;
+}
+
+export interface HtmlLiteralNode extends HtmlBaseNode {
+	value: string;
+}
+
+export interface HtmlParentNode extends HtmlBaseNode {
+	children: HtmlNode[];
+}
+
+export interface HtmlDocumentNode extends Omit<HtmlParentNode, "parent"> {
+	type: "document";
+	attributes: Record<string, string>;
+	parent: undefined;
+}
+
+export interface HtmlElementNode extends HtmlParentNode {
+	type: "element";
+	name: string;
+	attributes: Record<string, string>;
+}
+
+export interface HtmlTextNode extends HtmlLiteralNode {
+	type: "text";
+}
+
+export interface HtmlCommentNode extends HtmlLiteralNode {
+	type: "comment";
+}
+
+export interface HtmlDoctypeNode extends HtmlLiteralNode {
+	type: "doctype";
+}
+
+//------------------------------------------------------------------------------
+// Exports: Front Matter
+//------------------------------------------------------------------------------
+
 /**
  * Markdown TOML.
  */
@@ -116,6 +187,10 @@ export interface Json extends Literal {
  */
 export interface JsonData extends Data {}
 
+//------------------------------------------------------------------------------
+// Exports: Markdown Language
+//------------------------------------------------------------------------------
+
 /**
  * Language options provided for Markdown files.
  */
@@ -131,6 +206,10 @@ export interface MarkdownLanguageOptions extends LanguageOptions {
  */
 export type MarkdownLanguageContext = LanguageContext<MarkdownLanguageOptions>;
 
+//------------------------------------------------------------------------------
+// Exports: Markdown Rule Definition
+//------------------------------------------------------------------------------
+
 export interface MarkdownRuleVisitor
 	extends RuleVisitor,
 		WithExit<
diff --git a/tests/html.test.js b/tests/html.test.js
new file mode 100644
index 000000000..3cc990971
--- /dev/null
+++ b/tests/html.test.js
@@ -0,0 +1,443 @@
+/**
+ * @fileoverview Tests for the html.js
+ * @author Json Miller, Nate Moore, 루밀LuMir(lumirlumir)
+ * @license MIT
+ *
+ * ---
+ *
+ * Portions of this code were borrowed from `ultrahtml` - https://github.com/natemoo-re/ultrahtml
+ *
+ * MIT License Copyright (c) 2022 Nate Moore
+ *
+ * Permission is hereby granted, free of
+ * charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ * The above copyright notice and this permission notice
+ * (including the next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ * ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+ * EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * ---
+ *
+ * Portions of this code were borrowed from `htmlParser` - https://github.com/developit/htmlParser
+ *
+ * The MIT License (MIT) Copyright (c) 2013 Jason Miller
+ *
+ * Permission is hereby granted, free of
+ * charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the
+ * following conditions:
+ * The above copyright notice and this permission notice
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ * ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+ * EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+//-----------------------------------------------------------------------------
+// Imports
+//-----------------------------------------------------------------------------
+
+import assert from "node:assert";
+import {
+	parseAttrs,
+	parse,
+	walk,
+	render,
+	querySelectorAll,
+} from "../src/html.js";
+
+//-----------------------------------------------------------------------------
+// Tests
+//-----------------------------------------------------------------------------
+
+describe("html", () => {
+	it("sanity", () => {
+		assert.strictEqual(typeof parseAttrs, "function");
+		assert.strictEqual(typeof parse, "function");
+		assert.strictEqual(typeof walk, "function");
+		assert.strictEqual(typeof render, "function");
+		assert.strictEqual(typeof querySelectorAll, "function");
+	});
+
+	describe("parseAttrs()", () => {
+		// Basic
+		it("works for empty string", () => {
+			const attrs = parseAttrs("");
+
+			assert.deepStrictEqual(attrs, {});
+		});
+		it('works for `key=""`', () => {
+			const attrs = parseAttrs('key=""');
+			assert.deepStrictEqual(attrs, { key: "" });
+		});
+		it('works for `key="value"`', () => {
+			const attrs = parseAttrs('key="value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it("works for `key=''`", () => {
+			const attrs = parseAttrs("key=''");
+			assert.deepStrictEqual(attrs, { key: "" });
+		});
+		it("works for `key='value'`", () => {
+			const attrs = parseAttrs("key='value'");
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+
+		// Empty value
+		it("works for `key`", () => {
+			const attrs = parseAttrs("key");
+
+			assert.deepStrictEqual(attrs, { key: "" });
+		});
+		it("works for `key1 key2`", () => {
+			const attrs = parseAttrs("key1 key2");
+
+			assert.deepStrictEqual(attrs, { key1: "", key2: "" });
+		});
+
+		// Leading whitespaces
+		it('works for `   key="value"`', () => {
+			const attrs = parseAttrs('   key="value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it('works for `\tkey="value"`', () => {
+			const attrs = parseAttrs('\tkey="value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it('works for `\nkey="value"`', () => {
+			const attrs = parseAttrs('\nkey="value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it('works for `\r\nkey="value"`', () => {
+			const attrs = parseAttrs('\r\nkey="value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+
+		// Trailing whitespaces
+		it('works for `key="value"   `', () => {
+			const attrs = parseAttrs('key="value"   ');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it('works for `key="value"\t`', () => {
+			const attrs = parseAttrs('key="value"\t');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it('works for `key="value"\n`', () => {
+			const attrs = parseAttrs('key="value"\n');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it('works for `key="value"\r\n`', () => {
+			const attrs = parseAttrs('key="value"\r\n');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+
+		// Leading whitespaces around the equal sign
+		it('works for `key ="value"`', () => {
+			const attrs = parseAttrs('key ="value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it('works for `key   ="value"`', () => {
+			const attrs = parseAttrs('key   ="value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it('works for `key\t="value"`', () => {
+			const attrs = parseAttrs('key\t="value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it('works for `key\n="value"`', () => {
+			const attrs = parseAttrs('key\n="value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it('works for `key\r\n="value"`', () => {
+			const attrs = parseAttrs('key\r\n="value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+
+		// Trailing whitespaces around the equal sign
+		it('works for `key= "value"`', () => {
+			const attrs = parseAttrs('key= "value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it('works for `key=   "value"`', () => {
+			const attrs = parseAttrs('key=   "value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it('works for `key=\t"value"`', () => {
+			const attrs = parseAttrs('key=\t"value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it('works for `key=\n"value"`', () => {
+			const attrs = parseAttrs('key=\n"value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+		it('works for `key=\r\n"value"`', () => {
+			const attrs = parseAttrs('key=\r\n"value"');
+
+			assert.deepStrictEqual(attrs, { key: "value" });
+		});
+	});
+
+	describe("parse(), renderSync()", () => {
+		describe("input === output", () => {
+			it("works for elements", async () => {
+				const input = `<h1>Hello world!</h1>`;
+				const ast = parse(input);
+				const output = render(ast);
+
+				assert.strictEqual(ast.type, "document");
+				assert.strictEqual(output, input);
+			});
+			it("works for custom elements", async () => {
+				const input = `<custom-element>Hello world!</custom-element>`;
+				const ast = parse(input);
+				const output = render(ast);
+
+				assert.strictEqual(ast.type, "document");
+				assert.strictEqual(output, input);
+			});
+			it("works for comments", async () => {
+				const input = `<!--foobar-->`;
+				const ast = parse(input);
+				const output = render(ast);
+
+				assert.strictEqual(ast.type, "document");
+				assert.strictEqual(output, input);
+			});
+			it("works for text", async () => {
+				const input = `Hmm...`;
+				const ast = parse(input);
+				const output = render(ast);
+
+				assert.strictEqual(ast.type, "document");
+				assert.strictEqual(output, input);
+			});
+			it("works for doctype", async () => {
+				const input = `<!DOCTYPE html>`;
+				const ast = parse(input);
+				const output = render(ast);
+
+				assert.strictEqual(ast.type, "document");
+				assert.strictEqual(output, input);
+			});
+			it("works for html:5", async () => {
+				const input = `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title></head><body></body></html>`;
+				const ast = parse(input);
+				const output = render(ast);
+
+				assert.strictEqual(ast.type, "document");
+				assert.strictEqual(output, input);
+			});
+			it("works for long inputs", async () => {
+				const input =
+					'<p>Token CSS is a new tool that seamlessly integrates <a href="https://design-tokens.github.io/community-group/format/#design-token">Design Tokens</a> into your development workflow. Conceptually, it is similar to tools <a href="https://tailwindcss.com">Tailwind</a>, <a href="https://styled-system.com/">Styled System</a>, and many CSS-in-JS libraries that provide tokenized <em>constraints</em> for your styles—but there\'s one big difference.</p>\t<h1>Hello world!</h1><p><strong>Token CSS embraces <code>.css</code> files and <code>&lt;style&gt;</code> blocks.</strong></p>';
+				const ast = parse(input);
+				const output = render(ast);
+
+				assert.strictEqual(ast.type, "document");
+				assert.strictEqual(output, input);
+			});
+		});
+
+		describe("attributes", () => {
+			it("simple", async () => {
+				const {
+					children: [{ attributes }],
+				} = parse(`<div a="b" c="1"></div>`);
+
+				assert.deepStrictEqual(attributes, { a: "b", c: "1" });
+			});
+			it("empty", async () => {
+				const {
+					children: [{ attributes }],
+				} = parse(`<div test></div>`);
+
+				assert.deepStrictEqual(attributes, { test: "" });
+			});
+			it("@", async () => {
+				const {
+					children: [{ attributes }],
+				} = parse(`<div @on.click="doThing"></div>`);
+
+				assert.deepStrictEqual(attributes, { "@on.click": "doThing" });
+			});
+			it("namespace", async () => {
+				const {
+					children: [{ attributes }],
+				} = parse(`<div on:click="alert()"></div>`);
+
+				assert.deepStrictEqual(attributes, { "on:click": "alert()" });
+			});
+			it("simple and empty", async () => {
+				const {
+					children: [{ attributes }],
+				} = parse(`<div test a="b" c="1"></div>`);
+
+				assert.deepStrictEqual(attributes, {
+					test: "",
+					a: "b",
+					c: "1",
+				});
+			});
+			it("with linebreaks", async () => {
+				const {
+					children: [{ attributes }],
+				} = parse(`<div a="1
+2
+3"></div>`);
+
+				assert.deepStrictEqual(attributes, { a: "1\n2\n3" });
+			});
+			it("with single quote", async () => {
+				const {
+					children: [{ attributes }],
+				} = parse(`<div a="nate'
+s"></div>`);
+				assert.deepStrictEqual(attributes, { a: "nate'\ns" });
+			});
+			it("with escaped double quote", async () => {
+				const {
+					children: [{ attributes }],
+				} = parse(`<div a="&quot;never
+more&quot;"></div>`);
+
+				assert.deepStrictEqual(attributes, {
+					a: "&quot;never\nmore&quot;",
+				});
+			});
+		});
+
+		describe("script", () => {
+			it("works for elements", async () => {
+				const input = `<script>console.log("Hello <name>!")</script>`;
+				const output = render(parse(input));
+
+				assert.strictEqual(output, input);
+			});
+			it("works without quotes", async () => {
+				const input = `<script>0<1>0</name></script>`;
+				const output = render(parse(input));
+
+				assert.strictEqual(output, input);
+			});
+			it("works with <script> in string", async () => {
+				const input = `<head><meta charset="utf-8"/><meta name="viewport" content="width=device-width,initial-scale=1"/><link rel="icon" href="/favicon-48x48.cbbd161b.png"/><link rel="apple-touch-icon" href="/apple-touch-icon.6803c6f0.png"/><meta name="theme-color" content="#ffffff"/><link rel="manifest" href="/manifest.56b1cedc.json"/><link rel="search" type="application/opensearchdescription+xml" href="/opensearch.xml" title="MDN Web Docs"/><script>Array.prototype.flat&&Array.prototype.includes||document.write('<script src="https://polyfill.io/v3/polyfill.min.js?features=Array.prototype.flat%2Ces6"></script>')</script><title>HTML Sanitizer API - Web APIs | MDN</title><link rel="alternate" title="HTML Sanitizer API" href="https://developer.mozilla.org/ja/docs/Web/API/HTML_Sanitizer_API" hreflang="ja"/><link rel="alternate" title="HTML Sanitizer API" href="https://developer.mozilla.org/en-US/docs/Web/API/HTML_Sanitizer_API" hreflang="en"/><meta name="robots" content="index, follow"><meta name="description" content="The HTML Sanitizer API allow developers to take untrusted strings of HTML and Document or DocumentFragment objects, and sanitize them for safe insertion into a document&apos;s DOM."/><meta property="og:url" content="https://developer.mozilla.org/en-US/docs/Web/API/HTML_Sanitizer_API"/><meta property="og:title" content="HTML Sanitizer API - Web APIs | MDN"/><meta property="og:locale" content="en-US"/><meta property="og:description" content="The HTML Sanitizer API allow developers to take untrusted strings of HTML and Document or DocumentFragment objects, and sanitize them for safe insertion into a document&apos;s DOM."/><meta property="og:image" content="https://developer.mozilla.org/mdn-social-share.cd6c4a5a.png"/><meta property="twitter:card" content="summary_large_image"/><link rel="canonical" href="https://developer.mozilla.org/en-US/docs/Web/API/HTML_Sanitizer_API"/><style media="print">.breadcrumbs-container,.document-toc-container,.language-menu,.on-github,.page-footer,.top-navigation-main,nav.sidebar,ul.prev-next{display:none!important}.main-page-content,.main-page-content pre{padding:2px}.main-page-content pre{border-left-width:2px}</style><script src="/static/js/ga.js" defer=""></script><script defer="defer" src="/static/js/main.bfba1cdc.js"></script><link href="/static/css/main.7fcd0907.css" rel="stylesheet">`;
+				let meta = 0;
+				walk(parse(input), async (node, parent) => {
+					if (
+						node.type === "element" &&
+						node.name === "meta" &&
+						parent?.name === "head"
+					) {
+						meta++;
+					}
+				});
+
+				assert.strictEqual(meta, 11);
+			});
+			it("works with <script> inside script", async () => {
+				const input = `<script>const a = "<script>"</script>`;
+				const output = render(parse(input));
+
+				assert.strictEqual(output, input);
+			});
+			it("works with <any> inside script", async () => {
+				const input = `<script>const a = "<any>"</script>`;
+				const output = render(parse(input));
+
+				assert.strictEqual(output, input);
+			});
+			it("works with <\\/script> inside script", async () => {
+				const input = `<script>const a = "<\\/script>"</script>`;
+				const output = render(parse(input));
+
+				assert.strictEqual(output, input);
+			});
+		});
+
+		describe("style", () => {
+			it("works for elements", async () => {
+				const input = `<style><name></name><foo></style>`;
+				const output = render(parse(input));
+
+				assert.strictEqual(output, input);
+			});
+			it("works without quotes", async () => {
+				const input = `<style>0>1</name></style>`;
+				const output = render(parse(input));
+
+				assert.strictEqual(output, input);
+			});
+		});
+
+		describe("svg", () => {
+			it("renderSync as self-closing", async () => {
+				const input = `<svg><path d="0 0 0" /></svg>`;
+				const output = render(parse(input));
+
+				assert.strictEqual(output, input);
+			});
+		});
+	});
+
+	describe("querySelector()", () => {
+		describe("type selector", () => {
+			it("type", async () => {
+				const input = `<h1>Hello world!</h1>`;
+				const output = render(querySelectorAll(parse(input), "h1")[0]);
+
+				assert.strictEqual(output, input);
+			});
+		});
+
+		/*
+
+		describe("id selector", () => {
+			it("id", async () => {
+				const input = `<h1 id="foo">Hello world!</h1>`;
+				const output = renderSync(querySelectorAll(parse(input), "#foo")[0]);
+				expect(output).toEqual(input);
+			});
+		});
+
+		*/
+	});
+});