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

package/esm2022/primitives/event-dispatch/src/custom_events.mjs

@@ -0,0 +1,63 @@
+/**
+ * @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
+ */
+import { EventType } from './/event_type';
+/**
+ * Create a custom event with the specified data.
+ * @param type The type of the action, e.g., 'submit'.
+ * @param data An optional data payload.
+ * @param triggeringEvent The event that triggers this custom event. This can be
+ *     accessed from the custom event's action flow like so:
+ *     actionFlow.event().detail.triggeringEvent.
+ * @return The new custom event.
+ */
+export function createCustomEvent(type, data, triggeringEvent) {
+    let event;
+    const unrenamedDetail = {
+        '_type': type,
+    };
+    const renamedDetail = {
+        type,
+        data,
+        triggeringEvent,
+    };
+    const detail = { ...unrenamedDetail, ...renamedDetail };
+    try {
+        // We don't use the CustomEvent constructor directly since it isn't
+        // supported in IE 9 or 10 and initCustomEvent below works just fine.
+        event = document.createEvent('CustomEvent');
+        event.initCustomEvent(EventType.CUSTOM, true, false, detail);
+    }
+    catch (e) {
+        // If custom events aren't supported, fall back to custom-named HTMLEvent.
+        // Fallback used by Android Gingerbread, FF4-5.
+        // Hack to emulate `CustomEvent`, `HTMLEvents` doesn't satisfy `CustomEvent`
+        // type.
+        // tslint:disable-next-line:no-any
+        event = document.createEvent('HTMLEvents');
+        event.initEvent(EventType.CUSTOM, true, false);
+        // Hack to emulate `CustomEvent`, `detail` is readonly on `CustomEvent`.
+        // tslint:disable-next-line:no-any
+        event['detail'] = detail;
+    }
+    return event;
+}
+/**
+ * Fires a custom event with an optional payload. Only intended to be consumed
+ * by jsaction itself. Supported in Firefox 6+, IE 9+, and all Chrome versions.
+ *
+ * @param target The target element.
+ * @param type The type of the action, e.g., 'submit'.
+ * @param data An optional data payload.
+ * @param triggeringEvent An optional data for the Event triggered this custom
+ *     event.
+ */
+export function fireCustomEvent(target, type, data, triggeringEvent) {
+    const event = createCustomEvent(type, data, triggeringEvent);
+    target.dispatchEvent(event);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/primitives/event-dispatch/src/dispatcher.mjs

@@ -0,0 +1,254 @@
+/**
+ * @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
+ */
+import { BaseDispatcher } from './base_dispatcher';
+import { Char } from './char';
+import * as eventLib from './event';
+import { EventType } from './event_type';
+import { Restriction } from './restriction';
+/**
+ * Receives a DOM event, determines the jsaction associated with the source
+ * element of the DOM event, and invokes the handler associated with the
+ * jsaction.
+ */
+export class Dispatcher {
+    /**
+     * Receives a DOM event, determines the jsaction associated with the source
+     * element of the DOM event, and invokes the handler associated with the
+     * jsaction.
+     *
+     * @param getHandler A function that knows how to get the handler for a
+     *     given event info.
+     */
+    constructor(getHandler, { stopPropagation = false, eventReplayer = undefined, } = {}) {
+        this.getHandler = getHandler;
+        /**
+         * The actions that are registered for this Dispatcher instance.
+         * This should be the primary one used once migration off of registerHandlers
+         * is done.
+         */
+        this.actions = {};
+        /** A map of global event handlers, where each key is an event type. */
+        this.globalHandlers = new Map();
+        this.baseDispatcher = new BaseDispatcher((eventInfoWrapper, isGlobalDispatch) => {
+            this.dispatchToHandler(eventInfoWrapper, isGlobalDispatch);
+        }, {
+            eventReplayer: (eventInfoWrappers) => {
+                this.eventReplayer?.(eventInfoWrappers, this);
+            },
+        });
+        this.stopPropagation = stopPropagation;
+    }
+    /**
+     * Receives an event or the event queue from the EventContract. The event
+     * queue is copied and it attempts to replay.
+     * If event info is passed in it looks for an action handler that can handle
+     * the given event.  If there is no handler registered queues the event and
+     * checks if a loader is registered for the given namespace. If so, calls it.
+     *
+     * Alternatively, if in global dispatch mode, calls all registered global
+     * handlers for the appropriate event type.
+     *
+     * The three functionalities of this call are deliberately not split into
+     * three methods (and then declared as an abstract interface), because the
+     * interface is used by EventContract, which lives in a different jsbinary.
+     * Therefore the interface between the three is defined entirely in terms that
+     * are invariant under jscompiler processing (Function and Array, as opposed
+     * to a custom type with method names).
+     *
+     * @param eventInfo The info for the event that triggered this call or the
+     *     queue of events from EventContract.
+     * @param isGlobalDispatch If true, dispatches a global event instead of a
+     *     regular jsaction handler.
+     * @return An `EventInfo` for the `EventContract` to handle again if the
+     *    `Dispatcher` tried to resolve an a11y event as a click but failed.
+     */
+    dispatch(eventInfo, isGlobalDispatch) {
+        return this.baseDispatcher.dispatch(eventInfo, isGlobalDispatch);
+    }
+    /**
+     * Dispatches an `EventInfoWrapper`.
+     */
+    dispatchToHandler(eventInfoWrapper, isGlobalDispatch) {
+        if (isGlobalDispatch) {
+            // Skip everything related to jsaction handlers, and execute the global
+            // handlers.
+            const ev = eventInfoWrapper.getEvent();
+            const eventTypeHandlers = this.globalHandlers.get(eventInfoWrapper.getEventType());
+            let shouldPreventDefault = false;
+            if (eventTypeHandlers) {
+                for (const handler of eventTypeHandlers) {
+                    if (handler(ev) === false) {
+                        shouldPreventDefault = true;
+                    }
+                }
+            }
+            if (shouldPreventDefault) {
+                eventLib.preventDefault(ev);
+            }
+            return;
+        }
+        if (this.stopPropagation) {
+            stopPropagation(eventInfoWrapper);
+        }
+        const action = eventInfoWrapper.getAction();
+        let handler = undefined;
+        if (this.getHandler) {
+            handler = this.getHandler(eventInfoWrapper);
+        }
+        if (!handler) {
+            handler = this.actions[action.name];
+        }
+        if (handler) {
+            handler(eventInfoWrapper);
+            return;
+        }
+        // No handler was found.
+        this.baseDispatcher.queueEventInfoWrapper(eventInfoWrapper);
+    }
+    /**
+     * Registers multiple methods all bound to the same object
+     * instance. This is a common case: an application module binds
+     * multiple of its methods under public names to the event contract of
+     * the application. So we provide a shortcut for it.
+     * Attempts to replay the queued events after registering the handlers.
+     *
+     * @param namespace The namespace of the jsaction name.
+     *
+     * @param instance The object to bind the methods to. If this is null, then
+     *     the functions are not bound, but directly added under the public names.
+     *
+     * @param methods A map from public name to functions that will be bound to
+     *     instance and registered as action under the public name. I.e. the
+     *     property names are the public names. The property values are the
+     *     methods of instance.
+     */
+    registerEventInfoHandlers(namespace, instance, methods) {
+        for (const [name, method] of Object.entries(methods)) {
+            const handler = instance ? method.bind(instance) : method;
+            if (namespace) {
+                // Include a '.' separator between namespace name and action name.
+                // In the case that no namespace name is provided, the jsaction name
+                // consists of the action name only (no period).
+                const fullName = namespace + Char.NAMESPACE_ACTION_SEPARATOR + name;
+                this.actions[fullName] = handler;
+            }
+            else {
+                this.actions[name] = handler;
+            }
+        }
+        this.baseDispatcher.scheduleEventReplay();
+    }
+    /**
+     * Unregisters an action.  Provided as an easy way to reverse the effects of
+     * registerHandlers.
+     * @param namespace The namespace of the jsaction name.
+     * @param name The action name to unbind.
+     */
+    unregisterHandler(namespace, name) {
+        const fullName = namespace ? namespace + Char.NAMESPACE_ACTION_SEPARATOR + name : name;
+        delete this.actions[fullName];
+    }
+    /** Registers a global event handler. */
+    registerGlobalHandler(eventType, handler) {
+        if (!this.globalHandlers.has(eventType)) {
+            this.globalHandlers.set(eventType, new Set([handler]));
+        }
+        else {
+            this.globalHandlers.get(eventType).add(handler);
+        }
+    }
+    /** Unregisters a global event handler. */
+    unregisterGlobalHandler(eventType, handler) {
+        if (this.globalHandlers.has(eventType)) {
+            this.globalHandlers.get(eventType).delete(handler);
+        }
+    }
+    /**
+     * Checks whether there is an action registered under the given
+     * name. This returns true if there is a namespace handler, even
+     * if it can not yet handle the event.
+     *
+     * @param name Action name.
+     * @return Whether the name is registered.
+     * @see #canDispatch
+     */
+    hasAction(name) {
+        return this.actions.hasOwnProperty(name);
+    }
+    /**
+     * Whether this dispatcher can dispatch the event. This can be used by
+     * event replayer to check whether the dispatcher can replay an event.
+     */
+    canDispatch(eventInfoWrapper) {
+        const action = eventInfoWrapper.getAction();
+        if (!action) {
+            return false;
+        }
+        return this.hasAction(action.name);
+    }
+    /**
+     * Sets the event replayer, enabling queued events to be replayed when actions
+     * are bound. To replay events, you must register the dispatcher to the
+     * contract after setting the `EventReplayer`. The event replayer takes as
+     * parameters the queue of events and the dispatcher (used to check whether
+     * actions have handlers registered and can be replayed). The event replayer
+     * is also responsible for dequeuing events.
+     *
+     * Example: An event replayer that replays only the last event.
+     *
+     *   const dispatcher = new Dispatcher();
+     *   // ...
+     *   dispatcher.setEventReplayer((queue, dispatcher) => {
+     *     const lastEventInfoWrapper = queue[queue.length -1];
+     *     if (dispatcher.canDispatch(lastEventInfoWrapper.getAction())) {
+     *       jsaction.replay.replayEvent(
+     *           lastEventInfoWrapper.getEvent(),
+     *           lastEventInfoWrapper.getTargetElement(),
+     *           lastEventInfoWrapper.getEventType(),
+     *       );
+     *       queue.length = 0;
+     *     }
+     *   });
+     *
+     * @param eventReplayer It allows elements to be replayed and dequeuing.
+     */
+    setEventReplayer(eventReplayer) {
+        this.eventReplayer = eventReplayer;
+    }
+}
+/** Stop propagation for an `EventInfo`. */
+export function stopPropagation(eventInfoWrapper) {
+    if (eventLib.isGecko &&
+        (eventInfoWrapper.getTargetElement().tagName === 'INPUT' ||
+            eventInfoWrapper.getTargetElement().tagName === 'TEXTAREA') &&
+        eventInfoWrapper.getEventType() === EventType.FOCUS) {
+        /**
+         * Do nothing since stopping propagation on a focus event on an input
+         * element in Firefox makes the text cursor disappear:
+         * https://bugzilla.mozilla.org/show_bug.cgi?id=509684
+         */
+        return;
+    }
+    const event = eventInfoWrapper.getEvent();
+    // There are some cases where users of the `Dispatcher` will call dispatch
+    // with a fake event that does not support `stopPropagation`.
+    if (!event.stopPropagation) {
+        return;
+    }
+    event.stopPropagation();
+}
+/**
+ * Registers deferred functionality for an EventContract and a Jsaction
+ * Dispatcher.
+ */
+export function registerDispatcher(eventContract, dispatcher) {
+    eventContract.ecrd((eventInfo, globalDispatch) => {
+        return dispatcher.dispatch(eventInfo, globalDispatch);
+    }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dispatcher.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/dispatcher.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\nimport {BaseDispatcher, EventInfoWrapperHandler} from './base_dispatcher';\nimport {Char} from './char';\nimport * as eventLib from './event';\nimport {EventInfo, EventInfoWrapper} from './event_info';\nimport {EventType} from './event_type';\nimport {UnrenamedEventContract} from './eventcontract';\nimport {Restriction} from './restriction';\n\nexport type {EventInfoWrapperHandler as EventInfoHandler} from './base_dispatcher';\n\n/**\n * A global handler is dispatched to before normal handler dispatch. Returning\n * false will `preventDefault` on the event.\n */\nexport type GlobalHandler = (event: Event) => boolean | void;\n\n/**\n * A replayer is a function that is called when there are queued events,\n * either from the `EventContract` or when there are no detected handlers.\n */\nexport type Replayer = (eventInfoWrappers: EventInfoWrapper[], dispatcher: Dispatcher) => void;\n\n/**\n * Receives a DOM event, determines the jsaction associated with the source\n * element of the DOM event, and invokes the handler associated with the\n * jsaction.\n */\nexport class Dispatcher {\n  private readonly baseDispatcher: BaseDispatcher;\n\n  /** Whether to stop propagation for an `EventInfo`. */\n  private readonly stopPropagation: boolean;\n\n  /**\n   * The actions that are registered for this Dispatcher instance.\n   * This should be the primary one used once migration off of registerHandlers\n   * is done.\n   */\n  private readonly actions: {[key: string]: EventInfoWrapperHandler} = {};\n\n  /** A map of global event handlers, where each key is an event type. */\n  private readonly globalHandlers = new Map<string, Set<GlobalHandler>>();\n\n  /** The event replayer. */\n  private eventReplayer?: Replayer;\n\n  /**\n   * Receives a DOM event, determines the jsaction associated with the source\n   * element of the DOM event, and invokes the handler associated with the\n   * jsaction.\n   *\n   * @param getHandler A function that knows how to get the handler for a\n   *     given event info.\n   */\n  constructor(\n    private readonly getHandler?: (\n      eventInfoWrapper: EventInfoWrapper,\n    ) => EventInfoWrapperHandler | void,\n    {\n      stopPropagation = false,\n      eventReplayer = undefined,\n    }: {stopPropagation?: boolean; eventReplayer?: Replayer} = {},\n  ) {\n    this.baseDispatcher = new BaseDispatcher(\n      (eventInfoWrapper: EventInfoWrapper, isGlobalDispatch?: boolean) => {\n        this.dispatchToHandler(eventInfoWrapper, isGlobalDispatch);\n      },\n      {\n        eventReplayer: (eventInfoWrappers) => {\n          this.eventReplayer?.(eventInfoWrappers, this);\n        },\n      },\n    );\n    this.stopPropagation = stopPropagation;\n  }\n\n  /**\n   * Receives an event or the event queue from the EventContract. The event\n   * queue is copied and it attempts to replay.\n   * If event info is passed in it looks for an action handler that can handle\n   * the given event.  If there is no handler registered queues the event and\n   * checks if a loader is registered for the given namespace. If so, calls it.\n   *\n   * Alternatively, if in global dispatch mode, calls all registered global\n   * handlers for the appropriate event type.\n   *\n   * The three functionalities of this call are deliberately not split into\n   * three methods (and then declared as an abstract interface), because the\n   * interface is used by EventContract, which lives in a different jsbinary.\n   * Therefore the interface between the three is defined entirely in terms that\n   * are invariant under jscompiler processing (Function and Array, as opposed\n   * to a custom type with method names).\n   *\n   * @param eventInfo The info for the event that triggered this call or the\n   *     queue of events from EventContract.\n   * @param isGlobalDispatch If true, dispatches a global event instead of a\n   *     regular jsaction handler.\n   * @return An `EventInfo` for the `EventContract` to handle again if the\n   *    `Dispatcher` tried to resolve an a11y event as a click but failed.\n   */\n  dispatch(eventInfo: EventInfo, isGlobalDispatch?: boolean): EventInfo | void {\n    return this.baseDispatcher.dispatch(eventInfo, isGlobalDispatch);\n  }\n\n  /**\n   * Dispatches an `EventInfoWrapper`.\n   */\n  private dispatchToHandler(eventInfoWrapper: EventInfoWrapper, isGlobalDispatch?: boolean) {\n    if (isGlobalDispatch) {\n      // Skip everything related to jsaction handlers, and execute the global\n      // handlers.\n      const ev = eventInfoWrapper.getEvent();\n      const eventTypeHandlers = this.globalHandlers.get(eventInfoWrapper.getEventType());\n      let shouldPreventDefault = false;\n      if (eventTypeHandlers) {\n        for (const handler of eventTypeHandlers) {\n          if (handler(ev) === false) {\n            shouldPreventDefault = true;\n          }\n        }\n      }\n      if (shouldPreventDefault) {\n        eventLib.preventDefault(ev);\n      }\n      return;\n    }\n\n    if (this.stopPropagation) {\n      stopPropagation(eventInfoWrapper);\n    }\n\n    const action = eventInfoWrapper.getAction()!;\n\n    let handler: EventInfoWrapperHandler | void = undefined;\n    if (this.getHandler) {\n      handler = this.getHandler(eventInfoWrapper);\n    }\n\n    if (!handler) {\n      handler = this.actions[action.name];\n    }\n\n    if (handler) {\n      handler(eventInfoWrapper);\n      return;\n    }\n\n    // No handler was found.\n    this.baseDispatcher.queueEventInfoWrapper(eventInfoWrapper);\n  }\n\n  /**\n   * Registers multiple methods all bound to the same object\n   * instance. This is a common case: an application module binds\n   * multiple of its methods under public names to the event contract of\n   * the application. So we provide a shortcut for it.\n   * Attempts to replay the queued events after registering the handlers.\n   *\n   * @param namespace The namespace of the jsaction name.\n   *\n   * @param instance The object to bind the methods to. If this is null, then\n   *     the functions are not bound, but directly added under the public names.\n   *\n   * @param methods A map from public name to functions that will be bound to\n   *     instance and registered as action under the public name. I.e. the\n   *     property names are the public names. The property values are the\n   *     methods of instance.\n   */\n  registerEventInfoHandlers<T>(\n    namespace: string,\n    instance: T | null,\n    methods: {[key: string]: EventInfoWrapperHandler},\n  ) {\n    for (const [name, method] of Object.entries(methods)) {\n      const handler = instance ? method.bind(instance) : method;\n      if (namespace) {\n        // Include a '.' separator between namespace name and action name.\n        // In the case that no namespace name is provided, the jsaction name\n        // consists of the action name only (no period).\n        const fullName = namespace + Char.NAMESPACE_ACTION_SEPARATOR + name;\n        this.actions[fullName] = handler;\n      } else {\n        this.actions[name] = handler;\n      }\n    }\n\n    this.baseDispatcher.scheduleEventReplay();\n  }\n\n  /**\n   * Unregisters an action.  Provided as an easy way to reverse the effects of\n   * registerHandlers.\n   * @param namespace The namespace of the jsaction name.\n   * @param name The action name to unbind.\n   */\n  unregisterHandler(namespace: string, name: string) {\n    const fullName = namespace ? namespace + Char.NAMESPACE_ACTION_SEPARATOR + name : name;\n    delete this.actions[fullName];\n  }\n\n  /** Registers a global event handler. */\n  registerGlobalHandler(eventType: string, handler: GlobalHandler) {\n    if (!this.globalHandlers.has(eventType)) {\n      this.globalHandlers.set(eventType, new Set<GlobalHandler>([handler]));\n    } else {\n      this.globalHandlers.get(eventType)!.add(handler);\n    }\n  }\n\n  /** Unregisters a global event handler. */\n  unregisterGlobalHandler(eventType: string, handler: GlobalHandler) {\n    if (this.globalHandlers.has(eventType)) {\n      this.globalHandlers.get(eventType)!.delete(handler);\n    }\n  }\n\n  /**\n   * Checks whether there is an action registered under the given\n   * name. This returns true if there is a namespace handler, even\n   * if it can not yet handle the event.\n   *\n   * @param name Action name.\n   * @return Whether the name is registered.\n   * @see #canDispatch\n   */\n  hasAction(name: string): boolean {\n    return this.actions.hasOwnProperty(name);\n  }\n\n  /**\n   * Whether this dispatcher can dispatch the event. This can be used by\n   * event replayer to check whether the dispatcher can replay an event.\n   */\n  canDispatch(eventInfoWrapper: EventInfoWrapper): boolean {\n    const action = eventInfoWrapper.getAction();\n    if (!action) {\n      return false;\n    }\n    return this.hasAction(action.name);\n  }\n\n  /**\n   * Sets the event replayer, enabling queued events to be replayed when actions\n   * are bound. To replay events, you must register the dispatcher to the\n   * contract after setting the `EventReplayer`. The event replayer takes as\n   * parameters the queue of events and the dispatcher (used to check whether\n   * actions have handlers registered and can be replayed). The event replayer\n   * is also responsible for dequeuing events.\n   *\n   * Example: An event replayer that replays only the last event.\n   *\n   *   const dispatcher = new Dispatcher();\n   *   // ...\n   *   dispatcher.setEventReplayer((queue, dispatcher) => {\n   *     const lastEventInfoWrapper = queue[queue.length -1];\n   *     if (dispatcher.canDispatch(lastEventInfoWrapper.getAction())) {\n   *       jsaction.replay.replayEvent(\n   *           lastEventInfoWrapper.getEvent(),\n   *           lastEventInfoWrapper.getTargetElement(),\n   *           lastEventInfoWrapper.getEventType(),\n   *       );\n   *       queue.length = 0;\n   *     }\n   *   });\n   *\n   * @param eventReplayer It allows elements to be replayed and dequeuing.\n   */\n  setEventReplayer(eventReplayer: Replayer) {\n    this.eventReplayer = eventReplayer;\n  }\n}\n\n/** Stop propagation for an `EventInfo`. */\nexport function stopPropagation(eventInfoWrapper: EventInfoWrapper) {\n  if (\n    eventLib.isGecko &&\n    (eventInfoWrapper.getTargetElement().tagName === 'INPUT' ||\n      eventInfoWrapper.getTargetElement().tagName === 'TEXTAREA') &&\n    eventInfoWrapper.getEventType() === EventType.FOCUS\n  ) {\n    /**\n     * Do nothing since stopping propagation on a focus event on an input\n     * element in Firefox makes the text cursor disappear:\n     * https://bugzilla.mozilla.org/show_bug.cgi?id=509684\n     */\n    return;\n  }\n\n  const event = eventInfoWrapper.getEvent();\n  // There are some cases where users of the `Dispatcher` will call dispatch\n  // with a fake event that does not support `stopPropagation`.\n  if (!event.stopPropagation) {\n    return;\n  }\n  event.stopPropagation();\n}\n\n/**\n * Registers deferred functionality for an EventContract and a Jsaction\n * Dispatcher.\n */\nexport function registerDispatcher(eventContract: UnrenamedEventContract, dispatcher: Dispatcher) {\n  eventContract.ecrd((eventInfo: EventInfo, globalDispatch?: boolean) => {\n    return dispatcher.dispatch(eventInfo, globalDispatch);\n  }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);\n}\n"]}

package/esm2022/primitives/event-dispatch/src/dom.mjs

@@ -0,0 +1,48 @@
+/**
+ * @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
+ */
+/**
+ * Determines if one node is contained within another. Adapted from
+ * {@see goog.dom.contains}.
+ * @param node Node that should contain otherNode.
+ * @param otherNode Node being contained.
+ * @return True if otherNode is contained within node.
+ */
+export function contains(node, otherNode) {
+    if (otherNode === null) {
+        return false;
+    }
+    // We use browser specific methods for this if available since it is faster
+    // that way.
+    // IE DOM
+    if ('contains' in node && otherNode.nodeType === 1) {
+        return node.contains(otherNode);
+    }
+    // W3C DOM Level 3
+    if ('compareDocumentPosition' in node) {
+        return node === otherNode || Boolean(node.compareDocumentPosition(otherNode) & 16);
+    }
+    // W3C DOM Level 1
+    while (otherNode && node !== otherNode) {
+        otherNode = otherNode.parentNode;
+    }
+    return otherNode === node;
+}
+/**
+ * Helper method for broadcastCustomEvent. Returns true if any member of
+ * the set is an ancestor of element.
+ */
+export function hasAncestorInNodeList(element, nodeList) {
+    for (let idx = 0; idx < nodeList.length; ++idx) {
+        const member = nodeList[idx];
+        if (member !== element && contains(member, element)) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/primitives/event-dispatch/src/earlyeventcontract.mjs

@@ -0,0 +1,36 @@
+/**
+ * @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
+ */
+import { createEventInfoFromParameters } from './event_info';
+/**
+ * EarlyEventContract intercepts events in the bubbling phase at the
+ * boundary of the document body. This mapping will be passed to the
+ * late-loaded EventContract.
+ */
+export class EarlyEventContract {
+    constructor() {
+        window._ejsa = {
+            q: [],
+            et: [],
+            h: (event) => {
+                const eventInfo = createEventInfoFromParameters(event.type, event, event.target, window.document.documentElement, Date.now());
+                window._ejsa.q.push(eventInfo);
+            },
+        };
+    }
+    /**
+     * Installs a list of event types for window.document.documentElement.
+     */
+    addEvents(types) {
+        for (let idx = 0; idx < types.length; idx++) {
+            const eventType = types[idx];
+            window._ejsa.et.push(eventType);
+            window.document.documentElement.addEventListener(eventType, window._ejsa.h);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWFybHlldmVudGNvbnRyYWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9wcmltaXRpdmVzL2V2ZW50LWRpc3BhdGNoL3NyYy9lYXJseWV2ZW50Y29udHJhY3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLDZCQUE2QixFQUFZLE1BQU0sY0FBYyxDQUFDO0FBc0J0RTs7OztHQUlHO0FBQ0gsTUFBTSxPQUFPLGtCQUFrQjtJQUM3QjtRQUNFLE1BQU0sQ0FBQyxLQUFLLEdBQUc7WUFDYixDQUFDLEVBQUUsRUFBRTtZQUNMLEVBQUUsRUFBRSxFQUFFO1lBQ04sQ0FBQyxFQUFFLENBQUMsS0FBWSxFQUFFLEVBQUU7Z0JBQ2xCLE1BQU0sU0FBUyxHQUFHLDZCQUE2QixDQUM3QyxLQUFLLENBQUMsSUFBSSxFQUNWLEtBQUssRUFDTCxLQUFLLENBQUMsTUFBaUIsRUFDdkIsTUFBTSxDQUFDLFFBQVEsQ0FBQyxlQUFlLEVBQy9CLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FDWCxDQUFDO2dCQUNGLE1BQU0sQ0FBQyxLQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztZQUNsQyxDQUFDO1NBQ0YsQ0FBQztJQUNKLENBQUM7SUFFRDs7T0FFRztJQUNILFNBQVMsQ0FBQyxLQUFlO1FBQ3ZCLEtBQUssSUFBSSxHQUFHLEdBQUcsQ0FBQyxFQUFFLEdBQUcsR0FBRyxLQUFLLENBQUMsTUFBTSxFQUFFLEdBQUcsRUFBRSxFQUFFLENBQUM7WUFDNUMsTUFBTSxTQUFTLEdBQUcsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQzdCLE1BQU0sQ0FBQyxLQUFNLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztZQUNqQyxNQUFNLENBQUMsUUFBUSxDQUFDLGVBQWUsQ0FBQyxnQkFBZ0IsQ0FBQyxTQUFTLEVBQUUsTUFBTSxDQUFDLEtBQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUMvRSxDQUFDO0lBQ0gsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7Y3JlYXRlRXZlbnRJbmZvRnJvbVBhcmFtZXRlcnMsIEV2ZW50SW5mb30gZnJvbSAnLi9ldmVudF9pbmZvJztcblxuZGVjbGFyZSBnbG9iYWwge1xuICBpbnRlcmZhY2UgV2luZG93IHtcbiAgICBfZWpzYT86IEVhcmx5SnNhY3Rpb25EYXRhO1xuICB9XG59XG5cbi8qKlxuICogRGVmaW5lcyB0aGUgZWFybHkganNhY3Rpb24gZGF0YSB0eXBlcy5cbiAqL1xuZXhwb3J0IGRlY2xhcmUgaW50ZXJmYWNlIEVhcmx5SnNhY3Rpb25EYXRhIHtcbiAgLy8gTGlzdCB1c2VkIHRvIGtlZXAgdHJhY2sgb2YgdGhlIGVhcmx5IEpTQWN0aW9uIGV2ZW50IHR5cGVzLlxuICBldDogc3RyaW5nW107XG5cbiAgLy8gTGlzdCB1c2VkIHRvIGtlZXAgdHJhY2sgb2YgdGhlIEpTQWN0aW9uIGV2ZW50cyBpZiB1c2luZyBlYXJseWV2ZW50Y29udHJhY3QuXG4gIHE6IEV2ZW50SW5mb1tdO1xuXG4gIC8vIEVhcmx5IEpzYWN0aW9uIGhhbmRsZXJcbiAgaDogKGV2ZW50OiBFdmVudCkgPT4gdm9pZDtcbn1cblxuLyoqXG4gKiBFYXJseUV2ZW50Q29udHJhY3QgaW50ZXJjZXB0cyBldmVudHMgaW4gdGhlIGJ1YmJsaW5nIHBoYXNlIGF0IHRoZVxuICogYm91bmRhcnkgb2YgdGhlIGRvY3VtZW50IGJvZHkuIFRoaXMgbWFwcGluZyB3aWxsIGJlIHBhc3NlZCB0byB0aGVcbiAqIGxhdGUtbG9hZGVkIEV2ZW50Q29udHJhY3QuXG4gKi9cbmV4cG9ydCBjbGFzcyBFYXJseUV2ZW50Q29udHJhY3Qge1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICB3aW5kb3cuX2Vqc2EgPSB7XG4gICAgICBxOiBbXSxcbiAgICAgIGV0OiBbXSxcbiAgICAgIGg6IChldmVudDogRXZlbnQpID0+IHtcbiAgICAgICAgY29uc3QgZXZlbnRJbmZvID0gY3JlYXRlRXZlbnRJbmZvRnJvbVBhcmFtZXRlcnMoXG4gICAgICAgICAgZXZlbnQudHlwZSxcbiAgICAgICAgICBldmVudCxcbiAgICAgICAgICBldmVudC50YXJnZXQgYXMgRWxlbWVudCxcbiAgICAgICAgICB3aW5kb3cuZG9jdW1lbnQuZG9jdW1lbnRFbGVtZW50LFxuICAgICAgICAgIERhdGUubm93KCksXG4gICAgICAgICk7XG4gICAgICAgIHdpbmRvdy5fZWpzYSEucS5wdXNoKGV2ZW50SW5mbyk7XG4gICAgICB9LFxuICAgIH07XG4gIH1cblxuICAvKipcbiAgICogSW5zdGFsbHMgYSBsaXN0IG9mIGV2ZW50IHR5cGVzIGZvciB3aW5kb3cuZG9jdW1lbnQuZG9jdW1lbnRFbGVtZW50LlxuICAgKi9cbiAgYWRkRXZlbnRzKHR5cGVzOiBzdHJpbmdbXSkge1xuICAgIGZvciAobGV0IGlkeCA9IDA7IGlkeCA8IHR5cGVzLmxlbmd0aDsgaWR4KyspIHtcbiAgICAgIGNvbnN0IGV2ZW50VHlwZSA9IHR5cGVzW2lkeF07XG4gICAgICB3aW5kb3cuX2Vqc2EhLmV0LnB1c2goZXZlbnRUeXBlKTtcbiAgICAgIHdpbmRvdy5kb2N1bWVudC5kb2N1bWVudEVsZW1lbnQuYWRkRXZlbnRMaXN0ZW5lcihldmVudFR5cGUsIHdpbmRvdy5fZWpzYSEuaCk7XG4gICAgfVxuICB9XG59XG4iXX0=