@angular/core 18.0.0-rc.3 → 18.0.1

package/fesm2022/primitives/event-dispatch.mjs

@@ -1,231 +1,104 @@
 /**
- * @license Angular v18.0.0-rc.3
+ * @license Angular v18.0.1
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
 
-/** Added for readability when accessing stable property names. */
-function getEventType(eventInfo) {
-    return eventInfo.eventType;
-}
-/** Added for readability when accessing stable property names. */
-function setEventType(eventInfo, eventType) {
-    eventInfo.eventType = eventType;
-}
-/** Added for readability when accessing stable property names. */
-function getEvent(eventInfo) {
-    return eventInfo.event;
-}
-/** Added for readability when accessing stable property names. */
-function setEvent(eventInfo, event) {
-    eventInfo.event = event;
-}
-/** Added for readability when accessing stable property names. */
-function getTargetElement(eventInfo) {
-    return eventInfo.targetElement;
-}
-/** Added for readability when accessing stable property names. */
-function setTargetElement(eventInfo, targetElement) {
-    eventInfo.targetElement = targetElement;
-}
-/** Added for readability when accessing stable property names. */
-function getContainer(eventInfo) {
-    return eventInfo.eic;
-}
-/** Added for readability when accessing stable property names. */
-function setContainer(eventInfo, container) {
-    eventInfo.eic = container;
-}
-/** Added for readability when accessing stable property names. */
-function getTimestamp(eventInfo) {
-    return eventInfo.timeStamp;
-}
-/** Added for readability when accessing stable property names. */
-function setTimestamp(eventInfo, timestamp) {
-    eventInfo.timeStamp = timestamp;
-}
-/** Added for readability when accessing stable property names. */
-function getAction(eventInfo) {
-    return eventInfo.eia;
-}
-/** Added for readability when accessing stable property names. */
-function setAction(eventInfo, actionName, actionElement) {
-    eventInfo.eia = [actionName, actionElement];
-}
-/** Added for readability when accessing stable property names. */
-function unsetAction(eventInfo) {
-    eventInfo.eia = undefined;
-}
-/** Added for readability when accessing stable property names. */
-function getActionName(actionInfo) {
-    return actionInfo[0];
-}
-/** Added for readability when accessing stable property names. */
-function getActionElement(actionInfo) {
-    return actionInfo[1];
-}
-/** Added for readability when accessing stable property names. */
-function getIsReplay(eventInfo) {
-    return eventInfo.eirp;
-}
-/** Added for readability when accessing stable property names. */
-function setIsReplay(eventInfo, replay) {
-    eventInfo.eirp = replay;
-}
-/** Added for readability when accessing stable property names. */
-function getA11yClickKey(eventInfo) {
-    return eventInfo.eiack;
-}
-/** Added for readability when accessing stable property names. */
-function setA11yClickKey(eventInfo, a11yClickKey) {
-    eventInfo.eiack = a11yClickKey;
-}
-/** Added for readability when accessing stable property names. */
-function getResolved(eventInfo) {
-    return eventInfo.eir;
-}
-/** Added for readability when accessing stable property names. */
-function setResolved(eventInfo, resolved) {
-    eventInfo.eir = resolved;
-}
-/** Clones an `EventInfo` */
-function cloneEventInfo(eventInfo) {
-    return {
-        eventType: eventInfo.eventType,
-        event: eventInfo.event,
-        targetElement: eventInfo.targetElement,
-        eic: eventInfo.eic,
-        eia: eventInfo.eia,
-        timeStamp: eventInfo.timeStamp,
-        eirp: eventInfo.eirp,
-        eiack: eventInfo.eiack,
-        eir: eventInfo.eir,
-    };
-}
 /**
- * Utility function for creating an `EventInfo`.
+ * The jsaction attribute defines a mapping of a DOM event to a
+ * generic event (aka jsaction), to which the actual event handlers
+ * that implement the behavior of the application are bound. The
+ * value is a semicolon separated list of colon separated pairs of
+ * an optional DOM event name and a jsaction name. If the optional
+ * DOM event name is omitted, 'click' is assumed. The jsaction names
+ * are dot separated pairs of a namespace and a simple jsaction
+ * name.
  *
- * This can be used from code-size sensitive compilation units, as taking
- * parameters vs. an `Object` literal reduces code size.
+ * See grammar in README.md for expected syntax in the attribute value.
  */
-function createEventInfoFromParameters(eventType, event, targetElement, container, timestamp, action, isReplay, a11yClickKey) {
-    return {
-        eventType,
-        event,
-        targetElement,
-        eic: container,
-        timeStamp: timestamp,
-        eia: action,
-        eirp: isReplay,
-        eiack: a11yClickKey,
-    };
-}
+const JSACTION$1 = 'jsaction';
 /**
- * Utility function for creating an `EventInfo`.
+ * The oi attribute is a log impression tag for impression logging
+ * and action tracking. For an element that carries a jsaction
+ * attribute, the element is identified for the purpose of
+ * impression logging and click tracking by the dot separated path
+ * of all oi attributes in the chain of ancestors of the element.
  *
- * This should be used in compilation units that are less sensitive to code
- * size.
+ * Used by ActionFlow.
  */
-function createEventInfo({ eventType, event, targetElement, container, timestamp, action, isReplay, a11yClickKey, }) {
-    return {
-        eventType,
-        event,
-        targetElement,
-        eic: container,
-        timeStamp: timestamp,
-        eia: action ? [action.name, action.element] : undefined,
-        eirp: isReplay,
-        eiack: a11yClickKey,
-    };
-}
+const OI$1 = 'oi';
 /**
- * Utility class around an `EventInfo`.
+ * The ved attribute is an encoded ClickTrackingCGI proto to track
+ * visual elements.
  *
- * This should be used in compilation units that are less sensitive to code
- * size.
+ * Used by ActionFlow.
  */
-class EventInfoWrapper {
-    constructor(eventInfo) {
-        this.eventInfo = eventInfo;
-    }
-    getEventType() {
-        return getEventType(this.eventInfo);
-    }
-    setEventType(eventType) {
-        setEventType(this.eventInfo, eventType);
-    }
-    getEvent() {
-        return getEvent(this.eventInfo);
-    }
-    setEvent(event) {
-        setEvent(this.eventInfo, event);
-    }
-    getTargetElement() {
-        return getTargetElement(this.eventInfo);
-    }
-    setTargetElement(targetElement) {
-        setTargetElement(this.eventInfo, targetElement);
-    }
-    getContainer() {
-        return getContainer(this.eventInfo);
-    }
-    setContainer(container) {
-        setContainer(this.eventInfo, container);
-    }
-    getTimestamp() {
-        return getTimestamp(this.eventInfo);
-    }
-    setTimestamp(timestamp) {
-        setTimestamp(this.eventInfo, timestamp);
-    }
-    getAction() {
-        const action = getAction(this.eventInfo);
-        if (!action)
-            return undefined;
-        return {
-            name: action[0],
-            element: action[1],
-        };
-    }
-    setAction(action) {
-        if (!action) {
-            unsetAction(this.eventInfo);
-            return;
-        }
-        setAction(this.eventInfo, action.name, action.element);
-    }
-    getIsReplay() {
-        return getIsReplay(this.eventInfo);
-    }
-    setIsReplay(replay) {
-        setIsReplay(this.eventInfo, replay);
-    }
-    getResolved() {
-        return getResolved(this.eventInfo);
-    }
-    setResolved(resolved) {
-        setResolved(this.eventInfo, resolved);
-    }
-    clone() {
-        return new EventInfoWrapper(cloneEventInfo(this.eventInfo));
-    }
-}
-
-/*
- * Names of events that are special to jsaction. These are not all
- * event types that are legal to use in either HTML or the addEvent()
- * API, but these are the ones that are treated specially. All other
- * DOM events can be used in either addEvent() or in the value of the
- * jsaction attribute. Beware of browser specific events or events
- * that don't bubble though: If they are not mentioned here, then
- * event contract doesn't work around their peculiarities.
+const VED = 'ved';
+/**
+ * The vet attribute is the visual element type used to identify tracked
+ * visual elements.
  */
-const EventType = {
+const VET = 'vet';
+/**
+ * Support for iteration on reprocessing.
+ *
+ * Used by ActionFlow.
+ */
+const JSINSTANCE = 'jsinstance';
+/**
+ * All click jsactions that happen on the element that carries this
+ * attribute or its descendants are automatically logged.
+ * Impressions of jsactions on these elements are tracked too, if
+ * requested by the impression() method of ActionFlow.
+ *
+ * Used by ActionFlow.
+ */
+const JSTRACK = 'jstrack';
+const Attribute = { JSACTION: JSACTION$1, OI: OI$1, VED, VET, JSINSTANCE, JSTRACK };
+
+const Char = {
     /**
-     * Mouse middle click, introduced in Chrome 55 and not yet supported on
-     * other browsers.
+     * The separator between the namespace and the action name in the
+     * jsaction attribute value.
      */
-    AUXCLICK: 'auxclick',
+    NAMESPACE_ACTION_SEPARATOR: '.',
+    /**
+     * The separator between the event name and action in the jsaction
+     * attribute value.
+     */
+    EVENT_ACTION_SEPARATOR: ':',
+    /**
+     * The separator between the logged oi attribute values in the &oi=
+     * URL parameter value.
+     */
+    OI_SEPARATOR: '.',
+    /**
+     * The separator between the key and the value pairs in the &cad=
+     * URL parameter value.
+     */
+    CAD_KEY_VALUE_SEPARATOR: ':',
+    /**
+     * The separator between the key-value pairs in the &cad= URL
+     * parameter value.
+     */
+    CAD_SEPARATOR: ',',
+};
+
+/*
+ * Names of events that are special to jsaction. These are not all
+ * event types that are legal to use in either HTML or the addEvent()
+ * API, but these are the ones that are treated specially. All other
+ * DOM events can be used in either addEvent() or in the value of the
+ * jsaction attribute. Beware of browser specific events or events
+ * that don't bubble though: If they are not mentioned here, then
+ * event contract doesn't work around their peculiarities.
+ */
+const EventType = {
+    /**
+     * Mouse middle click, introduced in Chrome 55 and not yet supported on
+     * other browsers.
+     */
+    AUXCLICK: 'auxclick',
     /**
      * The change event fired by browsers when the `value` attribute of input,
      * select, and textarea elements are changed.
@@ -447,1058 +320,1053 @@ const EventType = {
      */
     CUSTOM: '_custom',
 };
-
-/**
- * @fileoverview An enum to control who can call certain jsaction APIs.
- */
-var Restriction;
-(function (Restriction) {
-    Restriction[Restriction["I_AM_THE_JSACTION_FRAMEWORK"] = 0] = "I_AM_THE_JSACTION_FRAMEWORK";
-})(Restriction || (Restriction = {}));
-
-/**
- * Determines if one node is contained within another. Adapted from
- * {@see goog.dom.contains}.
- * @param node Node that should contain otherNode.
- * @param otherNode Node being contained.
- * @return True if otherNode is contained within node.
- */
-function contains(node, otherNode) {
-    if (otherNode === null) {
-        return false;
-    }
-    // We use browser specific methods for this if available since it is faster
-    // that way.
-    // IE DOM
-    if ('contains' in node && otherNode.nodeType === 1) {
-        return node.contains(otherNode);
-    }
-    // W3C DOM Level 3
-    if ('compareDocumentPosition' in node) {
-        return node === otherNode || Boolean(node.compareDocumentPosition(otherNode) & 16);
-    }
-    // W3C DOM Level 1
-    while (otherNode && node !== otherNode) {
-        otherNode = otherNode.parentNode;
-    }
-    return otherNode === node;
-}
-/**
- * Helper method for broadcastCustomEvent. Returns true if any member of
- * the set is an ancestor of element.
- */
-function hasAncestorInNodeList(element, nodeList) {
-    for (let idx = 0; idx < nodeList.length; ++idx) {
-        const member = nodeList[idx];
-        if (member !== element && contains(member, element)) {
-            return true;
-        }
-    }
-    return false;
-}
-
-/**
- * If on a Macintosh with an extended keyboard, the Enter key located in the
- * numeric pad has a different ASCII code.
- */
-const MAC_ENTER = 3;
-/** The Enter key. */
-const ENTER = 13;
-/** The Space key. */
-const SPACE = 32;
-/** Special keycodes used by jsaction for the generic click action. */
-const KeyCode = { MAC_ENTER, ENTER, SPACE };
-
-/**
- * Gets a browser event type, if it would differ from the JSAction event type.
- */
-function getBrowserEventType(eventType) {
-    // Mouseenter and mouseleave events are not handled directly because they
-    // are not available everywhere. In browsers where they are available, they
-    // don't bubble and aren't visible at the container boundary. Instead, we
-    // synthesize the mouseenter and mouseleave events from mouseover and
-    // mouseout events, respectively. Cf. eventcontract.js.
-    if (eventType === EventType.MOUSEENTER) {
-        return EventType.MOUSEOVER;
-    }
-    else if (eventType === EventType.MOUSELEAVE) {
-        return EventType.MOUSEOUT;
-    }
-    else if (eventType === EventType.POINTERENTER) {
-        return EventType.POINTEROVER;
-    }
-    else if (eventType === EventType.POINTERLEAVE) {
-        return EventType.POINTEROUT;
-    }
-    return eventType;
-}
+const NON_BUBBLING_MOUSE_EVENTS = [
+    EventType.MOUSEENTER,
+    EventType.MOUSELEAVE,
+    'pointerenter',
+    'pointerleave',
+];
+/**
+ * Detects whether a given event type is supported by JSAction.
+ */
+const isSupportedEvent = (eventType) => SUPPORTED_EVENTS.includes(eventType);
+const SUPPORTED_EVENTS = [
+    EventType.CLICK,
+    EventType.DBLCLICK,
+    EventType.FOCUS,
+    EventType.FOCUSIN,
+    EventType.BLUR,
+    EventType.ERROR,
+    EventType.FOCUSOUT,
+    EventType.KEYDOWN,
+    EventType.KEYUP,
+    EventType.KEYPRESS,
+    EventType.LOAD,
+    EventType.MOUSEOVER,
+    EventType.MOUSEOUT,
+    EventType.SUBMIT,
+    EventType.TOGGLE,
+    EventType.TOUCHSTART,
+    EventType.TOUCHEND,
+    EventType.TOUCHMOVE,
+    'touchcancel',
+    'auxclick',
+    'change',
+    'compositionstart',
+    'compositionupdate',
+    'compositionend',
+    'beforeinput',
+    'input',
+    'select',
+    'copy',
+    'cut',
+    'paste',
+    'mousedown',
+    'mouseup',
+    'wheel',
+    'contextmenu',
+    'dragover',
+    'dragenter',
+    'dragleave',
+    'drop',
+    'dragstart',
+    'dragend',
+    'pointerdown',
+    'pointermove',
+    'pointerup',
+    'pointercancel',
+    'pointerover',
+    'pointerout',
+    'gotpointercapture',
+    'lostpointercapture',
+    // Video events.
+    'ended',
+    'loadedmetadata',
+    // Page visibility events.
+    'pagehide',
+    'pageshow',
+    'visibilitychange',
+    // Content visibility events.
+    'beforematch',
+];
 /**
- * Registers the event handler function with the given DOM element for
- * the given event type.
  *
- * @param element The element.
- * @param eventType The event type.
- * @param handler The handler function to install.
- * @return Information needed to uninstall the event handler eventually.
- */
-function addEventListener(element, eventType, handler) {
-    // All event handlers are registered in the bubbling
-    // phase.
-    //
-    // All browsers support focus and blur, but these events only are propagated
-    // in the capture phase. Very legacy browsers do not support focusin or
-    // focusout.
-    //
-    // It would be a bad idea to register all event handlers in the
-    // capture phase because then regular onclick handlers would not be
-    // executed at all on events that trigger a jsaction. That's not
-    // entirely what we want, at least for now.
-    //
-    // Error and load events (i.e. on images) do not bubble so they are also
-    // handled in the capture phase.
-    let capture = false;
-    if (eventType === EventType.FOCUS ||
-        eventType === EventType.BLUR ||
-        eventType === EventType.ERROR ||
-        eventType === EventType.LOAD ||
-        eventType === EventType.TOGGLE) {
-        capture = true;
-    }
-    element.addEventListener(eventType, handler, capture);
-    return { eventType, handler, capture };
-}
-/**
- * Removes the event handler for the given event from the element.
- * the given event type.
+ * Decides whether or not an event type is an event that only has a capture phase.
  *
- * @param element The element.
- * @param info The information needed to deregister the handler, as returned by
- *     addEventListener(), above.
- */
-function removeEventListener(element, info) {
-    if (element.removeEventListener) {
-        element.removeEventListener(info.eventType, info.handler, info.capture);
-        // `detachEvent` is an old DOM API.
-        // tslint:disable-next-line:no-any
-    }
-    else if (element.detachEvent) {
-        // `detachEvent` is an old DOM API.
-        // tslint:disable-next-line:no-any
-        element.detachEvent(`on${info.eventType}`, info.handler);
-    }
-}
-/**
- * Cancels propagation of an event.
- * @param e The event to cancel propagation for.
- */
-function stopPropagation(e) {
-    e.stopPropagation ? e.stopPropagation() : (e.cancelBubble = true);
-}
-/**
- * Prevents the default action of an event.
- * @param e The event to prevent the default action for.
- */
-function preventDefault(e) {
-    e.preventDefault ? e.preventDefault() : (e.returnValue = false);
-}
-/**
- * Gets the target Element of the event. In Firefox, a text node may appear as
- * the target of the event, in which case we return the parent element of the
- * text node.
- * @param e The event to get the target of.
- * @return The target element.
- */
-function getTarget(e) {
-    let el = e.target;
-    // In Firefox, the event may have a text node as its target. We always
-    // want the parent Element the text node belongs to, however.
-    if (!el.getAttribute && el.parentNode) {
-        el = el.parentNode;
-    }
-    return el;
-}
-/**
- * Whether we are on a Mac. Not pulling in useragent just for this.
- */
-let isMac = typeof navigator !== 'undefined' && /Macintosh/.test(navigator.userAgent);
-/**
- * Determines and returns whether the given event (which is assumed to be a
- * click event) is a middle click.
- * NOTE: There is not a consistent way to identify middle click
- * http://www.unixpapa.com/js/mouse.html
- */
-function isMiddleClick(e) {
-    return (
-    // `which` is an old DOM API.
-    // tslint:disable-next-line:no-any
-    e.which === 2 ||
-        // `which` is an old DOM API.
-        // tslint:disable-next-line:no-any
-        (e.which == null &&
-            // `button` is an old DOM API.
-            // tslint:disable-next-line:no-any
-            e.button === 4) // middle click for IE
-    );
-}
-/**
- * Determines and returns whether the given event (which is assumed
- * to be a click event) is modified. A middle click is considered a modified
- * click to retain the default browser action, which opens a link in a new tab.
- * @param e The event.
- * @return Whether the given event is modified.
- */
-function isModifiedClickEvent(e) {
-    return (
-    // `metaKey` is an old DOM API.
-    // tslint:disable-next-line:no-any
-    (isMac && e.metaKey) ||
-        // `ctrlKey` is an old DOM API.
-        // tslint:disable-next-line:no-any
-        (!isMac && e.ctrlKey) ||
-        isMiddleClick(e) ||
-        // `shiftKey` is an old DOM API.
-        // tslint:disable-next-line:no-any
-        e.shiftKey);
-}
-/** Whether we are on WebKit (e.g., Chrome). */
-const isWebKit = typeof navigator !== 'undefined' &&
-    !/Opera/.test(navigator.userAgent) &&
-    /WebKit/.test(navigator.userAgent);
-/** Whether we are on IE. */
-const isIe = typeof navigator !== 'undefined' &&
-    (/MSIE/.test(navigator.userAgent) || /Trident/.test(navigator.userAgent));
-/** Whether we are on Gecko (e.g., Firefox). */
-const isGecko = typeof navigator !== 'undefined' &&
-    !/Opera|WebKit/.test(navigator.userAgent) &&
-    /Gecko/.test(navigator.product);
+ * @param eventType
+ * @returns bool
+ */
+const isCaptureEvent = (eventType) => CAPTURE_EVENTS.indexOf(eventType) >= 0;
+const CAPTURE_EVENTS = [
+    EventType.FOCUS,
+    EventType.BLUR,
+    EventType.ERROR,
+    EventType.LOAD,
+    EventType.TOGGLE,
+];
+
 /**
- * Determines and returns whether the given element is a valid target for
- * keypress/keydown DOM events that act like regular DOM clicks.
- * @param el The element.
- * @return Whether the given element is a valid action key target.
+ * The parsed value of the jsaction attribute is stored in this
+ * property on the DOM node. The parsed value is an Object. The
+ * property names of the object are the events; the values are the
+ * names of the actions. This property is attached even on nodes
+ * that don't have a jsaction attribute as an optimization, because
+ * property lookup is faster than attribute access.
  */
-function isValidActionKeyTarget(el) {
-    if (!('getAttribute' in el)) {
-        return false;
-    }
-    if (isTextControl(el)) {
-        return false;
-    }
-    if (isNativelyActivatable(el)) {
-        return false;
-    }
-    // `isContentEditable` is an old DOM API.
-    // tslint:disable-next-line:no-any
-    if (el.isContentEditable) {
-        return false;
-    }
-    return true;
-}
+const JSACTION = '__jsaction';
+/** The value of the oi attribute as a property, for faster access. */
+const OI = '__oi';
 /**
- * Whether an event has a modifier key activated.
- * @param e The event.
- * @return True, if a modifier key is activated.
+ * The owner property references an a logical owner for a DOM node. JSAction
+ * will follow this reference instead of parentNode when traversing the DOM
+ * to find jsaction attributes. This allows overlaying a logical structure
+ * over a document where the DOM structure can't reflect that structure.
  */
-function hasModifierKey(e) {
-    return (
-    // `ctrlKey` is an old DOM API.
-    // tslint:disable-next-line:no-any
-    e.ctrlKey ||
-        // `shiftKey` is an old DOM API.
-        // tslint:disable-next-line:no-any
-        e.shiftKey ||
-        // `altKey` is an old DOM API.
-        // tslint:disable-next-line:no-any
-        e.altKey ||
-        // `metaKey` is an old DOM API.
-        // tslint:disable-next-line:no-any
-        e.metaKey);
-}
+const OWNER = '__owner';
+/** All properties that are used by jsaction. */
+const Property = {
+    JSACTION,
+    OI,
+    OWNER,
+};
+
 /**
- * Determines and returns whether the given event has a target that already
- * has event handlers attached because it is a native HTML control. Used to
- * determine if preventDefault should be called when isActionKeyEvent is true.
- * @param e The event.
- * @return If preventDefault should be called.
+ * Map from jsaction annotation to a parsed map from event name to action name.
  */
-function shouldCallPreventDefaultOnNativeHtmlControl(e) {
-    const el = getTarget(e);
-    const tagName = el.tagName.toUpperCase();
-    const role = (el.getAttribute('role') || '').toUpperCase();
-    if (tagName === 'BUTTON' || role === 'BUTTON') {
-        return true;
-    }
-    if (!isNativeHTMLControl(el)) {
-        return false;
-    }
-    if (tagName === 'A') {
-        return false;
-    }
-    /**
-     * Fix for physical d-pads on feature phone platforms; the native event
-     * (ie. isTrusted: true) needs to fire to show the OPTION list. See
-     * b/135288469 for more info.
-     */
-    if (tagName === 'SELECT') {
-        return false;
-    }
-    if (processSpace(el)) {
-        return false;
-    }
-    if (isTextControl(el)) {
-        return false;
-    }
-    return true;
-}
+const parseCache = {};
 /**
- * Determines and returns whether the given event acts like a regular DOM click,
- * and should be handled instead of the click.  If this returns true, the caller
- * will call preventDefault() to prevent a possible duplicate event.
- * This is represented by a keypress (keydown on Gecko browsers) on Enter or
- * Space key.
- * @param e The event.
- * @return True, if the event emulates a DOM click.
+ * Reads the jsaction parser cache from the given DOM Element.
+ *
+ * @param element .
+ * @return Map from event to qualified name of the jsaction bound to it.
  */
-function isActionKeyEvent(e) {
-    let key = 
-    // `which` is an old DOM API.
-    // tslint:disable-next-line:no-any
-    e.which ||
-        // `keyCode` is an old DOM API.
-        // tslint:disable-next-line:no-any
-        e.keyCode;
-    if (!key && e.key) {
-        key = ACTION_KEY_TO_KEYCODE[e.key];
-    }
-    if (isWebKit && key === KeyCode.MAC_ENTER) {
-        key = KeyCode.ENTER;
-    }
-    if (key !== KeyCode.ENTER && key !== KeyCode.SPACE) {
-        return false;
-    }
-    const el = getTarget(e);
-    if (e.type !== EventType.KEYDOWN || !isValidActionKeyTarget(el) || hasModifierKey(e)) {
-        return false;
-    }
-    // For <input type="checkbox">, we must only handle the browser's native click
-    // event, so that the browser can toggle the checkbox.
-    if (processSpace(el) && key === KeyCode.SPACE) {
-        return false;
-    }
-    // If this element is non-focusable, ignore stray keystrokes (b/18337209)
-    // Sscreen readers can move without tab focus, so any tabIndex is focusable.
-    // See B/21809604
-    if (!isFocusable(el)) {
-        return false;
-    }
-    const type = (el.getAttribute('role') ||
-        el.type ||
-        el.tagName).toUpperCase();
-    const isSpecificTriggerKey = IDENTIFIER_TO_KEY_TRIGGER_MAPPING[type] % key === 0;
-    const isDefaultTriggerKey = !(type in IDENTIFIER_TO_KEY_TRIGGER_MAPPING) && key === KeyCode.ENTER;
-    const hasType = el.tagName.toUpperCase() !== 'INPUT' || !!el.type;
-    return (isSpecificTriggerKey || isDefaultTriggerKey) && hasType;
+function get(element) {
+    // @ts-ignore
+    return element[JSACTION];
 }
 /**
- * Checks whether a DOM element can receive keyboard focus.
- * This code is based on goog.dom.isFocusable, but simplified since we shouldn't
- * care about visibility if we're already handling a keyboard event.
+ * Writes the jsaction parser cache to the given DOM Element.
+ *
+ * @param element .
+ * @param actionMap Map from event to qualified name of the jsaction bound to
+ *     it.
  */
-function isFocusable(el) {
-    return ((el.tagName in NATIVELY_FOCUSABLE_ELEMENTS || hasSpecifiedTabIndex(el)) &&
-        !el.disabled);
+function set(element, actionMap) {
+    // @ts-ignore
+    element[JSACTION] = actionMap;
 }
 /**
- * @param element Element to check.
- * @return Whether the element has a specified tab index.
+ * Looks up the parsed action map from the source jsaction attribute value.
+ *
+ * @param text Unparsed jsaction attribute value.
+ * @return Parsed jsaction attribute value, if already present in the cache.
  */
-function hasSpecifiedTabIndex(element) {
-    // IE returns 0 for an unset tabIndex, so we must use getAttributeNode(),
-    // which returns an object with a 'specified' property if tabIndex is
-    // specified.  This works on other browsers, too.
-    const attrNode = element.getAttributeNode('tabindex'); // Must be lowercase!
-    return attrNode != null && attrNode.specified;
-}
-/** Element tagnames that are focusable by default. */
-const NATIVELY_FOCUSABLE_ELEMENTS = {
-    'A': 1,
-    'INPUT': 1,
-    'TEXTAREA': 1,
-    'SELECT': 1,
-    'BUTTON': 1,
-};
-/** @return True, if the Space key was pressed. */
-function isSpaceKeyEvent(e) {
-    const key = 
-    // `which` is an old DOM API.
-    // tslint:disable-next-line:no-any
-    e.which ||
-        // `keyCode` is an old DOM API.
-        // tslint:disable-next-line:no-any
-        e.keyCode;
-    const el = getTarget(e);
-    const elementName = (el.type || el.tagName).toUpperCase();
-    return key === KeyCode.SPACE && elementName !== 'CHECKBOX';
+function getParsed(text) {
+    return parseCache[text];
 }
 /**
- * Determines whether the event corresponds to a non-bubbling mouse
- * event type (mouseenter, mouseleave, pointerenter, and pointerleave).
- *
- * During mouseover (mouseenter) and pointerover (pointerenter), the
- * relatedTarget is the element being entered from. During mouseout (mouseleave)
- * and pointerout (pointerleave), the relatedTarget is the element being exited
- * to.
+ * Inserts the parse result for the given source jsaction value into the cache.
  *
- * In both cases, if relatedTarget is outside target, then the corresponding
- * special event has occurred, otherwise it hasn't.
+ * @param text Unparsed jsaction attribute value.
+ * @param parsed Attribute value parsed into the action map.
+ */
+function setParsed(text, parsed) {
+    parseCache[text] = parsed;
+}
+/**
+ * Clears the jsaction parser cache from the given DOM Element.
  *
- * @param e The mouseover/mouseout event.
- * @param type The type of the mouse special event.
- * @param element The element on which the jsaction for the
- *     mouseenter/mouseleave event is defined.
- * @return True if the event is a mouseenter/mouseleave event.
+ * @param element .
  */
-function isMouseSpecialEvent(e, type, element) {
-    // `relatedTarget` is an old DOM API.
-    // tslint:disable-next-line:no-any
-    const related = e.relatedTarget;
-    return (((e.type === EventType.MOUSEOVER && type === EventType.MOUSEENTER) ||
-        (e.type === EventType.MOUSEOUT && type === EventType.MOUSELEAVE) ||
-        (e.type === EventType.POINTEROVER && type === EventType.POINTERENTER) ||
-        (e.type === EventType.POINTEROUT && type === EventType.POINTERLEAVE)) &&
-        (!related || (related !== element && !contains(element, related))));
+function clear(element) {
+    if (JSACTION in element) {
+        delete element[JSACTION];
+    }
+}
+
+/** Added for readability when accessing stable property names. */
+function getEventType(eventInfo) {
+    return eventInfo.eventType;
+}
+/** Added for readability when accessing stable property names. */
+function setEventType(eventInfo, eventType) {
+    eventInfo.eventType = eventType;
+}
+/** Added for readability when accessing stable property names. */
+function getEvent(eventInfo) {
+    return eventInfo.event;
+}
+/** Added for readability when accessing stable property names. */
+function setEvent(eventInfo, event) {
+    eventInfo.event = event;
+}
+/** Added for readability when accessing stable property names. */
+function getTargetElement(eventInfo) {
+    return eventInfo.targetElement;
+}
+/** Added for readability when accessing stable property names. */
+function setTargetElement(eventInfo, targetElement) {
+    eventInfo.targetElement = targetElement;
+}
+/** Added for readability when accessing stable property names. */
+function getContainer(eventInfo) {
+    return eventInfo.eic;
+}
+/** Added for readability when accessing stable property names. */
+function setContainer(eventInfo, container) {
+    eventInfo.eic = container;
+}
+/** Added for readability when accessing stable property names. */
+function getTimestamp(eventInfo) {
+    return eventInfo.timeStamp;
+}
+/** Added for readability when accessing stable property names. */
+function setTimestamp(eventInfo, timestamp) {
+    eventInfo.timeStamp = timestamp;
+}
+/** Added for readability when accessing stable property names. */
+function getAction(eventInfo) {
+    return eventInfo.eia;
+}
+/** Added for readability when accessing stable property names. */
+function setAction(eventInfo, actionName, actionElement) {
+    eventInfo.eia = [actionName, actionElement];
+}
+/** Added for readability when accessing stable property names. */
+function unsetAction(eventInfo) {
+    eventInfo.eia = undefined;
+}
+/** Added for readability when accessing stable property names. */
+function getActionName(actionInfo) {
+    return actionInfo[0];
+}
+/** Added for readability when accessing stable property names. */
+function getActionElement(actionInfo) {
+    return actionInfo[1];
+}
+/** Added for readability when accessing stable property names. */
+function getIsReplay(eventInfo) {
+    return eventInfo.eirp;
+}
+/** Added for readability when accessing stable property names. */
+function setIsReplay(eventInfo, replay) {
+    eventInfo.eirp = replay;
+}
+/** Added for readability when accessing stable property names. */
+function getA11yClickKey(eventInfo) {
+    return eventInfo.eiack;
+}
+/** Added for readability when accessing stable property names. */
+function setA11yClickKey(eventInfo, a11yClickKey) {
+    eventInfo.eiack = a11yClickKey;
+}
+/** Added for readability when accessing stable property names. */
+function getResolved(eventInfo) {
+    return eventInfo.eir;
+}
+/** Added for readability when accessing stable property names. */
+function setResolved(eventInfo, resolved) {
+    eventInfo.eir = resolved;
+}
+/** Clones an `EventInfo` */
+function cloneEventInfo(eventInfo) {
+    return {
+        eventType: eventInfo.eventType,
+        event: eventInfo.event,
+        targetElement: eventInfo.targetElement,
+        eic: eventInfo.eic,
+        eia: eventInfo.eia,
+        timeStamp: eventInfo.timeStamp,
+        eirp: eventInfo.eirp,
+        eiack: eventInfo.eiack,
+        eir: eventInfo.eir,
+    };
 }
 /**
- * Creates a new EventLike object for a mouseenter/mouseleave event that's
- * derived from the original corresponding mouseover/mouseout event.
- * @param e The event.
- * @param target The element on which the jsaction for the mouseenter/mouseleave
- *     event is defined.
- * @return A modified event-like object copied from the event object passed into
- *     this function.
+ * Utility function for creating an `EventInfo`.
+ *
+ * This can be used from code-size sensitive compilation units, as taking
+ * parameters vs. an `Object` literal reduces code size.
  */
-function createMouseSpecialEvent(e, target) {
-    // We have to create a copy of the event object because we need to mutate
-    // its fields. We do this for the special mouse events because the event
-    // target needs to be retargeted to the action element rather than the real
-    // element (since we are simulating the special mouse events with mouseover/
-    // mouseout).
-    //
-    // Since we're making a copy anyways, we might as well attempt to convert
-    // this event into a pseudo-real mouseenter/mouseleave event by adjusting
-    // its type.
-    //
-    // tslint:disable-next-line:no-any
-    const copy = {};
-    for (const property in e) {
-        if (property === 'srcElement' || property === 'target') {
-            continue;
-        }
-        const key = property;
-        // Making a copy requires iterating through all properties of `Event`.
-        // tslint:disable-next-line:no-dict-access-on-struct-type
-        const value = e[key];
-        if (typeof value === 'function') {
-            continue;
-        }
-        // Value should be the expected type, but the value of `key` is not known
-        // statically.
-        // tslint:disable-next-line:no-any
-        copy[key] = value;
-    }
-    if (e.type === EventType.MOUSEOVER) {
-        copy['type'] = EventType.MOUSEENTER;
-    }
-    else if (e.type === EventType.MOUSEOUT) {
-        copy['type'] = EventType.MOUSELEAVE;
-    }
-    else if (e.type === EventType.POINTEROVER) {
-        copy['type'] = EventType.POINTERENTER;
-    }
-    else {
-        copy['type'] = EventType.POINTERLEAVE;
-    }
-    copy['target'] = copy['srcElement'] = target;
-    copy['bubbles'] = false;
-    return copy;
+function createEventInfoFromParameters(eventType, event, targetElement, container, timestamp, action, isReplay, a11yClickKey) {
+    return {
+        eventType,
+        event,
+        targetElement,
+        eic: container,
+        timeStamp: timestamp,
+        eia: action,
+        eirp: isReplay,
+        eiack: a11yClickKey,
+    };
 }
 /**
- * Returns touch data extracted from the touch event: clientX, clientY, screenX
- * and screenY. If the event has no touch information at all, the returned
- * value is null.
- *
- * The fields of this Object are unquoted.
+ * Utility function for creating an `EventInfo`.
  *
- * @param event A touch event.
+ * This should be used in compilation units that are less sensitive to code
+ * size.
  */
-function getTouchData(event) {
-    const touch = (event.changedTouches && event.changedTouches[0]) || (event.touches && event.touches[0]);
-    if (!touch) {
-        return null;
-    }
+function createEventInfo({ eventType, event, targetElement, container, timestamp, action, isReplay, a11yClickKey, }) {
     return {
-        clientX: touch.clientX,
-        clientY: touch.clientY,
-        screenX: touch.screenX,
-        screenY: touch.screenY,
+        eventType,
+        event,
+        targetElement,
+        eic: container,
+        timeStamp: timestamp,
+        eia: action ? [action.name, action.element] : undefined,
+        eirp: isReplay,
+        eiack: a11yClickKey,
     };
 }
 /**
- * Creates a new EventLike object for a "click" event that's derived from the
- * original corresponding "touchend" event for a fast-click implementation.
- *
- * It takes a touch event, adds common fields found in a click event and
- * changes the type to 'click', so that the resulting event looks more like
- * a real click event.
+ * Utility class around an `EventInfo`.
  *
- * @param event A touch event.
- * @return A modified event-like object copied from the event object passed into
- *     this function.
+ * This should be used in compilation units that are less sensitive to code
+ * size.
  */
-function recreateTouchEventAsClick(event) {
-    const click = {};
-    click['originalEventType'] = event.type;
-    click['type'] = EventType.CLICK;
-    for (const property in event) {
-        if (property === 'type' || property === 'srcElement') {
-            continue;
-        }
-        const key = property;
-        // Making a copy requires iterating through all properties of `TouchEvent`.
-        // tslint:disable-next-line:no-dict-access-on-struct-type
-        const value = event[key];
-        if (typeof value === 'function') {
-            continue;
-        }
-        // Value should be the expected type, but the value of `key` is not known
-        // statically.
-        // tslint:disable-next-line:no-any
-        click[key] = value;
+class EventInfoWrapper {
+    constructor(eventInfo) {
+        this.eventInfo = eventInfo;
     }
-    // Ensure that the event has the most recent timestamp. This timestamp
-    // may be used in the future to validate or cancel subsequent click events.
-    click['timeStamp'] = Date.now();
-    // Emulate preventDefault and stopPropagation behavior
-    click['defaultPrevented'] = false;
-    click['preventDefault'] = syntheticPreventDefault;
-    click['_propagationStopped'] = false;
-    click['stopPropagation'] = syntheticStopPropagation;
-    // Emulate click coordinates using touch info
-    const touch = getTouchData(event);
-    if (touch) {
-        click['clientX'] = touch.clientX;
-        click['clientY'] = touch.clientY;
-        click['screenX'] = touch.screenX;
-        click['screenY'] = touch.screenY;
+    getEventType() {
+        return getEventType(this.eventInfo);
     }
-    return click;
-}
-/**
- * An implementation of "preventDefault" for a synthesized event. Simply
- * sets "defaultPrevented" property to true.
- */
-function syntheticPreventDefault() {
-    this.defaultPrevented = true;
-}
-/**
- * An implementation of "stopPropagation" for a synthesized event. It simply
- * sets a synthetic non-standard "_propagationStopped" property to true.
- */
-function syntheticStopPropagation() {
-    this._propagationStopped = true;
-}
-/**
- * Mapping of KeyboardEvent.key values to
- * KeyCode values.
- */
-const ACTION_KEY_TO_KEYCODE = {
-    'Enter': KeyCode.ENTER,
-    ' ': KeyCode.SPACE,
-};
-/**
- * Mapping of HTML element identifiers (ARIA role, type, or tagName) to the
- * keys (enter and/or space) that should activate them. A value of zero means
- * that both should activate them.
- */
-const IDENTIFIER_TO_KEY_TRIGGER_MAPPING = {
-    'A': KeyCode.ENTER,
-    'BUTTON': 0,
-    'CHECKBOX': KeyCode.SPACE,
-    'COMBOBOX': KeyCode.ENTER,
-    'FILE': 0,
-    'GRIDCELL': KeyCode.ENTER,
-    'LINK': KeyCode.ENTER,
-    'LISTBOX': KeyCode.ENTER,
-    'MENU': 0,
-    'MENUBAR': 0,
-    'MENUITEM': 0,
-    'MENUITEMCHECKBOX': 0,
-    'MENUITEMRADIO': 0,
-    'OPTION': 0,
-    'RADIO': KeyCode.SPACE,
-    'RADIOGROUP': KeyCode.SPACE,
-    'RESET': 0,
-    'SUBMIT': 0,
-    'SWITCH': KeyCode.SPACE,
-    'TAB': 0,
-    'TREE': KeyCode.ENTER,
-    'TREEITEM': KeyCode.ENTER,
-};
+    setEventType(eventType) {
+        setEventType(this.eventInfo, eventType);
+    }
+    getEvent() {
+        return getEvent(this.eventInfo);
+    }
+    setEvent(event) {
+        setEvent(this.eventInfo, event);
+    }
+    getTargetElement() {
+        return getTargetElement(this.eventInfo);
+    }
+    setTargetElement(targetElement) {
+        setTargetElement(this.eventInfo, targetElement);
+    }
+    getContainer() {
+        return getContainer(this.eventInfo);
+    }
+    setContainer(container) {
+        setContainer(this.eventInfo, container);
+    }
+    getTimestamp() {
+        return getTimestamp(this.eventInfo);
+    }
+    setTimestamp(timestamp) {
+        setTimestamp(this.eventInfo, timestamp);
+    }
+    getAction() {
+        const action = getAction(this.eventInfo);
+        if (!action)
+            return undefined;
+        return {
+            name: action[0],
+            element: action[1],
+        };
+    }
+    setAction(action) {
+        if (!action) {
+            unsetAction(this.eventInfo);
+            return;
+        }
+        setAction(this.eventInfo, action.name, action.element);
+    }
+    getIsReplay() {
+        return getIsReplay(this.eventInfo);
+    }
+    setIsReplay(replay) {
+        setIsReplay(this.eventInfo, replay);
+    }
+    getResolved() {
+        return getResolved(this.eventInfo);
+    }
+    setResolved(resolved) {
+        setResolved(this.eventInfo, resolved);
+    }
+    clone() {
+        return new EventInfoWrapper(cloneEventInfo(this.eventInfo));
+    }
+}
+
 /**
- * Returns whether or not to process space based on the type of the element;
- * checks to make sure that type is not null.
- * @param element The element.
- * @return Whether or not to process space based on type.
+ * Determines if one node is contained within another. Adapted from
+ * {@see goog.dom.contains}.
+ * @param node Node that should contain otherNode.
+ * @param otherNode Node being contained.
+ * @return True if otherNode is contained within node.
  */
-function processSpace(element) {
-    const type = (element.getAttribute('type') || element.tagName).toUpperCase();
-    return type in PROCESS_SPACE;
+function contains(node, otherNode) {
+    if (otherNode === null) {
+        return false;
+    }
+    // We use browser specific methods for this if available since it is faster
+    // that way.
+    // IE DOM
+    if ('contains' in node && otherNode.nodeType === 1) {
+        return node.contains(otherNode);
+    }
+    // W3C DOM Level 3
+    if ('compareDocumentPosition' in node) {
+        return node === otherNode || Boolean(node.compareDocumentPosition(otherNode) & 16);
+    }
+    // W3C DOM Level 1
+    while (otherNode && node !== otherNode) {
+        otherNode = otherNode.parentNode;
+    }
+    return otherNode === node;
 }
 /**
- * Returns whether or not the given element is a text control.
- * @param el The element.
- * @return Whether or not the given element is a text control.
+ * Helper method for broadcastCustomEvent. Returns true if any member of
+ * the set is an ancestor of element.
  */
-function isTextControl(el) {
-    const type = (el.getAttribute('type') || el.tagName).toUpperCase();
-    return type in TEXT_CONTROLS;
+function hasAncestorInNodeList(element, nodeList) {
+    for (let idx = 0; idx < nodeList.length; ++idx) {
+        const member = nodeList[idx];
+        if (member !== element && contains(member, element)) {
+            return true;
+        }
+    }
+    return false;
 }
+
 /**
- * Returns if the given element is a native HTML control.
- * @param el The element.
- * @return If the given element is a native HTML control.
+ * If on a Macintosh with an extended keyboard, the Enter key located in the
+ * numeric pad has a different ASCII code.
  */
-function isNativeHTMLControl(el) {
-    return el.tagName.toUpperCase() in NATIVE_HTML_CONTROLS;
-}
+const MAC_ENTER = 3;
+/** The Enter key. */
+const ENTER = 13;
+/** The Space key. */
+const SPACE = 32;
+/** Special keycodes used by jsaction for the generic click action. */
+const KeyCode = { MAC_ENTER, ENTER, SPACE };
+
 /**
- * Returns if the given element is natively activatable. Browsers emit click
- * events for natively activatable elements, even when activated via keyboard.
- * For these elements, we don't need to raise a11y click events.
- * @param el The element.
- * @return If the given element is a native HTML control.
+ * Gets a browser event type, if it would differ from the JSAction event type.
  */
-function isNativelyActivatable(el) {
-    return (el.tagName.toUpperCase() === 'BUTTON' ||
-        (!!el.type && el.type.toUpperCase() === 'FILE'));
+function getBrowserEventType(eventType) {
+    // Mouseenter and mouseleave events are not handled directly because they
+    // are not available everywhere. In browsers where they are available, they
+    // don't bubble and aren't visible at the container boundary. Instead, we
+    // synthesize the mouseenter and mouseleave events from mouseover and
+    // mouseout events, respectively. Cf. eventcontract.js.
+    if (eventType === EventType.MOUSEENTER) {
+        return EventType.MOUSEOVER;
+    }
+    else if (eventType === EventType.MOUSELEAVE) {
+        return EventType.MOUSEOUT;
+    }
+    else if (eventType === EventType.POINTERENTER) {
+        return EventType.POINTEROVER;
+    }
+    else if (eventType === EventType.POINTERLEAVE) {
+        return EventType.POINTEROUT;
+    }
+    return eventType;
 }
 /**
- * HTML <input> types (not ARIA roles) which will auto-trigger a click event for
- * the Space key, with side-effects. We will not call preventDefault if space is
- * pressed, nor will we raise a11y click events.  For all other elements, we can
- * suppress the default event (which has no desired side-effects) and handle the
- * keydown ourselves.
+ * Registers the event handler function with the given DOM element for
+ * the given event type.
+ *
+ * @param element The element.
+ * @param eventType The event type.
+ * @param handler The handler function to install.
+ * @return Information needed to uninstall the event handler eventually.
  */
-const PROCESS_SPACE = {
-    'CHECKBOX': true,
-    'FILE': true,
-    'OPTION': true,
-    'RADIO': true,
-};
-/** TagNames and Input types for which to not process enter/space as click. */
-const TEXT_CONTROLS = {
-    'COLOR': true,
-    'DATE': true,
-    'DATETIME': true,
-    'DATETIME-LOCAL': true,
-    'EMAIL': true,
-    'MONTH': true,
-    'NUMBER': true,
-    'PASSWORD': true,
-    'RANGE': true,
-    'SEARCH': true,
-    'TEL': true,
-    'TEXT': true,
-    'TEXTAREA': true,
-    'TIME': true,
-    'URL': true,
-    'WEEK': true,
-};
-/** TagNames that are native HTML controls. */
-const NATIVE_HTML_CONTROLS = {
-    'A': true,
-    'AREA': true,
-    'BUTTON': true,
-    'DIALOG': true,
-    'IMG': true,
-    'INPUT': true,
-    'LINK': true,
-    'MENU': true,
-    'OPTGROUP': true,
-    'OPTION': true,
-    'PROGRESS': true,
-    'SELECT': true,
-    'TEXTAREA': true,
-};
-/** Exported for testing. */
-const testing = {
-    setIsMac(value) {
-        isMac = value;
-    },
-};
-
+function addEventListener(element, eventType, handler) {
+    // All event handlers are registered in the bubbling
+    // phase.
+    //
+    // All browsers support focus and blur, but these events only are propagated
+    // in the capture phase. Very legacy browsers do not support focusin or
+    // focusout.
+    //
+    // It would be a bad idea to register all event handlers in the
+    // capture phase because then regular onclick handlers would not be
+    // executed at all on events that trigger a jsaction. That's not
+    // entirely what we want, at least for now.
+    //
+    // Error and load events (i.e. on images) do not bubble so they are also
+    // handled in the capture phase.
+    let capture = false;
+    if (isCaptureEvent(eventType)) {
+        capture = true;
+    }
+    element.addEventListener(eventType, handler, capture);
+    return { eventType, handler, capture };
+}
 /**
- * Receives a DOM event, determines the jsaction associated with the source
- * element of the DOM event, and invokes the handler associated with the
- * jsaction.
+ * Removes the event handler for the given event from the element.
+ * the given event type.
+ *
+ * @param element The element.
+ * @param info The information needed to deregister the handler, as returned by
+ *     addEventListener(), above.
  */
-class Dispatcher {
-    /**
-     * Options are:
-     *   - `eventReplayer`: When the event contract dispatches replay events
-     *      to the Dispatcher, the Dispatcher collects them and in the next tick
-     *      dispatches them to the `eventReplayer`. Defaults to dispatching to `dispatchDelegate`.
-     * @param dispatchDelegate A function that should handle dispatching an `EventInfoWrapper` to handlers.
-     */
-    constructor(dispatchDelegate, { actionResolver, eventReplayer = createEventReplayer(dispatchDelegate), } = {}) {
-        this.dispatchDelegate = dispatchDelegate;
-        /** Whether the event replay is scheduled. */
-        this.eventReplayScheduled = false;
-        /** The queue of events. */
-        this.replayEventInfoWrappers = [];
-        this.actionResolver = actionResolver;
-        this.eventReplayer = eventReplayer;
+function removeEventListener(element, info) {
+    if (element.removeEventListener) {
+        element.removeEventListener(info.eventType, info.handler, info.capture);
+        // `detachEvent` is an old DOM API.
+        // tslint:disable-next-line:no-any
     }
-    /**
-     * Receives an event or the event queue from the EventContract. The event
-     * queue is copied and it attempts to replay.
-     * If event info is passed in it looks for an action handler that can handle
-     * the given event.  If there is no handler registered queues the event and
-     * checks if a loader is registered for the given namespace. If so, calls it.
-     *
-     * Alternatively, if in global dispatch mode, calls all registered global
-     * handlers for the appropriate event type.
-     *
-     * The three functionalities of this call are deliberately not split into
-     * three methods (and then declared as an abstract interface), because the
-     * interface is used by EventContract, which lives in a different jsbinary.
-     * Therefore the interface between the three is defined entirely in terms that
-     * are invariant under jscompiler processing (Function and Array, as opposed
-     * to a custom type with method names).
-     *
-     * @param eventInfo The info for the event that triggered this call or the
-     *     queue of events from EventContract.
-     */
-    dispatch(eventInfo) {
-        const eventInfoWrapper = new EventInfoWrapper(eventInfo);
-        this.actionResolver?.resolve(eventInfo);
-        const action = eventInfoWrapper.getAction();
-        if (action && shouldPreventDefaultBeforeDispatching(action.element, eventInfoWrapper)) {
-            preventDefault(eventInfoWrapper.getEvent());
-        }
-        if (eventInfoWrapper.getIsReplay()) {
-            this.scheduleEventInfoWrapperReplay(eventInfoWrapper);
-            return;
-        }
-        this.dispatchDelegate(eventInfoWrapper);
+    else if (element.detachEvent) {
+        // `detachEvent` is an old DOM API.
+        // tslint:disable-next-line:no-any
+        element.detachEvent(`on${info.eventType}`, info.handler);
     }
-    /**
-     * Schedules an `EventInfoWrapper` for replay. The replaying will happen in its own
-     * stack once the current flow cedes control. This is done to mimic
-     * browser event handling.
-     */
-    scheduleEventInfoWrapperReplay(eventInfoWrapper) {
-        this.replayEventInfoWrappers.push(eventInfoWrapper);
-        if (this.eventReplayScheduled) {
-            return;
-        }
-        this.eventReplayScheduled = true;
-        Promise.resolve().then(() => {
-            this.eventReplayScheduled = false;
-            this.eventReplayer(this.replayEventInfoWrappers);
-        });
+}
+/**
+ * Cancels propagation of an event.
+ * @param e The event to cancel propagation for.
+ */
+function stopPropagation(e) {
+    e.stopPropagation ? e.stopPropagation() : (e.cancelBubble = true);
+}
+/**
+ * Prevents the default action of an event.
+ * @param e The event to prevent the default action for.
+ */
+function preventDefault(e) {
+    e.preventDefault ? e.preventDefault() : (e.returnValue = false);
+}
+/**
+ * Gets the target Element of the event. In Firefox, a text node may appear as
+ * the target of the event, in which case we return the parent element of the
+ * text node.
+ * @param e The event to get the target of.
+ * @return The target element.
+ */
+function getTarget(e) {
+    let el = e.target;
+    // In Firefox, the event may have a text node as its target. We always
+    // want the parent Element the text node belongs to, however.
+    if (!el.getAttribute && el.parentNode) {
+        el = el.parentNode;
     }
+    return el;
 }
 /**
- * Creates an `EventReplayer` that calls the `replay` function for every `eventInfoWrapper` in
- * the queue.
+ * Whether we are on a Mac. Not pulling in useragent just for this.
  */
-function createEventReplayer(replay) {
-    return (eventInfoWrappers) => {
-        for (const eventInfoWrapper of eventInfoWrappers) {
-            replay(eventInfoWrapper);
-        }
-    };
+let isMac = typeof navigator !== 'undefined' && /Macintosh/.test(navigator.userAgent);
+/**
+ * Determines and returns whether the given event (which is assumed to be a
+ * click event) is a middle click.
+ * NOTE: There is not a consistent way to identify middle click
+ * http://www.unixpapa.com/js/mouse.html
+ */
+function isMiddleClick(e) {
+    return (
+    // `which` is an old DOM API.
+    // tslint:disable-next-line:no-any
+    e.which === 2 ||
+        // `which` is an old DOM API.
+        // tslint:disable-next-line:no-any
+        (e.which == null &&
+            // `button` is an old DOM API.
+            // tslint:disable-next-line:no-any
+            e.button === 4) // middle click for IE
+    );
 }
 /**
- * Returns true if the default action of this event should be prevented before
- * this event is dispatched.
+ * Determines and returns whether the given event (which is assumed
+ * to be a click event) is modified. A middle click is considered a modified
+ * click to retain the default browser action, which opens a link in a new tab.
+ * @param e The event.
+ * @return Whether the given event is modified.
  */
-function shouldPreventDefaultBeforeDispatching(actionElement, eventInfoWrapper) {
-    // Prevent browser from following <a> node links if a jsaction is present
-    // and we are dispatching the action now. Note that the targetElement may be
-    // a child of an anchor that has a jsaction attached. For that reason, we
-    // need to check the actionElement rather than the targetElement.
-    return ((actionElement.tagName === 'A' && eventInfoWrapper.getEventType() === EventType.CLICK) ||
-        eventInfoWrapper.getEventType() === EventType.CLICKMOD);
+function isModifiedClickEvent(e) {
+    return (
+    // `metaKey` is an old DOM API.
+    // tslint:disable-next-line:no-any
+    (isMac && e.metaKey) ||
+        // `ctrlKey` is an old DOM API.
+        // tslint:disable-next-line:no-any
+        (!isMac && e.ctrlKey) ||
+        isMiddleClick(e) ||
+        // `shiftKey` is an old DOM API.
+        // tslint:disable-next-line:no-any
+        e.shiftKey);
 }
+/** Whether we are on WebKit (e.g., Chrome). */
+const isWebKit = typeof navigator !== 'undefined' &&
+    !/Opera/.test(navigator.userAgent) &&
+    /WebKit/.test(navigator.userAgent);
+/** Whether we are on IE. */
+const isIe = typeof navigator !== 'undefined' &&
+    (/MSIE/.test(navigator.userAgent) || /Trident/.test(navigator.userAgent));
+/** Whether we are on Gecko (e.g., Firefox). */
+const isGecko = typeof navigator !== 'undefined' &&
+    !/Opera|WebKit/.test(navigator.userAgent) &&
+    /Gecko/.test(navigator.product);
 /**
- * Registers deferred functionality for an EventContract and a Jsaction
- * Dispatcher.
+ * Determines and returns whether the given element is a valid target for
+ * keypress/keydown DOM events that act like regular DOM clicks.
+ * @param el The element.
+ * @return Whether the given element is a valid action key target.
  */
-function registerDispatcher(eventContract, dispatcher) {
-    eventContract.ecrd((eventInfo) => {
-        dispatcher.dispatch(eventInfo);
-    }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);
+function isValidActionKeyTarget(el) {
+    if (!('getAttribute' in el)) {
+        return false;
+    }
+    if (isTextControl(el)) {
+        return false;
+    }
+    if (isNativelyActivatable(el)) {
+        return false;
+    }
+    // `isContentEditable` is an old DOM API.
+    // tslint:disable-next-line:no-any
+    if (el.isContentEditable) {
+        return false;
+    }
+    return true;
 }
-
 /**
- * Whether the user agent is running on iOS.
+ * Whether an event has a modifier key activated.
+ * @param e The event.
+ * @return True, if a modifier key is activated.
  */
-const isIos = typeof navigator !== 'undefined' && /iPhone|iPad|iPod/.test(navigator.userAgent);
+function hasModifierKey(e) {
+    return (
+    // `ctrlKey` is an old DOM API.
+    // tslint:disable-next-line:no-any
+    e.ctrlKey ||
+        // `shiftKey` is an old DOM API.
+        // tslint:disable-next-line:no-any
+        e.shiftKey ||
+        // `altKey` is an old DOM API.
+        // tslint:disable-next-line:no-any
+        e.altKey ||
+        // `metaKey` is an old DOM API.
+        // tslint:disable-next-line:no-any
+        e.metaKey);
+}
 /**
- * A class representing a container node and all the event handlers
- * installed on it. Used so that handlers can be cleaned up if the
- * container is removed from the contract.
+ * Determines and returns whether the given event has a target that already
+ * has event handlers attached because it is a native HTML control. Used to
+ * determine if preventDefault should be called when isActionKeyEvent is true.
+ * @param e The event.
+ * @return If preventDefault should be called.
  */
-class EventContractContainer {
-    /**
-     * @param element The container Element.
-     */
-    constructor(element) {
-        this.element = element;
-        /**
-         * Array of event handlers and their corresponding event types that are
-         * installed on this container.
-         *
-         */
-        this.handlerInfos = [];
+function shouldCallPreventDefaultOnNativeHtmlControl(e) {
+    const el = getTarget(e);
+    const tagName = el.tagName.toUpperCase();
+    const role = (el.getAttribute('role') || '').toUpperCase();
+    if (tagName === 'BUTTON' || role === 'BUTTON') {
+        return true;
+    }
+    if (!isNativeHTMLControl(el)) {
+        return false;
+    }
+    if (tagName === 'A') {
+        return false;
     }
     /**
-     * Installs the provided installer on the element owned by this container,
-     * and maintains a reference to resulting handler in order to remove it
-     * later if desired.
+     * Fix for physical d-pads on feature phone platforms; the native event
+     * (ie. isTrusted: true) needs to fire to show the OPTION list. See
+     * b/135288469 for more info.
      */
-    addEventListener(eventType, getHandler) {
-        // In iOS, event bubbling doesn't happen automatically in any DOM element,
-        // unless it has an onclick attribute or DOM event handler attached to it.
-        // This breaks JsAction in some cases. See "Making Elements Clickable"
-        // section at http://goo.gl/2VoGnB.
-        //
-        // A workaround for this issue is to change the CSS cursor style to 'pointer'
-        // for the container element, which magically turns on event bubbling. This
-        // solution is described in the comments section at http://goo.gl/6pEO1z.
-        //
-        // We use a navigator.userAgent check here as this problem is present both
-        // on Mobile Safari and thin WebKit wrappers, such as Chrome for iOS.
-        if (isIos) {
-            this.element.style.cursor = 'pointer';
-        }
-        this.handlerInfos.push(addEventListener(this.element, eventType, getHandler(this.element)));
+    if (tagName === 'SELECT') {
+        return false;
+    }
+    if (processSpace(el)) {
+        return false;
+    }
+    if (isTextControl(el)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Determines and returns whether the given event acts like a regular DOM click,
+ * and should be handled instead of the click.  If this returns true, the caller
+ * will call preventDefault() to prevent a possible duplicate event.
+ * This is represented by a keypress (keydown on Gecko browsers) on Enter or
+ * Space key.
+ * @param e The event.
+ * @return True, if the event emulates a DOM click.
+ */
+function isActionKeyEvent(e) {
+    let key = 
+    // `which` is an old DOM API.
+    // tslint:disable-next-line:no-any
+    e.which ||
+        // `keyCode` is an old DOM API.
+        // tslint:disable-next-line:no-any
+        e.keyCode;
+    if (!key && e.key) {
+        key = ACTION_KEY_TO_KEYCODE[e.key];
+    }
+    if (isWebKit && key === KeyCode.MAC_ENTER) {
+        key = KeyCode.ENTER;
+    }
+    if (key !== KeyCode.ENTER && key !== KeyCode.SPACE) {
+        return false;
+    }
+    const el = getTarget(e);
+    if (e.type !== EventType.KEYDOWN || !isValidActionKeyTarget(el) || hasModifierKey(e)) {
+        return false;
+    }
+    // For <input type="checkbox">, we must only handle the browser's native click
+    // event, so that the browser can toggle the checkbox.
+    if (processSpace(el) && key === KeyCode.SPACE) {
+        return false;
     }
-    /**
-     * Removes all the handlers installed on this container.
-     */
-    cleanUp() {
-        for (let i = 0; i < this.handlerInfos.length; i++) {
-            removeEventListener(this.element, this.handlerInfos[i]);
-        }
-        this.handlerInfos = [];
+    // If this element is non-focusable, ignore stray keystrokes (b/18337209)
+    // Sscreen readers can move without tab focus, so any tabIndex is focusable.
+    // See B/21809604
+    if (!isFocusable(el)) {
+        return false;
     }
+    const type = (el.getAttribute('role') ||
+        el.type ||
+        el.tagName).toUpperCase();
+    const isSpecificTriggerKey = IDENTIFIER_TO_KEY_TRIGGER_MAPPING[type] % key === 0;
+    const isDefaultTriggerKey = !(type in IDENTIFIER_TO_KEY_TRIGGER_MAPPING) && key === KeyCode.ENTER;
+    const hasType = el.tagName.toUpperCase() !== 'INPUT' || !!el.type;
+    return (isSpecificTriggerKey || isDefaultTriggerKey) && hasType;
 }
-
 /**
- * Update `EventInfo` to be `eventType = 'click'` and sets `a11yClickKey` if it
- * is a a11y click.
+ * Checks whether a DOM element can receive keyboard focus.
+ * This code is based on goog.dom.isFocusable, but simplified since we shouldn't
+ * care about visibility if we're already handling a keyboard event.
  */
-function updateEventInfoForA11yClick(eventInfo) {
-    if (!isActionKeyEvent(getEvent(eventInfo))) {
-        return;
-    }
-    setA11yClickKey(eventInfo, true);
-    // A 'click' triggered by a DOM keypress should be mapped to the 'click'
-    // jsaction.
-    setEventType(eventInfo, EventType.CLICK);
+function isFocusable(el) {
+    return ((el.tagName in NATIVELY_FOCUSABLE_ELEMENTS || hasSpecifiedTabIndex(el)) &&
+        !el.disabled);
 }
 /**
- * Call `preventDefault` on an a11y click if it is space key or to prevent the
- * browser's default action for native HTML controls.
+ * @param element Element to check.
+ * @return Whether the element has a specified tab index.
  */
-function preventDefaultForA11yClick(eventInfo) {
-    if (!getA11yClickKey(eventInfo) ||
-        (!isSpaceKeyEvent(getEvent(eventInfo)) &&
-            !shouldCallPreventDefaultOnNativeHtmlControl(getEvent(eventInfo)))) {
-        return;
-    }
-    preventDefault(getEvent(eventInfo));
+function hasSpecifiedTabIndex(element) {
+    // IE returns 0 for an unset tabIndex, so we must use getAttributeNode(),
+    // which returns an object with a 'specified' property if tabIndex is
+    // specified.  This works on other browsers, too.
+    const attrNode = element.getAttributeNode('tabindex'); // Must be lowercase!
+    return attrNode != null && attrNode.specified;
+}
+/** Element tagnames that are focusable by default. */
+const NATIVELY_FOCUSABLE_ELEMENTS = {
+    'A': 1,
+    'INPUT': 1,
+    'TEXTAREA': 1,
+    'SELECT': 1,
+    'BUTTON': 1,
+};
+/** @return True, if the Space key was pressed. */
+function isSpaceKeyEvent(e) {
+    const key = 
+    // `which` is an old DOM API.
+    // tslint:disable-next-line:no-any
+    e.which ||
+        // `keyCode` is an old DOM API.
+        // tslint:disable-next-line:no-any
+        e.keyCode;
+    const el = getTarget(e);
+    const elementName = (el.type || el.tagName).toUpperCase();
+    return key === KeyCode.SPACE && elementName !== 'CHECKBOX';
 }
 /**
- * Sets the `action` to `clickonly` for a click event that is not an a11y click
- * and if there is not already a click action.
+ * Determines whether the event corresponds to a non-bubbling mouse
+ * event type (mouseenter, mouseleave, pointerenter, and pointerleave).
+ *
+ * During mouseover (mouseenter) and pointerover (pointerenter), the
+ * relatedTarget is the element being entered from. During mouseout (mouseleave)
+ * and pointerout (pointerleave), the relatedTarget is the element being exited
+ * to.
+ *
+ * In both cases, if relatedTarget is outside target, then the corresponding
+ * special event has occurred, otherwise it hasn't.
+ *
+ * @param e The mouseover/mouseout event.
+ * @param type The type of the mouse special event.
+ * @param element The element on which the jsaction for the
+ *     mouseenter/mouseleave event is defined.
+ * @return True if the event is a mouseenter/mouseleave event.
  */
-function populateClickOnlyAction(actionElement, eventInfo, actionMap) {
-    if (
-    // If there's already an action, don't attempt to set a CLICKONLY
-    getAction(eventInfo) ||
-        // Only attempt CLICKONLY if the type is CLICK
-        getEventType(eventInfo) !== EventType.CLICK ||
-        // a11y clicks are never CLICKONLY
-        getA11yClickKey(eventInfo) ||
-        actionMap[EventType.CLICKONLY] === undefined) {
-        return;
-    }
-    setEventType(eventInfo, EventType.CLICKONLY);
-    setAction(eventInfo, actionMap[EventType.CLICKONLY], actionElement);
+function isMouseSpecialEvent(e, type, element) {
+    // `relatedTarget` is an old DOM API.
+    // tslint:disable-next-line:no-any
+    const related = e.relatedTarget;
+    return (((e.type === EventType.MOUSEOVER && type === EventType.MOUSEENTER) ||
+        (e.type === EventType.MOUSEOUT && type === EventType.MOUSELEAVE) ||
+        (e.type === EventType.POINTEROVER && type === EventType.POINTERENTER) ||
+        (e.type === EventType.POINTEROUT && type === EventType.POINTERLEAVE)) &&
+        (!related || (related !== element && !contains(element, related))));
 }
-
 /**
- * The jsaction attribute defines a mapping of a DOM event to a
- * generic event (aka jsaction), to which the actual event handlers
- * that implement the behavior of the application are bound. The
- * value is a semicolon separated list of colon separated pairs of
- * an optional DOM event name and a jsaction name. If the optional
- * DOM event name is omitted, 'click' is assumed. The jsaction names
- * are dot separated pairs of a namespace and a simple jsaction
- * name.
- *
- * See grammar in README.md for expected syntax in the attribute value.
+ * Creates a new EventLike object for a mouseenter/mouseleave event that's
+ * derived from the original corresponding mouseover/mouseout event.
+ * @param e The event.
+ * @param target The element on which the jsaction for the mouseenter/mouseleave
+ *     event is defined.
+ * @return A modified event-like object copied from the event object passed into
+ *     this function.
  */
-const JSACTION$1 = 'jsaction';
+function createMouseSpecialEvent(e, target) {
+    // We have to create a copy of the event object because we need to mutate
+    // its fields. We do this for the special mouse events because the event
+    // target needs to be retargeted to the action element rather than the real
+    // element (since we are simulating the special mouse events with mouseover/
+    // mouseout).
+    //
+    // Since we're making a copy anyways, we might as well attempt to convert
+    // this event into a pseudo-real mouseenter/mouseleave event by adjusting
+    // its type.
+    //
+    // tslint:disable-next-line:no-any
+    const copy = {};
+    for (const property in e) {
+        if (property === 'srcElement' || property === 'target') {
+            continue;
+        }
+        const key = property;
+        // Making a copy requires iterating through all properties of `Event`.
+        // tslint:disable-next-line:no-dict-access-on-struct-type
+        const value = e[key];
+        if (typeof value === 'function') {
+            continue;
+        }
+        // Value should be the expected type, but the value of `key` is not known
+        // statically.
+        // tslint:disable-next-line:no-any
+        copy[key] = value;
+    }
+    if (e.type === EventType.MOUSEOVER) {
+        copy['type'] = EventType.MOUSEENTER;
+    }
+    else if (e.type === EventType.MOUSEOUT) {
+        copy['type'] = EventType.MOUSELEAVE;
+    }
+    else if (e.type === EventType.POINTEROVER) {
+        copy['type'] = EventType.POINTERENTER;
+    }
+    else {
+        copy['type'] = EventType.POINTERLEAVE;
+    }
+    copy['target'] = copy['srcElement'] = target;
+    copy['bubbles'] = false;
+    return copy;
+}
 /**
- * The oi attribute is a log impression tag for impression logging
- * and action tracking. For an element that carries a jsaction
- * attribute, the element is identified for the purpose of
- * impression logging and click tracking by the dot separated path
- * of all oi attributes in the chain of ancestors of the element.
+ * Returns touch data extracted from the touch event: clientX, clientY, screenX
+ * and screenY. If the event has no touch information at all, the returned
+ * value is null.
  *
- * Used by ActionFlow.
+ * The fields of this Object are unquoted.
+ *
+ * @param event A touch event.
  */
-const OI$1 = 'oi';
+function getTouchData(event) {
+    const touch = (event.changedTouches && event.changedTouches[0]) || (event.touches && event.touches[0]);
+    if (!touch) {
+        return null;
+    }
+    return {
+        clientX: touch.clientX,
+        clientY: touch.clientY,
+        screenX: touch.screenX,
+        screenY: touch.screenY,
+    };
+}
 /**
- * The ved attribute is an encoded ClickTrackingCGI proto to track
- * visual elements.
+ * Creates a new EventLike object for a "click" event that's derived from the
+ * original corresponding "touchend" event for a fast-click implementation.
  *
- * Used by ActionFlow.
+ * It takes a touch event, adds common fields found in a click event and
+ * changes the type to 'click', so that the resulting event looks more like
+ * a real click event.
+ *
+ * @param event A touch event.
+ * @return A modified event-like object copied from the event object passed into
+ *     this function.
  */
-const VED = 'ved';
+function recreateTouchEventAsClick(event) {
+    const click = {};
+    click['originalEventType'] = event.type;
+    click['type'] = EventType.CLICK;
+    for (const property in event) {
+        if (property === 'type' || property === 'srcElement') {
+            continue;
+        }
+        const key = property;
+        // Making a copy requires iterating through all properties of `TouchEvent`.
+        // tslint:disable-next-line:no-dict-access-on-struct-type
+        const value = event[key];
+        if (typeof value === 'function') {
+            continue;
+        }
+        // Value should be the expected type, but the value of `key` is not known
+        // statically.
+        // tslint:disable-next-line:no-any
+        click[key] = value;
+    }
+    // Ensure that the event has the most recent timestamp. This timestamp
+    // may be used in the future to validate or cancel subsequent click events.
+    click['timeStamp'] = Date.now();
+    // Emulate preventDefault and stopPropagation behavior
+    click['defaultPrevented'] = false;
+    click['preventDefault'] = syntheticPreventDefault;
+    click['_propagationStopped'] = false;
+    click['stopPropagation'] = syntheticStopPropagation;
+    // Emulate click coordinates using touch info
+    const touch = getTouchData(event);
+    if (touch) {
+        click['clientX'] = touch.clientX;
+        click['clientY'] = touch.clientY;
+        click['screenX'] = touch.screenX;
+        click['screenY'] = touch.screenY;
+    }
+    return click;
+}
 /**
- * The vet attribute is the visual element type used to identify tracked
- * visual elements.
+ * An implementation of "preventDefault" for a synthesized event. Simply
+ * sets "defaultPrevented" property to true.
  */
-const VET = 'vet';
+function syntheticPreventDefault() {
+    this.defaultPrevented = true;
+}
 /**
- * Support for iteration on reprocessing.
- *
- * Used by ActionFlow.
+ * An implementation of "stopPropagation" for a synthesized event. It simply
+ * sets a synthetic non-standard "_propagationStopped" property to true.
  */
-const JSINSTANCE = 'jsinstance';
+function syntheticStopPropagation() {
+    this._propagationStopped = true;
+}
 /**
- * All click jsactions that happen on the element that carries this
- * attribute or its descendants are automatically logged.
- * Impressions of jsactions on these elements are tracked too, if
- * requested by the impression() method of ActionFlow.
- *
- * Used by ActionFlow.
+ * Mapping of KeyboardEvent.key values to
+ * KeyCode values.
  */
-const JSTRACK = 'jstrack';
-const Attribute = { JSACTION: JSACTION$1, OI: OI$1, VED, VET, JSINSTANCE, JSTRACK };
-
-const Char = {
-    /**
-     * The separator between the namespace and the action name in the
-     * jsaction attribute value.
-     */
-    NAMESPACE_ACTION_SEPARATOR: '.',
-    /**
-     * The separator between the event name and action in the jsaction
-     * attribute value.
-     */
-    EVENT_ACTION_SEPARATOR: ':',
-    /**
-     * The separator between the logged oi attribute values in the &oi=
-     * URL parameter value.
-     */
-    OI_SEPARATOR: '.',
-    /**
-     * The separator between the key and the value pairs in the &cad=
-     * URL parameter value.
-     */
-    CAD_KEY_VALUE_SEPARATOR: ':',
-    /**
-     * The separator between the key-value pairs in the &cad= URL
-     * parameter value.
-     */
-    CAD_SEPARATOR: ',',
+const ACTION_KEY_TO_KEYCODE = {
+    'Enter': KeyCode.ENTER,
+    ' ': KeyCode.SPACE,
 };
-
-/**
- * The parsed value of the jsaction attribute is stored in this
- * property on the DOM node. The parsed value is an Object. The
- * property names of the object are the events; the values are the
- * names of the actions. This property is attached even on nodes
- * that don't have a jsaction attribute as an optimization, because
- * property lookup is faster than attribute access.
- */
-const JSACTION = '__jsaction';
-/** The value of the oi attribute as a property, for faster access. */
-const OI = '__oi';
 /**
- * The owner property references an a logical owner for a DOM node. JSAction
- * will follow this reference instead of parentNode when traversing the DOM
- * to find jsaction attributes. This allows overlaying a logical structure
- * over a document where the DOM structure can't reflect that structure.
+ * Mapping of HTML element identifiers (ARIA role, type, or tagName) to the
+ * keys (enter and/or space) that should activate them. A value of zero means
+ * that both should activate them.
  */
-const OWNER = '__owner';
-/** All properties that are used by jsaction. */
-const Property = {
-    JSACTION,
-    OI,
-    OWNER,
+const IDENTIFIER_TO_KEY_TRIGGER_MAPPING = {
+    'A': KeyCode.ENTER,
+    'BUTTON': 0,
+    'CHECKBOX': KeyCode.SPACE,
+    'COMBOBOX': KeyCode.ENTER,
+    'FILE': 0,
+    'GRIDCELL': KeyCode.ENTER,
+    'LINK': KeyCode.ENTER,
+    'LISTBOX': KeyCode.ENTER,
+    'MENU': 0,
+    'MENUBAR': 0,
+    'MENUITEM': 0,
+    'MENUITEMCHECKBOX': 0,
+    'MENUITEMRADIO': 0,
+    'OPTION': 0,
+    'RADIO': KeyCode.SPACE,
+    'RADIOGROUP': KeyCode.SPACE,
+    'RESET': 0,
+    'SUBMIT': 0,
+    'SWITCH': KeyCode.SPACE,
+    'TAB': 0,
+    'TREE': KeyCode.ENTER,
+    'TREEITEM': KeyCode.ENTER,
 };
-
-/**
- * Map from jsaction annotation to a parsed map from event name to action name.
- */
-const parseCache = {};
 /**
- * Reads the jsaction parser cache from the given DOM Element.
- *
- * @param element .
- * @return Map from event to qualified name of the jsaction bound to it.
+ * Returns whether or not to process space based on the type of the element;
+ * checks to make sure that type is not null.
+ * @param element The element.
+ * @return Whether or not to process space based on type.
  */
-function get(element) {
-    // @ts-ignore
-    return element[JSACTION];
+function processSpace(element) {
+    const type = (element.getAttribute('type') || element.tagName).toUpperCase();
+    return type in PROCESS_SPACE;
 }
 /**
- * Writes the jsaction parser cache to the given DOM Element.
- *
- * @param element .
- * @param actionMap Map from event to qualified name of the jsaction bound to
- *     it.
+ * Returns whether or not the given element is a text control.
+ * @param el The element.
+ * @return Whether or not the given element is a text control.
  */
-function set(element, actionMap) {
-    // @ts-ignore
-    element[JSACTION] = actionMap;
+function isTextControl(el) {
+    const type = (el.getAttribute('type') || el.tagName).toUpperCase();
+    return type in TEXT_CONTROLS;
 }
 /**
- * Looks up the parsed action map from the source jsaction attribute value.
- *
- * @param text Unparsed jsaction attribute value.
- * @return Parsed jsaction attribute value, if already present in the cache.
+ * Returns if the given element is a native HTML control.
+ * @param el The element.
+ * @return If the given element is a native HTML control.
  */
-function getParsed(text) {
-    return parseCache[text];
+function isNativeHTMLControl(el) {
+    return el.tagName.toUpperCase() in NATIVE_HTML_CONTROLS;
 }
 /**
- * Inserts the parse result for the given source jsaction value into the cache.
- *
- * @param text Unparsed jsaction attribute value.
- * @param parsed Attribute value parsed into the action map.
+ * Returns if the given element is natively activatable. Browsers emit click
+ * events for natively activatable elements, even when activated via keyboard.
+ * For these elements, we don't need to raise a11y click events.
+ * @param el The element.
+ * @return If the given element is a native HTML control.
  */
-function setParsed(text, parsed) {
-    parseCache[text] = parsed;
+function isNativelyActivatable(el) {
+    return (el.tagName.toUpperCase() === 'BUTTON' ||
+        (!!el.type && el.type.toUpperCase() === 'FILE'));
 }
 /**
- * Clears the jsaction parser cache from the given DOM Element.
- *
- * @param element .
+ * HTML <input> types (not ARIA roles) which will auto-trigger a click event for
+ * the Space key, with side-effects. We will not call preventDefault if space is
+ * pressed, nor will we raise a11y click events.  For all other elements, we can
+ * suppress the default event (which has no desired side-effects) and handle the
+ * keydown ourselves.
  */
-function clear(element) {
-    if (JSACTION in element) {
-        delete element[JSACTION];
-    }
-}
+const PROCESS_SPACE = {
+    'CHECKBOX': true,
+    'FILE': true,
+    'OPTION': true,
+    'RADIO': true,
+};
+/** TagNames and Input types for which to not process enter/space as click. */
+const TEXT_CONTROLS = {
+    'COLOR': true,
+    'DATE': true,
+    'DATETIME': true,
+    'DATETIME-LOCAL': true,
+    'EMAIL': true,
+    'MONTH': true,
+    'NUMBER': true,
+    'PASSWORD': true,
+    'RANGE': true,
+    'SEARCH': true,
+    'TEL': true,
+    'TEXT': true,
+    'TEXTAREA': true,
+    'TIME': true,
+    'URL': true,
+    'WEEK': true,
+};
+/** TagNames that are native HTML controls. */
+const NATIVE_HTML_CONTROLS = {
+    'A': true,
+    'AREA': true,
+    'BUTTON': true,
+    'DIALOG': true,
+    'IMG': true,
+    'INPUT': true,
+    'LINK': true,
+    'MENU': true,
+    'OPTGROUP': true,
+    'OPTION': true,
+    'PROGRESS': true,
+    'SELECT': true,
+    'TEXTAREA': true,
+};
+/** Exported for testing. */
+const testing = {
+    setIsMac(value) {
+        isMac = value;
+    },
+};
 
 /**
  * Since maps from event to action are immutable we can use a single map
@@ -1520,26 +1388,7 @@ class ActionResolver {
         this.populateClickOnlyAction = undefined;
         this.syntheticMouseEventSupport = syntheticMouseEventSupport;
     }
-    resolve(eventInfo) {
-        if (getResolved(eventInfo)) {
-            return;
-        }
-        this.populateAction(eventInfo);
-        setResolved(eventInfo, true);
-    }
-    /**
-     * Searches for a jsaction that the DOM event maps to and creates an
-     * object containing event information used for dispatching by
-     * jsaction.Dispatcher. This method populates the `action` and `actionElement`
-     * fields of the EventInfo object passed in by finding the first
-     * jsaction attribute above the target Node of the event, and below
-     * the container Node, that specifies a jsaction for the event
-     * type. If no such jsaction is found, then action is undefined.
-     *
-     * @param eventInfo `EventInfo` to set `action` and `actionElement` if an
-     *    action is found on any `Element` in the path of the `Event`.
-     */
-    populateAction(eventInfo) {
+    resolveEventType(eventInfo) {
         // We distinguish modified and plain clicks in order to support the
         // default browser behavior of modified clicks on links; usually to
         // open the URL of the link in new tab or new window on ctrl/cmd
@@ -1580,10 +1429,38 @@ class ActionResolver {
         else if (this.a11yClickSupport) {
             this.updateEventInfoForA11yClick(eventInfo);
         }
-        // Walk to the parent node, unless the node has a different owner in
-        // which case we walk to the owner. Attempt to walk to host of a
-        // shadow root if needed.
-        let actionElement = getTargetElement(eventInfo);
+    }
+    resolveAction(eventInfo) {
+        if (getResolved(eventInfo)) {
+            return;
+        }
+        this.populateAction(eventInfo, getTargetElement(eventInfo));
+        setResolved(eventInfo, true);
+    }
+    resolveParentAction(eventInfo) {
+        const action = getAction(eventInfo);
+        const actionElement = action && getActionElement(action);
+        unsetAction(eventInfo);
+        const parentNode = actionElement && this.getParentNode(actionElement);
+        if (!parentNode) {
+            return;
+        }
+        this.populateAction(eventInfo, parentNode);
+    }
+    /**
+     * Searches for a jsaction that the DOM event maps to and creates an
+     * object containing event information used for dispatching by
+     * jsaction.Dispatcher. This method populates the `action` and `actionElement`
+     * fields of the EventInfo object passed in by finding the first
+     * jsaction attribute above the target Node of the event, and below
+     * the container Node, that specifies a jsaction for the event
+     * type. If no such jsaction is found, then action is undefined.
+     *
+     * @param eventInfo `EventInfo` to set `action` and `actionElement` if an
+     *    action is found on any `Element` in the path of the `Event`.
+     */
+    populateAction(eventInfo, currentTarget) {
+        let actionElement = currentTarget;
         while (actionElement && actionElement !== getContainer(eventInfo)) {
             if (actionElement.nodeType === Node.ELEMENT_NODE) {
                 this.populateActionOnElement(actionElement, eventInfo);
@@ -1594,16 +1471,7 @@ class ActionResolver {
                 // ancestor chain of the event target node.
                 break;
             }
-            if (actionElement[OWNER]) {
-                actionElement = actionElement[OWNER];
-                continue;
-            }
-            if (actionElement.parentNode?.nodeName !== '#document-fragment') {
-                actionElement = actionElement.parentNode;
-            }
-            else {
-                actionElement = actionElement.parentNode?.host ?? null;
-            }
+            actionElement = this.getParentNode(actionElement);
         }
         const action = getAction(eventInfo);
         if (!action) {
@@ -1643,6 +1511,22 @@ class ActionResolver {
             }
         }
     }
+    /**
+     * Walk to the parent node, unless the node has a different owner in
+     * which case we walk to the owner. Attempt to walk to host of a
+     * shadow root if needed.
+     */
+    getParentNode(element) {
+        const owner = element[OWNER];
+        if (owner) {
+            return owner;
+        }
+        const parentNode = element.parentNode;
+        if (parentNode?.nodeName === '#document-fragment') {
+            return parentNode?.host ?? null;
+        }
+        return parentNode;
+    }
     /**
      * Accesses the jsaction map on a node and retrieves the name of the
      * action the given event is mapped to, if any. It parses the
@@ -1711,6 +1595,339 @@ class ActionResolver {
     }
 }
 
+/**
+ * @fileoverview An enum to control who can call certain jsaction APIs.
+ */
+var Restriction;
+(function (Restriction) {
+    Restriction[Restriction["I_AM_THE_JSACTION_FRAMEWORK"] = 0] = "I_AM_THE_JSACTION_FRAMEWORK";
+})(Restriction || (Restriction = {}));
+
+/**
+ * Receives a DOM event, determines the jsaction associated with the source
+ * element of the DOM event, and invokes the handler associated with the
+ * jsaction.
+ */
+class Dispatcher {
+    /**
+     * Options are:
+     *   - `eventReplayer`: When the event contract dispatches replay events
+     *      to the Dispatcher, the Dispatcher collects them and in the next tick
+     *      dispatches them to the `eventReplayer`. Defaults to dispatching to `dispatchDelegate`.
+     * @param dispatchDelegate A function that should handle dispatching an `EventInfoWrapper` to handlers.
+     */
+    constructor(dispatchDelegate, { actionResolver, eventReplayer, } = {}) {
+        this.dispatchDelegate = dispatchDelegate;
+        /** Whether the event replay is scheduled. */
+        this.eventReplayScheduled = false;
+        /** The queue of events. */
+        this.replayEventInfoWrappers = [];
+        this.actionResolver = actionResolver;
+        this.eventReplayer = eventReplayer;
+    }
+    /**
+     * Receives an event or the event queue from the EventContract. The event
+     * queue is copied and it attempts to replay.
+     * If event info is passed in it looks for an action handler that can handle
+     * the given event.  If there is no handler registered queues the event and
+     * checks if a loader is registered for the given namespace. If so, calls it.
+     *
+     * Alternatively, if in global dispatch mode, calls all registered global
+     * handlers for the appropriate event type.
+     *
+     * The three functionalities of this call are deliberately not split into
+     * three methods (and then declared as an abstract interface), because the
+     * interface is used by EventContract, which lives in a different jsbinary.
+     * Therefore the interface between the three is defined entirely in terms that
+     * are invariant under jscompiler processing (Function and Array, as opposed
+     * to a custom type with method names).
+     *
+     * @param eventInfo The info for the event that triggered this call or the
+     *     queue of events from EventContract.
+     */
+    dispatch(eventInfo) {
+        const eventInfoWrapper = new EventInfoWrapper(eventInfo);
+        this.actionResolver?.resolveEventType(eventInfo);
+        this.actionResolver?.resolveAction(eventInfo);
+        const action = eventInfoWrapper.getAction();
+        if (action && shouldPreventDefaultBeforeDispatching(action.element, eventInfoWrapper)) {
+            preventDefault(eventInfoWrapper.getEvent());
+        }
+        if (this.eventReplayer && eventInfoWrapper.getIsReplay()) {
+            this.scheduleEventInfoWrapperReplay(eventInfoWrapper);
+            return;
+        }
+        this.dispatchDelegate(eventInfoWrapper);
+    }
+    /**
+     * Schedules an `EventInfoWrapper` for replay. The replaying will happen in its own
+     * stack once the current flow cedes control. This is done to mimic
+     * browser event handling.
+     */
+    scheduleEventInfoWrapperReplay(eventInfoWrapper) {
+        this.replayEventInfoWrappers.push(eventInfoWrapper);
+        if (this.eventReplayScheduled) {
+            return;
+        }
+        this.eventReplayScheduled = true;
+        Promise.resolve().then(() => {
+            this.eventReplayScheduled = false;
+            this.eventReplayer(this.replayEventInfoWrappers);
+        });
+    }
+}
+/**
+ * Creates an `EventReplayer` that calls the `replay` function for every `eventInfoWrapper` in
+ * the queue.
+ */
+function createEventReplayer(replay) {
+    return (eventInfoWrappers) => {
+        for (const eventInfoWrapper of eventInfoWrappers) {
+            replay(eventInfoWrapper);
+        }
+    };
+}
+/**
+ * Returns true if the default action of this event should be prevented before
+ * this event is dispatched.
+ */
+function shouldPreventDefaultBeforeDispatching(actionElement, eventInfoWrapper) {
+    // Prevent browser from following <a> node links if a jsaction is present
+    // and we are dispatching the action now. Note that the targetElement may be
+    // a child of an anchor that has a jsaction attached. For that reason, we
+    // need to check the actionElement rather than the targetElement.
+    return ((actionElement.tagName === 'A' && eventInfoWrapper.getEventType() === EventType.CLICK) ||
+        eventInfoWrapper.getEventType() === EventType.CLICKMOD);
+}
+/**
+ * Registers deferred functionality for an EventContract and a Jsaction
+ * Dispatcher.
+ */
+function registerDispatcher$1(eventContract, dispatcher) {
+    eventContract.ecrd((eventInfo) => {
+        dispatcher.dispatch(eventInfo);
+    }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);
+}
+
+/** An internal symbol used to indicate whether propagation should be stopped or not. */
+const PROPAGATION_STOPPED_SYMBOL = Symbol.for('propagationStopped');
+/** Extra event phases beyond what the browser provides. */
+const EventPhase = {
+    REPLAY: 101,
+};
+const PREVENT_DEFAULT_ERROR_MESSAGE_DETAILS = ' Because event replay occurs after browser dispatch, `preventDefault` would have no ' +
+    'effect. You can check whether an event is being replayed by accessing the event phase: ' +
+    '`event.eventPhase === EventPhase.REPLAY`.';
+const PREVENT_DEFAULT_ERROR_MESSAGE = `\`preventDefault\` called during event replay.`;
+const COMPOSED_PATH_ERROR_MESSAGE_DETAILS = () => ngDevMode
+    ? ' Because event replay occurs after browser ' +
+        'dispatch, `composedPath()` will be empty. Iterate parent nodes from `event.target` or ' +
+        '`event.currentTarget` if you need to check elements in the event path.'
+    : '';
+const COMPOSED_PATH_ERROR_MESSAGE = `\`composedPath\` called during event replay.`;
+/**
+ * A dispatcher that uses browser-based `Event` semantics, for example bubbling, `stopPropagation`,
+ * `currentTarget`, etc.
+ */
+class EventDispatcher {
+    constructor(dispatchDelegate) {
+        this.dispatchDelegate = dispatchDelegate;
+        this.actionResolver = new ActionResolver();
+        this.dispatcher = new Dispatcher((eventInfoWrapper) => {
+            this.dispatchToDelegate(eventInfoWrapper);
+        }, {
+            actionResolver: this.actionResolver,
+        });
+    }
+    /**
+     * The entrypoint for the `EventContract` dispatch.
+     */
+    dispatch(eventInfo) {
+        this.dispatcher.dispatch(eventInfo);
+    }
+    /** Internal method that does basic disaptching. */
+    dispatchToDelegate(eventInfoWrapper) {
+        if (eventInfoWrapper.getIsReplay()) {
+            prepareEventForReplay(eventInfoWrapper);
+        }
+        prepareEventForBubbling(eventInfoWrapper);
+        while (eventInfoWrapper.getAction()) {
+            prepareEventForDispatch(eventInfoWrapper);
+            this.dispatchDelegate(eventInfoWrapper.getEvent(), eventInfoWrapper.getAction().name);
+            if (propagationStopped(eventInfoWrapper)) {
+                return;
+            }
+            this.actionResolver.resolveParentAction(eventInfoWrapper.eventInfo);
+        }
+    }
+}
+function prepareEventForBubbling(eventInfoWrapper) {
+    const event = eventInfoWrapper.getEvent();
+    const stopPropagation = () => {
+        event[PROPAGATION_STOPPED_SYMBOL] = true;
+    };
+    patchEventInstance(event, 'stopPropagation', stopPropagation);
+    patchEventInstance(event, 'stopImmediatePropagation', stopPropagation);
+}
+function propagationStopped(eventInfoWrapper) {
+    const event = eventInfoWrapper.getEvent();
+    return !!event[PROPAGATION_STOPPED_SYMBOL];
+}
+function prepareEventForReplay(eventInfoWrapper) {
+    const event = eventInfoWrapper.getEvent();
+    const target = eventInfoWrapper.getTargetElement();
+    patchEventInstance(event, 'target', target);
+    patchEventInstance(event, 'eventPhase', EventPhase.REPLAY);
+    patchEventInstance(event, 'preventDefault', () => {
+        throw new Error(PREVENT_DEFAULT_ERROR_MESSAGE + (ngDevMode ? PREVENT_DEFAULT_ERROR_MESSAGE_DETAILS : ''));
+    });
+    patchEventInstance(event, 'composedPath', () => {
+        throw new Error(COMPOSED_PATH_ERROR_MESSAGE + (ngDevMode ? COMPOSED_PATH_ERROR_MESSAGE_DETAILS : ''));
+    });
+}
+function prepareEventForDispatch(eventInfoWrapper) {
+    const event = eventInfoWrapper.getEvent();
+    const currentTarget = eventInfoWrapper.getAction()?.element;
+    if (currentTarget) {
+        patchEventInstance(event, 'currentTarget', currentTarget, {
+            // `currentTarget` is going to get reassigned every dispatch.
+            configurable: true,
+        });
+    }
+}
+/**
+ * Patch `Event` instance during non-standard `Event` dispatch. This patches just the `Event`
+ * instance that the browser created, it does not patch global properties or methods.
+ *
+ * This is necessary because dispatching an `Event` outside of browser dispatch results in
+ * incorrect properties and methods that need to be polyfilled or do not work.
+ *
+ * JSAction dispatch adds two extra "phases" to event dispatch:
+ * 1. Event delegation - the event is being dispatched by a delegating event handler on a container
+ *    (typically `window.document.documentElement`), to a delegated event handler on some child
+ *    element. Certain `Event` properties will be unintuitive, such as `currentTarget`, which would
+ *    be the container rather than the child element. Bubbling would also not work. In order to
+ *    emulate the browser, these properties and methods on the `Event` are patched.
+ * 2. Event replay - the event is being dispatched by the framework once the handlers have been
+ *    loaded (during hydration, or late-loaded). Certain `Event` properties can be unset by the
+ *    browser because the `Event` is no longer actively being dispatched, such as `target`. Other
+ *    methods have no effect because the `Event` has already been dispatched, such as
+ *    `preventDefault`. Bubbling would also not work. These properties and methods are patched,
+ *    either to fill in information that the browser may have removed, or to throw errors in methods
+ *    that no longer behave as expected.
+ */
+function patchEventInstance(event, property, value, { configurable = false } = {}) {
+    Object.defineProperty(event, property, { value, configurable });
+}
+/**
+ * Registers deferred functionality for an EventContract and a Jsaction
+ * Dispatcher.
+ */
+function registerDispatcher(eventContract, dispatcher) {
+    eventContract.ecrd((eventInfo) => {
+        dispatcher.dispatch(eventInfo);
+    }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);
+}
+
+/**
+ * Whether the user agent is running on iOS.
+ */
+const isIos = typeof navigator !== 'undefined' && /iPhone|iPad|iPod/.test(navigator.userAgent);
+/**
+ * A class representing a container node and all the event handlers
+ * installed on it. Used so that handlers can be cleaned up if the
+ * container is removed from the contract.
+ */
+class EventContractContainer {
+    /**
+     * @param element The container Element.
+     */
+    constructor(element) {
+        this.element = element;
+        /**
+         * Array of event handlers and their corresponding event types that are
+         * installed on this container.
+         *
+         */
+        this.handlerInfos = [];
+    }
+    /**
+     * Installs the provided installer on the element owned by this container,
+     * and maintains a reference to resulting handler in order to remove it
+     * later if desired.
+     */
+    addEventListener(eventType, getHandler) {
+        // In iOS, event bubbling doesn't happen automatically in any DOM element,
+        // unless it has an onclick attribute or DOM event handler attached to it.
+        // This breaks JsAction in some cases. See "Making Elements Clickable"
+        // section at http://goo.gl/2VoGnB.
+        //
+        // A workaround for this issue is to change the CSS cursor style to 'pointer'
+        // for the container element, which magically turns on event bubbling. This
+        // solution is described in the comments section at http://goo.gl/6pEO1z.
+        //
+        // We use a navigator.userAgent check here as this problem is present both
+        // on Mobile Safari and thin WebKit wrappers, such as Chrome for iOS.
+        if (isIos) {
+            this.element.style.cursor = 'pointer';
+        }
+        this.handlerInfos.push(addEventListener(this.element, eventType, getHandler(this.element)));
+    }
+    /**
+     * Removes all the handlers installed on this container.
+     */
+    cleanUp() {
+        for (let i = 0; i < this.handlerInfos.length; i++) {
+            removeEventListener(this.element, this.handlerInfos[i]);
+        }
+        this.handlerInfos = [];
+    }
+}
+
+/**
+ * Update `EventInfo` to be `eventType = 'click'` and sets `a11yClickKey` if it
+ * is a a11y click.
+ */
+function updateEventInfoForA11yClick(eventInfo) {
+    if (!isActionKeyEvent(getEvent(eventInfo))) {
+        return;
+    }
+    setA11yClickKey(eventInfo, true);
+    // A 'click' triggered by a DOM keypress should be mapped to the 'click'
+    // jsaction.
+    setEventType(eventInfo, EventType.CLICK);
+}
+/**
+ * Call `preventDefault` on an a11y click if it is space key or to prevent the
+ * browser's default action for native HTML controls.
+ */
+function preventDefaultForA11yClick(eventInfo) {
+    if (!getA11yClickKey(eventInfo) ||
+        (!isSpaceKeyEvent(getEvent(eventInfo)) &&
+            !shouldCallPreventDefaultOnNativeHtmlControl(getEvent(eventInfo)))) {
+        return;
+    }
+    preventDefault(getEvent(eventInfo));
+}
+/**
+ * Sets the `action` to `clickonly` for a click event that is not an a11y click
+ * and if there is not already a click action.
+ */
+function populateClickOnlyAction(actionElement, eventInfo, actionMap) {
+    if (
+    // If there's already an action, don't attempt to set a CLICKONLY
+    getAction(eventInfo) ||
+        // Only attempt CLICKONLY if the type is CLICK
+        getEventType(eventInfo) !== EventType.CLICK ||
+        // a11y clicks are never CLICKONLY
+        getA11yClickKey(eventInfo) ||
+        actionMap[EventType.CLICKONLY] === undefined) {
+        return;
+    }
+    setEventType(eventInfo, EventType.CLICKONLY);
+    setAction(eventInfo, actionMap[EventType.CLICKONLY], actionElement);
+}
+
 /**
  * @define Support for accessible click actions.  This flag can be overridden in
  * a build rule.
@@ -1819,7 +2036,8 @@ class EventContract {
             return;
         }
         if (this.useActionResolver) {
-            this.actionResolver.resolve(eventInfo);
+            this.actionResolver.resolveEventType(eventInfo);
+            this.actionResolver.resolveAction(eventInfo);
         }
         this.dispatcher(eventInfo);
     }
@@ -1840,11 +2058,7 @@ class EventContract {
         if (eventType in this.eventHandlers || !this.containerManager) {
             return;
         }
-        if (!EventContract.MOUSE_SPECIAL_SUPPORT &&
-            (eventType === EventType.MOUSEENTER ||
-                eventType === EventType.MOUSELEAVE ||
-                eventType === EventType.POINTERENTER ||
-                eventType === EventType.POINTERLEAVE)) {
+        if (!EventContract.MOUSE_SPECIAL_SUPPORT && NON_BUBBLING_MOUSE_EVENTS.indexOf(eventType) >= 0) {
             return;
         }
         const eventHandler = (eventType, event, container) => {
@@ -2056,5 +2270,5 @@ function bootstrapEarlyEventContract(field, container, appId, eventTypes, captur
         eventContract.addEvents(captureEventTypes, true);
 }
 
-export { Dispatcher, EventContract, EventContractContainer, EventInfoWrapper, bootstrapEarlyEventContract, registerDispatcher };
+export { EventContract, EventContractContainer, EventDispatcher, EventInfoWrapper, EventPhase, bootstrapEarlyEventContract, isCaptureEvent, isSupportedEvent, registerDispatcher };
 //# sourceMappingURL=event-dispatch.mjs.map