diff --git a/deno.json b/deno.json
index d0ee3b9..cf8e7f4 100644
--- a/deno.json
+++ b/deno.json
@@ -1,6 +1,6 @@
 {
   "name": "@dbushell/hyperless",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "exports": {
     ".": "./mod.ts"
   },
diff --git a/mod.ts b/mod.ts
index 55de15b..237e413 100644
--- a/mod.ts
+++ b/mod.ts
@@ -1,12 +1,12 @@
-export {escape, unescape} from './src/html-utils.ts';
-export {inlineTags, opaqueTags, voidTags} from './src/html-tags.ts';
-export {AttributeMap} from './src/attribute-map.ts';
-export {parseAttributes} from './src/attribute-parser.ts';
-export {Node} from './src/html-node.ts';
+export { escape, unescape } from "./src/html-utils.ts";
+export { inlineTags, opaqueTags, voidTags } from "./src/html-tags.ts";
+export { AttributeMap } from "./src/attribute-map.ts";
+export { parseAttributes } from "./src/attribute-parser.ts";
+export { Node } from "./src/html-node.ts";
 export {
-  type ParseOptions,
   getParseOptions,
-  parseHTML
-} from './src/html-parser.ts';
-export {excerpt} from './src/excerpt.ts';
-export {stripTags} from './src/striptags.ts';
+  parseHTML,
+  type ParseOptions,
+} from "./src/html-parser.ts";
+export { excerpt } from "./src/excerpt.ts";
+export { stripTags } from "./src/striptags.ts";
diff --git a/package.json b/package.json
index b909f44..d17c41a 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@dbushell/hyperless",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/dbushell/hyperless.git"
diff --git a/src/attribute-map.ts b/src/attribute-map.ts
index 46171b2..c52b50b 100644
--- a/src/attribute-map.ts
+++ b/src/attribute-map.ts
@@ -1,4 +1,4 @@
-import {escape, unescape} from './html-utils.ts';
+import { escape, unescape } from "./html-utils.ts";
 
 /**
  * HTML attributes map
@@ -7,12 +7,12 @@ import {escape, unescape} from './html-utils.ts';
  */
 export class AttributeMap extends Map<string, string> {
   constructor(
-    iterable?: Iterable<readonly [string, string]> | null | undefined
+    iterable?: Iterable<readonly [string, string]> | null | undefined,
   ) {
     super(
       iterable instanceof AttributeMap
         ? Array.from(iterable, ([k, v]) => [k, escape(v)])
-        : iterable
+        : iterable,
     );
   }
   override [Symbol.iterator](): MapIterator<[string, string]> {
@@ -49,7 +49,7 @@ export class AttributeMap extends Map<string, string> {
   }
   override forEach(
     callbackfn: (value: string, key: string, map: Map<string, string>) => void,
-    thisArg?: unknown
+    thisArg?: unknown,
   ): void {
     super.forEach((value, key, map) =>
       callbackfn.call(thisArg, unescape(value), key, map)
@@ -58,8 +58,8 @@ export class AttributeMap extends Map<string, string> {
   override toString(): string {
     const entries = Array.from(super.entries());
     const attr = entries.map(([k, v]) =>
-      v === '' ? k : v.indexOf('"') === -1 ? `${k}="${v}"` : `${k}='${v}'`
+      v === "" ? k : v.indexOf('"') === -1 ? `${k}="${v}"` : `${k}='${v}'`
     );
-    return attr.join(' ');
+    return attr.join(" ");
   }
 }
diff --git a/src/attribute-parser.ts b/src/attribute-parser.ts
index fa0ec25..809f15d 100644
--- a/src/attribute-parser.ts
+++ b/src/attribute-parser.ts
@@ -2,22 +2,22 @@
  * Parse HTML Attributes
  * {@link https://html.spec.whatwg.org/#before-attribute-name-state}
  */
-import {AttributeMap} from './attribute-map.ts';
+import { AttributeMap } from "./attribute-map.ts";
 import {
+  ASCII_WHITESPACE,
   INVALID_ATTRIBUTE_NAME,
   INVALID_ATTRIBUTE_VALUE,
-  ASCII_WHITESPACE
-} from './constants.ts';
+} from "./constants.ts";
 
 /** Attribute parser state */
 type ParseState =
-  | 'BEFORE_NAME'
-  | 'NAME'
-  | 'AFTER_NAME'
-  | 'BEFORE_VALUE'
-  | 'DOUBLE_QUOTED'
-  | 'SINGLE_QUOTED'
-  | 'UNQUOTED';
+  | "BEFORE_NAME"
+  | "NAME"
+  | "AFTER_NAME"
+  | "BEFORE_VALUE"
+  | "DOUBLE_QUOTED"
+  | "SINGLE_QUOTED"
+  | "UNQUOTED";
 
 /**
  * Return a map of HTML attributes
@@ -27,88 +27,88 @@ type ParseState =
 export const parseAttributes = (attributes: string): AttributeMap => {
   const map: AttributeMap = new AttributeMap();
 
-  let state: ParseState = 'BEFORE_NAME';
-  let name = '';
-  let value = '';
+  let state: ParseState = "BEFORE_NAME";
+  let name = "";
+  let value = "";
 
   for (let i = 0; i < attributes.length; i++) {
     const char = attributes[i];
     // Handle case where closing HTML tag is included to avoid error
-    if (state === 'BEFORE_NAME' || state === 'NAME' || state === 'UNQUOTED') {
-      if (char === '/' || char === '>') {
+    if (state === "BEFORE_NAME" || state === "NAME" || state === "UNQUOTED") {
+      if (char === "/" || char === ">") {
         break;
       }
     }
     switch (state) {
-      case 'BEFORE_NAME':
+      case "BEFORE_NAME":
         if (ASCII_WHITESPACE.has(char)) {
           continue;
         } else if (INVALID_ATTRIBUTE_NAME.has(char)) {
           throw new Error(`Invalid attribute name at character ${i}`);
         }
         name = char;
-        value = '';
-        state = 'NAME';
+        value = "";
+        state = "NAME";
         continue;
-      case 'NAME':
-        if (char === '=') {
-          state = 'BEFORE_VALUE';
+      case "NAME":
+        if (char === "=") {
+          state = "BEFORE_VALUE";
         } else if (ASCII_WHITESPACE.has(char)) {
-          state = 'AFTER_NAME';
+          state = "AFTER_NAME";
         } else if (INVALID_ATTRIBUTE_NAME.has(char)) {
           throw new Error(`invalid name at ${i}`);
         } else {
           name += char;
         }
         continue;
-      case 'AFTER_NAME':
-        if (char === '=') {
-          state = 'BEFORE_VALUE';
+      case "AFTER_NAME":
+        if (char === "=") {
+          state = "BEFORE_VALUE";
         } else if (ASCII_WHITESPACE.has(char) === false) {
           // End of empty attribute
-          map.set(name, '');
+          map.set(name, "");
           // Rewind state to match new name
           i--;
-          state = 'BEFORE_NAME';
+          state = "BEFORE_NAME";
         }
         continue;
-      case 'BEFORE_VALUE':
+      case "BEFORE_VALUE":
         if (char === "'") {
-          state = 'SINGLE_QUOTED';
+          state = "SINGLE_QUOTED";
         } else if (char === '"') {
-          state = 'DOUBLE_QUOTED';
+          state = "DOUBLE_QUOTED";
         } else if (ASCII_WHITESPACE.has(char)) {
           continue;
         } else if (INVALID_ATTRIBUTE_VALUE.has(char)) {
           throw new Error(`Invalid unquoted attribute value at character ${i}`);
         } else {
           value += char;
-          state = 'UNQUOTED';
+          state = "UNQUOTED";
         }
         continue;
-      case 'DOUBLE_QUOTED':
+      case "DOUBLE_QUOTED":
         if (char === '"') {
           // End of double quoted attribute
           map.set(name, value);
-          state = 'BEFORE_NAME';
+          state = "BEFORE_NAME";
         } else {
           value += char;
         }
         continue;
-      case 'SINGLE_QUOTED':
+      case "SINGLE_QUOTED":
         if (char === "'") {
           // End of single quoted attribute
           map.set(name, value);
-          state = 'BEFORE_NAME';
+          state = "BEFORE_NAME";
         } else {
           value += char;
         }
         continue;
-      case 'UNQUOTED':
+      case "UNQUOTED":
         if (ASCII_WHITESPACE.has(char)) {
           // End of unquoted attribute
           map.set(name, value);
-          state = 'BEFORE_NAME';
+          state = "BEFORE_NAME";
         } else if (INVALID_ATTRIBUTE_VALUE.has(char)) {
           throw new Error(`Invalid unquoted attribute value at character ${i}`);
         } else {
@@ -119,10 +119,10 @@ export const parseAttributes = (attributes: string): AttributeMap => {
   }
   // Handle end state
   switch (state) {
-    case 'NAME':
-      map.set(name, '');
+    case "NAME":
+      map.set(name, "");
       break;
-    case 'UNQUOTED':
+    case "UNQUOTED":
       map.set(name, value);
       break;
   }
diff --git a/src/constants.ts b/src/constants.ts
index e5d2258..429dd37 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -3,11 +3,11 @@
  * {@link https://infra.spec.whatwg.org/#ascii-whitespace}
  */
 export const ASCII_WHITESPACE = new Set([
-  '\t', // U+0009 TAB
-  '\n', // U+000A LF (Line Feed)
-  '\f', // U+000C FF (Form Feed)
-  '\r', // U+000D CR (Carriage Return)
-  ' ' // U+0020 SPACE
+  "\t", // U+0009 TAB
+  "\n", // U+000A LF (Line Feed)
+  "\f", // U+000C FF (Form Feed)
+  "\r", // U+000D CR (Carriage Return)
+  " ", // U+0020 SPACE
 ]);
 
 /**
@@ -36,10 +36,10 @@ export const INVALID_ATTRIBUTE_NAME = new Set(CONTROLS);
 [
   '"', // U+0022 Quotation Mark
   "'", // U+0027 Apostrophe
-  '=', // U+003D Equals Sign
-  '>', // U+003C Less-Than Sign
-  '<', // U+003E Greater-Than Sign
-  '/' // U+002F Solidus
+  "=", // U+003D Equals Sign
+  ">", // U+003C Less-Than Sign
+  "<", // U+003E Greater-Than Sign
+  "/", // U+002F Solidus
 ].forEach((char) => INVALID_ATTRIBUTE_NAME.add(char));
 
 /**
@@ -48,5 +48,5 @@ export const INVALID_ATTRIBUTE_NAME = new Set(CONTROLS);
  */
 export const INVALID_ATTRIBUTE_VALUE = new Set(INVALID_ATTRIBUTE_NAME);
 [
-  '`' // U+0060 Grave Accent
+  "`", // U+0060 Grave Accent
 ].forEach((char) => INVALID_ATTRIBUTE_VALUE.add(char));
diff --git a/src/excerpt.ts b/src/excerpt.ts
index c600a59..c609b88 100644
--- a/src/excerpt.ts
+++ b/src/excerpt.ts
@@ -1,4 +1,4 @@
-import {stripTags} from './striptags.ts';
+import { stripTags } from "./striptags.ts";
 
 /**
  * Generate a text excerpt from HTML content.
@@ -14,8 +14,8 @@ import {stripTags} from './striptags.ts';
 export const excerpt = (
   html: string,
   maxLength = 300,
-  trunateSuffix = '[…]',
-  endChars = ['.', '!', '?']
+  trunateSuffix = "[…]",
+  endChars = [".", "!", "?"],
 ): string => {
   // Remove HTML
   const text = stripTags(html);
@@ -31,11 +31,11 @@ export const excerpt = (
     const excerpt = text.substring(0, offsets.at(-1)! + 1);
     // Ensure excerpt is not too short
     if (maxLength - excerpt.length < maxLength * 0.2) {
-      return (excerpt + ' ' + trunateSuffix).trim();
+      return (excerpt + " " + trunateSuffix).trim();
     }
   }
   // Fallback to using words
-  let excerpt = '';
+  let excerpt = "";
   const words = text.split(/\s+/);
   while (words.length) {
     // Concatenate words until maximum length is reached
@@ -43,7 +43,7 @@ export const excerpt = (
     if (excerpt.length + word.length > maxLength) {
       break;
     }
-    excerpt += word + ' ';
+    excerpt += word + " ";
   }
   return (excerpt + trunateSuffix).trim();
 };
diff --git a/src/html-node.ts b/src/html-node.ts
index 7c5adde..a91a8ed 100644
--- a/src/html-node.ts
+++ b/src/html-node.ts
@@ -1,20 +1,20 @@
-import {AttributeMap} from './attribute-map.ts';
-import {parseAttributes} from './attribute-parser.ts';
-import {anyTag} from './regexp.ts';
+import { AttributeMap } from "./attribute-map.ts";
+import { parseAttributes } from "./attribute-parser.ts";
+import { anyTag } from "./regexp.ts";
 
 /** Node.type values */
 export type NodeType =
-  | 'COMMENT'
-  | 'ELEMENT'
-  | 'INVISIBLE'
-  | 'OPAQUE'
-  | 'ROOT'
-  | 'STRAY'
-  | 'TEXT'
-  | 'VOID';
+  | "COMMENT"
+  | "ELEMENT"
+  | "INVISIBLE"
+  | "OPAQUE"
+  | "ROOT"
+  | "STRAY"
+  | "TEXT"
+  | "VOID";
 
 /** Node has open/close tags */
-const renderTypes = new Set(['ELEMENT', 'OPAQUE', 'VOID']);
+const renderTypes = new Set(["ELEMENT", "OPAQUE", "VOID"]);
 
 /**
  * HTML node
@@ -29,10 +29,10 @@ export class Node {
 
   constructor(
     parent: Node | null = null,
-    type: NodeType = 'TEXT',
-    raw = '',
-    tag = '',
-    attributes?: AttributeMap
+    type: NodeType = "TEXT",
+    raw = "",
+    tag = "",
+    attributes?: AttributeMap,
   ) {
     parent?.append(this);
     this.type = type;
@@ -45,8 +45,8 @@ export class Node {
   get attributes(): AttributeMap {
     // Parse on first request for performance
     if (this.#attributes === undefined) {
-      const match = this.raw.match(new RegExp(anyTag.source, 's'));
-      this.#attributes = parseAttributes(match?.[2] ?? '');
+      const match = this.raw.match(new RegExp(anyTag.source, "s"));
+      this.#attributes = parseAttributes(match?.[2] ?? "");
     }
     return this.#attributes;
   }
@@ -80,7 +80,7 @@ export class Node {
     let depth = 0;
     let parent = this.parent;
     while (parent) {
-      if (parent.type !== 'INVISIBLE') depth++;
+      if (parent.type !== "INVISIBLE") depth++;
       parent = parent.parent;
     }
     return depth;
@@ -109,21 +109,21 @@ export class Node {
   /** Formatted opening tag with parsed attributes */
   get tagOpen(): string {
     if (renderTypes.has(this.type) === false) {
-      return '';
+      return "";
     }
-    let out = '<' + this.tag;
+    let out = "<" + this.tag;
     const attr = this.attributes.toString();
-    if (attr.length) out += ' ' + attr;
-    if (this.type === 'VOID') out += '/';
-    return out + '>';
+    if (attr.length) out += " " + attr;
+    if (this.type === "VOID") out += "/";
+    return out + ">";
   }
 
   /** Formatted closing tag */
   get tagClose(): string {
-    if (renderTypes.has(this.type) && this.type !== 'VOID') {
+    if (renderTypes.has(this.type) && this.type !== "VOID") {
       return `</${this.tag}>`;
     }
-    return '';
+    return "";
   }
 
   /** Append one or more child nodes */
@@ -148,7 +148,7 @@ export class Node {
       this.type,
       this.raw,
       this.#tag,
-      this.#attributes
+      this.#attributes,
     );
     if (deep) {
       for (const child of this.children) {
@@ -231,13 +231,13 @@ export class Node {
 
   /** Render node to HTML string */
   toString(): string {
-    if (this.type === 'COMMENT') return '';
-    if (this.type === 'STRAY') return '';
+    if (this.type === "COMMENT") return "";
+    if (this.type === "STRAY") return "";
     let out = this.tagOpen || this.raw;
     for (const node of this.#children) {
       out += node.toString();
     }
-    out += this.tagClose ?? '';
+    out += this.tagClose ?? "";
     return out;
   }
 }
diff --git a/src/html-parser.ts b/src/html-parser.ts
index da4423f..60e8b12 100644
--- a/src/html-parser.ts
+++ b/src/html-parser.ts
@@ -1,15 +1,15 @@
-import {Node} from './html-node.ts';
-import {inlineTags, opaqueTags, voidTags} from './html-tags.ts';
-import {anyTag, comment, customName} from './regexp.ts';
+import { Node } from "./html-node.ts";
+import { inlineTags, opaqueTags, voidTags } from "./html-tags.ts";
+import { anyTag, comment, customName } from "./regexp.ts";
 
 /** Regular expression to match HTML comment or tag */
 const commentTag = new RegExp(`^${comment.source}|^${anyTag.source}`);
 
 /** List of valid <li> parents */
-const listTags = new Set(['ol', 'ul', 'menu']);
+const listTags = new Set(["ol", "ul", "menu"]);
 
 /** HTML parser state */
-type ParseState = 'DATA' | 'RAWTEXT';
+type ParseState = "DATA" | "RAWTEXT";
 
 /** `parseHTML` configuration */
 export type ParseOptions = {
@@ -20,10 +20,10 @@ export type ParseOptions = {
 };
 
 export const getParseOptions = (): ParseOptions => ({
-  rootTag: 'html',
+  rootTag: "html",
   inlineTags: new Set(inlineTags),
   opaqueTags: new Set(opaqueTags),
-  voidTags: new Set(voidTags)
+  voidTags: new Set(voidTags),
 });
 
 const parseOptions: ParseOptions = getParseOptions();
@@ -35,18 +35,18 @@ const parseOptions: ParseOptions = getParseOptions();
  */
 export const parseHTML = (html: string, options = parseOptions): Node => {
   // Create current parent node
-  const root = new Node(null, 'ROOT', '', options.rootTag);
+  const root = new Node(null, "ROOT", "", options.rootTag);
   let parent = root;
-  let state: ParseState = 'DATA';
+  let state: ParseState = "DATA";
   // Start at first potential tag
-  let offset = html.indexOf('<');
+  let offset = html.indexOf("<");
 
   // Check if <p> element was not closed
   const closeParagraph = (nextTag: string, previousTag: string): boolean => {
     if (customName.test(nextTag)) return false;
     return (
-      nextTag !== 'p' &&
-      previousTag === 'p' &&
+      nextTag !== "p" &&
+      previousTag === "p" &&
       options.inlineTags.has(nextTag) === false
     );
   };
@@ -57,10 +57,10 @@ export const parseHTML = (html: string, options = parseOptions): Node => {
       // Get the text skipped
       const text = html.substring(0, offset);
       // In RAWTEXT state text is concatenated otherwise append a text node
-      if (state === 'RAWTEXT') {
+      if (state === "RAWTEXT") {
         (parent.at(0) ?? parent).raw += text;
       } else {
-        parent.append(new Node(parent, 'TEXT', text));
+        parent.append(new Node(parent, "TEXT", text));
       }
       // Reset offset and data to parse
       html = html.substring(offset);
@@ -70,7 +70,7 @@ export const parseHTML = (html: string, options = parseOptions): Node => {
     // Match next HTML comment or tag
     const tag = html.match(commentTag);
     if (tag === null) {
-      offset = html.substring(1).indexOf('<');
+      offset = html.substring(1).indexOf("<");
       // Add one to account for substring if found
       if (offset >= 0) offset += 1;
       // Next iteration ends if no tag was found
@@ -79,62 +79,57 @@ export const parseHTML = (html: string, options = parseOptions): Node => {
 
     // Matched tag parts
     const tagText = tag[0];
-    const tagRaw = tag[1] ?? '';
+    const tagRaw = tag[1] ?? "";
     const tagName = tagRaw.toLowerCase();
 
-    if (state === 'RAWTEXT') {
+    if (state === "RAWTEXT") {
       // Switch state if closing tag matches
-      if (tagName === parent.tag && tagText.startsWith('</')) {
+      if (tagName === parent.tag && tagText.startsWith("</")) {
         if (parent.parent === null) {
           throw new Error();
         }
         parent.raw += `</${parent.tag}>`;
         parent = parent.parent;
-        state = 'DATA';
+        state = "DATA";
       } else {
         (parent.at(0) ?? parent).raw += tagText;
       }
-    }
-    // Append comment
+    } // Append comment
     else if (tagText.startsWith(`<!--`)) {
-      parent.append(new Node(parent, 'COMMENT', tagText, tagRaw));
-    }
-    // Append self-closing and void tags
-    else if (options.voidTags.has(tagName) || tagText.endsWith('/>')) {
+      parent.append(new Node(parent, "COMMENT", tagText, tagRaw));
+    } // Append self-closing and void tags
+    else if (options.voidTags.has(tagName) || tagText.endsWith("/>")) {
       // Close unclosed <p> first
       if (closeParagraph(tagName, parent.tag)) {
         parent = parent.parent ?? parent;
       }
-      parent.append(new Node(parent, 'VOID', tagText, tagRaw));
-    }
-    // Append closing tag and descend
-    else if (tagText.startsWith('</')) {
+      parent.append(new Node(parent, "VOID", tagText, tagRaw));
+    } // Append closing tag and descend
+    else if (tagText.startsWith("</")) {
       // Close unclosed <p> first
       if (closeParagraph(tagName, parent.tag)) {
         parent = parent.parent ?? parent;
       }
       if (parent.parent === null) {
-        parent.append(new Node(parent, 'STRAY', tagText, tagRaw));
+        parent.append(new Node(parent, "STRAY", tagText, tagRaw));
       } else {
         parent = parent.parent;
       }
-    }
-    // Append opaque tag and change state
+    } // Append opaque tag and change state
     else if (options.opaqueTags.has(tagName)) {
-      const node = new Node(parent, 'OPAQUE', tagText, tagRaw);
-      const text = new Node(node, 'TEXT');
+      const node = new Node(parent, "OPAQUE", tagText, tagRaw);
+      const text = new Node(node, "TEXT");
       node.append(text);
       parent.append(node);
       parent = node;
-      state = 'RAWTEXT';
-    }
-    // Append opening tag and ascend
+      state = "RAWTEXT";
+    } // Append opening tag and ascend
     else {
-      const node = new Node(null, 'ELEMENT', tagText, tagRaw);
+      const node = new Node(null, "ELEMENT", tagText, tagRaw);
       // Close unclosed <li> if new <li> item is found
       if (
-        node.tag === 'li' &&
-        parent.tag === 'li' &&
+        node.tag === "li" &&
+        parent.tag === "li" &&
         listTags.has(parent.parent?.tag!)
       ) {
         parent = parent.parent!;
@@ -142,7 +137,7 @@ export const parseHTML = (html: string, options = parseOptions): Node => {
       // Close unclosed <p> before new element
       if (
         closeParagraph(tagName, parent.tag) ||
-        (tagName === 'p' && parent.tag === 'p')
+        (tagName === "p" && parent.tag === "p")
       ) {
         parent = parent.parent ?? parent;
       }
@@ -152,11 +147,11 @@ export const parseHTML = (html: string, options = parseOptions): Node => {
 
     // Skip ahead to next potential tag
     html = html.substring(tagText.length);
-    offset = html.indexOf('<');
+    offset = html.indexOf("<");
   }
   // Append leftover text
   if (html.length) {
-    parent.append(new Node(parent, 'TEXT', html));
+    parent.append(new Node(parent, "TEXT", html));
   }
   // Return node tree
   return root;
diff --git a/src/html-tags.ts b/src/html-tags.ts
index 5557146..7cd7a69 100644
--- a/src/html-tags.ts
+++ b/src/html-tags.ts
@@ -3,126 +3,126 @@
  * {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element#inline_text_semantics}
  */
 export const inlineTags: Set<string> = new Set([
-  'a',
-  'abbr',
-  'b',
-  'bdi',
-  'bdo',
-  'br',
-  'button',
-  'cite',
-  'code',
-  'data',
-  'del',
-  'dfn',
-  'em',
-  'i',
-  'input',
-  'ins',
-  'img',
-  'kbd',
-  'label',
-  'mark',
-  'meter',
-  'output',
-  'progress',
-  'q',
-  'rp',
-  'rt',
-  'ruby',
-  's',
-  'samp',
-  'select',
-  'small',
-  'span',
-  'strong',
-  'sub',
-  'sup',
-  'textarea',
-  'time',
-  'u',
-  'var',
-  'wbr'
+  "a",
+  "abbr",
+  "b",
+  "bdi",
+  "bdo",
+  "br",
+  "button",
+  "cite",
+  "code",
+  "data",
+  "del",
+  "dfn",
+  "em",
+  "i",
+  "input",
+  "ins",
+  "img",
+  "kbd",
+  "label",
+  "mark",
+  "meter",
+  "output",
+  "progress",
+  "q",
+  "rp",
+  "rt",
+  "ruby",
+  "s",
+  "samp",
+  "select",
+  "small",
+  "span",
+  "strong",
+  "sub",
+  "sup",
+  "textarea",
+  "time",
+  "u",
+  "var",
+  "wbr",
 ]);
 /**
  * Complete list of HTML elements (excluding inline)
  * {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element}
  */
 export const blockTags: Set<string> = new Set([
-  'address',
-  'area',
-  'article',
-  'aside',
-  'audio',
-  'base',
-  'blockquote',
-  'body',
-  'canvas',
-  'caption',
-  'col',
-  'colgroup',
-  'datalist',
-  'dd',
-  'details',
-  'dialog',
-  'div',
-  'dl',
-  'dt',
-  'embed',
-  'fieldset',
-  'figcaption',
-  'figure',
-  'footer',
-  'form',
-  'h1',
-  'h2',
-  'h3',
-  'h4',
-  'h5',
-  'h6',
-  'head',
-  'header',
-  'hgroup',
-  'hr',
-  'html',
-  'iframe',
-  'legend',
-  'li',
-  'link',
-  'main',
-  'map',
-  'menu',
-  'meta',
-  'nav',
-  'noscript',
-  'object',
-  'ol',
-  'optgroup',
-  'option',
-  'p',
-  'param',
-  'picture',
-  'pre',
-  'script',
-  'search',
-  'section',
-  'slot',
-  'source',
-  'style',
-  'summary',
-  'svg',
-  'table',
-  'tbody',
-  'td',
-  'template',
-  'tfoot',
-  'th',
-  'thead',
-  'title',
-  'tr',
-  'track',
-  'ul',
-  'video'
+  "address",
+  "area",
+  "article",
+  "aside",
+  "audio",
+  "base",
+  "blockquote",
+  "body",
+  "canvas",
+  "caption",
+  "col",
+  "colgroup",
+  "datalist",
+  "dd",
+  "details",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "iframe",
+  "legend",
+  "li",
+  "link",
+  "main",
+  "map",
+  "menu",
+  "meta",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "p",
+  "param",
+  "picture",
+  "pre",
+  "script",
+  "search",
+  "section",
+  "slot",
+  "source",
+  "style",
+  "summary",
+  "svg",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "tfoot",
+  "th",
+  "thead",
+  "title",
+  "tr",
+  "track",
+  "ul",
+  "video",
 ]);
 
 /**
@@ -130,20 +130,20 @@ export const blockTags: Set<string> = new Set([
  * {@link https://developer.mozilla.org/en-US/docs/Glossary/Void_element}
  */
 export const voidTags: Set<string> = new Set([
-  'area',
-  'base',
-  'br',
-  'col',
-  'embed',
-  'hr',
-  'img',
-  'input',
-  'link',
-  'meta',
-  'param',
-  'source',
-  'track',
-  'wbr'
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr",
 ]);
 
 /**
@@ -151,42 +151,42 @@ export const voidTags: Set<string> = new Set([
  * {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element#obsolete_and_deprecated_elements}
  */
 export const obsoleteTags: Set<string> = new Set([
-  'acronym',
-  'big',
-  'center',
-  'content',
-  'dir',
-  'font',
-  'frame',
-  'frameset',
-  'image',
-  'marquee',
-  'menuitem',
-  'nobr',
-  'noembed',
-  'noframes',
-  'param',
-  'plaintext',
-  'rb',
-  'rtc',
-  'shadow',
-  'strike',
-  'tt',
-  'xmp'
+  "acronym",
+  "big",
+  "center",
+  "content",
+  "dir",
+  "font",
+  "frame",
+  "frameset",
+  "image",
+  "marquee",
+  "menuitem",
+  "nobr",
+  "noembed",
+  "noframes",
+  "param",
+  "plaintext",
+  "rb",
+  "rtc",
+  "shadow",
+  "strike",
+  "tt",
+  "xmp",
 ]);
 
 /**
  * List of HTML elements to avoid parsing inside
  */
 export const opaqueTags: Set<string> = new Set([
-  'code',
-  'iframe',
-  'math',
-  'object',
-  'pre',
-  'script',
-  'style',
-  'svg',
-  'template',
-  'textarea'
+  "code",
+  "iframe",
+  "math",
+  "object",
+  "pre",
+  "script",
+  "style",
+  "svg",
+  "template",
+  "textarea",
 ]);
diff --git a/src/html-utils.ts b/src/html-utils.ts
index e00b1de..6861983 100644
--- a/src/html-utils.ts
+++ b/src/html-utils.ts
@@ -1,16 +1,16 @@
 const entities = new Map([
-  ['&', '&amp;'],
-  ['<', '&lt;'],
-  ['>', '&gt;'],
-  ['"', '&quot;'],
-  ["'", '&#39;']
+  ["&", "&amp;"],
+  ["<", "&lt;"],
+  [">", "&gt;"],
+  ['"', "&quot;"],
+  ["'", "&#39;"],
 ]);
 
 const encodes = new Map(Array.from(entities, ([k, v]) => [v, k]));
 
-const entityKeys = new RegExp([...entities.keys()].join('|'), 'g');
+const entityKeys = new RegExp([...entities.keys()].join("|"), "g");
 
-const encodedKeys = new RegExp([...encodes.keys()].join('|'), 'g');
+const encodedKeys = new RegExp([...encodes.keys()].join("|"), "g");
 
 /** Escape HTML entities */
 export const escape = (str: string): string =>
diff --git a/src/regexp.ts b/src/regexp.ts
index f9a34a1..d83af66 100644
--- a/src/regexp.ts
+++ b/src/regexp.ts
@@ -39,4 +39,4 @@ export const anyTag = new RegExp(`</?${tagName.source}([^>]*)/?>`);
  * Regular expression to match full tag with inner content
  * This is non-greedy and cannot handle nested tags of the same name
  */
-export const fullTag = new RegExp(`(<${tagName.source}[^>]*>)(.*?)</\\2>`, 's');
+export const fullTag = new RegExp(`(<${tagName.source}[^>]*>)(.*?)</\\2>`, "s");
diff --git a/src/striptags.ts b/src/striptags.ts
index 70c58ca..afaa6c4 100644
--- a/src/striptags.ts
+++ b/src/striptags.ts
@@ -1,22 +1,22 @@
-import {inlineTags} from './html-tags.ts';
-import {comment, fullTag, anyTag} from './regexp.ts';
+import { inlineTags } from "./html-tags.ts";
+import { anyTag, comment, fullTag } from "./regexp.ts";
 
 /** Match any remaining HTML comments or tags */
 const otherTags = new RegExp(`${comment.source}|${anyTag.source}`);
 
 /** Bespoke list of elements to remove with their content */
 const removeTags = new Set([
-  'audio',
-  'canvas',
-  'figure',
-  'form',
-  'iframe',
-  'picture',
-  'pre',
-  'script',
-  'style',
-  'table',
-  'video'
+  "audio",
+  "canvas",
+  "figure",
+  "form",
+  "iframe",
+  "picture",
+  "pre",
+  "script",
+  "style",
+  "table",
+  "video",
 ]);
 
 /**
@@ -32,25 +32,25 @@ export const stripTags = (html: string, depth = 0): string => {
   // Find open and close tags
   let match: RegExpMatchArray | null;
   while ((match = html.match(fullTag))) {
-    let {0: search, 2: tag, 3: text} = match;
+    let { 0: search, 2: tag, 3: text } = match;
     // Remove entire element
     if (removeTags.has(tag)) {
-      html = html.replace(search, () => '');
+      html = html.replace(search, () => "");
       continue;
     }
     // Wrap quote in alternating typographic style
-    if (['blockquote', 'q'].includes(tag)) {
-      const quotes = depth % 2 ? '‘’' : '“”';
+    if (["blockquote", "q"].includes(tag)) {
+      const quotes = depth % 2 ? "‘’" : "“”";
       const innerText = stripTags(text, depth + 1).trim();
       text = quotes[0] + innerText + quotes[1];
     }
     // Remove tags and keep content
     const inline = inlineTags.has(tag);
-    html = html.replace(search, () => text + (inline ? '' : ' '));
+    html = html.replace(search, () => text + (inline ? "" : " "));
   }
   // Remove everthing else
   while ((match = html.match(otherTags))) {
-    html = html.replace(match[0], () => '');
+    html = html.replace(match[0], () => "");
   }
   return html;
 };
diff --git a/test/attributes_test.ts b/test/attributes_test.ts
index 9ee045a..6a5c48d 100644
--- a/test/attributes_test.ts
+++ b/test/attributes_test.ts
@@ -1,131 +1,131 @@
-import {AttributeMap} from '../src/attribute-map.ts';
-import {parseAttributes} from '../src/attribute-parser.ts';
-import {anyTag} from '../src/regexp.ts';
-import {assertEquals, assertObjectMatch} from 'jsr:@std/assert';
+import { AttributeMap } from "../src/attribute-map.ts";
+import { parseAttributes } from "../src/attribute-parser.ts";
+import { anyTag } from "../src/regexp.ts";
+import { assertEquals, assertObjectMatch } from "jsr:@std/assert";
 
 /** Get unparsed attributes from the first HTML tag */
 const getTagAttributes = (html: string): string => {
-  const tagMatch = html.trim().match(new RegExp(anyTag.source, 's'));
-  return tagMatch?.[2] ?? '';
+  const tagMatch = html.trim().match(new RegExp(anyTag.source, "s"));
+  return tagMatch?.[2] ?? "";
 };
 
-Deno.test('single (pair)', () => {
+Deno.test("single (pair)", () => {
   const html = '<div data-test="test123">';
   const expected = {
-    'data-test': 'test123'
+    "data-test": "test123",
   };
   const attr = parseAttributes(getTagAttributes(html));
   const actual = Object.fromEntries(attr.entries());
   assertObjectMatch(actual, expected);
 });
 
-Deno.test('single (self-closing)', () => {
+Deno.test("single (self-closing)", () => {
   const html = '<div data-test="test123" />';
   const expected = {
-    'data-test': 'test123'
+    "data-test": "test123",
   };
   const attr = parseAttributes(getTagAttributes(html));
   const actual = Object.fromEntries(attr.entries());
   assertObjectMatch(actual, expected);
 });
 
-Deno.test('single (boolean self-closing)', () => {
-  const html = '<div data-test/>';
+Deno.test("single (boolean self-closing)", () => {
+  const html = "<div data-test/>";
   const expected = {
-    'data-test': ''
+    "data-test": "",
   };
   const attr = parseAttributes(getTagAttributes(html));
   const actual = Object.fromEntries(attr.entries());
   assertObjectMatch(actual, expected);
 });
 
-Deno.test('single (boolean)', () => {
-  const html = '<div data-test/>';
+Deno.test("single (boolean)", () => {
+  const html = "<div data-test/>";
   const expected = {
-    'data-test': ''
+    "data-test": "",
   };
   const attr = parseAttributes(getTagAttributes(html));
   const actual = Object.fromEntries(attr.entries());
   assertObjectMatch(actual, expected);
 });
 
-Deno.test('single (unquoted)', () => {
-  const html = '<div data-test=test/>';
+Deno.test("single (unquoted)", () => {
+  const html = "<div data-test=test/>";
   const expected = {
-    'data-test': 'test'
+    "data-test": "test",
   };
   const attr = parseAttributes(getTagAttributes(html));
   const actual = Object.fromEntries(attr.entries());
   assertObjectMatch(actual, expected);
 });
 
-Deno.test('duplicate', () => {
+Deno.test("duplicate", () => {
   const html = '<div a="a" b="b" a="A" c="c" A="AA"c>';
   const expected = {
-    a: 'AA',
-    b: 'b',
-    c: ''
+    a: "AA",
+    b: "b",
+    c: "",
   };
   const attr = parseAttributes(getTagAttributes(html));
   const actual = Object.fromEntries(attr.entries());
   assertObjectMatch(actual, expected);
 });
 
-Deno.test('multiple (whitespace)', () => {
+Deno.test("multiple (whitespace)", () => {
   const html = `\u0009 <div a1="1"a2="2"
     a3="3"\u0009a4="4"a5\u0009a6\u0009=
     \u0009"6"a7\u0009=7\u0009
     a8/> `;
   const expected = {
-    a1: '1',
-    a2: '2',
-    a3: '3',
-    a4: '4',
-    a5: '',
-    a6: '6',
-    a7: '7',
-    a8: ''
+    a1: "1",
+    a2: "2",
+    a3: "3",
+    a4: "4",
+    a5: "",
+    a6: "6",
+    a7: "7",
+    a8: "",
   };
   const attr = parseAttributes(getTagAttributes(html));
   const actual = Object.fromEntries(attr.entries());
   assertObjectMatch(actual, expected);
 });
 
-Deno.test('mixed', () => {
+Deno.test("mixed", () => {
   const html =
     '<div data-test="test123"a="\'b\'"c boolean data-2="2" data:3="3" _4=""s1=\'x="1"\'s2="x=\'\u20012\'" data5\u0009data_six=\' 6 \'>';
   const expected = {
-    'data-test': 'test123',
+    "data-test": "test123",
     a: "'b'",
-    c: '',
-    boolean: '',
-    'data-2': '2',
-    'data:3': '3',
-    _4: '',
+    c: "",
+    boolean: "",
+    "data-2": "2",
+    "data:3": "3",
+    _4: "",
     s1: 'x="1"',
     s2: "x='\u20012'",
-    data5: '',
-    data_six: ' 6 '
+    data5: "",
+    data_six: " 6 ",
   };
   const attr = parseAttributes(getTagAttributes(html));
   const actual = Object.fromEntries(attr.entries());
   assertObjectMatch(actual, expected);
 });
 
-Deno.test('entities', () => {
+Deno.test("entities", () => {
   const encoded = `&amp;&lt;&gt;&quot;&#39;`;
   const decoded = `&<>"'`;
-  const entries: {[key: string]: string} = {
-    prop: decoded
+  const entries: { [key: string]: string } = {
+    prop: decoded,
   };
   let attr = parseAttributes(`prop="${encoded}"`);
   attr = new AttributeMap(attr);
-  assertEquals(attr.get('prop'), decoded);
-  assertEquals(attr.get('prop', false), encoded);
+  assertEquals(attr.get("prop"), decoded);
+  assertEquals(attr.get("prop", false), encoded);
   assertEquals(attr.toString(), `prop="${encoded}"`);
   assertObjectMatch(entries, Object.fromEntries(attr.entries()));
-  assertEquals(Array.from(attr.values()).join(''), decoded);
-  assertEquals(Array.from(attr.values(false)).join(''), encoded);
+  assertEquals(Array.from(attr.values()).join(""), decoded);
+  assertEquals(Array.from(attr.values(false)).join(""), encoded);
   for (const [k, v] of attr) {
     assertEquals(v, entries[k]);
   }
diff --git a/test/excerpt_test.ts b/test/excerpt_test.ts
index c019d6a..d24bec8 100644
--- a/test/excerpt_test.ts
+++ b/test/excerpt_test.ts
@@ -1,44 +1,54 @@
-import {excerpt} from '../src/excerpt.ts';
-import {assertEquals} from 'jsr:@std/assert';
+import { excerpt } from "../src/excerpt.ts";
+import { assertEquals } from "jsr:@std/assert";
 
-Deno.test('short', () => {
-  const html = '<p>Ceci n’est pas une paragraphe.</p>';
-  const expected = 'Ceci n’est pas une paragraphe. ';
+Deno.test("short", () => {
+  const html = "<p>Ceci n’est pas une paragraphe.</p>";
+  const expected = "Ceci n’est pas une paragraphe. ";
   const text = excerpt(html);
   assertEquals(text, expected);
 });
 
-Deno.test('default', () => {
-  const html = `<p>Back in March I shared my <a href="https://example.com">spring self-hosted update</a>. I had a new <a href="https://example.com" rel="noopener noreferrer" target="_blank">ZimaBlade</a> to play with. I bought a cheap GeForce GT 710 just to try the PCIe. It worked. That graphics card is terrible (more on that later). The ZimaBlade is also, frankly, terrible. The CPU thermal throttles itself to death. It gets <em>dangerously</em> hot. Add it to the list of crowdfunding campaigns I regret.</p><p>So I still use my <strong>Raspberry Pi</strong> and <strong>Mac Mini</strong> as home servers. Until now!</p>`;
-  const expected = `Back in March I shared my spring self-hosted update. I had a new ZimaBlade to play with. I bought a cheap GeForce GT 710 just to try the PCIe. It worked. That graphics card is terrible (more on that later). The ZimaBlade is also, frankly, terrible. The CPU thermal throttles itself to death. […]`;
+Deno.test("default", () => {
+  const html =
+    `<p>Back in March I shared my <a href="https://example.com">spring self-hosted update</a>. I had a new <a href="https://example.com" rel="noopener noreferrer" target="_blank">ZimaBlade</a> to play with. I bought a cheap GeForce GT 710 just to try the PCIe. It worked. That graphics card is terrible (more on that later). The ZimaBlade is also, frankly, terrible. The CPU thermal throttles itself to death. It gets <em>dangerously</em> hot. Add it to the list of crowdfunding campaigns I regret.</p><p>So I still use my <strong>Raspberry Pi</strong> and <strong>Mac Mini</strong> as home servers. Until now!</p>`;
+  const expected =
+    `Back in March I shared my spring self-hosted update. I had a new ZimaBlade to play with. I bought a cheap GeForce GT 710 just to try the PCIe. It worked. That graphics card is terrible (more on that later). The ZimaBlade is also, frankly, terrible. The CPU thermal throttles itself to death. […]`;
   const text = excerpt(html);
   assertEquals(text, expected);
 });
 
-Deno.test('max length', () => {
-  const html = `<p>Back in March I shared my <a href="https://example.com">spring self-hosted update</a>. I had a new <a href="https://example.com" rel="noopener noreferrer" target="_blank">ZimaBlade</a> to play with. I bought a cheap GeForce GT 710 just to try the PCIe. It worked. That graphics card is terrible (more on that later). The ZimaBlade is also, frankly, terrible. The CPU thermal throttles itself to death. It gets <em>dangerously</em> hot. Add it to the list of crowdfunding campaigns I regret.</p><p>So I still use my <strong>Raspberry Pi</strong> and <strong>Mac Mini</strong> as home servers. Until now!</p>`;
-  const expected = `Back in March I shared my spring self-hosted update. I had a new ZimaBlade to play with. […]`;
+Deno.test("max length", () => {
+  const html =
+    `<p>Back in March I shared my <a href="https://example.com">spring self-hosted update</a>. I had a new <a href="https://example.com" rel="noopener noreferrer" target="_blank">ZimaBlade</a> to play with. I bought a cheap GeForce GT 710 just to try the PCIe. It worked. That graphics card is terrible (more on that later). The ZimaBlade is also, frankly, terrible. The CPU thermal throttles itself to death. It gets <em>dangerously</em> hot. Add it to the list of crowdfunding campaigns I regret.</p><p>So I still use my <strong>Raspberry Pi</strong> and <strong>Mac Mini</strong> as home servers. Until now!</p>`;
+  const expected =
+    `Back in March I shared my spring self-hosted update. I had a new ZimaBlade to play with. […]`;
   const text = excerpt(html, 100);
   assertEquals(text, expected);
 });
 
-Deno.test('truncate', () => {
-  const html = `<p>Back in March I shared my <a href="https://example.com">spring self-hosted update</a>. I had a new <a href="https://example.com" rel="noopener noreferrer" target="_blank">ZimaBlade</a> to play with. I bought a cheap GeForce GT 710 just to try the PCIe. It worked. That graphics card is terrible (more on that later). The ZimaBlade is also, frankly, terrible. The CPU thermal throttles itself to death. It gets <em>dangerously</em> hot. Add it to the list of crowdfunding campaigns I regret.</p><p>So I still use my <strong>Raspberry Pi</strong> and <strong>Mac Mini</strong> as home servers. Until now!</p>`;
-  const expected = `Back in March I shared my spring self-hosted update. I had a new ZimaBlade to […]`;
+Deno.test("truncate", () => {
+  const html =
+    `<p>Back in March I shared my <a href="https://example.com">spring self-hosted update</a>. I had a new <a href="https://example.com" rel="noopener noreferrer" target="_blank">ZimaBlade</a> to play with. I bought a cheap GeForce GT 710 just to try the PCIe. It worked. That graphics card is terrible (more on that later). The ZimaBlade is also, frankly, terrible. The CPU thermal throttles itself to death. It gets <em>dangerously</em> hot. Add it to the list of crowdfunding campaigns I regret.</p><p>So I still use my <strong>Raspberry Pi</strong> and <strong>Mac Mini</strong> as home servers. Until now!</p>`;
+  const expected =
+    `Back in March I shared my spring self-hosted update. I had a new ZimaBlade to […]`;
   const text = excerpt(html, 80);
   assertEquals(text, expected);
 });
 
-Deno.test('exclamation mark end', () => {
-  const html = `<p>Back in March I shared my <a href="https://example.com">spring self-hosted update</a>. I had a new <a href="https://example.com" rel="noopener noreferrer" target="_blank">ZimaBlade</a> to play with! I bought a cheap GeForce GT 710 just to try the PCIe.</p>`;
-  const expected = `Back in March I shared my spring self-hosted update. I had a new ZimaBlade to play with! …`;
-  const text = excerpt(html, 100, '…');
+Deno.test("exclamation mark end", () => {
+  const html =
+    `<p>Back in March I shared my <a href="https://example.com">spring self-hosted update</a>. I had a new <a href="https://example.com" rel="noopener noreferrer" target="_blank">ZimaBlade</a> to play with! I bought a cheap GeForce GT 710 just to try the PCIe.</p>`;
+  const expected =
+    `Back in March I shared my spring self-hosted update. I had a new ZimaBlade to play with! …`;
+  const text = excerpt(html, 100, "…");
   assertEquals(text, expected);
 });
 
-Deno.test('question mark end', () => {
-  const html = `<p>Back in March I shared my <a href="https://example.com">spring self-hosted update</a>. I had a new <a href="https://example.com" rel="noopener noreferrer" target="_blank">ZimaBlade</a> to play with? I bought a cheap GeForce GT 710 just to try the PCIe.</p>`;
-  const expected = `Back in March I shared my spring self-hosted update. I had a new ZimaBlade to play with?`;
-  const text = excerpt(html, 100, '');
+Deno.test("question mark end", () => {
+  const html =
+    `<p>Back in March I shared my <a href="https://example.com">spring self-hosted update</a>. I had a new <a href="https://example.com" rel="noopener noreferrer" target="_blank">ZimaBlade</a> to play with? I bought a cheap GeForce GT 710 just to try the PCIe.</p>`;
+  const expected =
+    `Back in March I shared my spring self-hosted update. I had a new ZimaBlade to play with?`;
+  const text = excerpt(html, 100, "");
   assertEquals(text, expected);
 });
diff --git a/test/html_test.ts b/test/html_test.ts
index 41b31bf..2ee433c 100644
--- a/test/html_test.ts
+++ b/test/html_test.ts
@@ -1,83 +1,83 @@
-import {Node} from '../mod.ts';
-import {parseHTML} from '../src/html-parser.ts';
-import {assert, assertEquals} from 'jsr:@std/assert';
+import { Node } from "../mod.ts";
+import { parseHTML } from "../src/html-parser.ts";
+import { assert, assertEquals } from "jsr:@std/assert";
 
-Deno.test('paragraph', () => {
-  const html = '<p>Paragraph</p>';
+Deno.test("paragraph", () => {
+  const html = "<p>Paragraph</p>";
   const root = parseHTML(html);
   const p = root.at(0)!;
-  assertEquals(p.tag, 'p');
+  assertEquals(p.tag, "p");
   assertEquals(p.size, 1);
-  assertEquals(p.at(0)!.type, 'TEXT');
-  assertEquals(p.at(0)!.raw, 'Paragraph');
+  assertEquals(p.at(0)!.type, "TEXT");
+  assertEquals(p.at(0)!.raw, "Paragraph");
 });
 
-Deno.test('case-insensitive', () => {
-  const html = '<ArTiClE>Paragraph</aRtIcLe>';
+Deno.test("case-insensitive", () => {
+  const html = "<ArTiClE>Paragraph</aRtIcLe>";
   const root = parseHTML(html);
-  assertEquals(root.at(0)!.tag, 'article');
+  assertEquals(root.at(0)!.tag, "article");
 });
 
-Deno.test('custom elements', () => {
+Deno.test("custom elements", () => {
   const html = `<my-element>
   <my-one>1</my-one>
   <my-two>2</my-two>
   <my-three>3</my-three>
-</my-element>`.replace(/\s+/g, '');
+</my-element>`.replace(/\s+/g, "");
   const root = parseHTML(html);
-  assertEquals(root.at(0)!.tag, 'my-element');
-  assertEquals(root.at(0)!.at(1)!.tag, 'my-two');
-  assertEquals(root.at(0)!.at(1)!.type, 'ELEMENT');
+  assertEquals(root.at(0)!.tag, "my-element");
+  assertEquals(root.at(0)!.at(1)!.tag, "my-two");
+  assertEquals(root.at(0)!.at(1)!.type, "ELEMENT");
   assertEquals(root.at(0)!.size, 3);
 });
 
-Deno.test('paragraph inline', () => {
-  const html = '<p>This is <strong>inline</strong></p>';
+Deno.test("paragraph inline", () => {
+  const html = "<p>This is <strong>inline</strong></p>";
   const root = parseHTML(html);
   const p = root.at(0)!;
   const strong = p.at(1)!;
   assertEquals(p.size, 2);
-  assertEquals(p.at(0)!.type, 'TEXT');
-  assertEquals(strong.tag, 'strong');
-  assertEquals(strong.at(0)!.raw, 'inline');
+  assertEquals(p.at(0)!.type, "TEXT");
+  assertEquals(strong.tag, "strong");
+  assertEquals(strong.at(0)!.raw, "inline");
 });
 
-Deno.test('fake out tag', () => {
-  const html = '<p>Less than < fake tag</p>';
+Deno.test("fake out tag", () => {
+  const html = "<p>Less than < fake tag</p>";
   const root = parseHTML(html);
   const p = root.at(0)!;
   assertEquals(p.size, 2);
 });
 
-Deno.test('void element', () => {
-  const html = '<p>1</p><img><p>2</p>';
+Deno.test("void element", () => {
+  const html = "<p>1</p><img><p>2</p>";
   const root = parseHTML(html);
   assertEquals(root.size, 3);
-  assertEquals(root.at(1)!.type, 'VOID');
+  assertEquals(root.at(1)!.type, "VOID");
 });
 
-Deno.test('self-closing', () => {
-  const html = '<div />';
+Deno.test("self-closing", () => {
+  const html = "<div />";
   const root = parseHTML(html);
   assertEquals(root.size, 1);
-  assertEquals(root.at(0)!.type, 'VOID');
+  assertEquals(root.at(0)!.type, "VOID");
 });
 
-Deno.test('stray node', () => {
-  const html = '<p>1</p></p><p>2</p>';
+Deno.test("stray node", () => {
+  const html = "<p>1</p></p><p>2</p>";
   const root = parseHTML(html);
   assertEquals(root.size, 3);
-  assertEquals(root.at(1)!.type, 'STRAY');
+  assertEquals(root.at(1)!.type, "STRAY");
 });
 
-Deno.test('leftover text', () => {
-  const html = '<p>Paragraph</p>Leftover';
+Deno.test("leftover text", () => {
+  const html = "<p>Paragraph</p>Leftover";
   const root = parseHTML(html);
-  assertEquals(root.at(1)!.type, 'TEXT');
-  assertEquals(root.at(1)!.raw, 'Leftover');
+  assertEquals(root.at(1)!.type, "TEXT");
+  assertEquals(root.at(1)!.raw, "Leftover");
 });
 
-Deno.test('unclosed <li>', () => {
+Deno.test("unclosed <li>", () => {
   const html = `
 <ul>
   <li>1<b>b</b>
@@ -87,7 +87,7 @@ Deno.test('unclosed <li>', () => {
       <li>4<i>i</i>
       <li>5
     </ol>
-</ul>`.replace(/\s+/g, '');
+</ul>`.replace(/\s+/g, "");
   const root = parseHTML(html);
   assertEquals(root.at(0)!.size, 3);
   assertEquals(
@@ -102,17 +102,17 @@ Deno.test('unclosed <li>', () => {
       <li>5</li>
     </ol>
   </li>
-</ul>`.replace(/\s+/g, '')
+</ul>`.replace(/\s+/g, ""),
   );
 });
 
-Deno.test('unclosed <p> (1)', () => {
+Deno.test("unclosed <p> (1)", () => {
   const html = `<p>1 <my-element /><div />2`;
   const root = parseHTML(html);
-  assertEquals(root.toString(), '<p>1 <my-element/></p><div/>2');
+  assertEquals(root.toString(), "<p>1 <my-element/></p><div/>2");
 });
 
-Deno.test('unclosed <p> (2)', () => {
+Deno.test("unclosed <p> (2)", () => {
   const html = `
 <p>Hello, World!
 <div>
@@ -121,7 +121,7 @@ Deno.test('unclosed <p> (2)', () => {
   <p>Unclosed
 </div>
 <p>EOF<hr>
-`.replace(/\s+/g, '');
+`.replace(/\s+/g, "");
   const root = parseHTML(html);
   assertEquals(root.size, 4);
   assertEquals(
@@ -135,11 +135,11 @@ Deno.test('unclosed <p> (2)', () => {
 </div>
 <p>EOF</p>
 <hr/>
-`.replace(/\s+/g, '')
+`.replace(/\s+/g, ""),
   );
 });
 
-Deno.test('comments', () => {
+Deno.test("comments", () => {
   const html = `
 <!--
   COMMENT 1 -->
@@ -147,11 +147,11 @@ Deno.test('comments', () => {
   <p><!-- COMMENT 2 --></p>
 </div>`;
   const root = parseHTML(html);
-  assertEquals(root.at(1)!.type, 'COMMENT');
-  assertEquals(root.at(3)!.at(1)!.at(0)!.type, 'COMMENT');
+  assertEquals(root.at(1)!.type, "COMMENT");
+  assertEquals(root.at(3)!.at(1)!.at(0)!.type, "COMMENT");
 });
 
-Deno.test('opaque state (svg)', () => {
+Deno.test("opaque state (svg)", () => {
   const svg = `<svg>
   <path />
   <rect />
@@ -160,27 +160,28 @@ Deno.test('opaque state (svg)', () => {
   const html = `<svg />${svg}<p>After</p>`;
   const root = parseHTML(html);
   assertEquals(root.size, 3);
-  assertEquals(root.at(1)!.type, 'OPAQUE');
+  assertEquals(root.at(1)!.type, "OPAQUE");
   assertEquals(root.at(1)!.size, 1);
-  assertEquals(root.at(1)!.at(0)!.type, 'TEXT');
+  assertEquals(root.at(1)!.at(0)!.type, "TEXT");
   assertEquals(root.at(1)!.toString(), svg);
 });
 
-Deno.test('script fake tag', () => {
-  const html = `<script>/* This is a fake </script> tag */</script><p>after</p>`;
+Deno.test("script fake tag", () => {
+  const html =
+    `<script>/* This is a fake </script> tag */</script><p>after</p>`;
   const root = parseHTML(html);
-  assertEquals(root.at(1)!.raw, ' tag */');
+  assertEquals(root.at(1)!.raw, " tag */");
 });
 
-Deno.test('attributes', () => {
+Deno.test("attributes", () => {
   const html =
     '<div data-test="test123"a="\'b\'"c boolean data-2="2" data:3="3" _4=""s1=\'x="1"\'s2="x=\'\u20012\'" data5\u0009data_six=\' 6 \'>test</div>';
   const root = parseHTML(html);
-  assertEquals(root.at(0)!.at(0)!.raw, 'test');
+  assertEquals(root.at(0)!.at(0)!.raw, "test");
   assertEquals(root.at(0)!.attributes.size, 11);
 });
 
-Deno.test('render', () => {
+Deno.test("render", () => {
   const html = `
 <p>Paragraph
   <b>bold</b>
@@ -199,8 +200,8 @@ Deno.test('render', () => {
   assertEquals(root.toString(), render);
 });
 
-Deno.test('detach', () => {
-  const html = '<p>1</p><p>2</p><p>3</p><p>4</p><p>5</p>';
+Deno.test("detach", () => {
+  const html = "<p>1</p><p>2</p><p>3</p><p>4</p><p>5</p>";
   const root = parseHTML(html);
   const c0 = root.at(0)!;
   const c1 = root.at(1)!;
@@ -223,22 +224,22 @@ Deno.test('detach', () => {
   assertEquals(root.size, 1);
 });
 
-Deno.test('Node.replaceWith', () => {
-  const html = '<p>1</p><p>2</p><p>3</p>';
+Deno.test("Node.replaceWith", () => {
+  const html = "<p>1</p><p>2</p><p>3</p>";
   const root = parseHTML(html);
-  const A = parseHTML('<p>A</p>');
-  const B = parseHTML('<p>B</p>');
-  const C = parseHTML('<p>C</p>');
+  const A = parseHTML("<p>A</p>");
+  const B = parseHTML("<p>B</p>");
+  const C = parseHTML("<p>C</p>");
   root.at(0)!.replace(A);
   root.at(1)!.replace(B);
   root.at(2)!.replace(C);
-  assertEquals(root.toString(), '<p>A</p><p>B</p><p>C</p>');
+  assertEquals(root.toString(), "<p>A</p><p>B</p><p>C</p>");
   assert(root.head === A);
   assert(root.tail === C);
 });
 
-Deno.test('Node.indexOf', () => {
-  const html = '<p>1</p><p>2</p><p>3</p><p>4</p><p>5</p>';
+Deno.test("Node.indexOf", () => {
+  const html = "<p>1</p><p>2</p><p>3</p><p>4</p><p>5</p>";
   const root = parseHTML(html);
   const c0 = root.at(0)!;
   const c2 = root.at(2)!;
@@ -249,40 +250,40 @@ Deno.test('Node.indexOf', () => {
   assertEquals(c0.indexOf(c4), -1);
 });
 
-Deno.test('Node.insertAt', () => {
+Deno.test("Node.insertAt", () => {
   const root = new Node();
-  const n1 = parseHTML('<p>1</p>');
-  const n2 = parseHTML('<p>2</p>');
-  const n3 = parseHTML('<p>3</p>');
+  const n1 = parseHTML("<p>1</p>");
+  const n2 = parseHTML("<p>2</p>");
+  const n3 = parseHTML("<p>3</p>");
   root.insertAt(n3, 0);
   root.insertAt(n2, 0);
   root.insertAt(n1, 0);
-  assertEquals(root.toString(), '<p>1</p><p>2</p><p>3</p>');
+  assertEquals(root.toString(), "<p>1</p><p>2</p><p>3</p>");
 });
 
-Deno.test('Node.after', () => {
+Deno.test("Node.after", () => {
   const root = new Node();
-  const n1 = parseHTML('<p>1</p>');
-  const n2 = parseHTML('<p>2</p>');
-  const n3 = parseHTML('<p>3</p>');
+  const n1 = parseHTML("<p>1</p>");
+  const n2 = parseHTML("<p>2</p>");
+  const n3 = parseHTML("<p>3</p>");
   root.append(n1, n2, n3);
-  assertEquals(root.toString(), '<p>1</p><p>2</p><p>3</p>');
+  assertEquals(root.toString(), "<p>1</p><p>2</p><p>3</p>");
   n2.after(n1); // 2 1 3
   n1.after(n3);
   n2.after(n3); // 2 3 1
   n1.after(n2); // 3 1 2
   n2.after(n1); // 3 2 1
-  assertEquals(root.toString(), '<p>3</p><p>2</p><p>1</p>');
+  assertEquals(root.toString(), "<p>3</p><p>2</p><p>1</p>");
 });
 
-Deno.test('Node.before', () => {
+Deno.test("Node.before", () => {
   const root = new Node();
-  const n1 = parseHTML('<p>1</p>');
-  const n2 = parseHTML('<p>2</p>');
-  const n3 = parseHTML('<p>3</p>');
+  const n1 = parseHTML("<p>1</p>");
+  const n2 = parseHTML("<p>2</p>");
+  const n3 = parseHTML("<p>3</p>");
   root.append(n1, n2, n3);
-  assertEquals(root.toString(), '<p>1</p><p>2</p><p>3</p>');
+  assertEquals(root.toString(), "<p>1</p><p>2</p><p>3</p>");
   n3.before(n1); // 2 1 3
   n2.before(n3); // 3 2 1
-  assertEquals(root.toString(), '<p>3</p><p>2</p><p>1</p>');
+  assertEquals(root.toString(), "<p>3</p><p>2</p><p>1</p>");
 });
diff --git a/test/striptags_test.ts b/test/striptags_test.ts
index 8af8517..463ab0e 100644
--- a/test/striptags_test.ts
+++ b/test/striptags_test.ts
@@ -1,35 +1,36 @@
-import {stripTags} from '../src/striptags.ts';
-import {assertEquals} from 'jsr:@std/assert';
+import { stripTags } from "../src/striptags.ts";
+import { assertEquals } from "jsr:@std/assert";
 
-Deno.test('demo', () => {
-  const html = '<p>Ceci n’est pas une paragraphe.</p>';
-  const expected = 'Ceci n’est pas une paragraphe. ';
+Deno.test("demo", () => {
+  const html = "<p>Ceci n’est pas une paragraphe.</p>";
+  const expected = "Ceci n’est pas une paragraphe. ";
   const text = stripTags(html);
   assertEquals(text, expected);
 });
 
-Deno.test('basic', () => {
-  const html = `<p><em>This</em> is <abbr="Hypertext Markup Language">HTML</abbr>.</p>
+Deno.test("basic", () => {
+  const html =
+    `<p><em>This</em> is <abbr="Hypertext Markup Language">HTML</abbr>.</p>
 <p>End of content.</p>`;
-  const expected = 'This is HTML. \nEnd of content. ';
+  const expected = "This is HTML. \nEnd of content. ";
   const text = stripTags(html);
   assertEquals(text, expected);
 });
 
-Deno.test('quotes', () => {
+Deno.test("quotes", () => {
   const html = `<blockquote>
   <p><em>This</em> is <abbr="Hypertext Markup Language">HTML</abbr>.</p>
 </blockquote>`;
-  const expected = '“This is HTML.” ';
+  const expected = "“This is HTML.” ";
   const text = stripTags(html);
   assertEquals(text, expected);
 });
 
-Deno.test('nested quotes', () => {
+Deno.test("nested quotes", () => {
   const html = `<blockquote>
   <p>Blockquote with <q>inline quote</q> text.</p>
 </blockquote>`;
-  const expected = '“Blockquote with ‘inline quote’ text.” ';
+  const expected = "“Blockquote with ‘inline quote’ text.” ";
   const text = stripTags(html);
   assertEquals(text, expected);
 });