diff --git a/.changeset/twelve-avocados-provide.md b/.changeset/twelve-avocados-provide.md
new file mode 100644
index 0000000..9aaae04
--- /dev/null
+++ b/.changeset/twelve-avocados-provide.md
@@ -0,0 +1,5 @@
+---
+"html-aria": minor
+---
+
+⚠️ Breaking change: aria- attribute data now matches ARIA spec, e.g. `enum` (unique type) replaced with `token` (described in ARIA 1.3).
diff --git a/README.md b/README.md
index aaf0bc7..3bc58c6 100644
--- a/README.md
+++ b/README.md
@@ -221,14 +221,18 @@ isInteractive({
 }); // true (see https://www.w3.org/TR/wai-aria-1.3/#separator)
 ```
 
-The methodology for this is somewhat complex to follow the complete ARIA specification:
+> ![WARNING]
+>
+> This doesn’t check for `display: none`, which could be applied with CSS that would make any element non-interactive.
+
+The methodology for this follows the complete ARIA specification:
 
 1. If the role is a [widget](https://www.w3.org/TR/wai-aria-1.3/#widget_roles) or [window](https://www.w3.org/TR/wai-aria-1.3/#window_roles) subclass, then it is interactive
-   - Note: if the element manually specifies `role`, and if it natively is NOT a widget or window role, `tabindex` must also be supplied
+   - If the element manually specifies `role`, and if it natively is NOT a widget or window role, `tabindex` must also be supplied
 1. If the element is `disabled` or `aria-disabled`, then it is NOT interactive
 1. Handle some explicit edge cases like [separator](https://www.w3.org/TR/wai-aria-1.3/#separator)
 
-Note that `aria-hidden` elements may be interactive (even if it’s not best practice) as a part of [2.4.5 Multiple Ways](https://www.w3.org/WAI/WCAG21/Understanding/multiple-ways.html) if an alternative is made for screenreaders, etc.
+Note that `aria-hidden` elements MAY be interactive (even if it’s not best practice) as a part of [2.4.5 Multiple Ways](https://www.w3.org/WAI/WCAG21/Understanding/multiple-ways.html) if an alternative is made for screenreaders, etc.
 
 ### isNameRequired()
 
@@ -345,21 +349,16 @@ _Note: `—` = [no corresponding role](#whats-the-difference-between-no-correspo
 
 Though the [HTML in ARIA](https://www.w3.org/TR/html-aria) spec was the foundation for this library, at points it conflicts with [AAM](https://www.w3.org/TR/html-aam-1.0). We also have browsers sometimes showing inconsistent roles, too. For these discrepancies, we compare what the specs recommend, along with the library’s current decision in an attempt to follow the most helpful path.
 
-| Element        | [HTML in ARIA](https://www.w3.org/TR/html-aria) | [AAM](https://www.w3.org/TR/html-aam-1.0) | Browsers\*                       | html-aria             |
-| :------------- | :---------------------------------------------- | :---------------------------------------- | :------------------------------- | --------------------- |
-| `<dd>`         | No corresponding role                           | definition                                | definition                       | definition            |
-| `<dl>`         | No corresponding role                           | list                                      | (inconsistent)                   | No corresponding role |
-| `<dt>`         | No corresponding role                           | term                                      | term                             | term                  |
-| `<figcaption>` | No corresponding role                           | caption                                   | caption (`Figcaption` in Chrome) | caption               |
-| `<mark>`       | No corresponding role                           | mark                                      | mark                             | mark                  |
-
-_\* Chrome 132, Safari 18, Firefox 135. _
-
-#### SVG
-
-SVG is tricky. Though the [spec says](https://www.w3.org/TR/html-aria/#el-svg) `<svg>` should get the `graphics-document` role by default, browsers chose chaos. Firefox 134 displays `graphics-document`, Chrome 131 defaults to `image` (previously it returned nothing, or other roles), and Safari defaults to `generic` (which is one of the worst roles you could probably give it).
+| Element        | [HTML in ARIA](https://www.w3.org/TR/html-aria) | [AAM](https://www.w3.org/TR/html-aam-1.0) | Browsers\*                                                        | html-aria             |
+| :------------- | :---------------------------------------------- | :---------------------------------------- | :---------------------------------------------------------------- | --------------------- |
+| `<dd>`         | No corresponding role                           | `definition`                              | `definition`                                                      | `definition`          |
+| `<dl>`         | No corresponding role                           | `list`                                    | (inconsistent)                                                    | No corresponding role |
+| `<dt>`         | No corresponding role                           | `term`                                    | `term`                                                            | `term`                |
+| `<figcaption>` | No corresponding role                           | `caption`                                 | `caption` (`Figcaption` in Chrome)                                | `caption`             |
+| `<mark>`       | No corresponding role                           | `mark`                                    | `mark`                                                            | `mark`                |
+| `<svg>`        | `graphics-document`                             | `graphics-document`                       | `graphics-document` (Firefox), `img` (Chrome), `generic` (Safari) | `graphics-document`   |
 
-Since we have 1 spec and 1 browser agreeing, this library defaults to `graphics-document`. Though the best answer is _SVGs should ALWAYS get an explicit `role`_.
+_\* Chrome 132, Safari 18, Firefox 135._
 
 ### Node.js vs DOM behavior
 
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b935347..86ad20f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1913,8 +1913,8 @@ packages:
     resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==}
     engines: {node: '>=10'}
 
-  type-fest@4.33.0:
-    resolution: {integrity: sha512-s6zVrxuyKbbAsSAD5ZPTB77q4YIdRctkTbJ2/Dqlinwz+8ooH2gd+YA7VA6Pa93KML9GockVvoxjZ2vHP+mu8g==}
+  type-fest@4.34.1:
+    resolution: {integrity: sha512-6kSc32kT0rbwxD6QL1CYe8IqdzN/J/ILMrNK+HMQCKH3insCDRY/3ITb0vcBss0a3t72fzh2YSzj8ko1HgwT3g==}
     engines: {node: '>=16'}
 
   typescript@5.7.3:
@@ -3441,7 +3441,7 @@ snapshots:
       path-to-regexp: 6.3.0
       picocolors: 1.1.1
       strict-event-emitter: 0.5.1
-      type-fest: 4.33.0
+      type-fest: 4.34.1
       yargs: 17.7.2
     optionalDependencies:
       typescript: 5.7.3
@@ -3925,7 +3925,7 @@ snapshots:
 
   type-fest@0.21.3: {}
 
-  type-fest@4.33.0: {}
+  type-fest@4.34.1: {}
 
   typescript@5.7.3: {}
 
diff --git a/src/get-role.ts b/src/get-role.ts
index 59e7380..72dba5e 100644
--- a/src/get-role.ts
+++ b/src/get-role.ts
@@ -7,6 +7,7 @@ import { getHeaderRole } from './tags/header.js';
 import { getInputRole } from './tags/input.js';
 import { getLIRole } from './tags/li.js';
 import { getSelectRole } from './tags/select.js';
+import { getSvgElementRole } from './tags/svg.js';
 import { getTDRole } from './tags/td.js';
 import { getTHRole } from './tags/th.js';
 import type { VirtualAncestorList, VirtualElement } from './types.js';
@@ -52,6 +53,7 @@ export interface GetRoleOptions {
  */
 export function getRole(element: Element | VirtualElement, options?: GetRoleOptions): RoleData | undefined {
   const tagName = getTagName(element);
+  const tagData = tags[tagName];
   const role = attr(element, 'role') as string | undefined;
 
   // explicit role: use if valid
@@ -64,22 +66,22 @@ export function getRole(element: Element | VirtualElement, options?: GetRoleOpti
     return roles[firstRole!];
   }
 
-  const tag = tags[tagName];
-
   // If custom element (unknown HTML element), assume generic
-  if (!tag) {
+  if (!tagData) {
     return roles.generic;
   }
 
+  const defaultRole = roles[tagData.defaultRole!];
+
   switch (tagName) {
     case 'a':
     case 'area': {
       const href = attr(element, 'href');
-      return typeof href === 'string' ? roles[tag.defaultRole!] : roles.generic;
+      return typeof href === 'string' ? defaultRole : roles.generic;
     }
     case 'aside': {
       const name = calculateAccessibleName(element, roles.complementary);
-      return name ? roles[tag.defaultRole!] : getAsideRole(element, options);
+      return name ? defaultRole : getAsideRole(element, options);
     }
     case 'header': {
       return getHeaderRole(element, options);
@@ -99,7 +101,7 @@ export function getRole(element: Element | VirtualElement, options?: GetRoleOpti
     }
     case 'section': {
       const name = calculateAccessibleName(element, roles.region);
-      return name ? roles[tag.defaultRole!] : roles.generic;
+      return name ? defaultRole : roles.generic;
     }
     case 'select': {
       return getSelectRole(element);
@@ -113,7 +115,24 @@ export function getRole(element: Element | VirtualElement, options?: GetRoleOpti
     case 'tr': {
       return roles.row;
     }
+
+    // @see https://www.w3.org/TR/svg-aam-1.0/#include_elements
+    case 'circle':
+    case 'ellipse':
+    case 'foreignObject':
+    case 'g':
+    case 'image':
+    case 'line':
+    case 'path':
+    case 'polygon':
+    case 'polyline':
+    case 'rect':
+    case 'textPath':
+    case 'tspan':
+    case 'use': {
+      return getSvgElementRole(element);
+    }
   }
 
-  return roles[tag.defaultRole!];
+  return defaultRole;
 }
diff --git a/src/get-supported-attributes.ts b/src/get-supported-attributes.ts
index fd8c9f5..c268ccd 100644
--- a/src/get-supported-attributes.ts
+++ b/src/get-supported-attributes.ts
@@ -2,7 +2,14 @@ import { type GetRoleOptions, getRole } from './get-role.js';
 import { attributes, globalAttributes } from './lib/aria-attributes.js';
 import { roles } from './lib/aria-roles.js';
 import { tags } from './lib/html.js';
-import { attr, calculateAccessibleName, concatDedupeAndSort, getTagName, removeProhibited } from './lib/util.js';
+import {
+  attr,
+  calculateAccessibleName,
+  concatDedupeAndSort,
+  getTagName,
+  parseTokenList,
+  removeProhibited,
+} from './lib/util.js';
 import type { ARIAAttribute, VirtualElement } from './types.js';
 
 const GLOBAL_ATTRIBUTES = Object.keys(globalAttributes) as ARIAAttribute[];
@@ -11,21 +18,20 @@ const GLOBAL_ATTRIBUTES = Object.keys(globalAttributes) as ARIAAttribute[];
  * Given an ARIA role returns a list of supported/inherited aria-* attributes.
  */
 export function getSupportedAttributes(element: Element | VirtualElement, options?: GetRoleOptions): ARIAAttribute[] {
+  const role = getRole(element, options);
+  const roleData = roles[role?.name!];
   const tagName = getTagName(element);
-  const tag = tags[tagName];
-  if (!tag) {
-    return [];
+  const tagData = tags[tagName];
+  if (!tagData) {
+    return roleData?.supported ?? GLOBAL_ATTRIBUTES;
   }
 
   // Note: DON’T check for length! Often an empty array is used
   // to mean “no aria-* attributes supported
-  if (tag.supportedAttributesOverride) {
-    return tag.supportedAttributesOverride;
+  if (tagData.supportedAttributesOverride) {
+    return tagData.supportedAttributesOverride;
   }
 
-  const role = getRole(element, options);
-  const roleData = role && roles[role?.name];
-
   // special cases
   switch (tagName) {
     // <audio> and <video> allow application aria-* attributes despite not
@@ -87,7 +93,7 @@ export function getSupportedAttributes(element: Element | VirtualElement, option
   }
 
   return removeProhibited(attrList, {
-    nameProhibited: roleData?.nameFrom === 'prohibited' || tag.namingProhibited,
+    nameProhibited: roleData?.nameFrom === 'prohibited' || tagData.namingProhibited,
     prohibited: roleData?.prohibited?.length ? roleData.prohibited : undefined,
   });
 }
@@ -120,14 +126,37 @@ export function isValidAttributeValue(attribute: ARIAAttribute, value: unknown):
     throw new Error(`${attribute} isn’t a valid ARIA attribute`);
   }
 
-  const valueStr = String(value);
-  if (attributeData.type === 'boolean') {
-    return (
-      valueStr === 'true' || valueStr === 'false' || valueStr === '' // note: ="" is equivalent to "true"
-    );
-  }
-  if (attributeData.type === 'enum') {
-    return attributeData.values.includes(valueStr);
+  switch (attributeData.type) {
+    case 'true/false': {
+      // Note: "" = true
+      return ['true', 'false', ''].includes(String(value));
+    }
+    case 'true/false/undefined': {
+      // Note: "" = true
+      return ['true', 'false', 'undefined', ''].includes(String(value));
+    }
+    case 'tristate': {
+      return ['true', 'false', 'mixed'].includes(String(value));
+    }
+    case 'idRef':
+    case 'idRefList': {
+      return typeof value === 'string' && value.length > 0;
+    }
+    case 'integer': {
+      const numVal = Number.parseFloat(String(value));
+      return Number.isInteger(numVal);
+    }
+    case 'number': {
+      const numVal = Number.parseFloat(String(value));
+      return Number.isFinite(numVal);
+    }
+    case 'token': {
+      return attributeData.values.includes(String(value));
+    }
+    case 'tokenList': {
+      const values = parseTokenList(String(value));
+      return values.length > 0 && values.every((v) => attributeData.values.includes(v));
+    }
   }
 
   return true; // if we can’t prove that it’s invalid, assume valid
diff --git a/src/get-supported-roles.ts b/src/get-supported-roles.ts
index f7e83e4..6ec218b 100644
--- a/src/get-supported-roles.ts
+++ b/src/get-supported-roles.ts
@@ -26,32 +26,32 @@ export interface SupportedRoleOptions {
  */
 export function getSupportedRoles(element: Element | VirtualElement, options?: SupportedRoleOptions): ARIARole[] {
   const tagName = getTagName(element);
-  const tag = tags[tagName];
-  if (!tag) {
-    return [];
+  const tagData = tags[tagName];
+  if (!tagData) {
+    return ALL_ROLES;
   }
 
   // special cases: some HTML elements require unique logic to determine supported roles based on attributes, etc.
   switch (tagName) {
     case 'a': {
       const href = attr(element, 'href');
-      return typeof href === 'string' ? tag.supportedRoles : ALL_ROLES;
+      return typeof href === 'string' ? tagData.supportedRoles : ALL_ROLES;
     }
     case 'area': {
       const href = attr(element, 'href');
-      return typeof href === 'string' ? tag.supportedRoles : ['button', 'generic', 'link'];
+      return typeof href === 'string' ? tagData.supportedRoles : ['button', 'generic', 'link'];
     }
     case 'footer':
     case 'header': {
       const role = getFooterRole(element, options);
-      return role?.name === 'generic' ? ['generic', 'group', 'none', 'presentation'] : tag.supportedRoles;
+      return role?.name === 'generic' ? ['generic', 'group', 'none', 'presentation'] : tagData.supportedRoles;
     }
     case 'div': {
       const DL_PARENT_ROLES: ARIARole[] = ['none', 'presentation'];
       if (typeof Element !== 'undefined' && element instanceof Element) {
-        return element.parentElement?.closest('dl:not([role])') ? DL_PARENT_ROLES : tag.supportedRoles;
+        return element.parentElement?.closest('dl:not([role])') ? DL_PARENT_ROLES : tagData.supportedRoles;
       }
-      return options?.ancestors?.[0]?.tagName === 'dl' ? DL_PARENT_ROLES : tag.supportedRoles;
+      return options?.ancestors?.[0]?.tagName === 'dl' ? DL_PARENT_ROLES : tagData.supportedRoles;
     }
     case 'img': {
       const name = calculateAccessibleName(element, roles.img);
@@ -59,7 +59,7 @@ export function getSupportedRoles(element: Element | VirtualElement, options?: S
         /** @see https://www.w3.org/TR/html-aria/#el-img */
         return ['button', 'checkbox', 'image', 'img', 'link', 'math', 'menuitem', 'menuitemcheckbox', 'menuitemradio', 'meter', 'option', 'progressbar', 'radio', 'scrollbar', 'separator', 'slider', 'switch', 'tab', 'treeitem']; // biome-ignore format: long list
       }
-      return tag.supportedRoles;
+      return tagData.supportedRoles;
     }
     case 'li': {
       return hasListParent(element, options?.ancestors) ? ['listitem'] : ALL_ROLES;
@@ -72,9 +72,9 @@ export function getSupportedRoles(element: Element | VirtualElement, options?: S
     }
     case 'summary': {
       if (typeof Element !== 'undefined' && element instanceof Element) {
-        return element.parentElement?.closest('details:not([role])') ? [] : tag.supportedRoles;
+        return element.parentElement?.closest('details:not([role])') ? [] : tagData.supportedRoles;
       }
-      return options?.ancestors?.some((a) => a.tagName === 'details') ? [] : tag.supportedRoles;
+      return options?.ancestors?.some((a) => a.tagName === 'details') ? [] : tagData.supportedRoles;
     }
     case 'td': {
       const role = getTDRole(element, options);
@@ -91,17 +91,14 @@ export function getSupportedRoles(element: Element | VirtualElement, options?: S
       }
     }
     case 'th': {
-      return hasTableParent(element, options?.ancestors) ? tag.supportedRoles : ALL_ROLES;
+      return hasTableParent(element, options?.ancestors) ? tagData.supportedRoles : ALL_ROLES;
     }
     case 'tr': {
-      return hasTableParent(element, options?.ancestors) ? tag.supportedRoles : ALL_ROLES;
+      return hasTableParent(element, options?.ancestors) ? tagData.supportedRoles : ALL_ROLES;
     }
   }
 
-  // Known cases that aren’t possible to detect without scanning full DOM:
-  // - <div> directly <dl> MUST be either role="presentation" or role="none"
-
-  return tag.supportedRoles;
+  return tagData.supportedRoles;
 }
 
 /** Helper function for getSupportedRoles that returns a boolean instead */
diff --git a/src/is-interactive.ts b/src/is-interactive.ts
index 394be7a..4bf0912 100644
--- a/src/is-interactive.ts
+++ b/src/is-interactive.ts
@@ -1,10 +1,18 @@
 import { type GetRoleOptions, getRole } from './get-role.js';
+import { tags } from './lib/html.js';
 import { attr, getTagName, isDisabled } from './lib/util.js';
 import { getTDRole } from './tags/td.js';
 import type { VirtualElement } from './types.js';
 
 /** Given HTML, can this element be interacted with? */
 export function isInteractive(element: Element | VirtualElement, options?: GetRoleOptions): boolean {
+  const tagName = getTagName(element);
+
+  // if tag doesn’t support any roles, this can’t be interactive
+  if (tags[tagName]?.supportedRoles.length === 0) {
+    return false;
+  }
+
   const role = getRole(element, options);
 
   // separator is a special case, and does NOT care about the HTML element
diff --git a/src/lib/aria-attributes.ts b/src/lib/aria-attributes.ts
index 3f4963d..98a615f 100644
--- a/src/lib/aria-attributes.ts
+++ b/src/lib/aria-attributes.ts
@@ -10,87 +10,83 @@ import type {
 
 // note: all fields required to be monomorphic
 export const globalAttributes: Record<GlobalAttribute, AttributeData> = {
-  'aria-atomic': { category: ['global', 'liveregion'], type: 'boolean', default: false },
-  'aria-braillelabel': { category: ['global'], type: 'string' },
-  'aria-brailleroledescription': { category: ['global'], type: 'string' },
-  'aria-busy': { category: ['global', 'liveregion'], type: 'boolean', default: false },
-  'aria-controls': { category: ['global', 'relationship'], type: 'string' },
-  'aria-current': { category: ['global'], type: 'string' },
-  'aria-describedby': { category: ['global', 'relationship'], type: 'string' },
-  'aria-description': { category: ['global'], type: 'string' },
-  'aria-details': { category: ['global', 'relationship'], type: 'string' },
-  'aria-dropeffect': { category: ['global', 'draganddrop'], type: 'string' },
-  'aria-flowto': { category: ['global', 'relationship'], type: 'string' },
-  'aria-grabbed': { category: ['global', 'draganddrop'], type: 'boolean', default: undefined },
-  'aria-hidden': { category: ['global', 'widget'], type: 'boolean', default: undefined },
-  'aria-keyshortcuts': { category: ['global'], type: 'string' },
-  'aria-label': { category: ['global', 'widget'], type: 'string' },
-  'aria-labelledby': { category: ['global', 'relationship'], type: 'string' },
-  'aria-live': { category: ['global', 'liveregion'], type: 'string' },
-  'aria-owns': { category: ['global', 'relationship'], type: 'string' },
+  'aria-atomic': { category: ['global', 'liveregion'], type: 'true/false', default: false },
+  'aria-braillelabel': { category: ['global'], type: 'string', default: undefined },
+  'aria-brailleroledescription': { category: ['global'], type: 'string', default: undefined },
+  'aria-busy': { category: ['global', 'liveregion'], type: 'true/false', default: false },
+  'aria-controls': { category: ['global', 'relationship'], type: 'string', default: undefined },
+  'aria-current': { category: ['global'], type: 'string', default: undefined },
+  'aria-describedby': { category: ['global', 'relationship'], type: 'string', default: undefined },
+  'aria-description': { category: ['global'], type: 'string', default: undefined },
+  'aria-details': { category: ['global', 'relationship'], type: 'string', default: undefined },
+  'aria-dropeffect': { category: ['global', 'draganddrop'], type: 'string', default: undefined },
+  'aria-flowto': { category: ['global', 'relationship'], type: 'string', default: undefined },
+  'aria-grabbed': { category: ['global', 'draganddrop'], type: 'true/false/undefined', default: undefined },
+  'aria-hidden': { category: ['global', 'widget'], type: 'true/false/undefined', default: undefined },
+  'aria-keyshortcuts': { category: ['global'], type: 'string', default: undefined },
+  'aria-label': { category: ['global', 'widget'], type: 'string', default: undefined },
+  'aria-labelledby': { category: ['global', 'relationship'], type: 'string', default: undefined },
+  'aria-live': {
+    category: ['global', 'liveregion'],
+    type: 'token',
+    default: 'off',
+    values: ['assertive', 'off', 'polite'],
+  },
+  'aria-owns': { category: ['global', 'relationship'], type: 'idRefList' },
   'aria-relevant': {
     category: ['global', 'liveregion'],
-    type: 'enum',
+    type: 'tokenList',
     default: 'additions text',
-    values: [
-      'additions',
-      'additions removals',
-      'additions removals text',
-      'additions text',
-      'all',
-      'removals',
-      'removals text',
-      'text',
-    ],
+    values: ['additions', 'removals', 'text', 'all'],
   },
-  'aria-roledescription': { category: ['global'], type: 'string' },
+  'aria-roledescription': { category: ['global'], type: 'string', default: undefined },
 };
 
 export const widgetAttributes: Record<WidgetAttribute, AttributeData> = {
   'aria-autocomplete': {
     category: ['widget'],
-    type: 'enum',
+    type: 'token',
     default: 'none',
     values: ['inline', 'list', 'both', 'none'],
   },
-  'aria-checked': { category: ['widget'], type: 'enum', values: ['true', 'false', 'mixed'], default: undefined },
-  'aria-disabled': { category: ['widget'], type: 'boolean', default: false },
-  'aria-errormessage': { category: ['widget', 'relationship'], type: 'string' },
-  'aria-expanded': { category: ['widget'], type: 'boolean', default: undefined },
+  'aria-checked': { category: ['widget'], type: 'tristate', default: undefined },
+  'aria-disabled': { category: ['widget'], type: 'true/false', default: false },
+  'aria-errormessage': { category: ['widget', 'relationship'], type: 'string', default: undefined },
+  'aria-expanded': { category: ['widget'], type: 'true/false/undefined', default: undefined },
   'aria-haspopup': {
     category: ['widget'],
-    type: 'enum',
+    type: 'token',
     default: 'false',
     values: ['false', 'true', 'menu', 'listbox', 'tree', 'grid', 'dialog'],
   },
   'aria-hidden': globalAttributes['aria-hidden'],
   'aria-invalid': {
     category: ['widget'],
-    type: 'enum',
+    type: 'token',
     default: 'false',
     values: ['grammar', 'false', 'spelling', 'true'],
   },
   'aria-label': globalAttributes['aria-label'],
-  'aria-level': { category: ['widget'], type: 'string' },
-  'aria-modal': { category: ['widget'], type: 'boolean', default: false },
-  'aria-multiline': { category: ['widget'], type: 'boolean', default: false },
-  'aria-multiselectable': { category: ['widget'], type: 'boolean', default: false },
-  'aria-orientation': { category: ['widget'], type: 'enum', default: undefined, values: ['horizontal', 'vertical'] },
+  'aria-level': { category: ['widget'], type: 'integer' },
+  'aria-modal': { category: ['widget'], type: 'true/false', default: false },
+  'aria-multiline': { category: ['widget'], type: 'true/false', default: false },
+  'aria-multiselectable': { category: ['widget'], type: 'true/false', default: false },
+  'aria-orientation': { category: ['widget'], type: 'token', default: undefined, values: ['horizontal', 'vertical'] },
   'aria-placeholder': { category: ['widget'], type: 'string' },
-  'aria-pressed': { category: ['widget'], type: 'enum', values: ['true', 'false', 'mixed'], default: undefined },
-  'aria-readonly': { category: ['widget'], type: 'boolean', default: false },
-  'aria-required': { category: ['widget'], type: 'boolean', default: false },
-  'aria-selected': { category: ['widget'], type: 'boolean', default: undefined },
+  'aria-pressed': { category: ['widget'], type: 'tristate', default: undefined },
+  'aria-readonly': { category: ['widget'], type: 'true/false', default: false },
+  'aria-required': { category: ['widget'], type: 'true/false', default: false },
+  'aria-selected': { category: ['widget'], type: 'true/false/undefined', default: undefined },
   'aria-sort': {
     category: ['widget'],
-    type: 'enum',
+    type: 'token',
     default: 'none',
     values: ['ascending', 'descending', 'none', 'other'],
   },
-  'aria-valuemax': { category: ['widget'], type: 'number' },
+  'aria-valuemax': { category: ['widget'], type: 'number', default: undefined },
   'aria-valuemin': { category: ['widget'], type: 'number' },
   'aria-valuenow': { category: ['widget'], type: 'number' },
-  'aria-valuetext': { category: ['widget'], type: 'string' },
+  'aria-valuetext': { category: ['widget'], type: 'string', default: undefined },
 };
 
 export const liveregionAttributes: Record<LiveRegionAttribute, AttributeData> = {
@@ -106,11 +102,11 @@ export const draganddropAttributes: Record<DragAndDropAttribute, AttributeData>
 };
 
 export const relationshipAttributes: Record<RelationshipAttribute, AttributeData> = {
-  'aria-activedescendant': { category: ['relationship'], type: 'string' },
-  'aria-colcount': { category: ['relationship'], type: 'string' },
-  'aria-colindex': { category: ['relationship'], type: 'number' },
+  'aria-activedescendant': { category: ['relationship'], type: 'idRef' },
+  'aria-colcount': { category: ['relationship'], type: 'integer' },
+  'aria-colindex': { category: ['relationship'], type: 'integer' },
   'aria-colindextext': { category: ['relationship'], type: 'string' },
-  'aria-colspan': { category: ['relationship'], type: 'number' },
+  'aria-colspan': { category: ['relationship'], type: 'integer' },
   'aria-controls': globalAttributes['aria-controls'],
   'aria-describedby': globalAttributes['aria-describedby'],
   'aria-details': globalAttributes['aria-details'],
@@ -118,12 +114,12 @@ export const relationshipAttributes: Record<RelationshipAttribute, AttributeData
   'aria-flowto': globalAttributes['aria-flowto'],
   'aria-labelledby': globalAttributes['aria-labelledby'],
   'aria-owns': globalAttributes['aria-owns'],
-  'aria-posinset': { category: ['relationship'], type: 'number' },
-  'aria-rowcount': { category: ['relationship'], type: 'string' },
-  'aria-rowindex': { category: ['relationship'], type: 'number' },
+  'aria-posinset': { category: ['relationship'], type: 'integer' },
+  'aria-rowcount': { category: ['relationship'], type: 'integer' },
+  'aria-rowindex': { category: ['relationship'], type: 'integer' },
   'aria-rowindextext': { category: ['relationship'], type: 'string' },
-  'aria-rowspan': { category: ['relationship'], type: 'number' },
-  'aria-setsize': { category: ['relationship'], type: 'number' },
+  'aria-rowspan': { category: ['relationship'], type: 'integer' },
+  'aria-setsize': { category: ['relationship'], type: 'integer' },
 };
 
 // Note: this would also throw a type error if we missed any!
diff --git a/src/lib/aria-roles.ts b/src/lib/aria-roles.ts
index abe1b25..140bb6f 100644
--- a/src/lib/aria-roles.ts
+++ b/src/lib/aria-roles.ts
@@ -952,7 +952,7 @@ export const documentRoles: Record<DocumentStructureRole, RoleData> = {
   /** A container for a collection of elements that form an image. See synonym image. */
   img: {
     allowedChildRoles: [],
-    childrenPresentational: false,
+    childrenPresentational: true,
     defaultAttributeValues: {},
     elements: [{ tagName: 'img' }],
     name: 'img',
@@ -1129,7 +1129,7 @@ export const documentRoles: Record<DocumentStructureRole, RoleData> = {
     defaultAttributeValues: {},
     elements: [],
     name: 'presentation',
-    nameFrom: 'author',
+    nameFrom: 'prohibited',
     nameRequired: false,
     prohibited: ['aria-braillelabel', 'aria-label', 'aria-labelledby'],
     required: [],
diff --git a/src/lib/html.ts b/src/lib/html.ts
index 2a66660..9a994e6 100644
--- a/src/lib/html.ts
+++ b/src/lib/html.ts
@@ -27,6 +27,27 @@ export interface TagInfo {
   namingProhibited: boolean;
 }
 
+/**
+ * SVG elements that are always hidden from screenreaders.
+ * @see https://www.w3.org/TR/svg-aam-1.0/#include_elements
+ */
+const SVG_ALWAYS_INACCESSIBLE_ELEMENT: TagInfo = {
+  defaultRole: 'none',
+  namingProhibited: true,
+  supportedRoles: [],
+  supportedAttributesOverride: [],
+};
+/**
+ * SVG elements that by default aren’t added to the a11y tree, but MAY be included if certain criteria are met.
+ * @see https://www.w3.org/TR/svg-aam-1.0/#include_elements
+ */
+const SVG_MAYBE_ACCESSIBLE_ELEMENT: TagInfo = {
+  defaultRole: 'none', // ⚠️ these elements will get different default roles if they have an accessible name, but they all default to 'none'
+  namingProhibited: true,
+  supportedRoles: ALL_ROLES,
+  supportedAttributesOverride: undefined,
+};
+
 export const tags: Record<TagName, TagInfo> = {
   // Main root
   html: {
@@ -756,106 +777,76 @@ export const tags: Record<TagName, TagInfo> = {
 
   // SVG
   // @see https://www.w3.org/TR/svg-aam-1.0/#mapping_role_table
-  animate: {
-    defaultRole: 'none',
-    namingProhibited: true,
-    supportedRoles: [],
-    supportedAttributesOverride: [],
-  },
-  animateMotion: {
-    defaultRole: 'none',
-    namingProhibited: true,
-    supportedRoles: [],
-    supportedAttributesOverride: [],
-  },
-  animateTransform: {
-    defaultRole: 'none',
-    namingProhibited: true,
-    supportedRoles: [],
-    supportedAttributesOverride: [],
-  },
-  circle: {
-    defaultRole: 'graphics-symbol',
-    namingProhibited: false,
-    supportedRoles: ALL_ROLES,
-    supportedAttributesOverride: undefined,
-  },
-  clipPath: {
-    defaultRole: 'none',
-    namingProhibited: true,
-    supportedRoles: [],
-    supportedAttributesOverride: [],
-  },
-  cursor: {
-    defaultRole: 'none',
-    namingProhibited: true,
-    supportedRoles: [],
-    supportedAttributesOverride: [],
-  },
-  defs: {
-    defaultRole: 'none',
-    namingProhibited: true,
-    supportedRoles: [],
-    supportedAttributesOverride: [],
-  },
-  desc: {
-    defaultRole: 'none',
-    namingProhibited: true,
-    supportedRoles: [],
-    supportedAttributesOverride: [],
-  },
-  discard: {
-    defaultRole: 'none',
-    namingProhibited: true,
-    supportedRoles: [],
-    supportedAttributesOverride: [],
-  },
-  ellipse: {
-    defaultRole: 'graphics-symbol',
-    namingProhibited: false,
-    supportedRoles: ALL_ROLES,
-    supportedAttributesOverride: undefined,
-  },
-  g: {
-    defaultRole: NO_CORRESPONDING_ROLE,
-    namingProhibited: false,
-    supportedRoles: ['group', 'graphics-object'],
-    supportedAttributesOverride: undefined,
-  },
-  switch: {
-    defaultRole: 'none',
-    namingProhibited: false,
-    supportedRoles: [],
-    supportedAttributesOverride: [],
-  },
-  symbol: {
-    defaultRole: 'graphics-object',
-    namingProhibited: false,
-    supportedRoles: ALL_ROLES,
-    supportedAttributesOverride: undefined,
-  },
+  // a: (use HTML <a>)
+  animate: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  animateMotion: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  animateTransform: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  // audio: (use HTML <audio>)
+  // canvas: (use HTML <canvas>)
+  circle: SVG_MAYBE_ACCESSIBLE_ELEMENT,
+  clipPath: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  defs: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  desc: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  ellipse: SVG_MAYBE_ACCESSIBLE_ELEMENT,
+  feBlend: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feColorMatrix: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feComponentTransfer: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feComposite: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feConvolveMatrix: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feDiffuseLighting: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feDisplacementMap: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feDistantLight: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feDropShadow: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feFlood: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feFuncA: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feFuncB: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feFuncG: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feFuncR: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feGaussianBlur: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feImage: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feMerge: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feMergeNode: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feMorphology: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feOffset: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  fePointLight: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feSpecularLighting: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feSpotLight: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feTile: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  feTurbulence: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  filter: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  foreignObject: SVG_MAYBE_ACCESSIBLE_ELEMENT,
+  g: SVG_MAYBE_ACCESSIBLE_ELEMENT,
+  image: SVG_MAYBE_ACCESSIBLE_ELEMENT,
+  line: SVG_MAYBE_ACCESSIBLE_ELEMENT,
+  linearGradient: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  marker: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  mask: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  metadata: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  mpath: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  path: SVG_MAYBE_ACCESSIBLE_ELEMENT,
+  pattern: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  polygon: SVG_MAYBE_ACCESSIBLE_ELEMENT,
+  polyline: SVG_MAYBE_ACCESSIBLE_ELEMENT,
+  radialGradient: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  rect: SVG_MAYBE_ACCESSIBLE_ELEMENT,
+  set: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  stop: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  // style: (use HTML <style>)
+  switch: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  symbol: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
+  // Note: text is the ONLY SVG element that defaults to "group" unconditionally
+  // because it contains text nodes by its nature.
   text: {
     defaultRole: 'group',
     namingProhibited: false,
     supportedRoles: ALL_ROLES,
     supportedAttributesOverride: undefined,
   },
-  textPath: {
-    defaultRole: 'group',
-    namingProhibited: false,
-    supportedRoles: ALL_ROLES,
-    supportedAttributesOverride: undefined,
-  },
-  tspan: {
-    defaultRole: 'group',
-    namingProhibited: false,
-    supportedRoles: ALL_ROLES,
-    supportedAttributesOverride: undefined,
-  },
-  use: {
-    defaultRole: 'graphics-object',
-    namingProhibited: false,
-    supportedRoles: ['group', 'graphics-object'],
-    supportedAttributesOverride: undefined,
-  },
+  textPath: SVG_MAYBE_ACCESSIBLE_ELEMENT,
+  // title: (use HTML <title>)
+  // track: (use HTML <track>)
+  tspan: SVG_MAYBE_ACCESSIBLE_ELEMENT,
+  use: SVG_MAYBE_ACCESSIBLE_ELEMENT,
+  // video: (use HTML <video>)
+  view: SVG_ALWAYS_INACCESSIBLE_ELEMENT,
 };
diff --git a/src/lib/util.ts b/src/lib/util.ts
index 9645ad2..688f15f 100644
--- a/src/lib/util.ts
+++ b/src/lib/util.ts
@@ -28,10 +28,15 @@ export function firstMatchingToken<T>(tokenList: string, validValues: T[]): T |
 }
 
 export function getTagName(element: Element | VirtualElement): TagName {
-  if (typeof Element !== 'undefined' && element instanceof Element) {
-    return element.tagName.toLowerCase() as TagName;
+  // JSDOM bug: feDropShadow gets converted to fedropshadow. Since this library is often used in JSDOM contexts, we should handle this at runtime, cheaply
+  if (element.tagName === 'fedropshadow') {
+    return 'feDropShadow';
   }
-  return element.tagName as TagName;
+
+  // note: HTML is case-insensitive, but SVG is not. Browsers will normalize case-insensitive
+  // names to UPPERCASE (e.g. `BUTTON`), and leave SVG in its original camelCase format.
+  const caseInsensitive = /^[A-Z]/.test(element.tagName);
+  return (caseInsensitive ? element.tagName.toLowerCase() : element.tagName) as TagName;
 }
 
 /**
diff --git a/src/tags/svg.ts b/src/tags/svg.ts
new file mode 100644
index 0000000..4fb24f6
--- /dev/null
+++ b/src/tags/svg.ts
@@ -0,0 +1,57 @@
+import { type RoleData, roles } from '../lib/aria-roles.js';
+import { tags } from '../lib/html.js';
+import { attr } from '../lib/util.js';
+import type { TagName, VirtualElement } from '../types.js';
+
+// ONLY applied if it meets the criteria
+const SVG_ACCESSIBLE_ROLE_MAPPING = {
+  circle: roles['graphics-symbol'],
+  ellipse: roles['graphics-symbol'],
+  foreignObject: roles.group,
+  g: roles.group,
+  line: roles['graphics-symbol'],
+  image: roles.img,
+  path: roles['graphics-symbol'],
+  polygon: roles['graphics-symbol'],
+  polyline: roles['graphics-symbol'],
+  rect: roles['graphics-symbol'],
+  // Note: open issue https://www.w3.org/TR/svg-aam-1.0/#textpath-tspan-mappings-issue
+  textPath: roles.group,
+  // Note: open issue https://www.w3.org/TR/svg-aam-1.0/#textpath-tspan-mappings-issue
+  tspan: roles.group,
+  use: roles['graphics-object'],
+};
+
+/**
+ * Handles role mapping for all SVG elements (<circle>, <rect>, <polygon>, etc.). because they
+ * share logic.
+ * @see https://www.w3.org/TR/svg-aam-1.0/#include_elements
+ */
+export function getSvgElementRole(element: Element | VirtualElement): RoleData | undefined {
+  const defaultRole = roles[tags[element.tagName as keyof typeof tags]?.defaultRole!];
+  if (!(element.tagName in SVG_ACCESSIBLE_ROLE_MAPPING)) {
+    return defaultRole;
+  }
+
+  const accessibleRole = SVG_ACCESSIBLE_ROLE_MAPPING[element.tagName as keyof typeof SVG_ACCESSIBLE_ROLE_MAPPING];
+
+  const ariaHidden = attr(element, 'aria-hidden');
+  const isHidden = ariaHidden === '' || String(ariaHidden) === 'true';
+  const hasLabel =
+    !isHidden &&
+    (attr(element, 'aria-label') ||
+      attr(element, 'aria-labelledby') ||
+      attr(element, 'aria-describedby') ||
+      attr(element, 'aria-roledescription'));
+  if (hasLabel) {
+    return accessibleRole;
+  }
+
+  // Check for <title> or <desc> children that have text content after trimming whitespace
+  const hasTextChild = 'querySelector' in element && element.querySelector('title,desc')?.textContent?.trim().length;
+  if (hasTextChild) {
+    return accessibleRole;
+  }
+
+  return defaultRole;
+}
diff --git a/src/types.d.ts b/src/types.d.ts
index a159951..0efdaf8 100644
--- a/src/types.d.ts
+++ b/src/types.d.ts
@@ -149,10 +149,8 @@ export type TagName =
   | 'animateTransform'
   | 'circle'
   | 'clipPath'
-  | 'cursor'
   | 'defs'
   | 'desc'
-  | 'discard'
   | 'ellipse'
   | 'feBlend'
   | 'feColorMatrix'
@@ -182,16 +180,11 @@ export type TagName =
   | 'filter'
   | 'foreignObject'
   | 'g'
-  | 'hatch'
-  | 'hatchPath'
   | 'image'
   | 'line'
   | 'linearGradient'
   | 'marker'
   | 'mask'
-  | 'mesh'
-  | 'meshPatch'
-  | 'meshRow'
   | 'metadata'
   | 'mpath'
   | 'path'
@@ -201,7 +194,6 @@ export type TagName =
   | 'radialGradient'
   | 'rect'
   | 'set'
-  | 'solidColor'
   | 'stop'
   | 'switch'
   | 'symbol'
@@ -362,26 +354,43 @@ export type NameProhibitedAttributes =
   | 'aria-label'
   | 'aria-labelledby'
   | 'aria-roledescription';
-/** Attribute may essentially allow any value. As a general rule, empty strings are NOT valid. */
-export type StringAttribute = { type: 'string'; default?: never; values?: never };
-/** Boolean attributes are essentially the same as enum types whose only allowed values are ["true", "false"] */
-export type BooleanAttribute = { type: 'boolean'; default: boolean | undefined; values?: never };
+/** Value representing either `true` or `false`. The default value for this value type is `false` unless otherwise specified. */
+export type TrueFalseAttribute = { type: 'true/false'; default: boolean; values?: never };
+/** Value representing `true`, `false`, `mixed`, or `undefined` values. The default value for this value type is `undefined` unless otherwise specified. */
+export type TristateAttribute = { type: 'tristate'; default: string | undefined; values?: never };
 /**
- * Enum attributes only allow one of a list of specific values.
- * Note that if a tokenlist (space-separated list) is allowed, it is type: "string".
- * Although the spec does allow “undefined” as a valid value (e.g.
- * aria-checked), that indicates the absence of the attribute altogether; this
- * only tests the presence of attributes, thus, `undefined` is omitted.
+ * Value representing `true`, `false`, or `undefined` (not applicable). The default
+ * value for this value type is `undefined` unless otherwise specified. For
+ * example, an element with aria-expanded set to `false` is not currently
+ * expanded; an element with aria-expanded set to `undefined` is not expandable.
  */
-export type EnumAttribute = { type: 'enum'; default: string | undefined; values: string[] };
-/** Number attributes represent both integer and scalar (floating point) types. */
+export type TrueFalseUndefinedAttribute = { type: 'true/false/undefined'; default: undefined; values?: never };
+/** Reference to the ID of another element in the same document */
+export type IDRefAttribute = { type: 'idRef'; default?: never; values?: never };
+/** A list of one or more ID references. */
+export type IDRefListAttribute = { type: 'idRefList'; default?: never; values?: never };
+/** A numerical value without a fractional component. */
+export type IntegerAttribute = { type: 'integer'; default?: never; values?: never };
+/** Any real numerical value. */
 export type NumberAttribute = { type: 'number'; default?: never; values?: never };
+/** Unconstrained value type. */
+export type StringAttribute = { type: 'string'; default?: never; values?: never };
+/** One of a limited set of allowed values. The default value is defined in each attribute's Values table, as specified in the Attribute Values section. */
+export type TokenAttribute = { type: 'token'; default: string | undefined; values: string[] };
+/** A list of one or more tokens. */
+export type TokenListAttribute = { type: 'tokenList'; default: string | undefined; values: string[] };
 
 export type AttributeData = { category: AttributeCategory[] } & (
-  | StringAttribute
-  | BooleanAttribute
-  | EnumAttribute
+  | TrueFalseAttribute
+  | TristateAttribute
+  | TrueFalseUndefinedAttribute
+  | IDRefAttribute
+  | IDRefListAttribute
+  | IntegerAttribute
   | NumberAttribute
+  | StringAttribute
+  | TokenAttribute
+  | TokenListAttribute
 );
 
 /**
diff --git a/test/dom/get-role.test.ts b/test/dom/get-role.test.ts
index 19b3f39..0819d51 100644
--- a/test/dom/get-role.test.ts
+++ b/test/dom/get-role.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
 import { NO_CORRESPONDING_ROLE, getRole, getTagName, tags } from '../../src/index.js';
-import { checkTestAndTagName, setUpDOM } from '../helpers.js';
+import { checkAllTagsTested, checkTestAndTagName, setUpDOM } from '../helpers.js';
 
 describe('getRole', () => {
   /**
@@ -91,7 +91,6 @@ describe('getRole', () => {
     ['footer', { given: ['<footer></footer>', 'footer'], want: 'contentinfo' }],
     ['footer (landmark)', { given: ['<article><footer></footer></article>', 'footer'], want: 'generic' }],
     ['form', { given: ['<form></form>', 'form'], want: 'form' }],
-    ['g', { given: ['<g></g>', 'g'], want: NO_CORRESPONDING_ROLE }],
     ['h1', { given: ['<h1></h1>', 'h1'], want: 'heading' }],
     ['h2', { given: ['<h2></h2>', 'h2'], want: 'heading' }],
     ['h3', { given: ['<h3></h3>', 'h3'], want: 'heading' }],
@@ -337,83 +336,147 @@ describe('getRole', () => {
     ],
     ['animate', { given: ['<svg><animate></animate></svg>', 'animate'], want: 'none' }],
     ['animateMotion', { given: ['<svg><animateMotion></animateMotion></svg>', 'animateMotion'], want: 'none' }],
-    ['circle', { given: ['<svg><circle></circle></svg>', 'circle'], want: 'graphics-symbol' }],
+    [
+      'animateTransform',
+      { given: ['<svg><animateTransform></animateTransform></svg>', 'animateTransform'], want: 'none' },
+    ],
+    ['circle', { given: ['<svg><circle /></svg>', 'circle'], want: 'none' }],
+    ['circle (empty title)', { given: ['<svg><circle><title></title></circle></svg>', 'circle'], want: 'none' }],
+    [
+      'circle (title)',
+      { given: ['<svg><circle><title>Circle</title></circle></svg>', 'circle'], want: 'graphics-symbol' },
+    ],
+    ['circle (empty desc)', { given: ['<svg><circle /></svg>', 'circle'], want: 'none' }],
+    [
+      'circle (desc)',
+      { given: ['<svg><circle><desc>Circle</desc></circle></svg>', 'circle'], want: 'graphics-symbol' },
+    ],
+    ['circle[aria-label]', { given: ['<svg><circle aria-label="Circle" /></svg>', 'circle'], want: 'graphics-symbol' }],
+    [
+      'circle[aria-label][aria-hidden]',
+      { given: ['<svg><circle aria-label="Circle" aria-hidden /></svg>', 'circle'], want: 'none' },
+    ],
+    [
+      'circle[aria-labelledby]',
+      { given: ['<svg><circle aria-labelledby="element" /></svg>', 'circle'], want: 'graphics-symbol' },
+    ],
+    [
+      'circle[aria-describedby]',
+      { given: ['<svg><circle aria-describedby="element" /></svg>', 'circle'], want: 'graphics-symbol' },
+    ],
+    [
+      'circle[aria-roledescription]',
+      {
+        given: ['<svg><circle aria-roledescription="Interactive circle element" /></svg>', 'circle'],
+        want: 'graphics-symbol',
+      },
+    ],
     ['clipPath', { given: ['<svg><clipPath></clipPath></svg>', 'clipPath'], want: 'none' }],
-    ['cursor', { given: ['<svg><cursor></cursor></svg>', 'cursor'], want: 'none' }],
     ['defs', { given: ['<svg><defs></defs></svg>', 'defs'], want: 'none' }],
     ['desc', { given: ['<svg><desc></desc></svg>', 'desc'], want: 'none' }],
-    ['discard', { given: ['<svg><discard></discard></svg>', 'discard'], want: 'none' }],
-    ['ellipse', { given: ['<svg><ellipse></ellipse></svg>', 'ellipse'], want: 'graphics-symbol' }],
-    ['feBlend', { given: ['<svg><feBlend></feBlend></svg>', 'feBlend'], want: 'none' }],
-    ['feColorMatrix', { given: ['<svg><feColorMatrix></feColorMatrix></svg>', 'feColorMatrix'], want: 'none' }],
+    ['ellipse', { given: ['<svg><ellipse /></svg>', 'ellipse'], want: 'none' }],
+    ['feBlend', { given: ['<svg><filter><feBlend /></filter></svg>', 'feBlend'], want: 'none' }],
+    ['feColorMatrix', { given: ['<svg><filter><feColorMatrix /></filter></svg>', 'feColorMatrix'], want: 'none' }],
     [
       'feComponentTransfer',
-      { given: ['<svg><feComponentTransfer></feComponentTransfer></svg>', 'feComponentTransfer'], want: 'none' },
+      { given: ['<svg><filter><feComponentTransfer /></filter></svg>', 'feComponentTransfer'], want: 'none' },
     ],
-    ['feComposite', { given: ['<svg><feComposite></feComposite></svg>', 'feComposite'], want: 'none' }],
+    ['feComposite', { given: ['<svg><filter><feComposite /></filter></svg>', 'feComposite'], want: 'none' }],
     [
       'feConvolveMatrix',
-      { given: ['<svg><feConvolveMatrix></feConvolveMatrix></svg>', 'feConvolveMatrix'], want: 'none' },
+      { given: ['<svg><filter><feConvolveMatrix /></filter></svg>', 'feConvolveMatrix'], want: 'none' },
     ],
     [
       'feDiffuseLighting',
-      { given: ['<svg><feDiffuseLighting></feDiffuseLighting></svg>', 'feDiffuseLighting'], want: 'none' },
+      {
+        given: ['<svg><filter><feDiffuseLighting></feDiffuseLighting></filter></svg>', 'feDiffuseLighting'],
+        want: 'none',
+      },
     ],
     [
       'feDisplacementMap',
-      { given: ['<svg><feDisplacementMap></feDisplacementMap></svg>', 'feDisplacementMap'], want: 'none' },
-    ],
-    ['feDistantLight', { given: ['<svg><feDistantLight></feDistantLight></svg>', 'feDistantLight'], want: 'none' }],
-    ['feDropShadow', { given: ['<svg><feDropShadow></feDropShadow></svg>', 'feDropShadow'], want: 'none' }],
-    ['feFlood', { given: ['<svg><feFlood></feFlood></svg>', 'feFlood'], want: 'none' }],
-    ['feFuncA', { given: ['<svg><feFuncA></feFuncA></svg>', 'feFuncA'], want: 'none' }],
-    ['feFuncB', { given: ['<svg><feFuncB></feFuncB></svg>', 'feFuncB'], want: 'none' }],
-    ['feFuncG', { given: ['<svg><feFuncG></feFuncG></svg>', 'feFuncG'], want: 'none' }],
-    ['feFuncR', { given: ['<svg><feFuncR></feFuncR></svg>', 'feFuncR'], want: 'none' }],
-    ['feGaussianBlur', { given: ['<svg><feGaussianBlur></feGaussianBlur></svg>', 'feGaussianBlur'], want: 'none' }],
-    ['feImage', { given: ['<svg><feImage></feImage></svg>', 'feImage'], want: 'none' }],
-    ['feMerge', { given: ['<svg><feMerge></feMerge></svg>', 'feMerge'], want: 'none' }],
-    ['feMergeNode', { given: ['<svg><feMergeNode></feMergeNode></svg>', 'feMergeNode'], want: 'none' }],
-    ['feMorphology', { given: ['<svg><feMorphology></feMorphology></svg>', 'feMorphology'], want: 'none' }],
-    ['feOffset', { given: ['<svg><feOffset></feOffset></svg>', 'feOffset'], want: 'none' }],
-    ['fePointLight', { given: ['<svg><fePointLight></fePointLight></svg>', 'fePointLight'], want: 'none' }],
+      { given: ['<svg><filter><feDisplacementMap /></filter></svg>', 'feDisplacementMap'], want: 'none' },
+    ],
+    [
+      'feDistantLight',
+      {
+        given: [
+          '<svg><filter><feSpecularLighting><feDistantLight /></feSpecularLighting></filter></svg>',
+          'feDistantLight',
+        ],
+        want: 'none',
+      },
+    ],
+    [
+      'feDropShadow',
+      {
+        given: ['<svg><filter><feDropShadow /></filter></svg>', 'feDropShadow'],
+        want: 'none',
+      },
+    ],
+    ['feFlood', { given: ['<svg><filter><feFlood /></filter></svg>', 'feFlood'], want: 'none' }],
+    ['feFuncA', { given: ['<svg><filter><feFuncA /></filter></svg>', 'feFuncA'], want: 'none' }],
+    ['feFuncB', { given: ['<svg><filter><feFuncB /></filter></svg>', 'feFuncB'], want: 'none' }],
+    ['feFuncG', { given: ['<svg><filter><feFuncG /></filter></svg>', 'feFuncG'], want: 'none' }],
+    ['feFuncR', { given: ['<svg><filter><feFuncR /></filter></svg>', 'feFuncR'], want: 'none' }],
+    ['feGaussianBlur', { given: ['<svg><filter><feGaussianBlur /></filter></svg>', 'feGaussianBlur'], want: 'none' }],
+    ['feImage', { given: ['<svg><filter><feImage /></filter></svg>', 'feImage'], want: 'none' }],
+    ['feMerge', { given: ['<svg><filter><feMerge /></filter></svg>', 'feMerge'], want: 'none' }],
+    ['feMergeNode', { given: ['<svg><filter><feMergeNode /></filter></svg>', 'feMergeNode'], want: 'none' }],
+    ['feMorphology', { given: ['<svg><filter><feMorphology /></filter></svg>', 'feMorphology'], want: 'none' }],
+    ['feOffset', { given: ['<svg><filter><feOffset /></filter></svg>', 'feOffset'], want: 'none' }],
+    [
+      'fePointLight',
+      {
+        given: [
+          '<svg><filter><feSpecularLighting><fePointLight /></feSpecularLighting></filter></svg>',
+          'fePointLight',
+        ],
+        want: 'none',
+      },
+    ],
     [
       'feSpecularLighting',
-      { given: ['<svg><feSpecularLighting></feSpecularLighting></svg>', 'feSpecularLighting'], want: 'none' },
+      {
+        given: ['<svg><filter><feSpecularLighting></feSpecularLighting></filter></svg>', 'feSpecularLighting'],
+        want: 'none',
+      },
+    ],
+    [
+      'feSpotLight',
+      {
+        given: ['<svg><filter><feSpecularLighting><feSpotLight /></feSpecularLighting></filter></svg>', 'feSpotLight'],
+        want: 'none',
+      },
     ],
-    ['feSpotLight', { given: ['<svg><feSpotLight></feSpotLight></svg>', 'feSpotLight'], want: 'none' }],
-    ['feTile', { given: ['<svg><feTile></feTile></svg>', 'feTile'], want: 'none' }],
-    ['feTurbulence', { given: ['<svg><feTurbulence></feTurbulence></svg>', 'feTurbulence'], want: 'none' }],
+    ['feTile', { given: ['<svg><filter><feTile /></fitler></svg>', 'feTile'], want: 'none' }],
+    ['feTurbulence', { given: ['<svg><filter><feTurbulence /></filter></svg>', 'feTurbulence'], want: 'none' }],
     ['filter', { given: ['<svg><filter></filter></svg>', 'filter'], want: 'none' }],
     ['foreignObject', { given: ['<svg><foreignObject></foreignObject></svg>', 'foreignObject'], want: 'none' }],
-    ['g', { given: ['<svg><g></g></svg>', 'g'], want: 'group' }],
-    ['hatch', { given: ['<svg><hatch></hatch></svg>', 'hatch'], want: 'none' }],
-    ['hatchPath', { given: ['<svg><hatchPath></hatchPath></svg>', 'hatchPath'], want: 'none' }],
-    ['image', { given: ['<svg><image></image></svg>', 'image'], want: 'img' }],
-    ['line', { given: ['<svg><line></line></svg>', 'line'], want: 'graphics-symbol' }],
+    ['g', { given: ['<svg><g></g></svg>', 'g'], want: 'none' }],
+    ['g (title)', { given: ['<svg><g><title>Group</title></g></svg>', 'g'], want: 'group' }],
+    ['image', { given: ['<svg><image></image></svg>', 'image'], want: 'none' }],
+    ['line', { given: ['<svg><line></line></svg>', 'line'], want: 'none' }],
     ['linearGradient', { given: ['<svg><linearGradient></linearGradient></svg>', 'linearGradient'], want: 'none' }],
     ['marker', { given: ['<svg><marker></marker></svg>', 'marker'], want: 'none' }],
     ['mask', { given: ['<svg><mask></mask></svg>', 'mask'], want: 'none' }],
-    ['mesh', { given: ['<svg><mesh></mesh></svg>', 'mesh'], want: 'none' }],
-    ['meshPatch', { given: ['<svg><meshPatch></meshPatch></svg>', 'meshPatch'], want: 'none' }],
-    ['meshRow', { given: ['<svg><meshRow></meshRow></svg>', 'meshRow'], want: 'none' }],
     ['metadata', { given: ['<svg><metadata></metadata></svg>', 'metadata'], want: 'none' }],
-    ['mpath', { given: ['<svg><mpath></mpath></svg>', 'mpath'], want: 'none' }],
-    ['path', { given: ['<svg><path></path></svg>', 'path'], want: 'graphics-symbol' }],
+    ['mpath', { given: ['<svg><mpath /></svg>', 'mpath'], want: 'none' }],
+    ['path', { given: ['<svg><path /></svg>', 'path'], want: 'none' }],
     ['pattern', { given: ['<svg><pattern></pattern></svg>', 'pattern'], want: 'none' }],
-    ['polygon', { given: ['<svg><polygon></polygon></svg>', 'polygon'], want: 'graphics-symbol' }],
-    ['polyline', { given: ['<svg><polyline></polyline></svg>', 'polyline'], want: 'graphics-symbol' }],
+    ['polygon', { given: ['<svg><polygon /></svg>', 'polygon'], want: 'none' }],
+    ['polyline', { given: ['<svg><polyline /></svg>', 'polyline'], want: 'none' }],
     ['radialGradient', { given: ['<svg><radialGradient></radialGradient></svg>', 'radialGradient'], want: 'none' }],
-    ['rect', { given: ['<svg><rect></rect></svg>', 'rect'], want: 'graphics-symbol' }],
+    ['rect', { given: ['<svg><rect></rect></svg>', 'rect'], want: 'none' }],
     ['set', { given: ['<svg><set></set></svg>', 'set'], want: 'none' }],
-    ['solidcolor', { given: ['<svg><solidColor></solidColor></svg>', 'solidColor'], want: 'none' }],
-    ['stop', { given: ['<svg><stop></stop></svg>', 'stop'], want: 'none' }],
+    ['stop', { given: ['<svg><linearGradient><stop></stop></linearGradient></svg>', 'stop'], want: 'none' }],
     ['switch', { given: ['<svg><switch></switch></svg>', 'switch'], want: 'none' }],
     ['symbol', { given: ['<svg><symbol></symbol></svg>', 'symbol'], want: 'none' }],
     ['text', { given: ['<svg><text></text></svg>', 'text'], want: 'group' }],
-    ['textPath', { given: ['<svg><textPath></textPath></svg>', 'textPath'], want: 'group' }],
+    ['textPath', { given: ['<svg><textPath></textPath></svg>', 'textPath'], want: 'none' }],
     ['tspan', { given: ['<svg><tspan></tspan></svg>', 'tspan'], want: 'none' }],
-    ['use', { given: ['<svg><use></use></svg>', 'use'], want: 'graphics-symbol' }],
+    ['tspan (title)', { given: ['<svg><tspan></tspan></svg>', 'tspan'], want: 'none' }],
+    ['use', { given: ['<svg><use></use></svg>', 'use'], want: 'none' }],
     ['view', { given: ['<svg><view></view></svg>', 'view'], want: 'none' }],
   ];
 
@@ -428,11 +491,6 @@ describe('getRole', () => {
   });
 
   test('all tags are tested', () => {
-    const allTags = Object.keys(tags);
-    for (const tag of allTags) {
-      if (!testedTags.has(tag)) {
-        console.warn(`Tag "${tag}" is not tested`);
-      }
-    }
+    checkAllTagsTested(testedTags);
   });
 });
diff --git a/test/dom/get-supported-roles.test.ts b/test/dom/get-supported-roles.test.ts
index 16d2718..fb6b7a5 100644
--- a/test/dom/get-supported-roles.test.ts
+++ b/test/dom/get-supported-roles.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
 import { ALL_ROLES, NO_ROLES, getSupportedRoles, getTagName, isSupportedRole, tags } from '../../src/index.js';
-import { checkTestAndTagName, setUpDOM } from '../helpers.js';
+import { checkAllTagsTested, checkTestAndTagName, setUpDOM } from '../helpers.js';
 
 describe('getSupportedRoles', () => {
   const tests: [
@@ -90,7 +90,6 @@ describe('getSupportedRoles', () => {
       'footer (default)',
       { given: ['<footer></footer>', 'footer'], want: ['contentinfo', 'generic', 'group', 'none', 'presentation'] },
     ],
-    ['g', { given: ['<g></g>', 'g'], want: ['group', 'graphics-object'] }],
     ['h1', { given: ['<h1></h1>', 'h1'], want: ['heading', 'none', 'presentation', 'tab'] }],
     ['h2', { given: ['<h2></h2>', 'h2'], want: ['heading', 'none', 'presentation', 'tab'] }],
     ['h3', { given: ['<h3></h3>', 'h3'], want: ['heading', 'none', 'presentation', 'tab'] }],
@@ -397,25 +396,116 @@ describe('getSupportedRoles', () => {
     ['wbr', { given: ['<wbr></wbr>', 'wbr'], want: ['none', 'presentation'] }],
 
     // Custom elements
-    ['custom element', { given: ['<custom-element></custom-element>', 'custom-element'], want: [] }],
+    ['custom-element', { given: ['<custom-element></custom-element>', 'custom-element'], want: ALL_ROLES }],
     [
-      'custom element (role)',
-      { given: ['<custom-element role="button"></custom-element>', 'custom-element'], want: ['button'] },
+      'custom-element (role)',
+      { given: ['<custom-element role="button"></custom-element>', 'custom-element'], want: ALL_ROLES },
     ],
 
     // SVG
-    ['svg: circle', { given: ['<svg><circle></circle></svg>', 'circle'], want: ['graphics-object'] }],
-    ['svg: ellipse', { given: ['<svg><ellipse></ellipse></svg>', 'ellipse'], want: ['graphics-object'] }],
-    ['svg: image', { given: ['<svg><image></image></svg>', 'image'], want: ['graphics-object'] }],
-    ['svg: line', { given: ['<svg><line></line></svg>', 'line'], want: ['graphics-object'] }],
-    ['svg: path', { given: ['<svg><path></path></svg>', 'path'], want: ['graphics-object'] }],
-    ['svg: polygon', { given: ['<svg><polygon></polygon></svg>', 'polygon'], want: ['graphics-object'] }],
-    ['svg: polyline', { given: ['<svg><polyline></polyline></svg>', 'polyline'], want: ['graphics-object'] }],
-    ['svg: rect', { given: ['<svg><rect></rect></svg>', 'rect'], want: ['graphics-object'] }],
-    ['svg: text', { given: ['<svg><text></text></svg>', 'text'], want: ['graphics-object'] }],
-    ['svg: textPath', { given: ['<svg><textPath></textPath></svg>', 'textPath'], want: ['graphics-object'] }],
-    ['svg: tspan', { given: ['<svg><tspan></tspan></svg>', 'tspan'], want: ['graphics-object'] }],
-    ['svg: use', { given: ['<svg><use></use></svg>', 'use'], want: ['graphics-object'] }],
+    ['animate', { given: ['<svg><animate /></svg>', 'animate'], want: NO_ROLES }],
+    ['animateMotion', { given: ['<svg><animateMotion /></svg>', 'animateMotion'], want: NO_ROLES }],
+    ['animateTransform', { given: ['<svg><animateTransform /></svg>', 'animateTransform'], want: NO_ROLES }],
+    ['circle', { given: ['<svg><circle /></svg>', 'circle'], want: ALL_ROLES }],
+    ['clipPath', { given: ['<svg><clipPath /></svg>', 'clipPath'], want: NO_ROLES }],
+    ['defs', { given: ['<svg><defs /></svg>', 'defs'], want: NO_ROLES }],
+    ['desc', { given: ['<svg><desc /></svg>', 'desc'], want: NO_ROLES }],
+    ['ellipse', { given: ['<svg><ellipse /></svg>', 'ellipse'], want: ALL_ROLES }],
+    ['feBlend', { given: ['<svg><filter><feBlend /></filter></svg>', 'feBlend'], want: NO_ROLES }],
+    ['feColorMatrix', { given: ['<svg><filter><feColorMatrix /></filter></svg>', 'feColorMatrix'], want: NO_ROLES }],
+    [
+      'feComponentTransfer',
+      { given: ['<svg><filter><feComponentTransfer /></filter></svg>', 'feComponentTransfer'], want: NO_ROLES },
+    ],
+    ['feComposite', { given: ['<svg><filter><feComposite /></filter></svg>', 'feComposite'], want: NO_ROLES }],
+    [
+      'feConvolveMatrix',
+      { given: ['<svg><filter><feConvolveMatrix /></filter></svg>', 'feConvolveMatrix'], want: NO_ROLES },
+    ],
+    [
+      'feDiffuseLighting',
+      {
+        given: ['<svg><filter><feDiffuseLighting></feDiffuseLighting></filter></svg>', 'feDiffuseLighting'],
+        want: NO_ROLES,
+      },
+    ],
+    [
+      'feDisplacementMap',
+      { given: ['<svg><filter><feDisplacementMap /></filter></svg>', 'feDisplacementMap'], want: NO_ROLES },
+    ],
+    [
+      'feDistantLight',
+      {
+        given: [
+          '<svg><filter><feSpecularLighting><feDistantLight /></feSpecularLighting></filter></svg>',
+          'feDistantLight',
+        ],
+        want: NO_ROLES,
+      },
+    ],
+    ['feDropShadow', { given: ['<svg><filter><feDropShadow /></filter></svg>', 'feDropShadow'], want: NO_ROLES }],
+    ['feFlood', { given: ['<svg><filter><feFlood /></filter></svg>', 'feFlood'], want: NO_ROLES }],
+    ['feFuncA', { given: ['<svg><filter><feFuncA /></filter></svg>', 'feFuncA'], want: NO_ROLES }],
+    ['feFuncB', { given: ['<svg><filter><feFuncB /></filter></svg>', 'feFuncB'], want: NO_ROLES }],
+    ['feFuncG', { given: ['<svg><filter><feFuncG /></filter></svg>', 'feFuncG'], want: NO_ROLES }],
+    ['feFuncR', { given: ['<svg><filter><feFuncR /></filter></svg>', 'feFuncR'], want: NO_ROLES }],
+    ['feGaussianBlur', { given: ['<svg><filter><feGaussianBlur /></filter></svg>', 'feGaussianBlur'], want: NO_ROLES }],
+    ['feImage', { given: ['<svg><filter><feImage /></filter></svg>', 'feImage'], want: NO_ROLES }],
+    ['feMerge', { given: ['<svg><filter><feMerge /></filter></svg>', 'feMerge'], want: NO_ROLES }],
+    ['feMergeNode', { given: ['<svg><filter><feMergeNode /></filter></svg>', 'feMergeNode'], want: NO_ROLES }],
+    ['feMorphology', { given: ['<svg><filter><feMorphology /></filter></svg>', 'feMorphology'], want: NO_ROLES }],
+    ['feOffset', { given: ['<svg><filter><feOffset /></filter></svg>', 'feOffset'], want: NO_ROLES }],
+    [
+      'fePointLight',
+      {
+        given: [
+          '<svg><filter><feSpecularLighting><fePointLight /></feSpecularLighting></filter></svg>',
+          'fePointLight',
+        ],
+        want: NO_ROLES,
+      },
+    ],
+    [
+      'feSpecularLighting',
+      {
+        given: ['<svg><filter><feSpecularLighting></feSpecularLighting></filter></svg>', 'feSpecularLighting'],
+        want: NO_ROLES,
+      },
+    ],
+    [
+      'feSpotLight',
+      {
+        given: ['<svg><filter><feSpecularLighting><feSpotLight /></feSpecularLighting></filter></svg>', 'feSpotLight'],
+        want: NO_ROLES,
+      },
+    ],
+    ['feTile', { given: ['<svg><filter><feTile /></filter></svg>', 'feTile'], want: NO_ROLES }],
+    ['feTurbulence', { given: ['<svg><filter><feTurbulence /></filter></svg>', 'feTurbulence'], want: NO_ROLES }],
+    ['filter', { given: ['<svg><filter /></svg>', 'filter'], want: NO_ROLES }],
+    ['foreignObject', { given: ['<svg><foreignObject></foreignObject></svg>', 'foreignObject'], want: ALL_ROLES }],
+    ['g', { given: ['<svg><g /></svg>', 'g'], want: ALL_ROLES }],
+    ['image', { given: ['<svg><image /></svg>', 'image'], want: ALL_ROLES }],
+    ['line', { given: ['<svg><line /></svg>', 'line'], want: ALL_ROLES }],
+    ['linearGradient', { given: ['<svg><linearGradient /></svg>', 'linearGradient'], want: NO_ROLES }],
+    ['marker', { given: ['<svg><marker /></svg>', 'marker'], want: NO_ROLES }],
+    ['mask', { given: ['<svg><mask /></svg>', 'mask'], want: NO_ROLES }],
+    ['metadata', { given: ['<svg><metadata /></svg>', 'metadata'], want: NO_ROLES }],
+    ['mpath', { given: ['<svg><mpath /></svg>', 'mpath'], want: NO_ROLES }],
+    ['path', { given: ['<svg><path /></svg>', 'path'], want: ALL_ROLES }],
+    ['pattern', { given: ['<svg><pattern></pattern></svg>', 'pattern'], want: NO_ROLES }],
+    ['polygon', { given: ['<svg><polygon /></svg>', 'polygon'], want: ALL_ROLES }],
+    ['polyline', { given: ['<svg><polyline /></svg>', 'polyline'], want: ALL_ROLES }],
+    ['radialGradient', { given: ['<svg><radialGradient /></svg>', 'radialGradient'], want: NO_ROLES }],
+    ['rect', { given: ['<svg><rect /></svg>', 'rect'], want: ALL_ROLES }],
+    ['set', { given: ['<svg><set /></svg>', 'set'], want: NO_ROLES }],
+    ['stop', { given: ['<svg><linearGradient><stop /></linearGradient></svg>', 'stop'], want: NO_ROLES }],
+    ['switch', { given: ['<svg><switch /></svg>', 'switch'], want: NO_ROLES }],
+    ['symbol', { given: ['<svg><symbol></symbol></svg>', 'symbol'], want: NO_ROLES }],
+    ['text', { given: ['<svg><text /></svg>', 'text'], want: ALL_ROLES }],
+    ['textPath', { given: ['<svg><textPath /></svg>', 'textPath'], want: ALL_ROLES }],
+    ['tspan', { given: ['<svg><tspan /></svg>', 'tspan'], want: ALL_ROLES }],
+    ['use', { given: ['<svg><use /></svg>', 'use'], want: ALL_ROLES }],
+    ['view', { given: ['<svg><view /></svg>', 'view'], want: NO_ROLES }],
   ];
 
   const testedTags = new Set<string>();
@@ -429,12 +519,7 @@ describe('getSupportedRoles', () => {
   });
 
   test('all tags are tested', () => {
-    const allTags = Object.keys(tags);
-    for (const tag of allTags) {
-      if (!testedTags.has(tag)) {
-        console.warn(`Tag "${tag}" is not tested`);
-      }
-    }
+    checkAllTagsTested(testedTags);
   });
 });
 
diff --git a/test/dom/is-interactive.test.ts b/test/dom/is-interactive.test.ts
index b1eb523..26cac88 100644
--- a/test/dom/is-interactive.test.ts
+++ b/test/dom/is-interactive.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
 import { getTagName, isInteractive, tags } from '../../src/index.js';
-import { checkTestAndTagName, setUpDOM } from './../helpers';
+import { checkAllTagsTested, checkTestAndTagName, setUpDOM } from './../helpers';
 
 // add <div tabindex=0>
 // add <div role="button" tabindex=0>
@@ -59,7 +59,6 @@ describe('isInteractive', () => {
     ['figure', { given: ['<figure></figure>', 'figure'], want: false }],
     ['form', { given: ['<form></form>', 'form'], want: false }],
     ['footer', { given: ['<footer></footer>', 'footer'], want: false }],
-    ['g', { given: ['<g></g>', 'g'], want: false }],
     ['h1', { given: ['<h1></h1>', 'h1'], want: false }],
     ['h2', { given: ['<h2></h2>', 'h2'], want: false }],
     ['h3', { given: ['<h3></h3>', 'h3'], want: false }],
@@ -154,7 +153,6 @@ describe('isInteractive', () => {
     ['sub', { given: ['<sub></sub>', 'sub'], want: false }],
     ['summary', { given: ['<summary></summary>', 'summary'], want: false }],
     ['sup', { given: ['<sup></sup>', 'sub'], want: false }],
-    ['svg', { given: ['<svg></svg>', 'svg'], want: false }],
     ['table', { given: ['<table></table>', 'table'], want: false }],
     ['tbody', { given: ['<table><tbody></tbody></table>', 'tbody'], want: false }],
     ['td', { given: ['<table><td></td></table>', 'td'], want: false }],
@@ -195,6 +193,117 @@ describe('isInteractive', () => {
     ['var', { given: ['<var></var>', 'var'], want: false }],
     ['video', { given: ['<video></video>', 'video'], want: false }],
     ['wbr', { given: ['<wbr></wbr>', 'wbr'], want: false }],
+
+    // Custom elements
+    ['custom element', { given: ['<custom-element></custom-element>', 'custom-element'], want: false }],
+    [
+      'custom element[role=button]',
+      { given: ['<custom-element role="button"></custom-element>', 'custom-element'], want: false },
+    ],
+    [
+      'custom element[tabindex=0]',
+      { given: ['<custom-element tabindex="0"></custom-element>', 'custom-element'], want: false },
+    ],
+    [
+      'custom element[role=button,tabindex]=0',
+      { given: ['<custom-element role="button" tabindex="0"></custom-element>', 'custom-element'], want: true },
+    ],
+
+    // SVG
+    ['svg', { given: ['<svg></svg>', 'svg'], want: false }],
+    ['svg[role=button]', { given: ['<svg role="button"></svg>', 'svg'], want: false }],
+    ['svg[tabindex]', { given: ['<svg tabindex="0"></svg>', 'svg'], want: false }],
+    ['svg[role=button,tabindex]', { given: ['<svg role="button" tabindex="0"></svg>', 'svg'], want: true }],
+    ['animate', { given: ['<svg><animate></animate></svg>', 'animate'], want: false }],
+    ['animateMotion', { given: ['<svg><animateMotion></animateMotion></svg>', 'animateMotion'], want: false }],
+    [
+      'animateTransform',
+      { given: ['<svg><animateTransform></animateTransform></svg>', 'animateTransform'], want: false },
+    ],
+    ['circle', { given: ['<svg><circle /></svg>', 'circle'], want: false }],
+    ['circle[tabindex]', { given: ['<svg><circle tabindex="0" /></svg>', 'circle'], want: false }],
+    [
+      'circle[role=button,tabindex]',
+      { given: ['<svg><circle role="button" tabindex="0" /></svg>', 'circle'], want: true },
+    ],
+    ['clipPath', { given: ['<svg><clipPath></clipPath></svg>', 'clipPath'], want: false }],
+    ['defs', { given: ['<svg><defs></defs></svg>', 'defs'], want: false }],
+    ['desc', { given: ['<svg><desc></desc></svg>', 'desc'], want: false }],
+    ['ellipse', { given: ['<svg><ellipse /></svg>', 'ellipse'], want: false }],
+    ['feBlend', { given: ['<svg><filter><feBlend /></filter></svg>', 'feBlend'], want: false }],
+    ['feColorMatrix', { given: ['<svg><filter><feColorMatrix /></filter></svg>', 'feColorMatrix'], want: false }],
+    [
+      'feComponentTransfer',
+      { given: ['<svg><filter><feComponentTransfer /></filter></svg>', 'feComponentTransfer'], want: false },
+    ],
+    ['feComposite', { given: ['<svg><filter><feComposite /></filter></svg>', 'feComposite'], want: false }],
+    [
+      'feConvolveMatrix',
+      { given: ['<svg><filter><feConvolveMatrix /></filter></svg>', 'feConvolveMatrix'], want: false },
+    ],
+    [
+      'feDiffuseLighting',
+      { given: ['<svg><filter><feDiffuseLighting /></filter></svg>', 'feDiffuseLighting'], want: false },
+    ],
+    [
+      'feDisplacementMap',
+      { given: ['<svg><filter><feDisplacementMap /></filter></svg>', 'feDisplacementMap'], want: false },
+    ],
+    ['feDistantLight', { given: ['<svg><filter><feDistantLight /></filter></svg>', 'feDistantLight'], want: false }],
+    ['feDropShadow', { given: ['<svg><filter><feDropShadow /></filter></svg>', 'feDropShadow'], want: false }],
+    ['feFlood', { given: ['<svg><filter><feFlood /></filter></svg>', 'feFlood'], want: false }],
+    ['feFuncA', { given: ['<svg><filter><feFuncA /></filter></svg>', 'feFuncA'], want: false }],
+    ['feFuncB', { given: ['<svg><filter><feFuncB /></filter></svg>', 'feFuncB'], want: false }],
+    ['feFuncG', { given: ['<svg><filter><feFuncG /></filter></svg>', 'feFuncG'], want: false }],
+    ['feFuncR', { given: ['<svg><filter><feFuncR /></filter></svg>', 'feFuncR'], want: false }],
+    ['feGaussianBlur', { given: ['<svg><filter><feGaussianBlur /></filter></svg>', 'feGaussianBlur'], want: false }],
+    ['feImage', { given: ['<svg><filter><feImage /></filter></svg>', 'feImage'], want: false }],
+    ['feMerge', { given: ['<svg><filter><feMerge /></filter></svg>', 'feMerge'], want: false }],
+    ['feMergeNode', { given: ['<svg><filter><feMergeNode /></filter></svg>', 'feMergeNode'], want: false }],
+    ['feMorphology', { given: ['<svg><filter><feMorphology /></filter></svg>', 'feMorphology'], want: false }],
+    ['feOffset', { given: ['<svg><filter><feOffset /></filter></svg>', 'feOffset'], want: false }],
+    [
+      'fePointLight',
+      {
+        given: [
+          '<svg><filter><feSpecularLighting><fePointLight /></feSpecularLighting></filter></svg>',
+          'fePointLight',
+        ],
+        want: false,
+      },
+    ],
+    [
+      'feSpecularLighting',
+      { given: ['<svg><filter><feSpecularLighting /></filter></svg>', 'feSpecularLighting'], want: false },
+    ],
+    ['feSpotLight', { given: ['<svg><filter><feSpotLight /></filter></svg>', 'feSpotLight'], want: false }],
+    ['feTile', { given: ['<svg><filter><feTile /></filter></svg>', 'feTile'], want: false }],
+    ['feTurbulence', { given: ['<svg><filter><feTurbulence /></filter></svg>', 'feTurbulence'], want: false }],
+    ['filter', { given: ['<svg><filter></filter></svg>', 'filter'], want: false }],
+    ['foreignObject', { given: ['<svg><foreignObject></foreignObject></svg>', 'foreignObject'], want: false }],
+    ['g', { given: ['<svg><g></g></svg>', 'g'], want: false }],
+    ['image', { given: ['<svg><image></image></svg>', 'image'], want: false }],
+    ['line', { given: ['<svg><line></line></svg>', 'line'], want: false }],
+    ['linearGradient', { given: ['<svg><linearGradient></linearGradient></svg>', 'linearGradient'], want: false }],
+    ['marker', { given: ['<svg><marker></marker></svg>', 'marker'], want: false }],
+    ['mask', { given: ['<svg><mask></mask></svg>', 'mask'], want: false }],
+    ['metadata', { given: ['<svg><metadata></metadata></svg>', 'metadata'], want: false }],
+    ['mpath', { given: ['<svg><mpath /></svg>', 'mpath'], want: false }],
+    ['path', { given: ['<svg><path></path></svg>', 'path'], want: false }],
+    ['pattern', { given: ['<svg><pattern></pattern></svg>', 'pattern'], want: false }],
+    ['polygon', { given: ['<svg><polygon /></svg>', 'polygon'], want: false }],
+    ['polyline', { given: ['<svg><polyline /></svg>', 'polyline'], want: false }],
+    ['radialGradient', { given: ['<svg><radialGradient></radialGradient></svg>', 'radialGradient'], want: false }],
+    ['rect', { given: ['<svg><rect /></svg>', 'rect'], want: false }],
+    ['set', { given: ['<svg><set></set></svg>', 'set'], want: false }],
+    ['stop', { given: ['<svg><linearGradient><stop></stop></linearGradient></svg>', 'stop'], want: false }],
+    ['switch', { given: ['<svg><switch></switch></svg>', 'switch'], want: false }],
+    ['symbol', { given: ['<svg><symbol></symbol></svg>', 'symbol'], want: false }],
+    ['text', { given: ['<svg><text></text></svg>', 'text'], want: false }],
+    ['textPath', { given: ['<svg><textPath></textPath></svg>', 'textPath'], want: false }],
+    ['tspan', { given: ['<svg><tspan></tspan></svg>', 'tspan'], want: false }],
+    ['use', { given: ['<svg><use /></svg>', 'use'], want: false }],
+    ['view', { given: ['<svg><view></view></svg>', 'view'], want: false }],
   ];
 
   const testedTags = new Set<string>();
@@ -208,10 +317,6 @@ describe('isInteractive', () => {
 
   // Vitest bug: this breaks?
   // test('all tags are tested', () => {
-  //   // verify all tags tested
-  //   const allTags = Object.keys(tags);
-  //   for (const tag of allTags) {
-  //     expect(testedTags.has(tag), tag).toBe(true);
-  //   }
+  //   checkAllTagsTested(testedTags);
   // });
 });
diff --git a/test/helpers.ts b/test/helpers.ts
index 6e1d37b..10828a6 100644
--- a/test/helpers.ts
+++ b/test/helpers.ts
@@ -1,15 +1,27 @@
+import { tags } from '../src';
+
 /** Ensure no copypasta error */
 export function checkTestAndTagName(testName: string, tagName: string) {
   // ignore custom elements
   if (tagName.includes('-')) {
     return;
   }
-
   if (!testName.includes(tagName)) {
     throw new Error(`Test "${testName}" is testing tag "${tagName}". Has there been a mistake?`);
   }
 }
 
+const ALL_TAG_KEYS = Object.keys(tags);
+
+/** Ensure all tags are tested */
+export function checkAllTagsTested(testedTags: Set<string>) {
+  const untestedTags = new Set(ALL_TAG_KEYS.filter((tag) => !testedTags.has(tag)));
+  if (untestedTags.size) {
+    throw new Error(`The following tags are not tested:
+  - ${Array.from(untestedTags).join('  - ')}`);
+  }
+}
+
 /** Ensure list is sorted alphabetically. */
 export function copyAndSortList<T = unknown>(list: T[]): T[] {
   return [...list].sort();
@@ -33,5 +45,10 @@ export function setUpDOM(html: string, querySelector: string) {
   const container = document.createElement('div');
 
   container.innerHTML = html;
-  return { root: container, element: (container.querySelector(querySelector) || container.children[0]) as Element };
+  return {
+    root: container,
+    element: (container.querySelector(querySelector) ||
+      container.querySelector(querySelector.toLowerCase()) || // hack: jsdom and happy-dom convert `feDropShadow` to `feDropShadow`
+      container.children[0]) as Element,
+  };
 }
diff --git a/test/node/data-integrity.test.ts b/test/node/data-integrity.test.ts
index d3fb59e..656f695 100644
--- a/test/node/data-integrity.test.ts
+++ b/test/node/data-integrity.test.ts
@@ -10,7 +10,11 @@ describe('html data', () => {
   for (const [tag, tagData] of Object.entries(tags)) {
     if (tagData.defaultRole) {
       test(tag, () => {
-        expect(tagData.supportedRoles, 'defaultRole not in supportedRoles').toContain(tagData.defaultRole);
+        // Some tags have a role of "none" and are not allowed to take on any roles, e.g. SVG <filter>.
+        // Ignore those from the data check.
+        if (tagData.defaultRole !== 'none' && tagData.defaultRole !== 'presentation') {
+          expect(tagData.supportedRoles, 'defaultRole not in supportedRoles').toContain(tagData.defaultRole);
+        }
         const deduped = new Set(tagData.supportedRoles);
         expect(deduped.size, 'duplicate roles in supportedRoles').toBe(tagData.supportedRoles.length);
       });
@@ -57,4 +61,20 @@ describe('role data', () => {
       });
     });
   }
+
+  describe('synonyms', () => {
+    for (const [a, b] of [
+      ['image', 'img'],
+      ['none', 'presentation'],
+    ]) {
+      test(`${a} ↔ ${b}`, () => {
+        for (const [k, v] of Object.entries(roles[a])) {
+          if (k === 'name') {
+            continue;
+          }
+          expect(roles[b][k], k).toEqual(v);
+        }
+      });
+    }
+  });
 });
diff --git a/test/node/get-role.test.ts b/test/node/get-role.test.ts
index 754c4ea..519198c 100644
--- a/test/node/get-role.test.ts
+++ b/test/node/get-role.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
 import { NO_CORRESPONDING_ROLE, type TagName, getRole, tags } from '../../src/index.js';
-import { checkTestAndTagName } from '../helpers.js';
+import { checkAllTagsTested, checkTestAndTagName } from '../helpers.js';
 
 describe('getRole', () => {
   /**
@@ -419,12 +419,15 @@ describe('getRole', () => {
     ['animate', { given: [{ tagName: 'animate' }], want: 'none' }],
     ['animateMotion', { given: [{ tagName: 'animateMotion' }], want: 'none' }],
     ['animateTransform', { given: [{ tagName: 'animateTransform' }], want: 'none' }],
-    ['circle', { given: [{ tagName: 'circle' }], want: 'graphics-symbol' }],
+    ['circle', { given: [{ tagName: 'circle' }], want: 'none' }],
+    [
+      'circle[aria-label]',
+      { given: [{ tagName: 'circle', attributes: { 'aria-label': 'Circle' } }], want: 'graphics-symbol' },
+    ],
     ['clipPath', { given: [{ tagName: 'clipPath' }], want: 'none' }],
-    ['cursor', { given: [{ tagName: 'cursor' }], want: 'none' }],
     ['defs', { given: [{ tagName: 'defs' }], want: 'none' }],
-    ['discard', { given: [{ tagName: 'discard' }], want: 'none' }],
-    ['ellipse', { given: [{ tagName: 'ellipse' }], want: 'graphics-symbol' }],
+    ['desc', { given: [{ tagName: 'desc' }], want: 'none' }],
+    ['ellipse', { given: [{ tagName: 'ellipse' }], want: 'none' }],
     ['feBlend', { given: [{ tagName: 'feBlend' }], want: 'none' }],
     ['feColorMatrix', { given: [{ tagName: 'feColorMatrix' }], want: 'none' }],
     ['feComponentTransfer', { given: [{ tagName: 'feComponentTransfer' }], want: 'none' }],
@@ -452,34 +455,29 @@ describe('getRole', () => {
     ['feTurbulence', { given: [{ tagName: 'feTurbulence' }], want: 'none' }],
     ['filter', { given: [{ tagName: 'filter' }], want: 'none' }],
     ['foreignObject', { given: [{ tagName: 'foreignObject' }], want: 'none' }],
-    ['g', { given: [{ tagName: 'g' }], want: NO_CORRESPONDING_ROLE }],
-    ['hatch', { given: [{ tagName: 'hatch' }], want: 'none' }],
-    ['hatchPath', { given: [{ tagName: 'hatchPath' }], want: 'none' }],
-    ['image', { given: [{ tagName: 'image' }], want: 'img' }],
-    ['line', { given: [{ tagName: 'line' }], want: 'graphics-symbol' }],
+    ['g', { given: [{ tagName: 'g' }], want: 'none' }],
+    ['g[aria-label]', { given: [{ tagName: 'g', attributes: { 'aria-label': 'Group' } }], want: 'group' }],
+    ['image', { given: [{ tagName: 'image' }], want: 'none' }],
+    ['line', { given: [{ tagName: 'line' }], want: 'none' }],
     ['linearGradient', { given: [{ tagName: 'linearGradient' }], want: 'none' }],
     ['marker', { given: [{ tagName: 'marker' }], want: 'none' }],
     ['mask', { given: [{ tagName: 'mask' }], want: 'none' }],
-    ['mesh', { given: [{ tagName: 'mesh' }], want: 'none' }],
-    ['meshPatch', { given: [{ tagName: 'meshPatch' }], want: 'none' }],
-    ['meshRow', { given: [{ tagName: 'meshRow' }], want: 'none' }],
     ['metadata', { given: [{ tagName: 'metadata' }], want: 'none' }],
     ['mpath', { given: [{ tagName: 'mpath' }], want: 'none' }],
-    ['path', { given: [{ tagName: 'path' }], want: 'graphics-symbol' }],
+    ['path', { given: [{ tagName: 'path' }], want: 'none' }],
     ['pattern', { given: [{ tagName: 'pattern' }], want: 'none' }],
-    ['polygon', { given: [{ tagName: 'polygon' }], want: 'graphics-symbol' }],
-    ['polyline', { given: [{ tagName: 'polyline' }], want: 'graphics-symbol' }],
+    ['polygon', { given: [{ tagName: 'polygon' }], want: 'none' }],
+    ['polyline', { given: [{ tagName: 'polyline' }], want: 'none' }],
     ['radialGradient', { given: [{ tagName: 'radialGradient' }], want: 'none' }],
-    ['rect', { given: [{ tagName: 'rect' }], want: 'graphics-symbol' }],
+    ['rect', { given: [{ tagName: 'rect' }], want: 'none' }],
     ['set', { given: [{ tagName: 'set' }], want: 'none' }],
-    ['solidcolor', { given: [{ tagName: 'solidColor' }], want: 'none' }],
     ['stop', { given: [{ tagName: 'stop' }], want: 'none' }],
     ['switch', { given: [{ tagName: 'switch' }], want: 'none' }],
     ['symbol', { given: [{ tagName: 'symbol' }], want: 'none' }],
-    ['text', { given: [{ tagName: 'text' }], want: 'graphics-symbol' }],
+    ['text', { given: [{ tagName: 'text' }], want: 'group' }],
     ['textPath', { given: [{ tagName: 'textPath' }], want: 'none' }],
     ['tspan', { given: [{ tagName: 'tspan' }], want: 'none' }],
-    ['use', { given: [{ tagName: 'use' }], want: 'graphics-symbol' }],
+    ['use', { given: [{ tagName: 'use' }], want: 'none' }],
     ['view', { given: [{ tagName: 'view' }], want: 'none' }],
   ];
 
@@ -492,11 +490,6 @@ describe('getRole', () => {
   });
 
   test('all tags are tested', () => {
-    const allTags = Object.keys(tags);
-    for (const tag of allTags) {
-      if (!testedTags.has(tag)) {
-        console.warn(`Tag "${tag}" is not tested`);
-      }
-    }
+    checkAllTagsTested(testedTags);
   });
 });
diff --git a/test/node/get-supported-attributes.test.ts b/test/node/get-supported-attributes.test.ts
index 8bc7736..2df2b6d 100644
--- a/test/node/get-supported-attributes.test.ts
+++ b/test/node/get-supported-attributes.test.ts
@@ -10,9 +10,8 @@ import {
   isValidAttributeValue,
   removeProhibited,
   roles,
-  tags,
 } from '../../src/index.js';
-import { checkTestAndTagName } from '../helpers.js';
+import { checkAllTagsTested, checkTestAndTagName } from '../helpers.js';
 
 // These tests are the most difficult to write—it’s very easy to make them
 // circular. To avoid that, it’s worth describing where the data came from.
@@ -443,18 +442,20 @@ const tests: [
 
   // Custom elements
   ['custom-element', { given: [{ tagName: 'custom-element' as TagName }], want: GENERIC_NO_NAMING }],
+  [
+    'custom-element[role=button]',
+    { given: [{ tagName: 'custom-element' as TagName, attributes: { role: 'button' } }], want: roles.button.supported },
+  ],
 
   // SVG
   ['animate', { given: [{ tagName: 'animate' }], want: NO_ATTRIBUTES }],
   ['animateMotion', { given: [{ tagName: 'animateMotion' }], want: NO_ATTRIBUTES }],
   ['animateTransform', { given: [{ tagName: 'animateTransform' }], want: NO_ATTRIBUTES }],
-  ['circle', { given: [{ tagName: 'circle' }], want: NO_ATTRIBUTES }],
+  ['circle', { given: [{ tagName: 'circle' }], want: roles.none.supported }],
   ['clipPath', { given: [{ tagName: 'clipPath' }], want: NO_ATTRIBUTES }],
-  ['cursor', { given: [{ tagName: 'cursor' }], want: NO_ATTRIBUTES }],
   ['defs', { given: [{ tagName: 'defs' }], want: NO_ATTRIBUTES }],
   ['desc', { given: [{ tagName: 'desc' }], want: NO_ATTRIBUTES }],
-  ['discard', { given: [{ tagName: 'discard' }], want: NO_ATTRIBUTES }],
-  ['ellipse', { given: [{ tagName: 'ellipse' }], want: NO_ATTRIBUTES }],
+  ['ellipse', { given: [{ tagName: 'ellipse' }], want: roles.none.supported }],
   ['feBlend', { given: [{ tagName: 'feBlend' }], want: NO_ATTRIBUTES }],
   ['feColorMatrix', { given: [{ tagName: 'feColorMatrix' }], want: NO_ATTRIBUTES }],
   ['feComponentTransfer', { given: [{ tagName: 'feComponentTransfer' }], want: NO_ATTRIBUTES }],
@@ -463,6 +464,7 @@ const tests: [
   ['feDiffuseLighting', { given: [{ tagName: 'feDiffuseLighting' }], want: NO_ATTRIBUTES }],
   ['feDisplacementMap', { given: [{ tagName: 'feDisplacementMap' }], want: NO_ATTRIBUTES }],
   ['feDistantLight', { given: [{ tagName: 'feDistantLight' }], want: NO_ATTRIBUTES }],
+  ['feDropShadow', { given: [{ tagName: 'feDropShadow' }], want: NO_ATTRIBUTES }],
   ['feFlood', { given: [{ tagName: 'feFlood' }], want: NO_ATTRIBUTES }],
   ['feFuncA', { given: [{ tagName: 'feFuncA' }], want: NO_ATTRIBUTES }],
   ['feFuncB', { given: [{ tagName: 'feFuncB' }], want: NO_ATTRIBUTES }],
@@ -480,35 +482,29 @@ const tests: [
   ['feTile', { given: [{ tagName: 'feTile' }], want: NO_ATTRIBUTES }],
   ['feTurbulence', { given: [{ tagName: 'feTurbulence' }], want: NO_ATTRIBUTES }],
   ['filter', { given: [{ tagName: 'filter' }], want: NO_ATTRIBUTES }],
-  ['foreignObject', { given: [{ tagName: 'foreignObject' }], want: NO_ATTRIBUTES }],
-  ['g', { given: [{ tagName: 'g' }], want: GLOBAL_ATTRIBUTES }],
-  ['hatch', { given: [{ tagName: 'hatch' }], want: NO_ATTRIBUTES }],
-  ['hatchPath', { given: [{ tagName: 'hatchPath' }], want: NO_ATTRIBUTES }],
-  ['image', { given: [{ tagName: 'image' }], want: NO_ATTRIBUTES }],
-  ['line', { given: [{ tagName: 'line' }], want: NO_ATTRIBUTES }],
+  ['foreignObject', { given: [{ tagName: 'foreignObject' }], want: roles.none.supported }],
+  ['g', { given: [{ tagName: 'g' }], want: roles.none.supported }],
+  ['image', { given: [{ tagName: 'image' }], want: roles.none.supported }],
+  ['line', { given: [{ tagName: 'line' }], want: roles.none.supported }],
   ['linearGradient', { given: [{ tagName: 'linearGradient' }], want: NO_ATTRIBUTES }],
   ['marker', { given: [{ tagName: 'marker' }], want: NO_ATTRIBUTES }],
   ['mask', { given: [{ tagName: 'mask' }], want: NO_ATTRIBUTES }],
-  ['mesh', { given: [{ tagName: 'mesh' }], want: NO_ATTRIBUTES }],
-  ['meshPatch', { given: [{ tagName: 'meshPatch' }], want: NO_ATTRIBUTES }],
-  ['meshRow', { given: [{ tagName: 'meshRow' }], want: NO_ATTRIBUTES }],
   ['metadata', { given: [{ tagName: 'metadata' }], want: NO_ATTRIBUTES }],
   ['mpath', { given: [{ tagName: 'mpath' }], want: NO_ATTRIBUTES }],
-  ['path', { given: [{ tagName: 'path' }], want: NO_ATTRIBUTES }],
+  ['path', { given: [{ tagName: 'path' }], want: roles.none.supported }],
   ['pattern', { given: [{ tagName: 'pattern' }], want: NO_ATTRIBUTES }],
-  ['polygon', { given: [{ tagName: 'polygon' }], want: NO_ATTRIBUTES }],
-  ['polyline', { given: [{ tagName: 'polyline' }], want: NO_ATTRIBUTES }],
+  ['polygon', { given: [{ tagName: 'polygon' }], want: roles.none.supported }],
+  ['polyline', { given: [{ tagName: 'polyline' }], want: roles.none.supported }],
   ['radialGradient', { given: [{ tagName: 'radialGradient' }], want: NO_ATTRIBUTES }],
-  ['rect', { given: [{ tagName: 'rect' }], want: NO_ATTRIBUTES }],
+  ['rect', { given: [{ tagName: 'rect' }], want: roles.none.supported }],
   ['set', { given: [{ tagName: 'set' }], want: NO_ATTRIBUTES }],
-  ['solidcolor', { given: [{ tagName: 'solidColor' }], want: NO_ATTRIBUTES }],
   ['stop', { given: [{ tagName: 'stop' }], want: NO_ATTRIBUTES }],
   ['switch', { given: [{ tagName: 'switch' }], want: NO_ATTRIBUTES }],
   ['symbol', { given: [{ tagName: 'symbol' }], want: NO_ATTRIBUTES }],
-  ['text', { given: [{ tagName: 'text' }], want: NO_ATTRIBUTES }],
-  ['textPath', { given: [{ tagName: 'textPath' }], want: NO_ATTRIBUTES }],
-  ['tspan', { given: [{ tagName: 'tspan' }], want: NO_ATTRIBUTES }],
-  ['use', { given: [{ tagName: 'use' }], want: NO_ATTRIBUTES }],
+  ['text', { given: [{ tagName: 'text' }], want: roles.group.supported }],
+  ['textPath', { given: [{ tagName: 'textPath' }], want: roles.none.supported }],
+  ['tspan', { given: [{ tagName: 'tspan' }], want: roles.none.supported }],
+  ['use', { given: [{ tagName: 'use' }], want: roles.none.supported }],
   ['view', { given: [{ tagName: 'view' }], want: NO_ATTRIBUTES }],
 ];
 
@@ -523,8 +519,7 @@ describe('getSupportedAttributes', () => {
   });
 
   test('all tags are tested', () => {
-    const missingTags = Object.keys(tags).filter((tag) => !testedTags.has(tag));
-    expect(missingTags).toEqual([]);
+    checkAllTagsTested(testedTags);
   });
 });
 
@@ -545,23 +540,77 @@ const valueTests: [
     want: ReturnType<typeof isValidAttributeValue>;
   },
 ][] = [
-  // enum
-  ['aria-checked="true"', { given: ['aria-checked', 'true'], want: true }],
-  ['aria-checked="false"', { given: ['aria-checked', 'false'], want: true }],
-  ['aria-checked="mixed"', { given: ['aria-checked', 'mixed'], want: true }],
-  ['aria-checked={true}', { given: ['aria-checked', true], want: true }],
-  ['aria-checked={false}', { given: ['aria-checked', false], want: true }],
-  ['aria-checked=""', { given: ['aria-checked', ''], want: false }], // acceptable for boolean, but this is an enum!
-  ['aria-checked="?"', { given: ['aria-checked', undefined], want: false }], // "undefined" is a valid value, however, this method assumes presence of an attribute (undefined is absence)
+  // token
+
   ['aria-checked="foobar"', { given: ['aria-checked', 'foobar'], want: false }],
 
-  // boolean
+  // true/false
   ['aria-disabled="true"', { given: ['aria-disabled', 'true'], want: true }],
   ['aria-disabled="false"', { given: ['aria-disabled', 'false'], want: true }],
   ['aria-disabled={true}', { given: ['aria-disabled', true], want: true }],
   ['aria-disabled={false}', { given: ['aria-disabled', false], want: true }],
   ['aria-disabled=""', { given: ['aria-disabled', ''], want: true }],
   ['aria-disabled="foobar"', { given: ['aria-disabled', 'foobar'], want: false }],
+
+  // true/false/undefined
+  ['aria-expanded=""', { given: ['aria-expanded', ''], want: true }],
+  ['aria-expanded="true"', { given: ['aria-expanded', 'true'], want: true }],
+  ['aria-expanded="false"', { given: ['aria-expanded', 'false'], want: true }],
+  ['aria-expanded={true}', { given: ['aria-expanded', true], want: true }],
+  ['aria-expanded={true}', { given: ['aria-expanded', undefined], want: true }],
+  ['aria-expanded="foobar"', { given: ['aria-expanded', 'foobar'], want: false }],
+
+  // tristate
+  ['aria-checked="true"', { given: ['aria-checked', 'true'], want: true }],
+  ['aria-checked="false"', { given: ['aria-checked', 'false'], want: true }],
+  ['aria-checked="mixed"', { given: ['aria-checked', 'mixed'], want: true }],
+  ['aria-checked={true}', { given: ['aria-checked', true], want: true }],
+  ['aria-checked={false}', { given: ['aria-checked', false], want: true }],
+  ['aria-checked=""', { given: ['aria-checked', ''], want: false }],
+  ['aria-checked={undefined}', { given: ['aria-checked', undefined], want: false }],
+
+  // ID Ref
+  ['aria-activedescendant="element-id"', { given: ['aria-activedescendant', 'element-id'], want: true }],
+  ['aria-activedescendant=""', { given: ['aria-activedescendant', ''], want: false }],
+
+  // ID Ref List
+  ['aria-owns="id1"', { given: ['aria-owns', 'id1'], want: true }],
+  ['aria-owns="id1 id2 id3"', { given: ['aria-owns', 'id1 id2 id3'], want: true }],
+  ['aria-owns=""', { given: ['aria-owns', ''], want: false }],
+
+  // Integer
+  ['aria-level="1"', { given: ['aria-level', '1'], want: true }],
+  ['aria-level={1}', { given: ['aria-level', 1], want: true }],
+  ['aria-level="0"', { given: ['aria-level', '0'], want: true }],
+  ['aria-level={0}', { given: ['aria-level', 0], want: true }],
+  ['aria-level=""', { given: ['aria-level', ''], want: false }],
+  ['aria-level="foobar"', { given: ['aria-level', 'foobar'], want: false }],
+  ['aria-level="1.1"', { given: ['aria-level', '1.1'], want: false }],
+  ['aria-level="1.1"', { given: ['aria-level', 1.1], want: false }],
+
+  // Number
+  ['aria-valuemax="100"', { given: ['aria-valuemax', '100'], want: true }],
+  ['aria-valuemax={100}', { given: ['aria-valuemax', 100], want: true }],
+  ['aria-valuemax="0"', { given: ['aria-valuemax', '0'], want: true }],
+  ['aria-valuemax={0}', { given: ['aria-valuemax', 0], want: true }],
+  ['aria-valuemax="50.435"', { given: ['aria-valuemax', '50.435'], want: true }],
+  ['aria-valuemax={50.435}', { given: ['aria-valuemax', 50.435], want: true }],
+  ['aria-valuemax="foobar"', { given: ['aria-valuemax', 'foobar'], want: false }],
+  ['aria-valuemax=""', { given: ['aria-valuemax', ''], want: false }],
+
+  // Token
+  ['aria-live="assertive"', { given: ['aria-live', 'assertive'], want: true }],
+  ['aria-live="off"', { given: ['aria-live', 'off'], want: true }],
+  ['aria-live="polite"', { given: ['aria-live', 'polite'], want: true }],
+  ['aria-live="assertive polite"', { given: ['aria-live', 'assertive polite'], want: false }],
+
+  // Token List
+  ['aria-relevant="additions"', { given: ['aria-relevant', 'additions'], want: true }],
+  ['aria-relevant="additions removals"', { given: ['aria-relevant', 'additions removals'], want: true }],
+  ['aria-relevant="additions text removals"', { given: ['aria-relevant', 'additions text removals'], want: true }],
+  ['aria-relevant="all"', { given: ['aria-relevant', 'all'], want: true }],
+  ['aria-relevant=""', { given: ['aria-relevant', ''], want: false }],
+  ['aria-relevant="false"', { given: ['aria-relevant', 'false'], want: false }],
 ];
 
 describe('isValidAttributeValue', () => {
diff --git a/test/node/get-supported-roles.test.ts b/test/node/get-supported-roles.test.ts
index 12ac42f..cc3ddd1 100644
--- a/test/node/get-supported-roles.test.ts
+++ b/test/node/get-supported-roles.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
 import { ALL_ROLES, NO_ROLES, type TagName, getSupportedRoles, isSupportedRole, tags } from '../../src/index.js';
-import { checkTestAndTagName } from '../helpers.js';
+import { checkAllTagsTested, checkTestAndTagName } from '../helpers.js';
 
 describe('getSupportedRoles', () => {
   const tests: [
@@ -84,7 +84,6 @@ describe('getSupportedRoles', () => {
       'footer (default)',
       { given: [{ tagName: 'footer' }], want: ['contentinfo', 'generic', 'group', 'none', 'presentation'] },
     ],
-    ['g', { given: [{ tagName: 'g' }], want: ['group', 'graphics-object'] }],
     ['h1', { given: [{ tagName: 'h1' }], want: ['heading', 'none', 'presentation', 'tab'] }],
     ['h2', { given: [{ tagName: 'h2' }], want: ['heading', 'none', 'presentation', 'tab'] }],
     ['h3', { given: [{ tagName: 'h3' }], want: ['heading', 'none', 'presentation', 'tab'] }],
@@ -431,18 +430,64 @@ describe('getSupportedRoles', () => {
     ],
 
     // SVG
-    ['svg: circle', { given: [{ tagName: 'circle' }], want: ['graphics-object'] }],
-    ['svg: ellipse', { given: [{ tagName: 'ellipse' }], want: ['graphics-object'] }],
-    ['svg: image', { given: [{ tagName: 'image' }], want: ['graphics-object'] }],
-    ['svg: line', { given: [{ tagName: 'line' }], want: ['graphics-object'] }],
-    ['svg: path', { given: [{ tagName: 'path' }], want: ['graphics-object'] }],
-    ['svg: polygon', { given: [{ tagName: 'polygon' }], want: ['graphics-object'] }],
-    ['svg: polyline', { given: [{ tagName: 'polyline' }], want: ['graphics-object'] }],
-    ['svg: rect', { given: [{ tagName: 'rect' }], want: ['graphics-object'] }],
-    ['svg: text', { given: [{ tagName: 'text' }], want: ['graphics-object'] }],
-    ['svg: textPath', { given: [{ tagName: 'textPath' }], want: ['graphics-object'] }],
-    ['svg: tspan', { given: [{ tagName: 'tspan' }], want: ['graphics-object'] }],
-    ['svg: use', { given: [{ tagName: 'use' }], want: ['graphics-object'] }],
+    ['animate', { given: [{ tagName: 'animate' }], want: NO_ROLES }],
+    ['animateMotion', { given: [{ tagName: 'animateMotion' }], want: NO_ROLES }],
+    ['animateTransform', { given: [{ tagName: 'animateTransform' }], want: NO_ROLES }],
+    ['circle', { given: [{ tagName: 'circle' }], want: ALL_ROLES }],
+    ['clipPath', { given: [{ tagName: 'clipPath' }], want: NO_ROLES }],
+    ['defs', { given: [{ tagName: 'defs' }], want: NO_ROLES }],
+    ['desc', { given: [{ tagName: 'desc' }], want: NO_ROLES }],
+    ['ellipse', { given: [{ tagName: 'ellipse' }], want: ALL_ROLES }],
+    ['feBlend', { given: [{ tagName: 'feBlend' }], want: NO_ROLES }],
+    ['feColorMatrix', { given: [{ tagName: 'feColorMatrix' }], want: NO_ROLES }],
+    ['feComponentTransfer', { given: [{ tagName: 'feComponentTransfer' }], want: NO_ROLES }],
+    ['feComposite', { given: [{ tagName: 'feComposite' }], want: NO_ROLES }],
+    ['feConvolveMatrix', { given: [{ tagName: 'feConvolveMatrix' }], want: NO_ROLES }],
+    ['feDiffuseLighting', { given: [{ tagName: 'feDiffuseLighting' }], want: NO_ROLES }],
+    ['feDisplacementMap', { given: [{ tagName: 'feDisplacementMap' }], want: NO_ROLES }],
+    ['feDistantLight', { given: [{ tagName: 'feDistantLight' }], want: NO_ROLES }],
+    ['feDropShadow', { given: [{ tagName: 'feDropShadow' }], want: NO_ROLES }],
+    ['feFlood', { given: [{ tagName: 'feFlood' }], want: NO_ROLES }],
+    ['feFuncA', { given: [{ tagName: 'feFuncA' }], want: NO_ROLES }],
+    ['feFuncB', { given: [{ tagName: 'feFuncB' }], want: NO_ROLES }],
+    ['feFuncG', { given: [{ tagName: 'feFuncG' }], want: NO_ROLES }],
+    ['feFuncR', { given: [{ tagName: 'feFuncR' }], want: NO_ROLES }],
+    ['feGaussianBlur', { given: [{ tagName: 'feGaussianBlur' }], want: NO_ROLES }],
+    ['feImage', { given: [{ tagName: 'feImage' }], want: NO_ROLES }],
+    ['feMerge', { given: [{ tagName: 'feMerge' }], want: NO_ROLES }],
+    ['feMergeNode', { given: [{ tagName: 'feMergeNode' }], want: NO_ROLES }],
+    ['feMorphology', { given: [{ tagName: 'feMorphology' }], want: NO_ROLES }],
+    ['feOffset', { given: [{ tagName: 'feOffset' }], want: NO_ROLES }],
+    ['fePointLight', { given: [{ tagName: 'fePointLight' }], want: NO_ROLES }],
+    ['feSpecularLighting', { given: [{ tagName: 'feSpecularLighting' }], want: NO_ROLES }],
+    ['feSpotLight', { given: [{ tagName: 'feSpotLight' }], want: NO_ROLES }],
+    ['feTile', { given: [{ tagName: 'feTile' }], want: NO_ROLES }],
+    ['feTurbulence', { given: [{ tagName: 'feTurbulence' }], want: NO_ROLES }],
+    ['filter', { given: [{ tagName: 'filter' }], want: NO_ROLES }],
+    ['foreignObject', { given: [{ tagName: 'foreignObject' }], want: ALL_ROLES }],
+    ['g', { given: [{ tagName: 'g' }], want: ALL_ROLES }],
+    ['image', { given: [{ tagName: 'image' }], want: ALL_ROLES }],
+    ['line', { given: [{ tagName: 'line' }], want: ALL_ROLES }],
+    ['linearGradient', { given: [{ tagName: 'linearGradient' }], want: NO_ROLES }],
+    ['marker', { given: [{ tagName: 'marker' }], want: NO_ROLES }],
+    ['mask', { given: [{ tagName: 'mask' }], want: NO_ROLES }],
+    ['metadata', { given: [{ tagName: 'metadata' }], want: NO_ROLES }],
+    ['mpath', { given: [{ tagName: 'mpath' }], want: NO_ROLES }],
+    ['path', { given: [{ tagName: 'path' }], want: ALL_ROLES }],
+    ['pattern', { given: [{ tagName: 'pattern' }], want: NO_ROLES }],
+    ['polygon', { given: [{ tagName: 'polygon' }], want: ALL_ROLES }],
+    ['polyline', { given: [{ tagName: 'polyline' }], want: ALL_ROLES }],
+    ['radialGradient', { given: [{ tagName: 'radialGradient' }], want: NO_ROLES }],
+    ['rect', { given: [{ tagName: 'rect' }], want: ALL_ROLES }],
+    ['set', { given: [{ tagName: 'set' }], want: NO_ROLES }],
+    ['stop', { given: [{ tagName: 'stop' }], want: NO_ROLES }],
+    ['switch', { given: [{ tagName: 'switch' }], want: NO_ROLES }],
+    ['symbol', { given: [{ tagName: 'symbol' }], want: NO_ROLES }],
+    ['text', { given: [{ tagName: 'text' }], want: ALL_ROLES }],
+    ['textPath', { given: [{ tagName: 'textPath' }], want: ALL_ROLES }],
+    ['tspan', { given: [{ tagName: 'tspan' }], want: ALL_ROLES }],
+    ['use', { given: [{ tagName: 'use' }], want: ALL_ROLES }],
+    ['view', { given: [{ tagName: 'view' }], want: NO_ROLES }],
   ];
 
   const testedTags = new Set<string>();
@@ -454,12 +499,7 @@ describe('getSupportedRoles', () => {
   });
 
   test('all tags are tested', () => {
-    const allTags = Object.keys(tags);
-    for (const tag of allTags) {
-      if (!testedTags.has(tag)) {
-        console.warn(`Tag "${tag}" is not tested`);
-      }
-    }
+    checkAllTagsTested(testedTags);
   });
 });
 
diff --git a/test/node/is-interactive.test.ts b/test/node/is-interactive.test.ts
index 06c3239..dd0ea54 100644
--- a/test/node/is-interactive.test.ts
+++ b/test/node/is-interactive.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
-import { isInteractive, tags } from '../../src/index.js';
-import { checkTestAndTagName } from './../helpers';
+import { type TagName, isInteractive, tags } from '../../src/index.js';
+import { checkAllTagsTested, checkTestAndTagName } from './../helpers';
 
 // add <div tabindex=0>
 // add <div role="button" tabindex=0>
@@ -52,7 +52,6 @@ describe('isInteractive', () => {
     ['figure', { given: [{ tagName: 'figure' }], want: false }],
     ['form', { given: [{ tagName: 'form' }], want: false }],
     ['footer', { given: [{ tagName: 'footer' }], want: false }],
-    ['g', { given: [{ tagName: 'g' }], want: false }],
     ['h1', { given: [{ tagName: 'h1' }], want: false }],
     ['h2', { given: [{ tagName: 'h2' }], want: false }],
     ['h3', { given: [{ tagName: 'h3' }], want: false }],
@@ -221,6 +220,101 @@ describe('isInteractive', () => {
     ['var', { given: [{ tagName: 'var' }], want: false }],
     ['video', { given: [{ tagName: 'video' }], want: false }],
     ['wbr', { given: [{ tagName: 'wbr' }], want: false }],
+
+    // Custom elements
+    ['custom-element', { given: [{ tagName: 'custom-element' as TagName }], want: false }],
+    [
+      'custom-element[role=button]',
+      { given: [{ tagName: 'custom-element' as TagName, attributes: { role: 'button' } }], want: false },
+    ],
+    [
+      'custom-element[tabindex=0]',
+      { given: [{ tagName: 'custom-element' as TagName, attributes: { tabindex: 0 } }], want: false },
+    ],
+    [
+      'custom-element[role=button,tabindex=0]',
+      { given: [{ tagName: 'custom-element' as TagName, attributes: { role: 'button', tabindex: 0 } }], want: true },
+    ],
+
+    // SVG
+    ['svg', { given: [{ tagName: 'svg' }], want: false }],
+    ['svg[role=button]', { given: [{ tagName: 'svg', attributes: { role: 'button' } }], want: false }],
+    ['svg[tabindex=0]', { given: [{ tagName: 'svg', attributes: { tabindex: 0 } }], want: false }],
+    [
+      'svg[role=button,tabindex=0]',
+      { given: [{ tagName: 'svg', attributes: { role: 'button', tabindex: 0 } }], want: true },
+    ],
+    ['animate', { given: [{ tagName: 'animate' }], want: false }],
+    ['animate[role=button]', { given: [{ tagName: 'animate', attributes: { role: 'button' } }], want: false }],
+    ['animate[tabindex=0]', { given: [{ tagName: 'animate', attributes: { tabindex: 0 } }], want: false }],
+    // <animate> should NEVER be interactive
+    [
+      'animate[role=button,tabindex=0]',
+      { given: [{ tagName: 'animate', attributes: { role: 'button', tabindex: 0 } }], want: false },
+    ],
+    ['animateMotion', { given: [{ tagName: 'animateMotion' }], want: false }],
+    ['animateTransform', { given: [{ tagName: 'animateTransform' }], want: false }],
+    ['circle', { given: [{ tagName: 'circle' }], want: false }],
+    ['circle[role=button]', { given: [{ tagName: 'circle', attributes: { role: 'button' } }], want: false }],
+    ['circle[tabindex=0]', { given: [{ tagName: 'circle', attributes: { tabindex: 0 } }], want: false }],
+    [
+      'circle[role=button,tabindex=0]',
+      { given: [{ tagName: 'circle', attributes: { role: 'button', tabindex: 0 } }], want: true },
+    ],
+    ['clipPath', { given: [{ tagName: 'clipPath' }], want: false }],
+    ['defs', { given: [{ tagName: 'defs' }], want: false }],
+    ['desc', { given: [{ tagName: 'desc' }], want: false }],
+    ['ellipse', { given: [{ tagName: 'ellipse' }], want: false }],
+    ['feBlend', { given: [{ tagName: 'feBlend' }], want: false }],
+    ['feColorMatrix', { given: [{ tagName: 'feColorMatrix' }], want: false }],
+    ['feComponentTransfer', { given: [{ tagName: 'feComponentTransfer' }], want: false }],
+    ['feComposite', { given: [{ tagName: 'feComposite' }], want: false }],
+    ['feConvolveMatrix', { given: [{ tagName: 'feConvolveMatrix' }], want: false }],
+    ['feDiffuseLighting', { given: [{ tagName: 'feDiffuseLighting' }], want: false }],
+    ['feDisplacementMap', { given: [{ tagName: 'feDisplacementMap' }], want: false }],
+    ['feDistantLight', { given: [{ tagName: 'feDistantLight' }], want: false }],
+    ['feDropShadow', { given: [{ tagName: 'feDropShadow' }], want: false }],
+    ['feFlood', { given: [{ tagName: 'feFlood' }], want: false }],
+    ['feFuncA', { given: [{ tagName: 'feFuncA' }], want: false }],
+    ['feFuncB', { given: [{ tagName: 'feFuncB' }], want: false }],
+    ['feFuncG', { given: [{ tagName: 'feFuncG' }], want: false }],
+    ['feFuncR', { given: [{ tagName: 'feFuncR' }], want: false }],
+    ['feGaussianBlur', { given: [{ tagName: 'feGaussianBlur' }], want: false }],
+    ['feImage', { given: [{ tagName: 'feImage' }], want: false }],
+    ['feMerge', { given: [{ tagName: 'feMerge' }], want: false }],
+    ['feMergeNode', { given: [{ tagName: 'feMergeNode' }], want: false }],
+    ['feMorphology', { given: [{ tagName: 'feMorphology' }], want: false }],
+    ['feOffset', { given: [{ tagName: 'feOffset' }], want: false }],
+    ['fePointLight', { given: [{ tagName: 'fePointLight' }], want: false }],
+    ['feSpecularLighting', { given: [{ tagName: 'feSpecularLighting' }], want: false }],
+    ['feSpotLight', { given: [{ tagName: 'feSpotLight' }], want: false }],
+    ['feTile', { given: [{ tagName: 'feTile' }], want: false }],
+    ['feTurbulence', { given: [{ tagName: 'feTurbulence' }], want: false }],
+    ['filter', { given: [{ tagName: 'filter' }], want: false }],
+    ['foreignObject', { given: [{ tagName: 'foreignObject' }], want: false }],
+    ['g', { given: [{ tagName: 'g' }], want: false }],
+    ['image', { given: [{ tagName: 'image' }], want: false }],
+    ['line', { given: [{ tagName: 'line' }], want: false }],
+    ['linearGradient', { given: [{ tagName: 'linearGradient' }], want: false }],
+    ['marker', { given: [{ tagName: 'marker' }], want: false }],
+    ['mask', { given: [{ tagName: 'mask' }], want: false }],
+    ['metadata', { given: [{ tagName: 'metadata' }], want: false }],
+    ['mpath', { given: [{ tagName: 'mpath' }], want: false }],
+    ['path', { given: [{ tagName: 'path' }], want: false }],
+    ['pattern', { given: [{ tagName: 'pattern' }], want: false }],
+    ['polygon', { given: [{ tagName: 'polygon' }], want: false }],
+    ['polyline', { given: [{ tagName: 'polyline' }], want: false }],
+    ['radialGradient', { given: [{ tagName: 'radialGradient' }], want: false }],
+    ['rect', { given: [{ tagName: 'rect' }], want: false }],
+    ['set', { given: [{ tagName: 'set' }], want: false }],
+    ['stop', { given: [{ tagName: 'stop' }], want: false }],
+    ['switch', { given: [{ tagName: 'switch' }], want: false }],
+    ['symbol', { given: [{ tagName: 'symbol' }], want: false }],
+    ['text', { given: [{ tagName: 'text' }], want: false }],
+    ['textPath', { given: [{ tagName: 'textPath' }], want: false }],
+    ['tspan', { given: [{ tagName: 'tspan' }], want: false }],
+    ['use', { given: [{ tagName: 'use' }], want: false }],
+    ['view', { given: [{ tagName: 'view' }], want: false }],
   ];
 
   const testedTags = new Set<string>();
@@ -232,9 +326,6 @@ describe('isInteractive', () => {
   });
 
   test('all tags are tested', () => {
-    const allTags = Object.keys(tags);
-    for (const tag of allTags) {
-      expect(testedTags.has(tag)).toBe(true);
-    }
+    checkAllTagsTested(testedTags);
   });
 });
diff --git a/vitest.workspace.ts b/vitest.workspace.ts
index 4f40e2e..088ee50 100644
--- a/vitest.workspace.ts
+++ b/vitest.workspace.ts
@@ -22,15 +22,15 @@ export default defineWorkspace([
       environment: 'happy-dom',
     },
   },
-  // {
-  //   test: {
-  //     name: 'browser',
-  //     include: ['./test/dom/**/*.test.ts'],
-  //     browser: {
-  //       provider: 'playwright',
-  //       enabled: true,
-  //       instances: [{ browser: 'chromium' }],
-  //     },
-  //   },
-  // },
+  {
+    test: {
+      name: 'browser',
+      include: ['./test/dom/**/*.test.ts'],
+      browser: {
+        provider: 'playwright',
+        enabled: true,
+        instances: [{ browser: 'chromium' }],
+      },
+    },
+  },
 ]);