npm - @angular/core - Versions diffs - 18.0.0-next.5 → 18.0.0-next.6 - Mend

@angular/core 18.0.0-next.5 → 18.0.0-next.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (82) hide show

package/esm2022/primitives/event-dispatch/contract_binary.mjs +10 -0
package/esm2022/primitives/event-dispatch/index.mjs +13 -0
package/esm2022/primitives/event-dispatch/src/a11y_click.mjs +54 -0
package/esm2022/primitives/event-dispatch/src/accessibility.mjs +35 -0
package/esm2022/primitives/event-dispatch/src/attribute.mjs +72 -0
package/esm2022/primitives/event-dispatch/src/base_dispatcher.mjs +196 -0
package/esm2022/primitives/event-dispatch/src/cache.mjs +95 -0
package/esm2022/primitives/event-dispatch/src/char.mjs +35 -0
package/esm2022/primitives/event-dispatch/src/custom_events.mjs +63 -0
package/esm2022/primitives/event-dispatch/src/dispatcher.mjs +254 -0
package/esm2022/primitives/event-dispatch/src/dom.mjs +48 -0
package/esm2022/primitives/event-dispatch/src/earlyeventcontract.mjs +36 -0
package/esm2022/primitives/event-dispatch/src/event.mjs +638 -0
package/esm2022/primitives/event-dispatch/src/event_contract_container.mjs +63 -0
package/esm2022/primitives/event-dispatch/src/event_contract_defines.mjs +48 -0
package/esm2022/primitives/event-dispatch/src/event_contract_multi_container.mjs +192 -0
package/esm2022/primitives/event-dispatch/src/event_handler.mjs +9 -0
package/esm2022/primitives/event-dispatch/src/event_info.mjs +199 -0
package/esm2022/primitives/event-dispatch/src/event_type.mjs +244 -0
package/esm2022/primitives/event-dispatch/src/eventcontract.mjs +675 -0
package/esm2022/primitives/event-dispatch/src/key_code.mjs +21 -0
package/esm2022/primitives/event-dispatch/src/legacy_dispatcher.mjs +9 -0
package/esm2022/primitives/event-dispatch/src/property.mjs +35 -0
package/esm2022/primitives/event-dispatch/src/register_events.mjs +32 -0
package/esm2022/primitives/event-dispatch/src/replay.mjs +389 -0
package/esm2022/primitives/event-dispatch/src/restriction.mjs +15 -0
package/esm2022/primitives/signals/index.mjs +3 -3
package/esm2022/primitives/signals/src/computed.mjs +5 -3
package/esm2022/primitives/signals/src/graph.mjs +14 -9
package/esm2022/primitives/signals/src/signal.mjs +2 -2
package/esm2022/primitives/signals/src/watch.mjs +2 -2
package/esm2022/src/change_detection/scheduling/zoneless_scheduling_impl.mjs +50 -5
package/esm2022/src/core.mjs +2 -1
package/esm2022/src/core_private_export.mjs +2 -1
package/esm2022/src/defer/instructions.mjs +31 -8
package/esm2022/src/di/host_tag_name_token.mjs +65 -0
package/esm2022/src/di/index.mjs +2 -1
package/esm2022/src/errors.mjs +1 -1
package/esm2022/src/hydration/annotate.mjs +15 -1
package/esm2022/src/hydration/event_replay.mjs +181 -0
package/esm2022/src/hydration/tokens.mjs +6 -1
package/esm2022/src/pending_tasks.mjs +54 -11
package/esm2022/src/render3/component_ref.mjs +1 -1
package/esm2022/src/render3/context_discovery.mjs +15 -1
package/esm2022/src/render3/instructions/control_flow.mjs +50 -3
package/esm2022/src/render3/list_reconciliation.mjs +41 -1
package/esm2022/src/util/callback_scheduler.mjs +13 -2
package/esm2022/src/version.mjs +1 -1
package/esm2022/src/zone/ng_zone.mjs +22 -6
package/esm2022/testing/src/async.mjs +2 -10
package/esm2022/testing/src/defer.mjs +1 -2
package/esm2022/testing/src/logger.mjs +3 -3
package/event-dispatch-contract.min.js +1 -1
package/fesm2022/core.mjs +516 -39
package/fesm2022/core.mjs.map +1 -1
package/fesm2022/primitives/event-dispatch.mjs +3044 -0
package/fesm2022/primitives/event-dispatch.mjs.map +1 -0
package/fesm2022/primitives/signals.mjs +17 -10
package/fesm2022/primitives/signals.mjs.map +1 -1
package/fesm2022/rxjs-interop.mjs +1 -1
package/fesm2022/testing.mjs +3 -12
package/fesm2022/testing.mjs.map +1 -1
package/index.d.ts +75 -13
package/package.json +7 -1
package/primitives/event-dispatch/index.d.ts +627 -0
package/primitives/signals/index.d.ts +1 -1
package/rxjs-interop/index.d.ts +1 -1
package/schematics/migrations/{transfer-state → http-providers}/bundle.js +254 -68
package/schematics/migrations/http-providers/bundle.js.map +7 -0
package/schematics/migrations/invalid-two-way-bindings/bundle.js +659 -337
package/schematics/migrations/invalid-two-way-bindings/bundle.js.map +2 -2
package/schematics/migrations.json +6 -16
package/schematics/ng-generate/control-flow-migration/bundle.js +667 -345
package/schematics/ng-generate/control-flow-migration/bundle.js.map +2 -2
package/schematics/ng-generate/standalone-migration/bundle.js +1030 -660
package/schematics/ng-generate/standalone-migration/bundle.js.map +2 -2
package/testing/index.d.ts +2 -9
package/schematics/migrations/block-template-entities/bundle.js +0 -22808
package/schematics/migrations/block-template-entities/bundle.js.map +0 -7
package/schematics/migrations/compiler-options/bundle.js +0 -582
package/schematics/migrations/compiler-options/bundle.js.map +0 -7
package/schematics/migrations/transfer-state/bundle.js.map +0 -7

package/esm2022/primitives/event-dispatch/src/eventcontract.mjs ADDED Viewed

@@ -0,0 +1,675 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @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.
+ */
+import * as a11yClickLib from './a11y_click';
+import { Attribute as AccessibilityAttribute } from './accessibility';
+import { Attribute } from './attribute';
+import * as cache from './cache';
+import { Char } from './char';
+import * as eventLib from './event';
+import { A11Y_CLICK_SUPPORT, A11Y_SUPPORT_IN_DISPATCHER, CUSTOM_EVENT_SUPPORT, JSNAMESPACE_SUPPORT, MOUSE_SPECIAL_SUPPORT, STOP_PROPAGATION, } from './event_contract_defines';
+import * as eventInfoLib from './event_info';
+import { EventType } from './event_type';
+import { Property } from './property';
+const DEFAULT_EVENT_TYPE = EventType.CLICK;
+/**
+ * Since maps from event to action are immutable we can use a single map
+ * to represent the empty map.
+ */
+const EMPTY_ACTION_MAP = {};
+/**
+ * This regular expression matches a semicolon.
+ */
+const REGEXP_SEMICOLON = /\s*;\s*/;
+/**
+ * EventContract intercepts events in the bubbling phase at the
+ * boundary of a container element, and maps them to generic actions
+ * which are specified using the custom jsaction attribute in
+ * HTML. Behavior of the application is then specified in terms of
+ * handler for such actions, cf. jsaction.Dispatcher in dispatcher.js.
+ *
+ * This has several benefits: (1) No DOM event handlers need to be
+ * registered on the specific elements in the UI. (2) The set of
+ * events that the application has to handle can be specified in terms
+ * of the semantics of the application, rather than in terms of DOM
+ * events. (3) Invocation of handlers can be delayed and handlers can
+ * be delay loaded in a generic way.
+ */
+export class EventContract {
+    static { this.CUSTOM_EVENT_SUPPORT = CUSTOM_EVENT_SUPPORT; }
+    static { this.STOP_PROPAGATION = STOP_PROPAGATION; }
+    static { this.A11Y_SUPPORT_IN_DISPATCHER = A11Y_SUPPORT_IN_DISPATCHER; }
+    static { this.A11Y_CLICK_SUPPORT = A11Y_CLICK_SUPPORT; }
+    static { this.MOUSE_SPECIAL_SUPPORT = MOUSE_SPECIAL_SUPPORT; }
+    static { this.JSNAMESPACE_SUPPORT = JSNAMESPACE_SUPPORT; }
+    constructor(containerManager) {
+        /**
+         * The DOM events which this contract covers. Used to prevent double
+         * registration of event types. The value of the map is the
+         * internally created DOM event handler function that handles the
+         * DOM events. See addEvent().
+         *
+         */
+        this.eventHandlers = {};
+        this.browserEventTypeToExtraEventTypes = {};
+        /**
+         * The dispatcher function. Events are passed to this function for
+         * handling once it was set using the registerDispatcher() method. This is
+         * done because the function is passed from another jsbinary, so passing the
+         * instance and invoking the method here would require to leave the method
+         * unobfuscated.
+         */
+        this.dispatcher = null;
+        /**
+         * The list of suspended `EventInfo` that will be dispatched
+         * as soon as the `Dispatcher` is registered.
+         */
+        this.queuedEventInfos = [];
+        /** Whether a11y click support has been loaded or not. */
+        this.hasA11yClickSupport = false;
+        /** Whether to add an a11y click listener. */
+        this.addA11yClickListener = EventContract.A11Y_SUPPORT_IN_DISPATCHER;
+        this.updateEventInfoForA11yClick = undefined;
+        this.preventDefaultForA11yClick = undefined;
+        this.populateClickOnlyAction = undefined;
+        this.containerManager = containerManager;
+        if (EventContract.CUSTOM_EVENT_SUPPORT) {
+            this.addEvent(EventType.CUSTOM);
+        }
+        if (EventContract.A11Y_CLICK_SUPPORT) {
+            // Add a11y click support to the `EventContract`.
+            this.addA11yClickSupport();
+        }
+    }
+    handleEvent(eventType, event, container) {
+        const eventInfo = eventInfoLib.createEventInfoFromParameters(
+        /* eventType= */ eventType,
+        /* event= */ event,
+        /* targetElement= */ event.target,
+        /* container= */ container,
+        /* timestamp= */ Date.now());
+        this.handleEventInfo(eventInfo);
+    }
+    /**
+     * Handle an `EventInfo`.
+     * @param allowRehandling Used in the case of a11y click casting to prevent
+     * us from trying to rehandle in an infinite loop.
+     */
+    handleEventInfo(eventInfo, allowRehandling = true) {
+        if (!this.dispatcher) {
+            // All events are queued when the dispatcher isn't yet loaded.
+            eventInfoLib.setIsReplay(eventInfo, true);
+            this.queuedEventInfos?.push(eventInfo);
+        }
+        if (EventContract.CUSTOM_EVENT_SUPPORT &&
+            eventInfoLib.getEventType(eventInfo) === EventType.CUSTOM) {
+            const detail = eventInfoLib.getEvent(eventInfo).detail;
+            // For custom events, use a secondary dispatch based on the internal
+            // custom type of the event.
+            if (!detail || !detail['_type']) {
+                // This should never happen.
+                return;
+            }
+            eventInfoLib.setEventType(eventInfo, detail['_type']);
+        }
+        this.populateAction(eventInfo);
+        if (this.dispatcher &&
+            !eventInfoLib.getEvent(eventInfo)[AccessibilityAttribute.SKIP_GLOBAL_DISPATCH]) {
+            const globalEventInfo = eventInfoLib.cloneEventInfo(eventInfo);
+            // In some cases, `populateAction` will rewrite `click` events to
+            // `clickonly`. Revert back to a regular click, otherwise we won't be able
+            // to execute global event handlers registered on click events.
+            if (eventInfoLib.getEventType(globalEventInfo) === EventType.CLICKONLY) {
+                eventInfoLib.setEventType(globalEventInfo, EventType.CLICK);
+            }
+            this.dispatcher(globalEventInfo, /* dispatch global event */ true);
+        }
+        const action = eventInfoLib.getAction(eventInfo);
+        if (!action && !checkDispatcherForA11yClick(eventInfo)) {
+            return;
+        }
+        if (this.dispatcher) {
+            if (action &&
+                shouldPreventDefaultBeforeDispatching(eventInfoLib.getActionElement(action), eventInfo)) {
+                eventLib.preventDefault(eventInfoLib.getEvent(eventInfo));
+            }
+            const unresolvedEventInfo = this.dispatcher(eventInfo);
+            if (unresolvedEventInfo && allowRehandling) {
+                // The dispatcher only returns an event for MAYBE_CLICK_EVENT_TYPE
+                // events that can't be casted to a click. We run it through the
+                // handler again to find keydown actions for it.
+                this.handleEventInfo(unresolvedEventInfo, /* allowRehandling= */ false);
+                return;
+            }
+        }
+    }
+    /**
+     * 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) {
+        // 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
+        // click. A DOM 'click' event is mapped to the jsaction 'click'
+        // event iff there is no modifier present on the event. If there is
+        // a modifier, it's mapped to 'clickmod' instead.
+        //
+        // It's allowed to omit the event in the jsaction attribute. In that
+        // case, 'click' is assumed. Thus the following two are equivalent:
+        //
+        //   <a href="someurl" jsaction="gna.fu">
+        //   <a href="someurl" jsaction="click:gna.fu">
+        //
+        // For unmodified clicks, EventContract invokes the jsaction
+        // 'gna.fu'. For modified clicks, EventContract won't find a
+        // suitable action and leave the event to be handled by the
+        // browser.
+        //
+        // In order to also invoke a jsaction handler for a modifier click,
+        // 'clickmod' needs to be used:
+        //
+        //   <a href="someurl" jsaction="clickmod:gna.fu">
+        //
+        // EventContract invokes the jsaction 'gna.fu' for modified
+        // clicks. Unmodified clicks are left to the browser.
+        //
+        // In order to set up the event contract to handle both clickonly and
+        // clickmod, only addEvent(EventType.CLICK) is necessary.
+        //
+        // In order to set up the event contract to handle click,
+        // addEvent() is necessary for CLICK, KEYDOWN, and KEYPRESS event types.  If
+        // a11y click support is enabled, addEvent() will set up the appropriate key
+        // event handler automatically.
+        if (eventInfoLib.getEventType(eventInfo) === EventType.CLICK &&
+            eventLib.isModifiedClickEvent(eventInfoLib.getEvent(eventInfo))) {
+            eventInfoLib.setEventType(eventInfo, EventType.CLICKMOD);
+        }
+        else if (this.hasA11yClickSupport) {
+            this.updateEventInfoForA11yClick(eventInfo);
+        }
+        else if (EventContract.A11Y_SUPPORT_IN_DISPATCHER &&
+            eventInfoLib.getEventType(eventInfo) === EventType.KEYDOWN &&
+            !eventInfoLib.getEvent(eventInfo)[AccessibilityAttribute.SKIP_A11Y_CHECK]) {
+            // We use a string literal as this value needs to be referenced in the
+            // dispatcher's binary.
+            eventInfoLib.setEventType(eventInfo, AccessibilityAttribute.MAYBE_CLICK_EVENT_TYPE);
+        }
+        // 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 = eventInfoLib.getTargetElement(eventInfo);
+        while (actionElement && actionElement !== eventInfoLib.getContainer(eventInfo)) {
+            this.populateActionOnElement(actionElement, eventInfo);
+            if (eventInfoLib.getAction(eventInfo)) {
+                // An event is handled by at most one jsaction. Thus we stop at the
+                // first matching jsaction specified in a jsaction attribute up the
+                // ancestor chain of the event target node.
+                break;
+            }
+            if (actionElement[Property.OWNER]) {
+                actionElement = actionElement[Property.OWNER];
+                continue;
+            }
+            if (actionElement.parentNode?.nodeName !== '#document-fragment') {
+                actionElement = actionElement.parentNode;
+            }
+            else {
+                actionElement = actionElement.parentNode?.host ?? null;
+            }
+        }
+        const action = eventInfoLib.getAction(eventInfo);
+        if (!action) {
+            // No action found.
+            return;
+        }
+        if (this.hasA11yClickSupport) {
+            this.preventDefaultForA11yClick(eventInfo);
+        }
+        // We attempt to handle the mouseenter/mouseleave events here by
+        // detecting whether the mouseover/mouseout events correspond to
+        // entering/leaving an element.
+        if (EventContract.MOUSE_SPECIAL_SUPPORT &&
+            (eventInfoLib.getEventType(eventInfo) === EventType.MOUSEENTER ||
+                eventInfoLib.getEventType(eventInfo) === EventType.MOUSELEAVE ||
+                eventInfoLib.getEventType(eventInfo) === EventType.POINTERENTER ||
+                eventInfoLib.getEventType(eventInfo) === EventType.POINTERLEAVE)) {
+            // We attempt to handle the mouseenter/mouseleave events here by
+            // detecting whether the mouseover/mouseout events correspond to
+            // entering/leaving an element.
+            if (eventLib.isMouseSpecialEvent(eventInfoLib.getEvent(eventInfo), eventInfoLib.getEventType(eventInfo), eventInfoLib.getActionElement(action))) {
+                // If both mouseover/mouseout and mouseenter/mouseleave events are
+                // enabled, two separate handlers for mouseover/mouseout are
+                // registered. Both handlers will see the same event instance
+                // so we create a copy to avoid interfering with the dispatching of
+                // the mouseover/mouseout event.
+                const copiedEvent = eventLib.createMouseSpecialEvent(eventInfoLib.getEvent(eventInfo), eventInfoLib.getActionElement(action));
+                eventInfoLib.setEvent(eventInfo, copiedEvent);
+                // Since the mouseenter/mouseleave events do not bubble, the target
+                // of the event is technically the `actionElement` (the node with the
+                // `jsaction` attribute)
+                eventInfoLib.setTargetElement(eventInfo, eventInfoLib.getActionElement(action));
+            }
+            else {
+                eventInfoLib.unsetAction(eventInfo);
+            }
+        }
+    }
+    /**
+     * 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
+     * attribute value and stores it in a property on the node for
+     * subsequent retrieval without re-parsing and re-accessing the
+     * attribute. In order to fully qualify jsaction names using a
+     * namespace, the DOM is searched starting at the current node and
+     * going through ancestor nodes until a jsnamespace attribute is
+     * found.
+     *
+     * @param actionElement The DOM node to retrieve the jsaction map from.
+     * @param eventInfo `EventInfo` to set `action` and `actionElement` if an
+     *    action is found on the `actionElement`.
+     */
+    populateActionOnElement(actionElement, eventInfo) {
+        const actionMap = parseActions(actionElement, eventInfoLib.getContainer(eventInfo));
+        const actionName = actionMap[eventInfoLib.getEventType(eventInfo)];
+        if (actionName !== undefined) {
+            eventInfoLib.setAction(eventInfo, actionName, actionElement);
+        }
+        if (this.hasA11yClickSupport) {
+            this.populateClickOnlyAction(actionElement, eventInfo, actionMap);
+        }
+        if (EventContract.A11Y_SUPPORT_IN_DISPATCHER) {
+            if (eventInfoLib.getEventType(eventInfo) === AccessibilityAttribute.MAYBE_CLICK_EVENT_TYPE &&
+                actionMap[EventType.CLICK] !== undefined) {
+                // We'll take the first CLICK action we find and have the dispatcher
+                // check if the keydown event can be used as a CLICK. If not, the
+                // dispatcher will retrigger the event so that we can find a keydown
+                // event instead.
+                // When we get MAYBE_CLICK_EVENT_TYPE as an eventType, we want to
+                // retrieve the action corresponding to CLICK, but still keep the
+                // eventInfoLib.getEventType(eventInfo, ) as MAYBE_CLICK_EVENT_TYPE. The
+                // dispatcher uses this event type to determine if it should get the
+                // handler for the action.
+                eventInfoLib.setAction(eventInfo, actionMap[EventType.CLICK], actionElement);
+            }
+            else {
+                a11yClickLib.populateClickOnlyAction(actionElement, eventInfo, actionMap);
+            }
+        }
+    }
+    /**
+     * Enables jsaction handlers to be called for the event type given by
+     * name.
+     *
+     * If the event is already registered, this does nothing.
+     *
+     * @param prefixedEventType If supplied, this event is used in
+     *     the actual browser event registration instead of the name that is
+     *     exposed to jsaction. Use this if you e.g. want users to be able
+     *     to subscribe to jsaction="transitionEnd:foo" while the underlying
+     *     event is webkitTransitionEnd in one browser and mozTransitionEnd
+     *     in another.
+     */
+    addEvent(eventType, prefixedEventType) {
+        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)) {
+            return;
+        }
+        const eventHandler = (eventType, event, container) => {
+            this.handleEvent(eventType, event, container);
+        };
+        // Store the callback to allow us to replay events.
+        this.eventHandlers[eventType] = eventHandler;
+        const browserEventType = eventLib.getBrowserEventType(prefixedEventType || eventType);
+        if (browserEventType !== eventType) {
+            const eventTypes = this.browserEventTypeToExtraEventTypes[browserEventType] || [];
+            eventTypes.push(eventType);
+            this.browserEventTypeToExtraEventTypes[browserEventType] = eventTypes;
+        }
+        this.containerManager.addEventListener(browserEventType, (element) => {
+            return (event) => {
+                eventHandler(eventType, event, element);
+            };
+        });
+        // Automatically install a keypress/keydown event handler if support for
+        // accessible clicks is turned on.
+        if (this.addA11yClickListener && eventType === EventType.CLICK) {
+            this.addEvent(EventType.KEYDOWN);
+        }
+    }
+    /**
+     * Gets the queued early events and replay them using the appropriate handler
+     * in the provided event contract. Once all the events are replayed, it cleans
+     * up the early contract.
+     */
+    replayEarlyEvents() {
+        // Check if the early contract is present and prevent calling this function
+        // more than once.
+        const earlyJsactionData = window._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];
+            const eventTypes = this.getEventTypesForBrowserEventType(earlyEventInfo.eventType);
+            for (let i = 0; i < eventTypes.length; i++) {
+                const eventInfo = eventInfoLib.cloneEventInfo(earlyEventInfo);
+                // EventInfo eventType maps to JSAction's internal event type,
+                // rather than the browser event type.
+                eventInfoLib.setEventType(eventInfo, eventTypes[i]);
+                this.handleEventInfo(eventInfo);
+            }
+        }
+        // Clean up the early contract.
+        const earlyEventTypes = earlyJsactionData.et;
+        const earlyEventHandler = earlyJsactionData.h;
+        for (let idx = 0; idx < earlyEventTypes.length; idx++) {
+            const eventType = earlyEventTypes[idx];
+            window.document.documentElement.removeEventListener(eventType, earlyEventHandler);
+        }
+        delete window._ejsa;
+    }
+    /**
+     * Returns all JSAction event types that have been registered for a given
+     * browser event type.
+     */
+    getEventTypesForBrowserEventType(browserEventType) {
+        const eventTypes = [];
+        if (this.eventHandlers[browserEventType]) {
+            eventTypes.push(browserEventType);
+        }
+        if (this.browserEventTypeToExtraEventTypes[browserEventType]) {
+            eventTypes.push(...this.browserEventTypeToExtraEventTypes[browserEventType]);
+        }
+        return eventTypes;
+    }
+    /**
+     * Returns the event handler function for a given event type.
+     */
+    handler(eventType) {
+        return this.eventHandlers[eventType];
+    }
+    /**
+     * Cleans up the event contract. This resets all of the `EventContract`'s
+     * internal state. Users are responsible for not using this `EventContract`
+     * after it has been cleaned up.
+     */
+    cleanUp() {
+        this.containerManager.cleanUp();
+        this.containerManager = null;
+        this.eventHandlers = {};
+        this.browserEventTypeToExtraEventTypes = {};
+        this.dispatcher = null;
+        this.queuedEventInfos = [];
+    }
+    /**
+     * Register a dispatcher function. Event info of each event mapped to
+     * a jsaction is passed for handling to this callback. The queued
+     * events are passed as well to the dispatcher for later replaying
+     * once the dispatcher is registered. Clears the event queue to null.
+     *
+     * @param dispatcher The dispatcher function.
+     * @param restriction
+     */
+    registerDispatcher(dispatcher, restriction) {
+        this.ecrd(dispatcher, restriction);
+    }
+    /**
+     * Unrenamed alias for registerDispatcher. Necessary for any codebases that
+     * split the `EventContract` and `Dispatcher` code into different compilation
+     * units.
+     */
+    ecrd(dispatcher, restriction) {
+        this.dispatcher = dispatcher;
+        if (this.queuedEventInfos?.length) {
+            for (let i = 0; i < this.queuedEventInfos.length; i++) {
+                this.handleEventInfo(this.queuedEventInfos[i]);
+            }
+            this.queuedEventInfos = null;
+        }
+    }
+    /**
+     * Adds a11y click support to the given `EventContract`. Meant to be called in
+     * the same compilation unit as the `EventContract`.
+     */
+    addA11yClickSupport() {
+        this.addA11yClickSupportImpl(a11yClickLib.updateEventInfoForA11yClick, a11yClickLib.preventDefaultForA11yClick, a11yClickLib.populateClickOnlyAction);
+    }
+    /**
+     * Enables a11y click support to be deferred. Meant to be called in the same
+     * compilation unit as the `EventContract`.
+     */
+    exportAddA11yClickSupport() {
+        this.addA11yClickListener = true;
+        this.ecaacs = this.addA11yClickSupportImpl.bind(this);
+    }
+    /**
+     * Unrenamed function that loads a11yClickSupport.
+     */
+    addA11yClickSupportImpl(updateEventInfoForA11yClick, preventDefaultForA11yClick, populateClickOnlyAction) {
+        this.addA11yClickListener = true;
+        this.hasA11yClickSupport = true;
+        this.updateEventInfoForA11yClick = updateEventInfoForA11yClick;
+        this.preventDefaultForA11yClick = preventDefaultForA11yClick;
+        this.populateClickOnlyAction = populateClickOnlyAction;
+    }
+}
+/**
+ * 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.
+ */
+export function addDeferredA11yClickSupport(eventContract) {
+    eventContract.ecaacs?.(a11yClickLib.updateEventInfoForA11yClick, a11yClickLib.preventDefaultForA11yClick, a11yClickLib.populateClickOnlyAction);
+}
+/**
+ * Determines whether or not the `EventContract` needs to check with the
+ * dispatcher even if there's no action.
+ */
+function checkDispatcherForA11yClick(eventInfo) {
+    return (EventContract.A11Y_SUPPORT_IN_DISPATCHER &&
+        eventInfoLib.getEventType(eventInfo) === AccessibilityAttribute.MAYBE_CLICK_EVENT_TYPE);
+}
+/**
+ * Returns true if the default action of this event should be prevented before
+ * this event is dispatched.
+ */
+function shouldPreventDefaultBeforeDispatching(actionElement, eventInfo) {
+    // 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' &&
+        (eventInfoLib.getEventType(eventInfo) === EventType.CLICK ||
+            eventInfoLib.getEventType(eventInfo) === EventType.CLICKMOD));
+}
+/**
+ * Parses and caches an element's jsaction element into a map.
+ *
+ * This is primarily for internal use.
+ *
+ * @param actionElement The DOM node to retrieve the jsaction map from.
+ * @param container The node which limits the namespace lookup for a jsaction
+ * name. The container node itself will not be searched.
+ * @return Map from event to qualified name of the jsaction bound to it.
+ */
+export function parseActions(actionElement, container) {
+    let actionMap = cache.get(actionElement);
+    if (!actionMap) {
+        const jsactionAttribute = getAttr(actionElement, Attribute.JSACTION);
+        if (!jsactionAttribute) {
+            actionMap = EMPTY_ACTION_MAP;
+            cache.set(actionElement, actionMap);
+        }
+        else {
+            actionMap = cache.getParsed(jsactionAttribute);
+            if (!actionMap) {
+                actionMap = {};
+                const values = jsactionAttribute.split(REGEXP_SEMICOLON);
+                for (let idx = 0; idx < values.length; idx++) {
+                    const value = values[idx];
+                    if (!value) {
+                        continue;
+                    }
+                    const colon = value.indexOf(Char.EVENT_ACTION_SEPARATOR);
+                    const hasColon = colon !== -1;
+                    const type = hasColon ? stringTrim(value.substr(0, colon)) : DEFAULT_EVENT_TYPE;
+                    const action = hasColon ? stringTrim(value.substr(colon + 1)) : value;
+                    actionMap[type] = action;
+                }
+                cache.setParsed(jsactionAttribute, actionMap);
+            }
+            // If namespace support is active we need to augment the (potentially
+            // cached) jsaction mapping with the namespace.
+            if (EventContract.JSNAMESPACE_SUPPORT) {
+                const noNs = actionMap;
+                actionMap = {};
+                for (const type in noNs) {
+                    actionMap[type] = getFullyQualifiedAction(noNs[type], actionElement, container);
+                }
+            }
+            cache.set(actionElement, actionMap);
+        }
+    }
+    return actionMap;
+}
+/**
+ * Returns the fully qualified jsaction action. If the given jsaction
+ * name doesn't already contain the namespace, the function iterates
+ * over ancestor nodes until a jsnamespace attribute is found, and
+ * uses the value of that attribute as the namespace.
+ *
+ * @param action The jsaction action to resolve.
+ * @param start The node from which to start searching for a jsnamespace
+ * attribute.
+ * @param container The node which limits the search for a jsnamespace
+ * attribute. This node will be searched.
+ * @return The fully qualified name of the jsaction. If no namespace is found,
+ * returns the unqualified name in case it exists in the global namespace.
+ */
+function getFullyQualifiedAction(action, start, container) {
+    if (EventContract.JSNAMESPACE_SUPPORT) {
+        if (isNamespacedAction(action)) {
+            return action;
+        }
+        let node = start;
+        while (node) {
+            const namespace = getNamespaceFromElement(node);
+            if (namespace) {
+                return namespace + Char.NAMESPACE_ACTION_SEPARATOR + action;
+            }
+            // If this node is the container, stop.
+            if (node === container) {
+                break;
+            }
+            node = node.parentNode;
+        }
+    }
+    return action;
+}
+/**
+ * Checks if a jsaction action contains a namespace part.
+ */
+function isNamespacedAction(action) {
+    return action.indexOf(Char.NAMESPACE_ACTION_SEPARATOR) >= 0;
+}
+/**
+ * Returns the value of the jsnamespace attribute of the given node.
+ * Also caches the value for subsequent lookups.
+ * @param element The node whose jsnamespace attribute is being asked for.
+ * @return The value of the jsnamespace attribute, or null if not found.
+ */
+function getNamespaceFromElement(element) {
+    let namespace = cache.getNamespace(element);
+    // Only query for the attribute if it has not been queried for
+    // before. getAttr() returns null if an attribute is not present. Thus,
+    // namespace is string|null if the query took place in the past, or
+    // undefined if the query did not take place.
+    if (namespace === undefined) {
+        namespace = getAttr(element, Attribute.JSNAMESPACE);
+        cache.setNamespace(element, namespace);
+    }
+    return namespace;
+}
+/**
+ * Accesses the event handler attribute value of a DOM node. It guards
+ * against weird situations (described in the body) that occur in
+ * connection with nodes that are removed from their document.
+ * @param element The DOM element.
+ * @param attribute The name of the attribute to access.
+ * @return The attribute value if it was found, null otherwise.
+ */
+function getAttr(element, attribute) {
+    let value = null;
+    // NOTE: Nodes in IE do not always have a getAttribute
+    // method defined. This is the case where sourceElement has in
+    // fact been removed from the DOM before eventContract begins
+    // handling - where a parentNode does not have getAttribute
+    // defined.
+    // NOTE: We must use the 'in' operator instead of the regular dot
+    // notation, since the latter fails in IE8 if the getAttribute method is not
+    // defined. See b/7139109.
+    if ('getAttribute' in element) {
+        value = element.getAttribute(attribute);
+    }
+    return value;
+}
+/**
+ * Helper function to trim whitespace from the beginning and the end
+ * of the string. This deliberately doesn't use the closure equivalent
+ * to keep dependencies small.
+ * @param str  Input string.
+ * @return  Trimmed string.
+ */
+function stringTrim(str) {
+    if (typeof String.prototype.trim === 'function') {
+        return str.trim();
+    }
+    const trimmedLeft = str.replace(/^\s+/, '');
+    return trimmedLeft.replace(/\s+$/, '');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eventcontract.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/eventcontract.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @fileoverview Implements the local event handling contract. This\n * allows DOM objects in a container that enters into this contract to\n * define event handlers which are executed in a local context.\n *\n * One EventContract instance can manage the contract for multiple\n * containers, which are added using the addContainer() method.\n *\n * Events can be registered using the addEvent() method.\n *\n * A Dispatcher is added using the registerDispatcher() method. Until there is\n * a dispatcher, events are queued. The idea is that the EventContract\n * class is inlined in the HTML of the top level page and instantiated\n * right after the start of <body>. The Dispatcher class is contained\n * in the external deferred js, and instantiated and registered with\n * EventContract when the external javascript in the page loads. The\n * external javascript will also register the jsaction handlers, which\n * then pick up the queued events at the time of registration.\n *\n * Since this class is meant to be inlined in the main page HTML, the\n * size of the binary compiled from this file MUST be kept as small as\n * possible and thus its dependencies to a minimum.\n */\n\nimport * as a11yClickLib from './a11y_click';\nimport {Attribute as AccessibilityAttribute} from './accessibility';\nimport {Attribute} from './attribute';\nimport * as cache from './cache';\nimport {Char} from './char';\nimport {EarlyJsactionData} from './earlyeventcontract';\nimport * as eventLib from './event';\nimport {EventContractContainerManager} from './event_contract_container';\nimport {\n  A11Y_CLICK_SUPPORT,\n  A11Y_SUPPORT_IN_DISPATCHER,\n  CUSTOM_EVENT_SUPPORT,\n  JSNAMESPACE_SUPPORT,\n  MOUSE_SPECIAL_SUPPORT,\n  STOP_PROPAGATION,\n} from './event_contract_defines';\nimport * as eventInfoLib from './event_info';\nimport {EventType} from './event_type';\nimport {Property} from './property';\nimport {Restriction} from './restriction';\n\n/**\n * The API of an EventContract that is safe to call from any compilation unit.\n */\nexport declare interface UnrenamedEventContract {\n  // Alias for Jsction EventContract registerDispatcher.\n  ecrd(dispatcher: Dispatcher, restriction: Restriction): void;\n  // Unrenamed function. Abbreviation for `eventContract.addA11yClickSupport`.\n  ecaacs?: (\n    updateEventInfoForA11yClick: typeof a11yClickLib.updateEventInfoForA11yClick,\n    preventDefaultForA11yClick: typeof a11yClickLib.preventDefaultForA11yClick,\n    populateClickOnlyAction: typeof a11yClickLib.populateClickOnlyAction,\n  ) => void;\n}\n\n/** A function that is called to handle events captured by the EventContract. */\nexport type Dispatcher = (\n  eventInfo: eventInfoLib.EventInfo,\n  globalDispatch?: boolean,\n) => eventInfoLib.EventInfo | void;\n\n/**\n * A function that handles an event dispatched from the browser.\n *\n * eventType: May differ from `event.type` if JSAction uses a\n * short-hand name or is patching over an non-bubbling event with a bubbling\n * variant.\n * event: The native browser event.\n * container: The container for this dispatch.\n */\ntype EventHandler = (eventType: string, event: Event, container: Element) => void;\n\nconst DEFAULT_EVENT_TYPE: string = EventType.CLICK;\n\n/**\n * Since maps from event to action are immutable we can use a single map\n * to represent the empty map.\n */\nconst EMPTY_ACTION_MAP: {[key: string]: string} = {};\n\n/**\n * This regular expression matches a semicolon.\n */\nconst REGEXP_SEMICOLON = /\\s*;\\s*/;\n\n/**\n * EventContract intercepts events in the bubbling phase at the\n * boundary of a container element, and maps them to generic actions\n * which are specified using the custom jsaction attribute in\n * HTML. Behavior of the application is then specified in terms of\n * handler for such actions, cf. jsaction.Dispatcher in dispatcher.js.\n *\n * This has several benefits: (1) No DOM event handlers need to be\n * registered on the specific elements in the UI. (2) The set of\n * events that the application has to handle can be specified in terms\n * of the semantics of the application, rather than in terms of DOM\n * events. (3) Invocation of handlers can be delayed and handlers can\n * be delay loaded in a generic way.\n */\nexport class EventContract implements UnrenamedEventContract {\n  static CUSTOM_EVENT_SUPPORT = CUSTOM_EVENT_SUPPORT;\n  static STOP_PROPAGATION = STOP_PROPAGATION;\n  static A11Y_SUPPORT_IN_DISPATCHER = A11Y_SUPPORT_IN_DISPATCHER;\n  static A11Y_CLICK_SUPPORT = A11Y_CLICK_SUPPORT;\n  static MOUSE_SPECIAL_SUPPORT = MOUSE_SPECIAL_SUPPORT;\n  static JSNAMESPACE_SUPPORT = JSNAMESPACE_SUPPORT;\n\n  private containerManager: EventContractContainerManager | null;\n\n  /**\n   * The DOM events which this contract covers. Used to prevent double\n   * registration of event types. The value of the map is the\n   * internally created DOM event handler function that handles the\n   * DOM events. See addEvent().\n   *\n   */\n  private eventHandlers: {[key: string]: EventHandler} = {};\n\n  private browserEventTypeToExtraEventTypes: {[key: string]: string[]} = {};\n\n  /**\n   * The dispatcher function. Events are passed to this function for\n   * handling once it was set using the registerDispatcher() method. This is\n   * done because the function is passed from another jsbinary, so passing the\n   * instance and invoking the method here would require to leave the method\n   * unobfuscated.\n   */\n  private dispatcher: Dispatcher | null = null;\n\n  /**\n   * The list of suspended `EventInfo` that will be dispatched\n   * as soon as the `Dispatcher` is registered.\n   */\n  private queuedEventInfos: eventInfoLib.EventInfo[] | null = [];\n\n  /** Whether a11y click support has been loaded or not. */\n  private hasA11yClickSupport = false;\n  /** Whether to add an a11y click listener. */\n  private addA11yClickListener = EventContract.A11Y_SUPPORT_IN_DISPATCHER;\n\n  private updateEventInfoForA11yClick?: (eventInfo: eventInfoLib.EventInfo) => void = undefined;\n\n  private preventDefaultForA11yClick?: (eventInfo: eventInfoLib.EventInfo) => void = undefined;\n\n  private populateClickOnlyAction?: (\n    actionElement: Element,\n    eventInfo: eventInfoLib.EventInfo,\n    actionMap: {[key: string]: string},\n  ) => void = undefined;\n\n  ecaacs?: (\n    updateEventInfoForA11yClick: typeof a11yClickLib.updateEventInfoForA11yClick,\n    preventDefaultForA11yClick: typeof a11yClickLib.preventDefaultForA11yClick,\n    populateClickOnlyAction: typeof a11yClickLib.populateClickOnlyAction,\n  ) => void;\n\n  constructor(containerManager: EventContractContainerManager) {\n    this.containerManager = containerManager;\n    if (EventContract.CUSTOM_EVENT_SUPPORT) {\n      this.addEvent(EventType.CUSTOM);\n    }\n    if (EventContract.A11Y_CLICK_SUPPORT) {\n      // Add a11y click support to the `EventContract`.\n      this.addA11yClickSupport();\n    }\n  }\n\n  private handleEvent(eventType: string, event: Event, container: Element) {\n    const eventInfo = eventInfoLib.createEventInfoFromParameters(\n      /* eventType= */ eventType,\n      /* event= */ event,\n      /* targetElement= */ event.target as Element,\n      /* container= */ container,\n      /* timestamp= */ Date.now(),\n    );\n    this.handleEventInfo(eventInfo);\n  }\n\n  /**\n   * Handle an `EventInfo`.\n   * @param allowRehandling Used in the case of a11y click casting to prevent\n   * us from trying to rehandle in an infinite loop.\n   */\n  private handleEventInfo(eventInfo: eventInfoLib.EventInfo, allowRehandling = true) {\n    if (!this.dispatcher) {\n      // All events are queued when the dispatcher isn't yet loaded.\n      eventInfoLib.setIsReplay(eventInfo, true);\n      this.queuedEventInfos?.push(eventInfo);\n    }\n    if (\n      EventContract.CUSTOM_EVENT_SUPPORT &&\n      eventInfoLib.getEventType(eventInfo) === EventType.CUSTOM\n    ) {\n      const detail = (eventInfoLib.getEvent(eventInfo) as CustomEvent).detail;\n      // For custom events, use a secondary dispatch based on the internal\n      // custom type of the event.\n      if (!detail || !detail['_type']) {\n        // This should never happen.\n        return;\n      }\n      eventInfoLib.setEventType(eventInfo, detail['_type']);\n    }\n\n    this.populateAction(eventInfo);\n\n    if (\n      this.dispatcher &&\n      !eventInfoLib.getEvent(eventInfo)[AccessibilityAttribute.SKIP_GLOBAL_DISPATCH]\n    ) {\n      const globalEventInfo: eventInfoLib.EventInfo = eventInfoLib.cloneEventInfo(eventInfo);\n\n      // In some cases, `populateAction` will rewrite `click` events to\n      // `clickonly`. Revert back to a regular click, otherwise we won't be able\n      // to execute global event handlers registered on click events.\n      if (eventInfoLib.getEventType(globalEventInfo) === EventType.CLICKONLY) {\n        eventInfoLib.setEventType(globalEventInfo, EventType.CLICK);\n      }\n\n      this.dispatcher(globalEventInfo, /* dispatch global event */ true);\n    }\n\n    const action = eventInfoLib.getAction(eventInfo);\n    if (!action && !checkDispatcherForA11yClick(eventInfo)) {\n      return;\n    }\n\n    if (this.dispatcher) {\n      if (\n        action &&\n        shouldPreventDefaultBeforeDispatching(eventInfoLib.getActionElement(action), eventInfo)\n      ) {\n        eventLib.preventDefault(eventInfoLib.getEvent(eventInfo));\n      }\n\n      const unresolvedEventInfo = this.dispatcher(eventInfo);\n      if (unresolvedEventInfo && allowRehandling) {\n        // The dispatcher only returns an event for MAYBE_CLICK_EVENT_TYPE\n        // events that can't be casted to a click. We run it through the\n        // handler again to find keydown actions for it.\n        this.handleEventInfo(unresolvedEventInfo, /* allowRehandling= */ false);\n        return;\n      }\n    }\n  }\n\n  /**\n   * Searches for a jsaction that the DOM event maps to and creates an\n   * object containing event information used for dispatching by\n   * jsaction.Dispatcher. This method populates the `action` and `actionElement`\n   * fields of the EventInfo object passed in by finding the first\n   * jsaction attribute above the target Node of the event, and below\n   * the container Node, that specifies a jsaction for the event\n   * type. If no such jsaction is found, then action is undefined.\n   *\n   * @param eventInfo `EventInfo` to set `action` and `actionElement` if an\n   *    action is found on any `Element` in the path of the `Event`.\n   */\n  private populateAction(eventInfo: eventInfoLib.EventInfo) {\n    // We distinguish modified and plain clicks in order to support the\n    // default browser behavior of modified clicks on links; usually to\n    // open the URL of the link in new tab or new window on ctrl/cmd\n    // click. A DOM 'click' event is mapped to the jsaction 'click'\n    // event iff there is no modifier present on the event. If there is\n    // a modifier, it's mapped to 'clickmod' instead.\n    //\n    // It's allowed to omit the event in the jsaction attribute. In that\n    // case, 'click' is assumed. Thus the following two are equivalent:\n    //\n    //   <a href=\"someurl\" jsaction=\"gna.fu\">\n    //   <a href=\"someurl\" jsaction=\"click:gna.fu\">\n    //\n    // For unmodified clicks, EventContract invokes the jsaction\n    // 'gna.fu'. For modified clicks, EventContract won't find a\n    // suitable action and leave the event to be handled by the\n    // browser.\n    //\n    // In order to also invoke a jsaction handler for a modifier click,\n    // 'clickmod' needs to be used:\n    //\n    //   <a href=\"someurl\" jsaction=\"clickmod:gna.fu\">\n    //\n    // EventContract invokes the jsaction 'gna.fu' for modified\n    // clicks. Unmodified clicks are left to the browser.\n    //\n    // In order to set up the event contract to handle both clickonly and\n    // clickmod, only addEvent(EventType.CLICK) is necessary.\n    //\n    // In order to set up the event contract to handle click,\n    // addEvent() is necessary for CLICK, KEYDOWN, and KEYPRESS event types.  If\n    // a11y click support is enabled, addEvent() will set up the appropriate key\n    // event handler automatically.\n    if (\n      eventInfoLib.getEventType(eventInfo) === EventType.CLICK &&\n      eventLib.isModifiedClickEvent(eventInfoLib.getEvent(eventInfo))\n    ) {\n      eventInfoLib.setEventType(eventInfo, EventType.CLICKMOD);\n    } else if (this.hasA11yClickSupport) {\n      this.updateEventInfoForA11yClick!(eventInfo);\n    } else if (\n      EventContract.A11Y_SUPPORT_IN_DISPATCHER &&\n      eventInfoLib.getEventType(eventInfo) === EventType.KEYDOWN &&\n      !eventInfoLib.getEvent(eventInfo)[AccessibilityAttribute.SKIP_A11Y_CHECK]\n    ) {\n      // We use a string literal as this value needs to be referenced in the\n      // dispatcher's binary.\n      eventInfoLib.setEventType(eventInfo, AccessibilityAttribute.MAYBE_CLICK_EVENT_TYPE);\n    }\n\n    // Walk to the parent node, unless the node has a different owner in\n    // which case we walk to the owner. Attempt to walk to host of a\n    // shadow root if needed.\n    let actionElement: Element | null = eventInfoLib.getTargetElement(eventInfo);\n    while (actionElement && actionElement !== eventInfoLib.getContainer(eventInfo)) {\n      this.populateActionOnElement(actionElement, eventInfo);\n\n      if (eventInfoLib.getAction(eventInfo)) {\n        // An event is handled by at most one jsaction. Thus we stop at the\n        // first matching jsaction specified in a jsaction attribute up the\n        // ancestor chain of the event target node.\n        break;\n      }\n      if (actionElement[Property.OWNER]) {\n        actionElement = actionElement[Property.OWNER] as Element;\n        continue;\n      }\n      if (actionElement.parentNode?.nodeName !== '#document-fragment') {\n        actionElement = actionElement.parentNode as Element | null;\n      } else {\n        actionElement = (actionElement.parentNode as ShadowRoot | null)?.host ?? null;\n      }\n    }\n\n    const action = eventInfoLib.getAction(eventInfo);\n    if (!action) {\n      // No action found.\n      return;\n    }\n\n    if (this.hasA11yClickSupport) {\n      this.preventDefaultForA11yClick!(eventInfo);\n    }\n\n    // We attempt to handle the mouseenter/mouseleave events here by\n    // detecting whether the mouseover/mouseout events correspond to\n    // entering/leaving an element.\n    if (\n      EventContract.MOUSE_SPECIAL_SUPPORT &&\n      (eventInfoLib.getEventType(eventInfo) === EventType.MOUSEENTER ||\n        eventInfoLib.getEventType(eventInfo) === EventType.MOUSELEAVE ||\n        eventInfoLib.getEventType(eventInfo) === EventType.POINTERENTER ||\n        eventInfoLib.getEventType(eventInfo) === EventType.POINTERLEAVE)\n    ) {\n      // We attempt to handle the mouseenter/mouseleave events here by\n      // detecting whether the mouseover/mouseout events correspond to\n      // entering/leaving an element.\n      if (\n        eventLib.isMouseSpecialEvent(\n          eventInfoLib.getEvent(eventInfo),\n          eventInfoLib.getEventType(eventInfo),\n          eventInfoLib.getActionElement(action),\n        )\n      ) {\n        // If both mouseover/mouseout and mouseenter/mouseleave events are\n        // enabled, two separate handlers for mouseover/mouseout are\n        // registered. Both handlers will see the same event instance\n        // so we create a copy to avoid interfering with the dispatching of\n        // the mouseover/mouseout event.\n        const copiedEvent = eventLib.createMouseSpecialEvent(\n          eventInfoLib.getEvent(eventInfo),\n          eventInfoLib.getActionElement(action),\n        );\n        eventInfoLib.setEvent(eventInfo, copiedEvent);\n        // Since the mouseenter/mouseleave events do not bubble, the target\n        // of the event is technically the `actionElement` (the node with the\n        // `jsaction` attribute)\n        eventInfoLib.setTargetElement(eventInfo, eventInfoLib.getActionElement(action));\n      } else {\n        eventInfoLib.unsetAction(eventInfo);\n      }\n    }\n  }\n\n  /**\n   * Accesses the jsaction map on a node and retrieves the name of the\n   * action the given event is mapped to, if any. It parses the\n   * attribute value and stores it in a property on the node for\n   * subsequent retrieval without re-parsing and re-accessing the\n   * attribute. In order to fully qualify jsaction names using a\n   * namespace, the DOM is searched starting at the current node and\n   * going through ancestor nodes until a jsnamespace attribute is\n   * found.\n   *\n   * @param actionElement The DOM node to retrieve the jsaction map from.\n   * @param eventInfo `EventInfo` to set `action` and `actionElement` if an\n   *    action is found on the `actionElement`.\n   */\n  private populateActionOnElement(actionElement: Element, eventInfo: eventInfoLib.EventInfo) {\n    const actionMap = parseActions(actionElement, eventInfoLib.getContainer(eventInfo));\n\n    const actionName = actionMap[eventInfoLib.getEventType(eventInfo)];\n    if (actionName !== undefined) {\n      eventInfoLib.setAction(eventInfo, actionName, actionElement);\n    }\n\n    if (this.hasA11yClickSupport) {\n      this.populateClickOnlyAction!(actionElement, eventInfo, actionMap);\n    }\n    if (EventContract.A11Y_SUPPORT_IN_DISPATCHER) {\n      if (\n        eventInfoLib.getEventType(eventInfo) === AccessibilityAttribute.MAYBE_CLICK_EVENT_TYPE &&\n        actionMap[EventType.CLICK] !== undefined\n      ) {\n        // We'll take the first CLICK action we find and have the dispatcher\n        // check if the keydown event can be used as a CLICK. If not, the\n        // dispatcher will retrigger the event so that we can find a keydown\n        // event instead.\n        // When we get MAYBE_CLICK_EVENT_TYPE as an eventType, we want to\n        // retrieve the action corresponding to CLICK, but still keep the\n        // eventInfoLib.getEventType(eventInfo, ) as MAYBE_CLICK_EVENT_TYPE. The\n        // dispatcher uses this event type to determine if it should get the\n        // handler for the action.\n        eventInfoLib.setAction(eventInfo, actionMap[EventType.CLICK], actionElement);\n      } else {\n        a11yClickLib.populateClickOnlyAction(actionElement, eventInfo, actionMap);\n      }\n    }\n  }\n\n  /**\n   * Enables jsaction handlers to be called for the event type given by\n   * name.\n   *\n   * If the event is already registered, this does nothing.\n   *\n   * @param prefixedEventType If supplied, this event is used in\n   *     the actual browser event registration instead of the name that is\n   *     exposed to jsaction. Use this if you e.g. want users to be able\n   *     to subscribe to jsaction=\"transitionEnd:foo\" while the underlying\n   *     event is webkitTransitionEnd in one browser and mozTransitionEnd\n   *     in another.\n   */\n  addEvent(eventType: string, prefixedEventType?: string) {\n    if (eventType in this.eventHandlers || !this.containerManager) {\n      return;\n    }\n\n    if (\n      !EventContract.MOUSE_SPECIAL_SUPPORT &&\n      (eventType === EventType.MOUSEENTER ||\n        eventType === EventType.MOUSELEAVE ||\n        eventType === EventType.POINTERENTER ||\n        eventType === EventType.POINTERLEAVE)\n    ) {\n      return;\n    }\n\n    const eventHandler = (eventType: string, event: Event, container: Element) => {\n      this.handleEvent(eventType, event, container);\n    };\n\n    // Store the callback to allow us to replay events.\n    this.eventHandlers[eventType] = eventHandler;\n\n    const browserEventType = eventLib.getBrowserEventType(prefixedEventType || eventType);\n\n    if (browserEventType !== eventType) {\n      const eventTypes = this.browserEventTypeToExtraEventTypes[browserEventType] || [];\n      eventTypes.push(eventType);\n      this.browserEventTypeToExtraEventTypes[browserEventType] = eventTypes;\n    }\n\n    this.containerManager.addEventListener(browserEventType, (element: Element) => {\n      return (event: Event) => {\n        eventHandler(eventType, event, element);\n      };\n    });\n\n    // Automatically install a keypress/keydown event handler if support for\n    // accessible clicks is turned on.\n    if (this.addA11yClickListener && eventType === EventType.CLICK) {\n      this.addEvent(EventType.KEYDOWN);\n    }\n  }\n\n  /**\n   * Gets the queued early events and replay them using the appropriate handler\n   * in the provided event contract. Once all the events are replayed, it cleans\n   * up the early contract.\n   */\n  replayEarlyEvents() {\n    // Check if the early contract is present and prevent calling this function\n    // more than once.\n    const earlyJsactionData: EarlyJsactionData | undefined = window._ejsa;\n    if (!earlyJsactionData) {\n      return;\n    }\n\n    // Replay the early contract events.\n    const earlyEventInfos: eventInfoLib.EventInfo[] = earlyJsactionData.q;\n    for (let idx = 0; idx < earlyEventInfos.length; idx++) {\n      const earlyEventInfo: eventInfoLib.EventInfo = earlyEventInfos[idx];\n      const eventTypes = this.getEventTypesForBrowserEventType(earlyEventInfo.eventType);\n      for (let i = 0; i < eventTypes.length; i++) {\n        const eventInfo = eventInfoLib.cloneEventInfo(earlyEventInfo);\n        // EventInfo eventType maps to JSAction's internal event type,\n        // rather than the browser event type.\n        eventInfoLib.setEventType(eventInfo, eventTypes[i]);\n        this.handleEventInfo(eventInfo);\n      }\n    }\n\n    // Clean up the early contract.\n    const earlyEventTypes: string[] = earlyJsactionData.et;\n    const earlyEventHandler: (event: Event) => void = earlyJsactionData.h;\n    for (let idx = 0; idx < earlyEventTypes.length; idx++) {\n      const eventType: string = earlyEventTypes[idx];\n      window.document.documentElement.removeEventListener(eventType, earlyEventHandler);\n    }\n    delete window._ejsa;\n  }\n\n  /**\n   * Returns all JSAction event types that have been registered for a given\n   * browser event type.\n   */\n  private getEventTypesForBrowserEventType(browserEventType: string) {\n    const eventTypes = [];\n    if (this.eventHandlers[browserEventType]) {\n      eventTypes.push(browserEventType);\n    }\n    if (this.browserEventTypeToExtraEventTypes[browserEventType]) {\n      eventTypes.push(...this.browserEventTypeToExtraEventTypes[browserEventType]);\n    }\n    return eventTypes;\n  }\n\n  /**\n   * Returns the event handler function for a given event type.\n   */\n  handler(eventType: string): EventHandler | undefined {\n    return this.eventHandlers[eventType];\n  }\n\n  /**\n   * Cleans up the event contract. This resets all of the `EventContract`'s\n   * internal state. Users are responsible for not using this `EventContract`\n   * after it has been cleaned up.\n   */\n  cleanUp() {\n    this.containerManager!.cleanUp();\n    this.containerManager = null;\n    this.eventHandlers = {};\n    this.browserEventTypeToExtraEventTypes = {};\n    this.dispatcher = null;\n    this.queuedEventInfos = [];\n  }\n\n  /**\n   * Register a dispatcher function. Event info of each event mapped to\n   * a jsaction is passed for handling to this callback. The queued\n   * events are passed as well to the dispatcher for later replaying\n   * once the dispatcher is registered. Clears the event queue to null.\n   *\n   * @param dispatcher The dispatcher function.\n   * @param restriction\n   */\n  registerDispatcher(dispatcher: Dispatcher, restriction: Restriction) {\n    this.ecrd(dispatcher, restriction);\n  }\n\n  /**\n   * Unrenamed alias for registerDispatcher. Necessary for any codebases that\n   * split the `EventContract` and `Dispatcher` code into different compilation\n   * units.\n   */\n  ecrd(dispatcher: Dispatcher, restriction: Restriction) {\n    this.dispatcher = dispatcher;\n\n    if (this.queuedEventInfos?.length) {\n      for (let i = 0; i < this.queuedEventInfos.length; i++) {\n        this.handleEventInfo(this.queuedEventInfos[i]);\n      }\n      this.queuedEventInfos = null;\n    }\n  }\n\n  /**\n   * Adds a11y click support to the given `EventContract`. Meant to be called in\n   * the same compilation unit as the `EventContract`.\n   */\n  addA11yClickSupport() {\n    this.addA11yClickSupportImpl(\n      a11yClickLib.updateEventInfoForA11yClick,\n      a11yClickLib.preventDefaultForA11yClick,\n      a11yClickLib.populateClickOnlyAction,\n    );\n  }\n\n  /**\n   * Enables a11y click support to be deferred. Meant to be called in the same\n   * compilation unit as the `EventContract`.\n   */\n  exportAddA11yClickSupport() {\n    this.addA11yClickListener = true;\n    this.ecaacs = this.addA11yClickSupportImpl.bind(this);\n  }\n\n  /**\n   * Unrenamed function that loads a11yClickSupport.\n   */\n  private addA11yClickSupportImpl(\n    updateEventInfoForA11yClick: typeof a11yClickLib.updateEventInfoForA11yClick,\n    preventDefaultForA11yClick: typeof a11yClickLib.preventDefaultForA11yClick,\n    populateClickOnlyAction: typeof a11yClickLib.populateClickOnlyAction,\n  ) {\n    this.addA11yClickListener = true;\n    this.hasA11yClickSupport = true;\n    this.updateEventInfoForA11yClick = updateEventInfoForA11yClick;\n    this.preventDefaultForA11yClick = preventDefaultForA11yClick;\n    this.populateClickOnlyAction = populateClickOnlyAction;\n  }\n}\n\n/**\n * Adds a11y click support to the given `EventContract`. Meant to be called\n * in a different compilation unit from the `EventContract`. The `EventContract`\n * must have called `exportAddA11yClickSupport` in its compilation unit for this\n * to have any effect.\n */\nexport function addDeferredA11yClickSupport(eventContract: EventContract) {\n  eventContract.ecaacs?.(\n    a11yClickLib.updateEventInfoForA11yClick,\n    a11yClickLib.preventDefaultForA11yClick,\n    a11yClickLib.populateClickOnlyAction,\n  );\n}\n\n/**\n * Determines whether or not the `EventContract` needs to check with the\n * dispatcher even if there's no action.\n */\nfunction checkDispatcherForA11yClick(eventInfo: eventInfoLib.EventInfo): boolean {\n  return (\n    EventContract.A11Y_SUPPORT_IN_DISPATCHER &&\n    eventInfoLib.getEventType(eventInfo) === AccessibilityAttribute.MAYBE_CLICK_EVENT_TYPE\n  );\n}\n\n/**\n * Returns true if the default action of this event should be prevented before\n * this event is dispatched.\n */\nfunction shouldPreventDefaultBeforeDispatching(\n  actionElement: Element,\n  eventInfo: eventInfoLib.EventInfo,\n): boolean {\n  // Prevent browser from following <a> node links if a jsaction is present\n  // and we are dispatching the action now. Note that the targetElement may be\n  // a child of an anchor that has a jsaction attached. For that reason, we\n  // need to check the actionElement rather than the targetElement.\n  return (\n    actionElement.tagName === 'A' &&\n    (eventInfoLib.getEventType(eventInfo) === EventType.CLICK ||\n      eventInfoLib.getEventType(eventInfo) === EventType.CLICKMOD)\n  );\n}\n\n/**\n * Parses and caches an element's jsaction element into a map.\n *\n * This is primarily for internal use.\n *\n * @param actionElement The DOM node to retrieve the jsaction map from.\n * @param container The node which limits the namespace lookup for a jsaction\n * name. The container node itself will not be searched.\n * @return Map from event to qualified name of the jsaction bound to it.\n */\nexport function parseActions(actionElement: Element, container: Node): {[key: string]: string} {\n  let actionMap: {[key: string]: string} | undefined = cache.get(actionElement);\n  if (!actionMap) {\n    const jsactionAttribute = getAttr(actionElement, Attribute.JSACTION);\n    if (!jsactionAttribute) {\n      actionMap = EMPTY_ACTION_MAP;\n      cache.set(actionElement, actionMap);\n    } else {\n      actionMap = cache.getParsed(jsactionAttribute);\n      if (!actionMap) {\n        actionMap = {};\n        const values = jsactionAttribute.split(REGEXP_SEMICOLON);\n        for (let idx = 0; idx < values.length; idx++) {\n          const value = values[idx];\n          if (!value) {\n            continue;\n          }\n          const colon = value.indexOf(Char.EVENT_ACTION_SEPARATOR);\n          const hasColon = colon !== -1;\n          const type = hasColon ? stringTrim(value.substr(0, colon)) : DEFAULT_EVENT_TYPE;\n          const action = hasColon ? stringTrim(value.substr(colon + 1)) : value;\n          actionMap[type] = action;\n        }\n        cache.setParsed(jsactionAttribute, actionMap);\n      }\n      // If namespace support is active we need to augment the (potentially\n      // cached) jsaction mapping with the namespace.\n      if (EventContract.JSNAMESPACE_SUPPORT) {\n        const noNs = actionMap;\n        actionMap = {};\n        for (const type in noNs) {\n          actionMap[type] = getFullyQualifiedAction(noNs[type], actionElement, container);\n        }\n      }\n      cache.set(actionElement, actionMap);\n    }\n  }\n  return actionMap;\n}\n\n/**\n * Returns the fully qualified jsaction action. If the given jsaction\n * name doesn't already contain the namespace, the function iterates\n * over ancestor nodes until a jsnamespace attribute is found, and\n * uses the value of that attribute as the namespace.\n *\n * @param action The jsaction action to resolve.\n * @param start The node from which to start searching for a jsnamespace\n * attribute.\n * @param container The node which limits the search for a jsnamespace\n * attribute. This node will be searched.\n * @return The fully qualified name of the jsaction. If no namespace is found,\n * returns the unqualified name in case it exists in the global namespace.\n */\nfunction getFullyQualifiedAction(action: string, start: Element, container: Node): string {\n  if (EventContract.JSNAMESPACE_SUPPORT) {\n    if (isNamespacedAction(action)) {\n      return action;\n    }\n\n    let node: Node | null = start;\n    while (node) {\n      const namespace = getNamespaceFromElement(node as Element);\n      if (namespace) {\n        return namespace + Char.NAMESPACE_ACTION_SEPARATOR + action;\n      }\n\n      // If this node is the container, stop.\n      if (node === container) {\n        break;\n      }\n\n      node = node.parentNode;\n    }\n  }\n\n  return action;\n}\n\n/**\n * Checks if a jsaction action contains a namespace part.\n */\nfunction isNamespacedAction(action: string): boolean {\n  return action.indexOf(Char.NAMESPACE_ACTION_SEPARATOR) >= 0;\n}\n\n/**\n * Returns the value of the jsnamespace attribute of the given node.\n * Also caches the value for subsequent lookups.\n * @param element The node whose jsnamespace attribute is being asked for.\n * @return The value of the jsnamespace attribute, or null if not found.\n */\nfunction getNamespaceFromElement(element: Element): string | null {\n  let namespace = cache.getNamespace(element);\n  // Only query for the attribute if it has not been queried for\n  // before. getAttr() returns null if an attribute is not present. Thus,\n  // namespace is string|null if the query took place in the past, or\n  // undefined if the query did not take place.\n  if (namespace === undefined) {\n    namespace = getAttr(element, Attribute.JSNAMESPACE);\n    cache.setNamespace(element, namespace);\n  }\n  return namespace;\n}\n\n/**\n * Accesses the event handler attribute value of a DOM node. It guards\n * against weird situations (described in the body) that occur in\n * connection with nodes that are removed from their document.\n * @param element The DOM element.\n * @param attribute The name of the attribute to access.\n * @return The attribute value if it was found, null otherwise.\n */\nfunction getAttr(element: Element, attribute: string): string | null {\n  let value = null;\n  // NOTE: Nodes in IE do not always have a getAttribute\n  // method defined. This is the case where sourceElement has in\n  // fact been removed from the DOM before eventContract begins\n  // handling - where a parentNode does not have getAttribute\n  // defined.\n  // NOTE: We must use the 'in' operator instead of the regular dot\n  // notation, since the latter fails in IE8 if the getAttribute method is not\n  // defined. See b/7139109.\n  if ('getAttribute' in element) {\n    value = element.getAttribute(attribute);\n  }\n  return value;\n}\n\n/**\n * Helper function to trim whitespace from the beginning and the end\n * of the string. This deliberately doesn't use the closure equivalent\n * to keep dependencies small.\n * @param str  Input string.\n * @return  Trimmed string.\n */\nfunction stringTrim(str: string): string {\n  if (typeof String.prototype.trim === 'function') {\n    return str.trim();\n  }\n\n  const trimmedLeft = str.replace(/^\\s+/, '');\n  return trimmedLeft.replace(/\\s+$/, '');\n}\n"]}