html/DOM3-Events.html
author Gary Kacmarcik <garykac@google.com>
Fri, 23 May 2014 07:45:46 -0700
changeset 641 b1e8b052491a
parent 640 a10c8f662151
child 642 0601f18fe5c1
permissions -rw-r--r--
Update stacked event dispatch image (re-create as SVG).
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en-US" xml:lang="en-US"
	data-bug-product='WebAppsWG'
	data-bug-component='DOM3 Events'
	>
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
	<title>Document Object Model (DOM) Level 3 Events Specification</title>
	<link rel="author" href="mailto:www-dom@w3.org" />
	<link rel="help" href="http://www.w3.org/DOM/" />
	<link rel="alternate stylesheet" type="text/css" media="screen" title="geek" href="geek.css" />
	<link rel="stylesheet" type="text/css" href="spec-WD.css" />
	<link rel="stylesheet" type="text/css" href="https://www.w3.org/StyleSheets/TR/w3c-tr.css" />
	<link rel="stylesheet" type="text/css" href="https://www.w3.org/StyleSheets/TR/W3C-WD" />
	<link rel="stylesheet" type="text/css" href="override.css" />
	<script type="text/javascript" src='https://www.w3.org/Tools/respec/respec-w3c-common' class='remove' async></script>
	<script type="text/javascript" src='fixup.js'></script>
	<script src="bug-assist.js"></script>
	<script type="text/javascript">
	var respecConfig = {
		specStatus: "ED",
		shortName:  "DOM-Level-3-Events",
		editors: [
			{
				name: "Gary Kacmarcik", 
				company: "Google, Inc.",
				url: "mailto:garykac@google.com?subject=%5BDOM3-event%5D%20Spec%20Feedback",
				companyURL: "http://www.google.com",
				note: "Jun 2013 - present",
			},
			{
				name: "Travis Leithead", 
				company: "Microsoft Corp.",
				url: "mailto:travis.leithead@microsoft.com?subject=%5BDOM3-event%5D%20Spec%20Feedback",
				companyURL: "http://www.microsoft.com",
				note: "Feb 2012 - present",
			},
			{
				name: "Jacob Rossi", 
				company: "Microsoft Corp.",
				note: "Mar 2011 - Oct 2011",
			},
			{
				name: "Doug Schepers", 
				company: "W3C",
				note: "Mar 2008 - May 2011",
			},
			{
				name: "Björn Höhrmann", 
				company: "Invited Expert",
				note: "until Jan 2008",
			},
			{
				name: "Philippe Le Hégaret", 
				company: "W3C",
				note: "until Nov 2003",
			},
			{
				name: "Tom Pixley", 
				company: "Netscape Communications Corporation",
				note: "until Jul 2002",
			}
		],
		publishDate:  "2014-05-09",
		edDraftURI: "https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html",
		previousPublishDate: "2013-11-05",
		previousMaturity: "WD",
		noIDLIn:  true,
		inlineCSS:  true,
		//noRecTrack:  true,
		wg: ["Web Applications Working Group"],
		wgURI: ["http://www.w3.org/2008/webapps/"],
		wgPublicList: "www-dom",
		wgPatentURI: ["http://www.w3.org/2004/01/pp-impl/42538/status"],
		maxTocLevel: 4
	};
	</script>
</head>
<body>
	<!-- Section: Abstract ========================================================-->
	<section id="abstract">
		<p>This specification defines the Document Object Model Events Level 3, a generic
			platform- and language-neutral event system which allows registration of event handlers,
			describes event flow through a tree structure, and provides basic contextual
			information for each event. The Document Object Model Events Level 3 builds on the
			Document Object Model Events Level 2 [<a href="#references-DOM2Events">DOM2 Events</a>].
			</p>
	</section>  <!-- abstract -->

	<!-- Section: SOTD ========================================================-->
	<section id="sotd">
		<p>This document is a Working Draft of the Document Object Model Level 3 Events
			(DOM3 Events) specification. 
			It is expected that this specification will progress to
			<abbr title="World Wide Web Consortium">W3C</abbr> 
			Recommendation status after review and refinement.
			</p>

		<p id="this-document-is-produced-by-the-web-app">
			This document is produced by the
				<a href="http://www.w3.org/2008/webapps/">Web Applications WG</a>,
			part of the
				<a href="http://www.w3.org/2006/rwc/Activity">Rich Web Clients Activity</a>
			in the W3C
				<a href="http://www.w3.org/Interaction/">Interaction Domain</a>.
			It is expected that this document will progress along the W3C's Recommendation track.
			Publication as a Working Draft does not imply endorsement by the W3C Membership.
			This is a draft document and MAY be updated, replaced or obsoleted by other
			documents at any time.
			It is inappropriate to cite this document as other than work in progress.
			</p>

		<p id="latest-editors-draft">
			<strong>You can find the latest
				<a href="https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html">Editor's Draft</a>
			of this document in the
				<a href="https://dvcs.w3.org/hg/">W3C's Mercurial repository</a>,
			which is updated on a regular basis.</strong>
			</p>

		<p id="unstable">
			<strong class="redNote">Implementers should be aware that this document is not stable.</strong>
			Implementers who are not taking part in the discussions are likely to find the
			specification changing out from under them in incompatible ways.
			Vendors interested in implementing this document before it eventually reaches
			the Candidate Recommendation stage should join the aforementioned mailing lists
			and take part in the discussions.
			</p>
	</section>  <!-- sotd -->

	<!-- Section 1: DOM3 Events Overview  ========================================================-->
	<section id="dom-events-intro">
		<h1>Introduction</h1>
		
		<section id="dom-events-overview">
			<h2>Overview</h2>
			<p>DOM Events is designed with two main goals. The first goal is the design of an <a class="def" href="#glossary-event">event</a> system which allows registration
				of event listeners and describes event flow through a tree structure. Additionally, the specification will provide standard modules of events for user interface
				control and document mutation notifications, including defined contextual information for each of these event modules.</p>

			<p>The second goal of DOM Events is to provide a common subset of the current event systems used in existing browsers. This is intended to foster interoperability
				of existing scripts and content. It is not expected that this goal will be met with full backwards compatibility. However, the specification attempts to achieve
				this when possible.</p>
		</section>  <!-- dom-events-overview -->

		<section id="dom-events-conformance">
			<h2>Conformance</h2>
			<p><strong>This section is normative.</strong></p>

			<p>Within this specification, the key words <q>MUST</q>, <q>MUST NOT</q>, <q>REQUIRED</q>,
				<q>SHALL</q>, <q>SHALL NOT</q>, <q>SHOULD</q>, <q>SHOULD NOT</q>,
				<q>RECOMMENDED</q>, <q>MAY</q>, and <q>OPTIONAL</q> are to be interpreted as described in
				[<a href="#RFC2119">RFC2119</a>].</p>

			<p>This specification is to be understood in the context of the DOM Level 3 Core specification [<cite><a class="normative" href="#references-DOMCore">DOM3 Core</a></cite>]
				and the general considerations for DOM implementations apply. For example, handling of <a class="def" href="#glossary-namespaceURI">namespace URIs</a> is discussed in
				<a class="normative" href="http://www.w3.org/TR/DOM-Level-3-Core/core.html#Namespaces-Considerations"><em>XML Namespaces</em></a>. For additional information about
				<a class="normative" href="http://www.w3.org/TR/DOM-Level-3-Core/introduction.html#ID-Conformance"><em>conformance</em></a>, please see the DOM Level 3 Core specification
				[<cite><a class="normative" href="#references-DOMCore">DOM3 Core</a></cite>].  A <a class="def" href="#glossary-user-agent">user agent</a> is not required to conform
				to the entirety of another specification in order to conform to this specification, but it MUST conform to the specific parts of any other specification which are called
				out in this specification (e.g., a conforming DOM3 Events <a class="def" href="#glossary-user-agent">user agent</a> MUST support the <code>DOMString</code> data type as defined
				in <a href="#references-WebIDL">Web IDL</a>, but need not support every method or data type defined in <a href="#references-WebIDL">Web IDL</a> in order to conform
				to DOM3 Events).</p>

			<p>This specification defines several classes of conformance for different <a class="def" href="#glossary-user-agent">user agents</a>, specifications, and content authors:</p>
			<dl>
				<dt id="conf-interactive-ua">Web browsers and other dynamic or interactive <a class="def" href="#glossary-user-agent">user agents</a></dt>
				<dd>
					<p>A dynamic or interactive <a class="def" href="#glossary-user-agent">user agent</a>, referred to
						here as a <q>browser</q> (be it a Web browser, AT (Accessibility Technology) application,
						or other similar program), conforms to DOM Level 3 Events if it supports:
						</p>
					<ul>
						<li>the Core module defined in
							[<cite><a class="normative" href="#references-DOMCore">DOM3 Core</a></cite>]
							</li>
						<li>the <a href="#event-flow">Event dispatch and DOM event flow</a> mechanism
							</li>
						<li>all the interfaces and events with their associated methods, attributes, and
							semantics defined in this specification with the exception of those marked as
							<a class="def" href="#glossary-deprecated">deprecated</a> (a conforming user
							agent MAY implement the deprecated interfaces, events, or APIs for backwards
							compatibility, but is not required to do so in order to be conforming)
							</li>
						<li>the complete set of <code>key</code> and <code>code</code> values defined in
							[<a href="#references-D3E-key">DOM3 key Values</a>] and
							[<a href="#references-D3E-code">DOM3 code Values</a>]
							(subject to platform availability), and
							</li>
						<li>all other normative requirements defined in this specification.
							</li>
					</ul>
					<p>A conforming browser MUST <a class="def" href="#glossary-dispatch">dispatch</a> events appropriate
						to the given <a href="#interface-EventTarget">EventTarget</a> when the conditions defined
						for that <a class="def" href="#glossary-event-type">event type</a> have been met.
						</p>

					<p><span id="conform-arch">A browser conforms specifically to the DOM Level 3 Events Architecture if it implements the <a href="#dom-event-architecture">DOM Event
						Architecture</a> and <a href="#event-interfaces">Basic Event Interfaces</a>, regardless of its support for any other event interfaces or <a class="def" href="#glossary-event-type">
						event types</a> defined in this specification.</span>  <span id="conform-module">A browser conforms specifically to the DOM Level 3 Events Module if it implements
						the interfaces and its related <a class="def" href="#glossary-event-type">event types</a> specified in the <a href="#events-module">Events Module</a>, and to each
						event interface if it implements that interface and its related <a class="def" href="#glossary-event-type">event types</a>.</span></p>

					<p><span id="conform-script">A conforming browser MUST support scripting, declarative interactivity, or some other means of detecting and dispatching events in the manner
						described by this specification, and MUST support the APIs specified for that <a class="def" href="#glossary-event-type">event type</a>.</span></p>

					<p>In addition to meeting all other conformance criteria, a conforming browser MAY implement features of this specification marked as <a class="def" href="#glossary-deprecated">
						deprecated</a>, for backwards compatibility with existing content, but such implementation is discouraged.</p>

					<p>A conforming browser MAY also support features not found in this specification, but which use the <a href="#event-flow">Event dispatch and DOM event flow</a> mechanism,
						interfaces, events, or other features defined in DOM Level 3 Events, and MAY implement additional interfaces and <a class="def" href="#glossary-event-type">event types</a>
						appropriate to that implementation. Such features can be later standardized in future specifications.</p>

					<p>A browser which does not conform to all required portions of this specification MUST NOT claim conformance to DOM Level 3 Events.  Such an implementation which
						does conform to portions of this specification MAY claim conformance to those specific portions.</p>

					<p>A conforming browser MUST also be a <i>conforming implementation</i> of the IDL fragments in this specification, as described in the Web IDL specification. <a
						href="#references-WebIDL">[WEBIDL]</a></p>
				</dd>

				<dt id="conf-author-tools">Authoring tools</dt>
				<dd>
					<p>A content authoring tool conforms to DOM Level 3 Events if it produces content which uses the <a class="def" href="#glossary-event-type">event types</a> and <a
						href="#event-flow">Event dispatch and DOM event flow</a> model, consistent in a manner as defined in this specification.  A content authoring tool MUST NOT claim
						conformance to DOM Level 3 Events for content it produces which uses features of this specification marked as <a class="def" href="#glossary-deprecated">deprecated</a>
						in this specification.  A conforming content authoring tool SHOULD provide to the content author a means to use all <a class="def" href="#glossary-event-type">event
						types</a> and interfaces appropriate to all <a class="def" href="#glossary-host-language">host languages</a> in the content document being produced.</p>
				</dd>

				<dt id="conf-authors">Content authors and content</dt>
				<dd>
					<p>A content author creates conforming DOM Level 3 Events content if that content uses the <a class="def" href="#glossary-event-type">event types</a> and <a href="#event-flow">
						Event dispatch and DOM event flow</a> model, consistent in a manner as defined in this specification.  A content author SHOULD NOT use features of this specification
						marked as <a class="def" href="#glossary-deprecated">deprecated</a>, but SHOULD rely instead upon replacement mechanisms defined in this specification and elsewhere.
						Conforming content MUST use the semantics of the interfaces and <a class="def" href="#glossary-event-type">event types</a> as described in this specification.</p>

					<p class="note"><strong>Authoring Note: </strong>Content authors are advised to follow best practices as described in <a href="http://www.w3.org/TR/WAI-WEBCONTENT/">
						accessibility</a> and <a href="http://www.w3.org/standards/techs/i18n">internationalization</a> guideline specifications.</p>
				</dd>

				<dt id="conf-specs">Specifications and host languages</dt>
				<dd>
					<p>A specification or <a class="def" href="#glossary-host-language">host language</a> conforms to DOM Level 3 Events if it references and uses the <a href="#event-flow">
						Event dispatch and DOM event flow</a> mechanism, interfaces, events, or other features defined in this specification, and does not extend these
						features in incompatible ways.  A specification or <a class="def" href="#glossary-host-language">host language</a> conforms specifically to the DOM Level 3 Events
						Architecture if it references and uses the <a href="#dom-event-architecture">DOM Event Architecture</a> and <a href="#event-interfaces">Basic Event Interfaces</a>,
						regardless of its use of any other event interfaces or <a class="def" href="#glossary-event-type">event types</a> defined in this specification.</p>

					<p>A specification or <a class="def" href="#glossary-host-language">host language</a> conforms specifically to the DOM Level 3 Events Module if it references and uses the interfaces and
						its related <a class="def" href="#glossary-event-type">event types</a> specified in the <a href="#events-module">Events Module</a>, and to each event interface
						if it references and uses that interface and its related <a class="def" href="#glossary-event-type">event types</a>. A conforming specification MAY
						define additional interfaces and <a class="def" href="#glossary-event-type">event types</a> appropriate to that specification, or MAY extend the DOM Level 3 Events
						interfaces and <a class="def" href="#glossary-event-type">event types</a> in a manner that does not contradict or conflict with the definitions of those interfaces
						and <a class="def" href="#glossary-event-type">event types</a> in this specification.</p>

					<p>Specifications or <a class="def" href="#glossary-host-language">host languages</a> which reference DOM Level 3 Events SHOULD NOT use or recommend features of this
						specification marked as <a class="def" href="#glossary-deprecated">deprecated</a>, but SHOULD use or recommend the indicated replacement for that the feature (if available).</p>
				</dd>
			</dl>
		</section>  <!-- dom-events-conformance -->

		<section id="style-conventions">
			<h2>Stylistic Conventions</h2>
			<p>This specification follows the <a href="http://www.w3.org/People/Schepers/spec-conventions.html">Proposed W3C Specification
				Conventions</a>, with the following supplemental additions:</p>

			<dl>
				<dt>Key and character values</dt>
				<dd><ul>
					<li>Names of key values are shown as: <code class="key">'='</code> (e.g., the value of 
						<a href="#widl-KeyboardEvent-key"><code>KeyboardEvent.key</code></a>).
					<li>Names of key codes are shown as: <code class="code">'Equal'</code> (e.g., the value of 
						<a href="#widl-KeyboardEvent-code"><code>KeyboardEvent.code</code></a>).
					<li>Character values of keys are shown as: <code class="char">'\u003d'</code> (e.g., the code point 
						of the key value).
					<li>Glyphs representing character values are shown as: <code class="glyph">'='</code> (e.g., the
						<a href="#key-legends"><em>key cap</em></a> or font associated with a character value).
				</ul></dd>
			</dl>

			<p>In addition, certain terms are used in this specification with particular meanings.  The term <q>implementation</q> applies to a browser, content authoring tool,
				or other <a class="def" href="#glossary-user-agent">user agent</a> that implements this specification, while a content author is a person who writes script or code
				that takes advantage of the interfaces, methods, attributes, events, and other features described in this specification in order to make Web applications, and a
				user is the person who uses those Web applications in an implementation.</p>
		</section>  <!-- style-conventions -->
	</section>  <!-- dom-events-intro -->

	<!-- Section 2: Issues ==============================================================-->
	<section id="issues">
		<h1>Issues</h1>
		
		<p class="issue">Open issues in this specification are called out using this convention.</p>
	</section>
	
	<!-- Section 3: Architecture ========================================================-->
	<section id="dom-event-architecture">
		<h1>DOM Event Architecture</h1>

		<section id="event-flow">
			<h2>Event dispatch and DOM event flow</h2>

			<p>This section defines the event <a class="def" href="#glossary-dispatch">dispatch</a> mechanism of the event model defined in this specification.
				Applications MAY dispatch event objects using the <a href="#widl-EventTarget-dispatchEvent"><code>EventTarget.dispatchEvent()</code></a> method, and
				implementations MUST dispatch event objects as if through this method. The behavior of this method depends on the <em>event flow</em>
				associated with the underlying object. An event flow describes how event objects <em>propagate</em> through a data structure. As an example, when an event object
				is dispatched to an element in an XML document, the object propagates through parts of the document, as determined by the DOM event flow which is defined at the
				end of this section.</p>

			<figure id="figure-dom-event-flow">
				<img src='images/eventflow.svg' width="520" height="560" />
				<figcaption>Graphical representation of an event dispatched in a DOM tree using the DOM event flow</figcaption>
			</figure>

			<p>Event objects are dispatched to an <a class="def" href="#glossary-event-target">event target</a>. At the beginning
				of the dispatch, implementations MUST first determine the event object's <a class="def" href="#glossary-propagation-path">propagation path</a>.</p>

			<p>The propagation path MUST be an ordered list of <a class="def" href="#glossary-current-event-target">current event targets</a> through which
				the event object MUST pass. For DOM implementations, the propagation path MUST reflect the hierarchical tree
				structure of the document. The last item in the list MUST be the <a class="def" href="#glossary-event-target">event target</a>. The
				preceding items in the list are referred to as the <em>target's ancestors</em>, and the immediately preceding item as the <em>target's parent</em>. Once determined, the
				propagation path MUST NOT be changed. For DOM implementations, this applies even if an element in the propagation path is moved within the
				DOM or removed from the DOM.</p>

			<div class="example">
				<div class="example-title"></div>
				<p>In the DOM event flow, event listeners might change the position of the <a class="def" href="#glossary-event-target">
				event target</a> in the document while the event object is being dispatched. Such changes do not affect the propagation path.</p>
			</div>

			<p>Exceptions thrown inside event listeners MUST NOT stop the propagation of the event or affect the
				<a class="def" href="#glossary-propagation-path">propagation path</a>. The exception itself MUST NOT propagate outside the scope of the event
				handler.</p>

			<div class="example">
				<div class="example-title"></div>
				<p>In the following code, the exception thrown from the call to <code>throw "Error"</code> does not propagate into the parent scope
				(which would prevent the <code>console.log</code> statement from executing):</p>
<pre>var e = document.createEvent("Event");
e.initEvent("myevent", false, false);
var target = document.createElement("div");
target.addEventListener("myevent", function () {
   throw "Error";
});
target.dispatchEvent(e); <span class="comment">// Causes the event listener to throw an exception...</span>
<span class="comment">// The previously thrown exception doesn't affect the code that follows:</span>
console.log("Exceptions? No problem");</pre>
			</div>

			<p id="event-phase">As the next step, the event object MUST complete one or more <a class="def" href="#glossary-phase">event phases</a>. This specification defines
				three event phases: <a href="#capture-phase">capture phase</a>, <a href="#target-phase">target phase</a> and <a href="#bubble-phase">bubble phase</a>.  Event objects
				complete these phases in the specified order using the partial propagation paths as defined below. A phase MUST be skipped if it is not
				supported, or if the event object's propagation has been stopped. For example, if the <a href="#widl-Event-bubbles"><code>Event.bubbles</code></a>
				attribute is set to false, the bubble phase will be skipped, and if <a href="#widl-Event-stopPropagation"><code>Event.stopPropagation()</code></a> has been
				called prior to the dispatch, all phases MUST be skipped.</p>

			<ol>
				<li>The <strong id="capture-phase">capture phase</strong>: The event object MUST propagate through the target's ancestors from the <a class="def"
					href="#glossary-window">Window</a> to the target's parent. This phase is also known as the <em>capturing phase</em>. Event
					listeners registered for this phase MUST handle the event before it reaches its target.</li>

				<li>The <strong id="target-phase">target phase</strong>: The event object MUST arrive at the event object's <a class="def" href="#glossary-event-target">
					event target</a>. This phase is also known as the <em>at-target phase</em>. Event listeners registered for this phase MUST
					handle the event once it has reached its target. If the <a class="def" href="#glossary-event-type">event type</a> indicates that
					the event MUST NOT bubble, the event object MUST halt after completion of this phase.</li>

				<li>The <strong id="bubble-phase">bubble phase</strong>: The event object propagates through the target's ancestors in reverse order, starting
					with the target's parent and ending with the <a class="def" href="#glossary-window">Window</a>. This phase is also known as the <em>bubbling phase</em>.
					Event listeners registered for this phase MUST handle the event after it has reached its target.</li>
			</ol>

			<p>Implementations MUST let event objects accomplish an event phase by applying the following steps while there are pending event targets in
				the partial propagation path for this phase and the event object's propagation has not been stopped through <a href="#widl-Event-stopPropagation"><code>
				Event.stopPropagation()</code></a>.</p>

			<p>First, the implementation MUST determine the <em>current target</em>. This MUST be the next pending event target in the partial propagation
				path, starting with the first. From the perspective of an event listener this MUST be the event target the listener has been registered on.</p>

			<p>Next, the implementation MUST determine the current target's <a class="def" href="#glossary-candidate-event-handlers">candidate event listeners</a>.
				This MUST be the list of all event listeners that have been registered on the current target in their order of registration. [<cite><a class="informative"
				href="#references-HTML5">HTML5</a></cite>] defines the ordering of listeners registered through event handler attributes. Once determined, the candidate event listeners
				MUST NOT be changed. Adding or removing listeners does not affect the current target's candidate event listeners.</p>

			<p>Finally, the implementation MUST process all candidate <a class="def" href="#glossary-event-handler">event handlers</a> in order and trigger
				each handler if all the following conditions are met:</p>

			<ul>
				<li>The event object's immediate propagation has not been stopped.</li>

				<li>The listener has been registered for this event phase.</li>

				<li>The listener has been registered for this <a class="def" href="#glossary-event-type">event type</a>.</li>
			</ul>

			<p>In the production of the <a class="def" href="#glossary-propagation-path">propagation path</a>, the event propagates from the <a class="def" href="#glossary-window">Window</a>
				to the <code>document</code> object during the <a class="def" href="#glossary-capture-phase">capture phase</a>, and from the <code>document</code> object to the
				<a class="def" href="#glossary-window">Window</a> during the <a class="def" href="#glossary-bubbling-phase">bubble phase</a>.</p>

			<p>After an event completes all the phases of its <a class="def" href="#glossary-propagation-path">propagation path</a>, its <a href="#widl-Event-currentTarget">
				<code>Event.currentTarget</code></a> MUST be set to <code>null</code> and the <a href="#widl-Event-eventPhase"><code>Event.eventPhase</code></a> MUST be
				set to <code>0</code> (<a href="#widl-Event-NONE"><code>NONE</code></a>). All other attributes of the <code>Event</code> (or interface derived from <code>Event</code>)
				are unchanged (including the <a href="#widl-Event-target"><code>Event.target</code></a> attribute, which MUST continue to reference the <a class="def" href="#glossary-event-target">
				event target</a>).</p>

			<p>The model defined above MUST be applied regardless of the specific event flow associated with an event target. Each event flow MUST define how the propagation path
				MUST be determined and which event phases are supported. The <em>DOM event flow</em> is an application of this model: the propagation path for a <code>Node</code>
				object MUST be determined by its <code>Node.parentNode</code> chain, and if applicable, the document's containing <a class="def" href="#glossary-window">Window</a>.
				All events accomplish the capture and target phases. Whether an event accomplishes the bubble phase MUST be defined individually for each <a class="def" href="#glossary-event-type">
				event type</a>. An alternate application of this model can be found in [<cite><a class="informative" href="#references-DOMLS">DOM3 Load and Save</a></cite>].</p>

			<p>Implementations of the DOM event model MUST be reentrant. Event listeners MAY perform actions that cause additional events to be dispatched. Such events are handled
				in a synchronous manner, the event propagation that causes the event listener to be triggered MUST resume only after the event dispatch of the new event is completed.</p>
		</section>  <!-- event-flow -->

		<section id="event-flow-default-cancel">
			<h2>Default actions and cancelable events</h2>

			<p>Events are typically dispatched by the implementation as a result of a user action, in response to the completion of a task, or to signal progress during asynchronous
				activity (such as a network request). Some events can be used to control the behavior that the implementation MAY take next (or undo an action that the implementation
				already took). Events in this category are said to be <em>cancelable</em> and the behavior they cancel is called their <a class="def" href="#glossary-default-action">
				<em>default action</em></a>. Cancelable event objects can be associated with one or more <a class="def" href="#glossary-default-action">default actions</a>.
				To cancel an event, call the <a href="#widl-Event-preventDefault"><code>Event.preventDefault()</code></a> method.</p>

			<div class="example">
				<div class="example-title"></div>
				<p>A <a class="eventtype" href="#event-type-mousedown"><code>mousedown</code></a> event is dispatched immediately after the user presses down a button on a
				pointing device (typically a mouse). One possible <a class="def" href="#glossary-default-action">default action</a> taken by the implementation is to set up a state
				machine that allows the user to drag images or select text. The <a class="def" href="#glossary-default-action">default action</a> depends on what happens next &mdash; for
				example, if the user's pointing device is over text, a text selection might begin. If the user's pointing device is over an image, then an image-drag action could
				begin. Preventing the <a class="def" href="#glossary-default-action">default action</a> of a <a class="eventtype" href="#event-type-mousedown"><code>mousedown</code></a>
				event prevents these actions from occuring.</p>
			</div>

			<p><a class="def" href="#glossary-default-action">Default actions</a> SHOULD be performed after the event dispatch has been completed, but in exceptional
				cases MAY also be performed immediately before the event is dispatched.</p>

			<div class="example">
				<div class="example-title"></div>
				<p>The default action associated with the <a class="eventtype" href="#event-type-click"><code>click</code></a> event on <code>&lt;input
				type="checkbox"&gt;</code> elements toggles the <code>checked</code> IDL attribute value of that element. If the <a class="eventtype" href="#event-type-click"><code>click</code>
				</a> event's default action is cancelled, then the value is restored to its former state.</p>
			</div>

			<p id="events-dt-cancelable-event">When an event is canceled, then the conditional <a class="def" href="#glossary-default-action">default actions</a> associated with the event MUST be skipped (or
				as mentioned above, if the <a class="def" href="#glossary-default-action">default actions</a> are carried out before the dispatch, their effect MUST be undone).
				Whether an event object is cancelable MUST be indicated by the <a href="#widl-Event-cancelable"><code>Event.cancelable</code></a> attribute. <a href="#widl-Event-preventDefault">
				<code>Event.preventDefault()</code></a> stops all related <a class="def" href="#glossary-default-action">default actions</a> of an event object. The <a href="#widl-Event-defaultPrevented">
				<code>Event.defaultPrevented</code></a> attribute indicates whether an event has already been canceled (e.g., by a prior event listener). If the <a class="def" href="#glossary-DOM-application">
				DOM application</a> itself initiated the dispatch, then the return value of the <a href="#widl-EventTarget-dispatchEvent"><code>EventTarget.dispatchEvent()</code></a>
				method indicates whether the event object was cancelled.</p>

			<p class="note"><strong>Authoring Note: </strong>Many implementations additionally interpret an event listener's return value, such as the value <code>false</code>, to mean
				that the <a class="def" href="#glossary-default-action">default action</a> of cancelable events will be cancelled (though <code>window.onerror</code> handlers are cancelled
				by returning <code>true</code>).</p>

			<p class="note"><strong>Authoring Note: </strong>Some cancelable events might not have any observable <a class="def" href="#glossary-default-action">default actions</a>. For
				example, the <a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a> event.</p>

			<p>This specification does not offer features to programatically query if an event object has any <a class="def" href="#glossary-default-action">default action</a> associated with
				it, or to associate new <a class="def" href="#glossary-default-action">default actions</a> with an event object. Other specifications SHOULD define what default actions, if any,
				are associated with certain event objects. Further, implementations MAY associate <a class="def" href="#glossary-default-action">default actions</a> with events as necessary and
				appropriate for that implementation.</p>

			<div class="example">
				<div class="example-title"></div>
				<p>As an example, one implementation might scroll a document view by a certain amount as the <a class="def" href="#glossary-default-action">
				default action</a> of a <a class="eventtype" href="#event-type-wheel"><code>wheel</code></a> event, while another implementation might instead zoom the document as its <a class="def"
				href="#glossary-default-action">default action</a>.</p>
			</div>
		</section>  <!-- event-flow-default-cancel -->

		<section id="sync-async">
			<h2>Synchronous and asynchronous events</h2>

			<p>Events MAY be dispatched either synchronously or asynchronously.</p>

			<p>Events which are synchronous (<em><q>sync events</q></em>) MUST be treated as if they are in a virtual queue in a first-in-first-out model, ordered by sequence
				of temporal occurrence with respect to other events, to changes in the DOM, and to user interaction.  Each event in this virtual queue MUST be delayed until the
				previous event has completed its propagation behavior, or been canceled.  Some sync events are driven by a specific device or process, such as mouse button events.
				These events are governed by the <a class="def" href="#glossary-event-order">event order</a> algorithms defined for that set of events, and a user agent MUST dispatch
				these events in the defined order.</p>

			<div class="example">
				<div class="example-title"></div>
				<p>A user double-clicks a passage of text to select a word, then presses the <code class="key">'Delete'</code>
				key to erase the word, triggering the following synchronous sequence of events:
					<a class="eventtype" href="#event-type-mousedown"><code>mousedown</code></a>,
					<a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a>,
					<a class="eventtype" href="#event-type-click"><code>click</code></a>,
					<a class="eventtype" href="#event-type-mousedown"><code>mousedown</code></a>,
					<a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a>,
					<a class="eventtype" href="#event-type-click"><code>click</code></a>,
					<a class="eventtype" href="#event-type-dblclick"><code>dblclick</code></a>,
					<a class="eventtype" href="#event-type-select"><code>select</code></a>,
					<a class="eventtype" href="#event-type-keydown"><code>keydown</code></a>,
					<a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a>,
					<a class="eventtype" href="#event-type-input"><code>input</code></a>,
					<a class="eventtype" href="#event-type-keyup"><code>keyup</code></a>.
				Each of these events are fired in the sequence initiated by the user's actions.</p>
			</div>

			<p>Events which are asynchronous (<em><q>async events</q></em>) MAY be dispatched as the results of the action are completed, with no relation to other events, to
				other changes in the DOM, nor to user interaction.</p>

			<div class="example">
				<div class="example-title"></div>
				<p>During loading of a document, an inline script element is parsed and executed. The <a class="eventtype" href="#event-type-load">
				<code>load</code></a> event is queued to be fired asynchronously at the script element. However, because it is an async event, its order with relation to other synchronous
				events fired during document load (such as the <code class="eventtype">DOMContentLoaded</code> event from <cite><a class="informative" href="#references-HTML5">HTML5</a></cite>) is not guaranteed.</p>
			</div>

			<section id="event-order-and-loops">
				<h3>Event order and event loops</h3>

				<p>Most events take place in a sequential context.  [<cite><a class="informative" href="#references-HTML5">HTML5</a></cite>] defines its event operations in terms
					of an event loop mechanism, in which events of all types are fed into different <em>task queues</em>.  This specification does not define events in terms of this
					event loop mechanism, but it is compatible with this mechanism.  Instead, this specification defines several operation-specific <a class="def" href="#glossary-event-order">
					event orders</a>.</p>

				<p>Using the terminology of HTML5, each independent device, such as a mouse or keyboard, SHOULD be treated as a <em>task source</em> which feeds into the appropriate
					<em>task queue</em>, in the order defined by the <a class="def" href="#glossary-event-order">event order</a> associated with that device. Each operation, such as
					a focus change or composition input, also acts as a <em>task source</em> for the appropriate <em>task queue</em>.  The resolution of these event loops is handled
					in a manner conforming to the <a class="def" href="#glossary-host-language">host language</a>, such as HTML [<cite><a class="informative" href="#references-HTML5">HTML5</a></cite>].</p>

				<p class="note"><strong>Authoring Note:</strong> Certain events, such as <q>hotkeys</q> or control keys pressed in a certain sequence, can be
					<q>swallowed</q> by the operating system or the application, interrupting the expected <a class="def" href="#glossary-event-order">event order</a>.</p>
			</section>  <!-- event-order-and-loops -->
		</section>  <!-- sync-async -->

		<section id="trusted-events">
			<h2>Trusted events</h2>

			<p>Events that are generated by the user agent, either as a result of user interaction, or as a direct result of changes to the DOM, are trusted by the user agent
				with privileges that are not afforded to events generated by script through the <a href="#widl-DocumentEvent-createEvent"><code>DocumentEvent.createEvent("Event")</code></a>
				method, modified using the <a href="#widl-Event-initEvent"><code>Event.initEvent()</code></a> method, or dispatched via the <a href="#widl-EventTarget-dispatchEvent">
				<code>EventTarget.dispatchEvent()</code></a> method.  The <a href="#widl-Event-isTrusted"><code>isTrusted</code></a> attribute of trusted events has a
				value of <code>true</code>, while untrusted events have a <a href="#widl-Event-isTrusted"><code>isTrusted</code></a> attribute value of <code>false</code>.</p>

			<p>Most untrusted events SHOULD NOT trigger <a class="def" href="#glossary-default-action">default actions</a>, with the exception of the <a class="eventtype" href="#event-type-click">
				<code>click</code></a> event. This event always triggers the <a class="def" href="#glossary-default-action">
				default action</a>, even if the <a href="#widl-Event-isTrusted"><code>isTrusted</code></a> attribute is <code>false</code> (this behavior is retained for backward-compatibility).
				All other untrusted events MUST behave
				as if the <a href="#widl-Event-preventDefault"><code>Event.preventDefault()</code></a> method had been called on that event.</p>
		</section>  <!-- trusted-events -->

		<section id="event-flow-activation">
			<h2>Activation triggers and behavior</h2>

			<p>Certain <a class="def" href="#glossary-event-target">event targets</a> (such as a link or button element) MAY have associated <a class="def" href="#glossary-activation-behavior">
				activation behavior</a> (such a following a link) that implementations perform in response to an <em><a class="def" href="#glossary-activation-trigger">activation
				trigger</a></em> (such as clicking a link).</p>

			<p>A <a class="def" href="#glossary-host-language">host language</a> SHOULD indicate which, if any, elements have activation behavior, describe appropriate <a class="def"
				href="#glossary-activation-trigger">activation triggers</a>, and define the result of that activation behavior.  An implementation which supports a <a class="def"
				href="#glossary-host-language">host language</a> SHOULD initiate these <a class="def" href="#glossary-activation-behavior">activation behavior</a> when the associated
				<a class="def" href="#glossary-activation-trigger">activation trigger</a> occurs.</p>

			<div class="example" id="example-activation">
				<div class="example-title"></div>
				<p>Both HTML and SVG have an <code>&lt;a&gt;</code> element which indicates a link.  Relevant <a
				class="def" href="#glossary-activation-trigger">activation triggers</a> for an <code>&lt;a&gt;</code> element are a <a class="eventtype" href="#event-type-click"><code>
				click</code></a> event on the text or image  content of the <code>&lt;a&gt;</code> element, or a <a class="eventtype" href="#event-type-keydown"><code>keydown</code></a>
				event with a <a href="#widl-KeyboardEvent-key">key</a> attribute value of <code class="key">'Enter'</code> key when the <code>&lt;a&gt;</code>
				element has focus.  The activation behavior for an <code>&lt;a&gt;</code> element is normally to change the content of the window to the content of the new document,
				in the case of external links, or to reposition the current document relative to the new anchor, in the case of internal links.</p>
			</div>

			<p>An <a class="def" href="#glossary-activation-trigger">activation trigger</a> is a user action or an event which indicates to the implementation that an activation
				behavior SHOULD be initiated.  User-initiated <a class="def" href="#glossary-activation-trigger">activation triggers</a> include clicking a mouse button on an activatable
				element, pressing the <code class="key">'Enter'</code> key when an activatable element has focus, or pressing a key that is somehow
				linked to an activatable element (a <q>hotkey</q> or <q>access key</q>) even when that element does not have focus.  Event-based <a class="def" href="#glossary-activation-trigger">
				activation triggers</a> MAY include timer-based events that activate an element at a certain clock time or after a certain time period has elapsed, progress
				events after a certain action has been completed, or many other condition-based or state-based events.</p>

			<p>In some cases, a <a class="def" href="#glossary-host-language">host language</a> MAY define attributes or even attribute values which add to or change the native
				<a class="def" href="#glossary-activation-trigger">activation trigger</a> or <a class="def" href="#glossary-activation-behavior">activation behavior</a> of an element.
				For example, ARIA [<cite><a class="informative" href="#ref-ARIA">ARIA</a></cite>] defines values for the <code class="attr">role</code> attribute that add semantics
				to the element to which it is applied, for purposes of enhanced accessibility.  In such cases, if the <a class="def" href="#glossary-host-language">host language</a>
				does not explicitly define the <a class="def" href="#glossary-activation-trigger">activation trigger</a> or <a class="def" href="#glossary-activation-behavior">activation
				behavior</a>, the content author MUST provide the mechanics of the <a class="def" href="#glossary-activation-trigger">activation trigger</a> (via an event listener)
				or <a class="def" href="#glossary-activation-behavior">activation behavior</a> (such as calling an ECMAScript function) for that element when applying that attribute
				or attribute value.</p>

			<section id="click-synthesis">
				<h3>Activation event synthesis</h3>

				<p>If the instance of the <a class="def" href="#glossary-activation-trigger">activation trigger</a> is not an event of <a class="def" href="#glossary-event-type">event
					type</a> <a class="eventtype" href="#event-type-click"><code>click</code></a> (that is, when it does not result from a user's activation of a button or link
					using a mouse or equivalent pointing device), the implementation MUST synthesize and dispatch an event of <a class="def" href="#glossary-event-type">event type</a> <a
					class="eventtype" href="#event-type-click"><code>click</code></a> as one of the <a class="def" href="#glossary-default-action">default actions</a> of that <a class="def"
					href="#glossary-activation-trigger">activation trigger</a>. The value of the <code class="attribute-name"><a href="#widl-Event-target">Event.target</a></code>
					MUST be set to the <a class="def" href="#glossary-event-target">event target</a> (normally, the currently focused element), and the event MUST simulate a <em>left
					click</em> (i.e., the <a href="#widl-MouseEvent-button"><code>MouseEvent.button</code></a> attribute value MUST be <code>0</code>, and the <a href="#widl-MouseEvent-buttons">
					<code>MouseEvent.buttons</code></a> attribute value MUST be <code>1</code>).  Other context information of such a simulated <a class="eventtype" href="#event-type-click">
					<code>click</code></a> event is implementation dependent, but for historical purposes, the interface for the <a class="eventtype" href="#event-type-click"><code>click</code></a>
					event MUST be the <a href="#interface-MouseEvent"><code>MouseEvent interface</code></a>, regardless of the actual device used to activate the element.  Preventing
					the <a class="def" href="#glossary-default-action">default action</a> of the <a class="def" href="#glossary-activation-trigger">activation trigger</a>, such as
					with the <a href="#widl-Event-preventDefault"><code>Event.preventDefault()</code></a>, MUST stop the initiation of the <a class="def" href="#glossary-activation-behavior">
					activation behavior</a>.</p>

				<div class="example">
					<div class="example-title"></div>
					<p>When a user activates a hyperlink using a keyboard, such as by focusing the hyperlink element
					and pressing the <code class="key">'Enter'</code> or <code class="key">'&nbsp;'</code> key, a <a class="eventtype"
					href="#event-type-click"><code>click</code></a> event would be dispatched as the <a class="def" href="#glossary-default-action">default action</a> of the respective
					<a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> event.</p>
				</div>

				<p>Implementations MUST dispatch the synthesized <a class="eventtype" href="#event-type-click"><code>click</code></a> event as described above even if they do not
					normally dispatch such an event (e.g., when activation is requested by a voice command, since this specification does not address <a class="def" href="#glossary-event-type">
					event types</a> for voice input).</p>

				<p class="note"><strong>Note:</strong> The activation of an event target is device dependent, but is also application dependent, e.g., a link in a document can be activated
					using a mouse click or a mouse double click.</p>
			</section>  <!-- click-synthesis -->

			<section id="events-activation-event-order">
				<h3>Activation event order</h3>

				<p>Activation triggers and behavior can be defined in part by the events which are dispatched in a set order relative to one another.  The following is the typical
					sequence of events for an element activated by a pointing device (with only pertinent events listed):</p>

				<table class="event-sequence-table">
					<tr>
						<td class="cell-number"></td>
						<th>Event Name</th>
						<th>Notes</th>
					</tr>
					<tr>
						<td class="cell-number">1.</td>
						<td><a class="eventtype" href="#event-type-click"><code>click</code></a></td>
						<td></td>
					</tr>
					<tr>
						<td class="cell-number"></td>
						<td></td>
						<td>
							<em>All <a class="def" href="#glossary-default-action">default actions</a>,
							including the <a class="def" href="#glossary-activation-behavior">activation behavior</a></em>
						</td>
					</tr>
				</table>

				<p>The following is the typical sequence of events when a focused element is activated by a key event (with only pertinent events listed):</p>

				<table class="event-sequence-table">
					<tr>
						<td class="cell-number"></td>
						<th>Event Name</th>
						<th>Notes</th>
					</tr>
					<tr>
						<td class="cell-number">1.</td>
						<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
						<td>MUST be a key which can activate the element, such as the
							<code class="key">'Enter'</code> or <code class="key">'&nbsp;'</code> key,
							or the element is not activated</td>
					</tr>
					<tr>
						<td class="cell-number">2.</td>
						<td><a class="eventtype" href="#event-type-click"><code>click</code></a></td>
						<td><a class="def" href="#glossary-default-action">default action</a>; synthesized; <code>isTrusted="true"</code></td>
					</tr>
					<tr>
						<td class="cell-number"></td>
						<td></td>
						<td>
							<em>All <a class="def" href="#glossary-default-action">default actions</a>,
							including the <a class="def" href="#glossary-activation-behavior">activation behavior</a></em>
						</td>
					</tr>
				</table>
			</section>  <!-- events-activation-event-order -->
		</section>  <!-- event-flow-activation -->

		<section id="event-exceptions">
			<h2>Event exceptions</h2>

			<p><em>This section is informative.</em></p>

			<p>Event operations can throw a <code>DOMException</code> as specified in their method descriptions.</p>

			<p class="note" id="note-eventexcpetion-removed"><strong>Note:</strong> The exception <em>EventException</em> introduced in <strong class="version">DOM Level 2</strong> is
				removed in this specification as part of this specification's normative support of <a href="#references-WebIDL">Web IDL</a>. <em>EventException</em> formerly defined
				an exception code <code>UNSPECIFIED_EVENT_TYPE_ERR</code> which is replaced in this specification by the use of a <code>DOMException</code> of type
				<code>InvalidStateError</code>.</p>

			<p>The following <code>DOMException</code> types are used in this specification.</p>

			<table class="exceptiontable" summary="Layout table: the first cell contains the name of the DOMException type, the second contains a short description">
				<tr>
					<th>Type</th>
					<th>Description</th>
				</tr>
				<tr>
					<td><code><dfn>InvalidStateError</dfn></code></td>
					<td>Thrown when the <a href="#widl-Event-type"><code>Event.type</code></a> was not specified by initializing the event before <code>dispatchEvent</code> was
						called. Also thrown when the <a href="#interface-Event"><code>Event</code></a> object provided to <code>dispatchEvent</code> is already being dispatched.</td>
				</tr>
				<tr>
					<td><code><dfn>NotSupportedError</dfn></code></td>
					<td>Thrown when <a href="#widl-DocumentEvent-createEvent"><code>DocumentEvent.createEvent()</code></a> is passed an <a href="#interface-Event"><code>Event</code></a>
						interface that the implementation does not support.</td>
				</tr>
			</table>
		</section>  <!-- event-exceptions -->
	</section>  <!-- dom-event-architecture -->

	<!-- Section 4: Basic Event Interfaces ========================================================-->
	<section id="event-interfaces">
		<h1>Basic Event Interfaces</h1>

		<p>The interfaces described in this section are fundamental to DOM Level 3 Events and MUST
			always be supported by the implementation.
			</p>

		<p>The event types defined in this specification derive from these basic interfaces, and MUST
			inherit all of the attributes, methods, and constants of the interfaces they derive from.
			Event types defined in other specifications MAY similarly inherit from these basic interfaces
			or other interfaces defined in this specification, or MAY define their own interfaces.
			The following chart describes the inheritance structure of interfaces defined in this specification.
			</p>

		<figure id="figure-event-inheritance">
			<img src='images/event-inheritance.svg' width="960" height="230" />
			<figcaption>Graphical representation of the DOM3 Events interface inheritance</figcaption>
		</figure>

		<section id="interface-Event">
			<h2>Interface Event</h2>

			<p class="intro-dom">Introduced in DOM Level 2</p>

			<p>The <code>Event</code> interface provides basic contextual information about an event to
				all registered <a class="def" href="#glossary-event-handler">event handlers</a>.
				Specific events can also implement other derived interfaces, for example the
					<a href="#interface-UIEvent"><code>UIEvent</code></a>
				and
					<a href="#interface-MouseEvent"><code>MouseEvent</code></a>
				interfaces.
				</p>

			<p>To create an instance of the <code>Event</code> interface, use the
				<a href="#widl-DocumentEvent-createEvent"><code>DocumentEvent.createEvent("Event")</code></a>
				method call.
				</p>

			<dl class="idl" title="dictionary EventInit">
				<dt>boolean bubbles = false</dt><dd></dd>
				<dt>boolean cancelable = false</dt><dd></dd>
			</dl>

			<dl class="idl" title="[Constructor(DOMString typeArg, optional EventInit eventInitDict), Exposed=Window,Worker] interface Event">
				<dt>// PhaseType</dt>

				<dt>const unsigned short NONE = 0</dt>
				<dd>
					<p>The current event is not being dispatched, i.e., the <a href="#widl-Event-eventPhase"><code>Event.eventPhase</code></a> is being observed prior to
						calling <a href="#widl-EventTarget-dispatchEvent">EventTarget.dispatchEvent()</a> or following the completion of the
						<a class="def" href="#glossary-phase">event phases</a> of a given <code>Event</code>.</p>
				</dd>

				<dt>const unsigned short CAPTURING_PHASE = 1</dt>
				<dd>
					<p>The current event phase is the <a class="def" href="#glossary-capture-phase">capture phase</a>.</p>
				</dd>

				<dt>const unsigned short AT_TARGET = 2</dt>
				<dd>
					<p>The current event is in the <a class="def" href="#glossary-target-phase">target phase</a>, i.e., it is being evaluated at the <a class="def"
						href="#glossary-event-target">event target</a>.</p>
				</dd>

				<dt>const unsigned short BUBBLING_PHASE = 3</dt>
				<dd>
					<p>The current event phase is the <a class="def" href="#glossary-bubbling-phase">bubbling phase</a>.</p>
				</dd>

				<dt>readonly attribute DOMString type</dt>
				<dd>
					<p>The name of the event type. <a href="#conf-specs">Specifications that define events</a>, <a href="#conf-authors">content authors</a>, and <a href="#conf-author-tools">
						authoring tools</a> MUST use case-sensitive event type names.</p>

					<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>""</code> (the empty string).</p>
				</dd>

				<dt>readonly attribute EventTarget? target</dt>
				<dd>
					<p>Used to retrieve the <a class="def" href="#glossary-event-target">event target</a> associated with the <a href="#event-flow">Event dispatch and DOM
						event flow</a>.</p>

					<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>null</code>.</p>
				</dd>

				<dt>readonly attribute EventTarget? currentTarget</dt>
				<dd>
					<p>Used to retrieve the <a class="def" href="#glossary-current-event-target">current event target</a> whose <a href="#interface-EventListener"><code>EventListeners</code></a>
						are currently being processed. This is particularly useful during the capture and bubbling phases.</p>

					<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>null</code>.</p>
				</dd>

				<dt>readonly attribute unsigned short eventPhase</dt>
				<dd>
					<p>Used to indicate the <a href="#event-phase">phase</a> of the event's current propagation path (capture, target, or bubble).
						The event flow phases are defined in <a href="#event-flow">Event dispatch and DOM event flow</a>.</p>

					<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>0</code> (<code>NONE</code>).</p>
				</dd>

				<dt>readonly attribute boolean bubbles</dt>
				<dd>
					<p>Used to indicate whether or not an event is a bubbling event. If the event can bubble the value MUST be <code>true</code>, otherwise the value MUST be
						<code>false</code>.</p>

					<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>false</code>.</p>
				</dd>

				<dt>readonly attribute boolean cancelable</dt>
				<dd>
					<p>Used to indicate whether or not an event can have its
							<a class="def" href="#glossary-default-action">default action</a>
						prevented.
						If the
							<a class="def" href="#glossary-default-action">default action</a>
						can be prevented the value MUST be <code>true</code>, otherwise the value
						MUST be <code>false</code>.
						See <a href="#event-flow-default-cancel">Default actions and cancelable events</a>
						for more information on cancelable events.
						</p>

					<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a>
						of this attribute MUST be <code>false</code>.
						</p>

					<p class="note"><strong>Note:</strong>
						Use <code>Event.defaultPrevented</code> to see whether a cancelable event has
						been cancelled or not.
						</p>
				</dd>

				<dt>readonly attribute DOMTimeStamp timeStamp</dt>
				<dd>
					<p>Used to specify the time at which the event was created in milliseconds relative to 1970-01-01T00:00:00Z. This value is the <a class="def" href="#glossary-un-initialized-value">
						un-initialized value</a> of this attribute.</p>
				</dd>

				<dt>void stopPropagation()</dt>
				<dd>
					<p>Prevents all other
							<a class="def" href="#glossary-event-handler">event listeners</a>
						from being triggered for this event dispatch, <strong>excluding</strong> any remaining
							<a class="def" href="#glossary-candidate-event-handlers">candidate event listeners</a>.
						Once it has been called, further calls to this method have no additional effect.
						</p>

					<p class="note" id="note-stopPropagation-default"><strong>Note:</strong>
						This method does not prevent the
							<a class="def" href="#glossary-default-action">default action</a>
						from being invoked &mdash; use
							<a href="#widl-Event-preventDefault"><code>Event.preventDefault()</code></a>
						for that effect.
						</p>
				</dd>

				<dt>void preventDefault()</dt>
				<dd>
					<p>When this method is invoked, the event MUST be canceled, meaning any
							<a class="def" href="#glossary-default-action">default actions</a>
						normally taken by the implementation as a result of the event MUST NOT occur.
						Default actions which occur prior to the event's dispatch are reverted.
						Calling this method for a non-cancelable event MUST have no effect.
						If an event has more than one
							<a class="def" href="#glossary-default-action">default action</a>,
						each cancelable
							<a class="def" href="#glossary-default-action">default action</a>
						MUST be canceled.
						See <a href="#event-flow-default-cancel">Default actions and cancelable events</a>
						for more information on cancelable events.
						</p>

					<p class="note"><strong>Note:</strong>
						This method does not stop the event propagation &mdash; use
							<a href="#widl-Event-stopPropagation"><code>Event.stopPropagation()</code></a>
						or
							<a href="#widl-Event-stopImmediatePropagation"><code>Event.stopImmediatePropagation()</code></a>
						for that effect.
						</p>
				</dd>

				<dt>void initEvent()</dt>
				<dd>
					<p>Initializes attributes of an <code>Event</code>.
						The <code>Event</code> could have been created through the
							<a href="#widl-DocumentEvent-createEvent"><code>DocumentEvent.createEvent</code></a>
						method or by the implementation in response to a user action.
						For any <code>Event</code> created with the
							<a href="#widl-DocumentEvent-createEvent"><code>DocumentEvent.createEvent</code></a>
						method, this method MUST be called before the <code>Event</code> is dispatched via the
							<a href="#widl-EventTarget-dispatchEvent"><code>EventTarget.dispatchEvent()</code></a>
						method.
						If the method is called several times before invoking
							<a href="#widl-EventTarget-dispatchEvent"><code>EventTarget.dispatchEvent</code></a>,
						only the final invocation takes precedence.
						If this method is called during an invocation of
							<a href="#widl-EventTarget-dispatchEvent"><code>EventTarget.dispatchEvent</code></a>,
						this method MUST do nothing and return immediately.
						If called from a subclass of the <code>Event</code> interface only the values specified in
						this method are modified, all other attributes are left unchanged.
						</p>

					<p>This method MUST also reset the event object's internal-propagation and default-action-prevention states.
						This allows an event object to be "reset" before being dispatched multiple times.
						</p>

					<div class="example">
						<div class="example-title"></div>
						<p>If an <code>EventListener</code> called <code>stopPropagation()</code> or
							<code>stopImmediatePropagation()</code> during the event's previous dispatch, then after
							calling this method, the event can be re-dispatched (via <code>dispatchEvent</code>) and
							will propagate through all candidate event listeners along its propagation path (as it did
							during the prior dispatch).
							Similarly, if an <code>EventListener</code> called <code>preventDefault()</code>
							during the event's previous dispatch, then after calling this method, the event's
							<code>defaultPrevented</code> property will be <code>false</code>.
							</p>
					</div>

					<p class="warning" id="warning-initEvent-untrusted"><strong>Warning!</strong>
						For security reasons, events modified using
							<a href="#widl-Event-initEvent"><code>Event.initEvent()</code></a>
						MUST have an
							<code class="attribute-name"><a href="#widl-Event-isTrusted">isTrusted</a></code>
						attribute value of <code>false</code>.
						See <a href="#trusted-events">trusted events</a> for more details.
						</p>

					<p class="note"><strong>Authoring Note:</strong>
						<a class="def" href="#trusted-events">Trusted events</a> can have their
						<a class="def" href="#glossary-event-type">event type</a> and other attributes changed using this method.
						However, this method always converts the <code>Event</code> from a trusted event to an untrusted
						event (e.g., the <a href="#widl-Event-isTrusted"><code>Event.isTrusted</code></a> attribute will return
						<code>false</code>).
						</p>

					<p class="note"><strong>Authoring Note:</strong>
						<a class="def" href="#trusted-events">Trusted events</a> are pre-initialized by the implementation
						before being dispatched.
						As a result, it is not necessary to call <code>Event.initEvent()</code> prior to re-dispatching
						the trusted event &mdash; however calling
						<a href="#widl-EventTarget-dispatchEvent"><code>EventTarget.dispatchEvent()</code></a> will convert
						the <code>Event</code> from a trusted event to an untrusted event (e.g., the
						<a href="#widl-Event-isTrusted"><code>Event.isTrusted</code></a> attribute will return <code>false</code>).
						</p>

					<dl class="parameters">
						<dt>DOMString eventTypeArg</dt>
						<dd>
							<p>Specifies <a href="#widl-Event-type"><code>Event.type</code></a>, the name of the event type.
								</p>
						</dd>
						
						<dt>boolean bubblesArg</dt>
						<dd>
							<p>Specifies <a href="#widl-Event-bubbles"><code>Event.bubbles</code></a>.
								This parameter overrides the intrinsic bubbling behavior of the event.
								</p>
						</dd>

						<dt>boolean cancelableArg</dt>
						<dd>
							<p>Specifies <a href="#widl-Event-cancelable"><code>Event.cancelable</code></a>.
								This parameter overrides the intrinsic cancelable behavior of the event.
								</p>
						</dd>
					</dl>
				</dd>

				<dt>// Introduced in DOM Level 3</dt>

				<dt>void stopImmediatePropagation()</dt>
				<dd>
					<p class="intro-dom">Introduced in DOM Level 3</p>

					<p>Prevents all other <a class="def" href="#glossary-event-handler">event listeners</a> from being triggered for this event dispatch, <strong>including</strong> any remaining
						<a class="def" href="#glossary-candidate-event-handlers">candidate event listeners</a>. Once it has been called, further calls to this method have no additional
						effect.</p>

					<p class="note"><strong>Note:</strong> This method does not prevent the <a class="def" href="#glossary-default-action">default action</a> from being invoked &mdash;
						use <a href="#widl-Event-preventDefault"><code>Event.preventDefault()</code></a> for that effect.</p>
				</dd>

				<dt>readonly attribute boolean defaultPrevented</dt>
				<dd>
					<p class="intro-dom">Introduced in DOM Level 3</p>
					
					<p>Used to indicate whether this event has been cancelled or not. <code>Event.defaultPrevented</code> MUST return true if both <a href="#widl-Event-cancelable">
						<code>Event.cancelable</code></a> is <code>true</code> and <a href="#widl-Event-preventDefault"><code>Event.preventDefault()</code></a> has been called for
						this event. Otherwise this attribute MUST return <code>false</code>.</p>

					<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>false</code>.</p>

					<p class="note"><strong>Note:</strong> Calling <a href="#widl-Event-initEvent"><code>Event.initEvent()</code></a> after an event has been dispatched will reset
						the internal default-prevented state of the event.</p>
				</dd>

				<dt>[Unforgeable] readonly attribute boolean isTrusted</dt>
				<dd>
					<p class="intro-dom">Introduced in DOM Level 3</p>

					<p>Used to indicate whether this event was generated by the <a class="def" href="#glossary-user-agent">user agent</a> (trusted) or by script (untrusted).  See <a
						href="#trusted-events">trusted events</a> for more details.</p>

					<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>false</code>.</p>
				</dd>
			</dl>
		</section><!-- interface-Event -->

		<section id="interface-CustomEvent">
			<h2>Interface CustomEvent</h2>

			<p class="intro-dom">Introduced in DOM Level 3</p>

			<p>The <a href="#interface-CustomEvent"><code>CustomEvent</code></a> interface is the RECOMMENDED
				interface for application-specific event types.
				Unlike the <a href="#interface-Event"><code>Event</code></a> interface, it allows applications
				to provide contextual information about the event type.
				</p>

			<p class="note"><strong>Authoring Note:</strong>
				Use a prefix string on the event type name for application-specific event types to avoid
				clashes with future general-purpose event types.
				</p>

			<p>To create an instance of the <code>CustomEvent</code> interface, use the
				<a href="#widl-DocumentEvent-createEvent"><code>DocumentEvent.createEvent("CustomEvent")</code></a>
				method call.
				</p>

			<dl class="idl" title="dictionary CustomEventInit : EventInit">
				<dt>any detail = null</dt><dd></dd>
			</dl>

			<dl class="idl" title="[Constructor(DOMString typeArg, optional CustomEventInit customEventInitDict), Exposed=Window,Worker] interface CustomEvent : Event">
				<dt>readonly attribute any detail</dt>
				<dd>
					<p>Specifies some detail information about the <a href="#interface-Event"><code>Event</code></a>.
						</p>

					<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a>
						of this attribute MUST be <code>null</code>.
						</p>
				</dd>
			</dl>
		</section><!-- interface-CustomEvent -->

		<section id="interface-EventTarget">
			<h2>Interface EventTarget</h2>

			<p class="intro-dom">Introduced in DOM Level 2</p>

			<p>The <code>EventTarget</code> interface allows registration and removal of event listeners, and dispatch of events to an event target.</p>

			<p class="note"><strong>Note:</strong> Though an event listener can be registered for any <a class="def" href="#glossary-event-target">event
				target</a> node, the user agent only dispatches UA-generated (trusted) events on node types that are defined as event target types for that specific event type
				(see the <a href="#event-types-list">List of DOM3 Event Types</a>). For example, a <a class="eventtype" href="#event-type-mouseover"><code>mouseover</code></a>
				event type registered on a text node will never be fired by the user agent, though a content author could dispatch an event of that type on the text node via script.</p>

			<p>When used with the DOM event flow, this interface MUST be implemented by all <a class="def" href="#glossary-event-target">event targets</a> and target ancestors,
				i.e., all DOM <code>Nodes</code> of the tree support this interface when the implementation conforms to DOM Level 3 Events and, therefore, this interface can be
				obtained by using binding-specific casting methods on an instance of the <code>Node</code> interface.</p>

			<p>Invoking <code>addEventListener</code> (or <code>removeEventListener</code>) repeatedly on the same <code>EventTarget</code> with the same values for the parameters
				<code>type</code>, <code>listener</code>, and <code>useCapture</code> has no effect. Doing so does not cause the event listener to be registered more than once and
				does not cause a change in the triggering order.</p>

			<p class="note"><strong>Note:</strong>  In addition to the <a href="#widl-EventTarget-addEventListener"><code>EventTarget.addEventListener</code></a> method, some
				<a class="def" href="#glossary-host-language">host languages</a> allow a content author to register event listeners by the use of attributes, e.g.,
				<code>onclick="handleClick()"</code> (see [<cite><a class="informative" href="#references-HTML5">HTML5</a></cite>] for further examples). Due to the
				language-specific details, this type of event listener registration is not defined in this specification. In general, many event types can be used as an attribute
				in this way by adding the prefix <em><code>on-</code></em> to the event type name. Dispatching events to these listeners is expected to behave consistently with the
				event registration and propagation defined in this specification, with the same interfaces, properties, and methods.</p>

			<dl class="idl" title="[Exposed=Window,Worker] interface EventTarget">
				<dt>// Modified in DOM Level 3</dt>

				<dt>void addEventListener()</dt>
				<dd>
					<p><em>Modified in DOM Level 3</em></p>

					<p>Registers an event listener on the <a href="#interface-EventTarget"><code>EventTarget</code></a>. The listener is registered for the capture phase if the
						<code>useCapture</code> parameter is <code>true</code>, and for the bubble phase otherwise. When the event reaches the target element, listeners for both
						the capture and bubble phases are triggered as part of the target phase.
					</p>
					
					<dl class="parameters">
						<dt>DOMString type</dt>
						<dd>
							<p>Specifies the <a href="#widl-Event-type"><code>Event.type</code></a> associated with the event for which the user is registering.</p>
						</dd>
						
						<dt>EventListener? listener</dt>
						<dd>
							<p>If non-null, the <code>listener</code> parameter MUST be an object that implements the
								<a href="#interface-EventListener"><code>EventListener</code></a> interface or a function.
								If <code>listener</code> is a function then it MUST be used as the callback for the event.
								Otherwise, if <code>listener</code> implements
								<a href="#interface-EventListener"><code>EventListener</code></a>, then its
								<a href="#widl-EventListener-handleEvent"><code>handleEvent</code></a> method MUST be used as the callback.
								</p>
							<p>If null is passed for the <code>listener</code>, then <code>addEventListener</code> does nothing.
								</p>
						</dd>

						<dt>optional boolean useCapture = false</dt>
						<dd>
							<p>If true, <code>useCapture</code> indicates that the user wishes to add the event listener for the <a class="def" href="#glossary-capture-phase">capture</a>
								and <a class="def" href="#glossary-target-phase">target</a> phases only, i.e., this event listener will not be triggered during the <a class="def"
								href="#glossary-bubbling-phase"> bubbling</a> phase. If <code>false</code>, the event listener MUST only be triggered during the <a class="def"
								href="#glossary-target-phase">target</a> and <a class="def" href="#glossary-bubbling-phase">bubbling</a> phases.</p>

							<p>This parameter MUST be optional. If not provided, the <a href="#widl-EventTarget-addEventListener"><code>EventTarget.addEventListener</code></a> method MUST behave as if
								<code class="parameter-name">useCapture</code> was specified to be <code>false</code>.</p>

							<p class="note"><strong>Authoring Note:</strong>  The <code class="parameter-name">useCapture</code> parameter was mandatory in
								DOM2 Events [<a href="#references-DOM2Events">DOM2 Events</a>], and omitting this parameter could cause an error in older implementations.</p>
						</dd>
					</dl>
				</dd>

				<dt>void removeEventListener()</dt>
				<dd>
					<p><em>Modified in DOM Level 3</em></p>

					<p>Removes an event listener. Calling <code>removeEventListener</code> with arguments that do not identify any currently registered <a href="#interface-EventListener"><code>
						EventListener</code></a> on the <code>EventTarget</code> has no effect. </p>

					<dl class="parameters">
						<dt>DOMString type</dt>
						<dd>
							<p>Specifies the <a href="#widl-Event-type"><code>Event.type</code></a> for which the user registered the event listener.</p>
						</dd>
						
						<dt>EventListener? listener</dt>
						<dd>
							<p>The <a href="#interface-EventListener"><code>EventListener</code></a> to be removed.</p>
						</dd>

						<dt>optional boolean useCapture = false</dt>
						<dd>
							<p>Specifies whether the <a href="#interface-EventListener"><code>EventListener</code></a> being removed was registered for the capture phase or not. Implementations
								MUST treat the same listener that was registered twice with both <code>useCapture</code> true and <code>useCapture</code> false as independent registrations, and
								remove them independently.</p>

							<p class="note"><strong>Authoring Note:</strong>  If a listener was registered twice, once for the capture and target phases and once for the target and bubbling phases,
								this represents two unique registrations. Removal of an event listener registered for the capture and target phases does not affect the same event listener registered
								for the target and bubbling phases, and vice versa.</p>

							<p>This parameter MUST be optional. If not provided, the <a href="#widl-EventTarget-removeEventListener"><code>EventTarget.removeEventListener</code></a> method MUST behave as if
								<code class="parameter-name">useCapture</code> were specified to be <code>false</code>.</p>

							<p class="note"><strong>Authoring Note:</strong>  The <code class="parameter-name">useCapture</code> parameter was mandatory in
								DOM2 Events [<a href="#references-DOM2Events">DOM2 Events</a>], and omitting this parameter could cause an error in older implementations.</p>
						</dd>
					</dl>
				</dd>

				<dt>boolean dispatchEvent()</dt>
				<dd>
					<p><em>Modified in DOM Level 3</em></p>

					<p>Dispatches an event into the implementation's event model. The <a class="def" href="#glossary-event-target">event target</a> of the event MUST be the <code>EventTarget</code>
						object on which <code>dispatchEvent</code> is called.</p>

					<p>If after the event object finishes propagating through the DOM event flow its <a href="#widl-Event-defaultPrevented"><code>Event.defaultPrevented</code></a>
						attribute is <code>false</code>, then this method returns <code>true</code>. Otherwise this method returns <code>false</code>.</p>

					<p class="warning"><strong>Warning!</strong>  For security reasons, events dispatched using <a href="#widl-EventTarget-dispatchEvent">
						<code>EventTarget.dispatchEvent()</code></a> MUST have a <code class="attribute-name"><a href="#widl-Event-isTrusted">isTrusted</a></code> attribute value
						of <code>false</code>.  See <a href="#trusted-events">trusted events</a> for more details.</p>

					<p class="note"><strong>Note:</strong> While a dispatch (triggered by <a href="#widl-EventTarget-dispatchEvent"><code>EventTarget.dispatchEvent()</code></a>) is in progress, calls to
						<a href="#widl-Event-initEvent"><code>Event.initEvent()</code></a> are ignored (the method returns immediately without side-effects) and calls to
						<a href="#widl-EventTarget-dispatchEvent"><code>EventTarget.dispatchEvent()</code></a> result in an exception.</p>

					<dl class="parameters">
						<dt>Event event</dt>
						<dd>
							<p>The event to be dispatched.</p>
							<p class="note"><strong>Note: </strong>This parameter receives an <code>Event</code> object, or any object that inherits from <code>Event</code>, e.g.,
								<a href="#interface-MouseEvent"><code>MouseEvent</code></a>,
								<a href="#interface-KeyboardEvent"><code>KeyboardEvent</code></a>,
								<code>MutationEvent</code>, etc.</p>
						</dd>
					</dl>

					<p><strong>Exceptions:</strong>
						If the <a href="#widl-Event-type"><code>Event.type</code></a> was not specified by initializing the event before <code>dispatchEvent</code> was called OR
						the <a href="#interface-Event"><code>Event</code></a> object is already being dispatched, a <code>DOMException</code> of type <em><code>InvalidStateError</code></em>
						is thrown.</p>
				</dd>
			</dl>
		</section><!-- interface-EventTarget -->

		<section id="interface-EventListener">
			<h2>Interface EventListener</h2>

			<p class="intro-dom">Introduced in DOM Level 2</p>

			<p>The <code>EventListener</code> interface is the primary way to handle events. <code>EventListener</code> represents the callback object that the user agent will
				invoke when dispatching an <code>Event</code> to an <a href="#interface-EventTarget"><code>EventTarget</code></a>.</p>

			<p class="note"><strong>Note:</strong> Authors define an object which implements the <code>EventListener</code> interface and register their event listener using 
				<a href="#widl-EventTarget-addEventListener"><code>EventTarget.addEventListener</code></a>. In JavaScript, an <code>EventListener</code> can be either a function or an object
				with a <code>handleEvent</code> member function.</p>

			<p class="note"><strong>Note:</strong> It is a best practice for authors to remove their <code>EventListener</code> from its <a href="#interface-EventTarget"><code>EventTarget</code></a>
				after they have completed using the listener.</p>

			<p>Copying a <code>Node</code>, with methods such as <code>Node.cloneNode</code> or <code>Range.cloneContents</code> [<cite><a class="informative"
				href="#references-DOMRange">DOM Range</a></cite>], MUST NOT copy the event listeners attached to it.
				Event listeners can be attached to the newly created <code>Node</code> afterwards, if so desired.</p>

			<p>Moving a <code>Node</code>, with methods such as <code>Document.adoptNode</code>, <code>Node.appendChild</code>, or <code>Range.extractContents</code>
				[<cite><a class="informative" href="#references-DOMRange">DOM Range</a></cite>], MUST NOT cause the event listeners attached to it to be removed or un-registered.</p>

			<dl class="idl" title="interface EventListener">
				<dt>void handleEvent()</dt>
				<dd>
					<p>This method MUST be called whenever an event occurs of the event type for which the <code>EventListener</code> interface was registered.</p>

					<dl class="parameters">
						<dt>Event event</dt>
						<dd>
							<p>The <a href="#interface-Event"><code>Event</code></a> contains contextual information about the <a class="def" href="#glossary-event">event</a>.</p>
						</dd>
					</dl>
				</dd>
			</dl>
		</section><!-- interface-EventListener -->

		<section id="interface-DocumentEvent">
			<h2>Interface DocumentEvent</h2>

			<p class="intro-dom">Introduced in DOM Level 2</p>

			<p>The <code>DocumentEvent</code> interface provides a mechanism by which the user can create an <a href="#interface-Event"><code>Event</code></a> object of a type supported
				by the implementation. The <code>DocumentEvent</code> interface MUST be implemented on the same object that implements the <code>Document</code> interface.</p>

			<dl class="idl" title="Document implements DocumentEvent">
			</dl>

			<!-- NOTE: This is preserved as a [NoInterfaceObject] definition (rather than a partial interface Document { ..} because SVG also needs to implement this interface on their SVGSVGElement interface -->
			<dl class="idl" title="[NoInterfaceObject] interface DocumentEvent">
				<dt>[NewObject] Event createEvent()</dt>
				<dd>
					<p class="intro-dom">Modified in DOM Level 3</p>

					<p>Creates an event object of the type specified. Returns the newly created object.</p>

<p class="issue">
The text of this note needs to be reviewed. Remove reference to initMouseEvent (here and throughout main text).
</p>
					<p class="note"><strong>Note: </strong>After calling <code>createEvent</code>, and prior to dispatching the event with the
						<a href="#widl-EventTarget-dispatchEvent"><code>EventTarget.dispatchEvent()</code></a> method, the
						<a href="#interface-Event"><code>Event</code></a> will need to be initialized with the appropriate event initialization
						method (e.g., <code>initEvent</code>, <code>initMouseEvent</code>, etc.) in order to associate it with an event type and related values.</p>

					<div class="example">
						<div class="example-title"></div>
						<p>A content author wishing to synthesize some kind of <a href="#interface-UIEvent"><code>UIEvent</code></a>
						would invoke <a href="#widl-DocumentEvent-createEvent"><code>DocumentEvent.createEvent("UIEvent")</code></a>. The <a href="#widl-UIEvent-initUIEvent"><code>
						UIEvent.initUIEvent()</code></a> method could then be called on the newly created <a class="noxref" href="#interface-UIEvent"><code>UIEvent</code></a> object to
						set the specific type of user interface event to be dispatched, <a class="eventtype" href="#event-type-scroll"><code>scroll</code></a> for example, and set its
						context information, e.g., <a href="#widl-UIEvent-detail"><code>UIEvent.detail</code></a>.</p>
					</div>

					<p class="warning"><strong>Warning!</strong>  For security reasons, events generated using <a href="#widl-DocumentEvent-createEvent">
						<code>DocumentEvent.createEvent("Event")</code></a> MUST have a <code class="attribute-name"><a href="#widl-Event-isTrusted">isTrusted</a></code> attribute
						value of <code>false</code>.  See <a href="#trusted-events">trusted events</a> for more details.</p>

					<p><strong>Exceptions:</strong>
						If the implementation does not support the <a href="#interface-Event"><code>Event</code></a> interface requested, a <code>DOMException</code> of type <em><code>NotSupportedError</code></em>
						is thrown.</p>

					<dl class="parameters">
						<dt>DOMString eventInterface</dt>
						<dd>
							<p>The <code>eventInterface</code> parameter specifies the name of the DOM Events interface to be supported by the created event
								object, e.g., <code>"Event"</code>, <code>"MouseEvent"</code>, <code>"MutationEvent"</code>, and so on.</p>

							<p>For backward compatibility, the following case-insensitive feature names are valid values for the parameter <code>eventInterface</code>:</p>

							<table class="data-table" summary="The first column contains the feature name, the second contains the resulting event interface returned by createEvent">
								<tr>
									<th>Legacy feature name</th>
									<th>Resulting event interface</th>
								</tr>
								<tr>
									<td><code>"Events"</code></td>
									<td><a href="#interface-Event"><code>Event</code></a></td>
								</tr>
								<tr>
									<td><code>"HTMLEvents"</code></td>
									<td><a href="#interface-Event"><code>Event</code></a></td>
								</tr>
								<tr>
									<td><code>"UIEvents"</code></td>
									<td><a href="#interface-UIEvent"><code>UIEvent</code></a></td>
								</tr>
								<tr>
									<td><code>"MouseEvents"</code></td>
									<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
								</tr>
								<tr>
									<td><code>"MutationEvents"</code></td>
									<td><a href="#interface-MutationEvent"><code>MutationEvent</code></a></td>
								</tr>
							</table>

						</dd>
					</dl>
				</dd>
			</dl>
		</section><!-- interface-DocumentEvent -->

	</section>  <!-- event-interfaces  -->

	<!-- Section 5: The Events ========================================================-->
	<section id="events-module">
		<h1>Events Module</h1>

		<section id="event-types">
			<h2>Event Types</h2>
			<p>Each event MUST be associated with a type, called <em>event type</em> and available as the <a href="#widl-Event-type"><code class="interface-attribute">type</code></a>
				attribute on the event object. The event type MUST be of type <code>DOMString</code>.</p>

			<section id="event-types-list">
				<h3>List of DOM3 Event Types</h3>
				<p>Depending on the level of DOM support, or the devices used for display (e.g., screen) or interaction (e.g., mouse, keyboard, touch screen, or voice), these event
					types can be generated by the implementation. When used with an [<cite><a class="informative" href="#references-XML">XML 1.0</a></cite>] or
					[<cite><a class="informative" href="#references-HTML5">HTML5</a></cite>] application, the specifications of those languages MAY restrict the
					semantics and scope (in particular the possible <a class="def" href="#glossary-event-target">event targets</a>) associated
					with an event type. Refer to the specification defining the language used in order to find those restrictions or to find event types that are
					not defined in this document.</p>

				<p>The following table provides an informative summary of the event types defined in this specification.</p>

				<table class="data-table"
					summary="This table contains the complete list of event types defined by DOM Level 3 Events. The first column contains the local name of the event type. The second column indicates if the event accomplish the bubbling phase or not (all events accomplish the capture and target phases). The third column indicates if the default action associated with the event can be canceled. The fourth column indicates the nodes that can be target of the event. the fifth (and last) column indicates the DOM interface implemented by the event object.">
					<tr>
						<th>Event Type</th>
						<th>Sync / Async</th>
						<th>Bubbling phase</th>
						<th>Trusted event target types</th>
						<th>DOM interface</th>
						<th>Cancelable</th>
						<th>Default Action</th>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-abort"><code>abort</code></a></td>
						<td>Sync</td>
						<td>No</td>
						<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
						<td><a href="#interface-Event"><code>Event</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-InputEvent"><code>InputEvent</code></a></td>
						<td>Yes</td>
						<td>Update the DOM element</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-blur"><code>blur</code></a></td>
						<td>Sync</td>
						<td>No</td>
						<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
						<td><a href="#interface-FocusEvent"><code>FocusEvent</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-click"><code>click</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
						<td>Yes</td>
						<td>Varies:
							for <a class="def" href="#glossary-event-target">targets</a> with an associated activation 
							behavior, executes the <a class="def" href="#glossary-activation-behavior">activation behavior</a>;
							for focusable <a class="def" href="#glossary-event-target">targets</a>, gives the element focus.
						</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-CompositionEvent"><code>CompositionEvent</code></a></td>
						<td>Yes</td>
						<td>Show a <a class="def" href="#glossary-text-composition-system">text composition system</a> candidate window</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-CompositionEvent"><code>CompositionEvent</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-CompositionEvent"><code>CompositionEvent</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-dblclick"><code>dblclick</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
						<td>No</td>
						<td>Varies:
							for <a class="def" href="#glossary-event-target">targets</a> with an associated activation 
							behavior, executes the <a class="def" href="#glossary-activation-behavior">activation behavior</a>;
							for focusable <a class="def" href="#glossary-event-target">targets</a>, gives the element focus;
							for selectable <a class="def" href="#glossary-event-target">targets</a>, selects part or all of the 
							element's content.
						</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-error"><code>error</code></a></td>
						<td>Async</td>
						<td>No</td>
						<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
						<td><a href="#interface-Event"><code>Event</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-focus"><code>focus</code></a></td>
						<td>Sync</td>
						<td>No</td>
						<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
						<td><a href="#interface-FocusEvent"><code>FocusEvent</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-focusin"><code>focusin</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
						<td><a href="#interface-FocusEvent"><code>FocusEvent</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-focusout"><code>focusout</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
						<td><a href="#interface-FocusEvent"><code>FocusEvent</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-input"><code>input</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-InputEvent"><code>InputEvent</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-KeyboardEvent"><code>KeyboardEvent</code></a></td>
						<td>Yes</td>
						<td>Varies:
							<a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a> and <a class="eventtype" href="#event-type-input"><code>input</code></a> events;
							launch <a class="def" href="#glossary-text-composition-system">text composition system</a>;
							<a class="eventtype" href="#event-type-blur"><code>blur</code></a> and <a class="eventtype" href="#event-type-focus"><code>focus</code></a> events;
							<a class="eventtype" href="#event-type-keypress"><code>keypress</code></a> event;
							<a class="def" href="#glossary-activation-behavior">activation behavior</a>;
							other event</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-KeyboardEvent"><code>KeyboardEvent</code></a></td>
						<td>Yes</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-load"><code>load</code></a></td>
						<td>Async</td>
						<td>No</td>
						<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Document</code>, <code>Element</code></td>
						<td><a href="#interface-Event"><code>Event</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-mousedown"><code>mousedown</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
						<td>Yes</td>
						<td>Varies: start a drag/drop operation; start a text selection; start a scroll/pan interaction (in combination with the middle mouse button, if supported)</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-mouseenter"><code>mouseenter</code></a></td>
						<td>Sync</td>
						<td>No</td>
						<td><code>Element</code></td>
						<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-mouseleave"><code>mouseleave</code></a></td>
						<td>Sync</td>
						<td>No</td>
						<td><code>Element</code></td>
						<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
						<td><a href="#mousemove-now-cancelable">Yes</a></td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-mouseout"><code>mouseout</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
						<td>Yes</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-mouseover"><code>mouseover</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
						<td>Yes</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
						<td>Yes</td>
						<td>Invoke a context menu (in combination with the right mouse button, if supported)</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-resize"><code>resize</code></a></td>
						<td>Sync</td>
						<td>No</td>
						<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
						<td><a href="#interface-UIEvent"><code>UIEvent</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-scroll"><code>scroll</code></a></td>
						<td>Async</td>
						<td>No / <a href="#scroll-document">Yes</a></td>
						<td><code>Document</code>, <code>Element</code></td>
						<td><a href="#interface-UIEvent"><code>UIEvent</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-select"><code>select</code></a></td>
						<td>Sync</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-Event"><code>Event</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-unload"><code>unload</code></a></td>
						<td>Sync</td>
						<td>No</td>
						<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Document</code>, <code>Element</code></td>
						<td><a href="#interface-Event"><code>Event</code></a></td>
						<td>No</td>
						<td>None</td>
					</tr>
					<tr>
						<td><a class="eventtype" href="#event-type-wheel"><code>wheel</code></a></td>
						<td>Async</td>
						<td>Yes</td>
						<td><code>Element</code></td>
						<td><a href="#interface-WheelEvent"><code>WheelEvent</code></a></td>
						<td>Yes</td>
						<td>Scroll (or zoom) the document</td>
					</tr>
				</table>

				<p>For a list of events which are deprecated in this specification, see the <a href="#legacy-event-types">Legacy Event Types</a> appendix
					at the end of this document.</p>
				
				<div class="example">
					<div class="example-title"></div>
					<p>The following is one way to interpret the above tables: the <a class="eventtype" href="#event-type-load"><code>load</code></a> event will
					trigger event listeners attached on <code>Element</code> nodes for that event and on the capture and target phases. This event is not cancelable. If an event listener for the
					<a class="eventtype" href="#event-type-load"><code>load</code></a> event is attached to a node other than <a class="def" href="#glossary-window"><code>Window</code></a>,
					<code>Document</code>, or <code>Element</code> nodes, or if it is attached to the bubbling phase only, this event listener would not be triggered.</p>
				</div>

				<p class="note"><strong>Note: </strong>Don't interpret the above tables as definitive for the listed event types. For example, the <a class="eventtype"><code>load</code></a> event is used in other
					specifications, for example, in XMLHttpRequest. Similarly, <a href="#widl-EventTarget-dispatchEvent"><code>dispatchEvent</code></a> can be used to dispatch untrusted events to
					listeners on <strong>any</strong> object that also implements <a href="#interface-EventTarget"><code>EventTarget</code></a>.</p>

				<p class="note"><strong>Note: </strong>The event objects associated with the event types described above contain additional context information--refer to the description of the DOM
					interfaces for further information.</p>
			</section>  <!-- event-types-list -->
		</section>  <!-- event-types -->

		<section id="event-definitions">
			<h2>Event Module Definitions</h2>
			<p>The DOM Event Model allows a DOM implementation to support multiple modules of events.
				The model has been designed to allow addition of new event modules in the future.
				This document does not attempt to define all possible events.
				For purposes of interoperability, the DOM defines a module of user interface events
				including lower level device dependent events and a module of document mutation events.
				</p>

			<section id="events-uievents">
				<h3>User Interface Event Types</h3>
				<p>The User Interface event module contains basic event types associated with user
					interfaces and document manipulation.
					</p>

				<section id="interface-UIEvent">
					<h4>Interface UIEvent</h4>

					<p class="intro-dom">Introduced in DOM Level 2</p>

					<p>The <code>UIEvent</code> interface provides specific contextual information associated
						with User Interface events.
						</p>

					<p>To create an instance of the <code>UIEvent</code> interface, use the
						<a href="#widl-DocumentEvent-createEvent"><code>DocumentEvent.createEvent("UIEvent")</code></a>
						method call.
						</p>

					<dl class="idl" title="[Constructor(DOMString type, optional UIEventInit eventInitDict)] interface UIEvent : Event">
						<dt>readonly attribute WindowProxy? view</dt>
						<dd>
							<p>The <code>view</code> attribute identifies the <code>Window</code> from which the event was generated.</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>null</code>.</p>
						</dd>

						<dt>readonly attribute long detail</dt>
						<dd>
							<p>Specifies some detail information about the <a href="#interface-Event"><code>Event</code></a>, depending on the type of event.</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>0</code>.</p>
						</dd>
					</dl>

					<dl class="idl" title="dictionary UIEventInit : EventInit">
						<dt>WindowProxy? view = null</dt>
						<dd>
							<p>Should be initialized to the Window object of the global environment 
								in which this event will be dispatched. If this event will be dispatched
								to an element, the view property should be set to the Window object 
								containing the element's <code>ownerDocument</code>.
								</p>
						</dd>

						<dt>long detail = 0</dt>
						<dd>
							<p>This value is initialized to a number that is application-specific.
								</p>
						</dd>
					</dl>

				</section>  <!-- interface-UIEvent -->

				<p>The User Interface event types are listed below.  Some of these events use the
					<a href="#interface-UIEvent"><code>UIEvent</code></a> interface if generated from a
					user interface, but the <a href="#interface-Event"><code>Event</code></a> interface
					otherwise, as detailed in each event.
					</p>

				<!-- load -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-load"><dfn><a class="eventtype" href="#event-type-load"><code>load</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>load</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-UIEvent"><code>UIEvent</code></a> if generated from a user interface, <a href="#interface-Event"><code>Event</code></a> otherwise.</td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Async</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Document</code>, <code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												common object whose contained resources have loaded</li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when the DOM implementation finishes loading the resource (such as the document)
								and any dependent resources (such as images, style sheets, or scripts). Dependent resources that fail to load MUST NOT prevent this event from firing if the resource
								that loaded them is still accessible via the DOM. If this event type is dispatched, implementations are REQUIRED to dispatch this event at least on the <code>Document</code>
								node.</p>

							<p class="note"><strong>Note:</strong> For legacy reasons, <a class="eventtype" href="#event-type-load"><code>load</code></a> events for resources inside
								the document (e.g., images) do not include the <a class="def" href="#glossary-window">Window</a> in the propagation path in HTML implementations. See
								[<cite><a class="informative" href="#references-HTML5">HTML5</a></cite>] for more information.</p>
						</dd>
					</dl>
				</div>

				<!-- unload -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-unload"><dfn><a class="eventtype" href="#event-type-unload"><code>unload</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>unload</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-UIEvent"><code>UIEvent</code></a> if generated from a user interface, <a href="#interface-Event"><code>Event</code></a> otherwise.</td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Document</code>, <code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												common object whose contained resources have been removed</li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when the DOM Implementation removes from the environment the resource (such
								as the document) or any dependent resources (such as images, style sheets, scripts). The document MUST be unloaded after the dispatch of this event type. If this
								event type is dispatched, implementations are REQUIRED to dispatch this event at least on the <code>Document</code> node.</p>
						</dd>
					</dl>
				</div>

				<!-- abort -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-abort"><dfn><a class="eventtype" href="#event-type-abort"><code>abort</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>abort</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-UIEvent"><code>UIEvent</code></a> if generated from a user interface, <a href="#interface-Event"><code>Event</code></a> otherwise.</td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												element whose resources have been stopped from loading without error</li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when the loading of a resource has been aborted, such as by a user canceling
								the load while it is still in progress.</p>
						</dd>
					</dl>
				</div>

				<!-- error -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-error"><dfn><a class="eventtype" href="#event-type-error"><code>error</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>error</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-UIEvent"><code>UIEvent</code></a> if generated from a user interface, <a href="#interface-Event"><code>Event</code></a> otherwise.</td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Async</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												element whose resources have been stopped from loading due to an error</li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a resource failed to load, or has been loaded but cannot be interpreted
								according to its semantics, such as an invalid image, a script execution error, or non-well-formed XML.</p>
						</dd>
					</dl>
				</div>

				<!-- select -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-select"><dfn><a class="eventtype" href="#event-type-select"><code>select</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>select</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-UIEvent"><code>UIEvent</code></a> if generated from a user interface, <a href="#interface-Event"><code>Event</code></a> otherwise.</td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												element whose text content has been selected</li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a user selects some text.  This event is dispatched after the selection
								has occurred.</p>

							<p>This specification does not provide contextual information to access the selected text.  Where applicable, a <a class="def" href="#glossary-host-language">host
								language</a> SHOULD define rules for how a user MAY select content (with consideration for international language conventions), at what point the <a class="eventtype"
								href="#event-type-select"><code>select</code></a> event is dispatched, and how a content author MAY access the user-selected content.</p>

							<p class="note"><strong>Note:</strong>  In order to access to user-selected content, content authors will use native capabilities of the <a
								class="def" href="#glossary-host-language">host languages</a>, such as the <code>Document.getSelection()</code> method of the <a href="https://dvcs.w3.org/hg/editing/raw-file/tip/editing.html#selections">
								HTML Editing APIs</a> [<cite><a class="informative" href="#references-HTMLEd">HTML Editing</a></cite>].</p>

							<p class="note"><strong>Note:</strong> The <a class="eventtype" href="#event-type-select"><code>select</code></a> event might not be available
								for all elements in all languages.  For example, in [<cite><a class="informative" href="#references-HTML5">HTML5</a></cite>], <a class="eventtype" href="#event-type-select">
								<code>select</code></a> events can be dispatched only on form <code>input</code> and <code>textarea</code> elements.  Implementations can dispatch <a class="eventtype"
								href="#event-type-select"><code>select</code></a> events in any context deemed appropriate, including text selections outside of form controls, or image or
								markup selections such as in SVG.</p>
						</dd>
					</dl>
				</div>

				<!-- resize -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-resize"><dfn><a class="eventtype" href="#event-type-resize"><code>resize</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>resize</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-UIEvent"><code>UIEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												object which has been resized</li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a document view has been resized. This event type is dispatched after
								all effects for that occurrence of resizing of that particular <a class="def" href="#glossary-event-target">event target</a> have been executed by the <a class="def"
								href="#glossary-user-agent">user agent</a>.</p>

							<p><a class="def" href="#glossary-user-agent">User agents</a> which support continuous reflow of the document's layout during user-initiated resizing MUST dispatch
								this event synchronously after each reflow of the document.</p>

							<p>The <a class="def" href="#glossary-window"><code>Window</code></a> object SHOULD always be resizable.  A <a class="def" href="#glossary-host-language">
								host language</a> MAY define certain elements to be resizable, and under what conditions (e.g., specific elements like <code>&lt;iframe&gt;</code>, or elements
								with particular characteristics like width and height). However, this specification does not define the behavior for elements.</p>

							<p class="note"><strong>Note:</strong>  The <a class="eventtype" href="#event-type-resize"><code>resize</code></a> event is distinct from the
								SVG <code class="eventtype">zoom</code> event types, though both can occur at the same time, or as the consequence of the same user action.  In particular, browser
								<q>font zooming</q> or <q>page zooming</q> will not necessarily trigger a <a class="eventtype" href="#event-type-resize"><code>resize</code></a> event.</p>

							<p class="note"><strong>Note:</strong> In previous DOM Events specifications, the <a class="eventtype" href="#event-type-resize"><code>resize</code></a>
								event type was defined to have a <a class="def" href="#glossary-bubbling-phase">bubbling phase</a>, but for performance reasons, this was not implemented in most
								user agents, and this specification removes the <a class="def" href="#glossary-bubbling-phase">bubbling phase</a> for this event.</p>
						</dd>
					</dl>
				</div>

				<!-- scroll -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-scroll"><dfn><a class="eventtype" href="#event-type-scroll"><code>scroll</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>scroll</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-UIEvent"><code>UIEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Async</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>No / <a href="#scroll-document">Yes</a></td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Document</code>, <code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												object which has been scrolled</li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a document view or an element has been scrolled.  This event type is dispatched
								after the scroll has occurred.</p>

							<p id="scroll-document">When dispatched on the <code>Document</code> element, this event type MUST 
								bubble to the <a class="def" href="#glossary-window"><code>Window</code></a> object.</p>
						</dd>
					</dl>
				</div>
			</section>

			<section id="events-focusevent">
				<h3>Focus Event Types</h3>

				<p class="note"><strong>Note:</strong>
					This interface and its associated event types and
						<a href="#events-focusevent-event-order">focus event order</a>
					were designed in accordance to the concepts and guidelines defined in
						<a href="http://www.w3.org/WAI/UA/2010/ED-UAAG20-20100308/">User Agent Accessibility Guidelines 2.0</a>
						[<a href="#references-UAAG2">UAAG 2.0</a>],
					with particular attention on the
						<a href="http://www.w3.org/WAI/UA/2010/ED-UAAG20-20100308/#gl-focus-mechanism">focus mechanism</a>
					and the terms defined in the
						<a href="http://www.w3.org/WAI/UA/2010/ED-UAAG20-20100308/#def-focus">glossary entry for focus</a>.
					</p>

				<section id="interface-FocusEvent">
					<h4>Interface FocusEvent</h4>

					<p class="intro-dom">Introduced in DOM Level 3</p>

					<p>The <code>FocusEvent</code> interface provides specific contextual information associated
						with Focus events.
						</p>

					<p>To create an instance of the <code>FocusEvent</code> interface, use the
						<a href="#widl-DocumentEvent-createEvent"><code>DocumentEvent.createEvent("FocusEvent")</code></a>
						method call.
						</p>

					<dl class="idl" title="[Constructor(DOMString typeArg, optional FocusEventInit focusEventInitDict)] interface FocusEvent : UIEvent">
						<dt>readonly attribute EventTarget? relatedTarget</dt>
						<dd>
							<p>Used to identify a secondary <a href="#interface-EventTarget"><code>EventTarget</code></a>
								related to a Focus event, depending on the type of event.
								</p>

							<p>For security reasons with nested browsing contexts, when tabbing into or out of a nested
								context, the relevant EventTarget SHOULD be <code>null</code>.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this
								attribute MUST be <code>null</code>.
								</p>
						</dd>

						<dl class="idl" title="dictionary FocusEventInit : UIEventInit">
							<dt>EventTarget? relatedTarget = null</dt>
							<dd>
								<p>The <code>relatedTarget</code> should be initialized to the element 
									losing focus (in the case of a <em>focus</em> or <em>focusin</em>
									event) or the element gaining focus (in the case of a <em>blur</em> 
									or <em>focusout</em> event).
									</p>
							</dd>
						</dl>
					</dl>
					
					<dl class="idl" title="dictionary FocusEventInit : UIEventInit">

						<dt>EventTarget? relatedTarget = null</dt>
						<dd>
							<p>The <code>relatedTarget</code> should be initialized to the element 
								whose bounds the mouse pointer just left (in the case of a 
								<em>mouseover</em> or <em>mouseenter</em> event) or the element 
								whose bounds the mouse pointer is entering (in the case of a 
								<em>mouseout</em> or <em>mouseleave</em>
								or <em>focusout</em> event). For other events, this value need not
								be assigned (and will default to null).
								</p>
						</dd>
					</dl>

				</section>  <!-- interface-FocusEvent -->

				<section id="events-focusevent-event-order">
					<h4>Focus Event Order</h4>
					<p>
						The focus events defined in this specification occur in a set order relative to one another.  The following is the typical sequence of events when a focus is shifted
						between elements (this order assumes that no element is initially focused):</p>

					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td><em>User shifts focus</em></td>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-focusin"><code>focusin</code></a></td>
							<td>Sent before first target element receives focus</td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-focus"><code>focus</code></a></td>
							<td>Sent after first target element receives focus</td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td><em>User shifts focus</em></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-focusout"><code>focusout</code></a></td>
							<td>Sent before first target element loses focus</td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-focusin"><code>focusin</code></a></td>
							<td>Sent before second target element receives focus</td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-blur"><code>blur</code></a></td>
							<td>Sent after first target element loses focus</td>
						</tr>
						<tr>
							<td class="cell-number">6.</td>
							<td><a class="eventtype" href="#event-type-focus"><code>focus</code></a></td>
							<td>Sent after second target element receives focus</td>
						</tr>
					</table>

					<p class="note"><strong>Note:</strong>  This specification does not define the behavior of focus events when interacting with methods such as <code>focus()</code> or
						<code>blur()</code>. See the relevant specifications where those methods are defined for such behavior.</p>
				</section>  <!-- events-focusevent-event-order -->

				<section id="events-focusevent-doc-focus">
					<h4>Document Focus and Focus Context</h4>

					<p>This event module includes event types for notification of changes in document
						<a class="def" href="#glossary-event-focus">focus</a>.
						There are three distinct focus contexts that are relevant to this discussion:
						</p>
					
					<ul>
						<li>The <em>operating system focus context</em> which MAY be on one of many different applications currently
							running on the computer. One of these applications with focus can be a browser.
							</li>
						<li>When the browser has focus, the user can switch (such as with the tab key) the
							<em>application focus context</em> among the different browser user interface fields (e.g., the
							Web site location bar, a search field, etc.). One of these user interface fields can be the
							document being shown in a tab.
							</li>
						<li>When the document itself has focus, the <em>document focus context</em> can be set to any of the
							focusable elements in the document.
							</li>
					</ul>

					<p>The event types defined in this specification deal exclusively with document focus, and the
						<a class="def" href="#glossary-event-target">event target</a> identified in the event details
						MUST only be part of the document or documents in the window, never a part of the browser or
						operating system, even when switching from one focus context to another.
						</p>
					
					<p>Normally, a document always has a focused element (even if it is the document element itself) and a persistent <a class="def" href="#glossary-event-focus-ring">focus
						ring</a>. When switching between focus contexts, the document's currently focused element and focus ring normally remain in their current state. For example,
						if a document has three focusable elements, with the second element focused, when a user changes operating system focus to another application and then back to
						the browser, the second element will still be focused within the document, and tabbing will change the focus to the third element.  A <a class="def" href="#glossary-host-language">
						host language</a> MAY define specific elements which might receive focus, the conditions under which an element MAY receive focus, the means by which
						focus MAY be changed, and the order in which the focus changes.  For example, in some cases an element might be given focus by moving a pointer over it, while other
						circumstances might require a mouse click. Some elements might not be focusable at all, and some might be focusable only by special means (clicking on the element),
						but not by tabbing to it.  Documents MAY contain multiple focus rings.  Other specifications MAY define a more complex focus model than is described in this specification,
						including allowing multiple elements to have the current focus.
						</p>
				</section>  <!-- events-focusevent-doc-focus -->

				<p>The Focus event types are listed below.</p>

				<!-- blur -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-blur"><dfn><a class="eventtype" href="#event-type-blur"><code>blur</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>blur</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-FocusEvent"><code>FocusEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-event-target">event target</a> losing focus</li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
											<li><a href="#widl-FocusEvent-relatedTarget"><code class="attribute-name">FocusEvent.relatedTarget</code></a>:
												<a class="def" href="#glossary-event-target">event target</a> receiving focus.</li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when an <a class="def" href="#glossary-event-target">event target</a> loses
								focus. The focus MUST be taken from the element before the dispatch of this event type.  This event type is similar to <a class="eventtype" href="#event-type-focusout">
								<code>focusout</code></a>, but is dispatched after focus is shifted, and does not bubble.</p>
						</dd>
					</dl>
				</div>

				<!-- focus -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-focus"><dfn><a class="eventtype" href="#event-type-focus"><code>focus</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>focus</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-FocusEvent"><code>FocusEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-event-target">event target</a> receiving focus</li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
											<li><a href="#widl-FocusEvent-relatedTarget"><code class="attribute-name">FocusEvent.relatedTarget</code></a>:
												<a class="def" href="#glossary-event-target">event target</a> losing focus (if any).</li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when an <a class="def" href="#glossary-event-target">event target</a> receives
								focus. The focus MUST be given to the element before the dispatch of this event type.  This event type is similar to <a class="eventtype" href="#event-type-focusin">
								<code>focusin</code></a>, but is dispatched after focus is shifted, and does not bubble.</p>
						</dd>
					</dl>
				</div>

				<!-- focusin -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-focusin"><dfn><a class="eventtype" href="#event-type-focusin"><code>focusin</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>focusin</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-FocusEvent"><code>FocusEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-event-target">event target</a> receiving focus</li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
											<li><a href="#widl-FocusEvent-relatedTarget"><code class="attribute-name">FocusEvent.relatedTarget</code></a>:
												<a class="def" href="#glossary-event-target">event target</a> losing focus (if any).</li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when an <a class="def" href="#glossary-event-target">event target</a> is about
								to receive focus. This event type MUST be dispatched before the element is given focus.  The <a class="def" href="#glossary-event-target">event target</a> MUST
								be the element which is about to receive focus.  This event type is similar to <a class="eventtype" href="#event-type-focus"><code>focus</code></a>, but is dispatched
								before focus is shifted, and does bubble.</p>

							<p class="note" id="_9"><strong>Note:</strong> When using this event type, the content author can use the event's <code class="attribute-name"><a href="#widl-FocusEvent-relatedTarget">
								FocusEvent.relatedTarget</a></code> attribute (or a host-language-specific method or means) to get the currently focused element before the focus shifts to the
								next focus <a class="def" href="#glossary-event-target">event target</a>, thus having access to both the element losing focus and the element gaining focus
								without the use of the <a class="eventtype" href="#event-type-blur"><code>blur</code></a> or <a class="eventtype" href="#event-type-focusout"><code>focusout</code></a> event
								types.</p>
						</dd>
					</dl>
				</div>

				<!-- focusout -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-focusout"><dfn><a class="eventtype" href="#event-type-focusout"><code>focusout</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>focusout</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-FocusEvent"><code>FocusEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-event-target">event target</a> losing focus</li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
											<li><a href="#widl-FocusEvent-relatedTarget"><code class="attribute-name">FocusEvent.relatedTarget</code></a>:
												<a class="def" href="#glossary-event-target">event target</a> receiving focus.</li>
										</ul>
									</td>
								</tr>
							</table>
							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when an <a class="def" href="#glossary-event-target">event target</a> is about
								to lose focus. This event type MUST be dispatched before the element loses focus.  The <a class="def" href="#glossary-event-target">event target</a> MUST be the
								element which is about to lose focus.  This event type is similar to <a class="eventtype" href="#event-type-blur"><code>blur</code></a>, but is dispatched before
								focus is shifted, and does bubble.</p>
						</dd>
					</dl>
				</div>
			</section>  <!-- events-focusevent -->

			<section id="events-mouseevents">
				<h3>Mouse Event Types</h3>

				<p>The mouse event module originates from the [<cite><a class="informative" href="#references-HTML40">HTML 4.01</a></cite>] <code>onclick</code>, <code>ondblclick</code>,
					<code>onmousedown</code>, <code>onmouseup</code>, <code>onmouseover</code>, <code>onmousemove</code>, and <code>onmouseout</code> attributes. This event module
					is specifically designed for use with pointing input devices, such as a mouse or a trackball.</p>

				<section id="interface-MouseEvent">
					<h4>Interface MouseEvent</h4>

					<p class="intro-dom">Introduced in DOM Level 2, modified in DOM Level 3</p>

					<p>The <code>MouseEvent</code> interface provides specific contextual information
						associated with Mouse events.
						</p>

					<p>In the case of nested elements, mouse events are always targeted at the most deeply
						nested element.
						</p>

					<p class="note"><strong>Note:</strong>
						Ancestors of the targeted element can use event bubbling to obtain notifications
						of mouse events which occur within their descendent elements.
						</p>

					<p>To create an instance of the <code>MouseEvent</code> interface, use the
						<a href="#widl-DocumentEvent-createEvent"><code>DocumentEvent.createEvent("MouseEvent")</code></a>
						method call.
						</p>

					<p class="note"><strong>Note:</strong>
						When initializing <code>MouseEvent</code> objects using <code>initMouseEvent</code>,
						implementations can use the client coordinates <code>clientX</code> and <code>clientY</code>
						for calculation of other coordinates (such as target coordinates exposed by
							<a class="def" href="#glossary-DOM-Level-0">DOM Level 0</a>
						implementations or other proprietary attributes, e.g., <code>pageX</code>).
						</p>

					<dl class="idl" title="[Constructor(DOMString typeArg, optional MouseEventInit mouseEventInitDict)] interface MouseEvent : UIEvent">
						<dt>readonly attribute long screenX</dt>
						<dd>
							<p>The horizontal coordinate at which the event occurred relative to the origin
								of the screen coordinate system.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a>
								of this attribute MUST be <code>0</code>.
								</p>
						</dd>

						<dt>readonly attribute long screenY</dt>
						<dd>
							<p>The vertical coordinate at which the event occurred relative to the origin
								of the screen coordinate system.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a>
								of this attribute MUST be <code>0</code>.
								</p>
						</dd>

						<dt>readonly attribute long clientX</dt>
						<dd>
							<p>The horizontal coordinate at which the event occurred relative to the viewport
								associated with the event.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a>
								of this attribute MUST be <code>0</code>.
								</p>
						</dd>

						<dt>readonly attribute long clientY</dt>
						<dd>
							<p>The vertical coordinate at which the event occurred relative to the viewport
								associated with the event.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a>
								of this attribute MUST be <code>0</code>.
								</p>
						</dd>

						<dt>readonly attribute boolean ctrlKey</dt>
						<dd>
							<p>Refer to the <a href="#widl-KeyboardEvent-ctrlKey"><code>KeyboardEvent.ctrlKey</code></a> attribute.</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a>
								of this attribute MUST be <code>false</code>.
								</p>
						</dd>

						<dt>readonly attribute boolean shiftKey</dt>
						<dd>
							<p>Refer to the <a href="#widl-KeyboardEvent-shiftKey"><code>KeyboardEvent.shiftKey</code></a> attribute.</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a>
								of this attribute MUST be <code>false</code>.
								</p>
						</dd>

						<dt>readonly attribute boolean altKey</dt>
						<dd>
							<p>Refer to the <a href="#widl-KeyboardEvent-altKey"><code>KeyboardEvent.altKey</code></a> attribute.</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a>
								of this attribute MUST be <code>false</code>.
								</p>
						</dd>

						<dt>readonly attribute boolean metaKey</dt>
						<dd>
							<p>Refer to the <a href="#widl-KeyboardEvent-metaKey"><code>KeyboardEvent.metaKey</code></a> attribute.</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a>
								of this attribute MUST be <code>false</code>.
								</p>
						</dd>

						<dt>readonly attribute short button</dt>
						<dd>
							<p>During mouse events caused by the depression or release of a mouse button,
								<code>button</code> MUST be used to indicate which pointer device button
								changed state.
								</p>
								
							<p>The value of the <a href="#widl-MouseEvent-button"><code>MouseEvent.button</code></a>
								attribute MUST be as follows:
								</p>

							<ul>
								<li><code>0</code> MUST indicate the primary button of the device
									(in general, the left button  or the only button on single-button devices,
									used to activate a user interface control or select text) or the
									un-initialized value.</li>
								<li><code>1</code> MUST indicate the auxiliary button
									(in general, the middle button, often combined with a mouse wheel).</li>
								<li><code>2</code> MUST indicate the secondary button
									(in general, the right button, often used to display a context menu).</li>
							</ul>

							<p>Some pointing devices provide or simulate more button states, and values higher than
								<code>2</code> or lower than <code>0</code> MAY be used to represent such buttons.
								</p>

							<p class="note"><strong>Note:</strong>
								The value of <code>button</code> is not updated for events not caused by the
								depression/release of a mouse button.
								In these scenarios, take care not to interpret the value <code>0</code> as the
								left button, but rather as the
									<a class="def" href="#glossary-un-initialized-value">un-initialized value</a>.
								</p>

							<p class="note"><strong>Authoring Note:</strong>
								Some <a class="def" href="#glossary-default-action">default actions</a> related
								to events such as <a class="eventtype"><code>mousedown</code></a> and
								<a class="eventtype"><code>mouseup</code></a> depend on the specific mouse
								button in use.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a>
								of this attribute MUST be <code>0</code>.
								</p>
						</dd>

						<dt>readonly attribute EventTarget? relatedTarget</dt>
						<dd>
							<p>Used to identify a secondary <a href="#interface-EventTarget"><code>EventTarget</code></a> related to a UI event, depending on the type of event.</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>null</code>.</p>
						</dd>

						<dt>// Introduced in DOM Level 3</dt>

						<dt>readonly attribute unsigned short buttons</dt>
						<dd>
							<p>During any mouse events, <code>buttons</code> MUST be used to indicate
								which combination of mouse buttons are currently being pressed,
								expressed as a bitmask.
								</p>

							<p class="note"><strong>Note:</strong>
								Though similarly named, the values for the <code>buttons</code> attribute
								and the <a href="#widl-MouseEvent-button"><code>button</code></a>
								attribute are very different.
								The value of <code>button</code> is assumed to be valid during
								<a class="eventtype"><code>mousedown</code></a> /
								<a class="eventtype"><code>mouseup</code></a> event handlers,
								whereas the <code>buttons</code> attribute reflects the state of the
								mouse's buttons for any trusted <code>MouseEvent</code> object
								(while it is being dispatched), because it can represent the
								"no button currently active" state (0).
								</p>

							<p>The value of the <a href="#widl-MouseEvent-buttons"><code>MouseEvent.buttons</code></a>
								attribute MUST be as follows:
								</p>

							<ul>
								<li><code>0</code> MUST indicate no button is currently active.</li>
								<li><code>1</code> MUST indicate the primary button of the device
									(in general, the left button or the only button on single-button devices,
									used to activate a user interface control or select text).</li>
								<li><code>2</code> MUST indicate the secondary button
									(in general, the right button, often used to display a context menu), if present.</li>
								<li><code>4</code> MUST indicate the auxiliary button
									(in general, the middle button, often combined with a mouse wheel).</li>
							</ul>

							<p>Some pointing devices provide or simulate more buttons.
								To represent such buttons, the value MUST be doubled for each successive button
								(in the binary series <code>8</code>, <code>16</code>, <code>32</code>, ... ).
								</p>

							<p class="note" id="buttons-mask"><strong>Note:</strong>
								Because the sum of any set of button values is a unique number, a content
								author can use a bitwise operation to determine how many buttons are currently
								being pressed and which buttons they are, for an arbitrary number of mouse buttons
								on a device.
								For example, the value <code>3</code> indicates that the left and right button are
								currently both pressed, while the value <code>5</code> indicates that the left and
								middle button are currently both pressed.
								</p>

							<p class="note"><strong>Authoring Note:</strong>
								Some <a class="def" href="#glossary-default-action">default actions</a> related
								to events such as <a class="eventtype"><code>mousedown</code></a> and
								<a class="eventtype"><code>mouseup</code></a> depend on the specific mouse button
								in use.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a>
								of this attribute MUST be <code>0</code>.
								</p>
						</dd>

						<dt>boolean getModifierState()</dt>
						<dd>
							<p class="intro-dom">Introduced in DOM Level 3</p>

							<p>Queries the state of a modifier using a key value.
								See <a href="#keys-modifiers">Modifier keys</a> for a list of valid (case-sensitive) arguments to this method.
								</p>

							<p>Returns <code>true</code> if it is a modifier key and the modifier is activated,
								<code>false</code> otherwise.
								</p>

							<dl class="parameters">
								<dt>DOMString keyArg</dt>
								<dd>
									<p>Refer to the <a href="#widl-KeyboardEvent-getModifierState"><code>KeyboardEvent.getModifierState()</code></a> method for a description of this parameter.</p>
								</dd>
							</dl>
						</dd>

					</dl>

					<dl class="idl" title="dictionary MouseEventInit : UIEventInit">

						<dt>long screenX = 0</dt>
						<dd>
							<p>See <code>screenY</code> (substituting "horizontal" for "veritcal").</p>
						</dd>

						<dt>long screenY = 0</dt>
						<dd>
							<p>Initializes the <code>screenY</code> attribute of the MouseEvent
								object to the desired vertical relative position of the mouse 
								pointer on the user's screen.
								</p>

							<p>Initializing the event object to the given mouse position must 
								not move the user's mouse pointer to the initialized position.
								</p>
						</dd>

						<dt>long clientX = 0</dt>
						<dd>
							<p>See <code>clientY</code> (substituting "horizontal" for "vertical").</p>
						</dd>

						<dt>long clientY = 0</dt>
						<dd>
							<p>Initializes the <code>clientY</code> attribute of the MouseEvent
								object to the desired vertical position of the mouse pointer 
								relative to the client window of the user's browser.
								</p>

							<p>Initializing the event object to the given mouse position must 
								not move the user's mouse pointer to the initialized position.
								</p>
						</dd>

						<dt>boolean ctrlKey = false</dt>
						<dd>
							<p>Initializes the <code>altKey</code> attribute of the MouseEvent
								object to <code>true</code> if the <code class="key">'Control'</code>
								(control) key modifier is to be considered active, 
								<code>false</code> otherwise.</p>
						</dd>

						<dt>boolean shiftKey = false</dt>
						<dd>
							<p>Initializes the <code>shiftKey</code> attribute of the MouseEvent
								object to <code>true</code> if the <code class="key">'Shift'</code>
								key modifier is to be considered active, <code>false</code> otherwise.</p>
						</dd>

						<dt>boolean altKey = false</dt>
						<dd>
							<p>Initializes the <code>altKey</code> attribute of the MouseEvent
								object to <code>true</code> if the <code class="key">'Alt'</code>
								(alternative) (or <code class="glyph">'Option'</code>) key modifier 
								is to be considered active, <code>false</code> otherwise.</p>
						</dd>

						<dt>boolean metaKey = false</dt>
						<dd>
							<p>Initializes the <code>metaKey</code> attribute of the MouseEvent
								object to <code>true</code> if the <code class="key">'Meta'</code>
								key modifier is to be considered active, <code>false</code> otherwise.</p>
						</dd>

						<dt>short button = 0</dt>
						<dd>
							<p>Initializes the <code>button</code> attribute of the MouseEvent
								object to a number representing the desired state of the button(s)
								of the mouse.
								</p>

							<p class="note"><strong>Note:</strong>
								The value 0 is used to represent
								the primary mouse button, 1 is used to represent the auxiliary/middle 
								mouse button, and 2 to represent the right mouse button.
								Numbers greater than 2 are also possible, but are not specified
								in this document.
								</p>
						</dd>

						<dt>unsigned short buttons = 0</dt>
						<dd>
							<p>Initializes the <code>buttons</code> attribute of the MouseEvent
								object to a number representing one <em>or more</em> of the button(s) of the mouse 
								that are to be considered active.
								</p>

							<p class="note"><strong>Note:</strong>
								The <code>buttons</code>
								attribute is a bit-field. If a mask value of 1 is true when applied to 
								the value of the bit field, then the primary mouse button is down. If a 
								mask value of 2 is true when applied to the value of the bit field, then 
								the right mouse button is down. If a mask value of 4 is true when applied 
								to the value of the bit field, then the auxiliary/middle button is down.</p>

							<div class="example">
								<p>In JavaScript, to initialize the 
									<code>buttons</code> attribute as if the right (2) and middle 
									button (4) were being pressed simultaneously, the buttons value 
									can be assigned as either:<br/>
									<code>{ buttons: 2 | 4 }</code></br/>
									or:<br/>
									<code>{ buttons: 6 }</code>
									</p>
							</div><!-- Initializing buttons -->
						</dd>

						<dt>EventTarget? relatedTarget = null</dt>
						<dd>
							<p>The <code>relatedTarget</code> should be initialized to the element 
								whose bounds the mouse pointer just left (in the case of a 
								<em>mouseover</em> or <em>mouseenter</em> event) or the element 
								whose bounds the mouse pointer is entering (in the case of a 
								<em>mouseout</em> or <em>mouseleave</em>
								or <em>focusout</em> event). For other events, this value need not
								be assigned (and will default to null).
								</p>
						</dd>
					</dl>

				</section>  <!-- interface-MouseEvent -->

				<p id="current-click-count">Implementations MUST maintain the <em>current click count</em> when generating mouse events. This MUST be a non-negative integer indicating
					the number of consecutive clicks of a pointing device button within a specific time. The delay after which the count resets is specific to the
					environment configuration.</p>

				<section id="events-mouseevent-event-order">
					<h4>Mouse Event Order</h4>

					<p>Certain mouse events defined in this specification MUST occur in a set order relative to one another.
						The following shows the event sequence that MUST occur when a pointing
						device's cursor is moved over an element:</p>

					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center">Element</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td></td>
							<td><em>Pointing device is moved into element A...</em></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-mouseover"><code>mouseover</code></a></td>
							<td class="cell-center">A</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-mouseenter"><code>mouseenter</code></a></td>
							<td class="cell-center">A</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a></td>
							<td class="cell-center">A</td>
							<td>Multiple events</td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td></td>
							<td><em>Pointing device is moved out of element A...</em></td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-mouseout"><code>mouseout</code></a></td>
							<td class="cell-center">A</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">6.</td>
							<td><a class="eventtype" href="#event-type-mouseleave"><code>mouseleave</code></a></td>
							<td class="cell-center">A</td>
							<td></td>
						</tr>
					</table>

					<p>When a pointing device is moved into an element <em>A</em>, and then into a nested element <em>B</em>
						and then back out again, the following sequence of events MUST occur:
						</p>

					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center">Element</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td></td>
							<td><em>Pointing device is moved into element A...</em></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-mouseover"><code>mouseover</code></a></td>
							<td class="cell-center">A</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-mouseenter"><code>mouseenter</code></a></td>
							<td class="cell-center">A</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a></td>
							<td class="cell-center">A</td>
							<td>Multiple events</td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td></td>
							<td><em>Pointing device is moved into nested element B...</em></td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-mouseout"><code>mouseout</code></a></td>
							<td class="cell-center">A</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">6.</td>
							<td><a class="eventtype" href="#event-type-mouseover"><code>mouseover</code></a></td>
							<td class="cell-center">B</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">7.</td>
							<td><a class="eventtype" href="#event-type-mouseenter"><code>mouseenter</code></a></td>
							<td class="cell-center">B</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">8.</td>
							<td><a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a></td>
							<td class="cell-center">B</td>
							<td>Multiple events</td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td></td>
							<td><em>Pointing device is moved from element B into A...</em></td>
						</tr>
						<tr>
							<td class="cell-number">9.</td>
							<td><a class="eventtype" href="#event-type-mouseout"><code>mouseout</code></a></td>
							<td class="cell-center">B</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">10.</td>
							<td><a class="eventtype" href="#event-type-mouseleave"><code>mouseleave</code></a></td>
							<td class="cell-center">B</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">11.</td>
							<td><a class="eventtype" href="#event-type-mouseover"><code>mouseover</code></a></td>
							<td class="cell-center">A</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">12.</td>
							<td><a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a></td>
							<td class="cell-center">A</td>
							<td>Multiple events</td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td></td>
							<td><em>Pointing device is moved out of element A...</em></td>
						</tr>
						<tr>
							<td class="cell-number">13.</td>
							<td><a class="eventtype" href="#event-type-mouseout"><code>mouseout</code></a></td>
							<td class="cell-center">A</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">14.</td>
							<td><a class="eventtype" href="#event-type-mouseleave"><code>mouseleave</code></a></td>
							<td class="cell-center">A</td>
							<td></td>
						</tr>
					</table>

					<p>Sometimes elements can be visually overlapped using CSS. In the following example, three elements
						labeled A, B, and C all have the same dimensions and absolute position on a web page.
						Element C is a child of B, and B is a child of A in the DOM:
						</p>

					<figure id="figure-mouse-event-stacked-elements">
						<img src='images/stacked-event-mouse-dispatch.svg' width="403" height="217" />
						<figcaption>Graphical representation of three stacked elements all on top of each other, with the pointing device moving over the stack.</figcaption>
					</figure>

					<p>When the pointing device is moved from outside the element stack to the element labeled C and then moved
						out again, the following series of events MUST occur:</p>

					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center">Element</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td></td>
							<td><em>Pointing device is moved into element C, the topmost element in the stack</em></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-mouseover"><code>mouseover</code></a></td>
							<td class="cell-center">C</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-mouseenter"><code>mouseenter</code></a></td>
							<td class="cell-center">A</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-mouseenter"><code>mouseenter</code></a></td>
							<td class="cell-center">B</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-mouseenter"><code>mouseenter</code></a></td>
							<td class="cell-center">C</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">6.</td>
							<td><a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a></td>
							<td class="cell-center">C</td>
							<td>Multiple events</td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td></td>
							<td><em>Pointing device is moved out of element C...</em></td>
						</tr>
						<tr>
							<td class="cell-number">7.</td>
							<td><a class="eventtype" href="#event-type-mouseout"><code>mouseout</code></a></td>
							<td class="cell-center">C</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">8.</td>
							<td><a class="eventtype" href="#event-type-mouseleave"><code>mouseleave</code></a></td>
							<td class="cell-center">C</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">9.</td>
							<td><a class="eventtype" href="#event-type-mouseleave"><code>mouseleave</code></a></td>
							<td class="cell-center">B</td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">10.</td>
							<td><a class="eventtype" href="#event-type-mouseleave"><code>mouseleave</code></a></td>
							<td class="cell-center">A</td>
							<td></td>
						</tr>
					</table>

					<p class="note"><strong>Note:</strong> The <code>mouseover</code>/<code>mouseout</code> events are only fired once, while <code>mouseenter</code>/<code>mouseleave</code>
						events are fired three times (once to each element).</p>

					<p>The following is the typical sequence of events when a button associated with a pointing device (e.g., a mouse button or trackpad) is pressed and released over
						an element:</p>

					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-mousedown"><code>mousedown</code></a></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a></td>
							<td>OPTIONAL, multiple events, some limits</td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-click"><code>click</code></a></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a></td>
							<td>OPTIONAL, multiple events, some limits</td>
						</tr>
						<tr>
							<td class="cell-number">6.</td>
							<td><a class="eventtype" href="#event-type-mousedown"><code>mousedown</code></a></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">7.</td>
							<td><a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a></td>
							<td>OPTIONAL, multiple events, some limits</td>
						</tr>
						<tr>
							<td class="cell-number">8.</td>
							<td><a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">9.</td>
							<td><a class="eventtype" href="#event-type-click"><code>click</code></a></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">10.</td>
							<td><a class="eventtype" href="#event-type-dblclick"><code>dblclick</code></a></td>
							<td></td>
						</tr>
					</table>

					<p class="note"><strong>Note: </strong>The lag time, degree, distance, and number of <a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a>
						events allowed between the <a class="eventtype" href="#event-type-mousedown"><code>mousedown</code></a> and <a class="eventtype" href="#event-type-mouseup">
						<code>mouseup</code></a> events while still firing a <a class="eventtype" href="#event-type-click"><code>click</code></a> or <a class="eventtype"
						href="#event-type-dblclick"><code>dblclick</code></a> event will be implementation-, device-, and platform-specific. This tolerance can aid users that have physical
						disabilities like unsteady hands when these users interact with a pointing device.</p>

					<p>Each implementation will determine the appropriate <a class="def" href="#glossary-hysteresis">hysteresis</a> tolerance, but in general SHOULD fire <a class="eventtype" href="#event-type-click"><code>click</code></a>
						and <a class="eventtype" href="#event-type-dblclick"><code>dblclick</code></a> events when the event target of the associated <a class="eventtype"
						href="#event-type-mousedown"><code>mousedown</code></a> and <a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a> events is the same element with no
						<a class="eventtype" href="#event-type-mouseout"><code>mouseout</code></a> or <a class="eventtype" href="#event-type-mouseleave"><code>mouseleave</code></a>
						events intervening, and SHOULD fire <a class="eventtype" href="#event-type-click"><code>click</code></a> and <a class="eventtype" href="#event-type-dblclick">
						<code>dblclick</code></a> events on the nearest common ancestor when the event targets of the associated <a class="eventtype" href="#event-type-mousedown">
						<code>mousedown</code></a> and <a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a> events are different.</p>

					<p>If the <a class="def" href="#glossary-event-target">event target</a> (e.g. the target element) is removed from the DOM during the mouse events sequence, the remaining
						events of the sequence MUST NOT be fired on that element.</p>

					<div class="example">
						<div class="example-title"></div>
						<p>If the target element is removed from the DOM as the result of a <a class="eventtype" href="#event-type-mousedown">
						<code>mousedown</code></a> event, no events for that element will be dispatched for <a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a>,
						<a class="eventtype" href="#event-type-click"><code>click</code></a>, or <a class="eventtype" href="#event-type-dblclick"><code>dblclick</code></a>, nor any default
						activation events. However, the <a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a> event will still be dispatched on the element that is exposed
						to the mouse after the removal of the initial target element. Similarly, if the target element is removed from the DOM during the dispatch of a <a class="eventtype"
						href="#event-type-mouseup"><code>mouseup</code></a> event, the <a class="eventtype" href="#event-type-click"><code>click</code></a> and subsequent events will
						not be dispatched.</p>
					</div>

				</section>  <!-- events-mouseevent-event-order -->

				<p>The Mouse event types are listed below. In the case of nested elements, mouse event types are always targeted at the most deeply nested element. Ancestors of the
					targeted element MAY use bubbling to obtain notification of mouse events which occur within its descendent elements.</p>

				<!-- click -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-click"><dfn><a class="eventtype" href="#event-type-click"><code>click</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>click</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>Varies</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-topmost-event-target">topmost event target</a></li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												indicates the <a href="#current-click-count">current click count</a>;
												the attribute value MUST be <code>1</code> when the user begins this action and increments by <code>1</code> for each click.</li>
											<li><a href="#widl-MouseEvent-screenX"><code class="attribute-name">MouseEvent.screenX</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-screenY"><code class="attribute-name">MouseEvent.screenY</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-clientX"><code class="attribute-name">MouseEvent.clientX</code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-clientY"><code class="attribute-name">MouseEvent.clientY </code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-altKey"><code class="attribute-name">MouseEvent.altKey</code></a>:
												<code>true</code> if <code class="key">'Alt'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-ctrlKey"><code class="attribute-name">MouseEvent.ctrlKey</code></a>:
												<code>true</code> if <code class="key">'Control'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-shiftKey"><code class="attribute-name">MouseEvent.shiftKey</code></a>:
												<code>true</code> if <code class="key">'Shift'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-metaKey"><code class="attribute-name">MouseEvent.metaKey</code></a>:
												<code>true</code> if <code class="key">'Meta'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-button"><code class="attribute-name">MouseEvent.button</code></a>:
												value based on current button pressed</li>
											<li><a href="#widl-MouseEvent-buttons"><code class="attribute-name">MouseEvent.buttons</code></a>:
												value based on all buttons current depressed, <code>0</code> if no buttons pressed</li>
											<li><a href="#widl-MouseEvent-relatedTarget"><code class="attribute-name">MouseEvent.relatedTarget</code></a>:
												<code>null</code></li>
										</ul>
									</td>
								</tr>
							</table>

							<p>The <a class="eventtype" href="#event-type-click"><code>click</code></a> event type MUST be dispatched on the
								<a class="def" href="#glossary-topmost-event-target">topmost event target</a> indicated by the pointer, when
								the user presses down and releases the primary pointer button,
								or otherwise activates the pointer in a manner that simulates such an action.
								The actuation method of the mouse button depends upon the pointer device and the environment configuration,
								e.g., it MAY depend on the screen location or the delay between the press and release of the pointing device button.
								</p>

							<p class="note"><strong>Note:</strong> The <code>click</code> event should only be fired for the primary
								pointer button (i.e., when <a href="#widl-MouseEvent-button"><code>MouseEvent.button</code></a> value is <code>0</code>,
								<a href="#widl-MouseEvent-buttons"><code>MouseEvent.buttons</code></a> value is <code>1</code>).
								Secondary buttons (like the middle or right button on a standard mouse) MUST NOT fire
								<code>click</code> events.
								</p>

							<p>The <a class="eventtype" href="#event-type-click"><code>click</code></a> event MAY be preceded by the <a class="eventtype" href="#event-type-mousedown"><code>mousedown</code></a>
								and <a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a> events on the same element, disregarding changes between other node types (e.g., text
								nodes).  Depending upon the environment configuration, the <a class="eventtype" href="#event-type-click"><code>click</code></a> event MAY be dispatched if one or
								more of the event types <a class="eventtype" href="#event-type-mouseover"><code>mouseover</code></a>, <a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a>,
								and <a class="eventtype" href="#event-type-mouseout"><code>mouseout</code></a> occur between the press and release of the pointing device button.  The <a class="eventtype"
								href="#event-type-click"><code>click</code></a> event MAY also be followed by the <a class="eventtype" href="#event-type-dblclick"><code>dblclick</code></a>
								event.</p>

							<div class="example">
								<div class="example-title"></div>
								<p>If a user mouses down on a text node child of a <code>&lt;p&gt;</code> element which has been styled with
									a large line-height, shifts the mouse slightly such that it is no longer over an area containing text but is still within the containing block of that <code>&lt;p&gt;</code>
									element (i.e., the pointer is between lines of the same text block, but not over the text node per se), then subsequently mouses up, this will likely still trigger
									a <a class="eventtype" href="#event-type-click"><code>click</code></a> event (if it falls within the normal temporal <a class="def" href="#glossary-hysteresis">hysteresis</a> for a <a class="eventtype" href="#event-type-click">
									<code>click</code></a>), since the user has stayed within the scope of the same element. Note that user-agent-generated mouse events are not dispatched on text nodes.
								</p>
							</div>

							<p>In addition to being associated with pointer devices, the <a class="eventtype" href="#event-type-click"><code>click</code></a> event type MUST be dispatched as
								part of an element activation, as described in <a href="#event-flow-activation">Activation triggers and behavior</a>.</p>

							<p class="note"><strong>Note:</strong> For maximum accessibility, content authors are encouraged to use the
								<a class="eventtype" href="#event-type-click"><code>click</code></a> event type when defining activation
								behavior for custom controls, rather than other pointing-device event types such as
								<a class="eventtype" href="#event-type-mousedown"><code>mousedown</code></a> or
								<a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a>, which are more device-specific.
								Though the <a class="eventtype" href="#event-type-click"><code>click</code></a> event type has its origins
								in pointer devices (e.g., a mouse), subsequent implementation
								enhancements have extended it beyond that association, and it can be considered a device-independent event
								type for element activation.
								</p>

							<p>The <a class="def" href="#glossary-default-action">default action</a> of the
								<a class="eventtype" href="#event-type-click"><code>click</code></a> event type varies
								based on the <a class="def" href="#glossary-event-target">event target</a> of the event and the value of the
								<a href="#widl-MouseEvent-button"><code>MouseEvent.button</code></a>
								or <a href="#widl-MouseEvent-buttons"><code>MouseEvent.buttons</code></a> attributes.
								Typical <a class="def" href="#glossary-default-action">default actions</a>
								of the <a class="eventtype" href="#event-type-click"><code>click</code></a> event type are as follows:
								</p>

							<ul>
								<li>If the <a class="def" href="#glossary-event-target">event target</a> has associated activation behavior, the <a class="def" href="#glossary-default-action">default
									action</a> MUST be to execute that activation behavior (see <a href="#event-flow-activation">Activation triggers and behavior</a>).</li>

								<li>If the <a class="def" href="#glossary-event-target">event target</a> is focusable, the <a class="def" href="#glossary-default-action">default action</a> MUST be
									to give that element document focus.</li>
							</ul>
						</dd>
					</dl>
				</div>

				<!-- dblclick -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-dblclick"><dfn><a class="eventtype" href="#event-type-dblclick"><code>dblclick</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>dblclick</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-topmost-event-target">topmost event target</a></li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												indicates the <a href="#current-click-count">current click count</a></li>
											<li><a href="#widl-MouseEvent-screenX"><code class="attribute-name">MouseEvent.screenX</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-screenY"><code class="attribute-name">MouseEvent.screenY</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-clientX"><code class="attribute-name">MouseEvent.clientX</code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-clientY"><code class="attribute-name">MouseEvent.clientY </code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-altKey"><code class="attribute-name">MouseEvent.altKey</code></a>:
												<code>true</code> if <code class="key">'Alt'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-ctrlKey"><code class="attribute-name">MouseEvent.ctrlKey</code></a>:
												<code>true</code> if <code class="key">'Control'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-shiftKey"><code class="attribute-name">MouseEvent.shiftKey</code></a>:
												<code>true</code> if <code class="key">'Shift'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-metaKey"><code class="attribute-name">MouseEvent.metaKey</code></a>:
												<code>true</code> if <code class="key">'Meta'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-button"><code class="attribute-name">MouseEvent.button</code></a>:
												value based on current button pressed</li>
											<li><a href="#widl-MouseEvent-buttons"><code class="attribute-name">MouseEvent.buttons</code></a>:
												value based on all buttons current depressed, <code>0</code> if no buttons pressed</li>
											<li><a href="#widl-MouseEvent-relatedTarget"><code class="attribute-name">MouseEvent.relatedTarget</code></a>:
												<code>null</code></li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when the primary button
								of a pointing device is clicked twice over an element. The definition of a double click depends on the environment
								configuration, except that the event target MUST be the same between
								<a class="eventtype" href="#event-type-mousedown"><code>mousedown</code></a>,
								<a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a>, and
								<a class="eventtype" href="#event-type-dblclick"><code>dblclick</code></a>.
								This event type MUST be dispatched after the event type
								<a class="eventtype" href="#event-type-click"><code>click</code></a>
								if a click and double click occur simultaneously,
								and after the event type <a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a> otherwise.
								</p>

							<p class="note"><strong>Note:</strong> As with the <code>click</code> event, the <code>dblclick</code> event
								should only be fired for the primary pointer button.
								Secondary buttons MUST NOT fire <code>dblclick</code> events.
								</p>

							<p class="note"><strong>Note:</strong> Canceling the
								<a class="eventtype" href="#event-type-click"><code>click</code></a> event does not affect the firing
								of a <a class="eventtype" href="#event-type-dblclick"><code>dblclick</code></a> event.
								</p>

							<p>As with the <a class="eventtype" href="#event-type-click"><code>click</code></a> event type, the
								<a class="def" href="#glossary-default-action">default action</a>
								of the <a class="eventtype" href="#event-type-dblclick"><code>dblclick</code></a> event type varies based on the
								<a class="def" href="#glossary-event-target">event target</a> of the event and the value of the
								<a href="#widl-MouseEvent-button"><code>MouseEvent.button</code></a> or
								<a href="#widl-MouseEvent-buttons"><code>MouseEvent.buttons</code></a> attributes.
								Normally, the typical <a class="def" href="#glossary-default-action">default actions</a> of the
								<a class="eventtype" href="#event-type-dblclick"><code>dblclick</code></a> event type match those of the
								<a class="eventtype" href="#event-type-click"><code>click</code></a> event type, with the following additional
								behavior:
								</p>

							<ul>
								<li>If the <a class="def" href="#glossary-event-target">event target</a> is selectable, the <a class="def" href="#glossary-default-action">default action</a> MUST
									be to select part or all of the selectable content. Subsequent clicks MAY select additional selectable portions of that content.</li>
							</ul>
						</dd>
					</dl>
				</div>

				<!-- mousedown -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-mousedown"><dfn><a class="eventtype" href="#event-type-mousedown"><code>mousedown</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>mousedown</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>Varies: Start a drag/drop operation; start a text selection; start a scroll/pan interaction (in combination with the middle mouse button, if supported)</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-topmost-event-target">topmost event target</a></li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												indicates the <a href="#current-click-count">current click count</a> incremented by one. For example, if no click happened
												before the <a class="eventtype"><code>mousedown</code></a>, <a href="#widl-UIEvent-detail"><code>UIEvent.detail</code></a>
												will contain the value <code>1</code></li>
											<li><a href="#widl-MouseEvent-screenX"><code class="attribute-name">MouseEvent.screenX</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-screenY"><code class="attribute-name">MouseEvent.screenY</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-clientX"><code class="attribute-name">MouseEvent.clientX</code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-clientY"><code class="attribute-name">MouseEvent.clientY </code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-altKey"><code class="attribute-name">MouseEvent.altKey</code></a>:
												<code>true</code> if <code class="key">'Alt'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-ctrlKey"><code class="attribute-name">MouseEvent.ctrlKey</code></a>:
												<code>true</code> if <code class="key">'Control'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-shiftKey"><code class="attribute-name">MouseEvent.shiftKey</code></a>:
												<code>true</code> if <code class="key">'Shift'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-metaKey"><code class="attribute-name">MouseEvent.metaKey</code></a>:
												<code>true</code> if <code class="key">'Meta'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-button"><code class="attribute-name">MouseEvent.button</code></a>:
												value based on current button pressed</li>
											<li><a href="#widl-MouseEvent-buttons"><code class="attribute-name">MouseEvent.buttons</code></a>:
												value based on all buttons current depressed, <code>0</code> if no buttons pressed</li>
											<li><a href="#widl-MouseEvent-relatedTarget"><code class="attribute-name">MouseEvent.relatedTarget</code></a>:
												<code>null</code></li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a pointing device button is pressed over an element.</p>

							<p class="note"><strong>Note: </strong>Many implementations use the <a class="eventtype"><code>mousedown</code></a> event to begin a variety of contextually dependent <a class="def"
								href="#glossary-default-action">default actions</a>. These default actions can be prevented if this event is canceled. Some of these default actions could include: beginning
								a drag/drop interaction with an image or link, starting text selection, etc. Additionally, some implementations provide a mouse-driven panning feature that is activated when
								the middle mouse button is pressed at the time the <a class="eventtype"><code>mousedown</code></a> event is dispatched.</p>

						</dd>
					</dl>
				</div>

				<!-- mouseenter -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-mouseenter"><dfn><a class="eventtype" href="#event-type-mouseenter"><code>mouseenter</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>mouseenter</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-topmost-event-target">topmost event target</a></li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
											<li><a href="#widl-MouseEvent-screenX"><code class="attribute-name">MouseEvent.screenX</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-screenY"><code class="attribute-name">MouseEvent.screenY</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-clientX"><code class="attribute-name">MouseEvent.clientX</code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-clientY"><code class="attribute-name">MouseEvent.clientY </code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-altKey"><code class="attribute-name">MouseEvent.altKey</code></a>:
												<code>true</code> if <code class="key">'Alt'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-ctrlKey"><code class="attribute-name">MouseEvent.ctrlKey</code></a>:
												<code>true</code> if <code class="key">'Control'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-shiftKey"><code class="attribute-name">MouseEvent.shiftKey</code></a>:
												<code>true</code> if <code class="key">'Shift'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-metaKey"><code class="attribute-name">MouseEvent.metaKey</code></a>:
												<code>true</code> if <code class="key">'Meta'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-button"><code class="attribute-name">MouseEvent.button</code></a>:
												<code>0</code></li>
											<li><a href="#widl-MouseEvent-buttons"><code class="attribute-name">MouseEvent.buttons</code></a>:
												value based on all buttons current depressed, <code>0</code> if no buttons pressed</li>
											<li><a href="#widl-MouseEvent-relatedTarget"><code class="attribute-name">MouseEvent.relatedTarget</code></a>:
												indicates the <a class="def" href="#glossary-event-target">event target</a> a pointing device is exiting, if any.</li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a pointing device is moved onto the boundaries of an element or one of
								its descendent elements.  This event type is similar to <a class="eventtype" href="#event-type-mouseover"><code>mouseover</code></a>, but differs in that it does
								not bubble, and MUST NOT be dispatched when the pointer device moves from an element onto the boundaries of one of its descendent elements.</p>

							<p class="note"><strong>Note:</strong> There are similarities between this event type and the CSS <a href="http://www.w3.org/TR/CSS2/selector.html#dynamic-pseudo-classes"
								title="Selectors"><code>:hover</code> pseudo-class</a> <a href="#references-CSS2">[CSS2.1]</a>.  See also the <a class="eventtype" href="#event-type-mouseleave"><code>
								mouseleave</code></a> event type.</p>

						</dd>
					</dl>
				</div>

				<!-- mouseleave -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-mouseleave"><dfn><a class="eventtype" href="#event-type-mouseleave"><code>mouseleave</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>mouseleave</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-topmost-event-target">topmost event target</a></li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
											<li><a href="#widl-MouseEvent-screenX"><code class="attribute-name">MouseEvent.screenX</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-screenY"><code class="attribute-name">MouseEvent.screenY</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-clientX"><code class="attribute-name">MouseEvent.clientX</code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-clientY"><code class="attribute-name">MouseEvent.clientY </code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-altKey"><code class="attribute-name">MouseEvent.altKey</code></a>:
												<code>true</code> if <code class="key">'Alt'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-ctrlKey"><code class="attribute-name">MouseEvent.ctrlKey</code></a>:
												<code>true</code> if <code class="key">'Control'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-shiftKey"><code class="attribute-name">MouseEvent.shiftKey</code></a>:
												<code>true</code> if <code class="key">'Shift'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-metaKey"><code class="attribute-name">MouseEvent.metaKey</code></a>:
												<code>true</code> if <code class="key">'Meta'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-button"><code class="attribute-name">MouseEvent.button</code></a>:
												<code>0</code></li>
											<li><a href="#widl-MouseEvent-buttons"><code class="attribute-name">MouseEvent.buttons</code></a>:
												value based on all buttons current depressed, <code>0</code> if no buttons pressed</li>
											<li><a href="#widl-MouseEvent-relatedTarget"><code class="attribute-name">MouseEvent.relatedTarget</code></a>:
												indicates the <a class="def" href="#glossary-event-target">event target</a> a pointing device is entering, if any.</li>
										</ul>
									</td>
								</tr>
							</table>
							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a pointing device is moved off of the boundaries of an element and all
								of its descendent elements.  This event type is similar to <a class="eventtype" href="#event-type-mouseout"><code>mouseout</code></a>, but differs in that does
								not bubble, and that it MUST NOT be dispatched until the pointing device has left the boundaries of the element and the boundaries of all of its children.</p>

							<p class="note"><strong>Note:</strong> There are similarities between this event type and the CSS <a href="http://www.w3.org/TR/CSS2/selector.html#dynamic-pseudo-classes"
								title="Selectors"><code>:hover</code> pseudo-class</a> <a href="#references-CSS2">[CSS2.1]</a>.  See also the <a class="eventtype" href="#event-type-mouseenter"><code>
								mouseenter</code></a> event type.</p>
						</dd>
					</dl>
				</div>

				<!-- mousemove -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-mousemove"><dfn><a class="eventtype" href="#event-type-mousemove"><code>mousemove</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>mousemove</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-topmost-event-target">topmost event target</a></li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
											<li><a href="#widl-MouseEvent-screenX"><code class="attribute-name">MouseEvent.screenX</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-screenY"><code class="attribute-name">MouseEvent.screenY</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-clientX"><code class="attribute-name">MouseEvent.clientX</code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-clientY"><code class="attribute-name">MouseEvent.clientY </code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-altKey"><code class="attribute-name">MouseEvent.altKey</code></a>:
												<code>true</code> if <code class="key">'Alt'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-ctrlKey"><code class="attribute-name">MouseEvent.ctrlKey</code></a>:
												<code>true</code> if <code class="key">'Control'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-shiftKey"><code class="attribute-name">MouseEvent.shiftKey</code></a>:
												<code>true</code> if <code class="key">'Shift'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-metaKey"><code class="attribute-name">MouseEvent.metaKey</code></a>:
												<code>true</code> if <code class="key">'Meta'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-button"><code class="attribute-name">MouseEvent.button</code></a>:
												<code>0</code></li>
											<li><a href="#widl-MouseEvent-buttons"><code class="attribute-name">MouseEvent.buttons</code></a>:
												value based on all buttons current depressed, <code>0</code> if no buttons pressed</li>
											<li><a href="#widl-MouseEvent-relatedTarget"><code class="attribute-name">MouseEvent.relatedTarget</code></a>:
												<code>null</code></li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a pointing device is moved while it is over an element.  The frequency
								rate of events while the pointing device is moved is implementation-, device-, and platform-specific, but multiple consecutive <a class="eventtype" href="#event-type-mousemove">
								<code>mousemove</code></a> events SHOULD be fired for sustained pointer-device movement, rather than a single event for each instance of mouse movement.  Implementations
								are encouraged to determine the optimal frequency rate to balance responsiveness with performance.</p>

							<p class="note"><strong>Authoring Note: </strong>In some implementation environments, such as a browser, <a class="eventtype"><code>mousemove</code></a> events can continue
								to fire if the user began a drag operation (e.g., a mouse button is pressed) and the pointing device has left the boundary of the user agent.</p>

							<p class="note" id="mousemove-now-cancelable"><strong>Note: </strong>This event was formerly specified to be non-cancelable in DOM Level 2 Events
								[<a href="#references-DOM2Events">DOM2 Events</a>], but was changed to reflect existing interoperability between 
								user agents.
						</dd>
					</dl>
				</div>

				<!-- mouseout -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-mouseout"><dfn><a class="eventtype" href="#event-type-mouseout"><code>mouseout</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>mouseout</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-topmost-event-target">topmost event target</a></li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
											<li><a href="#widl-MouseEvent-screenX"><code class="attribute-name">MouseEvent.screenX</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-screenY"><code class="attribute-name">MouseEvent.screenY</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-clientX"><code class="attribute-name">MouseEvent.clientX</code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-clientY"><code class="attribute-name">MouseEvent.clientY </code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-altKey"><code class="attribute-name">MouseEvent.altKey</code></a>:
												<code>true</code> if <code class="key">'Alt'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-ctrlKey"><code class="attribute-name">MouseEvent.ctrlKey</code></a>:
												<code>true</code> if <code class="key">'Control'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-shiftKey"><code class="attribute-name">MouseEvent.shiftKey</code></a>:
												<code>true</code> if <code class="key">'Shift'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-metaKey"><code class="attribute-name">MouseEvent.metaKey</code></a>:
												<code>true</code> if <code class="key">'Meta'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-button"><code class="attribute-name">MouseEvent.button</code></a>:
												<code>0</code></li>
											<li><a href="#widl-MouseEvent-buttons"><code class="attribute-name">MouseEvent.buttons</code></a>:
												value based on all buttons current depressed, <code>0</code> if no buttons pressed</li>
											<li><a href="#widl-MouseEvent-relatedTarget"><code class="attribute-name">MouseEvent.relatedTarget</code></a>: 
												indicates the <a class="def" href="#glossary-event-target">event target</a> a pointing device is entering, if any.</li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a pointing device is moved off of the boundaries of an element.  This
								event type is similar to <a class="eventtype" href="#event-type-mouseleave"><code>mouseleave</code></a>, but differs in that does bubble, and that it MUST be dispatched
								when the pointer device moves from an element onto the boundaries of one of its descendent elements.</p>

							<p class="note"><strong>Note:</strong> See also the <a class="eventtype" href="#event-type-mouseover"><code>mouseover</code></a> event type.</p>
						</dd>
					</dl>
				</div>

				<!-- mouseover -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-mouseover"><dfn><a class="eventtype" href="#event-type-mouseover"><code>mouseover</code></a></dfn></dt>
						<dd>
							<table summary="This table contains information about the semantics of the given event type" border="0" cellpadding="2" cellspacing="0">
								<tbody>
									<tr>
										<th>Type</th>
										<td><strong><code>mouseover</code></strong></td>
									</tr>
									<tr>
										<th>Interface</th>
										<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
									</tr>
									<tr>
										<th>Sync / Async</th>
										<td>Sync</td>
									</tr>
									<tr>
										<th>Bubbles</th>
										<td>Yes</td>
									</tr>
									<tr>
										<th>Trusted Targets</th>
										<td><code>Element</code></td>
									</tr>
									<tr>
										<th>Cancelable</th>
										<td>Yes</td>
									</tr>
									<tr>
										<th>Default action</th>
										<td>None</td>
									</tr>
									<tr>
										<th>Context<br/>(trusted events)</th>
										<td>
											<ul>
												<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
													<a class="def" href="#glossary-topmost-event-target">topmost event target</a></li>
												<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
													<a class="def" href="#glossary-window"><code>Window</code></a></li>
												<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
													<code>0</code></li>
												<li><a href="#widl-MouseEvent-screenX"><code class="attribute-name">MouseEvent.screenX</code></a>:
													value based on the pointer position on the screen</li>
												<li><a href="#widl-MouseEvent-screenY"><code class="attribute-name">MouseEvent.screenY</code></a>:
													value based on the pointer position on the screen</li>
												<li><a href="#widl-MouseEvent-clientX"><code class="attribute-name">MouseEvent.clientX</code></a>:
													value based on the pointer position within the viewport</li>
												<li><a href="#widl-MouseEvent-clientY"><code class="attribute-name">MouseEvent.clientY </code></a>:
													value based on the pointer position within the viewport</li>
												<li><a href="#widl-MouseEvent-altKey"><code class="attribute-name">MouseEvent.altKey</code></a>:
													<code>true</code> if <code class="key">'Alt'</code> modifier was active, otherwise <code>false</code></li>
												<li><a href="#widl-MouseEvent-ctrlKey"><code class="attribute-name">MouseEvent.ctrlKey</code></a>:
													<code>true</code> if <code class="key">'Control'</code> modifier was active, otherwise <code>false</code></li>
												<li><a href="#widl-MouseEvent-shiftKey"><code class="attribute-name">MouseEvent.shiftKey</code></a>:
													<code>true</code> if <code class="key">'Shift'</code> modifier was active, otherwise <code>false</code></li>
												<li><a href="#widl-MouseEvent-metaKey"><code class="attribute-name">MouseEvent.metaKey</code></a>:
													<code>true</code> if <code class="key">'Meta'</code> modifier was active, otherwise <code>false</code></li>
												<li><a href="#widl-MouseEvent-button"><code class="attribute-name">MouseEvent.button</code></a>:
													<code>0</code></li>
												<li><a href="#widl-MouseEvent-buttons"><code class="attribute-name">MouseEvent.buttons</code></a>:
													value based on all buttons current depressed, <code>0</code> if no buttons pressed</li>
												<li><a href="#widl-MouseEvent-relatedTarget"><code class="attribute-name">MouseEvent.relatedTarget</code></a>:
													indicates the <a class="def" href="#glossary-event-target">event target</a> a pointing device is exiting, if any.</li>
											</ul>
										</td>
									</tr>
								</tbody>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a pointing device is moved onto the boundaries of an element.  This event
								type is similar to <a class="eventtype" href="#event-type-mouseenter"><code>mouseenter</code></a>, but differs in that it bubbles, and that it MUST be dispatched
								when the pointer device moves onto the boundaries of an element whose ancestor element is the <a class="def" href="#glossary-event-target">event target</a> for
								the same event listener instance.</p>

							<p class="note"><strong>Note:</strong> See also the <a class="eventtype" href="#event-type-mouseout"><code>mouseout</code></a> event type.</p>
						</dd>
					</dl>
				</div>

				<!-- mouseup -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-mouseup"><dfn><a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>mouseup</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-MouseEvent"><code>MouseEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>Invoke a context menu (in combination with the right mouse button, if supported)</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-topmost-event-target">topmost event target</a></li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												indicates the <a href="#current-click-count">current click count</a> incremented by one.</li>
											<li><a href="#widl-MouseEvent-screenX"><code class="attribute-name">MouseEvent.screenX</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-screenY"><code class="attribute-name">MouseEvent.screenY</code></a>:
												value based on the pointer position on the screen</li>
											<li><a href="#widl-MouseEvent-clientX"><code class="attribute-name">MouseEvent.clientX</code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-clientY"><code class="attribute-name">MouseEvent.clientY </code></a>:
												value based on the pointer position within the viewport</li>
											<li><a href="#widl-MouseEvent-altKey"><code class="attribute-name">MouseEvent.altKey</code></a>:
												<code>true</code> if <code class="key">'Alt'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-ctrlKey"><code class="attribute-name">MouseEvent.ctrlKey</code></a>:
												<code>true</code> if <code class="key">'Control'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-shiftKey"><code class="attribute-name">MouseEvent.shiftKey</code></a>:
												<code>true</code> if <code class="key">'Shift'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-metaKey"><code class="attribute-name">MouseEvent.metaKey</code></a>:
												<code>true</code> if <code class="key">'Meta'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-button"><code class="attribute-name">MouseEvent.button</code></a>:
												value based on current button pressed</li>
											<li><a href="#widl-MouseEvent-buttons"><code class="attribute-name">MouseEvent.buttons</code></a>:
												value based on all buttons current depressed, <code>0</code> if no buttons pressed</li>
											<li><a href="#widl-MouseEvent-relatedTarget"><code class="attribute-name">MouseEvent.relatedTarget</code></a>:
												<code>null</code></li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a pointing device button is released over an element.</p>

							<p class="note"><strong>Note: </strong>Many implementations will invoke a context menu as the default action of this event if the right mouse button is being released.</p>

							<p class="note"><strong>Authoring Note: </strong>In some implementation environments,
								such as a browser, a <a class="eventtype"><code>mouseup</code></a> event
								can be dispatched even if the pointing device has left the boundary of the user
								agent, e.g., if the user began a drag operation with a mouse button pressed.</p>
						</dd>
					</dl>
				</div>
			</section>  <!-- events-mouseevents -->

			<section id="events-wheelevents">
				<h3>Wheel Event Types</h3>
				<p>Wheels are devices that can be rotated in one or more spatial dimensions, and which can be associated with a pointer device. The coordinate system depends on the
					environment configuration.</p>

				<div class="example">
					<div class="example-title"></div>
					<p>The user's environment might be configured to associate vertical scrolling
						with rotation along the y-axis, horizontal scrolling with rotation along
						the x-axis, and zooming with rotation along the z-axis.
						</p>
				</div>

				<p>The deltaX, deltaY, and deltaZ attributes of
					<a href="#interface-WheelEvent"><code>WheelEvent</code></a> objects indicate a
					measurement along their respective axes in units of pixels, lines, or pages.
					The reported measurements are provided after an environment-specific algorithm
					translates the actual rotation/movement of the wheel device into the appropriate
					values and units.
					</p>

				<p class="note"><strong>Authoring Note:</strong>
					A user's environment settings can be customized to interpret actual rotation/movement
					of a wheel device in different ways.
					One movement of a common <q>dented</q> mouse wheel can produce a measurement of 162 pixels
					(162 is just an example value, actual values can depend on the current screen
					dimensions of the user-agent).
					But a user can change their default environment settings to speed-up their mouse wheel,
					increasing this number.
					Furthermore, some mouse wheel software can support acceleration (the faster the wheel
					is rotated/moved, the greater the <a class="def" href="#glossary-delta">delta</a> of each measurement) or even sub-pixel <a class="def" href="#glossary-rotation">rotation</a>
					measurements.
					Because of this, authors can not assume a given <a class="def" href="#glossary-rotation">rotation</a> amount in one user agent will
					produce the same <a class="def" href="#glossary-delta">delta</a> value in all user agents.
					</p>

				<p>The sign (positive or negative) of the values of the deltaX, deltaY, and deltaZ attributes
					MUST be consistent between multiple dispatches of the
					<a class="eventtype" href="#event-type-wheel"><code>wheel</code></a> event while the
					motion of the actual wheel device is rotating/moving in the same direction.
					If a user agent scrolls as the default action of the
					<a class="eventtype" href="#event-type-wheel"><code>wheel</code></a> event then the sign
					of the <a class="def" href="#glossary-delta">delta</a> SHOULD be given by a right-hand coordinate system where positive X,
					Y, and Z axes are directed towards the right-most edge, bottom-most edge, and farthest
					depth (away from the user) of the document, respectively.
					</p>

				<p class="note"><strong>Note:</strong>
					Individual user agents can (depending on their environment and hardware configuration)
					interpret the same physical user interaction on the wheel differently.
					For example, a vertical swipe on the edge of a trackpad from top to bottom can be
					interpreted as a wheel action intended to either scroll the
					page down or to pan the page up (i.e., resulting in either a positive or negative
					deltaY value respectively).
					</p>

				<section id="interface-WheelEvent">
					<h4>Interface WheelEvent</h4>

					<p class="intro-dom">Introduced in DOM Level 3</p>

					<p>The <code>WheelEvent</code> interface provides specific contextual information
						associated with <a class="eventtype" href="#event-type-wheel"><code>wheel</code></a>
						events.
						</p>

					<p>To create an instance of the <code>WheelEvent</code> interface, use the
						<a href="#widl-DocumentEvent-createEvent"><code>DocumentEvent.createEvent("WheelEvent")</code></a>
						method call.
						</p>

					<dl class="idl" title="[Constructor(DOMString typeArg, optional WheelEventInit wheelEventInitDict)] interface WheelEvent : MouseEvent">
						<dt>// DeltaModeCode</dt>

						<dt>const unsigned long DOM_DELTA_PIXEL = 0x00</dt>
						<dd>
							<p>The units of measurement for the <a href="#glossary-delta">delta</a> MUST be
								pixels. This is the most typical case in most operating system and implementation
								configurations.
								</p>
						</dd>

						<dt>const unsigned long DOM_DELTA_LINE  = 0x01</dt>
						<dd>
							<p>The units of measurement for the <a href="#glossary-delta">delta</a> MUST be
								individual lines of text.  This is the case for many form controls.
								</p>
						</dd>

						<dt>const unsigned long DOM_DELTA_PAGE  = 0x02</dt>
						<dd>
							<p>The units of measurement for the <a href="#glossary-delta">delta</a> MUST be
								pages, either defined as a single screen or as a demarcated page.
								</p>
						</dd>

						<dt>readonly attribute double deltaX</dt>
						<dd>
							<p>In user agents where the default action of the
								<a class="eventtype" href="#event-type-wheel"><code>wheel</code></a> event is to scroll,
								the value MUST be the measurement along the x-axis (in pixels, lines, or pages) to be scrolled
								in the case where the event is not cancelled. Otherwise, this is an implementation-specific
								measurement (in pixels, lines, or pages) of the movement of a wheel device around the x-axis.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute
								MUST be <code>0.0</code>.
								</p>
						</dd>

						<dt>readonly attribute double deltaY</dt>
						<dd>
							<p>In user agents where the default action of the
								<a class="eventtype" href="#event-type-wheel"><code>wheel</code></a> event is to scroll, the value
								MUST be the measurement along the y-axis (in pixels, lines, or pages) to be scrolled in the case
								where the event is not cancelled. Otherwise, this is an implementation-specific
								measurement (in pixels, lines, or pages) of the movement of a wheel device around the y-axis.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute
								MUST be <code>0.0</code>.
								</p>
						</dd>

						<dt>readonly attribute double deltaZ</dt>
						<dd>
							<p>In user agents where the default action of the
								<a class="eventtype" href="#event-type-wheel"><code>wheel</code></a> event is to scroll, the value
								MUST be the measurement along the z-axis (in pixels, lines, or pages) to be scrolled in the case
								where the event is not cancelled. Otherwise, this is an implementation-specific
								measurement (in pixels, lines, or pages) of the movement of a wheel device around the z-axis.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute
								MUST be <code>0.0</code>.
								</p>
						</dd>

						<dt>readonly attribute unsigned long deltaMode</dt>
						<dd>
							<p>The <code>deltaMode</code> attribute contains an indication of the units of measurement for the
								<a href="#glossary-delta">delta</a> values.
								The default value is
									<a href="#widl-WheelEvent-DOM_DELTA_PIXEL"><code class="constant-name">DOM_DELTA_PIXEL</code></a>
								(pixels).
								</p>

							<p>This attribute MUST be set to one of the DOM_DELTA constants to indicate the units of measurement
								for the <a href="#glossary-delta">delta</a> values.  The precise measurement
								is specific to device, operating system, and application configurations.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute
								MUST be <code>0</code>.
								</p>
						</dd>

					</dl>

					<dl class="idl" title="dictionary WheelEventInit : MouseEventInit">
						<dt>double deltaX = 0.0</dt>
						<dd><p>See <code>deltaZ</code> attribute.</p></dd>

						<dt>double deltaY = 0.0</dt>
						<dd><p>See <code>deltaZ</code> attribute.</p></dd>

						<dt>double deltaZ = 0.0</dt>
						<dd>
							<p>Initializes the <code>deltaZ</code> attribute of the WheelEvent object.
								Relative positive values for this attribute (as well as the 
								<code>deltaX</code> and <code>deltaY</code> attributes) are given by 
								a right-hand coordinate system where the X, Y, and Z axes are 
								directed towards the right-most edge, bottom-most edge, and farthest 
								depth (away from the user) of the document, respectively. Negative 
								relative values are in the respective opposite directions.
								</p>
						</dd>

						<dt>unsigned long deltaMode = 0</dt>
						<dd>
							<p>Initializes the <code>deltaMode</code> attribute on the WheelEvent 
								object to the enumerated values 0, 1, or 2, which represent the amount
								of pixels scrolled
								(<a href="#widl-WheelEvent-DOM_DELTA_PIXEL"><code class="constant-name">DOM_DELTA_PIXEL</code></a>),
								lines scrolled
								(<a href="#widl-WheelEvent-DOM_DELTA_LINE"><code class="constant-name">DOM_DELTA_LINE</code></a>),
								or pages scrolled
								(<a href="#widl-WheelEvent-DOM_DELTA_PAGE"><code class="constant-name">DOM_DELTA_PAGE</code></a>)
								if the <a class="def" href="#glossary-rotation">rotation</a> of the wheel would 
								have resulted in scrolling.
								</p>
						</dd>
					</dl>

				</section>  <!-- interface-WheelEvent -->

				<p>The Wheel event types are listed below.</p>

				<!-- wheel -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-wheel"><dfn><a class="eventtype" href="#event-type-wheel"><code>wheel</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>wheel</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-WheelEvent"><code>WheelEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Async</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>Scroll (or zoom) the document</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-topmost-event-target">topmost event target</a></li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
											<li><a href="#widl-MouseEvent-screenX"><code class="attribute-name">MouseEvent.screenX</code></a>:
												if the wheel is associated with a pointing device, the value based on the pointer position on the screen, otherwise <code>0</code></li>
											<li><a href="#widl-MouseEvent-screenY"><code class="attribute-name">MouseEvent.screenY</code></a>:
												if the wheel is associated with a pointing device, the value based
												on the pointer position on the screen, otherwise <code>0</code></li>
											<li><a href="#widl-MouseEvent-clientX"><code class="attribute-name">MouseEvent.clientX</code></a>:
												if the wheel is associated with a pointing device, the value based
												on the pointer position within the viewport, otherwise <code>0</code></li>
											<li><a href="#widl-MouseEvent-clientY"><code class="attribute-name">MouseEvent.clientY </code></a>:
												if the wheel is associated with a pointing device, the value
												based on the pointer position within the viewport, otherwise <code>0</code></li>
											<li><a href="#widl-MouseEvent-altKey"><code class="attribute-name">MouseEvent.altKey</code></a>:
												<code>true</code> if <code class="key">'Alt'</code>
												modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-ctrlKey"><code class="attribute-name">MouseEvent.ctrlKey</code></a>:
												<code>true</code> if <code class="key">'Control'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-shiftKey"><code class="attribute-name">MouseEvent.shiftKey</code></a>:
												<code>true</code> if <code class="key">'Shift'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-metaKey"><code class="attribute-name">MouseEvent.metaKey</code></a>:
												<code>true</code> if <code class="key">'Meta'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-MouseEvent-button"><code class="attribute-name">MouseEvent.button</code></a>:
												if wheel is associated with a pointing device, value based on current button pressed, otherwise <code>0</code></li>
											<li><a href="#widl-MouseEvent-buttons"><code class="attribute-name">MouseEvent.buttons</code></a>:
												if wheel is associated with a pointing device, value based on all buttons current depressed, <code>0</code> if no buttons pressed</li>
											<li><a href="#widl-MouseEvent-relatedTarget"><code class="attribute-name">MouseEvent.relatedTarget</code></a>:
												indicates the <a class="def" href="#glossary-event-target">event target</a> the pointing device is pointing at, if any.</li>
											<li><a href="#widl-WheelEvent-deltaX"><code class="attribute-name">WheelEvent.deltaX</code></a>:
												expected amount that the page will scroll along the x-axis according
												to the deltaMode units; or an implemenation-specific value of movement of a wheel around the x-axis</li>
											<li><a href="#widl-WheelEvent-deltaY"><code class="attribute-name">WheelEvent.deltaY</code></a>:
												expected amount that the page will scroll along the y-axis according
												to the deltaMode units; or an implemenation-specific value of movement of a wheel around the y-axis</li>
											<li><a href="#widl-WheelEvent-deltaZ"><code class="attribute-name">WheelEvent.deltaZ</code></a>:
												expected amount that the page will scroll along the z-axis according
												to the deltaMode units; or an implemenation-specific value of movement of a wheel around the z-axis</li>
											<li><a href="#widl-WheelEvent-deltaMode"><code class="attribute-name">WheelEvent.deltaMode</code></a>:
												unit indicator (pixels, lines, or pages) for the deltaX, deltaY, and deltaZ attributes</li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a mouse wheel has been rotated around any axis, or when an equivalent
								input device (such as a mouse-ball, certain tablets or touchpads, etc.) has emulated such an action. Depending on the platform and input device, diagonal wheel
								<a class="def" href="#glossary-delta">deltas</a> MAY be delivered either as a single <a class="eventtype" href="#event-type-wheel"><code>wheel</code></a> event with multiple non-zero axes or as separate <a class="eventtype" href="#event-type-wheel"><code>wheel</code></a>
								events for each non-zero axis.</p>

							<p>The typical <a class="def" href="#glossary-default-action">default action</a> of the <a class="eventtype" href="#event-type-wheel"><code>wheel</code></a> event
								type is to scroll (or in some cases, zoom) the document by the indicated amount.  If this event is canceled, the implementation MUST NOT scroll or zoom the document
								(or perform whatever other implementation-specific default action is associated with this event type).</p>

							<p class="note"><strong>Note:</strong> In some <a class="def" href="#glossary-user-agent">user agents</a>, or with some input devices, the speed that the wheel has been
								turned can affect the <a href="#glossary-delta">delta</a> values, with a faster speed producing a higher <a href="#glossary-delta">delta</a> value.</p>
						</dd>
					</dl>
				</div>
			</section>  <!-- events-wheelevents -->

			<section id="events-inputevents">
				<h3>Input Event Types</h3>
				<p>Input events are sent as notifications whenever the DOM is being updated.</p>
				
				<section id="interface-InputEvent">
					<h4>Interface InputEvent</h4>

					<p class="intro-dom">Introduced in DOM Level 3</p>

					<dl class="idl" title="[Constructor(DOMString typeArg, optional InputEventInit inputEventInitDict)] interface InputEvent : UIEvent">
						<dt>readonly attribute DOMString data</dt>
						<dd>
							<p><code>data</code> holds the value of the characters generated by an input method.
								This MAY be a single Unicode character or a non-empty sequence of Unicode characters
								[<cite><a class="normative" href="#references-Unicode">Unicode</a></cite>].
								Characters SHOULD be normalized as defined by the Unicode normalization form <em>NFC</em>,
								defined in [<cite><a class="normative" href="#references-UnicodeNormalization">UAX #15</a></cite>].
								This attribute MAY contain the <a class="def" href="#glossary-empty-string">empty string</a>.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute
								MUST be <code>""</code> (the empty string).
								</p>
						</dd>

						<dt>readonly attribute boolean isComposing</dt>
						<dd>
							<p><code>true</code> if the input event occurs as part of a composition session, i.e., after a
								<a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a>
								event and before the corresponding
								<a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a>
								event.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this
								attribute MUST be <code>false</code>.
								</p>
						</dd>

					</dl>
					
					<dl class="idl" title="dictionary InputEventInit : UIEventInit">
						<dt>DOMString data = ""</dt>
						<dd>
							<p>Initializes the <code>data</code> attribute of the InputEvent object.
								</p>
						</dd>

						<dt>boolean isComposing = false</dt>
						<dd>
							<p>Initializes the <code>isComposing</code> attribute of the InputEvent object.
								</p>
						</dd>
					</dl>

				</section>  <!-- interface-InputEvent -->

				<section id="events-inputevent-event-order">
					<h4>Input Event Order</h4>

					<p>The input events defined in this specification MUST occur in a set order relative to one another.
						</p>

					<table class="event-sequence-table">
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td colspan="2"><em>DOM element is updated</em></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-input"><code>input</code></a></td>
							<td></td>
						</tr>
					</table>

				</section>  <!-- events-inputevent-event-order -->
				
				<p>The Input event types are listed below.</p>

				<!-- beforeinput -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-beforeinput"><dfn><a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>beforeinput</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-InputEvent"><code>InputEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Element</code> (specifically: control types such as <code>HTMLInputElement</code>, etc.) or any <code>Element</code> with 
										<code>contenteditable</code> attribute enabled.</td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>Update the DOM element</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-event-target">event target</a> that is about to be updated</li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
											<li><a href="#widl-InputEvent-data"><code class="attribute-name">InputEvent.data</code></a>:
												the string containing the data that will be added to the element,
												which MAY be the <a class="def" href="#glossary-empty-string">empty string</a> if the content has been deleted</li>
											<li><a href="#widl-InputEvent-isComposing"><code class="attribute-name">InputEvent.isComposing</code></a>:
												<code>true</code> if this event is dispatched during a <a href="#keys-dead">dead key</a> sequence or while an 
												<a href="#glossary-ime">input method editor</a> is active (such that 
												<a href="#events-compositionevents">composition events</a> are being dispatched); <code>false</code> otherwise.</li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when the DOM is about to be updated.</p>
						</dd>
					</dl>
				</div><!-- beforeinput -->

				<!-- input -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-input"><dfn><a class="eventtype" href="#event-type-input"><code>input</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>input</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-InputEvent"><code>InputEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Element</code> (specifically: control types such as <code>HTMLInputElement</code>, etc.) or any <code>Element</code> with 
										<code>contenteditable</code> attribute enabled.</td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>No</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												<a class="def" href="#glossary-event-target">event target</a> that was just updated</li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
											<li><a href="#widl-InputEvent-data"><code class="attribute-name">InputEvent.data</code></a>:
												the string containing the data that was added to the element,
												which MAY be the <a class="def" href="#glossary-empty-string">empty string</a> if the content has been deleted</li>
											<li><a href="#widl-InputEvent-isComposing"><code class="attribute-name">InputEvent.isComposing</code></a>:
												<code>true</code> if this event is dispatched during a <a href="#keys-dead">dead key</a> sequence or while an 
												<a href="#glossary-ime">input method editor</a> is active (such that 
												<a href="#events-compositionevents">composition events</a> are being dispatched); <code>false</code> otherwise.</li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event immediately after the DOM has been updated.</p>
						</dd>
					</dl>
				</div><!-- input -->

			</section>  <!-- events-inputevents -->

			<section id="events-keyboardevents">
				<h3>Keyboard Event Types</h3>

				<p>Keyboard events are device dependent, i.e., they rely on the capabilities of the
					input devices and how they are mapped in the operating systems. Refer to
					<a href="#keys">Keyboard events and key values</a> for more details, including
					examples on how Keyboard Events are used in combination with Composition Events.
					Depending on the
					character generation device, keyboard events might not be generated.
					</p>

				<p class="note"><strong>Authoring Note:</strong>
					Keyboard events are only one modality of providing textual input.
					For editing scenarios, consider also using the
						<a href="#interface-InputEvent"><code>InputEvent</code></a>
					as an alternate to (or in addition to) keyboard events.
					</p>

				<section id="interface-KeyboardEvent">
					<h4>Interface KeyboardEvent</h4>

					<p class="intro-dom">Introduced in DOM Level 3</p>

					<p>The <a href="#interface-KeyboardEvent"><code>KeyboardEvent</code></a> interface
						provides specific contextual information associated with keyboard devices.
						Each keyboard event references a key using a value.
						Keyboard events are commonly directed at the element that has the focus.
						</p>

					<p>The <a href="#interface-KeyboardEvent"><code>KeyboardEvent</code></a> interface
						provides convenient attributes for some common modifiers keys:
							<a href="#widl-KeyboardEvent-ctrlKey"><code>KeyboardEvent.ctrlKey</code></a>,
							<a href="#widl-KeyboardEvent-shiftKey"><code>KeyboardEvent.shiftKey</code></a>,
							<a href="#widl-KeyboardEvent-altKey"><code>KeyboardEvent.altKey</code></a>,
							<a href="#widl-KeyboardEvent-metaKey"><code>KeyboardEvent.metaKey</code></a>.
						These attributes are equivalent to using the method
							<a href="#widl-KeyboardEvent-getModifierState"><code>KeyboardEvent.getModifierState(keyArg)</code></a>
						with
							<code class="key">'Control'</code>,
							<code class="key">'Shift'</code>,
							<code class="key">'Alt'</code>, or
							<code class="key">'Meta'</code>
						respectively.
						</p>

					<p>To create an instance of the <a href="#interface-KeyboardEvent"><code>KeyboardEvent</code></a>
						interface, use the
							<a href="#widl-DocumentEvent-createEvent"><code>DocumentEvent.createEvent("KeyboardEvent")</code></a>
						method call.
						</p>

					<dl class="idl" title="[Constructor(DOMString typeArg, optional KeyboardEventInit keyboardEventInitDict)] interface KeyboardEvent : UIEvent">
						<dt>// KeyLocationCode</dt>

						<dt>const unsigned long DOM_KEY_LOCATION_STANDARD = 0x00</dt>
						<dd>
							<p>The key activation MUST NOT be distinguished as the left or right version of the key, and (other than the 
								<code class="key">'NumLock'</code> key) did not originate from the numeric keypad (or did not originate 
								with a virtual key corresponding to the numeric keypad).</p>

							<div class="example">
								<div class="example-title"></div>
								<p>The <code class="key">'Q'</code> key on a PC 101 Key US keyboard.</p>
								<p>The <code class="key">'NumLock'</code> key on a PC 101 Key US keyboard.</p>
								<p>The <code class="key">'1'</code> key on a PC 101 Key US keyboard located in the main section of the keyboard.</p>
							</div>
						</dd>

						<dt>const unsigned long DOM_KEY_LOCATION_LEFT = 0x01</dt>
						<dd>
							<p>The key activated originated from the left key location (when there is more than one possible location for this key).</p>

							<div class="example">
								<div class="example-title"></div>
								<p>The left <code class="key">'Control'</code> key on a PC 101 Key US keyboard.</p>
							</div>
						</dd>

						<dt>const unsigned long DOM_KEY_LOCATION_RIGHT = 0x02</dt>
						<dd>
							<p>The key activation originated from the right key location (when there is more than one possible location for this key).</p>

							<div class="example">
								<div class="example-title"></div>
								<p>The right <code class="key">'Shift'</code> key on a PC 101 Key US keyboard.</p>
							</div>
						</dd>

						<dt>const unsigned long DOM_KEY_LOCATION_NUMPAD = 0x03</dt>
						<dd>
							<p>The key activation originated on the numeric keypad or with a virtual key corresponding to the numeric 
								keypad (when there is more than one possible location for this key). Note that the <code class="key">'NumLock'</code>
								key should always be encoded with a location of
								<a href="#widl-KeyboardEvent-DOM_KEY_LOCATION_STANDARD"><code class="constant-name">DOM_KEY_LOCATION_STANDARD</code></a>.
								</p>

							<div class="example">
								<div class="example-title"></div>
								<p>The <code class="key">'1'</code> key on a PC 101 Key US keyboard located on the numeric pad.</p>
							</div>
						</dd>

						<dt>readonly attribute DOMString key</dt>
						<dd>
							<p><code>key</code> holds the key value of the key pressed.
								If the value is has a printed representation, it MUST be a non-empty Unicode character
								string, conforming to the <a href="#key-algorithm">algorithm for determining the key value</a> defined in this specification.
								If the value is a control key which has no printed representation, it MUST be one of the key values defined in the
								<a href="#keys-keyvalues">key values set</a>, as determined by the <a href="#key-algorithm">algorithm for determining the key value</a>. Implementations that are
								unable to identify a key MUST use the key value <code class="key">'Unidentified'</code>.</p>

							<p class="note"><strong>Note:</strong> The <code>key</code> attribute is not related to the legacy <code>keyCode</code> attribute and does not have the same set of values.</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>""</code> (the empty string).</p>
						</dd>

						<dt>readonly attribute DOMString code</dt>
						<dd>
							<p><code>code</code> holds a string that identifies the physical key being pressed.
							   The value is not affected by the current keyboard layout or modifier state, so a particular
							   key will always return the same value.
							</p>
							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>""</code> (the empty string).</p>
						</dd>

						<dt>readonly attribute unsigned long location</dt>
						<dd>
							<p>The <code>location</code> attribute contains an indication of the location of the key on the device.</p>

							<p>This attribute MUST be set to one of the DOM_KEY_LOCATION constants to indicate the location of a key on the device. In case a DOM implementation wishes to provide a new location value, a
								value different from the defined constant values MUST be used.</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>0</code>.</p>
						</dd>

						<dt>readonly attribute boolean ctrlKey</dt>
						<dd>
							<p><code>true</code> if the <code class="key">'Control'</code> (control) key modifier was active.</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>false</code>.</p>
						</dd>

						<dt>readonly attribute boolean shiftKey</dt>
						<dd>
							<p><code>true</code> if the shift (<code class="key">'Shift'</code>) key modifier was active.</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>false</code>.</p>
						</dd>

						<dt>readonly attribute boolean altKey</dt>
						<dd>
							<p><code>true</code> if the <code class="key">'Alt'</code> (alternative) (or <code class="glyph">'Option'</code>) key modifier was active.</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>false</code>.</p>
						</dd>

						<dt>readonly attribute boolean metaKey</dt>
						<dd>
							<p><code>true</code> if the meta (<code class="key">'Meta'</code>) key modifier was active.</p>

							<p class="note"><strong>Note:</strong> The <code class="glyph">'Command'</code> (<code class="glyph">'&#x2318;'</code>) key modifier on Macintosh systems is represented using this key modifier.</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>false</code>.</p>
						</dd>

						<dt>readonly attribute boolean repeat</dt>
						<dd>
							<p><code>true</code> if the key has been pressed in a sustained manner.  Holding down a key MUST result in the repeating the events
								<a class="eventtype" href="#event-type-keydown"><code>keydown</code></a>,
								<a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a>,
								<a class="eventtype" href="#event-type-input"><code>input</code></a>
								in this order, at a rate determined by the system configuration. For mobile devices which have <em>long-key-press</em>
								behavior, the first key event with a <a href="#widl-KeyboardEvent-repeat"><code>repeat</code></a> attribute value of <code>'true'</code> MUST serve as an
								indication of a <em>long-key-press</em>. The length of time that the key MUST be pressed in order to begin repeating is configuration-dependent.</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute MUST be <code>false</code>.</p>
						</dd>

						<dt>readonly attribute boolean isComposing</dt>
						<dd>
							<p><code>true</code> if the key event occurs as part of a composition session, i.e., after a
								<a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a>
								event and before the corresponding
								<a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a>
								event.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this
								attribute MUST be <code>false</code>.
								</p>
						</dd>

						<dt>boolean getModifierState()</dt>
						<dd>
							<p>Queries the state of a modifier using a key value.
								See <a href="#keys-modifiers">Modifier keys</a> for a list of valid (case-sensitive) arguments to this method.
								</p>

							<dl class="parameters">
								<dt>DOMString keyArg</dt>
								<dd>
									<p>A modifier key value.  Valid modifier keys are defined in the
										<a href="DOM3Events-key.html#keys-modifier">Modifier Keys</a> table in
										[<a href="#references-D3E-key">DOM3 key Values</a>].
										</p>

									<p>Returns <code>true</code> if it is a modifier key and the modifier is activated, <code>false</code> otherwise.</p>

									<p class="note"><strong>Note:</strong> If an application wishes to distinguish between right and left modifiers, this information could be
										deduced using keyboard events and <a href="#widl-KeyboardEvent-location"><code>KeyboardEvent.location</code></a>.</p>
								</dd>

							</dl>
						</dd>
					</dl>

					<dl class="idl" title="dictionary KeyboardEventInit : UIEventInit">
						<dt>DOMString key = ""</dt>
						<dd>
							<p>Initializes the <code>key</code> attribute of the KeyboardEvent
								object to the unicode character string representing the meaning of a
								key after taking into account all keyboard modifications (such as 
								shift-state). This value is the final effective value of the key. 
								If the key is not a printable character, then it should be one of
								the key values defined in
								[<a href="#references-D3E-key">DOM3 key Values</a>].
								</p>
						</dd>

						<dt>DOMString code = ""</dt>
						<dd>
							<p>Initializes the <code>code</code> attribute of the KeyboardEvent
								object to the unicode character string representing the key that
								was pressed, ignoring any keyboard modifications such as keyboard
								layout.
								This value should be one of the code values defined in
								[<a href="#references-D3E-code">DOM3 code Values</a>].
								</p>
						</dd>

						<dt>unsigned long location = 0</dt>
						<dd>
							<p>Initializes the <code>location</code> attribute of the KeyboardEvent
								object to one of the following location numerical constants:
								</p>
							<ul>
								<li><code>KeyboardEvent.DOM_KEY_LOCATION_STANDARD</code> (numerical value 0)</li>
								<li><code>KeyboardEvent.DOM_KEY_LOCATION_LEFT</code> (numerical value 1)</li>
								<li><code>KeyboardEvent.DOM_KEY_LOCATION_RIGHT</code> (numerical value 2)</li>
								<li><code>KeyboardEvent.DOM_KEY_LOCATION_NUMPAD</code> (numerical value 3)</li>
							</ul>
						</dd>

						<dt>boolean ctrlKey = false</dt>
						<dd>
							<p>Initializes the <code>altKey</code> attribute of the KeyboardEvent
								object to <code>true</code> if the <code class="key">'Control'</code>
								(control) key modifier is to be considered active, 
								<code>false</code> otherwise.</p>
						</dd>

						<dt>boolean shiftKey = false</dt>
						<dd>
							<p>Initializes the <code>shiftKey</code> attribute of the KeyboardEvent
								object to <code>true</code> if the <code class="key">'Shift'</code>
								key modifier is to be considered active, <code>false</code> otherwise.</p>
						</dd>

						<dt>boolean altKey = false</dt>
						<dd>
							<p>Initializes the <code>altKey</code> attribute of the KeyboardEvent
								object to <code>true</code> if the <code class="key">'Alt'</code>
								(alternative) (or <code class="glyph">'Option'</code>) key modifier 
								is to be considered active, <code>false</code> otherwise.</p>
						</dd>

						<dt>boolean metaKey = false</dt>
						<dd>
							<p>Initializes the <code>metaKey</code> attribute of the KeyboardEvent
								object to <code>true</code> if the <code class="key">'Meta'</code>
								key modifier is to be considered active, <code>false</code> otherwise.</p>
						</dd>

						<dt>boolean repeat = false</dt>
						<dd>
							<p>Initializes the <code>repeat</code> attribute of the KeyboardEvent
								object. This attribute should be set to <code>true</code> if the the current KeyboardEvent is
								considered part of a repeating sequence of similar events caused
								by the long depression of any single key, <code>false</code> otherwise.
								</p>
						</dd>

						<dt>boolean isComposing = false</dt>
						<dd>
							<p>Initializes the <code>isComposing</code> attribute of the KeyboardEvent
								object. This attribute should be set to <code>true</code> if the
								event being constructed occurs as part of a composition sequence,
								<code>false</code> otherwise.
								</p>
						</dd>
					</dl>

				</section>  <!-- interface-KeyboardEvent -->

				<div class="warning">
					<p><strong>Warning!</strong></p>
					<p>Legacy keyboard event implementations include three additional attributes,
						<code>keyCode</code>, <code>charCode</code>, and <code>which</code>.
						The <code>keyCode</code> attribute indicates a numeric value associated with
						a particular key on a computer keyboard,
						while the <code>charCode</code> attribute indicates the
						<acronym title="American Standard Code for Information Interchange">ASCII</acronym>
						value of the character associated with that key (which might be the same as
						the <code>keyCode</code> value) and is applicable only to keys that produce a
						<a class="def" href="#glossary-character-value">character value</a>.
						</p>
					<p>In practice, <code>keyCode</code> and <code>charCode</code> are inconsistent across platforms
						and even the same implementation on different operating systems or using different localizations.
						DOM Level 3 Events  does not define values for either
						<code>keyCode</code> or <code>charCode</code>, or behavior for <code>charCode</code>.
						In conforming DOM Level 3 Events implementations, content authors can instead use
						<a href="#widl-KeyboardEvent-key"><code>KeyboardEvent.key</code></a> and
						<a href="#widl-KeyboardEvent-code"><code>KeyboardEvent.code</code></a>.
						</p>
					<p><em>For more information, see the informative appendix on
						<a href="#legacy-key-attributes">Legacy key attributes</a>.</em>
						</p>
					</div>

				<p class="note"><strong>Note:</strong>
					For compatibility with existing content, virtual keyboards, such as software keyboards
					on screen-based input devices, are expected to produce the normal range of keyboard
					events, even though they do not possess physical keys.
					</p>

				<p class="note"><strong>Note:</strong>
					In some implementations or system configurations, some key events, or their values,
					might be suppressed by the <a class="def" href="#glossary-ime">IME</a> in use.
					</p>

				<section id="events-keyboard-event-order">
					<h4>Keyboard Event Order</h4>
					<p>The keyboard events defined in this specification occur in a set order relative
						to one another, for any given key:</p>

					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a></td>
							<td><em>(only for keys which produce a <a class="def" href="#glossary-character-value">character value</a>)</em></td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td><em>Any <a class="def" href="#glossary-default-action">default actions</a> related to this key, such as inserting a
								character in to the DOM.</em></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-input"><code>input</code></a></td>
							<td><em>(only for keys which have updated the DOM)</em></td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td><em>Any events as a result of the key being held for a sustained period (see below).</em></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td></td>
						</tr>
					</table>
					
					<p>If the key is depressed for a sustained period, the following events MAY repeat
						at an environment-dependent rate: <!-- and the key should seek counseling -->
						</p>
					
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td><em>(with <a href="#widl-KeyboardEvent-repeat">repeat</a> attribute set to <code> true</code>)</em></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a></td>
							<td><em>(only for keys which produce a <a class="def" href="#glossary-character-value">character value</a>)</em></td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td><em>Any <a class="def" href="#glossary-default-action">default actions</a> related to this key, such as inserting a
								character in to the DOM.</em></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-input"><code>input</code></a></td>
							<td><em>(only for keys which have updated the DOM)</em></td>
						</tr>
					</table>

					<p class="note"><strong>Note:</strong>
						Typically, any <a class="def" href="#glossary-default-action">default actions</a>
						associated with any particular key are completed before the
						<a class="eventtype" href="#event-type-keyup"><code>keyup</code></a> event is dispatched.
						This might delay the <a class="eventtype" href="#event-type-keyup"><code>keyup</code></a>
						event slightly (though this is not likely to be a perceptible delay).
						</p>

					<p>The <a class="def" href="#glossary-event-target">event target</a> of a key event is
						the currently focused element which is processing the keyboard activity.
						This is often an HTML <code>input</code> element or a textual element which is editable,
						but MAY be an element defined by the
						<a class="def" href="#glossary-host-language">host language</a> to accept keyboard input
						for non-text purposes, such as the activation of an accelerator key or trigger of some 
						other behavior. If no suitable element is in focus, the event target will be the HTML
						<a href="#glossary-body-element">body element</a> if available, 
						otherwise the <a href="#glossary-root-element">root element</a>.
						</p>

					<p class="note"><strong>Note:</strong>
						The <a class="def" href="#glossary-event-target">event target</a> might change between
						different key events.
						For example, a <a class="eventtype" href="#event-type-keydown"><code>keydown</code></a>
						event for the <code class="key">'Tab'</code> key
						will likely have a different <a class="def" href="#glossary-event-target">event target</a>
						than the  <a class="eventtype" href="#event-type-keyup"><code>keyup</code></a>
						event on the same keystroke.
						</p>
				</section>  <!-- events-keyboard-event-order -->

				<p>The keyboard event types are listed below.</p>

				<!-- keydown -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-keydown"><dfn><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>keydown</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-KeyboardEvent"><code>KeyboardEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>Varies:
										<a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a> and <a class="eventtype" href="#event-type-input"><code>input</code></a> events;
										launch <a class="def" href="#glossary-text-composition-system">text composition system</a>;
										<a class="eventtype" href="#event-type-blur"><code>blur</code></a> and <a class="eventtype" href="#event-type-focus"><code>focus</code></a> events;
										<a class="eventtype" href="#event-type-keypress"><code>keypress</code></a> event;
										<a class="def" href="#glossary-activation-behavior">activation behavior</a>;
										other event</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												focused element processing the key event or if no element focused, then the 
												<a href="#glossary-body-element">body element</a> if available, otherwise the 
												<a href="#glossary-root-element">root element</a></li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
											<li><a href="#widl-KeyboardEvent-key"><code class="attribute-name">KeyboardEvent.key</code></a>:
												the key value of the key pressed.</li>
											<li><a href="#widl-KeyboardEvent-code"><code class="attribute-name">KeyboardEvent.code</code></a>:
												the code value associated with the key's physical placement on the keyboard.</li>
											<li><a href="#widl-KeyboardEvent-location"><code class="attribute-name">KeyboardEvent.location</code></a>:
												the location of the key on the device.</li>
											<li><a href="#widl-KeyboardEvent-altKey"><code class="attribute-name">KeyboardEvent.altKey</code></a>:
												<code>true</code> if <code class="key">'Alt'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-KeyboardEvent-shiftKey"><code class="attribute-name">KeyboardEvent.shiftKey</code></a>:
												<code>true</code> if <code class="key">'Shift'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-KeyboardEvent-ctrlKey"><code class="attribute-name">KeyboardEvent.ctrlKey</code></a>:
												<code>true</code> if <code class="key">'Control'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-KeyboardEvent-metaKey"><code class="attribute-name">KeyboardEvent.metaKey</code></a>:
												<code>true</code> if <code class="key">'Meta'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-KeyboardEvent-repeat"><code class="attribute-name">KeyboardEvent.repeat</code></a>:
												<code>true</code> if a key has been depressed long enough to trigger key repetition, otherwise <code>false</code></li>
											<li><a href="#widl-KeyboardEvent-isComposing"><code class="attribute-name">KeyboardEvent.isComposing</code></a>:
												<code>true</code> if the key event occurs as part of a composition session, otherwise <code>false</code></li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a key is pressed down. The <a class="eventtype" href="#event-type-keydown">
								<code>keydown</code></a> event type is device dependent and relies on the capabilities of the input devices and how they are mapped in the operating system. This
								event type MUST be generated after the <a class="def" href="#glossary-key-mapping">key mapping</a>.
								This event type MUST be dispatched before the
									<a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a>,
									<a class="eventtype" href="#event-type-input"><code>input</code></a>,
									and <a class="eventtype" href="#event-type-keyup"><code>keyup</code></a>
								events associated with the same key.</p>

							<p>The default action of the <a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> event depends upon the key:</p>

							<ul>
								<li>If the key is associated with a character, the default action MUST be to dispatch
										a <a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a> event
										followed by an <a class="eventtype" href="#event-type-input"><code>input</code></a>
									event.
									In the case where the key which is associated with multiple characters (such as with a macro or certain sequences of dead keys), the default action MUST
									be to dispatch one set of
										<a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a> /
										<a class="eventtype" href="#event-type-input"><code>input</code></a>
									events for each character</li>

								<li>If the key is associated with a <a class="def" href="#glossary-text-composition-system">text composition system</a>, the default action MUST be to launch that
									system</li>

								<li>If the key is the <code class="key">'Tab'</code> key, the default action MUST be to shift the document focus from the currently focused
									element (if any) to the new focused element, as described in <a href="#events-focusevent">Focus Event Types</a></li>

								<li>If the key is the <code class="key">'Enter'</code> or <code class="key">'&nbsp;'</code> key and the
									current focus is on a state-changing element, the default action MUST be to dispatch a <a class="eventtype" href="#event-type-click"><code>click</code></a> event,
									and a <a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a> event if that event type is supported by the <a class="def" href="#glossary-user-agent">
									user agent</a> (refer to <a href="#event-flow-activation">activation triggers and behavior</a> for more details)</li>
							</ul>

							<p>If this event is canceled, the associated event types MUST NOT be dispatched, and the associated actions MUST NOT be performed.</p>

							<p class="note"><strong>Note:</strong> The <a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> and <a class="eventtype" href="#event-type-keyup">
								<code>keyup</code></a> events are traditionally associated with detecting any key, not just those which produce a <a class="def" href="#glossary-character-value">character
								value</a>.</p>
						</dd>
					</dl>
				</div>

				<!-- keyup -->
				<div class="event-definition">
					<dl>
						<dt id="event-type-keyup"><dfn><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></dfn></dt>
						<dd>
							<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
								<tr>
									<th>Type</th>
									<td><strong><code>keyup</code></strong></td>
								</tr>
								<tr>
									<th>Interface</th>
									<td><a href="#interface-KeyboardEvent"><code>KeyboardEvent</code></a></td>
								</tr>
								<tr>
									<th>Sync / Async</th>
									<td>Sync</td>
								</tr>
								<tr>
									<th>Bubbles</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Trusted Targets</th>
									<td><code>Element</code></td>
								</tr>
								<tr>
									<th>Cancelable</th>
									<td>Yes</td>
								</tr>
								<tr>
									<th>Default action</th>
									<td>None</td>
								</tr>
								<tr>
									<th>Context<br/>(trusted events)</th>
									<td>
										<ul>
											<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
												focused element processing the key event or if no element focused, then the 
												<a href="#glossary-body-element">body element</a> if available, otherwise the 
												<a href="#glossary-root-element">root element</a></li>
											<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
												<a class="def" href="#glossary-window"><code>Window</code></a></li>
											<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
												<code>0</code></li>
											<li><a href="#widl-KeyboardEvent-key"><code class="attribute-name">KeyboardEvent.key</code></a>:
												the key value of the key pressed.</li>
											<li><a href="#widl-KeyboardEvent-code"><code class="attribute-name">KeyboardEvent.code</code></a>:
												the code value associated with the key's physical placement on the keyboard.</li>
											<li><a href="#widl-KeyboardEvent-location"><code class="attribute-name">KeyboardEvent.location</code></a>:
												the location of the key on the device.</li>
											<li><a href="#widl-KeyboardEvent-altKey"><code class="attribute-name">KeyboardEvent.altKey</code></a>:
												<code>true</code> if <code class="key">'Alt'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-KeyboardEvent-shiftKey"><code class="attribute-name">KeyboardEvent.shiftKey</code></a>:
												<code>true</code> if <code class="key">'Shift'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-KeyboardEvent-ctrlKey"><code class="attribute-name">KeyboardEvent.ctrlKey</code></a>:
												<code>true</code> if <code class="key">'Control'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-KeyboardEvent-metaKey"><code class="attribute-name">KeyboardEvent.metaKey</code></a>:
												<code>true</code> if <code class="key">'Meta'</code> modifier was active, otherwise <code>false</code></li>
											<li><a href="#widl-KeyboardEvent-repeat"><code class="attribute-name">KeyboardEvent.repeat</code></a>:
												<code>false</code></li>
											<li><a href="#widl-KeyboardEvent-isComposing"><code class="attribute-name">KeyboardEvent.isComposing</code></a>:
												<code>true</code> if the key event occurs as part of a composition session, otherwise <code>false</code></li>
										</ul>
									</td>
								</tr>
							</table>

							<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a key is released.
								The <a class="eventtype" href="#event-type-keyup"><code>keyup</code></a> event type is device dependent and relies on the
								capabilities of the input devices and how they are mapped in the operating system.
								This event type MUST be generated after the <a class="def" href="#glossary-key-mapping">key mapping</a>.
								This event type MUST be dispatched after the
									<a class="eventtype" href="#event-type-keydown"><code>keydown</code></a>,
									<a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a>,
									and <a class="eventtype" href="#event-type-input"><code>input</code></a>
								events associated with the same key.</p>

							<p class="note"><strong>Note:</strong> the <a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> and <a class="eventtype" href="#event-type-keyup">
								<code>keyup</code></a> events are traditionally associated with detecting any key, not just those which produce a <a class="def" href="#glossary-character-value">character
								value</a>.</p>
						</dd>
					</dl>
				</div>
			</section>  <!-- events-keyboardevents -->

			<section id="events-compositionevents">
				<h3>Composition Event Types</h3>

				<p>Composition Events provide a means for inputing text in a supplementary or alternate
					manner than by Keyboard Events, in order to allow the use of characters that
					might not be commonly available on keyboard.
					For example, Composition Events might be used
						to add accents to characters despite their absence from standard US keyboards,
						to build up logograms of many Asian languages from their base components or categories,
						to select word choices from a combination of key presses on a mobile device keyboard,
						or to convert voice commands into text using a speech recognition processor.
					Refer to <a href="#keys">Keyboard events and key values</a> for examples
					on how Composition Events are used in combination with keyboard events.
					</p>

				<p>Conceptually, a composition session consists of one
						<a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a>
					event, one or more
						<a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a>
					events, and one
						<a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a>
					event, with the value of the <a href="#widl-CompositionEvent-data"><code>data</code></a>
					attribute persisting between each <q>stage</q> of this event chain during each session.
					</p>

				<p class="note"><strong>Note:</strong>
					While a composition session is active, keyboard events can be dispatched to the DOM
					if the keyboard is the input device used with the composition session.
					See the <a href="#event-type-compositionstart"><code>compositionstart</code> event details</a>
					and <a href="#keys-IME">IME section</a> for relevent event ordering.
					</p>

				<p>Not all <a class="def" href="#glossary-ime">IME</a> systems or devices expose the necessary
					data to the DOM, so the active composition string (the <q>Reading Window</q>
					or <q>candidate selection menu option</q>) might not be available through this interface,
					in which case the selection MAY be represented by the
					<a class="def" href="#glossary-empty-string">empty string</a>.
					</p>

				<section id="interface-CompositionEvent">
					<h4>Interface CompositionEvent</h4>

					<p class="intro-dom">Introduced in DOM Level 3</p>

					<p>The <code>CompositionEvent</code> interface provides specific contextual information associated with Composition Events.</p>

					<p>To create an instance of the <code>CompositionEvent</code> interface, use the <a href="#widl-DocumentEvent-createEvent"><code>DocumentEvent.createEvent("CompositionEvent")</code></a>
						method call.</p>

					<dl class="idl" title="[Constructor(DOMString typeArg, optional CompositionEventInit compositionEventInitDict)] interface CompositionEvent : UIEvent">
						<dt>readonly attribute DOMString data</dt>
						<dd>
							<p><code>data</code> holds the value of the characters generated by an input method.
								This MAY be a single Unicode character or a non-empty sequence of Unicode characters
								[<cite><a class="normative" href="#references-Unicode">Unicode</a></cite>].
								Characters SHOULD be normalized as defined by the Unicode normalization form <em>NFC</em>,
								defined in [<cite><a class="normative" href="#references-UnicodeNormalization">UAX #15</a></cite>].
								This attribute MAY be the <a class="def" href="#glossary-empty-string">empty string</a>.
								</p>

							<p>The <a class="def" href="#glossary-un-initialized-value">un-initialized value</a> of this attribute
								MUST be <code>""</code> (the empty string).
								</p>
						</dd>
					</dl>

					<dl class="idl" title="dictionary CompositionEventInit : UIEventInit">
						<dt>DOMString data = ""</dt>
						<dd>
							<p>Initializes the <code>data</code> attribute of the CompositionEvent
								object to the characters generated by the IME composition.
								</p>
						</dd>
					</dl>

				</section>  <!-- interface-CompositionEvent -->

				<section id="events-composition-event-order">
					<h4>Composition Event Order</h4>

					<p>The Composition Events defined in this specification MUST occur in the following set order relative to one another:</p>

					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td>Multiple events</td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a></td>
							<td></td>
						</tr>
					</table>
				</section>  <!-- events-composition-event-order -->

				<section id="handwriting">
					<h4>Handwriting Recognition Systems</h4>
					<p>The following example describes a possible sequence of events when composing a text passage <q>text</q> with a handwriting recognition system, such as on a pen
						tablet, as modeled using Composition Events.</p>

					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th><a href="#widl-CompositionEvent-data"><code>CompositionEvent<br>data</code></a></th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a></td>
							<td><code>''</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td></td>
							<td colspan="2"><em>User writes word on tablet surface</em></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td><code>'test'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td></td>
							<td colspan="2"><em>User rejects first word-match suggestion, selects different match</em></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td><code>'text'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a></td>
							<td><code>'text'</code></td>
							<td></td>
						</tr>
					</table>
				</section>  <!-- handwriting -->

				<section id="events-composition-event-canceling">
					<h4>Canceling Composition Events</h4>
					<p>If a <a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> event is canceled then any 
					Composition Events that would have fired as a result of that 
					<a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> SHOULD not be dispatched:</p>

					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td>The <a class="def" href="#glossary-default-action">default action</a> is
								prevented, e.g., by invoking <a href="#widl-Event-preventDefault"><code>Event.preventDefault()</code></a>.
								</td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td><em>No Composition Events are dispatched</em></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td></td>
						</tr>
					</table>

					<p>If the initial <a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a> event is 
						canceled then the text composition session SHOULD be terminated. Regardless of whether or not the composition 
						session is terminated, the <a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a>
						event MUST be sent.</p>

					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a></td>
							<td>The <a class="def" href="#glossary-default-action">default action</a> is
								prevented, e.g., by invoking <a href="#widl-Event-preventDefault"><code>Event.preventDefault()</code></a>.
								</td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td><em>No Composition Events are dispatched</em></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td></td>
						</tr>
					</table>
				</section>  <!-- events-composition-event-canceling -->

				<section id="events-composition-event-key-events">
					<h4>Key Events During Composition</h4>
					<p>During the composition session, all <a class="eventtype" href="#event-type-keydown"><code>keydown</code></a>
						and <a class="eventtype" href="#event-type-keyup"><code>keyup</code></a> events MAY be suppressed.</p>

					<section id="events-composition-event-including-key-events">
						<h4>Including Key Events During Composition</h4>

						<p>If a <a class="def" href="#glossary-user-agent">user agent</a> does not suppress these events during
							composition, then it MUST set the key event's
								<a href="#widl-KeyboardEvent-isComposing"><code>isComposing</code></a>
							attribute to <code>true</code> for any events that occur during a composition session.
							</p>

						<table class="event-sequence-table">
							<tr>
								<td class="cell-number"></td>
								<th>Event Name</th>
								<th class="cell-center"><a href="#widl-KeyboardEvent-isComposing"><code>KeyboardEvent<br/>isComposing</code></a></th>
								<th>Notes</th>
							</tr>
							<tr>
								<td class="cell-number">1.</td>
								<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
								<td class="cell-center"><code>false</code></td>
								<td>This is the key event that initiates the composition.</td>
							</tr>
							<tr>
								<td class="cell-number">2.</td>
								<td><a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a></td>
								<td></td>
								<td></td>
							</tr>
							<tr>
								<td class="cell-number">3.</td>
								<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
								<td></td>
								<td></td>
							</tr>
							<tr>
								<td class="cell-number">4.</td>
								<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
								<td class="cell-center"><code>true</code></td>
								<td></td>
							</tr>
							<tr>
								<td class="cell-number"></td>
								<td>...</td>
								<td></td>
								<td>Any key events sent during the composition session MUST have <code>isComposing</code> set to <code>true</code>.</td>
							</tr>
							<tr>
								<td class="cell-number">5.</td>
								<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
								<td class="cell-center"><code>true</code></td>
								<td>This is the key event that exits the composition.</td>
							</tr>
							<tr>
								<td class="cell-number">6.</td>
								<td><a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a></td>
								<td></td>
								<td></td>
							</tr>
							<tr>
								<td class="cell-number">7.</td>
								<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
								<td class="cell-center"><code>false</code></td>
								<td></td>
							</tr>
						</table>

					</section> <!-- events-composition-event-including-key-events -->

					<section id="events-composition-event-suppressing-key-events">
						<h4>Suppressing Key Events During Composition</h4>

						<p>If key events are suppressed between 
							<a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a> and 
							<a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a>, then the first 
							or last key pressed might result in unmatched 
							<a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> and 
							<a class="eventtype" href="#event-type-keyup"><code>keyup</code></a> events.
							If a <a class="def" href="#glossary-user-agent">user agent</a> suppresses key events during composition,
							then it MUST ensure that all <a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> and 
							<a class="eventtype" href="#event-type-keyup"><code>keyup</code></a> events occur in matching pairs.
							</p>

						<p>To ensure that the initial <a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> has a 
							matching <a class="eventtype" href="#event-type-keyup"><code>keyup</code></a>, a
							<a class="def" href="#glossary-user-agent">user agent</a> might insert an extra 
							<a class="eventtype" href="#event-type-keyup"><code>keyup</code></a> to match the 
							<a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> that initiated a composition session,
							as shown in the following example:
							</p>

						<table class="event-sequence-table">
							<tr>
								<td class="cell-number"></td>
								<th>Event Name</th>
								<th class="cell-center"><a href="#widl-KeyboardEvent-isComposing"><code>KeyboardEvent<br/>isComposing</code></a></th>
								<th>Notes</th>
							</tr>
							<tr>
								<td class="cell-number">1.</td>
								<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
								<td class="cell-center"><code>false</code></td>
								<td>This is the key event that initiates the composition.</td>
							</tr>
							<tr>
								<td class="cell-number">2.</td>
								<td><a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a></td>
								<td></td>
								<td></td>
							</tr>
							<tr>
								<td class="cell-number">3.</td>
								<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
								<td></td>
								<td></td>
							</tr>
							<tr>
								<td class="cell-number">4.</td>
								<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
								<td class="cell-center"><code>true</code></td>
								<td>This event would normally be suppressed because of the ongoing composition session, but it is sent
									to match the previously sent <a class="eventtype" href="#event-type-keydown"><code>keydown</code></a>
									event.</td>
							</tr>
							<tr>
								<td class="cell-number"></td>
								<td>...</td>
								<td></td>
								<td>Any other key events that occur during the composition session are suppressed.</td>
							</tr>
							<tr>
								<td class="cell-number">5.</td>
								<td><a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a></td>
								<td></td>
								<td></td>
							</tr>
						</table>

						<p>To ensure that the composition session doesn't end with a dangling 
							<a class="eventtype" href="#event-type-keyup"><code>keyup</code></a> event, a 
							<a class="def" href="#glossary-user-agent">user agent</a> can choose either (A) to suppress this
							<a class="eventtype" href="#event-type-keyup"><code>keyup</code></a> event, or (B) to insert an extra 
							<a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> event.</p>

						<p>An example event sequence where both the 
							<a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> and 
							<a class="eventtype" href="#event-type-keyup"><code>keyup</code></a> events have
							been suppressed:</p>
						
						<table class="event-sequence-table">
							<tr>
								<td class="cell-number"></td>
								<th>Event Name</th>
								<th class="cell-center"><a href="#widl-KeyboardEvent-isComposing"><code>KeyboardEvent<br/>isComposing</code></a></th>
								<th>Notes</th>
							</tr>
							<tr>
								<td class="cell-number"></td>
								<td></td>
								<td></td>
								<td><em><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> for key that exits IME suppressed
									during composition session</em></td>
							</tr>
							<tr>
								<td class="cell-number">1.</td>
								<td><a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a></td>
								<td></td>
								<td></td>
							</tr>
							<tr>
								<td class="cell-number"></td>
								<td></td>
								<td></td>
								<td><em>A <a class="eventtype" href="#event-type-keyup"><code>keyup</code></a> event would normally be sent
									at this time, but it is suppressed to avoid generating an unmatched 
									<a class="eventtype" href="#event-type-keyup"><code>keyup</code></a> event.</em></td>
							</tr>
						</table>

						<p>An example event sequence where a <a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> has been inserted:
							</p>

						<table class="event-sequence-table">
							<tr>
								<td class="cell-number"></td>
								<th>Event Name</th>
								<th class="cell-center"><a href="#widl-KeyboardEvent-isComposing"><code>KeyboardEvent<br/>isComposing</code></a></th>
								<th>Notes</th>
							</tr>
							<tr>
								<td class="cell-number"></td>
								<td></td>
								<td></td>
								<td><em><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> for key that exits IME suppressed 
									during composition session</em></td>
							</tr>
							<tr>
								<td class="cell-number">1.</td>
								<td><a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a></td>
								<td></td>
								<td></td>
							</tr>
							<tr>
								<td class="cell-number">2.</td>
								<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
								<td class="cell-center"><code>false</code></td>
								<td>This is key event that was suppressed earlier. It is sent now to match the upcoming 
									<a class="eventtype" href="#event-type-keyup"><code>keyup</code></a>.</td>
							</tr>
							<tr>
								<td class="cell-number">3.</td>
								<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
								<td class="cell-center"><code>false</code></td>
								<td></td>
							</tr>
						</table>
					
					</section> <!-- events-composition-event-suppressing-key-events -->

				</section>  <!-- events-composition-event-key-events -->
				
				<section id="events-composition-event-input-events">
					<h4>Input Events During Composition</h4>
					
					<p>During the composition session, the 
						<a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a> MUST be dispatched
						before the <a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a> and <code>input</code> events are sent.
						</p>

					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td><em>Any DOM updates occur at this point.</em></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-input"><code>input</code></a></td>
							<td></td>
						</tr>
					</table>

					<p class="note"><strong>Note:</strong> Most IMEs do not support canceling updates
						during a composition session.
						</p>

					<p>When a composition session is finished, any 
						<a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a> and 
						<a class="eventtype" href="#event-type-input"><code>input</code></a> events MUST be dispatched after the 
						<a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a> event.
						</p>

					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a></td>
							<td><em>Sent only if we’re about to update the DOM (i.e., the composition was not canceled).
								Canceling this will prevent the DOM update and the 
								<a class="eventtype" href="#event-type-input"><code>input</code></a> event.</em></td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td><em>Any DOM updates occur at this point.</em></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-input"><code>input</code></a></td>
							<td><em>Sent only if the DOM was updated.</em></td>
						</tr>
					</table>
					
					<p class="note"><strong>Note:</strong> Some IMEs update the DOM before the
						<a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a> event is dispatched.
						In this case, canceling the <a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a>
						event will have no effect (i.e., the <a class="eventtype" href="#event-type-input"><code>input</code></a>
						event will still fire).</p>

				</section>  <!-- events-composition-event-input-events -->
				
				<section id="events-composition-event-types">
					<h4>Composition Event Types</h4>
					<p>The composition event types are listed below.</p>

					<!-- compositionstart -->
					<div class="event-definition">
						<dl>
							<dt id="event-type-compositionstart"><dfn><a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a></dfn></dt>
							<dd>
								<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
									<tr>
										<th>Type</th>
										<td><strong><code>compositionstart</code></strong></td>
									</tr>
									<tr>
										<th>Interface</th>
										<td><a href="#interface-CompositionEvent"><code>CompositionEvent</code></a></td>
									</tr>
									<tr>
										<th>Sync / Async</th>
										<td>Sync</td>
									</tr>
									<tr>
										<th>Bubbles</th>
										<td>Yes</td>
									</tr>
									<tr>
										<th>Trusted Targets</th>
										<td><code>Element</code></td>
									</tr>
									<tr>
										<th>Cancelable</th>
										<td>Yes</td>
									</tr>
									<tr>
										<th>Default action</th>
										<td>Start a new composition session when a <a class="def" href="#glossary-text-composition-system">text composition system</a> is enabled</td>
									</tr>
									<tr>
										<th>Context<br/>(trusted events)</th>
										<td>
											<ul>
												<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
													focused element processing the composition</li>
												<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
													<a class="def" href="#glossary-window"><code>Window</code></a></li>
												<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
													<code>0</code></li>
												<li><a href="#widl-CompositionEvent-data"><code class="attribute-name">CompositionEvent.data</code></a>:
													the original string being edited, otherwise the <a class="def" href="#glossary-empty-string">empty string</a></li>
											</ul>
										</td>
									</tr>
								</table>

								<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a <a class="def" href="#glossary-text-composition-system">text composition
									system</a> is enabled and a new composition session is about to begin (or has begun, depending on the <a class="def" href="#glossary-text-composition-system">text composition
									system</a>) in preparation for composing a passage of text. This event type is device-dependent, and MAY rely upon the capabilities of the text conversion system and how it is
									mapped into the operating system. When a keyboard is used to feed an input method editor, this event type is generated after a <a class="eventtype"><code>keydown</code></a> event,
									but speech or handwriting recognition systems MAY send this event type without keyboard events.  Some implementations MAY populate the
									<a href="#widl-CompositionEvent-data"><code>data</code></a> attribute of the <a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a> event
									with the text currently selected in the document (for editing and replacement). Otherwise, the value of the <a href="#widl-CompositionEvent-data"><code>data</code></a>
									attribute MUST be  the <a class="def" href="#glossary-empty-string">empty string</a>.</p>

								<p>This event MUST be dispatched immediately before a <a class="def" href="#glossary-text-composition-system">text composition system</a> begins a new composition session, and
									before the DOM is modified due to the composition process. The default action of this event is for the <a class="def" href="#glossary-text-composition-system">text
									composition system</a> to start a new composition session. If this event is canceled, the <a class="def" href="#glossary-text-composition-system">text composition system</a> SHOULD
									discard the current composition session.</p>

								<p class="note"><strong>Note:</strong> Canceling the <a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a> <em>event type</em> is distinct
									from canceling the <a class="def" href="#glossary-text-composition-system">text composition system</a> itself (e.g., by hitting a cancel button or closing an <a class="def"
									href="#glossary-ime">IME</a> window).</p>

								<p class="note"><strong>Note:</strong> Some IMEs do not support cancelling an in-progress composition session (e.g., such as GTK which doesn't presently have such an API). In these
									cases, calling <a href="#widl-Event-preventDefault"><code>preventDefault</code></a> will not stop this event's default action.</p>
							</dd>
						</dl>
					</div>

					<!-- compositionupdate -->
					<div class="event-definition">
						<dl>
							<dt id="event-type-compositionupdate"><dfn><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></dfn></dt>
							<dd>
								<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
									<tr>
										<th>Type</th>
										<td><strong><code>compositionupdate</code></strong></td>
									</tr>
									<tr>
										<th>Interface</th>
										<td><a href="#interface-CompositionEvent"><code>CompositionEvent</code></a></td>
									</tr>
									<tr>
										<th>Sync / Async</th>
										<td>Sync</td>
									</tr>
									<tr>
										<th>Bubbles</th>
										<td>Yes</td>
									</tr>
									<tr>
										<th>Trusted Targets</th>
										<td><code>Element</code></td>
									</tr>
									<tr>
										<th>Cancelable</th>
										<td>No</td>
									</tr>
									<tr>
										<th>Default action</th>
										<td>None</td>
									</tr>
									<tr>
										<th>Context<br/>(trusted events)</th>
										<td>
											<ul>
												<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
													focused element processing the composition, <code>null</code> if not accessible</li>
												<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
													<a class="def" href="#glossary-window"><code>Window</code></a></li>
												<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
													<code>0</code></li>
												<li><a href="#widl-CompositionEvent-data"><code class="attribute-name">CompositionEvent.data</code></a>:
													the string comprising the current results of the composition session, which MAY be the
													<a class="def" href="#glossary-empty-string">empty string</a> if the content has been deleted</li>
											</ul>
										</td>
									</tr>
								</table>
								<p>A <a class="def" href="#glossary-user-agent">user agent</a> SHOULD dispatch this event during a composition session when a
									<a class="def" href="#glossary-text-composition-system">text composition system</a> updates its active text passage with a
									new character, which is reflected in the string in <a href="#widl-CompositionEvent-data"><code>CompositionEvent.data</code></a>.
									</p>

								<p>In <a class="def" href="#glossary-text-composition-system">text composition systems</a> which keep the ongoing composition in sync
									with the input control, the <a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a> event
									MUST be dispatched before the control is updated.
									</p>
								
								<p>Some <a class="def" href="#glossary-text-composition-system">text composition systems</a> might not expose this information to the DOM,
									in which case this event will not fire during the composition process.
									</p>
								
								<p>If the composition session is canceled, this event will be fired immediately before the
									<a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a> event,
									and the <a href="#widl-CompositionEvent-data"><code>CompositionEvent.data</code></a> attribute will be set to the
									<a class="def" href="#glossary-empty-string">empty string</a>.
									</p>
							</dd>
						</dl>
					</div>

					<!-- compositionend -->
					<div class="event-definition">
						<dl>
							<dt id="event-type-compositionend"><dfn><a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a></dfn></dt>
							<dd>
								<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
									<tr>
										<th>Type</th>
										<td><strong><code>compositionend</code></strong></td>
									</tr>
									<tr>
										<th>Interface</th>
										<td><a href="#interface-CompositionEvent"><code>CompositionEvent</code></a></td>
									</tr>
									<tr>
										<th>Sync / Async</th>
										<td>Sync</td>
									</tr>
									<tr>
										<th>Bubbles</th>
										<td>Yes</td>
									</tr>
									<tr>
										<th>Trusted Targets</th>
										<td><code>Element</code></td>
									</tr>
									<tr>
										<th>Cancelable</th>
										<td>No</td>
									</tr>
									<tr>
										<th>Default action</th>
										<td>None</td>
									</tr>
									<tr>
										<th>Context<br/>(trusted events)</th>
										<td>
											<ul>
												<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
													focused element processing the composition</li>
												<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
													<a class="def" href="#glossary-window"><code>Window</code></a></li>
												<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
													<code>0</code></li>
												<li><a href="#widl-CompositionEvent-data"><code class="attribute-name">CompositionEvent.data</code></a>:
													the string comprising the final result of the composition session, which MAY be the
													<a class="def" href="#glossary-empty-string">empty string</a> if the content has been deleted or if the composition process has been canceled</li>
											</ul>
										</td>
									</tr>
								</table>
								<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a
									<a class="def" href="#glossary-text-composition-system">text composition system</a> completes or cancels the current composition session,
									and the <a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a> event MUST be dispatched after the control is updated.
									</p>

								<p>This event is dispatched immediately after the <a class="def" href="#glossary-text-composition-system">text composition system</a> completes
									the composition session (e.g., the <a class="def" href="#glossary-ime">IME</a> is closed, minimized, switched out of focus, or otherwise dismissed,
									and the focus switched back to the <a class="def" href="#glossary-user-agent">user agent</a>).
									</p>
							</dd>
						</dl>
					</div>
				</section>  <!-- events-composition-event-types -->
			</section>  <!-- events-compositionevents -->

		</section>  <!-- event-definitions -->

	</section>  <!-- events-module -->

	<!-- Section 6: Keyboard and key values ========================================================-->
	<section id="keys">
		<h1>Keyboard events and key values</h1>

		<p>This section contains necessary information regarding keyboard events:</p>

		<ul>
			<li>Explanation of keyboard layout, mapping, and key values.</li>
			<li>Relations between keys, such as <a class="def" href="#glossary-dead-key">dead keys</a> or modifiers keys.</li>
			<li>Relations between keyboard events and their default actions.</li>
			<li>The set of <code>key</code> values, and guidelines on how to extend this set.</li>
		</ul>

		<p class="note"><strong>Note:</strong> This section uses Serbian and Kanji characters which could
			be misrepresented or unavailable in the PDF version or printed version of this specification.
			</p>

		<section id="keyboard-input">
			<h2>Keyboard Input</h2>

			<p><em>This section is informative</em></p>

			<p>The relationship of each key to the complete keyboard has three separate aspects,
				each of which vary among different models and configurations of keyboards, particularly
				for locale-specific reasons:
				</p>

			<ul>
				<li><strong>Mechanical layout:</strong> the dimensions, size, and placement of the physical keys on the keyboard</li>
				<li><strong>Visual markings:</strong> the labels (or <em>legends</em>) that mark each key</li>
				<li><strong>Functional mapping:</strong> the abstract key-value association of each key.</li>
			</ul>

			<p>This specification only defines the functional mapping, in terms of
					<a href="#keys-keyvalues"><code>key</code></a> values and
					<a href="#keys-codevalues"><code>code</code></a> values,
				but briefly describes
					<a href="#keyboard-layout">keyboard layout</a> and
					<a href="#key-legends">key legends</a>
				for background.
				</p>

			<section id="key-legends">
				<h3>Key Legends</h3>

				<p><em>This section is informative</em></p>

				<p>The key legend is the visual marking that is printed or embossed on the <em>key cap</em> (the rectangular
					'cap' that covers the mechanical switch for the key).
					These markings normally consist of one or more characters that a keystroke on that key
					will produce (such as
						<code class="glyph">'F'</code>,
						<code class="glyph">'8'</code>, or
						<code class="glyph">'ш'</code>),
					or names or symbols which indicate that key's function (such as an upward-pointing arrow
					<code class="glyph">&#x21E7;</code> indicating <code class="key">'Shift'</code>,
					or the string <code>'Enter'</code>).
					Keys are often referred to by this marking
					(e.g., <q>Press the <code>'Shift'</code> and <code>'F'</code> keys.</q>).
					Note, however, that the visual appearance of the key has no bearing on its digital representation,
					and in many configurations may be completely inaccurate.
					Even the control and function keys, such as <code>'Enter'</code>, MAY be mapped to different
					functionality, or even mapped as character keys.
					</p>

				<p>For historical reasons, the character keys are typically marked with the capital-letter equivalents
					of the character value they produce, e.g., the <code>'F'</code> key (the key marked with the glyph
					<code class="glyph">'F'</code>), will produce the character value <code class="char">'f'</code> when
					pressed without an active modifier key (<code class="key">'Shift'</code>) or modifier state
					(<code class="key">'CapsLock'</code>).
					</p>

				<p class="note"><strong>Note:</strong>
					Many keyboards contain keys that do not normally produce any characters, even though the symbol might
					have a Unicode equivalent.
					For example, the <code class="key">'Shift'</code> key might bear the symbol
					<code class="glyph">&#x21E7;</code>, which has the
					<a class="def" href="#glossary-unicode-code-point">Unicode code point</a> <code class="char">'\u21E7'</code>,
					but pressing the <code class="key">'Shift'</code> key will not produce this character value, and
					there is no <a class="def" href="#glossary-unicode-code-point">Unicode code point</a> for
					<code class="key">'Shift'</code>.
					</p>
			</section>  <!-- key-legends -->

		</section>  <!-- keyboard-input -->

		<section id="keys-codevalues">
			<h1>Key codes</h1>
			
			<p>A key <code>code</code> is an attribute of a keyboard event that can be used to identify the physical
				key associated with the keyboard event. It is similar to USB Usage IDs in that it provides
				a low-level value (similar to a scancode) that is vendor-neutral.
				</p>
				
			<p>The primary purpose of the <code>code</code> attribute is to provide a consistent and coherent way
				to identify keys based on their physical location. In addition, it also provides a stable name
				(unaffected by the current keyboard state) that uniquely identifies each key on the keyboard.
				</p>

			<p>The list of valid <code>code</code> values is defined in the
				DOM Level 3 KeyboardEvent code Values Specification [<a href="#references-D3E-code">DOM3 code Values</a>].
				</p>

			<section id="code-motivation">
				<h1>Motivation for Adding the <code>code</code> Attribute</h1>

				<p>As discussed in more detail later in this document, the standard PC keyboard has a set of keys (which
					we refer to as <em><a href="#key-alphanumeric-writing-system">writing system keys</a></em>)
					that generate different <code>key</code> values 
					based on the current keyboard layout selected by the user.
					This situation makes it difficult to write code that detects keys based on their physical
					location since the code would need to know which layout is in effect in order to know which
					<code>key</code> values to check for.
					A real-world example of this is a game that wants to use the
						<code class="glyph">'W'</code>,
						<code class="glyph">'A'</code>,
						<code class="glyph">'S'</code> and
						<code class="glyph">'D'</code>
					keys to control player movement.
					The <code>code</code> attribute solves this problem by providing
					a stable value to check that is <em>not affected by the current keyboard layout</em>.
					</p>
					
				<p>In addition, the values in the <code>key</code> attribute depend as well
					on the current keyboard state.
					Because of this, the order in which keys are pressed and released in relation to modifier keys
					can affect the values stored in the <code>key</code> attribute.
					The <code>code</code> attribute solves this problem by providing
					a stable value that is <em>not affected by the current keyboard state</em>.
					</p>
			</section>  <!-- code-motivation -->
			
			<section id="relationship-between-key-code">
				<h1>The Relationship Between <code>key</code> and <code>code</code></h1>
				<dl>
					<dt><code>key</code></dt>
					<dd>The <code>key</code> attribute is intended for users who are interested in the meaning of the key
						being pressed, taking into account the current keyboard layout (and IME; <a href="#keys-dead">dead keys</a>
						are given a unique <code>key</code> value).
						Example use case: Detecting modified keys or bare modifier keys (e.g., to perform an action in
						response to a keyboard shortcut).</dd>

					<dt><code>code</code></dt>
					<dd>The <code>code</code> attribute is intended for users who are interested in the key that was pressed
						by the user, without any layout modifications applied.
						Example use case: Detecting WASD keys (e.g., for movement controls in a game) or trapping all keys
						(e.g., in a remote desktop client to send all keys to the remote host).
						</dd>
				</dl>
			</section>  <!-- relationship-between-key-code -->

			<section id="code-examples">
				<h1><code>code</code> Examples</h1>
				<div class="example">
					<div class="example-title"></div>
					<p>Handling the Left and Right Alt Keys</p>
					<table class="data-table" style="width:auto">
						<thead>
							<tr>
								<th>Keyboard Layout</th>
								<th><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
								<th><a href="#widl-KeyboardEvent-code"><code>KeyboardEvent<br/>code</code></a></th>
								<th>Notes</th>
							</tr>
						</thead>
						<tbody>
							<tr>
								<td>US</td>
								<td><code class="key">'Alt'</code></td>
								<td><code class="code">'AltLeft'</code></td>
								<td><code class="constant-name">DOM_KEY_LOCATION_LEFT</code></td>
							</tr>
							<tr>
								<td>French</td>
								<td><code class="key">'Alt'</code></td>
								<td><code class="code">'AltLeft'</code></td>
								<td><code class="constant-name">DOM_KEY_LOCATION_LEFT</code></td>
							</tr>
							<tr>
								<td>US</td>
								<td><code class="key">'Alt'</code></td>
								<td><code class="code">'AltRight'</code></td>
								<td><code class="constant-name">DOM_KEY_LOCATION_RIGHT</code></td>
							</tr>
							<tr>
								<td>French</td>
								<td><code class="key">'AltGr'</code></td>
								<td><code class="code">'AltRight'</code></td>
								<td><code class="constant-name">DOM_KEY_LOCATION_RIGHT</code></td>
							</tr>
						</tbody>
					</table>
					<p>In this example, checking the <code>key</code> attribute permits matching <code class="key">'Alt'</code> without worrying about which Alt key (left or right) was pressed.
						Checking the <code>code</code> attribute permits matching the right Alt key (<code class="code">'AltRight'</code>) without worrying about which layout is currently in effect.
						</p>
					<p>Note that, in the French example, the <code class="key">'Alt'</code> and
						<code class="key">'AltGr'</code> keys retain their left and right location, even through there
						is only one of each key.
						</p>
				</div>  <!-- Handling Left and Right Alt Keys -->

				<div class="example">
					<div class="example-title"></div>
					<p>Handling the Single Quote Key</p>
					<table class="data-table" style="width:auto">
						<thead>
							<tr>
								<th>Keyboard Layout</th>
								<th><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
								<th><a href="#widl-KeyboardEvent-code"><code>KeyboardEvent<br/>code</code></a></th>
								<th>Notes</th>
							</tr>
						</thead>
						<tbody>
							<tr>
								<td>US</td>
								<td><code class="key">'''</code></td>
								<td><code class="code">'Quote'</code></td>
								<td></td>
							</tr>
							<tr>
								<td>Japanese</td>
								<td><code class="key">':'</code></td>
								<td><code class="code">'Quote'</code></td>
								<td></td>
							</tr>
							<tr>
								<td>US Intl</td>
								<td><code class="key">'Dead'</code></td>
								<td><code class="code">'Quote'</code></td>
								<td></td>
							</tr>
						</tbody>
					</table>
					<p>This example shows how dead key values are encoded in the attributes. The
						<code>key</code> values vary based on the current locale, whereas the <code>code</code> attribute
						returns a consistent value.
						</p>
				</div><!-- Handling the Single Quote Key -->

				<div class="example" id="example-key-2">
					<div class="example-title"></div>
					<p>Handling the <code class="glyph">'2'</code> Key (with and without Shift pressed)</p>
					<table class="data-table" style="width:auto">
						<thead>
							<tr>
								<th>Keyboard Layout</th>
								<th><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
								<th><a href="#widl-KeyboardEvent-code"><code>KeyboardEvent<br/>code</code></a></th>
								<th>Notes</th>
							</tr>
						</thead>
						<tbody>
							<tr>
								<td>US</td>
								<td><code class="key">'2'</code></td>
								<td><code class="code">'Digit2'</code></td>
								<td></td>
							</tr>
							<tr>
								<td>US</td>
								<td><code class="key">'@'</code></td>
								<td><code class="code">'Digit2'</code></td>
								<td><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							</tr>
							<tr>
								<td>UK</td>
								<td><code class="key">'2'</code></td>
								<td><code class="code">'Digit2'</code></td>
								<td></td>
							</tr>
							<tr>
								<td>UK</td>
								<td><code class="key">'"'</code></td>
								<td><code class="code">'Digit2'</code></td>
								<td><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							</tr>
							<tr>
								<td>French</td>
								<td><code class="key">'é'</code></td>
								<td><code class="code">'Digit2'</code></td>
								<td></td>
							</tr>
							<tr>
								<td>French</td>
								<td><code class="key">'2'</code></td>
								<td><code class="code">'Digit2'</code></td>
								<td><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							</tr>
						</tbody>
					</table>
					<p>Regardless of the current locale or the modifier key state, pressing the key labelled <code class="glyph">'2'</code>
						on a US keyboard always results in <code class="code">'Digit2'</code> in the <code>code</code> attribute. 
						</p>
				</div><!-- Handling the 2 Key -->

				<div class="example" id="example-key-shift-2">
					<div class="example-title"></div>
					<p>Sequence of Keyboard Events : <code class="key">'Shift'</code> and <code class="key">'2'</code></p>
					<p>Compare the attribute values in the following two key event sequences. They both produce the
						<code class="glyph">'@'</code> character on a US keyboard, but differ in the order in which the
						keys are released. In the first sequence, the order is:
							<code class="key">'Shift'</code> (down),
							<code class="key">'2'</code> (down),
							<code class="key">'2'</code> (up), 
							<code class="key">'Shift'</code> (up).
						</p>
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th>Keyboard Layout</th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-code"><code>KeyboardEvent<br/>code</code></a></th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td>US</td>
							<td class="cell-center"><code class="key">'Shift'</code></td>
							<td class="cell-center"><code class="code">'ShiftLeft'</code></td>
							<td><code class="constant-name">DOM_KEY_LOCATION_LEFT</code></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td>US</td>
							<td class="cell-center"><code class="key">'@'</code></td>
							<td class="cell-center"><code class="code">'Digit2'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-keypress"><code>keypress</code></a></td>
							<td>US</td>
							<td class="cell-center"><code class="key">'@'</code></td>
							<td class="cell-center"><code>''</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td>US</td>
							<td class="cell-center"><code class="key">'@'</code></td>
							<td class="cell-center"><code class="code">'Digit2'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td>US</td>
							<td class="cell-center"><code class="key">'Shift'</code></td>
							<td class="cell-center"><code class="code">'ShiftLeft'</code></td>
							<td><code class="constant-name">DOM_KEY_LOCATION_LEFT</code></td>
						</tr>
					</table>
					<p>In the second sequence, the Shift is released before the 2, resulting in the following event order:
						<code class="key">'Shift'</code> (down),
						<code class="key">'2'</code> (down), 
						<code class="key">'Shift'</code> (up), 
						<code class="key">'2'</code> (up).
						</p>
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th>Keyboard Layout</th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-code"><code>KeyboardEvent<br/>code</code></a></th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td>US</td>
							<td class="cell-center"><code class="key">'Shift'</code></td>
							<td class="cell-center"><code class="code">'ShiftLeft'</code></td>
							<td><code class="constant-name">DOM_KEY_LOCATION_LEFT</code></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td>US</td>
							<td class="cell-center"><code class="key">'@'</code></td>
							<td class="cell-center"><code class="code">'Digit2'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-keypress"><code>keypress</code></a></td>
							<td>US</td>
							<td class="cell-center"><code class="key">'@'</code></td>
							<td class="cell-center"><code>''</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td>US</td>
							<td class="cell-center"><code class="key">'Shift'</code></td>
							<td class="cell-center"><code class="code">'ShiftLeft'</code></td>
							<td><code class="constant-name">DOM_KEY_LOCATION_LEFT</code></td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td>US</td>
							<td class="cell-center"><code class="key">'2'</code></td>
							<td class="cell-center"><code class="code">'Digit2'</code></td>
							<td></td>
						</tr>
					</table>
					<p>Note that the values contained in the <code>key</code> attribute does not match between
						the keydown and keyup events for the <code class="glyph">'2'</code> key. The <code>code</code> attribute provides a consistent value
						that is not affected by the current modifier state.
						</p>
				</div><!-- Sequence of Keyboard Events: Shift and 2 -->
			</section>  <!-- code-examples -->

			<section id="code-virtual-keyboards">
				<h1><code>code</code> and Virtual Keyboards</h1>
				<p>The usefulness of the <code>code</code> attribute is less obvious for virtual keyboards (and also
					for remote controls and chording keyboards).
					In general, if a virtual (or remote control) keyboard is mimicking the layout and functionality
					of a standard keyboard, then it MUST also set the <code>code</code> attribute as appropriate.
					For keyboards which are not mimicking the layout of a standard keyboard, then the <code>code</code>
					attribute MAY be set to the closest match on a standard keyboard or it MAY be left undefined.
					</p>
				<p>For virtual keyboards with keys that produce different values based on some modifier state,
					the <code>code</code> value should be the <code>key</code> value
					generated when the button is pressed while the device is in its factory-reset state.
					</p>
			</section>  <!-- code-virtual-keyboards -->
			
		</section>  <!-- keys-codevalues -->
		
		<section id="keys-keyvalues">
			<h2>Keyboard Event <code>key</code> Values</h2>

			<p>A key value is a <code>DOMString</code> that can be used to indicate any given key on a keyboard, regardless of position or state, by the value it produces.  These
				key values MAY be used as return values for keyboard events generated by the implementation, or as input values by the content author to specify desired input (such
				as for keyboard shortcuts).
				</p>

			<p>The list of valid <code>key</code> values is defined in the
				DOM Level 3 KeyboardEvent key Values Specification [<a href="#references-D3E-key">DOM3 key Values</a>].
				</p>

			<p>Key values can be used to detect the value of a key which has been pressed, using the <a href="#widl-KeyboardEvent-key"><code>KeyboardEvent.key</code></a>
				attribute.  Content authors can retrieve the <a class="def" href="#glossary-character-value">
				character value</a> of upper- or lower-case letters, number, symbols, or other character-producing keys, and also the <a class="def" href="#glossary-key-value">key
				value</a> of control keys, modifier keys, function keys, or other keys that do not generate characters. These values can be used for monitoring particular
				input strings, for detecting and acting on modifier key input in combination with other inputs (such as a mouse), for creating virtual keyboards, or for any number
				of other purposes.</p>

			<p>Key values can also be used by content authors in string comparisons, as values for markup attributes (such as the HTML <code>accesskey</code>) in conforming <a
				class="def" href="#glossary-host-language">host languages</a>, or for other related purposes.   A conforming <a class="def" href="#glossary-host-language">host language</a>
				SHOULD allow content authors to use either of the two equivalent string values for a key value: the <a class="def" href="#glossary-character-value">character value</a>,
				or the <a class="def" href="#glossary-key-value">key value</a>.</p>

			<p class="note"><strong>Note:</strong> While implementations will use the most relevant value for a key independently of the platform or keyboard layout mappings,
				content authors can not make assumptions on the ability of keyboard devices to generate them.  When using keyboard events and key values for shortcut-key combinations,
				content authors can <q>consider using numbers and function keys (F4, F5, and so on) instead of letters</q> ([<cite><a class="informative" href="#references-DWW95">DWW95</a></cite>])
				given that most keyboard layouts will provide keys for those.</p>

			<p>A key value does not indicate a specific key on the physical keyboard, nor does it reflect the character printed on the key. A key
				value indicates the current value of the event with consideration to the current state of all active keys and key input modes 
				(including shift modes), as reflected in the operating-system mapping of the keyboard and reported to the implementation.  In other
				words, the key value for the key marked <code class="glyph">'O'</code> on a <a class="def" href="#glossary-qwerty">QWERTY</a> keyboard
				has the key value <code class="key">'o'</code> in an unshifted state and <code class="key">'O'</code> in a shifted state.
				Because a user can map their keyboard to an arbitrary custom configuration, the content author is encouraged not to assume that a 
				relationship exists between the shifted and unshifted states of a key and the majuscule form (uppercase or capital letters)
				and minuscule form (lowercase or small letters) of a character representation, but is encouraged instead to use the value of the 
				<a href="#widl-KeyboardEvent-key"><code>KeyboardEvent.key</code></a> attribute. For example, the Standard "102" Keyboard layout 
				depicted in [<a href="#references-D3E-code">DOM3 code Values</a>] illustrates one possible set of 
				<a class="def" href="#glossary-key-mapping">key mappings</a> on one possible keyboard layout. Many others exist, both standard and 
				idiosyncratic.</p>

			<p class="note"><strong>Note:</strong> To simplify <a class="def" href="#glossary-dead-key">dead key</a> support, when the operating-system 
				mapping of the keyboard is handling a <a class="def" href="#glossary-dead-key">dead key</a> state, the current state of the dead 
				key sequence is not reported via the <a href="#widl-KeyboardEvent-key"><code>KeyboardEvent.key</code></a> attribute. Rather, a key value of
				<code class="key">'Dead'</code> is reported. Instead, implementations generate <a href="#events-compositionevents">composition events</a>
				which contain the intermediate state of the dead key sequence reported via the 
				<a href="#widl-CompositionEvent-data"><code>CompositionEvent.data</code></a> attribute. As in the previous example, the key value for 
				the key marked <code class="glyph">'O'</code> on a <a class="def" href="#glossary-qwerty">QWERTY</a> keyboard has a 
				<a href="#widl-CompositionEvent-data"><code>CompositionEvent.data</code></a> value of <code class="char">'&#xF6;'</code> in an unshifted 
				state during a dead-key operation to add an umlaut diacritic, and <code class="char">'&#xD6;'</code> in a shifted state during a dead-key 
				operation to add an umlaut diacritic.</p>
				
			<p>It is also important to note that there is not a one-to-one relationship between key event states and key values.  A particular key value might be associated with
				multiple keys. For example, many standard keyboards contain more than one key with the <code class="key">'Shift'</code> key value (normally distinguished by the
				<a href="#widl-KeyboardEvent-location"><code>KeyboardEvent.location</code></a> values <a href="#widl-KeyboardEvent-DOM_KEY_LOCATION_LEFT"><code class="constant-name">DOM_KEY_LOCATION_LEFT</code></a>
				and <a href="#widl-KeyboardEvent-DOM_KEY_LOCATION_RIGHT"><code class="constant-name">DOM_KEY_LOCATION_RIGHT</code></a>) or <code class="key">'8'</code> key value (normally
				distinguished by the <a href="#widl-KeyboardEvent-location"><code>KeyboardEvent.location</code></a> values
				<a href="#widl-KeyboardEvent-DOM_KEY_LOCATION_STANDARD"><code class="constant-name">DOM_KEY_LOCATION_STANDARD</code></a>
				and <a href="#widl-KeyboardEvent-DOM_KEY_LOCATION_NUMPAD"><code class="constant-name">DOM_KEY_LOCATION_NUMPAD</code></a>), and user-configured
				custom keyboard layouts MAY duplicate any key value in multiple key-state scenarios (note that <a href="#widl-KeyboardEvent-location"><code>KeyboardEvent.location</code></a>
				is intended for standard keyboard layouts, and cannot always indicate a meaningful distinction).</p>

			<p>Finally, the meaning of any given character representation is context-dependent and complex.  For example, in some contexts, the asterisk (star) glyph (<code
				class="glyph">'*'</code>) represents a footnote or emphasis (when bracketing a passage of text). However, in some documents or executable programs it is equivalent
				to the mathematical multiplication operation, while in other documents or executable programs, that function is reserved for the multiplication symbol (<code class="glyph">'&#xD7;'</code>,
				Unicode value <code class="char">'\u00D7'</code>) or the Latin small letter <code>'x'</code> (due to the lack of a multiplication key on many keyboards
				and the superficial resemblance of the glyphs <code class="glyph">'&#xD7;'</code> and <code class="glyph">'x'</code>).  Thus, the semantic meaning or function of
				character representations is outside the scope of this specification.</p>

			<section id="keys-unicode">
				<h3>Key Values and Unicode</h3>

				<p>The <a class="def" href="#glossary-character-value">character values</a> described in this specification are Unicode [<a href="#references-Unicode">Unicode</a>]
					codepoints, and as such, have certain advantages.</p>

				<p>The most obvious advantage is that it allows the content author to use the full range of internationalized language functionality available in the implementation,
					regardless of the limitations of the text input devices on the system.  This opens up possibilities for virtual keyboards and Web-application-based <a class="def"
					href="#glossary-ime">input method editors</a>.</p>

				<p>Another benefit is that it allows the content author to utilize the Unicode general category properties programmatically.</p>

				<p>With legacy keyboard event attributes such as <code class="attribute-name">keyCode</code> and <code class="attribute-name">charCode</code>, content authors are forced to
					filter key input using cryptic, platform- and implementation-specific numeric codes, with poor internationalization, such as the following pseudocode:</p>

				<div class="example">
					<div class="example-title"></div>
<pre><code>if ( ( event.charCode == 45 || event.charCode == 36 ) ||
     ( event.charCode &gt;= 48 &amp;&amp; event.charCode &lt;= 57 ) ||
     ( event.charCode &gt;= 96 &amp;&amp; event.charCode &lt;= 105 ) ) {
   <span class="comment">// minus sign, dollar sign, and numeric characters from keyboard and numpad</span>
   <span class="comment">// ...</span>
}
else if ( ( event.charCode &gt;= 65 &amp;&amp; event.charCode &lt;= 90 ) ||
          ( event.charCode &gt;= 97 &amp;&amp; event.charCode &lt;= 122 ) ) {
   <span class="comment">// alphabetic characters from Latin character set, A-Z, a-z</span>
   <span class="comment">// ...</span>
}
else {
   <span class="comment">// ...</span>
}
</code></pre>
				</div>

				<p>With key values and regular expressions, however, content authors can support selective and intuitive ranges for key-based input, in a cross-platform manner with
					advanced internationalization support, such as the following pseudocode:</p>

				<div class="example">
					<div class="example-title"></div>
<pre><code>if ( event.key == "-" || event.key.match("\p{Sc}") || event.key.match("\p{N}") ) {
   <span class="comment">// minus sign, any currency symbol, and numeric characters (regardless of key location)</span>
   <span class="comment">// ...</span>
}
else if ( event.key.match("\p{L}") ) {
   <span class="comment">// alphabetic characters from any language, upper and lower case</span>
   <span class="comment">// ...</span>
}
else {
   <span class="comment">// ...</span>
}
</code></pre>
				</div>

				<p>In addition, because Unicode categorizes each assigned <a class="def" href="#glossary-unicode-code-point">code point</a> into a group of code points used by a particular
					human writing system, even more advanced capabilities are possible.</p>

				<div class="example">
					<div class="example-title"></div>
					<p>A content author can match characters from a particular human script (e.g., Tibetan) using a regular expression such as
					<code>\p{Tibetan}</code>, to filter out other characters, or discover if a <a class="def" href="#glossary-unicode-code-point">code point</a> is in
					a certain code block (range of code points), using a regular expression like <code>\p{InCyrillic}</code>.</p>
				</div>

				<p>To facilitate this, implementations SHOULD support Unicode range detection using regular expressions, in a manner such as the Perl Compatible Regular Expressions
					(PCRE) [<a href="#references-pcre">PCRE</a>].</p>
			</section>  <!-- keys-unicode -->

			<section id="keys-modifiers">
				<h3>Modifier keys</h3>

				<p>Keyboard input uses modifier keys to change the normal behavior of a key.
					Like other keys, modifier keys generate
						<a class="eventtype" href="#event-type-keydown"><code>keydown</code></a>
					and
						<a class="eventtype" href="#event-type-keyup"><code>keyup</code></a>
					events, as shown in the example below.
					Some modifiers are activated while the key is being pressed down or maintained pressed such as
						<code class="key">'Alt'</code>,
						<code class="key">'Control'</code>,
						<code class="key">'Shift'</code>,
						<code class="key">'AltGraph'</code>,
					or
						<code class="key">'Meta'</code>.
					Others modifiers are activated depending on their state such as
						<code class="key">'CapsLock'</code>,
						<code class="key">'NumLock'</code>,
					or
						<code class="key">'ScrollLock'</code>.
					Change in the state happens when the modifier key is being pressed down.
					The
						<a href="#interface-KeyboardEvent"><code>KeyboardEvent</code></a>
					interface provides convenient attributes for some common modifiers keys:
						<a href="#widl-KeyboardEvent-ctrlKey"><code>KeyboardEvent.ctrlKey</code></a>,
						<a href="#widl-KeyboardEvent-shiftKey"><code>KeyboardEvent.shiftKey</code></a>,
						<a href="#widl-KeyboardEvent-altKey"><code>KeyboardEvent.altKey</code></a>,
						<a href="#widl-KeyboardEvent-metaKey"><code>KeyboardEvent.metaKey</code></a>.
					Some operating systems simulate the
						<code class="key">'AltGraph'</code>
					modifier key with the combination of the
						<code class="key">'Alt'</code>
					and
						<code class="key">'Control'</code>
					modifier keys.
					Implementations are encouraged to use the
						<code class="key">'AltGraph'</code>
					modifier key.
					</p>

				<p>The following example describes a possible sequence of events associated with the generation of the Unicode character Q (Latin Capital Letter Q, <a class="def"
					href="#glossary-unicode-code-point">Unicode code point</a> <code class="char">'\u0051'</code>) on a US keyboard using a US mapping:</p>

				<div class="example">
					<div class="example-title"></div>
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
							<th>Modifiers</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Shift'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Q'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							<td>Latin Capital Letter Q</td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a></td>
							<td class="cell-center"><code class="key">'Q'</code></td>
							<td></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-input"><code>input</code></a></td>
							<td class="cell-center"></td>
							<td></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Q'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">6.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Shift'</code></td>
							<td></td>
							<td></td>
						</tr>
					</table>
				</div>

				<p>The following example describes an alternate sequence of keys to the example above, where the <code class="key">'Shift'</code> key is released before the <code
					class="key">'Q'</code> key.  The key value for the key labeled <code class="glyph">'Q'</code> will revert to its unshifted value for the <a class="eventtype" href="#event-type-keyup">
					<code>keyup</code></a> event:</p>

				<div class="example">
					<div class="example-title"></div>
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
							<th>Modifiers</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Shift'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Q'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							<td>Latin Capital Letter Q</td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a></td>
							<td class="cell-center"><code class="key">'Q'</code></td>
							<td></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-input"><code>input</code></a></td>
							<td class="cell-center"></td>
							<td></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Shift'</code></td>
							<td></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">6.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'q'</code></td>
							<td></td>
							<td>Latin Small Letter Q</td>
						</tr>
					</table>
				</div>

				<p>The following example describes a possible sequence of keys that does not generate a Unicode character (using the same configuration):</p>

				<div class="example">
					<div class="example-title"></div>
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
							<th>Modifiers</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Control'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-ctrlKey">ctrlKey</a></code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'v'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-ctrlKey">ctrlKey</a></code></td>
							<td>Latin Small Letter V</td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td colspan="4"><em>No beforeinput or input events are generated.</em></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'v'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-ctrlKey">ctrlKey</a></code></td>
							<td>Latin Small Letter V</td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Control'</code></td>
							<td></td>
							<td></td>
						</tr>
					</table>
				</div>

				<p>The following example shows the sequence of events when both <code class="key">'Shift'</code> and 
					<code class="key">'Control'</code> are pressed:</p>

				<div class="example">
					<div class="example-title"></div>
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
							<th>Modifiers</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Control'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-ctrlKey">ctrlKey</a></code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Shift'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-ctrlKey">ctrlKey</a></code> 
								<code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'V'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-ctrlKey">ctrlKey</a></code> 
								<code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							<td>Latin Capital Letter V</td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td colspan="4"><em>No beforeinput or input events are generated.</em></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'V'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-ctrlKey">ctrlKey</a></code> 
								<code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							<td>Latin Capital Letter V</td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Shift'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-ctrlKey">ctrlKey</a></code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">6.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Control'</code></td>
							<td></td>
							<td></td>
						</tr>
					</table>
				</div>

				<p>For non-US keyboard layouts, the sequence of events is the same, but the value of the key is based on the current
					keyboard layout. The following example shows a sequence of events when an Arabic keyboard layout is used:</p>
						
				<div class="example">
					<div class="example-title"></div>
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
							<th>Modifiers</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Control'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-ctrlKey">ctrlKey</a></code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'ر'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-ctrlKey">ctrlKey</a></code></td>
							<td>Arabic Letter Reh</td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td colspan="4"><em>No beforeinput or input events are generated.</em></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'ر'</code></td>
							<td><code class="attribute-name"><a href="#widl-MouseEvent-ctrlKey">ctrlKey</a></code></td>
							<td>Arabic Letter Reh</td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Control'</code></td>
							<td></td>
							<td></td>
						</tr>
					</table>
				</div>

				<p class="note"><strong>Note:</strong>
					The value in the keydown and keyup events varies based on the current keyboard
					layout in effect when the key is pressed.
					This means that the <code class="key">'v'</code> key on a US layout and the
					<code class="key">'ر'</code> key on an Arabic layout will generate different
					events even though they are the same physical key.
					To identify these events as coming from the same physical key, you will need
					to make use of the <code>code</code> attribute.
					</p>
				
				<p>In some cases, modifier keys change the key value value for a key event.
					For example, on some MacOS keyboards, the  key labeled <code class="glyph">'delete'</code>
					functions the same as the <code class="key">'Backspace'</code> key on the
					Windows OS when unmodified, but when modified by the <code class="key">'Fn'</code>
					key, acts as the <code class="key">'Delete'</code> key, and the value of the
					key value will match the most appropriate function of the key in its current
					modified state.
					</p>

			</section>  <!-- keys-modifiers -->

			<section id="keys-dead">
				<h3>Dead keys</h3>

				<p>Some keyboard input uses <a class="def" href="#glossary-dead-key">dead keys</a> for the input of composed character sequences. Unlike the handwriting sequence,
					in which users enter the base character first, keyboard input requires to enter a special state when a <a class="def" href="#glossary-dead-key">dead key</a> is
					pressed and emit the character(s) only when one of a limited number of <q>legal</q> base character is entered.</p>

				<p class="note"><strong>Note:</strong> The MacOS and Linux operating systems use input methods to process
					<a class="def" href="#glossary-dead-key">dead keys</a>.
					</p>

				<p>The <a class="def" href="#glossary-dead-key">dead keys</a> (across all keyboard layouts and mappings) are represented by the 
					key value <code class="key">'Dead'</code>. In response to any dead key press, <a href="#events-compositionevents">
					composition events</a> must be dispatched by the user agent and the
					<a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a> event's 
					<a href="#widl-CompositionEvent-data"><code>CompositionEvent.data</code></a> value must be the character value of the current state
					of the dead key combining sequence.</p>

				<p>While Unicode combining characters always follow the handwriting sequence, with the 
					combining character trailing the corresponding letter, typical dead key input MAY reverse the sequence, with the
					combining character before the corresponding letter. For example, the word <em>naïve</em>, using the combining diacritic 
					<em>¨</em>, would be represented sequentially in Unicode as <em>nai¨ve</em>, but MAY be typed <em>na¨ive</em>. The sequence 
					of keystrokes <code class="char">'\u0302'</code> (Combining Circumflex Accent key) and <code class="char">'\u0065'</code>
					(key marked with the Latin Small Letter E) will likely produce (on a French keyboard using a french mapping and without
					any modifier activated) the Unicode character <code class="glyph">'&#xEA;'</code> (Latin Small Letter E With Circumflex), as 
					preferred by the Unicode Normalization Form <em>NFC</em>:</p>

				<p class="note"><strong>Note:</strong> The <code>keydown</code> and <code>keyup</code> events shown in these
					examples would normally be suppressed during the composition session.
					They are included in these examples to make the user actions (pressing and releasing keys) more apparent.
					</p>

				<div class="example">
					<div class="example-title"></div>
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-isComposing"><code>KeyboardEvent<br/>isComposing</code></a></th>
							<th class="cell-center"><a href="#widl-CompositionEvent-data"><code>CompositionEvent<br/>data</code></a></th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Dead'</code></td>
							<td class="cell-center"><code>false</code></td>
							<td class="cell-center"></td>
							<td>Combining Circumflex Accent (Dead Key)</td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code>''</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="char">'\u0302'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Dead'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'ê'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">6.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="glyph">'ê'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">7.</td>
							<td><a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="glyph">'ê'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">8.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'e'</code></td>
							<td class="cell-center"><code>false</code></td>
							<td class="cell-center"></td>
							<td>Latin Small Letter E</td>
						</tr>
					</table>
				</div>

				<p class="note"><strong>Note:</strong> In the second <code>keydown</code> event (step 5), the key value
					(assuming the event is not suppressed) will
					<em>not</em> be <code class="key">'e'</code> (Latin Small Letter E key) under normal circumstances
					because the value delivered to the user agent will already be modified by the dead key operation.</p>

				<p>This process might be aborted when a user types an unsupported base character (that is, a base character for which the which the active diacritical mark is not
					available) after pressing a <a class="def" href="#glossary-dead-key">dead key</a>:</p>

				<div class="example">
					<div class="example-title"></div>
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-isComposing"><code>KeyboardEvent<br/>isComposing</code></a></th>
							<th class="cell-center"><a href="#widl-CompositionEvent-data"><code>CompositionEvent<br/>data</code></a></th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Dead'</code></td>
							<td class="cell-center"><code>false</code></td>
							<td class="cell-center"></td>
							<td>Combining Circumflex Accent (Dead Key)</td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code>''</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="char">'\u0302'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Dead'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'q'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td>Latin Small Letter Q</td>
						</tr>
						<tr>
							<td class="cell-number">6.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code>''</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">7.</td>
							<td><a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code>''</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">8.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'q'</code></td>
							<td class="cell-center"><code>false</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
					</table>
				</div>
			</section>  <!-- keys-dead -->

			<section id="keys-IME">
				<h3>Input Method Editors</h3>

				<p>This specification includes a model for <a class="def" href="#glossary-ime">input method editors (IMEs)</a>, through the <a href="#interface-CompositionEvent">CompositionEvent</a>
					interface and events.  However, Composition Events and Keyboard Events do not necessarily map as a one-to-one relationship.  As an example, receiving a <a class="eventtype"
					href="#event-type-keydown"><code>keydown</code></a> for the <code class="key">'Accept'</code> key value does not necessarily imply
					that the text currently selected in the <a class="def" href="#glossary-ime">IME</a> is being accepted, but indicates only that a keystroke happened, disconnected
					from the <a class="def" href="#glossary-ime">IME</a> Accept functionality (which would normally result in a <a class="eventtype" href="#event-type-compositionend">
					<code>compositionend</code></a> event in most <a class="def" href="#glossary-ime">IME</a> systems).  Keyboard events cannot be used to determine the current
					state of the input method editor, which can be obtained through the <a href="#widl-CompositionEvent-data"><code>data</code></a> attribute of the <a href="#interface-CompositionEvent">
					CompositionEvent</a> interface.  Additionally, <a class="def" href="#glossary-ime">IME</a> systems and devices vary in their functionality, and in which keys
					are used for activating that functionality, such that the <code class="key">'Convert'</code> and <code class="key">'Accept'</code> keys MAY be represented
					by other available keys. Keyboard events correspond to the events generated by the input device after the keyboard layout mapping.</p>

				<p class="note"><strong>Note:</strong>  In some implementations or system configurations, some key events, or their values, might be suppressed
					by the <a class="def" href="#glossary-ime">IME</a> in use.</p>

				<p>The following example describes a possible sequence of keys to generate the Unicode character <code class="glyph">'&#x5E02;'</code> (Kanji character, part of CJK Unified Ideographs) using Japanese
					input methods. This example assumes that the input method editor is activated and in the Japanese-Romaji input mode. The keys <code class="key">'Convert'</code>
					and <code class="key">'Accept'</code> MAY be replaced by others depending on the input device in use and the configuration of the IME, e.g., it can be respectively
					<code class="char">'\u0020'</code> (Space key) and <code class="key">'Enter'</code>.</p>

				<p class="note"><strong>Note:</strong> <code class="glyph">'&#x8A69;'</code> (<q>poem</q>) and <code class="glyph">'&#x5E02;'</code> (<q>city</q>) are homophones, both
					pronounced &#x3057; (<q>shi</q>), so the user needs to use the <code class="key">'Convert'</code> key to select the proper option.</p>
					
				<div class="example">
					<div class="example-title"></div>
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-isComposing"><code>KeyboardEvent<br/>isComposing</code></a></th>
							<th class="cell-center"><a href="#widl-CompositionEvent-data"><code>CompositionEvent<br/>data</code></a></th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'s'</code></td>
							<td class="cell-center"><code>false</code></td>
							<td class="cell-center"></td>
							<td>Latin Small Letter S</td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code>''</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="glyph">'s'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'s'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'i'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td>Latin Small Letter I</td>
						</tr>
						<tr>
							<td class="cell-number">6.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="glyph">'&#x3057;'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">7.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'i'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">8.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Convert'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td>Convert</td>
						</tr>
						<tr>
							<td class="cell-number">9.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="glyph">'&#x8A69;'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">10.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Convert'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">11.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Convert'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td>Convert</td>
						</tr>
						<tr>
							<td class="cell-number">12.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="glyph">'&#x5E02;'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">13.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Convert'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">14.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Accept'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td>Accept</td>
						</tr>
						<tr>
							<td class="cell-number">15.</td>
							<td><a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="glyph">'&#x5E02;'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">16.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Accept'</code></td>
							<td class="cell-center"><code>false</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
					</table>
				</div>

				<p>IME composition can also be canceled as in the following example, with conditions identical to the previous example.
					The key <code class="key">'Cancel'</code> might also be replaced by others depending on the input device in use and 
					the configuration of the IME, e.g., it could be <code class="char">'\u001B'</code> (Escape key).</p>

				<div class="example">
					<div class="example-title"></div>
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-isComposing"><code>KeyboardEvent<br/>isComposing</code></a></th>
							<th class="cell-center"><a href="#widl-CompositionEvent-data"><code>CompositionEvent<br/>data</code></a></th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'s'</code></td>
							<td class="cell-center"><code>false</code></td>
							<td class="cell-center"></td>
							<td>Latin Small Letter S</td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-compositionstart"><code>compositionstart</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code>''</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="glyph">'s'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'s'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'i'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td>Latin Small Letter I</td>
						</tr>
						<tr>
							<td class="cell-number">6.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="glyph">'し'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">7.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'i'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">8.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Convert'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td>Convert</td>
						</tr>
						<tr>
							<td class="cell-number">9.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="glyph">'&#x8A69;'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">10.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Convert'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">11.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Convert'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td>Convert</td>
						</tr>
						<tr>
							<td class="cell-number">12.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="glyph">'&#x5E02;'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">13.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Convert'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">14.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Cancel'</code></td>
							<td class="cell-center"><code>true</code></td>
							<td class="cell-center"></td>
							<td>Cancel</td>
						</tr>
						<tr>
							<td class="cell-number">15.</td>
							<td><a class="eventtype" href="#event-type-compositionupdate"><code>compositionupdate</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code>''</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">16.</td>
							<td><a class="eventtype" href="#event-type-compositionend"><code>compositionend</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code>''</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">17.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Cancel'</code></td>
							<td class="cell-center"><code>false</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
					</table>
				</div>

				<p class="note"><strong>Note:</strong> Some <a class="def" href="#glossary-ime">input method editors</a> (such as on the MacOS operating system) might set an <a class="def" href="#glossary-empty-string">
					empty string</a> to the composition data attribute before canceling a composition.</p>

				<section id="keys-IME-keys">
					<h4>Input Method Editor mode keys</h4>

					<p>Some keys on certain devices are intended to activate <a class="def" href="#glossary-ime">input method editor</a> functionality, or to change the mode of an active
						<a class="def" href="#glossary-ime">input method editor</a>.  Custom keys for this purpose can be defined for different devices or language modes. The keys defined
						in this specification for this purpose are: <code>Alphanumeric</code>, <code>CodeInput</code>, <code>FinalMode</code>, <code>HangulMode</code>, <code>HanjaMode</code>,
						<code>Hiragana</code>, <code>JunjaMode</code>, <code>KanaMode</code>,
						<code>KanjiMode</code>, <code>Katakana</code>, and <code>RomanCharacters</code>.  When one of these keys is pressed, and no <a class="def" href="#glossary-ime">IME</a>
						is currently active, the appropriate <a class="def" href="#glossary-ime">IME</a> is expected to be activated in the mode indicated by the key (if available). If
						an <a class="def" href="#glossary-ime">IME</a> is already active when the key is pressed, the active <a class="def" href="#glossary-ime">IME</a> might change to
						the indicated mode, or a different <a class="def" href="#glossary-ime">IME</a> might be launched, or the might MAY be ignored, on a device- and application-specific
						basis.</p>

					<p>This specification also defines other keys which are intended for operation specifically with <a class="def" href="#glossary-ime">input method editors</a>: <code>
						Accept</code>, <code>AllCandidates</code>, <code>Cancel</code>, <code>Convert</code>, <code>Compose</code>, <code>FullWidth</code>, <code>HalfWidth</code>, <code>NextCandidate</code>,
						<code>Nonconvert</code>, and <code>PreviousCandidate</code>.  The functions of these keys are not defined in this specification &mdash; refer to other resources for details
						on <a class="def" href="#glossary-ime">input method editor</a> functionality.</p>

					<p class="note"><strong>Note:</strong> Keys with <a class="def" href="#glossary-ime">input method editor</a> functions are not restricted to that purpose, and can have other device- or implementation-specific
						purposes.</p>
				</section>  <!-- keys-IME-keys -->
			</section>  <!-- keys-IME -->

			<section id="keys-cancelable-keys">
				<h3>Default actions and cancelable keyboard events</h3>

				<p>Canceling the
						<a class="def" href="#glossary-default-action">default action</a>
					of a
						<a class="eventtype" href="#event-type-keydown"><code>keydown</code></a>
					event MUST NOT affect its respective
						<a class="eventtype" href="#event-type-keyup"><code>keyup</code></a>
					event, but it MUST prevent the respective
						<a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a>
					and
						<a class="eventtype" href="#event-type-input"><code>input</code></a>
					(and
						<a class="eventtype" href="#event-type-keypress"><code>keypress</code></a>
					if supported) events from being generated.
					The following example describes a possible sequence of keys to generate the Unicode character
					Q (Latin Capital Letter Q) on a US keyboard using a US mapping:
					</p>

				<div class="example">
					<div class="example-title"></div>
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
							<th class="cell-center"><a href="#widl-InputEvent-data"><code>InputEvent<br/>data</code></a></th>
							<th class="cell-center">Modifiers</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Shift'</code></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Q'</code></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							<td>The <a class="def" href="#glossary-default-action">default action</a> is
								prevented, e.g., by invoking <a href="#widl-Event-preventDefault"><code>Event.preventDefault()</code></a>.
								</td>
						</tr>
						<tr>
							<td class="cell-number"></td>
							<td></td>
							<td></td>
							<td></td>
							<td></td>
							<td><em>No
									<a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a>
								or
									<a class="eventtype" href="#event-type-input"><code>input</code></a>
								(or 
									<a class="eventtype" href="#event-type-keypress"><code>keypress</code></a>,
								if supported) events are generated</em>
								</td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Q'</code></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Shift'</code></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
					</table>
				</div>

				<p>If the key is a modifier key, the keystroke MUST still be taken into account for the modifiers states. The following example describes a possible sequence of keys
					to generate the Unicode character Q (Latin Capital Letter Q) on a US keyboard using a US mapping:</p>

				<div class="example">
					<div class="example-title"></div>
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
							<th class="cell-center"><a href="#widl-InputEvent-data"><code>InputEvent<br/>data</code></a></th>
							<th class="cell-center">Modifiers</th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Shift'</code></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							<td>The <a class="def" href="#glossary-default-action">default action</a> is
								prevented, e.g., by invoking <a href="#widl-Event-preventDefault"><code>Event.preventDefault()</code></a>.
								</td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Q'</code></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="glyph">'Q'</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-input"><code>input</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Q'</code></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="attribute-name"><a href="#widl-MouseEvent-shiftKey">shiftKey</a></code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">6.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Shift'</code></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
					</table>
				</div>

				<p>If the key is part of a sequence of several keystrokes, whether it is a <a class="def" href="#glossary-dead-key">dead key</a> or
					it is contributing to an Input Method Editor sequence, the keystroke MUST be ignored (not taken into account) only if the 
					<a class="def" href="#glossary-default-action">default action</a> is canceled on the 
					<a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> event. Canceling a 
					<a class="def" href="#glossary-dead-key">dead key</a> on a 
					<a class="eventtype" href="#event-type-keyup"><code>keyup</code></a> event has no effect on
					<a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a> or
					<a class="eventtype" href="#event-type-input"><code>input</code></a> events.
					The following example uses the dead key <code class="key">'Dead'</code> (<code class="char">'\u0302'</code> Combining Circumflex 
					Accent key) and <code class="key">'e'</code> (<code class="char">'\u0065'</code>, Latin Small Letter E key) on a French 
					keyboard using a French mapping and without any modifier activated:</p>

				<div class="example">
					<div class="example-title"></div>
					<table class="event-sequence-table">
						<tr>
							<td class="cell-number"></td>
							<th>Event Name</th>
							<th class="cell-center"><a href="#widl-KeyboardEvent-key"><code>KeyboardEvent<br/>key</code></a></th>
							<th class="cell-center"><a href="#widl-InputEvent-data"><code>InputEvent<br/>data</code></a></th>
							<th>Notes</th>
						</tr>
						<tr>
							<td class="cell-number">1.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'Dead'</code></td>
							<td class="cell-center"></td>
							<td>The <a class="def" href="#glossary-default-action">default action</a> is
								prevented, e.g., by invoking <a href="#widl-Event-preventDefault"><code>Event.preventDefault()</code></a>.
								</td>
						</tr>
						<tr>
							<td class="cell-number">2.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'Dead'</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">3.</td>
							<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
							<td class="cell-center"><code class="key">'e'</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">4.</td>
							<td><a class="eventtype" href="#event-type-beforeinput"><code>beforeinput</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"><code class="glyph">'e'</code></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">5.</td>
							<td><a class="eventtype" href="#event-type-input"><code>input</code></a></td>
							<td class="cell-center"></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
						<tr>
							<td class="cell-number">6.</td>
							<td><a class="eventtype" href="#event-type-keyup"><code>keyup</code></a></td>
							<td class="cell-center"><code class="key">'e'</code></td>
							<td class="cell-center"></td>
							<td></td>
						</tr>
					</table>
				</div>
			</section>  <!-- keys-cancelable-keys -->

			<section id="keys-guidelines">
				<h3>Guidelines for selecting key values</h3>

				<p><strong>This section is normative.</strong></p>

				<p>To determine the appropriate key value for a key, use the following algorithm:
					</p>

				<ol class="algo" id="key-algorithm">
					<li>If there exists an appropriate character in the <a href="#keys-keyvalues">key values set</a>,
						then the
							<a href="#widl-KeyboardEvent-key"><code>KeyboardEvent.key</code></a>
						attribute MUST be a string consisting of the <em>key value</em> of that character.
						</li>
					<li>If the key generates a printable character, 
						and there exists an appropriate
							<a class="def" href="#glossary-unicode-code-point">Unicode code point</a>,
						then the
							<a href="#widl-KeyboardEvent-key"><code>KeyboardEvent.key</code></a>
						attribute MUST be a string consisting of the <em>char value</em> of that character.
						</li>
					<li>If more than one key is being pressed and the key combination includes one or more modifier keys that result in the key
						no longer producing a printable character (e.g., <code class="glyph">'Control'</code> + <code class="glyph">'a'</code>),
						then the key value should be the printable key value that would have been 
						produced if the key had been typed with the default keyboard layout
						with no modifier keys except for <code class="key">'Shift'</code> and <code class="key">'AltGr'</code> applied.
						</li>
					<li>Otherwise, the special value <code class="key">'Unidentified'</code> should be used.
						</li>
				</ol>

				<div class="example">
					<div class="example-title"></div>
					<ul>
						<li>On a US keyboard with a right-handed single-hand Dvorak
								<a class="def" href="#glossary-key-mapping">key mapping</a>,
							the key labeled
								<code class="glyph">'Q'</code>
							maps to the key values
								<code class="key">'5'</code> (unmodified)
							and
								<code class="key">'%'</code> (shifted).
							The primary function of this key is to generate the character
								<code class="key">'5'</code> (<code class="char">'\u0035'</code>).
							Since this character is a character (in Unicode general category
							<abbr title="Number, Decimal Digit">Nd</abbr>), the
								<a href="#widl-KeyboardEvent-key"><code>KeyboardEvent.key</code></a>
							attribute value for the unmodified key will be <code class="key">'5'</code>.
							</li>
						<li>On the same US Dvorak keyboard layout as the previous example,
							pressing <code class="glyph">'Control'</code> and the key labeled <code class="glyph">'Q'</code>
							will produce a key value of <code class="key">'q'</code>.
							</li>
						<li>On a French PC keyboard with a standard French mapping, the primary function of the
								<code class="glyph">'^'</code>
							key is to act as a
								<a class="def" href="#glossary-dead-key">dead key</a>
							for the combining circumflex diacritical mark.
							The value for this key is <code class="key">'Dead'</code>.
							</li>
						<li>Also on a French PC keyboard with a standard French mapping, the
								<code class="glyph">'&#x00e9;'</code>
							key (which corresponds to the <code class="glyph">'2'</code> key on a US keyboard)
							generates a key value of <code class="key">'&#x00e9;'</code> (<code class="char">'\u00e9'</code>).
							</li>
						<li>On a Korean PC keyboard with a standard Korean mapping, the primary function of the
								<code class="glyph">'Ha/En'</code>
							key is to switch between Hangul and English input.
							The predefined key value list has an appropriate entry for this key,
								<code class="key">'HangulMode'</code>,
							so this will be the key value.
							</li>
						<li>On some mobile devices, there are special keys to launch specific applications.
							For a standard application like Calendar, there is a predefined key value of
								<code class="key">'LaunchCalendar'</code>.
							</li>
					</ul>
				</div>

				<p>While every attempt has been made to make this list of key values as complete as possible, new key values
					will periodically need to be defined as new input devices are introduced.
					Rather than allowing user agents to define their own key values (which may not work across multiple user
					agents), bugs should be filed so that this specification can be updated. 
					</p>

			</section>  <!-- keys-guidelines -->
		</section>  <!-- keys-keyvalues -->

	</section>  <!-- keys -->

	<!-- Appendix A: Legacy Event Initializers ========================================================-->
	<section id="legacy-event-initializers" class="appendix">
		<h1>Legacy Event Initializers</h1>

		<p><em>This section is informative</em></p>

		<p>Early versions of this specification included an initialization method on the
			interface (for example <code>initMouseEvent</code>) that required a long list of parameters
			that, in most cases, did not fully initialize all attributes of the event object.
			Because of this, event interfaces which were derived from the basic <code>Event</code> interface
			required that the initializer of <em>each</em> of the derived
			interfaces be called explicitly in order to fully initialize an event.
			</p>
			
		<div class="example">
			<div class="example-title"></div>
			<p>Initializing all the attributes of a MutationEvent requires calls to two initializer methods:
				<code>initEvent</code> and <code>initMutationEvent</code>.
				</p>
		</div>

		<p>Due in part to the length of time in the development of this standard, some implementations MAY have
			taken a dependency on these (now deprecated) initializer methods.
			For completeness, these legacy event intializers are described in this Appendix.
			</p>

		<section id="legacy-event-initializer-interfaces">
			<h2>Legacy Event Initializer Interfaces</h2>
			<p><em>This section is informative</em></p>

			<p>This section documents legacy initializer methods that were introduced in earlier
				versions of the DOM Level 3 Events specification.
				</p>

			<section id="idl-interface-CustomEvent-initializers">
				<h3>Initializers for interface CustomEvent</h3>

				<dl class="idl" title="partial interface CustomEvent">
					<dt>// Originally introduced (and deprecated) in DOM Level 3</dt>
					<dd></dd>
					<dt>void initCustomEvent()</dt>
					<dd>
						<p>Initializes attributes of a <code>CustomEvent</code> object. This method has the
							same behavior as <a href="#widl-Event-initEvent"><code>Event.initEvent()</code></a>.
							</p>

						<p class="warning"><strong>Warning!</strong>
							The <code>initCustomEvent</code> method is deprecated.
							</p>

						<dl class="parameters">
							<dt>DOMString typeArg</dt>
							<dd><p>Refer to the <a href="#widl-Event-initEvent"><code>Event.initEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>boolean bubblesArg</dt>
							<dd><p>Refer to the <a href="#widl-Event-initEvent"><code>Event.initEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>boolean cancelableArg</dt>
							<dd><p>Refer to the <a href="#widl-Event-initEvent"><code>Event.initEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>any detailArg</dt>
							<dd><p>Specifies <a href="#widl-CustomEvent-detail"><code>CustomEvent.detail</code></a>.</p></dd>
						</dl>
					</dd>
				</dl>
			</section>  <!-- idl-interface-CustomEvent-initializers -->

			<section id="idl-interface-UIEvent-initializers">
				<h3>Initializers for interface UIEvent</h3>

				<dl class="idl" title="partial interface UIEvent">
					<dt>// Deprecated in DOM Level 3</dt>

					<dt>void initUIEvent()</dt>
					<dd>
						<p>Initializes attributes of an <code>UIEvent</code> object.
							This method has the same behavior as <a href="#widl-Event-initEvent"><code>Event.initEvent()</code></a>.
							</p>

						<p class="warning"><strong>Warning!</strong>
							The <code>initUIEvent</code> method is deprecated, but supported for
							backwards-compatibility with widely-deployed implementations.
							</p>

						<dl class="parameters">
							<dt>DOMString typeArg</dt>
							<dd>
								<p>Refer to the <a href="#widl-Event-initEvent"><code>Event.initEvent()</code></a> method for a description of this parameter.</p>
							</dd>

							<dt>boolean bubblesArg</dt>
							<dd>
								<p>Refer to the <a href="#widl-Event-initEvent"><code>Event.initEvent()</code></a> method for a description of this parameter.</p>
							</dd>

							<dt>boolean cancelableArg</dt>
							<dd>
								<p>Refer to the <a href="#widl-Event-initEvent"><code>Event.initEvent()</code></a> method for a description of this parameter.</p>
							</dd>

							<dt>Window? viewArg</dt>
							<dd>
								<p>Specifies <a href="#widl-UIEvent-view"><code>UIEvent.view</code></a>. This value MAY be <code>null</code>.</p>
							</dd>

							<dt>long detailArg</dt>
							<dd>
								<p>Specifies <a href="#widl-UIEvent-detail"><code>UIEvent.detail</code></a>.</p>
							</dd>
						</dl>
					</dd>
				</dl>
			</section>  <!-- idl-interface-UIEvent-initializers -->

			<section id="idl-interface-FocusEvent-initializers">
				<h3>Initializers for interface FocusEvent</h3>

				<dl class="idl" title="partial interface FocusEvent">
					<dt>// Originally introduced (and deprecated) in DOM Level 3</dt>
					<dd></dd>
					<dt>void initFocusEvent()</dt>
					<dd>
						<p>Initializes attributes of a <code>FocusEvent</code> object.
							This method has the same behavior as
							<a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a>.
							</p>

						<p class="warning"><strong>Warning!</strong>
							The <code>initFocusEvent</code> method is deprecated.
							</p>

						<dl class="parameters">
							<dt>DOMString typeArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>boolean bubblesArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>boolean cancelableArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>Window? viewArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>long detailArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>EventTarget? relatedTargetArg</dt>
							<dd><p>Specifies <a href="#widl-FocusEvent-relatedTarget"><code>FocusEvent.relatedTarget</code></a>. This value MAY be <code>null</code>.</p></dd>
						</dl>
					</dd>
				</dl>
			</section>  <!-- idl-interface-FocusEvent-initializers -->

			<section id="idl-interface-MouseEvent-initializers">
				<h3>Initializers for interface MouseEvent</h3>

				<dl class="idl" title="partial interface MouseEvent">
					<dt>// Deprecated in DOM Level 3</dt>

					<dt>void initMouseEvent()</dt>
					<dd>
						<p>Initializes attributes of a <code>MouseEvent</code> object.
							This method has the same behavior as <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a>.
							</p>

						<p class="warning"><strong>Warning!</strong>
							The <code>initMouseEvent</code> method is deprecated, but supported for
							backwards-compatibility with widely-deployed implementations.
							</p>

						<dl class="parameters">
							<dt>DOMString typeArg</dt>
							<dd>
								<p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p>
							</dd>

							<dt>boolean bubblesArg</dt>
							<dd>
								<p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p>
							</dd>

							<dt>boolean cancelableArg</dt>
							<dd>
								<p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p>
							</dd>

							<dt>Window? viewArg</dt>
							<dd>
								<p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p>
							</dd>

							<dt>long detailArg</dt>
							<dd>
								<p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p>
							</dd>

							<dt>long screenXArg</dt>
							<dd>
								<p>Specifies <a href="#widl-MouseEvent-screenX"><code>MouseEvent.screenX</code></a>.</p>
							</dd>

							<dt>long screenYArg</dt>
							<dd>
								<p>Specifies <a href="#widl-MouseEvent-screenY"><code>MouseEvent.screenY</code></a>.</p>
							</dd>

							<dt>long clientXArg</dt>
							<dd>
								<p>Specifies <a href="#widl-MouseEvent-clientX"><code>MouseEvent.clientX</code></a>.</p>
							</dd>

							<dt>long clientYArg</dt>
							<dd>
								<p>Specifies <a href="#widl-MouseEvent-clientY"><code>MouseEvent.clientY</code></a>.</p>
							</dd>

							<dt>boolean ctrlKeyArg</dt>
							<dd>
								<p>Specifies <a href="#widl-MouseEvent-ctrlKey"><code>MouseEvent.ctrlKey</code></a>.</p>
							</dd>

							<dt>boolean altKeyArg</dt>
							<dd>
								<p>Specifies <a href="#widl-MouseEvent-altKey"><code>MouseEvent.altKey</code></a>.</p>
							</dd>

							<dt>boolean shiftKeyArg</dt>
							<dd>
								<p>Specifies <a href="#widl-MouseEvent-shiftKey"><code>MouseEvent.shiftKey</code></a>.</p>
							</dd>

							<dt>boolean metaKeyArg</dt>
							<dd>
								<p>Specifies <a href="#widl-MouseEvent-metaKey"><code>MouseEvent.metaKey</code></a>.</p>
							</dd>

							<dt>short buttonArg</dt>
							<dd>
								<p>Specifies <a href="#widl-MouseEvent-button"><code>MouseEvent.button</code></a>.</p>
							</dd>

							<dt>EventTarget? relatedTargetArg</dt>
							<dd>
								<p>Specifies <a href="#widl-MouseEvent-relatedTarget"><code>MouseEvent.relatedTarget</code></a>. This value MAY be <code>null</code>.</p>
							</dd>
						</dl>
					</dd>

				</dl>
			</section>  <!-- idl-interface-MouseEvent-initializers -->

			<section id="idl-interface-WheelEvent-initializers">
				<h3>Initializers for interface WheelEvent</h3>

				<dl class="idl" title="partial interface WheelEvent">
					<dt>// Originally introduced (and deprecated) in DOM Level 3</dt>
					<dd></dd>
					<dt>void initWheelEvent()</dt>
					<dd>
						<p>Initializes attributes of a <code>WheelEvent</code> object.
							This method has the same behavior as
							<a href="#widl-MouseEvent-initMouseEvent"><code>MouseEvent.initMouseEvent()</code></a>.
							</p>

						<p class="warning"><strong>Warning!</strong>
							The <code>initWheelEvent</code> method is deprecated.
							</p>

						<dl class="parameters">
							<dt>DOMString typeArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>boolean bubblesArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>boolean cancelableArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>Window? viewArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>long detailArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>long screenXArg</dt>
							<dd><p>Refer to the <a href="#widl-MouseEvent-initMouseEvent"><code>MouseEvent.initMouseEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>long screenYArg</dt>
							<dd><p>Refer to the <a href="#widl-MouseEvent-initMouseEvent"><code>MouseEvent.initMouseEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>long clientXArg</dt>
							<dd><p>Refer to the <a href="#widl-MouseEvent-initMouseEvent"><code>MouseEvent.initMouseEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>long clientYArg</dt>
							<dd><p>Refer to the <a href="#widl-MouseEvent-initMouseEvent"><code>MouseEvent.initMouseEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>short buttonArg</dt>
							<dd><p>Refer to the <a href="#widl-MouseEvent-initMouseEvent"><code>MouseEvent.initMouseEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>EventTarget? relatedTargetArg</dt>
							<dd><p>Refer to the <a href="#widl-MouseEvent-initMouseEvent"><code>MouseEvent.initMouseEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>DOMString modifiersListArg</dt>
							<dd>
								<p>A <a class="normative" href="http://www.w3.org/TR/2004/REC-xml-20040204/#NT-S"><em>white space</em></a>
									separated list of modifier key values to be activated on this object.
									As an example, <code>"Control Shift"</code> marks the control and shift modifiers as activated
									(the <a href="#widl-MouseEvent-ctrlKey"><code>MouseEvent.ctrlKey</code></a> and
									<a href="#widl-MouseEvent-shiftKey"><code>MouseEvent.shiftKey</code></a> inherited attributes
									will be <code>true</code> on the initialized <code>WheelEvent</code> object).
									</p>
							</dd>

							<dt>double deltaXArg</dt>
							<dd><p>Specifies <a href="#widl-WheelEvent-deltaX"><code>WheelEvent.deltaX</code></a>.</p></dd>

							<dt>double deltaYArg</dt>
							<dd><p>Specifies <a href="#widl-WheelEvent-deltaY"><code>WheelEvent.deltaY</code></a>.</p></dd>

							<dt>double deltaZArg</dt>
							<dd><p>Specifies <a href="#widl-WheelEvent-deltaZ"><code>WheelEvent.deltaZ</code></a>.</p></dd>

							<dt>unsigned long deltaMode</dt>
							<dd><p>Specifies <a href="#widl-WheelEvent-deltaMode"><code>WheelEvent.deltaMode</code></a>.</p></dd>
						</dl>
					</dd>
				</dl>
			</section>  <!-- idl-interface-WheelEvent-initializers -->

			<section id="idl-interface-KeyboardEvent-initializers">
				<h3>Initializers for interface KeyboardEvent</h3>
				<p class="note"><strong>Note: </strong>The argument list to this legacy KeyboardEvent initializer does not include 
					the <code>detailArg</code> (present in other initializers) and adds the <code>locale</code> argument (see 
					<a href="#changes-drafts">Changes between different drafts of DOM Level 3 Events</a>); it is necessary
					to preserve this inconsistency for compatibility with existing implementations.</p>
				<dl class="idl" title="partial interface KeyboardEvent">
					<dt>// Originally introduced (and deprecated) in DOM Level 3</dt>
					<dd></dd>
					<dt>void initKeyboardEvent()</dt>
					<dd>
						<p>Initializes attributes of a <a href="#interface-KeyboardEvent"><code>KeyboardEvent</code></a> object.
							This method has the same behavior as <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a>.
							The value of <a href="#widl-UIEvent-detail"><code>UIEvent.detail</code></a> remains undefined.
							</p>

						<p class="warning"><strong>Warning!</strong>
							The <code>initKeyboardEvent</code> method is deprecated.
							</p>

						<dl class="parameters">
							<dt>DOMString typeArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>boolean bubblesArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>boolean cancelableArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>Window? viewArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>DOMString keyArg</dt>
							<dd><p>Specifies <a href="#widl-KeyboardEvent-key"><code>KeyboardEvent.key</code></a>.</p></dd>

							<dt>unsigned long locationArg</dt>
							<dd><p>Specifies <a href="#widl-KeyboardEvent-location"><code>KeyboardEvent.location</code></a>.</p></dd>

							<dt>DOMString modifiersListArg</dt>
							<dd><p>A <a class="normative" href="http://www.w3.org/TR/2004/REC-xml-20040204/#NT-S"><em>white space</em></a>
								separated list of modifier key values to be activated on this object.
								As an example, <code>"Control Alt"</code> marks the control and alt modifiers as activated.
								</p>
							</dd>

							<dt>boolean repeat</dt>
							<dd><p>Specifies whether the key event is repeating. See <a href="#widl-KeyboardEvent-repeat"><code>KeyboardEvent.repeat</code></a>.</p></dd>
						
							<dt>DOMString locale</dt>
							<dd><p>Specifies the <code>locale</code> attribute of the KeyboardEvent.
								This attribute is not defined in DOM3, but will be included in the
								[<a href="#references-UIEvents">UI Events</a>] specification.
								User agents which do not support <code>locale</code> should ignore this parameter.
								</p></dd>
						</dl>
					</dd>
				</dl>
			</section>  <!-- idl-interface-KeyboardEvent-initializers -->

			<section id="idl-interface-CompositionEvent-initializers">
				<h3>Initializers for interface CompositionEvent</h3>
				<p class="note"><strong>Note: </strong>The argument list to this legacy CompositionEvent initializer does not include 
					the <code>detailArg</code> (present in other initializers) and adds the <code>locale</code> argument (see 
					<a href="#changes-drafts">Changes between different drafts of DOM Level 3 Events</a>); it is necessary
					to preserve this inconsistency for compatibility with existing implementations.</p>
				<dl class="idl" title="partial interface CompositionEvent">
					<dt>// Originally introduced (and deprecated) in DOM Level 3</dt>
					<dd></dd>
					<dt>void initCompositionEvent()</dt>
					<dd>
						<p>Initializes attributes of a <code>CompositionEvent</code> object.
							This method has the same behavior as <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a>.
							The value of <a href="#widl-UIEvent-detail"><code>UIEvent.detail</code></a> remains undefined.
							</p>

						<p class="warning"><strong>Warning!</strong>
							The <code>initCompositionEvent</code> method is deprecated.
							</p>

						<dl class="parameters">
							<dt>DOMString typeArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>boolean bubblesArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>boolean cancelableArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>Window? viewArg</dt>
							<dd><p>Refer to the <a href="#widl-UIEvent-initUIEvent"><code>UIEvent.initUIEvent()</code></a> method for a description of this parameter.</p></dd>

							<dt>DOMString dataArg</dt>
							<dd><p>Specifies <a href="#widl-CompositionEvent-data"><code>CompositionEvent.data</code></a>.</p></dd>

							<dt>DOMString locale</dt>
							<dd><p>Specifies the <code>locale</code> attribute of the CompositionEvent.
								This attribute is not defined in DOM3, but will be included in the
								[<a href="#references-UIEvents">UI Events</a>] specification.
								User agents which do not support <code>locale</code> should ignore this parameter.
								</p></dd>
						</dl>
					</dd>
				</dl>
			</section>  <!-- idl-interface-CompositionEvent-initializers -->

		</section>  <!-- legacy-event-initializer-interfaces -->
	</section>  <!-- legacy-event-initializers -->

	<!-- Appendix B: Legacy Key Attributes ========================================================-->
	<section id="legacy-key-attributes">
		<h1>Legacy Key Attributes</h1>
		<p><em>This section is informative</em></p>

		<p>This section provides a non-normative description of the attributes that are currently used when
			handling keyboard events.
			</p>

		<p>These features were never formally specified and the current browser implementations vary in
			significant ways.
			The large amount of legacy content, including script libraries, that relies upon detecting the
			<a class="def" href="#glossary-user-agent">user agent</a> and acting accordingly means that any
			attempt to formalize these legacy attributes and events would risk breaking as much content as
			it would fix or enable.
			Additionally, these attributes are not suitable for international usage, nor do they address
			accessibility concerns.
			</p>

		<p>Therefore, this specification does not normatively define the events and attributes commonly employed
			for handling keyboard input, though they MAY be present in
			<a class="def" href="#glossary-user-agent">user agents</a> for compatibility with legacy content.
			Authors SHOULD use the <a href="#widl-KeyboardEvent-key"><code>KeyboardEvent.key</code></a> attribute
			instead of the <code class="attribute-name">charCode</code>
			and <code class="attribute-name">keyCode</code> attributes.
			</p>

		<p>However, for the purpose of documenting the current state of these features and their relation to
			normative events and attributes, this section provides an informative description.
			For implementations which do support these attributes and events, it is suggested that the definitions
			provided in this section be used.
			</p>

		<section id="KeyboardEvent-supplemental-interface">
			<h2>Legacy <a href="#interface-KeyboardEvent"><code>KeyboardEvent</code></a> supplemental interface</h2>
			<p><em>This section is informative</em></p>
			
			<p>Browser support for keyboards has traditionally relied on three ad-hoc attributes,
				<code class="attribute-name">keyCode</code>, <code class="attribute-name">charCode</code>,
				and <code class="attribute-name">which</code>.</p>

			<p>All three of these attributes return a numerical code that represents some aspect of the key pressed:
				<code class="attribute-name">keyCode</code> is an index of the key itself.
				<code class="attribute-name">charCode</code> is the ASCII value of the character keys.
				<code class="attribute-name">which</code> is the character value where available and otherwise the key index.
				The values for these attributes, and the availability of the attribute, is inconsistent across
				platforms, keyboard languages and layouts, <a class="def" href="#glossary-user-agent">user agents</a>,
				versions, and even event types.
				</p>

			<dl>
				<dt id="events-KeyboardEvent-supplemental"><strong>Interface <em>KeyboardEvent (supplemental)</em></strong></dt>
				<dd>
					<p class="intro-dom">Introduced in DOM Level 3</p>
					
					<p>The partial
							<a href="#interface-KeyboardEvent"><code>KeyboardEvent</code></a>
						interface is an informative extension of the
							<a href="#interface-KeyboardEvent">KeyboardEvent</a>
						interface, which adds the
							<a href="#widl-KeyboardEvent-charCode">charCode</a>,
							<a href="#widl-KeyboardEvent-keyCode">keyCode</a>,
							and <a href="#widl-KeyboardEvent-which">which</a>
						attributes.</p>

					<p>The partial
							<a href="#interface-KeyboardEvent"><code>KeyboardEvent</code></a>
						interface can be obtained by using the
							<a href="#widl-DocumentEvent-createEvent"><code>DocumentEvent.createEvent("KeyboardEvent")</code></a>
						method call in implementations that support this extension.</p>

					<dl class="idl" title="partial interface KeyboardEvent">
						<dt>// The following support legacy user agents</dt>
						<dd></dd>

						<dt>readonly attribute unsigned long charCode</dt>
						<dd>
							<p><code class="attribute-name">charCode</code> holds a character value, for
								<a class="eventtype" href="#event-type-keypress"><code>keypress</code></a> events which
								generate character input.
								The value is the Unicode reference number (code point) of that character (e.g.
								<code>event.charCode = event.key.charCodeAt(0)</code> for printable characters).
								For <a class="eventtype" href="#event-type-keydown"><code>keydown</code></a> or
								<a class="eventtype" href="#event-type-keyup"><code>keyup</code></a> events, the
								value of <code class="attribute-name">charCode</code> is <code>0</code>.
								</p>
						</dd>

						<dt>readonly attribute unsigned long keyCode</dt>
						<dd>
							<p><code class="attribute-name">keyCode</code> holds a system- and implementation-dependent
								numerical code signifying the unmodified identifier associated with the key pressed.
								Unlike the <a href="#widl-KeyboardEvent-key"><code>KeyboardEvent.key</code></a>
								attribute, the set of possible values are not normatively defined in this specification.
								Typically, these value of the <code class="attribute-name">keyCode</code>
								SHOULD represent the decimal codepoint in
								ASCII [<a href="#ref-rfc20">RFC20</a>][<a href="#ref-US-ASCII">US-ASCII</a>]
								or Windows 1252 [<a href="#ref-WIN1252">WIN1252</a>],
								but MAY be drawn from a different appropriate character set.
								Implementations that are unable to identify a key use the key value
								<code class="key">'0'</code>.
								</p>

							<p>See <a href="#legacy-key-models">Legacy key models</a> for more details on how to
								determine the values for <code class="attribute-name">keyCode</code>.
								</p>
						</dd>

						<dt>readonly attribute unsigned long which</dt>
						<dd>
							<p><code>which</code> holds a system- and implementation-dependent numerical code
								signifying the unmodified identifier associated with the key pressed.
								In most cases, the value is identical to
								<code class="attribute-name"><a href="#widl-KeyboardEvent-keyCode">keyCode</a></code>.
								</p>
						</dd>
					</dl>

				</dd>
			</dl>

			<dl>
				<dt id="events-KeyboardEventInit-supplemental"><strong>dictionary <em>KeyboardEventInit (supplemental)</em></strong></dt>
				<dd>
					<p>Browsers that include support for
							<code class="attribute-name">keyCode</code>,
							<code class="attribute-name">charCode</code>,
						and
							<code class="attribute-name">which</code>
						in <code>KeyboardEvent</code> should also add the following members to the
						<code>KeyboardEventInit</code> dictionary.
						</p>

					<p>The partial
							<a href="#interface-KeyboardEvent"><code>KeyboardEventInit</code></a>
						dictionary is an informative extension of the
							<a href="#interface-KeyboardEvent">KeyboardEventInit</a>
						dictionary, which adds
							<a href="#widl-KeyboardEvent-charCode">charCode</a>,
							<a href="#widl-KeyboardEvent-keyCode">keyCode</a>,
							and <a href="#widl-KeyboardEvent-which">which</a>
						members to initialize the corresponding <code>KeyboardEvent</code> attributes.</p>

					<dl class="idl" title="partial dictionary KeyboardEventInit">
						<dt>unsigned long charCode = 0</dt>
						<dd>
							<p>Initializes the <code class="attribute-name">charCode</code> attribute of the 
								KeyboardEvent to the Unicode code point for the event's character.
								</p>
						</dd>

						<dt>unsigned long keyCode = 0</dt>
						<dd>
							<p>Initializes the <code class="attribute-name">keyCode</code> attribute of the 
								KeyboardEvent to the system- and implementation-dependent
								numerical code signifying the unmodified identifier associated with the key pressed.
								</p>
						</dd>

						<dt>unsigned long which = 0</dt>
						<dd>
							<p>Initializes the <code>which</code> attribute of the KeyboardEvent
								to the implementation-dependent numerical code
								signifying the unmodified identifier associated with the key pressed.
								In most cases, the value is identical to
								<code class="attribute-name"><a href="#widl-KeyboardEvent-keyCode">keyCode</a></code>.
								</p>
						</dd>
					</dl>
				</dd>
			</dl>

		</section>

		<section id="legacy-key-models">
			<h2>Legacy key models</h2>
			<p><em>This section is informative</em></p>

			<p>Implementations differ on which values are exposed on these attributes for different event types.
				An implementation MAY choose to expose both virtual key codes and character codes in the
				<code class="attribute-name">keyCode</code> property (<em>conflated model</em>), or report
				separate <code class="attribute-name">keyCode</code> and <code class="attribute-name">charCode</code>
				properties (<em>split model</em>).
				</p>

			<section id="determine-keydown-keyup-keyCode">
				<h3>How to determine <code class="attribute-name">keyCode</code> for <code>keydown</code> and <code>keyup</code> events</h3>

				<p>The <code class="attribute-name">keyCode</code> for
					<a class="eventtype" href="#event-type-keydown"><code>keydown</code></a>
					or <a class="eventtype" href="#event-type-keyup"><code>keyup</code></a> events is calculated
					as follows:
					</p>

				<ol>
					<li>Read the virtual key code from the operating system's event information, if such information
						is available.</li>
					<li>If an Input Method Editor is processing key input and the event is
						<a class="eventtype" href="#event-type-keydown"><code>keydown</code></a>, return 229.</li>
					<li>If input key when pressed without modifiers would insert a numerical character (0-9),
						return the ASCII code of that numerical character.</li>
					<li>If input key when pressed without modifiers would insert a lower case character in the
						a-z alphabetical range, return the ASCII code of the upper case equivalent.</li>
					<li>If the implementation supports a key code conversion table for the operating system and platform,
						look up the value. If the conversion table specifies an alternate virtual key value for the given
						input, return the specified value.</li>
					<li>If the key's function, as determined in an implementation-specific way, corresponds to one of
						the keys in the <a href="#fixed-virtual-key-codes">table of fixed virtual key codes</a>,
						return the corresponding key code.</li>
					<li>Return the virtual key code from the operating system.</li>
					<li>If no key code was found, return 0.</li>
				</ol>
			</section>

			<section id="determine-keypress-keyCode">
				<h3>How to determine <code class="attribute-name">keyCode</code> for <a class="eventtype" href="#event-type-keypress"><code>keypress</code></a> events</h3>

				<p>The <code class="attribute-name">keyCode</code> for
					<a class="eventtype" href="#event-type-keypress"><code>keypress</code></a> events is
					calculated as follows:
					</p>

				<ol>
					<li>If the implementation supports a <em>conflated model</em>, set <code class="attribute-name">keyCode</code>
						to the Unicode code point of the character being entered.</li>
					<li>If the implementation supports a <em>split model</em>, set <code class="attribute-name">keyCode</code> to 0.</li>
				</ol>
			</section>

			<section id="fixed-virtual-key-codes">
				<h3>Fixed virtual key codes</h3>

				<p>The virtual key codes for the following keys do not usually change with keyboard layouts
					on desktop systems:
					</p>

				<table class="legacy-key-table">
					<tr>
						<th>Key</th>
						<th class="cell-center">Virtual Key</br/>Code</th>
						<th>Notes</th>
					</tr>
					<tr><td><code class="key">'Backspace'</code></td>		<td class="cell-center">8</td>		<td></td>	</tr>
					<tr><td><code class="key">'Tab'</code></td>				<td class="cell-center">9</td>		<td></td>	</tr>
					<tr><td><code class="key">'Enter'</code></td>			<td class="cell-center">13</td>		<td></td>	</tr>
					<tr><td><code class="key">'Shift'</code></td>			<td class="cell-center">16</td>		<td></td>	</tr>
					<tr><td><code class="key">'Control'</code></td>			<td class="cell-center">17</td>		<td></td>	</tr>
					<tr><td><code class="key">'Alt'</code></td>				<td class="cell-center">18</td>		<td></td>	</tr>
					<tr><td><code class="key">'CapsLock'</code></td>		<td class="cell-center">20</td>		<td></td>	</tr>
					<tr><td><code class="key">'Escape'</code></td>			<td class="cell-center">27</td>		<td><em>Esc</em></td>	</tr>
					<tr><td><code class="key">' '</code></td>				<td class="cell-center">32</td>		<td><em>Space</em></td>	</tr>
					<tr><td><code class="key">'PageUp'</code></td>			<td class="cell-center">33</td>		<td></td>	</tr>
					<tr><td><code class="key">'PageDown'</code></td>		<td class="cell-center">34</td>		<td></td>	</tr>
					<tr><td><code class="key">'End'</code></td>				<td class="cell-center">35</td>		<td></td>	</tr>
					<tr><td><code class="key">'Home'</code></td>			<td class="cell-center">36</td>		<td></td>	</tr>
					<tr><td><code class="key">'ArrowLeft'</code></td>		<td class="cell-center">37</td>		<td></td>	</tr>
					<tr><td><code class="key">'ArrowUp'</code></td>			<td class="cell-center">38</td>		<td></td>	</tr>
					<tr><td><code class="key">'ArrowRight'</code></td>		<td class="cell-center">39</td>		<td></td>	</tr>
					<tr><td><code class="key">'ArrowDown'</code></td>		<td class="cell-center">40</td>		<td></td>	</tr>
					<tr><td><code class="key">'Delete'</code></td>			<td class="cell-center">46</td>		<td><em>Del</em></td>	</tr>
				</table>
			</section>

			<section id="optionally-fixed-virtual-key-codes">
				<h3>Optionally fixed virtual key codes</h3>

				<p>The following punctuation characters MAY change virtual codes between keyboard layouts, but reporting
					these values will likely be more compatible with legacy content expecting US-English keyboard layout:
					</p>

				<table class="legacy-key-table">
					<tr>
						<th>Key</th>
						<th class="cell-center">Character</th>
						<th class="cell-center">Virtual Key</br/>Code</th>
					</tr>
					<tr><td>Semicolon</td>				<td class="cell-center"><code class="glyph">';'</code></td>		<td class="cell-center">186</td>	</tr>
					<tr><td>Colon</td>					<td class="cell-center"><code class="glyph">':'</code></td>		<td class="cell-center">186</td>	</tr>
					<tr><td>Equals sign</td>			<td class="cell-center"><code class="glyph">'='</code></td>		<td class="cell-center">187</td>	</tr>
					<tr><td>Plus</td>					<td class="cell-center"><code class="glyph">'+'</code></td>		<td class="cell-center">187</td>	</tr>
					<tr><td>Comma</td>					<td class="cell-center"><code class="glyph">','</code></td>		<td class="cell-center">188</td>	</tr>
					<tr><td>Less than sign</td>			<td class="cell-center"><code class="glyph">'&lt;'</code></td>	<td class="cell-center">188</td>	</tr>
					<tr><td>Minus</td>					<td class="cell-center"><code class="glyph">'-'</code></td>		<td class="cell-center">189</td>	</tr>
					<tr><td>Underscore</td>				<td class="cell-center"><code class="glyph">'_'</code></td>		<td class="cell-center">189</td>	</tr>
					<tr><td>Period</td>					<td class="cell-center"><code class="glyph">'.'</code></td>		<td class="cell-center">190</td>	</tr>
					<tr><td>Greater than sign</td>		<td class="cell-center"><code class="glyph">'&gt;'</code></td>		<td class="cell-center">190</td>	</tr>
					<tr><td>Forward slash</td>			<td class="cell-center"><code class="glyph">'/'</code></td>		<td class="cell-center">191</td>	</tr>
					<tr><td>Question mark</td>			<td class="cell-center"><code class="glyph">'?'</code></td>		<td class="cell-center">191</td>	</tr>
					<tr><td>Backtick</td>				<td class="cell-center"><code class="glyph">'`'</code></td>		<td class="cell-center">192</td>	</tr>
					<tr><td>Tilde</td>					<td class="cell-center"><code class="glyph">'~'</code></td>		<td class="cell-center">192</td>	</tr>
					<tr><td>Opening square bracket</td>	<td class="cell-center"><code class="glyph">'['</code></td>		<td class="cell-center">219</td>	</tr>
					<tr><td>Opening curly brace</td>	<td class="cell-center"><code class="glyph">'{'</code></td>		<td class="cell-center">219</td>	</tr>
					<tr><td>Backslash</td>				<td class="cell-center"><code class="glyph">'\'</code></td>		<td class="cell-center">220</td>	</tr>
					<tr><td>Pipe</td>					<td class="cell-center"><code class="glyph">'|'</code></td>		<td class="cell-center">220</td>	</tr>
					<tr><td>Closing square bracket</td>	<td class="cell-center"><code class="glyph">']'</code></td>		<td class="cell-center">221</td>	</tr>
					<tr><td>Closing curly brace</td>	<td class="cell-center"><code class="glyph">'}'</code></td>		<td class="cell-center">221</td>	</tr>
					<tr><td>Single quote</td>			<td class="cell-center"><code class="glyph">'''</code></td>		<td class="cell-center">222</td>	</tr>
					<tr><td>Double quote</td>			<td class="cell-center"><code class="glyph">'"'</code></td>		<td class="cell-center">222</td>	</tr>
				</table>
			</section>
		</section>
	</section>  <!-- legacy-key-attributes -->

	<!-- Appendix C: Legacy Event Types ========================================================-->
	<section id="legacy-event-types">
		<h1>Legacy Event Types</h1>
		<p><em>This section is informative</em></p>

		<p>This section provides a non-normative description of the event types that are deprecated in
			this document.
			</p>

		<p>The purpose of this section is to document the current state of these features and their relation
			to normative events.
			For implementations which do support these events, it is suggested that the definitions provided
			in this section be used.
			</p>

		<p>The following table provides an informative summary of the event types which are deprecated in
			this specification.
			They are included here for reference and completeness.
			</p>

		<table class="data-table"
			summary="This table contains the complete list of the deprecated event types defined by DOM Level 3 Events.
				The first column contains the local name of the event type.
				The second column indicates if the event accomplish the bubbling phase or not (all events accomplish the capture and target phases).
				The third column indicates if the default action associated with the event can be canceled.
				The fourth column indicates the nodes that can be target of the event.
				The fifth (and last) column indicates the DOM interface implemented by the event object.">
			<tr>
				<th>Event Type</th>
				<th>Sync / Async</th>
				<th>Bubbling phase</th>
				<th>Trusted event target types</th>
				<th>DOM interface</th>
				<th>Cancelable</th>
				<th>Default Action</th>
			</tr>
			<tr>
				<td><a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a></td>
				<td>Sync</td>
				<td>Yes</td>
				<td><code>Element</code></td>
				<td><a href="#interface-UIEvent"><code>UIEvent</code></a></td>
				<td>Yes</td>
				<td>None</td>
			</tr>
			<tr>
				<td><a class="eventtype" href="#event-type-DOMAttrModified"><code>DOMAttrModified</code></a></td>
				<td>Sync</td>
				<td>Yes</td>
				<td><code>Element</code></td>
				<td><a href="#interface-MutationEvent"><code>MutationEvent</code></a></td>
				<td>No</td>
				<td>None</td>
			</tr>
			<tr>
				<td><a class="eventtype" href="#event-type-DOMCharacterDataModified"><code>DOMCharacterDataModified</code></a></td>
				<td>Sync</td>
				<td>Yes</td>
				<td><code>Text</code>, <code>Comment</code>, <code>ProcessingInstruction</code></td>
				<td><a href="#interface-MutationEvent"><code>MutationEvent</code></a></td>
				<td>No</td>
				<td>None</td>
			</tr>
			<tr>
				<td><a class="eventtype" href="#event-type-DOMFocusIn"><code>DOMFocusIn</code></a></td>
				<td>Sync</td>
				<td>Yes</td>
				<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
				<td><a href="#interface-FocusEvent"><code>FocusEvent</code></a></td>
				<td>No</td>
				<td>None</td>
			</tr>
			<tr>
				<td><a class="eventtype" href="#event-type-DOMFocusOut"><code>DOMFocusOut</code></a></td>
				<td>Sync</td>
				<td>Yes</td>
				<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
				<td><a href="#interface-FocusEvent"><code>FocusEvent</code></a></td>
				<td>No</td>
				<td>None</td>
			</tr>
			<tr>
				<td><a class="eventtype" href="#event-type-DOMNodeInserted"><code>DOMNodeInserted</code></a></td>
				<td>Sync</td>
				<td>Yes</td>
				<td><code>Element</code>, <code>Attr</code>, <code>Text</code>, <code>Comment</code>, <code>DocumentType</code>,
					<code>ProcessingInstruction</code></td>
				<td><a href="#interface-MutationEvent"><code>MutationEvent</code></a></td>
				<td>No</td>
				<td>None</td>
			</tr>
			<tr>
				<td><a class="eventtype" href="#event-type-DOMNodeInsertedIntoDocument"><code>DOMNodeInsertedIntoDocument</code></a></td>
				<td>Sync</td>
				<td>No</td>
				<td><code>Element</code>, <code>Attr</code>, <code>Text</code>, <code>Comment</code>, <code>DocumentType</code>,
					<code>ProcessingInstruction</code></td>
				<td><a href="#interface-MutationEvent"><code>MutationEvent</code></a></td>
				<td>No</td>
				<td>None</td>
			</tr>
			<tr>
				<td><a class="eventtype" href="#event-type-DOMNodeRemoved"><code>DOMNodeRemoved</code></a></td>
				<td>Sync</td>
				<td>Yes</td>
				<td><code>Element</code>, <code>Attr</code>, <code>Text</code>, <code>Comment</code>, <code>DocumentType</code>,
					<code>ProcessingInstruction</code></td>
				<td><a href="#interface-MutationEvent"><code>MutationEvent</code></a></td>
				<td>No</td>
				<td>None</td>
			</tr>
			<tr>
				<td><a class="eventtype" href="#event-type-DOMNodeRemovedFromDocument"><code>DOMNodeRemovedFromDocument</code></a></td>
				<td>Sync</td>
				<td>No</td>
				<td><code>Element</code>, <code>Attr</code>, <code>Text</code>, <code>Comment</code>, <code>DocumentType</code>,
					<code>ProcessingInstruction</code></td>
				<td><a href="#interface-MutationEvent"><code>MutationEvent</code></a></td>
				<td>No</td>
				<td>None</td>
			</tr>
			<tr>
				<td><a class="eventtype" href="#event-type-DOMSubtreeModified"><code>DOMSubtreeModified</code></a></td>
				<td>Sync</td>
				<td>Yes</td>
				<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Document</code>, <code>DocumentFragment</code>, <code>Element</code>, <code>Attr</code>
				</td>
				<td><a href="#interface-MutationEvent"><code>MutationEvent</code></a></td>
				<td>No</td>
				<td>None</td>
			</tr>
			<tr>
				<td><a class="eventtype" href="#event-type-keypress"><code>keypress</code></a></td>
				<td>Sync</td>
				<td>Yes</td>
				<td><code>Element</code></td>
				<td><a href="#interface-KeyboardEvent"><code>KeyboardEvent</code></a></td>
				<td>Yes</td>
				<td>Varies:
					launch <a class="def" href="#glossary-text-composition-system">text composition system</a>;
					<a class="eventtype" href="#event-type-blur"><code>blur</code></a> and <a class="eventtype" href="#event-type-focus"><code>focus</code></a> events;
					<a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a> event;
					other event</td>
			</tr>
		</table>

		<section id="legacy-uievent-events">
			<h2>Legacy <a href="#interface-UIEvent"><code>UIEvent</code></a> events</h2>
		
			<!-- DOMActivate -->
			<div class="event-definition">
				<dl>
					<dt id="event-type-DOMActivate"><dfn><a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a></dfn></dt>
					<dd>
						<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
							<tr>
								<th>Type</th>
								<td><strong><code>DOMActivate</code></strong></td>
							</tr>
							<tr>
								<th>Interface</th>
								<td><a href="#interface-UIEvent"><code>UIEvent</code></a></td>
							</tr>
							<tr>
								<th>Sync / Async</th>
								<td>Sync</td>
							</tr>
							<tr>
								<th>Bubbles</th>
								<td>Yes</td>
							</tr>
							<tr>
								<th>Trusted Targets</th>
								<td><code>Element</code></td>
							</tr>
							<tr>
								<th>Cancelable</th>
								<td>Yes</td>
							</tr>
							<tr>
								<th>Default action</th>
								<td>None</td>
							</tr>
							<tr>
								<th>Context<br/>(trusted events)</th>
								<td>
									<ul>
										<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
											element being activated</li>
										<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
											<a class="def" href="#glossary-window"><code>Window</code></a></li>
										<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
											<code>0</code></li>
									</ul>
								</td>
							</tr>
						</table>
						<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event when a button, link, or other state-changing element is activated.  Refer to
							<a href="#event-flow-activation">Activation triggers and behavior</a> for more details.</p>

						<p class="warning" id="DOMActivate-deprecated"><strong>Warning!</strong> The <a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a> <a
							class="def" href="#glossary-event-type">event type</a> is defined in this specification for reference and completeness, but this specification <a class="def" href="#glossary-deprecated">
							deprecates</a> the use of this event type in favor of the related <a class="def" href="#glossary-event-type">event type</a> <a class="eventtype" href="#event-type-click">
							<code>click</code></a>.  Other specifications MAY define and maintain their own <a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a>
							<a class="def" href="#glossary-event-type">event type</a> for backwards compatibility.</p>

						<p class="note" id="DOMActivate-click"><strong>Note:</strong>   While <a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a> and <a class="eventtype"
							href="#event-type-click"><code>click</code></a> are not completely equivalent, implemented behavior for the <a class="eventtype" href="#event-type-click"><code>click</code></a>
							<a class="def" href="#glossary-event-type">event type</a> has developed to encompass the most critical accessibility aspects for which the <a class="eventtype" href="#event-type-DOMActivate">
							<code>DOMActivate</code></a> <a class="def" href="#glossary-event-type">event type</a> was designed, and is more widely implemented.  Content authors are encouraged
							to use the <a class="eventtype" href="#event-type-click"><code>click</code></a> <a class="def" href="#glossary-event-type">event type</a> rather than the related
							<a class="eventtype" href="#event-type-mousedown"><code>mousedown</code></a> or <a class="eventtype" href="#event-type-mouseup"><code>mouseup</code></a> <a class="def"
							href="#glossary-event-type">event type</a> to ensure maximum accessibility.</p>
					</dd>
				</dl>
			</div>

			<p>Implementations which support the
					<a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a>
				<a class="def" href="#glossary-event-type">event type</a> SHOULD also dispatch a
					<a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a>
				event as a <a class="def" href="#glossary-default-action">default action</a> of a
				<a class="eventtype" href="#event-type-click"><code>click</code></a> event which is associated
				with an <a class="def" href="#glossary-activation-trigger">activation trigger</a>.
				However, such implementations SHOULD only initiate the associated
				<a class="def" href="#glossary-activation-behavior">activation behavior</a>
				once for any given occurrence of an
				<a class="def" href="#glossary-activation-trigger">activation trigger</a>.
				</p>

			<div class="example">
				<div class="example-title"></div>
				<p>The <a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a>
					<a class="def" href="#glossary-event-type">event type</a> is REQUIRED to be supported for
					XForms [<cite><a class="informative" href="#ref-xforms">XFORMS</a></cite>],
					which is intended for implementation within a <a class="def" href="#glossary-host-language">host language</a>.
					In a scenario where a plugin or script-based implementation of XForms is intended for installation
					in a native implementation of this specification which does not support the
					<a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a>
					<a class="def" href="#glossary-event-type">event type</a>, the XForms
					<a class="def" href="#glossary-user-agent">user agent</a> has to synthesize and dispatch its own
					<a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a> events based on
					the appropriate <a class="def" href="#glossary-activation-trigger">activation triggers</a>.
					</p>
				
				<p>Thus, when a <a class="eventtype" href="#event-type-click"><code>click</code></a> event is dispatched
					by the DOM Level 3 Events <a class="def" href="#glossary-user-agent">user agent</a>, the
					XForms <a class="def" href="#glossary-user-agent">user agent</a> has to determine whether to synthesize
					a <a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a> event with the
					same relevant properties as a <a class="def" href="#glossary-default-action">default action</a> of
					that <a class="eventtype" href="#event-type-click"><code>click</code></a> event.
					Appropriate cues might be whether the <a class="eventtype" href="#event-type-click"><code>click</code></a>
					event is <a href="#trusted-events">trusted</a>, or whether its
					<a class="def" href="#glossary-event-target">event target</a> has a
					<a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a> event listener
					registered.
					</p>
			</div>

			<p class="note"><strong>Authoring Note:</strong>
				Don't rely upon the interoperable support of
				<a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a>
				in many <a class="def" href="#glossary-user-agent">user agents</a>.
				Instead, the <a class="eventtype" href="#event-type-click"><code>click</code></a>
				<a class="def" href="#glossary-event-type">event type</a> should be used since it will provide more
				accessible behavior due to broader implementation support.
				</p>

			<p class="warning"><strong>Warning!</strong>
				The <a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a>
				<a class="def" href="#glossary-event-type">event type</a> is deprecated in this specification.
				</p>

			<section id="legacy-uievent-event-order">
				<h3>Activation event order</h3>

				<p>If the <code>DOMActivate</code> event is supported by the
					<a class="def" href="#glossary-user-agent">user agent</a>, then the
					events MUST be dispatched in a set order relative to each other:
					(with only pertinent events listed):
					</p>

				<table class="event-sequence-table">
					<tr>
						<td class="cell-number">1.</td>
						<td><a class="eventtype" href="#event-type-click"><code>click</code></a></td>
						<td></td>
					</tr>
					<tr>
						<td class="cell-number">2.</td>
						<td><a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a></td>
						<td><a class="def" href="#glossary-default-action">default action</a>, if supported
							by the <a class="def" href="#glossary-user-agent">user agent</a>; synthesized; <code>isTrusted="true"</code>
						</td>
					</tr>
					<tr>
						<td class="cell-number">3.</td>
						<td colspan="2">
							<em>All other <a class="def" href="#glossary-default-action">default actions</a>,
							including the <a class="def" href="#glossary-activation-behavior">activation behavior</a></em>
						</td>
					</tr>
				</table>

				<p>If the focused element is activated by a key event, then the following shows the
					typical sequence of events (with only pertinent events listed):
					</p>

				<table class="event-sequence-table">
					<tr>
						<td class="cell-number">1.</td>
						<td><a class="eventtype" href="#event-type-keydown"><code>keydown</code></a></td>
						<td>MUST be a key which can activate the element, such as the
							<code class="key">'Enter'</code> or <code class="key">'&nbsp;'</code> key,
							or the element is not activated
						</td>
					</tr>
					<tr>
						<td class="cell-number">2.</td>
						<td><a class="eventtype" href="#event-type-click"><code>click</code></a></td>
						<td><a class="def" href="#glossary-default-action">default action</a>; synthesized; <code>isTrusted="true"</code></td>
					</tr>
					<tr>
						<td class="cell-number">3.</td>
						<td><a class="eventtype" href="#event-type-DOMActivate"><code>DOMActivate</code></a></td>
						<td><a class="def" href="#glossary-default-action">default action</a>, if supported
							by the <a class="def" href="#glossary-user-agent">user agent</a>; synthesized; <code>isTrusted="true"</code>
						</td>
					</tr>
					<tr>
						<td class="cell-number">4.</td>
						<td colspan="2">
							<em>All other <a class="def" href="#glossary-default-action">default actions</a>,
							including the <a class="def" href="#glossary-activation-behavior">activation behavior</a></em>
						</td>
					</tr>
				</table>
			</section>  <!-- legacy-uievent-event-order -->
		</section>  <!-- legacy-uievent-events -->
		
		<section id="legacy-focusevent-events">
			<h2>Legacy <a href="#interface-FocusEvent"><code>FocusEvent</code></a> events</h2>
		
			<!-- DOMFocusIn -->
			<div class="event-definition">
				<dl>
					<dt id="event-type-DOMFocusIn"><dfn><a class="eventtype" href="#event-type-DOMFocusIn"><code>DOMFocusIn</code></a></dfn></dt>
					<dd>
						<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
							<tr>
								<th>Type</th>
								<td><strong><code>DOMFocusIn</code></strong></td>
							</tr>
							<tr>
								<th>Interface</th>
								<td><a href="#interface-FocusEvent"><code>FocusEvent</code></a></td>
							</tr>
							<tr>
								<th>Sync / Async</th>
								<td>Sync</td>
							</tr>
							<tr>
								<th>Bubbles</th>
								<td>Yes</td>
							</tr>
							<tr>
								<th>Trusted Targets</th>
								<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
							</tr>
							<tr>
								<th>Cancelable</th>
								<td>No</td>
							</tr>
							<tr>
								<th>Default action</th>
								<td>None</td>
							</tr>
							<tr>
								<th>Context<br/>(trusted events)</th>
								<td>
									<ul>
										<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
											<a class="def" href="#glossary-event-target">event target</a> receiving focus</li>
										<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
											<a class="def" href="#glossary-window"><code>Window</code></a></li>
										<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
											<code>0</code></li>
										<li><a href="#widl-FocusEvent-relatedTarget"><code class="attribute-name">FocusEvent.relatedTarget</code></a>:
											<code>null</code></li>
									</ul>
								</td>
							</tr>
						</table>
						<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event
							when an <a class="def" href="#glossary-event-target">event target</a> receives focus.
							The focus MUST be given to the element before the dispatch of this event type.
							This event type MUST be dispatched after the event type
							<a class="eventtype" href="#event-type-focus"><code>focus</code></a>.
							</p>

						<p class="warning"><strong>Warning!</strong>
							The <a class="eventtype" href="#event-type-DOMFocusIn"><code>DOMFocusIn</code></a> event type
							is defined in this specification for reference and completeness, but this specification
							<a class="def" href="#glossary-deprecated">deprecates</a> the use of this event type in favor
							of the related event types <a class="eventtype" href="#event-type-focus"><code>focus</code></a>
							and <a class="eventtype" href="#event-type-focusin"><code>focusin</code></a>.
							</p>
					</dd>
				</dl>
			</div>

			<!-- DOMFocusOut -->
			<div class="event-definition">
				<dl>
					<dt id="event-type-DOMFocusOut"><dfn><a class="eventtype" href="#event-type-DOMFocusOut"><code>DOMFocusOut</code></a></dfn></dt>
					<dd>
						<table border="0" summary="This table contains information about the semantics of the given event type" cellpadding="2" cellspacing="0">
							<tr>
								<th>Type</th>
								<td><strong><code>DOMFocusOut</code></strong></td>
							</tr>
							<tr>
								<th>Interface</th>
								<td><a href="#interface-FocusEvent"><code>FocusEvent</code></a></td>
							</tr>
							<tr>
								<th>Sync / Async</th>
								<td>Sync</td>
							</tr>
							<tr>
								<th>Bubbles</th>
								<td>Yes</td>
							</tr>
							<tr>
								<th>Trusted Targets</th>
								<td><a class="def" href="#glossary-window"><code>Window</code></a>, <code>Element</code></td>
							</tr>
							<tr>
								<th>Cancelable</th>
								<td>No</td>
							</tr>
							<tr>
								<th>Default action</th>
								<td>None</td>
							</tr>
							<tr>
								<th>Context<br/>(trusted events)</th>
								<td>
									<ul>
										<li><a href="#widl-Event-target"><code class="attribute-name">Event.target</code></a>:
											<a class="def" href="#glossary-event-target">event target</a> losing focus</li>
										<li><a href="#widl-UIEvent-view"><code class="attribute-name">UIEvent.view</code></a>:
											<a class="def" href="#glossary-window"><code>Window</code></a></li>
										<li><a href="#widl-UIEvent-detail"><code class="attribute-name">UIEvent.detail</code></a>:
											<code>0</code></li>
										<li><a href="#widl-FocusEvent-relatedTarget"><code class="attribute-name">FocusEvent.relatedTarget</code></a>:
											<code>null</code></li>
									</ul>
								</td>
							</tr>
						</table>
						<p>A <a class="def" href="#glossary-user-agent">user agent</a> MUST dispatch this event
							when an <a class="def" href="#glossary-event-target">event target</a> loses focus.
							The focus MUST be taken from the element before the dispatch of this event type.
							This event type MUST be dispatched after the event type
							<a class="eventtype" href="#event-type-blur"><code>blur</code></a>.
							</p>

						<p class="warning"><strong>Warning!</strong>
							The <a class="eventtype" href="#event-type-DOMFocusOut"><code>DOMFocusOut</code></a> event
							type is defined in this specification for reference and completeness, but this specification
							<a class="def" href="#glossary-deprecated">deprecates</a> the use of this event type in
							favor of the related event types <a class="eventtype" href="#event-type-blur"><code>blur</code></a>
							and <a class="eventtype" href="#event-type-focusout"><code>focusout</code></a>.
							</p>
					</dd>
				</dl>
			</div>

			<section id="legacy-focusevent-event-order">
				<h4>Legacy FocusEvent event order</h4>
				
				<p>The following is the typical sequence of events when a focus is shifted between elements,
					including the deprecated
						<a class="eventtype" href="#event-type-DOMFocusIn"><code>DOMFocusIn</code></a>
						and <a class="eventtype" href="#event-type-DOMFocusOut"><code>DOMFocusOut</code></a>
					events. The order shown assumes that no element is initially focused.
					</p>

				<table class="event-sequence-table">
					<tr>
						<td class="cell-number"></td>
						<td colspan="2"><em>User shifts focus</em></td>
					</tr>
					<tr>
						<td class="cell-number">1.</td>
						<td><a class="eventtype" href="#event-type-focusin"><code>focusin</code></a></td>
						<td>Sent before first target element receives focus</td>
					</tr>
					<tr>
						<td class="cell-number">2.</td>
						<td><a class="eventtype" href="#event-type-focus"><code>focus</code></a></td>
						<td>Sent after first target element receives focus</td>
					</tr>
					<tr>
						<td class="cell-number">3.</td>
						<td><a class="eventtype" href="#event-type-DOMFocusIn"><code>DOMFocusIn</code></a></td>
						<td>If supported</td>
					</tr>
					<tr>
						<td class="cell-number"></td>
						<td colspan="2"><em>User shifts focus</em></td>
					</tr>
					<tr>
						<td class="cell-number">4.</td>
						<td><a class="eventtype" href="#event-type-focusout"><code>focusout</code></a></td>
						<td>Sent before first target element loses focus</td>
					</tr>
					<tr>
						<td class="cell-number">5.</td>
						<td><a class="eventtype" href="#event-type-focusin"><code>focusin</code></a></td>
						<td>Sent before second target element receive