@hypothesi/tauri-mcp-server 0.7.0 → 0.8.0

package/dist/driver/scripts/aria-api.bundle.js

@@ -0,0 +1,1295 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.aria = {}));
+})(this, (function (exports) { 'use strict';
+
+	// https://www.w3.org/TR/wai-aria/#state_prop_def
+	const attributes = {
+		'activedescendant': 'id',
+		'atomic': 'bool',
+		'autocomplete': 'token',
+		'braillelabel': 'string',
+		'brailleroledescription': 'string',
+		'busy': 'bool',
+		'checked': 'tristate',
+		'colcount': 'int',
+		'colindex': 'int',
+		'colindextext': 'string',
+		'colspan': 'int',
+		'controls': 'id-list',
+		'current': 'token',
+		'describedby': 'id-list',
+		'description': 'string',
+		'details': 'id',
+		'disabled': 'bool',
+		'dropeffect': 'token-list',
+		'errormessage': 'id',
+		'expanded': 'bool-undefined',
+		'flowto': 'id-list',
+		'grabbed': 'bool-undefined',
+		'haspopup': 'token',
+		'hidden': 'bool-undefined',
+		'invalid': 'token',
+		'keyshortcuts': 'string',
+		'label': 'string',
+		'labelledby': 'id-list',
+		'level': 'int',
+		'live': 'token',
+		'modal': 'bool',
+		'multiline': 'bool',
+		'multiselectable': 'bool',
+		'orientation': 'token',
+		'owns': 'id-list',
+		'placeholder': 'string',
+		'posinset': 'int',
+		'pressed': 'tristate',
+		'readonly': 'bool',
+		'relevant': 'token-list',
+		'required': 'bool',
+		'roledescription': 'string',
+		'rowcount': 'int',
+		'rowindex': 'int',
+		'rowindextext': 'string',
+		'rowspan': 'int',
+		'selected': 'bool-undefined',
+		'setsize': 'int',
+		'sort': 'token',
+		'valuemax': 'number',
+		'valuemin': 'number',
+		'valuenow': 'number',
+		'valuetext': 'string',
+	};
+
+	const attributeStrongMapping = {
+		'disabled': 'disabled',
+		'placeholder': 'placeholder',
+		'readonly': 'readOnly',
+		'required': 'required',
+	};
+
+	const attributeWeakMapping = {
+		'checked': 'checked',
+		'colspan': 'colSpan',
+		'expanded': 'open',
+		'multiselectable': 'multiple',
+		'rowspan': 'rowSpan',
+		'selected': 'selected',
+	};
+
+	// https://www.w3.org/TR/html/dom.html#sectioning-content-2
+	const scoped = ['article *', 'aside *', 'nav *', 'section *'].join(',');
+
+	const svgSelectors = function(selector) {
+		return [
+			// `${selector}:has(> title:not(:empty))`,
+			// `${selector}:has(> desc:not(:empty))`,
+			`${selector}[aria-label]`,
+			`${selector}[aria-roledescription]`,
+			`${selector}[aria-labelledby]`,
+			`${selector}[aria-describedby]`,
+			`${selector}[tabindex]`,
+			`${selector}[role]`,
+		];
+	};
+
+	// https://www.w3.org/TR/html-aam-1.0/#html-element-role-mappings
+	// https://www.w3.org/TR/wai-aria/roles
+	const roles = {
+		alert: {
+			childRoles: ['alertdialog'],
+			defaults: {
+				'live': 'assertive',
+				'atomic': true,
+			},
+		},
+		alertdialog: {},
+		application: {},
+		article: {
+			selectors: ['article'],
+			childRoles: ['comment'],
+		},
+		banner: {
+			selectors: [`header:not(main *, ${scoped})`],
+		},
+		blockquote: {
+			selectors: ['blockquote'],
+		},
+		button: {
+			selectors: [
+				'button',
+				'input[type="button"]',
+				'input[type="image"]',
+				'input[type="reset"]',
+				'input[type="submit"]',
+				'summary',
+			],
+			nameFromContents: true,
+		},
+		caption: {
+			selectors: ['caption', 'figcaption'],
+		},
+		cell: {
+			selectors: ['td', 'td ~ th:not([scope])'],
+			childRoles: ['columnheader', 'gridcell', 'rowheader'],
+			nameFromContents: true,
+		},
+		checkbox: {
+			selectors: ['input[type="checkbox"]'],
+			childRoles: ['switch'],
+			nameFromContents: true,
+			defaults: {
+				'checked': 'false',
+			},
+		},
+		code: {
+			selectors: ['code'],
+		},
+		columnheader: {
+			selectors: ['th[scope="col"]'],
+			nameFromContents: true,
+		},
+		combobox: {
+			selectors: [
+				'input:not([type])[list]',
+				'input[type="email"][list]',
+				'input[type="search"][list]',
+				'input[type="tel"][list]',
+				'input[type="text"][list]',
+				'input[type="url"][list]',
+				'select:not([size]):not([multiple])',
+				'select[size="0"]:not([multiple])',
+				'select[size="1"]:not([multiple])',
+			],
+			defaults: {
+				'expanded': false,
+				'haspopup': 'listbox',
+			},
+		},
+		command: {
+			abstract: true,
+			childRoles: ['button', 'link', 'menuitem'],
+		},
+		comment: {
+			nameFromContents: true,
+		},
+		complementary: {
+			selectors: [
+				`aside:not(${scoped})`,
+				'aside[aria-label]',
+				'aside[aria-labelledby]',
+				'aside[title]',
+			],
+		},
+		composite: {
+			abstract: true,
+			childRoles: ['grid', 'select', 'spinbutton', 'tablist'],
+		},
+		contentinfo: {
+			selectors: [`footer:not(main *, ${scoped})`],
+		},
+		definition: {
+			selectors: ['dd'],
+		},
+		deletion: {
+			selectors: ['del', 's'],
+		},
+		dialog: {
+			selectors: ['dialog'],
+			childRoles: ['alertdialog'],
+		},
+		'doc-abstract': {},
+		'doc-acknowledgments': {},
+		'doc-afterword': {},
+		'doc-appendix': {},
+		'doc-backlink': {
+			nameFromContents: true,
+		},
+		'doc-biblioentry': {},
+		'doc-bibliography': {},
+		'doc-biblioref': {
+			nameFromContents: true,
+		},
+		'doc-chapter': {},
+		'doc-colophon': {},
+		'doc-conclusion': {},
+		'doc-cover': {},
+		'doc-credit': {},
+		'doc-credits': {},
+		'doc-dedication': {},
+		'doc-endnote': {},
+		'doc-endnotes': {},
+		'doc-epilogue': {},
+		'doc-epigraph': {},
+		'doc-errata': {},
+		'doc-example': {},
+		'doc-footnote': {},
+		'doc-foreword': {},
+		'doc-glossary': {},
+		'doc-glossref': {
+			nameFromContents: true,
+		},
+		'doc-index': {},
+		'doc-introduction': {},
+		'doc-noteref': {
+			nameFromContents: true,
+		},
+		'doc-notice': {},
+		'doc-pagebreak': {
+			nameFromContents: true,
+		},
+		'doc-pagefooter': {},
+		'doc-pageheader': {},
+		'doc-pagelist': {},
+		'doc-part': {},
+		'doc-preface': {},
+		'doc-prologue': {},
+		'doc-pullquote': {},
+		'doc-qna': {},
+		'doc-subtitle': {
+			nameFromContents: true,
+		},
+		'doc-tip': {},
+		'doc-toc': {},
+		document: {
+			selectors: ['html'],
+			childRoles: ['article', 'graphics-document'],
+		},
+		emphasis: {
+			selectors: ['em'],
+		},
+		feed: {},
+		figure: {
+			selectors: ['figure'],
+			childRoles: ['doc-example'],
+		},
+		form: {
+			selectors: ['form[aria-label]', 'form[aria-labelledby]', 'form[title]'],
+		},
+		generic: {
+			selectors: [
+				'a:not([*|href])',
+				'area:not([*|href])',
+				`aside:not(${scoped}):not([aria-label]):not([aria-labelledby]):not([title])`,
+				'b',
+				'bdi',
+				'bdo',
+				'body',
+				'data',
+				'div',
+				// footer scoped
+				// header scoped
+				'i',
+				'li:not(ul > li):not(ol > li)',
+				'pre',
+				'q',
+				'samp',
+				'section:not([aria-label]):not([aria-labelledby]):not([title])',
+				'small',
+				'span',
+				'u',
+			],
+		},
+		'graphics-document': {
+			selectors: ['svg'],
+		},
+		'graphics-object': {
+			selectors: [
+				...svgSelectors('symbol'),
+				...svgSelectors('use'),
+			],
+		},
+		'graphics-symbol': {
+			selectors: [
+				...svgSelectors('circle'),
+				...svgSelectors('ellipse'),
+				...svgSelectors('line'),
+				...svgSelectors('path'),
+				...svgSelectors('polygon'),
+				...svgSelectors('polyline'),
+				...svgSelectors('rect'),
+			],
+		},
+		grid: {
+			childRoles: ['treegrid'],
+		},
+		gridcell: {
+			childRoles: ['columnheader', 'rowheader'],
+			nameFromContents: true,
+		},
+		group: {
+			selectors: [
+				'address',
+				'details',
+				'fieldset',
+				'hgroup',
+				'optgroup',
+				...svgSelectors('foreignObject'),
+				...svgSelectors('g'),
+				'text',
+				...svgSelectors('textPath'),
+				...svgSelectors('tspan'),
+			],
+			childRoles: ['row', 'select', 'toolbar', 'graphics-object'],
+		},
+		heading: {
+			selectors: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'],
+			nameFromContents: true,
+			defaults: {
+				'level': 2,
+			},
+		},
+		image: {
+			selectors: [
+				'img:not([alt=""])',
+				'graphics-symbol',
+				...svgSelectors('image'),
+				...svgSelectors('mesh'),
+			],
+			childRoles: ['doc-cover'],
+		},
+		input: {
+			abstract: true,
+			childRoles: [
+				'checkbox',
+				'combobox',
+				'option',
+				'radio',
+				'slider',
+				'spinbutton',
+				'textbox',
+			],
+		},
+		insertion: {
+			selectors: ['ins'],
+		},
+		landmark: {
+			abstract: true,
+			childRoles: [
+				'banner',
+				'complementary',
+				'contentinfo',
+				'doc-acknowledgments',
+				'doc-afterword',
+				'doc-appendix',
+				'doc-bibliography',
+				'doc-chapter',
+				'doc-conclusion',
+				'doc-credits',
+				'doc-endnotes',
+				'doc-epilogue',
+				'doc-errata',
+				'doc-foreword',
+				'doc-glossary',
+				'doc-introduction',
+				'doc-part',
+				'doc-preface',
+				'doc-prologue',
+				'form',
+				'main',
+				'navigation',
+				'region',
+				'search',
+			],
+		},
+		link: {
+			selectors: ['a[*|href]', 'area[*|href]'],
+			childRoles: ['doc-backlink', 'doc-biblioref', 'doc-glossref', 'doc-noteref'],
+			nameFromContents: true,
+		},
+		list: {
+			selectors: ['dl', 'ol', 'ul', 'menu'],
+			childRoles: ['feed'],
+		},
+		listbox: {
+			selectors: [
+				'datalist',
+				'select[multiple]',
+				'select[size]:not([size="0"]):not([size="1"])',
+			],
+			defaults: {
+				'orientation': 'vertical',
+			},
+		},
+		listitem: {
+			selectors: ['ol > li', 'ul > li'],
+			childRoles: ['doc-biblioentry', 'doc-endnote', 'treeitem'],
+		},
+		log: {
+			defaults: {
+				'live': 'polite',
+			},
+		},
+		main: {
+			selectors: ['main'],
+		},
+		mark: {
+			selectors: ['mark'],
+		},
+		marquee: {},
+		math: {
+			selectors: ['math'],
+		},
+		meter: {
+			selectors: ['meter'],
+			defaults: {
+				'valuemin': 0,
+				'valuemax': 100,
+			},
+		},
+		menu: {
+			childRoles: ['menubar'],
+			defaults: {
+				'orientation': 'vertical',
+			},
+		},
+		menubar: {
+			defaults: {
+				'orientation': 'horizontal',
+			},
+		},
+		menuitem: {
+			childRoles: ['menuitemcheckbox', 'menuitemradio'],
+			nameFromContents: true,
+		},
+		menuitemcheckbox: {
+			nameFromContents: true,
+			defaults: {
+				'checked': 'false',
+			},
+		},
+		menuitemradio: {
+			nameFromContents: true,
+			defaults: {
+				'checked': 'false',
+			},
+		},
+		navigation: {
+			selectors: ['nav'],
+			childRoles: ['doc-index', 'doc-pagelist', 'doc-toc'],
+		},
+		none: {
+			selectors: ['img[alt=""]'],
+		},
+		note: {
+			childRoles: ['doc-notice', 'doc-tip'],
+		},
+		option: {
+			selectors: ['option'],
+			childRoles: ['treeitem'],
+			nameFromContents: true,
+			defaults: {
+				'selected': 'false',
+			},
+		},
+		paragraph: {
+			selectors: ['p'],
+		},
+		progressbar: {
+			selectors: ['progress'],
+			defaults: {
+				'valuemin': 0,
+				'valuemax': 100,
+			},
+		},
+		radio: {
+			selectors: ['input[type="radio"]'],
+			childRoles: ['menuitemradio'],
+			nameFromContents: true,
+			defaults: {
+				'checked': 'false',
+			},
+		},
+		radiogroup: {},
+		range: {
+			abstract: true,
+			childRoles: ['meter', 'progressbar', 'scrollbar', 'slider', 'spinbutton'],
+		},
+		region: {
+			selectors: ['section[aria-label]', 'section[aria-labelledby]', 'section[title]'],
+		},
+		roletype: {
+			abstract: true,
+			childRoles: ['structure', 'widget', 'window'],
+		},
+		row: {
+			selectors: ['tr'],
+			nameFromContents: true,
+		},
+		rowgroup: {
+			selectors: ['tbody', 'thead', 'tfoot'],
+		},
+		rowheader: {
+			selectors: ['th[scope="row"]', 'th:not([scope]):not(td ~ th)'],
+			nameFromContents: true,
+		},
+		scrollbar: {
+			defaults: {
+				'orientation': 'vertical',
+				'valuemin': 0,
+				'valuemax': 100,
+			},
+		},
+		search: {
+			selectors: ['search'],
+		},
+		searchbox: {
+			selectors: ['input[type="search"]:not([list])'],
+		},
+		section: {
+			abstract: true,
+			childRoles: [
+				'alert',
+				'blockquote',
+				'caption',
+				'cell',
+				'code',
+				'definition',
+				'deletion',
+				'doc-abstract',
+				'doc-colophon',
+				'doc-credit',
+				'doc-dedication',
+				'doc-epigraph',
+				'doc-footnote',
+				'doc-pagefooter',
+				'doc-pageheader',
+				'doc-pullquote',
+				'doc-qna',
+				'emphasis',
+				'figure',
+				'group',
+				'image',
+				'insertion',
+				'landmark',
+				'list',
+				'listitem',
+				'log',
+				'mark',
+				'marquee',
+				'math',
+				'note',
+				'paragraph',
+				'status',
+				'strong',
+				'subscript',
+				'suggestion',
+				'superscript',
+				'table',
+				'tabpanel',
+				'term',
+				'time',
+				'tooltip',
+			],
+		},
+		sectionhead: {
+			abstract: true,
+			childRoles: [
+				'columnheader',
+				'doc-subtitle',
+				'heading',
+				'rowheader',
+				'tab',
+			],
+			nameFromContents: true,
+		},
+		select: {
+			abstract: true,
+			childRoles: ['listbox', 'menu', 'radiogroup', 'tree'],
+		},
+		separator: {
+			// assume not focussable because <hr> is not
+			selectors: ['hr'],
+			childRoles: ['doc-pagebreak'],
+			defaults: {
+				'orientation': 'horizontal',
+				'valuemin': 0,
+				'valuemax': 100,
+			},
+		},
+		slider: {
+			selectors: ['input[type="range"]'],
+			defaults: {
+				'orientation': 'horizontal',
+				'valuemin': 0,
+				'valuemax': 100,
+				// FIXME: halfway between actual valuemin and valuemax
+				'valuenow': 50,
+			},
+		},
+		spinbutton: {
+			selectors: ['input[type="number"]'],
+			defaults: {
+				// FIXME: no valuemin/valuemax/valuenow
+			},
+		},
+		status: {
+			selectors: ['output'],
+			childRoles: ['timer'],
+			defaults: {
+				'live': 'polite',
+				'atomic': true,
+			},
+		},
+		strong: {
+			selectors: ['strong'],
+		},
+		structure: {
+			abstract: true,
+			childRoles: [
+				'application',
+				'document',
+				'none',
+				'generic',
+				'range',
+				'rowgroup',
+				'section',
+				'sectionhead',
+				'separator',
+			],
+		},
+		suggestion: {},
+		subscript: {
+			selectors: ['sub'],
+		},
+		superscript: {
+			selectors: ['sup'],
+		},
+		switch: {
+			nameFromContents: true,
+			defaults: {
+				'checked': false,
+			},
+		},
+		tab: {
+			nameFromContents: true,
+			defaults: {
+				'selected': false,
+			},
+		},
+		table: {
+			selectors: ['table'],
+			childRoles: ['grid'],
+		},
+		tablist: {
+			defaults: {
+				'orientation': 'horizontal',
+			},
+		},
+		tabpanel: {},
+		term: {
+			selectors: ['dfn', 'dt'],
+		},
+		textbox: {
+			selectors: [
+				'input:not([type]):not([list])',
+				'input[type="email"]:not([list])',
+				'input[type="tel"]:not([list])',
+				'input[type="text"]:not([list])',
+				'input[type="url"]:not([list])',
+				'textarea',
+			],
+			childRoles: ['searchbox'],
+		},
+		time: {
+			selectors: ['time'],
+		},
+		timer: {
+			defaults: {
+				'live': 'off',
+			},
+		},
+		toolbar: {
+			defaults: {
+				'orientation': 'horizontal',
+			},
+		},
+		tooltip: {
+			nameFromContents: true,
+		},
+		tree: {
+			childRoles: ['treegrid'],
+			defaults: {
+				'orientation': 'vertical',
+			},
+		},
+		treegrid: {},
+		treeitem: {
+			nameFromContents: true,
+		},
+		widget: {
+			abstract: true,
+			childRoles: [
+				'command',
+				'composite',
+				'gridcell',
+				'input',
+				'progressbar',
+				'row',
+				'scrollbar',
+				'separator',
+				'tab',
+			],
+		},
+		window: {
+			abstract: true,
+			childRoles: ['dialog'],
+		},
+	};
+
+	const getSubRoles = function(role) {
+		const children = (roles[role]).childRoles || [];
+		const descendents = children.map(getSubRoles);
+
+		const result = [role];
+
+		descendents.forEach(list => {
+			list.forEach(r => {
+				if (!result.includes(r)) {
+					result.push(r);
+				}
+			});
+		});
+
+		return result;
+	};
+
+	const attrsWithDefaults = [];
+
+	for (const role in roles) {
+		roles[role].subRoles = getSubRoles(role);
+		for (const key in roles[role].defaults) {
+			if (!attrsWithDefaults.includes(key)) {
+				attrsWithDefaults.push(key);
+			}
+		}
+	}
+
+	const aliases = {
+		'presentation': 'none',
+		'directory': 'list',
+		'img': 'image',
+	};
+
+	const nameFromDescendant = {
+		'figure': 'figcaption',
+		'table': 'caption',
+		'fieldset': 'legend',
+	};
+
+	const nameDefaults = {
+		'input[type="submit"]': 'Submit',
+		'input[type="reset"]': 'Reset',
+		'summary': 'Details',
+	};
+
+	var unique = function(arr) {
+		return arr.filter((a, i) => arr.indexOf(a) === i);
+	};
+
+	var flatten = function(arr) {
+		return [].concat.apply([], arr);
+	};
+
+	var normalizeRoles = function(roles$1, includeAbstract) {
+		return unique(roles$1
+			.map(r => aliases[r] || r)
+			.filter(r => roles[r])
+			.filter(r => includeAbstract || !roles[r].abstract)
+		);
+	};
+
+	// candidates can be passed for performance optimization
+	const getRoleRaw = function(el, candidates) {
+		// TODO: filter out any invalid roles (e.g. name or context required)
+		const roles$1 = normalizeRoles(
+			(el.getAttribute('role') || '').toLowerCase().split(/\s+/)
+		);
+
+		if (roles$1.length > 1 && candidates) {
+			return [roles$1, candidates];
+		} else if (roles$1.length) {
+			for (const role of roles$1) {
+				if (!candidates || candidates.includes(role)) {
+					return role;
+				}
+			}
+		} else {
+			for (const role of (candidates || Object.keys(roles))) {
+				const r = roles[role];
+				if (!r.abstract && r.selectors && el.matches(r.selectors.join(','))) {
+					return role;
+				}
+			}
+		}
+	};
+
+	const getRole = function(el) {
+		return getRoleRaw(el);
+	};
+
+	const hasRole = function(el, roles$1) {
+		const subRoles = normalizeRoles(roles$1, true).map(role => {
+			return roles[role].subRoles || [role];
+		});
+		return !!getRoleRaw(el, unique(flatten(subRoles)));
+	};
+
+	const getAttribute = function(el, key) {
+		if (attributeStrongMapping.hasOwnProperty(key)) {
+			const value = el[attributeStrongMapping[key]];
+			if (value) {
+				return value;
+			}
+		}
+		if (key === 'readonly' && el.contentEditable) {
+			return false;
+		} else if (key === 'invalid' && el.checkValidity) {
+			return !el.checkValidity();
+		} else if (key === 'hidden') {
+			// workaround for chromium
+			if (el.matches('noscript')) {
+				return true;
+			}
+			if (el.matches('details:not([open]) > :not(summary)')) {
+				return true;
+			}
+			const style = window.getComputedStyle(el);
+			if (style.display === 'none' || style.visibility === 'hidden' || style.visibility === 'collapse') {
+				return true;
+			}
+		}
+
+		const type = attributes[key];
+		const raw = el.getAttribute('aria-' + key);
+
+		if (raw) {
+			if (type === 'bool') {
+				return raw === 'true';
+			} else if (type === 'tristate') {
+				return raw === 'true' ? true : raw === 'false' ? false : 'mixed';
+			} else if (type === 'bool-undefined') {
+				return raw === 'true' ? true : raw === 'false' ? false : undefined;
+			} else if (type === 'id-list') {
+				return raw.split(/\s+/);
+			} else if (type === 'integer') {
+				return parseInt(raw, 10);
+			} else if (type === 'number') {
+				return parseFloat(raw);
+			} else if (type === 'token-list') {
+				return raw.split(/\s+/);
+			} else {
+				return raw;
+			}
+		}
+
+		// TODO
+		// autocomplete
+		// contextmenu -> aria-haspopup
+		// indeterminate -> aria-checked="mixed"
+		// list -> aria-controls
+
+		if (key === 'level') {
+			for (let i = 1; i <= 6; i++) {
+				if (el.tagName.toLowerCase() === 'h' + i) {
+					return i;
+				}
+			}
+		} else if (attributeWeakMapping.hasOwnProperty(key)) {
+			return el[attributeWeakMapping[key]];
+		}
+
+		if (key in attrsWithDefaults) {
+			const role = getRole(el);
+			const defaults = roles[role].defaults;
+			if (defaults && defaults.hasOwnProperty(key)) {
+				return defaults[key];
+			}
+		}
+
+		if (type === 'bool' || type === 'tristate') {
+			return false;
+		}
+	};
+
+	const _getOwner = function(node, owners) {
+		if (node.nodeType === node.ELEMENT_NODE && node.id) {
+			const selector = '[aria-owns~="' + CSS.escape(node.id) + '"]';
+			if (owners) {
+				for (const owner of owners) {
+					if (owner.matches(selector)) {
+						return owner;
+					}
+				}
+			} else {
+				return document.querySelector(selector);
+			}
+		}
+	};
+
+	const _getParentNode = function(node, owners) {
+		return _getOwner(node, owners) || node.parentNode;
+	};
+
+	const detectLoop = function(node, owners) {
+		const seen = [node];
+		while ((node = _getParentNode(node, owners))) {
+			if (seen.includes(node)) {
+				return true;
+			}
+			seen.push(node);
+		}
+	};
+
+	const getOwner = function(node, owners) {
+		const owner = _getOwner(node, owners);
+		if (owner && !detectLoop(node, owners)) {
+			return owner;
+		}
+	};
+
+	const getParentNode = function(node, owners) {
+		return getOwner(node, owners) || node.parentNode;
+	};
+
+	const isHidden = function(node) {
+		return node.nodeType === node.ELEMENT_NODE && getAttribute(node, 'hidden');
+	};
+
+	const getChildNodes = function(node, owners) {
+		const childNodes = [];
+
+		for (let i = 0; i < node.childNodes.length; i++) {
+			const child = node.childNodes[i];
+			if (!getOwner(child, owners) && !isHidden(child)) {
+				childNodes.push(child);
+			}
+		}
+
+		if (node.nodeType === node.ELEMENT_NODE) {
+			const owns = getAttribute(node, 'owns') || [];
+			for (let i = 0; i < owns.length; i++) {
+				const child = document.getElementById(owns[i]);
+				// double check with getOwner for consistency
+				if (child && getOwner(child, owners) === node && !isHidden(child)) {
+					childNodes.push(child);
+				}
+			}
+		}
+
+		return childNodes;
+	};
+
+	const walk = function(root, fn) {
+		const owners = document.querySelectorAll('[aria-owns]');
+		let queue = [root];
+		while (queue.length) {
+			const item = queue.shift();
+			fn(item);
+			queue = getChildNodes(item, owners).concat(queue);
+		}
+	};
+
+	const searchUp = function(node, test) {
+		const candidate = getParentNode(node);
+		if (candidate) {
+			if (test(candidate)) {
+				return candidate;
+			} else {
+				return searchUp(candidate, test);
+			}
+		}
+	};
+
+	const matches = function(el, selector) {
+		if (selector.substr(0, 1) === ':') {
+			const attr = selector.substr(1);
+			return getAttribute(el, attr);
+		} else if (selector.substr(0, 1) === '[') {
+			const match = /\[([a-z]+)="(.*)"\]/.exec(selector);
+			const actual = getAttribute(el, match[1]);
+			const rawValue = match[2];
+			return actual.toString() === rawValue;
+		} else {
+			return hasRole(el, selector.split(','));
+		}
+	};
+
+	const _querySelector = function(all) {
+		return function(root, selector) {
+			const results = [];
+			try {
+				walk(root, node => {
+					if (node.nodeType === node.ELEMENT_NODE) {
+						// FIXME: skip hidden elements
+						if (matches(node, selector)) {
+							results.push(node);
+							if (!all) {
+								throw 'StopIteration';
+							}
+						}
+					}
+				});
+			} catch (e) {
+				if (e !== 'StopIteration') {
+					throw e;
+				}
+			}
+			return all ? results : results[0];
+		};
+	};
+
+	const closest = function(el, selector) {
+		return searchUp(el, candidate => {
+			if (candidate.nodeType === candidate.ELEMENT_NODE) {
+				return matches(candidate, selector);
+			}
+		});
+	};
+
+	const querySelector = _querySelector();
+	const querySelectorAll = _querySelector(true);
+
+	const addSpaces = function(text, el, pseudoSelector) {
+		// https://github.com/w3c/accname/issues/3
+		const styles = window.getComputedStyle(el, pseudoSelector);
+		const inline = styles.display === 'inline';
+		return inline ? text : ` ${text} `;
+	};
+
+	const getPseudoContent = function(el, pseudoSelector) {
+		const styles = window.getComputedStyle(el, pseudoSelector);
+		let tail = styles.getPropertyValue('content').trim();
+		let ret = [];
+
+		let match;
+		while (tail.length) {
+			if ((match = tail.match(/^"([^"]*)"/))) {
+				ret.push(match[1]);
+			} else if ((match = tail.match(/^([a-z-]+)\(([^)]*)\)/))) {
+				if (match[1] === 'attr') {
+					ret.push(el.getAttribute(match[2]) || '');
+				}
+			} else if ((match = tail.match(/^([a-z-]+)/))) {
+				if (match[1] === 'open-quote' || match[1] === 'close-quote') {
+					ret.push('"');
+				}
+			} else if ((match = tail.match(/^\//))) {
+				ret = [];
+			} else {
+				// invalid content, ignore
+				return '';
+			}
+			tail = tail.slice(match[0].length).trim();
+		}
+
+		return addSpaces(ret.join(''), el, pseudoSelector);
+	};
+
+	const getContent = function(root, ongoingLabelledBy, visited) {
+		const children = getChildNodes(root);
+
+		let ret = '';
+		for (let i = 0; i < children.length; i++) {
+			const node = children[i];
+			if (node.nodeType === node.TEXT_NODE) {
+				const styles = window.getComputedStyle(node.parentElement);
+				if (styles.textTransform === 'uppercase') {
+					ret += node.textContent.toUpperCase();
+				} else if (styles.textTransform === 'lowercase') {
+					ret += node.textContent.toLowerCase();
+				} else if (styles.textTransform === 'capitalize') {
+					ret += node.textContent.replace(/\b\w/g, c => c.toUpperCase());
+				} else {
+					ret += node.textContent;
+				}
+			} else if (node.nodeType === node.ELEMENT_NODE) {
+				if (node.tagName.toLowerCase() === 'br') {
+					ret += '\n';
+				} else {
+					ret += getNameRaw(node, true, ongoingLabelledBy, visited);
+				}
+			}
+		}
+
+		return ret;
+	};
+
+	const allowNameFromContent = function(el) {
+		const role = getRole(el);
+		if (role) {
+			return roles[role].nameFromContents;
+		}
+	};
+
+	const getNameRaw = function(el, recursive, ongoingLabelledBy, visited, directReference) {
+		let ret = '';
+
+		visited = visited || [];
+		if (visited.includes(el)) {
+			if (!directReference) {
+				return '';
+			}
+		} else {
+			visited.push(el);
+		}
+
+		// A
+		// handled in atree
+
+		// B
+		if (!ongoingLabelledBy && el.matches('[aria-labelledby]')) {
+			const ids = el.getAttribute('aria-labelledby').split(/\s+/);
+			const strings = ids.map(id => {
+				const label = document.getElementById(id);
+				return label ? getNameRaw(label, true, true, visited, true) : '';
+			});
+			ret = strings.join(' ');
+		}
+
+		// E (the current draft has this at this high priority)
+		if (!ret.trim() && recursive) {
+			if (matches(el, 'textbox')) {
+				ret = el.value || el.textContent;
+			} else if (matches(el, 'combobox,listbox')) {
+				const selected = querySelector(el, ':selected') || querySelector(el, 'option');
+				if (selected) {
+					ret = getNameRaw(selected, recursive, ongoingLabelledBy, visited);
+				} else {
+					ret = el.value || '';
+				}
+			} else if (matches(el, 'range')) {
+				ret = '' + (getAttribute(el, 'valuetext') || getAttribute(el, 'valuenow') || el.value);
+			}
+		}
+
+		// C
+		if (!ret.trim() && el.matches('[aria-label]')) {
+			// FIXME: may skip to 2E
+			ret = el.getAttribute('aria-label');
+		}
+
+		// D
+		if (!ret.trim() && !recursive && el.labels) {
+			const strings = Array.prototype.map.call(el.labels, label => {
+				return getNameRaw(label, true, ongoingLabelledBy, visited);
+			});
+			ret = strings.join(' ');
+		}
+		if (!ret.trim()) {
+			ret = el.alt || '';
+		}
+		if (!ret.trim() && el.matches('abbr,acronym') && el.title) {
+			ret = el.title;
+		}
+		if (!ret.trim()) {
+			for (const selector in nameFromDescendant) {
+				if (el.matches(selector)) {
+					const descendant = el.querySelector(nameFromDescendant[selector]);
+					if (descendant) {
+						ret = getNameRaw(descendant, true, ongoingLabelledBy, visited);
+					}
+				}
+			}
+		}
+		if (!ret.trim() && el.matches('svg *')) {
+			const svgTitle = el.querySelector('title');
+			if (svgTitle && svgTitle.parentElement === el) {
+				ret = svgTitle.textContent;
+			}
+		}
+		if (!ret.trim() && el.matches('a')) {
+			ret = el.getAttribute('xlink:title') || '';
+		}
+
+		// F
+		// FIXME: menu is not mentioned in the spec
+		if (!ret.trim() && (recursive || allowNameFromContent(el) || el.closest('label')) && !matches(el, 'menu')) {
+			ret = getContent(el, ongoingLabelledBy, visited);
+		}
+
+		if (!ret.trim() && matches(el, 'button')) {
+			ret = el.value || '';
+		}
+
+		if (!ret.trim()) {
+			for (const selector in nameDefaults) {
+				if (el.matches(selector)) {
+					ret = nameDefaults[selector];
+				}
+			}
+		}
+
+		// G/H
+		// handled in getContent
+
+		// I
+		if (!ret.trim()) {
+			ret = el.title || el.placeholder || '';
+		}
+
+		// FIXME: not exactly sure about this, but it reduces the number of failing
+		// WPT tests. Whitespace is hard.
+		if (!ret.trim()) {
+			ret = ' ';
+		}
+
+		const before = getPseudoContent(el, ':before');
+		const after = getPseudoContent(el, ':after');
+		return addSpaces(before + ret + after, el);
+	};
+
+	const getName = function(el) {
+		return getNameRaw(el)
+			.replace(/[ \n\r\t\f]+/g, ' ')
+			.replace(/^ /, '')
+			.replace(/ $/, '');
+	};
+
+	const getDescription = function(el) {
+		let ret = '';
+
+		if (el.matches('[aria-describedby]')) {
+			const ids = el.getAttribute('aria-describedby').split(/\s+/);
+			const strings = ids.map(id => {
+				const label = document.getElementById(id);
+				return label ? getNameRaw(label, true, true) : '';
+			});
+			ret = strings.join(' ');
+		} else if (el.matches('[aria-description]')) {
+			ret = el.getAttribute('aria-description');
+		} else if (el.matches('svg *')) {
+			const svgDesc = el.querySelector('desc');
+			if (svgDesc && svgDesc.parentElement === el) {
+				ret = svgDesc.textContent;
+			}
+		} else if (el.title) {
+			ret = el.title;
+		}
+		if (!ret.trim() && el.matches('a')) {
+			ret = el.getAttribute('xlink:title') || '';
+		}
+
+		ret = (ret || '').trim().replace(/\s+/g, ' ');
+
+		if (ret === getName(el)) {
+			ret = '';
+		}
+
+		return ret;
+	};
+
+	exports.closest = closest;
+	exports.getAttribute = getAttribute;
+	exports.getChildNodes = getChildNodes;
+	exports.getDescription = getDescription;
+	exports.getName = getName;
+	exports.getParentNode = getParentNode;
+	exports.getRole = getRole;
+	exports.matches = matches;
+	exports.querySelector = querySelector;
+	exports.querySelectorAll = querySelectorAll;
+
+}));
+
+window.ariaApi = window.aria;