@angular/platform-browser 12.2.8 → 13.0.0-next.11

package/esm2020/src/browser/xhr.mjs

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A factory for `HttpXhrBackend` that uses the `XMLHttpRequest` browser API.
+ */
+export class BrowserXhr {
+    build() {
+        return new XMLHttpRequest();
+    }
+}
+BrowserXhr.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.11", ngImport: i0, type: BrowserXhr, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+BrowserXhr.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.11", ngImport: i0, type: BrowserXhr });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.11", ngImport: i0, type: BrowserXhr, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieGhyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvcGxhdGZvcm0tYnJvd3Nlci9zcmMvYnJvd3Nlci94aHIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0EsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLGVBQWUsQ0FBQzs7QUFFekM7O0dBRUc7QUFFSCxNQUFNLE9BQU8sVUFBVTtJQUNyQixLQUFLO1FBQ0gsT0FBTyxJQUFJLGNBQWMsRUFBRSxDQUFDO0lBQzlCLENBQUM7O2tIQUhVLFVBQVU7c0hBQVYsVUFBVTtzR0FBVixVQUFVO2tCQUR0QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7WGhyRmFjdG9yeX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7SW5qZWN0YWJsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbi8qKlxuICogQSBmYWN0b3J5IGZvciBgSHR0cFhockJhY2tlbmRgIHRoYXQgdXNlcyB0aGUgYFhNTEh0dHBSZXF1ZXN0YCBicm93c2VyIEFQSS5cbiAqL1xuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIEJyb3dzZXJYaHIgaW1wbGVtZW50cyBYaHJGYWN0b3J5IHtcbiAgYnVpbGQoKTogWE1MSHR0cFJlcXVlc3Qge1xuICAgIHJldHVybiBuZXcgWE1MSHR0cFJlcXVlc3QoKTtcbiAgfVxufVxuIl19

package/esm2020/src/browser.mjs

@@ -0,0 +1,132 @@
+/**
+ * @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 { CommonModule, DOCUMENT, XhrFactory, ɵPLATFORM_BROWSER_ID as PLATFORM_BROWSER_ID } from '@angular/common';
+import { APP_ID, ApplicationModule, createPlatformFactory, ErrorHandler, Inject, NgModule, NgZone, Optional, PLATFORM_ID, PLATFORM_INITIALIZER, platformCore, RendererFactory2, Sanitizer, SkipSelf, Testability, ɵINJECTOR_SCOPE as INJECTOR_SCOPE, ɵsetDocument } from '@angular/core';
+import { BrowserDomAdapter } from './browser/browser_adapter';
+import { SERVER_TRANSITION_PROVIDERS, TRANSITION_ID } from './browser/server-transition';
+import { BrowserGetTestability } from './browser/testability';
+import { BrowserXhr } from './browser/xhr';
+import { ELEMENT_PROBE_PROVIDERS } from './dom/debug/ng_probe';
+import { DomRendererFactory2 } from './dom/dom_renderer';
+import { DomEventsPlugin } from './dom/events/dom_events';
+import { EVENT_MANAGER_PLUGINS, EventManager } from './dom/events/event_manager';
+import { HAMMER_PROVIDERS } from './dom/events/hammer_gestures';
+import { KeyEventsPlugin } from './dom/events/key_events';
+import { DomSharedStylesHost, SharedStylesHost } from './dom/shared_styles_host';
+import { DomSanitizer, DomSanitizerImpl } from './security/dom_sanitization_service';
+import * as i0 from "@angular/core";
+export function initDomAdapter() {
+    BrowserDomAdapter.makeCurrent();
+    BrowserGetTestability.init();
+}
+export function errorHandler() {
+    return new ErrorHandler();
+}
+export function _document() {
+    // Tell ivy about the global document
+    ɵsetDocument(document);
+    return document;
+}
+export const INTERNAL_BROWSER_PLATFORM_PROVIDERS = [
+    { provide: PLATFORM_ID, useValue: PLATFORM_BROWSER_ID },
+    { provide: PLATFORM_INITIALIZER, useValue: initDomAdapter, multi: true },
+    { provide: DOCUMENT, useFactory: _document, deps: [] },
+];
+const BROWSER_SANITIZATION_PROVIDERS__PRE_R3__ = [
+    { provide: Sanitizer, useExisting: DomSanitizer },
+    { provide: DomSanitizer, useClass: DomSanitizerImpl, deps: [DOCUMENT] },
+];
+export const BROWSER_SANITIZATION_PROVIDERS__POST_R3__ = [];
+/**
+ * @security Replacing built-in sanitization providers exposes the application to XSS risks.
+ * Attacker-controlled data introduced by an unsanitized provider could expose your
+ * application to XSS risks. For more detail, see the [Security Guide](https://g.co/ng/security).
+ * @publicApi
+ */
+export const BROWSER_SANITIZATION_PROVIDERS = BROWSER_SANITIZATION_PROVIDERS__POST_R3__;
+/**
+ * A factory function that returns a `PlatformRef` instance associated with browser service
+ * providers.
+ *
+ * @publicApi
+ */
+export const platformBrowser = createPlatformFactory(platformCore, 'browser', INTERNAL_BROWSER_PLATFORM_PROVIDERS);
+export const BROWSER_MODULE_PROVIDERS = [
+    BROWSER_SANITIZATION_PROVIDERS,
+    { provide: INJECTOR_SCOPE, useValue: 'root' },
+    { provide: ErrorHandler, useFactory: errorHandler, deps: [] },
+    {
+        provide: EVENT_MANAGER_PLUGINS,
+        useClass: DomEventsPlugin,
+        multi: true,
+        deps: [DOCUMENT, NgZone, PLATFORM_ID]
+    },
+    { provide: EVENT_MANAGER_PLUGINS, useClass: KeyEventsPlugin, multi: true, deps: [DOCUMENT] },
+    HAMMER_PROVIDERS,
+    {
+        provide: DomRendererFactory2,
+        useClass: DomRendererFactory2,
+        deps: [EventManager, DomSharedStylesHost, APP_ID]
+    },
+    { provide: RendererFactory2, useExisting: DomRendererFactory2 },
+    { provide: SharedStylesHost, useExisting: DomSharedStylesHost },
+    { provide: DomSharedStylesHost, useClass: DomSharedStylesHost, deps: [DOCUMENT] },
+    { provide: Testability, useClass: Testability, deps: [NgZone] },
+    { provide: EventManager, useClass: EventManager, deps: [EVENT_MANAGER_PLUGINS, NgZone] },
+    { provide: XhrFactory, useClass: BrowserXhr, deps: [] },
+    ELEMENT_PROBE_PROVIDERS,
+];
+/**
+ * Exports required infrastructure for all Angular apps.
+ * Included by default in all Angular apps created with the CLI
+ * `new` command.
+ * Re-exports `CommonModule` and `ApplicationModule`, making their
+ * exports and providers available to all apps.
+ *
+ * @publicApi
+ */
+export class BrowserModule {
+    constructor(parentModule) {
+        if (parentModule) {
+            throw new Error(`BrowserModule has already been loaded. If you need access to common directives such as NgIf and NgFor from a lazy loaded module, import CommonModule instead.`);
+        }
+    }
+    /**
+     * Configures a browser-based app to transition from a server-rendered app, if
+     * one is present on the page.
+     *
+     * @param params An object containing an identifier for the app to transition.
+     * The ID must match between the client and server versions of the app.
+     * @returns The reconfigured `BrowserModule` to import into the app's root `AppModule`.
+     */
+    static withServerTransition(params) {
+        return {
+            ngModule: BrowserModule,
+            providers: [
+                { provide: APP_ID, useValue: params.appId },
+                { provide: TRANSITION_ID, useExisting: APP_ID },
+                SERVER_TRANSITION_PROVIDERS,
+            ],
+        };
+    }
+}
+BrowserModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.11", ngImport: i0, type: BrowserModule, deps: [{ token: BrowserModule, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.NgModule });
+BrowserModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.11", ngImport: i0, type: BrowserModule, exports: [CommonModule, ApplicationModule] });
+BrowserModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-next.11", ngImport: i0, type: BrowserModule, providers: BROWSER_MODULE_PROVIDERS, imports: [CommonModule, ApplicationModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.11", ngImport: i0, type: BrowserModule, decorators: [{
+            type: NgModule,
+            args: [{ providers: BROWSER_MODULE_PROVIDERS, exports: [CommonModule, ApplicationModule] }]
+        }], ctorParameters: function () { return [{ type: BrowserModule, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }, {
+                    type: Inject,
+                    args: [BrowserModule]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser.js","sourceRoot":"","sources":["../../../../../../packages/platform-browser/src/browser.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 {CommonModule, DOCUMENT, XhrFactory, ɵPLATFORM_BROWSER_ID as PLATFORM_BROWSER_ID} from '@angular/common';\nimport {APP_ID, ApplicationModule, createPlatformFactory, ErrorHandler, Inject, ModuleWithProviders, NgModule, NgZone, Optional, PLATFORM_ID, PLATFORM_INITIALIZER, platformCore, PlatformRef, RendererFactory2, Sanitizer, SkipSelf, StaticProvider, Testability, ɵINJECTOR_SCOPE as INJECTOR_SCOPE, ɵsetDocument} from '@angular/core';\n\nimport {BrowserDomAdapter} from './browser/browser_adapter';\nimport {SERVER_TRANSITION_PROVIDERS, TRANSITION_ID} from './browser/server-transition';\nimport {BrowserGetTestability} from './browser/testability';\nimport {BrowserXhr} from './browser/xhr';\nimport {ELEMENT_PROBE_PROVIDERS} from './dom/debug/ng_probe';\nimport {DomRendererFactory2} from './dom/dom_renderer';\nimport {DomEventsPlugin} from './dom/events/dom_events';\nimport {EVENT_MANAGER_PLUGINS, EventManager} from './dom/events/event_manager';\nimport {HAMMER_PROVIDERS} from './dom/events/hammer_gestures';\nimport {KeyEventsPlugin} from './dom/events/key_events';\nimport {DomSharedStylesHost, SharedStylesHost} from './dom/shared_styles_host';\nimport {DomSanitizer, DomSanitizerImpl} from './security/dom_sanitization_service';\n\nexport function initDomAdapter() {\n  BrowserDomAdapter.makeCurrent();\n  BrowserGetTestability.init();\n}\n\nexport function errorHandler(): ErrorHandler {\n  return new ErrorHandler();\n}\n\nexport function _document(): any {\n  // Tell ivy about the global document\n  ɵsetDocument(document);\n  return document;\n}\n\nexport const INTERNAL_BROWSER_PLATFORM_PROVIDERS: StaticProvider[] = [\n  {provide: PLATFORM_ID, useValue: PLATFORM_BROWSER_ID},\n  {provide: PLATFORM_INITIALIZER, useValue: initDomAdapter, multi: true},\n  {provide: DOCUMENT, useFactory: _document, deps: []},\n];\n\nconst BROWSER_SANITIZATION_PROVIDERS__PRE_R3__: StaticProvider[] = [\n  {provide: Sanitizer, useExisting: DomSanitizer},\n  {provide: DomSanitizer, useClass: DomSanitizerImpl, deps: [DOCUMENT]},\n];\n\nexport const BROWSER_SANITIZATION_PROVIDERS__POST_R3__ = [];\n\n/**\n * @security Replacing built-in sanitization providers exposes the application to XSS risks.\n * Attacker-controlled data introduced by an unsanitized provider could expose your\n * application to XSS risks. For more detail, see the [Security Guide](https://g.co/ng/security).\n * @publicApi\n */\nexport const BROWSER_SANITIZATION_PROVIDERS = BROWSER_SANITIZATION_PROVIDERS__PRE_R3__;\n\n/**\n * A factory function that returns a `PlatformRef` instance associated with browser service\n * providers.\n *\n * @publicApi\n */\nexport const platformBrowser: (extraProviders?: StaticProvider[]) => PlatformRef =\n    createPlatformFactory(platformCore, 'browser', INTERNAL_BROWSER_PLATFORM_PROVIDERS);\n\nexport const BROWSER_MODULE_PROVIDERS: StaticProvider[] = [\n  BROWSER_SANITIZATION_PROVIDERS,\n  {provide: INJECTOR_SCOPE, useValue: 'root'},\n  {provide: ErrorHandler, useFactory: errorHandler, deps: []},\n  {\n    provide: EVENT_MANAGER_PLUGINS,\n    useClass: DomEventsPlugin,\n    multi: true,\n    deps: [DOCUMENT, NgZone, PLATFORM_ID]\n  },\n  {provide: EVENT_MANAGER_PLUGINS, useClass: KeyEventsPlugin, multi: true, deps: [DOCUMENT]},\n  HAMMER_PROVIDERS,\n  {\n    provide: DomRendererFactory2,\n    useClass: DomRendererFactory2,\n    deps: [EventManager, DomSharedStylesHost, APP_ID]\n  },\n  {provide: RendererFactory2, useExisting: DomRendererFactory2},\n  {provide: SharedStylesHost, useExisting: DomSharedStylesHost},\n  {provide: DomSharedStylesHost, useClass: DomSharedStylesHost, deps: [DOCUMENT]},\n  {provide: Testability, useClass: Testability, deps: [NgZone]},\n  {provide: EventManager, useClass: EventManager, deps: [EVENT_MANAGER_PLUGINS, NgZone]},\n  {provide: XhrFactory, useClass: BrowserXhr, deps: []},\n  ELEMENT_PROBE_PROVIDERS,\n];\n\n/**\n * Exports required infrastructure for all Angular apps.\n * Included by default in all Angular apps created with the CLI\n * `new` command.\n * Re-exports `CommonModule` and `ApplicationModule`, making their\n * exports and providers available to all apps.\n *\n * @publicApi\n */\n@NgModule({providers: BROWSER_MODULE_PROVIDERS, exports: [CommonModule, ApplicationModule]})\nexport class BrowserModule {\n  constructor(@Optional() @SkipSelf() @Inject(BrowserModule) parentModule: BrowserModule|null) {\n    if (parentModule) {\n      throw new Error(\n          `BrowserModule has already been loaded. If you need access to common directives such as NgIf and NgFor from a lazy loaded module, import CommonModule instead.`);\n    }\n  }\n\n  /**\n   * Configures a browser-based app to transition from a server-rendered app, if\n   * one is present on the page.\n   *\n   * @param params An object containing an identifier for the app to transition.\n   * The ID must match between the client and server versions of the app.\n   * @returns The reconfigured `BrowserModule` to import into the app's root `AppModule`.\n   */\n  static withServerTransition(params: {appId: string}): ModuleWithProviders<BrowserModule> {\n    return {\n      ngModule: BrowserModule,\n      providers: [\n        {provide: APP_ID, useValue: params.appId},\n        {provide: TRANSITION_ID, useExisting: APP_ID},\n        SERVER_TRANSITION_PROVIDERS,\n      ],\n    };\n  }\n}\n"]}

package/esm2020/src/dom/debug/ng_probe.mjs

@@ -0,0 +1,54 @@
+/**
+ * @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 { APP_INITIALIZER, ApplicationRef, NgProbeToken, NgZone, Optional, ɵgetDebugNodeR2 } from '@angular/core';
+import { exportNgVar } from '../util';
+const CORE_TOKENS = (() => ({
+    'ApplicationRef': ApplicationRef,
+    'NgZone': NgZone,
+}))();
+const INSPECT_GLOBAL_NAME = 'probe';
+const CORE_TOKENS_GLOBAL_NAME = 'coreTokens';
+/**
+ * Returns a {@link DebugElement} for the given native DOM element, or
+ * null if the given native element does not have an Angular view associated
+ * with it.
+ */
+export function inspectNativeElementR2(element) {
+    return ɵgetDebugNodeR2(element);
+}
+export function _createNgProbeR2(coreTokens) {
+    exportNgVar(INSPECT_GLOBAL_NAME, inspectNativeElementR2);
+    exportNgVar(CORE_TOKENS_GLOBAL_NAME, { ...CORE_TOKENS, ..._ngProbeTokensToMap(coreTokens || []) });
+    return () => inspectNativeElementR2;
+}
+function _ngProbeTokensToMap(tokens) {
+    return tokens.reduce((prev, t) => (prev[t.name] = t.token, prev), {});
+}
+/**
+ * In Ivy, we don't support NgProbe because we have our own set of testing utilities
+ * with more robust functionality.
+ *
+ * We shouldn't bring in NgProbe because it prevents DebugNode and friends from
+ * tree-shaking properly.
+ */
+export const ELEMENT_PROBE_PROVIDERS__POST_R3__ = [];
+/**
+ * Providers which support debugging Angular applications (e.g. via `ng.probe`).
+ */
+export const ELEMENT_PROBE_PROVIDERS__PRE_R3__ = [
+    {
+        provide: APP_INITIALIZER,
+        useFactory: _createNgProbeR2,
+        deps: [
+            [NgProbeToken, new Optional()],
+        ],
+        multi: true,
+    },
+];
+export const ELEMENT_PROBE_PROVIDERS = ELEMENT_PROBE_PROVIDERS__POST_R3__;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/dom/dom_renderer.mjs

@@ -0,0 +1,310 @@
+/**
+ * @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 { APP_ID, Inject, Injectable, RendererStyleFlags2, ViewEncapsulation } from '@angular/core';
+import { EventManager } from './events/event_manager';
+import { DomSharedStylesHost } from './shared_styles_host';
+import * as i0 from "@angular/core";
+import * as i1 from "./events/event_manager";
+import * as i2 from "./shared_styles_host";
+export const NAMESPACE_URIS = {
+    'svg': 'http://www.w3.org/2000/svg',
+    'xhtml': 'http://www.w3.org/1999/xhtml',
+    'xlink': 'http://www.w3.org/1999/xlink',
+    'xml': 'http://www.w3.org/XML/1998/namespace',
+    'xmlns': 'http://www.w3.org/2000/xmlns/',
+};
+const COMPONENT_REGEX = /%COMP%/g;
+const NG_DEV_MODE = typeof ngDevMode === 'undefined' || !!ngDevMode;
+export const COMPONENT_VARIABLE = '%COMP%';
+export const HOST_ATTR = `_nghost-${COMPONENT_VARIABLE}`;
+export const CONTENT_ATTR = `_ngcontent-${COMPONENT_VARIABLE}`;
+export function shimContentAttribute(componentShortId) {
+    return CONTENT_ATTR.replace(COMPONENT_REGEX, componentShortId);
+}
+export function shimHostAttribute(componentShortId) {
+    return HOST_ATTR.replace(COMPONENT_REGEX, componentShortId);
+}
+export function flattenStyles(compId, styles, target) {
+    for (let i = 0; i < styles.length; i++) {
+        let style = styles[i];
+        if (Array.isArray(style)) {
+            flattenStyles(compId, style, target);
+        }
+        else {
+            style = style.replace(COMPONENT_REGEX, compId);
+            target.push(style);
+        }
+    }
+    return target;
+}
+function decoratePreventDefault(eventHandler) {
+    // `DebugNode.triggerEventHandler` needs to know if the listener was created with
+    // decoratePreventDefault or is a listener added outside the Angular context so it can handle the
+    // two differently. In the first case, the special '__ngUnwrap__' token is passed to the unwrap
+    // the listener (see below).
+    return (event) => {
+        // Ivy uses '__ngUnwrap__' as a special token that allows us to unwrap the function
+        // so that it can be invoked programmatically by `DebugNode.triggerEventHandler`. The debug_node
+        // can inspect the listener toString contents for the existence of this special token. Because
+        // the token is a string literal, it is ensured to not be modified by compiled code.
+        if (event === '__ngUnwrap__') {
+            return eventHandler;
+        }
+        const allowDefaultBehavior = eventHandler(event);
+        if (allowDefaultBehavior === false) {
+            // TODO(tbosch): move preventDefault into event plugins...
+            event.preventDefault();
+            event.returnValue = false;
+        }
+        return undefined;
+    };
+}
+let hasLoggedNativeEncapsulationWarning = false;
+export class DomRendererFactory2 {
+    constructor(eventManager, sharedStylesHost, appId) {
+        this.eventManager = eventManager;
+        this.sharedStylesHost = sharedStylesHost;
+        this.appId = appId;
+        this.rendererByCompId = new Map();
+        this.defaultRenderer = new DefaultDomRenderer2(eventManager);
+    }
+    createRenderer(element, type) {
+        if (!element || !type) {
+            return this.defaultRenderer;
+        }
+        switch (type.encapsulation) {
+            case ViewEncapsulation.Emulated: {
+                let renderer = this.rendererByCompId.get(type.id);
+                if (!renderer) {
+                    renderer = new EmulatedEncapsulationDomRenderer2(this.eventManager, this.sharedStylesHost, type, this.appId);
+                    this.rendererByCompId.set(type.id, renderer);
+                }
+                renderer.applyToHost(element);
+                return renderer;
+            }
+            // @ts-ignore TODO: Remove as part of FW-2290. TS complains about us dealing with an enum
+            // value that is not known (but previously was the value for ViewEncapsulation.Native)
+            case 1:
+            case ViewEncapsulation.ShadowDom:
+                // TODO(FW-2290): remove the `case 1:` fallback logic and the warning in v12.
+                if ((typeof ngDevMode === 'undefined' || ngDevMode) &&
+                    // @ts-ignore TODO: Remove as part of FW-2290. TS complains about us dealing with an
+                    // enum value that is not known (but previously was the value for
+                    // ViewEncapsulation.Native)
+                    !hasLoggedNativeEncapsulationWarning && type.encapsulation === 1) {
+                    hasLoggedNativeEncapsulationWarning = true;
+                    console.warn('ViewEncapsulation.Native is no longer supported. Falling back to ViewEncapsulation.ShadowDom. The fallback will be removed in v12.');
+                }
+                return new ShadowDomRenderer(this.eventManager, this.sharedStylesHost, element, type);
+            default: {
+                if (!this.rendererByCompId.has(type.id)) {
+                    const styles = flattenStyles(type.id, type.styles, []);
+                    this.sharedStylesHost.addStyles(styles);
+                    this.rendererByCompId.set(type.id, this.defaultRenderer);
+                }
+                return this.defaultRenderer;
+            }
+        }
+    }
+    begin() { }
+    end() { }
+}
+DomRendererFactory2.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.11", ngImport: i0, type: DomRendererFactory2, deps: [{ token: i1.EventManager }, { token: i2.DomSharedStylesHost }, { token: APP_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+DomRendererFactory2.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.11", ngImport: i0, type: DomRendererFactory2 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.11", ngImport: i0, type: DomRendererFactory2, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.EventManager }, { type: i2.DomSharedStylesHost }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [APP_ID]
+                }] }]; } });
+class DefaultDomRenderer2 {
+    constructor(eventManager) {
+        this.eventManager = eventManager;
+        this.data = Object.create(null);
+        this.destroyNode = null;
+    }
+    destroy() { }
+    createElement(name, namespace) {
+        if (namespace) {
+            // In cases where Ivy (not ViewEngine) is giving us the actual namespace, the look up by key
+            // will result in undefined, so we just return the namespace here.
+            return document.createElementNS(NAMESPACE_URIS[namespace] || namespace, name);
+        }
+        return document.createElement(name);
+    }
+    createComment(value) {
+        return document.createComment(value);
+    }
+    createText(value) {
+        return document.createTextNode(value);
+    }
+    appendChild(parent, newChild) {
+        parent.appendChild(newChild);
+    }
+    insertBefore(parent, newChild, refChild) {
+        if (parent) {
+            parent.insertBefore(newChild, refChild);
+        }
+    }
+    removeChild(parent, oldChild) {
+        if (parent) {
+            parent.removeChild(oldChild);
+        }
+    }
+    selectRootElement(selectorOrNode, preserveContent) {
+        let el = typeof selectorOrNode === 'string' ? document.querySelector(selectorOrNode) :
+            selectorOrNode;
+        if (!el) {
+            throw new Error(`The selector "${selectorOrNode}" did not match any elements`);
+        }
+        if (!preserveContent) {
+            el.textContent = '';
+        }
+        return el;
+    }
+    parentNode(node) {
+        return node.parentNode;
+    }
+    nextSibling(node) {
+        return node.nextSibling;
+    }
+    setAttribute(el, name, value, namespace) {
+        if (namespace) {
+            name = namespace + ':' + name;
+            // TODO(FW-811): Ivy may cause issues here because it's passing around
+            // full URIs for namespaces, therefore this lookup will fail.
+            const namespaceUri = NAMESPACE_URIS[namespace];
+            if (namespaceUri) {
+                el.setAttributeNS(namespaceUri, name, value);
+            }
+            else {
+                el.setAttribute(name, value);
+            }
+        }
+        else {
+            el.setAttribute(name, value);
+        }
+    }
+    removeAttribute(el, name, namespace) {
+        if (namespace) {
+            // TODO(FW-811): Ivy may cause issues here because it's passing around
+            // full URIs for namespaces, therefore this lookup will fail.
+            const namespaceUri = NAMESPACE_URIS[namespace];
+            if (namespaceUri) {
+                el.removeAttributeNS(namespaceUri, name);
+            }
+            else {
+                // TODO(FW-811): Since ivy is passing around full URIs for namespaces
+                // this could result in properties like `http://www.w3.org/2000/svg:cx="123"`,
+                // which is wrong.
+                el.removeAttribute(`${namespace}:${name}`);
+            }
+        }
+        else {
+            el.removeAttribute(name);
+        }
+    }
+    addClass(el, name) {
+        el.classList.add(name);
+    }
+    removeClass(el, name) {
+        el.classList.remove(name);
+    }
+    setStyle(el, style, value, flags) {
+        if (flags & (RendererStyleFlags2.DashCase | RendererStyleFlags2.Important)) {
+            el.style.setProperty(style, value, flags & RendererStyleFlags2.Important ? 'important' : '');
+        }
+        else {
+            el.style[style] = value;
+        }
+    }
+    removeStyle(el, style, flags) {
+        if (flags & RendererStyleFlags2.DashCase) {
+            el.style.removeProperty(style);
+        }
+        else {
+            // IE requires '' instead of null
+            // see https://github.com/angular/angular/issues/7916
+            el.style[style] = '';
+        }
+    }
+    setProperty(el, name, value) {
+        NG_DEV_MODE && checkNoSyntheticProp(name, 'property');
+        el[name] = value;
+    }
+    setValue(node, value) {
+        node.nodeValue = value;
+    }
+    listen(target, event, callback) {
+        NG_DEV_MODE && checkNoSyntheticProp(event, 'listener');
+        if (typeof target === 'string') {
+            return this.eventManager.addGlobalEventListener(target, event, decoratePreventDefault(callback));
+        }
+        return this.eventManager.addEventListener(target, event, decoratePreventDefault(callback));
+    }
+}
+const AT_CHARCODE = (() => '@'.charCodeAt(0))();
+function checkNoSyntheticProp(name, nameKind) {
+    if (name.charCodeAt(0) === AT_CHARCODE) {
+        throw new Error(`Unexpected synthetic ${nameKind} ${name} found. Please make sure that:
+  - Either \`BrowserAnimationsModule\` or \`NoopAnimationsModule\` are imported in your application.
+  - There is corresponding configuration for the animation named \`${name}\` defined in the \`animations\` field of the \`@Component\` decorator (see https://angular.io/api/core/Component#animations).`);
+    }
+}
+class EmulatedEncapsulationDomRenderer2 extends DefaultDomRenderer2 {
+    constructor(eventManager, sharedStylesHost, component, appId) {
+        super(eventManager);
+        this.component = component;
+        const styles = flattenStyles(appId + '-' + component.id, component.styles, []);
+        sharedStylesHost.addStyles(styles);
+        this.contentAttr = shimContentAttribute(appId + '-' + component.id);
+        this.hostAttr = shimHostAttribute(appId + '-' + component.id);
+    }
+    applyToHost(element) {
+        super.setAttribute(element, this.hostAttr, '');
+    }
+    createElement(parent, name) {
+        const el = super.createElement(parent, name);
+        super.setAttribute(el, this.contentAttr, '');
+        return el;
+    }
+}
+class ShadowDomRenderer extends DefaultDomRenderer2 {
+    constructor(eventManager, sharedStylesHost, hostEl, component) {
+        super(eventManager);
+        this.sharedStylesHost = sharedStylesHost;
+        this.hostEl = hostEl;
+        this.shadowRoot = hostEl.attachShadow({ mode: 'open' });
+        this.sharedStylesHost.addHost(this.shadowRoot);
+        const styles = flattenStyles(component.id, component.styles, []);
+        for (let i = 0; i < styles.length; i++) {
+            const styleEl = document.createElement('style');
+            styleEl.textContent = styles[i];
+            this.shadowRoot.appendChild(styleEl);
+        }
+    }
+    nodeOrShadowRoot(node) {
+        return node === this.hostEl ? this.shadowRoot : node;
+    }
+    destroy() {
+        this.sharedStylesHost.removeHost(this.shadowRoot);
+    }
+    appendChild(parent, newChild) {
+        return super.appendChild(this.nodeOrShadowRoot(parent), newChild);
+    }
+    insertBefore(parent, newChild, refChild) {
+        return super.insertBefore(this.nodeOrShadowRoot(parent), newChild, refChild);
+    }
+    removeChild(parent, oldChild) {
+        return super.removeChild(this.nodeOrShadowRoot(parent), oldChild);
+    }
+    parentNode(node) {
+        return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(node)));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dom_renderer.js","sourceRoot":"","sources":["../../../../../../../packages/platform-browser/src/dom/dom_renderer.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 {APP_ID, Inject, Injectable, Renderer2, RendererFactory2, RendererStyleFlags2, RendererType2, ViewEncapsulation} from '@angular/core';\n\nimport {EventManager} from './events/event_manager';\nimport {DomSharedStylesHost} from './shared_styles_host';\n\nexport const NAMESPACE_URIS: {[ns: string]: string} = {\n  'svg': 'http://www.w3.org/2000/svg',\n  'xhtml': 'http://www.w3.org/1999/xhtml',\n  'xlink': 'http://www.w3.org/1999/xlink',\n  'xml': 'http://www.w3.org/XML/1998/namespace',\n  'xmlns': 'http://www.w3.org/2000/xmlns/',\n};\n\nconst COMPONENT_REGEX = /%COMP%/g;\nconst NG_DEV_MODE = typeof ngDevMode === 'undefined' || !!ngDevMode;\n\nexport const COMPONENT_VARIABLE = '%COMP%';\nexport const HOST_ATTR = `_nghost-${COMPONENT_VARIABLE}`;\nexport const CONTENT_ATTR = `_ngcontent-${COMPONENT_VARIABLE}`;\n\nexport function shimContentAttribute(componentShortId: string): string {\n  return CONTENT_ATTR.replace(COMPONENT_REGEX, componentShortId);\n}\n\nexport function shimHostAttribute(componentShortId: string): string {\n  return HOST_ATTR.replace(COMPONENT_REGEX, componentShortId);\n}\n\nexport function flattenStyles(\n    compId: string, styles: Array<any|any[]>, target: string[]): string[] {\n  for (let i = 0; i < styles.length; i++) {\n    let style = styles[i];\n\n    if (Array.isArray(style)) {\n      flattenStyles(compId, style, target);\n    } else {\n      style = style.replace(COMPONENT_REGEX, compId);\n      target.push(style);\n    }\n  }\n  return target;\n}\n\nfunction decoratePreventDefault(eventHandler: Function): Function {\n  // `DebugNode.triggerEventHandler` needs to know if the listener was created with\n  // decoratePreventDefault or is a listener added outside the Angular context so it can handle the\n  // two differently. In the first case, the special '__ngUnwrap__' token is passed to the unwrap\n  // the listener (see below).\n  return (event: any) => {\n    // Ivy uses '__ngUnwrap__' as a special token that allows us to unwrap the function\n    // so that it can be invoked programmatically by `DebugNode.triggerEventHandler`. The debug_node\n    // can inspect the listener toString contents for the existence of this special token. Because\n    // the token is a string literal, it is ensured to not be modified by compiled code.\n    if (event === '__ngUnwrap__') {\n      return eventHandler;\n    }\n\n    const allowDefaultBehavior = eventHandler(event);\n    if (allowDefaultBehavior === false) {\n      // TODO(tbosch): move preventDefault into event plugins...\n      event.preventDefault();\n      event.returnValue = false;\n    }\n\n    return undefined;\n  };\n}\n\nlet hasLoggedNativeEncapsulationWarning = false;\n\n@Injectable()\nexport class DomRendererFactory2 implements RendererFactory2 {\n  private rendererByCompId = new Map<string, Renderer2>();\n  private defaultRenderer: Renderer2;\n\n  constructor(\n      private eventManager: EventManager, private sharedStylesHost: DomSharedStylesHost,\n      @Inject(APP_ID) private appId: string) {\n    this.defaultRenderer = new DefaultDomRenderer2(eventManager);\n  }\n\n  createRenderer(element: any, type: RendererType2|null): Renderer2 {\n    if (!element || !type) {\n      return this.defaultRenderer;\n    }\n    switch (type.encapsulation) {\n      case ViewEncapsulation.Emulated: {\n        let renderer = this.rendererByCompId.get(type.id);\n        if (!renderer) {\n          renderer = new EmulatedEncapsulationDomRenderer2(\n              this.eventManager, this.sharedStylesHost, type, this.appId);\n          this.rendererByCompId.set(type.id, renderer);\n        }\n        (<EmulatedEncapsulationDomRenderer2>renderer).applyToHost(element);\n        return renderer;\n      }\n      // @ts-ignore TODO: Remove as part of FW-2290. TS complains about us dealing with an enum\n      // value that is not known (but previously was the value for ViewEncapsulation.Native)\n      case 1:\n      case ViewEncapsulation.ShadowDom:\n        // TODO(FW-2290): remove the `case 1:` fallback logic and the warning in v12.\n        if ((typeof ngDevMode === 'undefined' || ngDevMode) &&\n            // @ts-ignore TODO: Remove as part of FW-2290. TS complains about us dealing with an\n            // enum value that is not known (but previously was the value for\n            // ViewEncapsulation.Native)\n            !hasLoggedNativeEncapsulationWarning && type.encapsulation === 1) {\n          hasLoggedNativeEncapsulationWarning = true;\n          console.warn(\n              'ViewEncapsulation.Native is no longer supported. Falling back to ViewEncapsulation.ShadowDom. The fallback will be removed in v12.');\n        }\n\n        return new ShadowDomRenderer(this.eventManager, this.sharedStylesHost, element, type);\n      default: {\n        if (!this.rendererByCompId.has(type.id)) {\n          const styles = flattenStyles(type.id, type.styles, []);\n          this.sharedStylesHost.addStyles(styles);\n          this.rendererByCompId.set(type.id, this.defaultRenderer);\n        }\n        return this.defaultRenderer;\n      }\n    }\n  }\n\n  begin() {}\n  end() {}\n}\n\nclass DefaultDomRenderer2 implements Renderer2 {\n  data: {[key: string]: any} = Object.create(null);\n\n  constructor(private eventManager: EventManager) {}\n\n  destroy(): void {}\n\n  destroyNode = null;\n\n  createElement(name: string, namespace?: string): any {\n    if (namespace) {\n      // In cases where Ivy (not ViewEngine) is giving us the actual namespace, the look up by key\n      // will result in undefined, so we just return the namespace here.\n      return document.createElementNS(NAMESPACE_URIS[namespace] || namespace, name);\n    }\n\n    return document.createElement(name);\n  }\n\n  createComment(value: string): any {\n    return document.createComment(value);\n  }\n\n  createText(value: string): any {\n    return document.createTextNode(value);\n  }\n\n  appendChild(parent: any, newChild: any): void {\n    parent.appendChild(newChild);\n  }\n\n  insertBefore(parent: any, newChild: any, refChild: any): void {\n    if (parent) {\n      parent.insertBefore(newChild, refChild);\n    }\n  }\n\n  removeChild(parent: any, oldChild: any): void {\n    if (parent) {\n      parent.removeChild(oldChild);\n    }\n  }\n\n  selectRootElement(selectorOrNode: string|any, preserveContent?: boolean): any {\n    let el: any = typeof selectorOrNode === 'string' ? document.querySelector(selectorOrNode) :\n                                                       selectorOrNode;\n    if (!el) {\n      throw new Error(`The selector \"${selectorOrNode}\" did not match any elements`);\n    }\n    if (!preserveContent) {\n      el.textContent = '';\n    }\n    return el;\n  }\n\n  parentNode(node: any): any {\n    return node.parentNode;\n  }\n\n  nextSibling(node: any): any {\n    return node.nextSibling;\n  }\n\n  setAttribute(el: any, name: string, value: string, namespace?: string): void {\n    if (namespace) {\n      name = namespace + ':' + name;\n      // TODO(FW-811): Ivy may cause issues here because it's passing around\n      // full URIs for namespaces, therefore this lookup will fail.\n      const namespaceUri = NAMESPACE_URIS[namespace];\n      if (namespaceUri) {\n        el.setAttributeNS(namespaceUri, name, value);\n      } else {\n        el.setAttribute(name, value);\n      }\n    } else {\n      el.setAttribute(name, value);\n    }\n  }\n\n  removeAttribute(el: any, name: string, namespace?: string): void {\n    if (namespace) {\n      // TODO(FW-811): Ivy may cause issues here because it's passing around\n      // full URIs for namespaces, therefore this lookup will fail.\n      const namespaceUri = NAMESPACE_URIS[namespace];\n      if (namespaceUri) {\n        el.removeAttributeNS(namespaceUri, name);\n      } else {\n        // TODO(FW-811): Since ivy is passing around full URIs for namespaces\n        // this could result in properties like `http://www.w3.org/2000/svg:cx=\"123\"`,\n        // which is wrong.\n        el.removeAttribute(`${namespace}:${name}`);\n      }\n    } else {\n      el.removeAttribute(name);\n    }\n  }\n\n  addClass(el: any, name: string): void {\n    el.classList.add(name);\n  }\n\n  removeClass(el: any, name: string): void {\n    el.classList.remove(name);\n  }\n\n  setStyle(el: any, style: string, value: any, flags: RendererStyleFlags2): void {\n    if (flags & (RendererStyleFlags2.DashCase | RendererStyleFlags2.Important)) {\n      el.style.setProperty(style, value, flags & RendererStyleFlags2.Important ? 'important' : '');\n    } else {\n      el.style[style] = value;\n    }\n  }\n\n  removeStyle(el: any, style: string, flags: RendererStyleFlags2): void {\n    if (flags & RendererStyleFlags2.DashCase) {\n      el.style.removeProperty(style);\n    } else {\n      // IE requires '' instead of null\n      // see https://github.com/angular/angular/issues/7916\n      el.style[style] = '';\n    }\n  }\n\n  setProperty(el: any, name: string, value: any): void {\n    NG_DEV_MODE && checkNoSyntheticProp(name, 'property');\n    el[name] = value;\n  }\n\n  setValue(node: any, value: string): void {\n    node.nodeValue = value;\n  }\n\n  listen(target: 'window'|'document'|'body'|any, event: string, callback: (event: any) => boolean):\n      () => void {\n    NG_DEV_MODE && checkNoSyntheticProp(event, 'listener');\n    if (typeof target === 'string') {\n      return <() => void>this.eventManager.addGlobalEventListener(\n          target, event, decoratePreventDefault(callback));\n    }\n    return <() => void>this.eventManager.addEventListener(\n               target, event, decoratePreventDefault(callback)) as () => void;\n  }\n}\n\nconst AT_CHARCODE = (() => '@'.charCodeAt(0))();\nfunction checkNoSyntheticProp(name: string, nameKind: string) {\n  if (name.charCodeAt(0) === AT_CHARCODE) {\n    throw new Error(`Unexpected synthetic ${nameKind} ${name} found. Please make sure that:\n  - Either \\`BrowserAnimationsModule\\` or \\`NoopAnimationsModule\\` are imported in your application.\n  - There is corresponding configuration for the animation named \\`${\n        name}\\` defined in the \\`animations\\` field of the \\`@Component\\` decorator (see https://angular.io/api/core/Component#animations).`);\n  }\n}\n\nclass EmulatedEncapsulationDomRenderer2 extends DefaultDomRenderer2 {\n  private contentAttr: string;\n  private hostAttr: string;\n\n  constructor(\n      eventManager: EventManager, sharedStylesHost: DomSharedStylesHost,\n      private component: RendererType2, appId: string) {\n    super(eventManager);\n    const styles = flattenStyles(appId + '-' + component.id, component.styles, []);\n    sharedStylesHost.addStyles(styles);\n\n    this.contentAttr = shimContentAttribute(appId + '-' + component.id);\n    this.hostAttr = shimHostAttribute(appId + '-' + component.id);\n  }\n\n  applyToHost(element: any) {\n    super.setAttribute(element, this.hostAttr, '');\n  }\n\n  override createElement(parent: any, name: string): Element {\n    const el = super.createElement(parent, name);\n    super.setAttribute(el, this.contentAttr, '');\n    return el;\n  }\n}\n\nclass ShadowDomRenderer extends DefaultDomRenderer2 {\n  private shadowRoot: any;\n\n  constructor(\n      eventManager: EventManager, private sharedStylesHost: DomSharedStylesHost,\n      private hostEl: any, component: RendererType2) {\n    super(eventManager);\n    this.shadowRoot = (hostEl as any).attachShadow({mode: 'open'});\n    this.sharedStylesHost.addHost(this.shadowRoot);\n    const styles = flattenStyles(component.id, component.styles, []);\n    for (let i = 0; i < styles.length; i++) {\n      const styleEl = document.createElement('style');\n      styleEl.textContent = styles[i];\n      this.shadowRoot.appendChild(styleEl);\n    }\n  }\n\n  private nodeOrShadowRoot(node: any): any {\n    return node === this.hostEl ? this.shadowRoot : node;\n  }\n\n  override destroy() {\n    this.sharedStylesHost.removeHost(this.shadowRoot);\n  }\n\n  override appendChild(parent: any, newChild: any): void {\n    return super.appendChild(this.nodeOrShadowRoot(parent), newChild);\n  }\n  override insertBefore(parent: any, newChild: any, refChild: any): void {\n    return super.insertBefore(this.nodeOrShadowRoot(parent), newChild, refChild);\n  }\n  override removeChild(parent: any, oldChild: any): void {\n    return super.removeChild(this.nodeOrShadowRoot(parent), oldChild);\n  }\n  override parentNode(node: any): any {\n    return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(node)));\n  }\n}\n"]}