@angular/platform-browser 13.0.0-next.0 → 13.0.0-next.12

package/esm2020/src/dom/events/hammer_gestures.mjs

@@ -0,0 +1,266 @@
+/**
+ * @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 { DOCUMENT } from '@angular/common';
+import { Inject, Injectable, InjectionToken, NgModule, Optional, ɵConsole as Console } from '@angular/core';
+import { EVENT_MANAGER_PLUGINS, EventManagerPlugin } from './event_manager';
+import * as i0 from "@angular/core";
+/**
+ * Supported HammerJS recognizer event names.
+ */
+const EVENT_NAMES = {
+    // pan
+    'pan': true,
+    'panstart': true,
+    'panmove': true,
+    'panend': true,
+    'pancancel': true,
+    'panleft': true,
+    'panright': true,
+    'panup': true,
+    'pandown': true,
+    // pinch
+    'pinch': true,
+    'pinchstart': true,
+    'pinchmove': true,
+    'pinchend': true,
+    'pinchcancel': true,
+    'pinchin': true,
+    'pinchout': true,
+    // press
+    'press': true,
+    'pressup': true,
+    // rotate
+    'rotate': true,
+    'rotatestart': true,
+    'rotatemove': true,
+    'rotateend': true,
+    'rotatecancel': true,
+    // swipe
+    'swipe': true,
+    'swipeleft': true,
+    'swiperight': true,
+    'swipeup': true,
+    'swipedown': true,
+    // tap
+    'tap': true,
+    'doubletap': true
+};
+/**
+ * DI token for providing [HammerJS](https://hammerjs.github.io/) support to Angular.
+ * @see `HammerGestureConfig`
+ *
+ * @ngModule HammerModule
+ * @publicApi
+ */
+export const HAMMER_GESTURE_CONFIG = new InjectionToken('HammerGestureConfig');
+/**
+ * Injection token used to provide a {@link HammerLoader} to Angular.
+ *
+ * @publicApi
+ */
+export const HAMMER_LOADER = new InjectionToken('HammerLoader');
+/**
+ * An injectable [HammerJS Manager](https://hammerjs.github.io/api/#hammermanager)
+ * for gesture recognition. Configures specific event recognition.
+ * @publicApi
+ */
+export class HammerGestureConfig {
+    constructor() {
+        /**
+         * A set of supported event names for gestures to be used in Angular.
+         * Angular supports all built-in recognizers, as listed in
+         * [HammerJS documentation](https://hammerjs.github.io/).
+         */
+        this.events = [];
+        /**
+         * Maps gesture event names to a set of configuration options
+         * that specify overrides to the default values for specific properties.
+         *
+         * The key is a supported event name to be configured,
+         * and the options object contains a set of properties, with override values
+         * to be applied to the named recognizer event.
+         * For example, to disable recognition of the rotate event, specify
+         *  `{"rotate": {"enable": false}}`.
+         *
+         * Properties that are not present take the HammerJS default values.
+         * For information about which properties are supported for which events,
+         * and their allowed and default values, see
+         * [HammerJS documentation](https://hammerjs.github.io/).
+         *
+         */
+        this.overrides = {};
+    }
+    /**
+     * Creates a [HammerJS Manager](https://hammerjs.github.io/api/#hammermanager)
+     * and attaches it to a given HTML element.
+     * @param element The element that will recognize gestures.
+     * @returns A HammerJS event-manager object.
+     */
+    buildHammer(element) {
+        const mc = new Hammer(element, this.options);
+        mc.get('pinch').set({ enable: true });
+        mc.get('rotate').set({ enable: true });
+        for (const eventName in this.overrides) {
+            mc.get(eventName).set(this.overrides[eventName]);
+        }
+        return mc;
+    }
+}
+HammerGestureConfig.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: HammerGestureConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+HammerGestureConfig.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: HammerGestureConfig });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: HammerGestureConfig, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * Event plugin that adds Hammer support to an application.
+ *
+ * @ngModule HammerModule
+ */
+export class HammerGesturesPlugin extends EventManagerPlugin {
+    constructor(doc, _config, console, loader) {
+        super(doc);
+        this._config = _config;
+        this.console = console;
+        this.loader = loader;
+        this._loaderPromise = null;
+    }
+    supports(eventName) {
+        if (!EVENT_NAMES.hasOwnProperty(eventName.toLowerCase()) && !this.isCustomEvent(eventName)) {
+            return false;
+        }
+        if (!window.Hammer && !this.loader) {
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                this.console.warn(`The "${eventName}" event cannot be bound because Hammer.JS is not ` +
+                    `loaded and no custom loader has been specified.`);
+            }
+            return false;
+        }
+        return true;
+    }
+    addEventListener(element, eventName, handler) {
+        const zone = this.manager.getZone();
+        eventName = eventName.toLowerCase();
+        // If Hammer is not present but a loader is specified, we defer adding the event listener
+        // until Hammer is loaded.
+        if (!window.Hammer && this.loader) {
+            this._loaderPromise = this._loaderPromise || this.loader();
+            // This `addEventListener` method returns a function to remove the added listener.
+            // Until Hammer is loaded, the returned function needs to *cancel* the registration rather
+            // than remove anything.
+            let cancelRegistration = false;
+            let deregister = () => {
+                cancelRegistration = true;
+            };
+            this._loaderPromise
+                .then(() => {
+                // If Hammer isn't actually loaded when the custom loader resolves, give up.
+                if (!window.Hammer) {
+                    if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                        this.console.warn(`The custom HAMMER_LOADER completed, but Hammer.JS is not present.`);
+                    }
+                    deregister = () => { };
+                    return;
+                }
+                if (!cancelRegistration) {
+                    // Now that Hammer is loaded and the listener is being loaded for real,
+                    // the deregistration function changes from canceling registration to removal.
+                    deregister = this.addEventListener(element, eventName, handler);
+                }
+            })
+                .catch(() => {
+                if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                    this.console.warn(`The "${eventName}" event cannot be bound because the custom ` +
+                        `Hammer.JS loader failed.`);
+                }
+                deregister = () => { };
+            });
+            // Return a function that *executes* `deregister` (and not `deregister` itself) so that we
+            // can change the behavior of `deregister` once the listener is added. Using a closure in
+            // this way allows us to avoid any additional data structures to track listener removal.
+            return () => {
+                deregister();
+            };
+        }
+        return zone.runOutsideAngular(() => {
+            // Creating the manager bind events, must be done outside of angular
+            const mc = this._config.buildHammer(element);
+            const callback = function (eventObj) {
+                zone.runGuarded(function () {
+                    handler(eventObj);
+                });
+            };
+            mc.on(eventName, callback);
+            return () => {
+                mc.off(eventName, callback);
+                // destroy mc to prevent memory leak
+                if (typeof mc.destroy === 'function') {
+                    mc.destroy();
+                }
+            };
+        });
+    }
+    isCustomEvent(eventName) {
+        return this._config.events.indexOf(eventName) > -1;
+    }
+}
+HammerGesturesPlugin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: HammerGesturesPlugin, deps: [{ token: DOCUMENT }, { token: HAMMER_GESTURE_CONFIG }, { token: i0.ɵConsole }, { token: HAMMER_LOADER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+HammerGesturesPlugin.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: HammerGesturesPlugin });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: HammerGesturesPlugin, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: HammerGestureConfig, decorators: [{
+                    type: Inject,
+                    args: [HAMMER_GESTURE_CONFIG]
+                }] }, { type: i0.ɵConsole }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [HAMMER_LOADER]
+                }] }]; } });
+/**
+ * In Ivy, support for Hammer gestures is optional, so applications must
+ * import the `HammerModule` at root to turn on support. This means that
+ * Hammer-specific code can be tree-shaken away if not needed.
+ */
+export const HAMMER_PROVIDERS__POST_R3__ = [];
+/**
+ * In View Engine, support for Hammer gestures is built-in by default.
+ */
+export const HAMMER_PROVIDERS__PRE_R3__ = [
+    {
+        provide: EVENT_MANAGER_PLUGINS,
+        useClass: HammerGesturesPlugin,
+        multi: true,
+        deps: [DOCUMENT, HAMMER_GESTURE_CONFIG, Console, [new Optional(), HAMMER_LOADER]]
+    },
+    { provide: HAMMER_GESTURE_CONFIG, useClass: HammerGestureConfig, deps: [] },
+];
+export const HAMMER_PROVIDERS = HAMMER_PROVIDERS__POST_R3__;
+/**
+ * Adds support for HammerJS.
+ *
+ * Import this module at the root of your application so that Angular can work with
+ * HammerJS to detect gesture events.
+ *
+ * Note that applications still need to include the HammerJS script itself. This module
+ * simply sets up the coordination layer between HammerJS and Angular's EventManager.
+ *
+ * @publicApi
+ */
+export class HammerModule {
+}
+HammerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: HammerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+HammerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: HammerModule });
+HammerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: HammerModule, providers: HAMMER_PROVIDERS__PRE_R3__ });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: HammerModule, decorators: [{
+            type: NgModule,
+            args: [{ providers: HAMMER_PROVIDERS__PRE_R3__ }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hammer_gestures.js","sourceRoot":"","sources":["../../../../../../../../packages/platform-browser/src/dom/events/hammer_gestures.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 {DOCUMENT} from '@angular/common';\nimport {Inject, Injectable, InjectionToken, NgModule, Optional, Provider, ɵConsole as Console} from '@angular/core';\n\nimport {EVENT_MANAGER_PLUGINS, EventManagerPlugin} from './event_manager';\n\n\n\n/**\n * Supported HammerJS recognizer event names.\n */\nconst EVENT_NAMES = {\n  // pan\n  'pan': true,\n  'panstart': true,\n  'panmove': true,\n  'panend': true,\n  'pancancel': true,\n  'panleft': true,\n  'panright': true,\n  'panup': true,\n  'pandown': true,\n  // pinch\n  'pinch': true,\n  'pinchstart': true,\n  'pinchmove': true,\n  'pinchend': true,\n  'pinchcancel': true,\n  'pinchin': true,\n  'pinchout': true,\n  // press\n  'press': true,\n  'pressup': true,\n  // rotate\n  'rotate': true,\n  'rotatestart': true,\n  'rotatemove': true,\n  'rotateend': true,\n  'rotatecancel': true,\n  // swipe\n  'swipe': true,\n  'swipeleft': true,\n  'swiperight': true,\n  'swipeup': true,\n  'swipedown': true,\n  // tap\n  'tap': true,\n  'doubletap': true\n};\n\n/**\n * DI token for providing [HammerJS](https://hammerjs.github.io/) support to Angular.\n * @see `HammerGestureConfig`\n *\n * @ngModule HammerModule\n * @publicApi\n */\nexport const HAMMER_GESTURE_CONFIG = new InjectionToken<HammerGestureConfig>('HammerGestureConfig');\n\n\n/**\n * Function that loads HammerJS, returning a promise that is resolved once HammerJs is loaded.\n *\n * @publicApi\n */\nexport type HammerLoader = () => Promise<void>;\n\n/**\n * Injection token used to provide a {@link HammerLoader} to Angular.\n *\n * @publicApi\n */\nexport const HAMMER_LOADER = new InjectionToken<HammerLoader>('HammerLoader');\n\nexport interface HammerInstance {\n  on(eventName: string, callback?: Function): void;\n  off(eventName: string, callback?: Function): void;\n  destroy?(): void;\n}\n\n/**\n * An injectable [HammerJS Manager](https://hammerjs.github.io/api/#hammermanager)\n * for gesture recognition. Configures specific event recognition.\n * @publicApi\n */\n@Injectable()\nexport class HammerGestureConfig {\n  /**\n   * A set of supported event names for gestures to be used in Angular.\n   * Angular supports all built-in recognizers, as listed in\n   * [HammerJS documentation](https://hammerjs.github.io/).\n   */\n  events: string[] = [];\n\n  /**\n   * Maps gesture event names to a set of configuration options\n   * that specify overrides to the default values for specific properties.\n   *\n   * The key is a supported event name to be configured,\n   * and the options object contains a set of properties, with override values\n   * to be applied to the named recognizer event.\n   * For example, to disable recognition of the rotate event, specify\n   *  `{\"rotate\": {\"enable\": false}}`.\n   *\n   * Properties that are not present take the HammerJS default values.\n   * For information about which properties are supported for which events,\n   * and their allowed and default values, see\n   * [HammerJS documentation](https://hammerjs.github.io/).\n   *\n   */\n  overrides: {[key: string]: Object} = {};\n\n  /**\n   * Properties whose default values can be overridden for a given event.\n   * Different sets of properties apply to different events.\n   * For information about which properties are supported for which events,\n   * and their allowed and default values, see\n   * [HammerJS documentation](https://hammerjs.github.io/).\n   */\n  options?: {\n    cssProps?: any;\n    domEvents?: boolean;\n    enable?: boolean | ((manager: any) => boolean);\n    preset?: any[];\n    touchAction?: string;\n    recognizers?: any[];\n    inputClass?: any;\n    inputTarget?: EventTarget;\n  };\n\n  /**\n   * Creates a [HammerJS Manager](https://hammerjs.github.io/api/#hammermanager)\n   * and attaches it to a given HTML element.\n   * @param element The element that will recognize gestures.\n   * @returns A HammerJS event-manager object.\n   */\n  buildHammer(element: HTMLElement): HammerInstance {\n    const mc = new Hammer!(element, this.options);\n\n    mc.get('pinch').set({enable: true});\n    mc.get('rotate').set({enable: true});\n\n    for (const eventName in this.overrides) {\n      mc.get(eventName).set(this.overrides[eventName]);\n    }\n\n    return mc;\n  }\n}\n\n/**\n * Event plugin that adds Hammer support to an application.\n *\n * @ngModule HammerModule\n */\n@Injectable()\nexport class HammerGesturesPlugin extends EventManagerPlugin {\n  private _loaderPromise: Promise<void>|null = null;\n\n  constructor(\n      @Inject(DOCUMENT) doc: any,\n      @Inject(HAMMER_GESTURE_CONFIG) private _config: HammerGestureConfig, private console: Console,\n      @Optional() @Inject(HAMMER_LOADER) private loader?: HammerLoader|null) {\n    super(doc);\n  }\n\n  override supports(eventName: string): boolean {\n    if (!EVENT_NAMES.hasOwnProperty(eventName.toLowerCase()) && !this.isCustomEvent(eventName)) {\n      return false;\n    }\n\n    if (!(window as any).Hammer && !this.loader) {\n      if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        this.console.warn(\n            `The \"${eventName}\" event cannot be bound because Hammer.JS is not ` +\n            `loaded and no custom loader has been specified.`);\n      }\n      return false;\n    }\n\n    return true;\n  }\n\n  override addEventListener(element: HTMLElement, eventName: string, handler: Function): Function {\n    const zone = this.manager.getZone();\n    eventName = eventName.toLowerCase();\n\n    // If Hammer is not present but a loader is specified, we defer adding the event listener\n    // until Hammer is loaded.\n    if (!(window as any).Hammer && this.loader) {\n      this._loaderPromise = this._loaderPromise || this.loader();\n      // This `addEventListener` method returns a function to remove the added listener.\n      // Until Hammer is loaded, the returned function needs to *cancel* the registration rather\n      // than remove anything.\n      let cancelRegistration = false;\n      let deregister: Function = () => {\n        cancelRegistration = true;\n      };\n\n      this._loaderPromise\n          .then(() => {\n            // If Hammer isn't actually loaded when the custom loader resolves, give up.\n            if (!(window as any).Hammer) {\n              if (typeof ngDevMode === 'undefined' || ngDevMode) {\n                this.console.warn(\n                    `The custom HAMMER_LOADER completed, but Hammer.JS is not present.`);\n              }\n              deregister = () => {};\n              return;\n            }\n\n            if (!cancelRegistration) {\n              // Now that Hammer is loaded and the listener is being loaded for real,\n              // the deregistration function changes from canceling registration to removal.\n              deregister = this.addEventListener(element, eventName, handler);\n            }\n          })\n          .catch(() => {\n            if (typeof ngDevMode === 'undefined' || ngDevMode) {\n              this.console.warn(\n                  `The \"${eventName}\" event cannot be bound because the custom ` +\n                  `Hammer.JS loader failed.`);\n            }\n            deregister = () => {};\n          });\n\n      // Return a function that *executes* `deregister` (and not `deregister` itself) so that we\n      // can change the behavior of `deregister` once the listener is added. Using a closure in\n      // this way allows us to avoid any additional data structures to track listener removal.\n      return () => {\n        deregister();\n      };\n    }\n\n    return zone.runOutsideAngular(() => {\n      // Creating the manager bind events, must be done outside of angular\n      const mc = this._config.buildHammer(element);\n      const callback = function(eventObj: HammerInput) {\n        zone.runGuarded(function() {\n          handler(eventObj);\n        });\n      };\n      mc.on(eventName, callback);\n      return () => {\n        mc.off(eventName, callback);\n        // destroy mc to prevent memory leak\n        if (typeof mc.destroy === 'function') {\n          mc.destroy();\n        }\n      };\n    });\n  }\n\n  isCustomEvent(eventName: string): boolean {\n    return this._config.events.indexOf(eventName) > -1;\n  }\n}\n\n/**\n * In Ivy, support for Hammer gestures is optional, so applications must\n * import the `HammerModule` at root to turn on support. This means that\n * Hammer-specific code can be tree-shaken away if not needed.\n */\nexport const HAMMER_PROVIDERS__POST_R3__ = [];\n\n/**\n * In View Engine, support for Hammer gestures is built-in by default.\n */\nexport const HAMMER_PROVIDERS__PRE_R3__: Provider[] = [\n  {\n    provide: EVENT_MANAGER_PLUGINS,\n    useClass: HammerGesturesPlugin,\n    multi: true,\n    deps: [DOCUMENT, HAMMER_GESTURE_CONFIG, Console, [new Optional(), HAMMER_LOADER]]\n  },\n  {provide: HAMMER_GESTURE_CONFIG, useClass: HammerGestureConfig, deps: []},\n];\n\nexport const HAMMER_PROVIDERS = HAMMER_PROVIDERS__PRE_R3__;\n\n/**\n * Adds support for HammerJS.\n *\n * Import this module at the root of your application so that Angular can work with\n * HammerJS to detect gesture events.\n *\n * Note that applications still need to include the HammerJS script itself. This module\n * simply sets up the coordination layer between HammerJS and Angular's EventManager.\n *\n * @publicApi\n */\n@NgModule({providers: HAMMER_PROVIDERS__PRE_R3__})\nexport class HammerModule {\n}\n"]}

package/esm2020/src/dom/events/key_events.mjs

@@ -0,0 +1,204 @@
+/**
+ * @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 { DOCUMENT, ɵgetDOM as getDOM } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { EventManagerPlugin } from './event_manager';
+import * as i0 from "@angular/core";
+/**
+ * Defines supported modifiers for key events.
+ */
+const MODIFIER_KEYS = ['alt', 'control', 'meta', 'shift'];
+const DOM_KEY_LOCATION_NUMPAD = 3;
+// Map to convert some key or keyIdentifier values to what will be returned by getEventKey
+const _keyMap = {
+    // The following values are here for cross-browser compatibility and to match the W3C standard
+    // cf https://www.w3.org/TR/DOM-Level-3-Events-key/
+    '\b': 'Backspace',
+    '\t': 'Tab',
+    '\x7F': 'Delete',
+    '\x1B': 'Escape',
+    'Del': 'Delete',
+    'Esc': 'Escape',
+    'Left': 'ArrowLeft',
+    'Right': 'ArrowRight',
+    'Up': 'ArrowUp',
+    'Down': 'ArrowDown',
+    'Menu': 'ContextMenu',
+    'Scroll': 'ScrollLock',
+    'Win': 'OS'
+};
+// There is a bug in Chrome for numeric keypad keys:
+// https://code.google.com/p/chromium/issues/detail?id=155654
+// 1, 2, 3 ... are reported as A, B, C ...
+const _chromeNumKeyPadMap = {
+    'A': '1',
+    'B': '2',
+    'C': '3',
+    'D': '4',
+    'E': '5',
+    'F': '6',
+    'G': '7',
+    'H': '8',
+    'I': '9',
+    'J': '*',
+    'K': '+',
+    'M': '-',
+    'N': '.',
+    'O': '/',
+    '\x60': '0',
+    '\x90': 'NumLock'
+};
+/**
+ * Retrieves modifiers from key-event objects.
+ */
+const MODIFIER_KEY_GETTERS = {
+    'alt': (event) => event.altKey,
+    'control': (event) => event.ctrlKey,
+    'meta': (event) => event.metaKey,
+    'shift': (event) => event.shiftKey
+};
+/**
+ * @publicApi
+ * A browser plug-in that provides support for handling of key events in Angular.
+ */
+export class KeyEventsPlugin extends EventManagerPlugin {
+    /**
+     * Initializes an instance of the browser plug-in.
+     * @param doc The document in which key events will be detected.
+     */
+    constructor(doc) {
+        super(doc);
+    }
+    /**
+     * Reports whether a named key event is supported.
+     * @param eventName The event name to query.
+     * @return True if the named key event is supported.
+     */
+    supports(eventName) {
+        return KeyEventsPlugin.parseEventName(eventName) != null;
+    }
+    /**
+     * Registers a handler for a specific element and key event.
+     * @param element The HTML element to receive event notifications.
+     * @param eventName The name of the key event to listen for.
+     * @param handler A function to call when the notification occurs. Receives the
+     * event object as an argument.
+     * @returns The key event that was registered.
+     */
+    addEventListener(element, eventName, handler) {
+        const parsedEvent = KeyEventsPlugin.parseEventName(eventName);
+        const outsideHandler = KeyEventsPlugin.eventCallback(parsedEvent['fullKey'], handler, this.manager.getZone());
+        return this.manager.getZone().runOutsideAngular(() => {
+            return getDOM().onAndCancel(element, parsedEvent['domEventName'], outsideHandler);
+        });
+    }
+    static parseEventName(eventName) {
+        const parts = eventName.toLowerCase().split('.');
+        const domEventName = parts.shift();
+        if ((parts.length === 0) || !(domEventName === 'keydown' || domEventName === 'keyup')) {
+            return null;
+        }
+        const key = KeyEventsPlugin._normalizeKey(parts.pop());
+        let fullKey = '';
+        MODIFIER_KEYS.forEach(modifierName => {
+            const index = parts.indexOf(modifierName);
+            if (index > -1) {
+                parts.splice(index, 1);
+                fullKey += modifierName + '.';
+            }
+        });
+        fullKey += key;
+        if (parts.length != 0 || key.length === 0) {
+            // returning null instead of throwing to let another plugin process the event
+            return null;
+        }
+        // NOTE: Please don't rewrite this as so, as it will break JSCompiler property renaming.
+        //       The code must remain in the `result['domEventName']` form.
+        // return {domEventName, fullKey};
+        const result = {};
+        result['domEventName'] = domEventName;
+        result['fullKey'] = fullKey;
+        return result;
+    }
+    static getEventFullKey(event) {
+        let fullKey = '';
+        let key = getEventKey(event);
+        key = key.toLowerCase();
+        if (key === ' ') {
+            key = 'space'; // for readability
+        }
+        else if (key === '.') {
+            key = 'dot'; // because '.' is used as a separator in event names
+        }
+        MODIFIER_KEYS.forEach(modifierName => {
+            if (modifierName != key) {
+                const modifierGetter = MODIFIER_KEY_GETTERS[modifierName];
+                if (modifierGetter(event)) {
+                    fullKey += modifierName + '.';
+                }
+            }
+        });
+        fullKey += key;
+        return fullKey;
+    }
+    /**
+     * Configures a handler callback for a key event.
+     * @param fullKey The event name that combines all simultaneous keystrokes.
+     * @param handler The function that responds to the key event.
+     * @param zone The zone in which the event occurred.
+     * @returns A callback function.
+     */
+    static eventCallback(fullKey, handler, zone) {
+        return (event /** TODO #9100 */) => {
+            if (KeyEventsPlugin.getEventFullKey(event) === fullKey) {
+                zone.runGuarded(() => handler(event));
+            }
+        };
+    }
+    /** @internal */
+    static _normalizeKey(keyName) {
+        // TODO: switch to a Map if the mapping grows too much
+        switch (keyName) {
+            case 'esc':
+                return 'escape';
+            default:
+                return keyName;
+        }
+    }
+}
+KeyEventsPlugin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: KeyEventsPlugin, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+KeyEventsPlugin.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: KeyEventsPlugin });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: KeyEventsPlugin, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+function getEventKey(event) {
+    let key = event.key;
+    if (key == null) {
+        key = event.keyIdentifier;
+        // keyIdentifier is defined in the old draft of DOM Level 3 Events implemented by Chrome and
+        // Safari cf
+        // https://www.w3.org/TR/2007/WD-DOM-Level-3-Events-20071221/events.html#Events-KeyboardEvents-Interfaces
+        if (key == null) {
+            return 'Unidentified';
+        }
+        if (key.startsWith('U+')) {
+            key = String.fromCharCode(parseInt(key.substring(2), 16));
+            if (event.location === DOM_KEY_LOCATION_NUMPAD && _chromeNumKeyPadMap.hasOwnProperty(key)) {
+                // There is a bug in Chrome for numeric keypad keys:
+                // https://code.google.com/p/chromium/issues/detail?id=155654
+                // 1, 2, 3 ... are reported as A, B, C ...
+                key = _chromeNumKeyPadMap[key];
+            }
+        }
+    }
+    return _keyMap[key] || key;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key_events.js","sourceRoot":"","sources":["../../../../../../../../packages/platform-browser/src/dom/events/key_events.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,QAAQ,EAAE,OAAO,IAAI,MAAM,EAAC,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAC,MAAM,EAAE,UAAU,EAAS,MAAM,eAAe,CAAC;AACzD,OAAO,EAAC,kBAAkB,EAAC,MAAM,iBAAiB,CAAC;;AAEnD;;GAEG;AACH,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AAE1D,MAAM,uBAAuB,GAAG,CAAC,CAAC;AAElC,0FAA0F;AAC1F,MAAM,OAAO,GAA0B;IACrC,8FAA8F;IAC9F,mDAAmD;IACnD,IAAI,EAAE,WAAW;IACjB,IAAI,EAAE,KAAK;IACX,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,QAAQ;IACf,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,WAAW;IACnB,OAAO,EAAE,YAAY;IACrB,IAAI,EAAE,SAAS;IACf,MAAM,EAAE,WAAW;IACnB,MAAM,EAAE,aAAa;IACrB,QAAQ,EAAE,YAAY;IACtB,KAAK,EAAE,IAAI;CACZ,CAAC;AAEF,oDAAoD;AACpD,6DAA6D;AAC7D,0CAA0C;AAC1C,MAAM,mBAAmB,GAAG;IAC1B,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,GAAG,EAAE,GAAG;IACR,MAAM,EAAE,GAAG;IACX,MAAM,EAAE,SAAS;CAClB,CAAC;AAGF;;GAEG;AACH,MAAM,oBAAoB,GAAuD;IAC/E,KAAK,EAAE,CAAC,KAAoB,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM;IAC7C,SAAS,EAAE,CAAC,KAAoB,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO;IAClD,MAAM,EAAE,CAAC,KAAoB,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO;IAC/C,OAAO,EAAE,CAAC,KAAoB,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ;CAClD,CAAC;AAEF;;;GAGG;AAEH,MAAM,OAAO,eAAgB,SAAQ,kBAAkB;IACrD;;;OAGG;IACH,YAA8B,GAAQ;QACpC,KAAK,CAAC,GAAG,CAAC,CAAC;IACb,CAAC;IAED;;;;OAIG;IACM,QAAQ,CAAC,SAAiB;QACjC,OAAO,eAAe,CAAC,cAAc,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC;IAC3D,CAAC;IAED;;;;;;;OAOG;IACM,gBAAgB,CAAC,OAAoB,EAAE,SAAiB,EAAE,OAAiB;QAClF,MAAM,WAAW,GAAG,eAAe,CAAC,cAAc,CAAC,SAAS,CAAE,CAAC;QAE/D,MAAM,cAAc,GAChB,eAAe,CAAC,aAAa,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QAE3F,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,iBAAiB,CAAC,GAAG,EAAE;YACnD,OAAO,MAAM,EAAE,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC,CAAC;QACpF,CAAC,CAAC,CAAC;IACL,CAAC;IAED,MAAM,CAAC,cAAc,CAAC,SAAiB;QACrC,MAAM,KAAK,GAAa,SAAS,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAE3D,MAAM,YAAY,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC;QACnC,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,YAAY,KAAK,SAAS,IAAI,YAAY,KAAK,OAAO,CAAC,EAAE;YACrF,OAAO,IAAI,CAAC;SACb;QAED,MAAM,GAAG,GAAG,eAAe,CAAC,aAAa,CAAC,KAAK,CAAC,GAAG,EAAG,CAAC,CAAC;QAExD,IAAI,OAAO,GAAG,EAAE,CAAC;QACjB,aAAa,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE;YACnC,MAAM,KAAK,GAAW,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;YAClD,IAAI,KAAK,GAAG,CAAC,CAAC,EAAE;gBACd,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;gBACvB,OAAO,IAAI,YAAY,GAAG,GAAG,CAAC;aAC/B;QACH,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,GAAG,CAAC;QAEf,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE;YACzC,6EAA6E;YAC7E,OAAO,IAAI,CAAC;SACb;QAED,wFAAwF;QACxF,mEAAmE;QACnE,kCAAkC;QAClC,MAAM,MAAM,GAA4C,EAAS,CAAC;QAClE,MAAM,CAAC,cAAc,CAAC,GAAG,YAAY,CAAC;QACtC,MAAM,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC;QAC5B,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,CAAC,eAAe,CAAC,KAAoB;QACzC,IAAI,OAAO,GAAG,EAAE,CAAC;QACjB,IAAI,GAAG,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;QAC7B,GAAG,GAAG,GAAG,CAAC,WAAW,EAAE,CAAC;QACxB,IAAI,GAAG,KAAK,GAAG,EAAE;YACf,GAAG,GAAG,OAAO,CAAC,CAAE,kBAAkB;SACnC;aAAM,IAAI,GAAG,KAAK,GAAG,EAAE;YACtB,GAAG,GAAG,KAAK,CAAC,CAAE,oDAAoD;SACnE;QACD,aAAa,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE;YACnC,IAAI,YAAY,IAAI,GAAG,EAAE;gBACvB,MAAM,cAAc,GAAG,oBAAoB,CAAC,YAAY,CAAC,CAAC;gBAC1D,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE;oBACzB,OAAO,IAAI,YAAY,GAAG,GAAG,CAAC;iBAC/B;aACF;QACH,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,GAAG,CAAC;QACf,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,aAAa,CAAC,OAAY,EAAE,OAAiB,EAAE,IAAY;QAChE,OAAO,CAAC,KAAU,CAAC,iBAAiB,EAAE,EAAE;YACtC,IAAI,eAAe,CAAC,eAAe,CAAC,KAAK,CAAC,KAAK,OAAO,EAAE;gBACtD,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;aACvC;QACH,CAAC,CAAC;IACJ,CAAC;IAED,gBAAgB;IAChB,MAAM,CAAC,aAAa,CAAC,OAAe;QAClC,sDAAsD;QACtD,QAAQ,OAAO,EAAE;YACf,KAAK,KAAK;gBACR,OAAO,QAAQ,CAAC;YAClB;gBACE,OAAO,OAAO,CAAC;SAClB;IACH,CAAC;;uHApHU,eAAe,kBAKN,QAAQ;2HALjB,eAAe;sGAAf,eAAe;kBAD3B,UAAU;;0BAMI,MAAM;2BAAC,QAAQ;;AAkH9B,SAAS,WAAW,CAAC,KAAU;IAC7B,IAAI,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;IACpB,IAAI,GAAG,IAAI,IAAI,EAAE;QACf,GAAG,GAAG,KAAK,CAAC,aAAa,CAAC;QAC1B,4FAA4F;QAC5F,YAAY;QACZ,yGAAyG;QACzG,IAAI,GAAG,IAAI,IAAI,EAAE;YACf,OAAO,cAAc,CAAC;SACvB;QACD,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YACxB,GAAG,GAAG,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;YAC1D,IAAI,KAAK,CAAC,QAAQ,KAAK,uBAAuB,IAAI,mBAAmB,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;gBACzF,oDAAoD;gBACpD,6DAA6D;gBAC7D,0CAA0C;gBAC1C,GAAG,GAAI,mBAA2B,CAAC,GAAG,CAAC,CAAC;aACzC;SACF;KACF;IAED,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC;AAC7B,CAAC","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 {DOCUMENT, ɵgetDOM as getDOM} from '@angular/common';\nimport {Inject, Injectable, NgZone} from '@angular/core';\nimport {EventManagerPlugin} from './event_manager';\n\n/**\n * Defines supported modifiers for key events.\n */\nconst MODIFIER_KEYS = ['alt', 'control', 'meta', 'shift'];\n\nconst DOM_KEY_LOCATION_NUMPAD = 3;\n\n// Map to convert some key or keyIdentifier values to what will be returned by getEventKey\nconst _keyMap: {[k: string]: string} = {\n  // The following values are here for cross-browser compatibility and to match the W3C standard\n  // cf https://www.w3.org/TR/DOM-Level-3-Events-key/\n  '\\b': 'Backspace',\n  '\\t': 'Tab',\n  '\\x7F': 'Delete',\n  '\\x1B': 'Escape',\n  'Del': 'Delete',\n  'Esc': 'Escape',\n  'Left': 'ArrowLeft',\n  'Right': 'ArrowRight',\n  'Up': 'ArrowUp',\n  'Down': 'ArrowDown',\n  'Menu': 'ContextMenu',\n  'Scroll': 'ScrollLock',\n  'Win': 'OS'\n};\n\n// There is a bug in Chrome for numeric keypad keys:\n// https://code.google.com/p/chromium/issues/detail?id=155654\n// 1, 2, 3 ... are reported as A, B, C ...\nconst _chromeNumKeyPadMap = {\n  'A': '1',\n  'B': '2',\n  'C': '3',\n  'D': '4',\n  'E': '5',\n  'F': '6',\n  'G': '7',\n  'H': '8',\n  'I': '9',\n  'J': '*',\n  'K': '+',\n  'M': '-',\n  'N': '.',\n  'O': '/',\n  '\\x60': '0',\n  '\\x90': 'NumLock'\n};\n\n\n/**\n * Retrieves modifiers from key-event objects.\n */\nconst MODIFIER_KEY_GETTERS: {[key: string]: (event: KeyboardEvent) => boolean} = {\n  'alt': (event: KeyboardEvent) => event.altKey,\n  'control': (event: KeyboardEvent) => event.ctrlKey,\n  'meta': (event: KeyboardEvent) => event.metaKey,\n  'shift': (event: KeyboardEvent) => event.shiftKey\n};\n\n/**\n * @publicApi\n * A browser plug-in that provides support for handling of key events in Angular.\n */\n@Injectable()\nexport class KeyEventsPlugin extends EventManagerPlugin {\n  /**\n   * Initializes an instance of the browser plug-in.\n   * @param doc The document in which key events will be detected.\n   */\n  constructor(@Inject(DOCUMENT) doc: any) {\n    super(doc);\n  }\n\n  /**\n   * Reports whether a named key event is supported.\n   * @param eventName The event name to query.\n   * @return True if the named key event is supported.\n   */\n  override supports(eventName: string): boolean {\n    return KeyEventsPlugin.parseEventName(eventName) != null;\n  }\n\n  /**\n   * Registers a handler for a specific element and key event.\n   * @param element The HTML element to receive event notifications.\n   * @param eventName The name of the key event to listen for.\n   * @param handler A function to call when the notification occurs. Receives the\n   * event object as an argument.\n   * @returns The key event that was registered.\n   */\n  override addEventListener(element: HTMLElement, eventName: string, handler: Function): Function {\n    const parsedEvent = KeyEventsPlugin.parseEventName(eventName)!;\n\n    const outsideHandler =\n        KeyEventsPlugin.eventCallback(parsedEvent['fullKey'], handler, this.manager.getZone());\n\n    return this.manager.getZone().runOutsideAngular(() => {\n      return getDOM().onAndCancel(element, parsedEvent['domEventName'], outsideHandler);\n    });\n  }\n\n  static parseEventName(eventName: string): {fullKey: string, domEventName: string}|null {\n    const parts: string[] = eventName.toLowerCase().split('.');\n\n    const domEventName = parts.shift();\n    if ((parts.length === 0) || !(domEventName === 'keydown' || domEventName === 'keyup')) {\n      return null;\n    }\n\n    const key = KeyEventsPlugin._normalizeKey(parts.pop()!);\n\n    let fullKey = '';\n    MODIFIER_KEYS.forEach(modifierName => {\n      const index: number = parts.indexOf(modifierName);\n      if (index > -1) {\n        parts.splice(index, 1);\n        fullKey += modifierName + '.';\n      }\n    });\n    fullKey += key;\n\n    if (parts.length != 0 || key.length === 0) {\n      // returning null instead of throwing to let another plugin process the event\n      return null;\n    }\n\n    // NOTE: Please don't rewrite this as so, as it will break JSCompiler property renaming.\n    //       The code must remain in the `result['domEventName']` form.\n    // return {domEventName, fullKey};\n    const result: {fullKey: string, domEventName: string} = {} as any;\n    result['domEventName'] = domEventName;\n    result['fullKey'] = fullKey;\n    return result;\n  }\n\n  static getEventFullKey(event: KeyboardEvent): string {\n    let fullKey = '';\n    let key = getEventKey(event);\n    key = key.toLowerCase();\n    if (key === ' ') {\n      key = 'space';  // for readability\n    } else if (key === '.') {\n      key = 'dot';  // because '.' is used as a separator in event names\n    }\n    MODIFIER_KEYS.forEach(modifierName => {\n      if (modifierName != key) {\n        const modifierGetter = MODIFIER_KEY_GETTERS[modifierName];\n        if (modifierGetter(event)) {\n          fullKey += modifierName + '.';\n        }\n      }\n    });\n    fullKey += key;\n    return fullKey;\n  }\n\n  /**\n   * Configures a handler callback for a key event.\n   * @param fullKey The event name that combines all simultaneous keystrokes.\n   * @param handler The function that responds to the key event.\n   * @param zone The zone in which the event occurred.\n   * @returns A callback function.\n   */\n  static eventCallback(fullKey: any, handler: Function, zone: NgZone): Function {\n    return (event: any /** TODO #9100 */) => {\n      if (KeyEventsPlugin.getEventFullKey(event) === fullKey) {\n        zone.runGuarded(() => handler(event));\n      }\n    };\n  }\n\n  /** @internal */\n  static _normalizeKey(keyName: string): string {\n    // TODO: switch to a Map if the mapping grows too much\n    switch (keyName) {\n      case 'esc':\n        return 'escape';\n      default:\n        return keyName;\n    }\n  }\n}\n\nfunction getEventKey(event: any): string {\n  let key = event.key;\n  if (key == null) {\n    key = event.keyIdentifier;\n    // keyIdentifier is defined in the old draft of DOM Level 3 Events implemented by Chrome and\n    // Safari cf\n    // https://www.w3.org/TR/2007/WD-DOM-Level-3-Events-20071221/events.html#Events-KeyboardEvents-Interfaces\n    if (key == null) {\n      return 'Unidentified';\n    }\n    if (key.startsWith('U+')) {\n      key = String.fromCharCode(parseInt(key.substring(2), 16));\n      if (event.location === DOM_KEY_LOCATION_NUMPAD && _chromeNumKeyPadMap.hasOwnProperty(key)) {\n        // There is a bug in Chrome for numeric keypad keys:\n        // https://code.google.com/p/chromium/issues/detail?id=155654\n        // 1, 2, 3 ... are reported as A, B, C ...\n        key = (_chromeNumKeyPadMap as any)[key];\n      }\n    }\n  }\n\n  return _keyMap[key] || key;\n}\n"]}

package/esm2020/src/dom/shared_styles_host.mjs

@@ -0,0 +1,83 @@
+/**
+ * @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 { DOCUMENT, ɵgetDOM as getDOM } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SharedStylesHost {
+    constructor() {
+        /** @internal */
+        this._stylesSet = new Set();
+    }
+    addStyles(styles) {
+        const additions = new Set();
+        styles.forEach(style => {
+            if (!this._stylesSet.has(style)) {
+                this._stylesSet.add(style);
+                additions.add(style);
+            }
+        });
+        this.onStylesAdded(additions);
+    }
+    onStylesAdded(additions) { }
+    getAllStyles() {
+        return Array.from(this._stylesSet);
+    }
+}
+SharedStylesHost.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: SharedStylesHost, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SharedStylesHost.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: SharedStylesHost });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: SharedStylesHost, decorators: [{
+            type: Injectable
+        }] });
+export class DomSharedStylesHost extends SharedStylesHost {
+    constructor(_doc) {
+        super();
+        this._doc = _doc;
+        // Maps all registered host nodes to a list of style nodes that have been added to the host node.
+        this._hostNodes = new Map();
+        this._hostNodes.set(_doc.head, []);
+    }
+    _addStylesToHost(styles, host, styleNodes) {
+        styles.forEach((style) => {
+            const styleEl = this._doc.createElement('style');
+            styleEl.textContent = style;
+            styleNodes.push(host.appendChild(styleEl));
+        });
+    }
+    addHost(hostNode) {
+        const styleNodes = [];
+        this._addStylesToHost(this._stylesSet, hostNode, styleNodes);
+        this._hostNodes.set(hostNode, styleNodes);
+    }
+    removeHost(hostNode) {
+        const styleNodes = this._hostNodes.get(hostNode);
+        if (styleNodes) {
+            styleNodes.forEach(removeStyle);
+        }
+        this._hostNodes.delete(hostNode);
+    }
+    onStylesAdded(additions) {
+        this._hostNodes.forEach((styleNodes, hostNode) => {
+            this._addStylesToHost(additions, hostNode, styleNodes);
+        });
+    }
+    ngOnDestroy() {
+        this._hostNodes.forEach(styleNodes => styleNodes.forEach(removeStyle));
+    }
+}
+DomSharedStylesHost.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: DomSharedStylesHost, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+DomSharedStylesHost.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: DomSharedStylesHost });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.12", ngImport: i0, type: DomSharedStylesHost, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+function removeStyle(styleNode) {
+    getDOM().remove(styleNode);
+}
+//# sourceMappingURL=data:application/json;base64,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