@angular/core 18.1.0 → 18.1.2

package/fesm2022/primitives/event-dispatch.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v18.1.0
+ * @license Angular v18.1.2
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -20,19 +20,80 @@ const Attribute = {
     JSACTION: 'jsaction',
 };
 
-const Char = {
+/** All properties that are used by jsaction. */
+const Property = {
     /**
-     * The separator between the namespace and the action name in the
-     * jsaction attribute value.
+     * 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.
      */
-    NAMESPACE_ACTION_SEPARATOR: '.',
+    JSACTION: '__jsaction',
     /**
-     * The separator between the event name and action in the jsaction
-     * attribute value.
+     * 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.
      */
-    EVENT_ACTION_SEPARATOR: ':',
+    OWNER: '__owner',
 };
 
+/**
+ * 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.
+ */
+function get(element) {
+    return element[Property.JSACTION];
+}
+/**
+ * Reads the jsaction parser cache for the given DOM element. If no cache is yet present,
+ * creates an empty one.
+ */
+function getDefaulted(element) {
+    const cache = get(element) ?? {};
+    set(element, cache);
+    return cache;
+}
+/**
+ * Writes the jsaction parser cache to the given DOM Element.
+ */
+function set(element, actionMap) {
+    element[Property.JSACTION] = actionMap;
+}
+/**
+ * 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 getParsed(text) {
+    return parseCache[text];
+}
+/**
+ * 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.
+ */
+function setParsed(text, parsed) {
+    parseCache[text] = parsed;
+}
+/**
+ * Clears the jsaction parser cache from the given DOM Element.
+ *
+ * @param element .
+ */
+function clear(element) {
+    if (Property.JSACTION in element) {
+        delete element[Property.JSACTION];
+    }
+}
+
 /*
  * 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()
@@ -269,32 +330,25 @@ const EventType = {
      */
     CUSTOM: '_custom',
 };
-const NON_BUBBLING_MOUSE_EVENTS = [
+/** All event types that do not bubble or capture and need a polyfill. */
+const MOUSE_SPECIAL_EVENT_TYPES = [
     EventType.MOUSEENTER,
     EventType.MOUSELEAVE,
     'pointerenter',
     'pointerleave',
 ];
-/**
- * Detects whether a given event type is supported by JSAction.
- */
-const isSupportedEvent = (eventType) => SUPPORTED_EVENTS.indexOf(eventType) >= 0;
-const SUPPORTED_EVENTS = [
+/** All event types that are registered in the bubble phase. */
+const BUBBLE_EVENT_TYPES = [
     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,
@@ -338,313 +392,26 @@ const SUPPORTED_EVENTS = [
     // Content visibility events.
     'beforematch',
 ];
-/**
- *
- * Decides whether or not an event type is an event that only has a capture phase.
- *
- * @param eventType
- * @returns bool
- */
-const isCaptureEvent = (eventType) => CAPTURE_EVENTS.indexOf(eventType) >= 0;
-const CAPTURE_EVENTS = [
+/** All event types that are registered in the capture phase. */
+const CAPTURE_EVENT_TYPES = [
     EventType.FOCUS,
-    EventType.BLUR,
-    EventType.ERROR,
-    EventType.LOAD,
-    EventType.TOGGLE,
-];
-
-/** All properties that are used by jsaction. */
-const Property = {
-    /**
-     * 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.
-     */
-    JSACTION: '__jsaction',
-    /**
-     * 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.
-     */
-    OWNER: '__owner',
-};
-
-/**
- * Map from jsaction annotation to a parsed map from event name to action name.
- */
-const parseCache = {};
-function registerEventType(element, eventType, action) {
-    const cache = get(element) || {};
-    cache[eventType] = action;
-    set(element, cache);
-}
-function unregisterEventType(element, eventType) {
-    const cache = get(element);
-    if (cache) {
-        cache[eventType] = undefined;
-    }
-}
-/**
- * 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 get(element) {
-    // @ts-ignore
-    return element[Property.JSACTION];
-}
-/**
- * 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 set(element, actionMap) {
-    // @ts-ignore
-    element[Property.JSACTION] = actionMap;
-}
-/**
- * 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 getParsed(text) {
-    return parseCache[text];
-}
-/**
- * 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.
- */
-function setParsed(text, parsed) {
-    parseCache[text] = parsed;
-}
-/**
- * Clears the jsaction parser cache from the given DOM Element.
- *
- * @param element .
- */
-function clear(element) {
-    if (Property.JSACTION in element) {
-        delete element[Property.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,
-    };
-}
-/**
- * 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 createEventInfoFromParameters(eventType, event, targetElement, container, timestamp, action, isReplay, a11yClickKey) {
-    return {
-        eventType,
-        event,
-        targetElement,
-        eic: container,
-        timeStamp: timestamp,
-        eia: action,
-        eirp: isReplay,
-        eiack: a11yClickKey,
-    };
-}
-/**
- * Utility function for creating an `EventInfo`.
- *
- * This should be used in compilation units that are less sensitive to code
- * size.
- */
-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,
-    };
-}
-/**
- * Utility class around an `EventInfo`.
- *
- * This should be used in compilation units that are less sensitive to code
- * size.
- */
-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));
-    }
-}
+    EventType.BLUR,
+    EventType.ERROR,
+    EventType.LOAD,
+    EventType.TOGGLE,
+];
+/**
+ * Whether or not an event type should be registered in the capture phase.
+ * @param eventType
+ * @returns bool
+ */
+const isCaptureEventType = (eventType) => CAPTURE_EVENT_TYPES.indexOf(eventType) >= 0;
+/** All event types that are registered early.  */
+const EARLY_EVENT_TYPES = BUBBLE_EVENT_TYPES.concat(CAPTURE_EVENT_TYPES);
+/**
+ * Whether or not an event type is registered in the early contract.
+ */
+const isEarlyEventType = (eventType) => EARLY_EVENT_TYPES.indexOf(eventType) >= 0;
 
 /**
  * If on a Macintosh with an extended keyboard, the Enter key located in the
@@ -706,7 +473,7 @@ function addEventListener(element, eventType, handler) {
     // 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)) {
+    if (isCaptureEventType(eventType)) {
         capture = true;
     }
     element.addEventListener(eventType, handler, capture);
@@ -1217,70 +984,345 @@ function isNativeHTMLControl(el) {
     return el.tagName.toUpperCase() in NATIVE_HTML_CONTROLS;
 }
 /**
- * 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.
+ * 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 isNativelyActivatable(el) {
+    return (el.tagName.toUpperCase() === 'BUTTON' ||
+        (!!el.type && el.type.toUpperCase() === 'FILE'));
+}
+/**
+ * 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.
+ */
+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;
+    },
+};
+
+/**
+ * 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 = [];
+    }
+}
+
+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: ':',
+};
+
+/** 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`.
+ *
+ * This can be used from code-size sensitive compilation units, as taking
+ * parameters vs. an `Object` literal reduces code size.
+ */
+function createEventInfoFromParameters(eventType, event, targetElement, container, timestamp, action, isReplay, a11yClickKey) {
+    return {
+        eventType,
+        event,
+        targetElement,
+        eic: container,
+        timeStamp: timestamp,
+        eia: action,
+        eirp: isReplay,
+        eiack: a11yClickKey,
+    };
+}
+/**
+ * Utility function for creating an `EventInfo`.
+ *
+ * This should be used in compilation units that are less sensitive to code
+ * size.
  */
-function isNativelyActivatable(el) {
-    return (el.tagName.toUpperCase() === 'BUTTON' ||
-        (!!el.type && el.type.toUpperCase() === 'FILE'));
+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,
+    };
 }
 /**
- * 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.
+ * Utility class around an `EventInfo`.
+ *
+ * This should be used in compilation units that are less sensitive to code
+ * size.
  */
-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;
-    },
-};
+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));
+    }
+}
 
 /**
  * Since maps from event to action are immutable we can use a single map
@@ -1618,7 +1660,7 @@ function shouldPreventDefaultBeforeDispatching(actionElement, eventInfoWrapper)
  * Registers deferred functionality for an EventContract and a Jsaction
  * Dispatcher.
  */
-function registerDispatcher$1(eventContract, dispatcher) {
+function registerDispatcher$2(eventContract, dispatcher) {
     eventContract.ecrd((eventInfo) => {
         dispatcher.dispatch(eventInfo);
     }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);
@@ -1736,78 +1778,110 @@ function patchEventInstance(event, property, value, { configurable = false } = {
  * Registers deferred functionality for an EventContract and a Jsaction
  * Dispatcher.
  */
-function registerDispatcher(eventContract, dispatcher) {
+function registerDispatcher$1(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.
+ * EarlyEventContract intercepts events in the bubbling phase at the
+ * boundary of the document body. This mapping will be passed to the
+ * late-loaded EventContract.
  */
-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 = [];
+class EarlyEventContract {
+    constructor(dataContainer = window, container = window.document.documentElement) {
+        this.dataContainer = dataContainer;
+        dataContainer._ejsa = createEarlyJsactionData(container);
     }
     /**
-     * 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.
+     * Installs a list of event types for container .
      */
-    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)));
+    addEvents(types, capture) {
+        addEvents(this.dataContainer._ejsa, types, capture);
     }
-    /**
-     * 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 = [];
+}
+/** Creates an `EarlyJsactionData` object. */
+function createEarlyJsactionData(container) {
+    const q = [];
+    const d = (eventInfo) => {
+        q.push(eventInfo);
+    };
+    const h = (event) => {
+        d(createEventInfoFromParameters(event.type, event, event.target, container, Date.now()));
+    };
+    return {
+        c: container,
+        q,
+        et: [],
+        etc: [],
+        d,
+        h,
+    };
+}
+/** Add all the events to the container stored in the `EarlyJsactionData`. */
+function addEvents(earlyJsactionData, types, capture) {
+    for (let i = 0; i < types.length; i++) {
+        const eventType = types[i];
+        const eventTypes = capture ? earlyJsactionData.etc : earlyJsactionData.et;
+        eventTypes.push(eventType);
+        earlyJsactionData.c.addEventListener(eventType, earlyJsactionData.h, capture);
+    }
+}
+/** Get the queued `EventInfo` objects that were dispatched before a dispatcher was registered. */
+function getQueuedEventInfos(earlyJsactionData) {
+    return earlyJsactionData?.q ?? [];
+}
+/** Register a different dispatcher function on the `EarlyJsactionData`. */
+function registerDispatcher(earlyJsactionData, dispatcher) {
+    if (!earlyJsactionData) {
+        return;
+    }
+    earlyJsactionData.d = dispatcher;
+}
+/** Removes all event listener handlers. */
+function removeAllEventListeners(earlyJsactionData) {
+    if (!earlyJsactionData) {
+        return;
+    }
+    removeEventListeners(earlyJsactionData.c, earlyJsactionData.et, earlyJsactionData.h);
+    removeEventListeners(earlyJsactionData.c, earlyJsactionData.etc, earlyJsactionData.h, true);
+}
+function removeEventListeners(container, eventTypes, earlyEventHandler, capture) {
+    for (let i = 0; i < eventTypes.length; i++) {
+        container.removeEventListener(eventTypes[i], earlyEventHandler, /* useCapture */ capture);
     }
 }
 
-/**
- * @define Support for accessible click actions.  This flag can be overridden in
- * a build rule.
- */
-const A11Y_CLICK_SUPPORT = false;
 /**
  * @define Support for the non-bubbling mouseenter and mouseleave events.  This
  * flag can be overridden in a build rule.
  */
 const MOUSE_SPECIAL_SUPPORT = false;
 
+/**
+ * @fileoverview Implements the local event handling contract. This
+ * allows DOM objects in a container that enters into this contract to
+ * define event handlers which are executed in a local context.
+ *
+ * One EventContract instance can manage the contract for multiple
+ * containers, which are added using the addContainer() method.
+ *
+ * Events can be registered using the addEvent() method.
+ *
+ * A Dispatcher is added using the registerDispatcher() method. Until there is
+ * a dispatcher, events are queued. The idea is that the EventContract
+ * class is inlined in the HTML of the top level page and instantiated
+ * right after the start of <body>. The Dispatcher class is contained
+ * in the external deferred js, and instantiated and registered with
+ * EventContract when the external javascript in the page loads. The
+ * external javascript will also register the jsaction handlers, which
+ * then pick up the queued events at the time of registration.
+ *
+ * Since this class is meant to be inlined in the main page HTML, the
+ * size of the binary compiled from this file MUST be kept as small as
+ * possible and thus its dependencies to a minimum.
+ */
 /**
  * EventContract intercepts events in the bubbling phase at the
  * boundary of a container element, and maps them to generic actions
@@ -1823,10 +1897,8 @@ const MOUSE_SPECIAL_SUPPORT = false;
  * be delay loaded in a generic way.
  */
 class EventContract {
-    static { this.A11Y_CLICK_SUPPORT = A11Y_CLICK_SUPPORT; }
     static { this.MOUSE_SPECIAL_SUPPORT = MOUSE_SPECIAL_SUPPORT; }
-    constructor(containerManager, useActionResolver) {
-        this.useActionResolver = useActionResolver;
+    constructor(containerManager) {
         /**
          * The DOM events which this contract covers. Used to prevent double
          * registration of event types. The value of the map is the
@@ -1889,7 +1961,7 @@ class EventContract {
         if (eventType in this.eventHandlers || !this.containerManager) {
             return;
         }
-        if (!EventContract.MOUSE_SPECIAL_SUPPORT && NON_BUBBLING_MOUSE_EVENTS.indexOf(eventType) >= 0) {
+        if (!EventContract.MOUSE_SPECIAL_SUPPORT && MOUSE_SPECIAL_EVENT_TYPES.indexOf(eventType) >= 0) {
             return;
         }
         const eventHandler = (eventType, event, container) => {
@@ -1914,31 +1986,34 @@ class EventContract {
      * in the provided event contract. Once all the events are replayed, it cleans
      * up the early contract.
      */
-    replayEarlyEvents(earlyJsactionContainer = window) {
+    replayEarlyEvents(earlyJsactionData = window._ejsa) {
         // Check if the early contract is present and prevent calling this function
         // more than once.
-        const earlyJsactionData = earlyJsactionContainer._ejsa;
         if (!earlyJsactionData) {
             return;
         }
         // Replay the early contract events.
-        const earlyEventInfos = earlyJsactionData.q;
-        for (let idx = 0; idx < earlyEventInfos.length; idx++) {
-            const earlyEventInfo = earlyEventInfos[idx];
+        this.replayEarlyEventInfos(earlyJsactionData.q);
+        // Clean up the early contract.
+        removeAllEventListeners(earlyJsactionData);
+        delete window._ejsa;
+    }
+    /**
+     * Replays all the early `EventInfo` objects, dispatching them through the normal
+     * `EventContract` flow.
+     */
+    replayEarlyEventInfos(earlyEventInfos) {
+        for (let i = 0; i < earlyEventInfos.length; i++) {
+            const earlyEventInfo = earlyEventInfos[i];
             const eventTypes = this.getEventTypesForBrowserEventType(earlyEventInfo.eventType);
-            for (let i = 0; i < eventTypes.length; i++) {
+            for (let j = 0; j < eventTypes.length; j++) {
                 const eventInfo = cloneEventInfo(earlyEventInfo);
                 // EventInfo eventType maps to JSAction's internal event type,
                 // rather than the browser event type.
-                setEventType(eventInfo, eventTypes[i]);
+                setEventType(eventInfo, eventTypes[j]);
                 this.handleEventInfo(eventInfo);
             }
         }
-        // Clean up the early contract.
-        const earlyEventHandler = earlyJsactionData.h;
-        removeEventListeners(earlyJsactionData.c, earlyJsactionData.et, earlyEventHandler);
-        removeEventListeners(earlyJsactionData.c, earlyJsactionData.etc, earlyEventHandler, true);
-        delete earlyJsactionContainer._ejsa;
     }
     /**
      * Returns all JSAction event types that have been registered for a given
@@ -1999,86 +2074,43 @@ class EventContract {
             this.queuedEventInfos = null;
         }
     }
-    /**
-     * Adds a11y click support to the given `EventContract`. Meant to be called in
-     * the same compilation unit as the `EventContract`.
-     */
-    addA11yClickSupport() { }
-    /**
-     * Enables a11y click support to be deferred. Meant to be called in the same
-     * compilation unit as the `EventContract`.
-     */
-    exportAddA11yClickSupport() { }
-}
-function removeEventListeners(container, eventTypes, earlyEventHandler, capture) {
-    for (let idx = 0; idx < eventTypes.length; idx++) {
-        container.removeEventListener(eventTypes[idx], earlyEventHandler, /* useCapture */ capture);
-    }
 }
-/**
- * Adds a11y click support to the given `EventContract`. Meant to be called
- * in a different compilation unit from the `EventContract`. The `EventContract`
- * must have called `exportAddA11yClickSupport` in its compilation unit for this
- * to have any effect.
- */
-function addDeferredA11yClickSupport(eventContract) { }
 
 /**
- * EarlyEventContract intercepts events in the bubbling phase at the
- * boundary of the document body. This mapping will be passed to the
- * late-loaded EventContract.
+ * Creates an `EarlyJsactionData`, adds events to it, and populates it on a nested object on
+ * the window.
  */
-class EarlyEventContract {
-    constructor(replaySink = window, container = window.document.documentElement) {
-        this.replaySink = replaySink;
-        this.container = container;
-        replaySink._ejsa = {
-            c: container,
-            q: [],
-            et: [],
-            etc: [],
-            h: (event) => {
-                const eventInfo = createEventInfoFromParameters(event.type, event, event.target, container, Date.now());
-                replaySink._ejsa.q.push(eventInfo);
-            },
-        };
-    }
-    /**
-     * Installs a list of event types for container .
-     */
-    addEvents(types, capture) {
-        const replaySink = this.replaySink._ejsa;
-        for (let idx = 0; idx < types.length; idx++) {
-            const eventType = types[idx];
-            const eventTypes = capture ? replaySink.etc : replaySink.et;
-            eventTypes.push(eventType);
-            this.container.addEventListener(eventType, replaySink.h, capture);
-        }
+function bootstrapAppScopedEarlyEventContract(container, appId, bubbleEventTypes, captureEventTypes, dataContainer = window) {
+    const earlyJsactionData = createEarlyJsactionData(container);
+    if (!dataContainer._ejsas) {
+        dataContainer._ejsas = {};
     }
+    dataContainer._ejsas[appId] = earlyJsactionData;
+    addEvents(earlyJsactionData, bubbleEventTypes);
+    addEvents(earlyJsactionData, captureEventTypes, /* capture= */ true);
+}
+/** Get the queued `EventInfo` objects that were dispatched before a dispatcher was registered. */
+function getAppScopedQueuedEventInfos(appId, dataContainer = window) {
+    return getQueuedEventInfos(dataContainer._ejsas?.[appId]);
 }
-
 /**
- * Provides a factory function for bootstrapping an event contract on a
- * specified object (by default, exposed on the `window`).
- * @param field The property on the object that the event contract will be placed on.
- * @param container The container that listens to events
- * @param appId A given identifier for an application. If there are multiple apps on the page
- *              then this is how contracts can be initialized for each one.
- * @param eventTypes An array of event names that should be listened to.
- * @param captureEventTypes An array of event names that should be listened to with capture.
- * @param earlyJsactionTracker The object that should receive the event contract.
+ * Registers a dispatcher function on the `EarlyJsactionData` present on the nested object on the
+ * window.
  */
-function bootstrapEarlyEventContract(field, container, appId, eventTypes, captureEventTypes, earlyJsactionTracker = window) {
-    if (!earlyJsactionTracker[field]) {
-        earlyJsactionTracker[field] = {};
+function registerAppScopedDispatcher(restriction, appId, dispatcher, dataContainer = window) {
+    registerDispatcher(dataContainer._ejsas?.[appId], dispatcher);
+}
+/** Removes all event listener handlers. */
+function removeAllAppScopedEventListeners(appId, dataContainer = window) {
+    removeAllEventListeners(dataContainer._ejsas?.[appId]);
+}
+/** Clear the early event contract. */
+function clearAppScopedEarlyEventContract(appId, dataContainer = window) {
+    if (!dataContainer._ejsas) {
+        return;
     }
-    earlyJsactionTracker[field][appId] = {};
-    const eventContract = new EarlyEventContract(earlyJsactionTracker[field][appId], container);
-    if (eventTypes)
-        eventContract.addEvents(eventTypes);
-    if (captureEventTypes)
-        eventContract.addEvents(captureEventTypes, true);
+    dataContainer._ejsas[appId] = undefined;
 }
 
-export { Attribute, EventContract, EventContractContainer, EventDispatcher, EventInfoWrapper, EventPhase, bootstrapEarlyEventContract, isCaptureEvent, isSupportedEvent, registerDispatcher, registerEventType, unregisterEventType };
+export { Attribute, EventContract, EventContractContainer, EventDispatcher, EventInfoWrapper, EventPhase, bootstrapAppScopedEarlyEventContract, clearAppScopedEarlyEventContract, getDefaulted as getActionCache, getAppScopedQueuedEventInfos, isCaptureEventType, isEarlyEventType, registerAppScopedDispatcher, registerDispatcher$1 as registerDispatcher, removeAllAppScopedEventListeners };
 //# sourceMappingURL=event-dispatch.mjs.map