@angular/core 13.0.0-next.7 → 13.0.0-rc.1

package/{esm2015/src/linker/ng_module_factory_registration.js → esm2020/src/linker/ng_module_factory_registration.mjs}

@@ -54,6 +54,6 @@ export function clearModulesForTest() {
     modules.clear();
 }
 export function getRegisteredNgModuleType(id) {
-    return modules.get(id) || autoRegisterModuleById[id];
+    return (modules.get(id) || autoRegisterModuleById[id]);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/src/linker/template_ref.js → esm2020/src/linker/template_ref.mjs}

@@ -15,7 +15,7 @@ import { noop } from '../util/noop';
 import { createElementRef } from './element_ref';
 export const SWITCH_TEMPLATE_REF_FACTORY__POST_R3__ = injectTemplateRef;
 const SWITCH_TEMPLATE_REF_FACTORY__PRE_R3__ = noop;
-const SWITCH_TEMPLATE_REF_FACTORY = SWITCH_TEMPLATE_REF_FACTORY__PRE_R3__;
+const SWITCH_TEMPLATE_REF_FACTORY = SWITCH_TEMPLATE_REF_FACTORY__POST_R3__;
 /**
  * Represents an embedded template that can be used to instantiate embedded views.
  * To instantiate embedded views based on a template, use the `ViewContainerRef`
@@ -85,4 +85,4 @@ export function createTemplateRef(hostTNode, hostLView) {
     }
     return null;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template_ref.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/linker/template_ref.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,gBAAgB,EAAC,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAC,WAAW,EAAE,UAAU,EAAC,MAAM,gCAAgC,CAAC;AAEvE,OAAO,EAAC,sBAAsB,EAAqB,OAAO,EAAQ,MAAM,4BAA4B,CAAC;AACrG,OAAO,EAAC,eAAe,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAC,aAAa,EAAC,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAC,IAAI,EAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAC,gBAAgB,EAAa,MAAM,eAAe,CAAC;AAK3D,MAAM,CAAC,MAAM,sCAAsC,GAAG,iBAAiB,CAAC;AACxE,MAAM,qCAAqC,GAAG,IAAI,CAAC;AACnD,MAAM,2BAA2B,GAA6B,qCAAqC,CAAC;AAEpG;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAgB,WAAW;;AAwB/B;;;GAGG;AACI,6BAAiB,GAAiC,2BAA2B,CAAC;AAGvF,MAAM,qBAAqB,GAAG,WAAW,CAAC;AAE1C,MAAM,aAAa,GAAG,MAAM,WAAe,SAAQ,qBAAwB;IACzE,YACY,iBAAwB,EAAU,sBAAsC,EACzE,UAAsB;QAC/B,KAAK,EAAE,CAAC;QAFE,sBAAiB,GAAjB,iBAAiB,CAAO;QAAU,2BAAsB,GAAtB,sBAAsB,CAAgB;QACzE,eAAU,GAAV,UAAU,CAAY;IAEjC,CAAC;IAEQ,kBAAkB,CAAC,OAAU;QACpC,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,CAAC,MAAe,CAAC;QAClE,MAAM,aAAa,GAAG,WAAW,CAC7B,IAAI,CAAC,iBAAiB,EAAE,aAAa,EAAE,OAAO,wBAA0B,IAAI,EAC5E,aAAa,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QAErD,MAAM,qBAAqB,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;QACxF,SAAS,IAAI,gBAAgB,CAAC,qBAAqB,CAAC,CAAC;QACrD,aAAa,CAAC,sBAAsB,CAAC,GAAG,qBAAqB,CAAC;QAE9D,MAAM,uBAAuB,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAChE,IAAI,uBAAuB,KAAK,IAAI,EAAE;YACpC,aAAa,CAAC,OAAO,CAAC,GAAG,uBAAuB,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;SACpF;QAED,UAAU,CAAC,aAAa,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;QAElD,OAAO,IAAI,UAAU,CAAI,aAAa,CAAC,CAAC;IAC1C,CAAC;CACF,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,iBAAiB,CAAI,eAAe,EAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;AAC9D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAI,SAAgB,EAAE,SAAgB;IACrE,IAAI,SAAS,CAAC,IAAI,oBAAsB,EAAE;QACxC,SAAS,IAAI,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC;QACxE,OAAO,IAAI,aAAa,CACpB,SAAS,EAAE,SAA2B,EAAE,gBAAgB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC;KACrF;IACD,OAAO,IAAI,CAAC;AACd,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 {assertLContainer} from '../render3/assert';\nimport {createLView, renderView} from '../render3/instructions/shared';\nimport {TContainerNode, TNode, TNodeType} from '../render3/interfaces/node';\nimport {DECLARATION_LCONTAINER, LView, LViewFlags, QUERIES, TView} from '../render3/interfaces/view';\nimport {getCurrentTNode, getLView} from '../render3/state';\nimport {ViewRef as R3_ViewRef} from '../render3/view_ref';\nimport {assertDefined} from '../util/assert';\nimport {noop} from '../util/noop';\nimport {createElementRef, ElementRef} from './element_ref';\nimport {EmbeddedViewRef} from './view_ref';\n\n\n\nexport const SWITCH_TEMPLATE_REF_FACTORY__POST_R3__ = injectTemplateRef;\nconst SWITCH_TEMPLATE_REF_FACTORY__PRE_R3__ = noop;\nconst SWITCH_TEMPLATE_REF_FACTORY: typeof injectTemplateRef = SWITCH_TEMPLATE_REF_FACTORY__PRE_R3__;\n\n/**\n * Represents an embedded template that can be used to instantiate embedded views.\n * To instantiate embedded views based on a template, use the `ViewContainerRef`\n * method `createEmbeddedView()`.\n *\n * Access a `TemplateRef` instance by placing a directive on an `<ng-template>`\n * element (or directive prefixed with `*`). The `TemplateRef` for the embedded view\n * is injected into the constructor of the directive,\n * using the `TemplateRef` token.\n *\n * You can also use a `Query` to find a `TemplateRef` associated with\n * a component or a directive.\n *\n * @see `ViewContainerRef`\n * @see [Navigate the Component Tree with DI](guide/dependency-injection-navtree)\n *\n * @publicApi\n */\nexport abstract class TemplateRef<C> {\n  /**\n   * The anchor element in the parent view for this embedded view.\n   *\n   * The data-binding and injection contexts of embedded views created from this `TemplateRef`\n   * inherit from the contexts of this location.\n   *\n   * Typically new embedded views are attached to the view container of this location, but in\n   * advanced use-cases, the view can be attached to a different container while keeping the\n   * data-binding and injection context from the original location.\n   *\n   */\n  // TODO(i): rename to anchor or location\n  abstract get elementRef(): ElementRef;\n\n  /**\n   * Instantiates an embedded view based on this template,\n   * and attaches it to the view container.\n   * @param context The data-binding context of the embedded view, as declared\n   * in the `<ng-template>` usage.\n   * @returns The new embedded view object.\n   */\n  abstract createEmbeddedView(context: C): EmbeddedViewRef<C>;\n\n  /**\n   * @internal\n   * @nocollapse\n   */\n  static __NG_ELEMENT_ID__: () => TemplateRef<any>| null = SWITCH_TEMPLATE_REF_FACTORY;\n}\n\nconst ViewEngineTemplateRef = TemplateRef;\n\nconst R3TemplateRef = class TemplateRef<T> extends ViewEngineTemplateRef<T> {\n  constructor(\n      private _declarationLView: LView, private _declarationTContainer: TContainerNode,\n      public elementRef: ElementRef) {\n    super();\n  }\n\n  override createEmbeddedView(context: T): EmbeddedViewRef<T> {\n    const embeddedTView = this._declarationTContainer.tViews as TView;\n    const embeddedLView = createLView(\n        this._declarationLView, embeddedTView, context, LViewFlags.CheckAlways, null,\n        embeddedTView.declTNode, null, null, null, null);\n\n    const declarationLContainer = this._declarationLView[this._declarationTContainer.index];\n    ngDevMode && assertLContainer(declarationLContainer);\n    embeddedLView[DECLARATION_LCONTAINER] = declarationLContainer;\n\n    const declarationViewLQueries = this._declarationLView[QUERIES];\n    if (declarationViewLQueries !== null) {\n      embeddedLView[QUERIES] = declarationViewLQueries.createEmbeddedView(embeddedTView);\n    }\n\n    renderView(embeddedTView, embeddedLView, context);\n\n    return new R3_ViewRef<T>(embeddedLView);\n  }\n};\n\n/**\n * Creates a TemplateRef given a node.\n *\n * @returns The TemplateRef instance to use\n */\nexport function injectTemplateRef<T>(): TemplateRef<T>|null {\n  return createTemplateRef<T>(getCurrentTNode()!, getLView());\n}\n\n/**\n * Creates a TemplateRef and stores it on the injector.\n *\n * @param hostTNode The node on which a TemplateRef is requested\n * @param hostLView The `LView` to which the node belongs\n * @returns The TemplateRef instance or null if we can't create a TemplateRef on a given node type\n */\nexport function createTemplateRef<T>(hostTNode: TNode, hostLView: LView): TemplateRef<T>|null {\n  if (hostTNode.type & TNodeType.Container) {\n    ngDevMode && assertDefined(hostTNode.tViews, 'TView must be allocated');\n    return new R3TemplateRef(\n        hostLView, hostTNode as TContainerNode, createElementRef(hostTNode, hostLView));\n  }\n  return null;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template_ref.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/linker/template_ref.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,gBAAgB,EAAC,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAC,WAAW,EAAE,UAAU,EAAC,MAAM,gCAAgC,CAAC;AAEvE,OAAO,EAAC,sBAAsB,EAAqB,OAAO,EAAQ,MAAM,4BAA4B,CAAC;AACrG,OAAO,EAAC,eAAe,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAC,aAAa,EAAC,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAC,IAAI,EAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAC,gBAAgB,EAAa,MAAM,eAAe,CAAC;AAK3D,MAAM,CAAC,MAAM,sCAAsC,GAAG,iBAAiB,CAAC;AACxE,MAAM,qCAAqC,GAAG,IAAI,CAAC;AACnD,MAAM,2BAA2B,GAFpB,sCAEsF,CAAC;AAEpG;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAgB,WAAW;;AAwB/B;;;GAGG;AACI,6BAAiB,GAAiC,2BAA2B,CAAC;AAGvF,MAAM,qBAAqB,GAAG,WAAW,CAAC;AAE1C,MAAM,aAAa,GAAG,MAAM,WAAe,SAAQ,qBAAwB;IACzE,YACY,iBAAwB,EAAU,sBAAsC,EACzE,UAAsB;QAC/B,KAAK,EAAE,CAAC;QAFE,sBAAiB,GAAjB,iBAAiB,CAAO;QAAU,2BAAsB,GAAtB,sBAAsB,CAAgB;QACzE,eAAU,GAAV,UAAU,CAAY;IAEjC,CAAC;IAEQ,kBAAkB,CAAC,OAAU;QACpC,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,CAAC,MAAe,CAAC;QAClE,MAAM,aAAa,GAAG,WAAW,CAC7B,IAAI,CAAC,iBAAiB,EAAE,aAAa,EAAE,OAAO,wBAA0B,IAAI,EAC5E,aAAa,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QAErD,MAAM,qBAAqB,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;QACxF,SAAS,IAAI,gBAAgB,CAAC,qBAAqB,CAAC,CAAC;QACrD,aAAa,CAAC,sBAAsB,CAAC,GAAG,qBAAqB,CAAC;QAE9D,MAAM,uBAAuB,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAChE,IAAI,uBAAuB,KAAK,IAAI,EAAE;YACpC,aAAa,CAAC,OAAO,CAAC,GAAG,uBAAuB,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;SACpF;QAED,UAAU,CAAC,aAAa,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;QAElD,OAAO,IAAI,UAAU,CAAI,aAAa,CAAC,CAAC;IAC1C,CAAC;CACF,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,iBAAiB,CAAI,eAAe,EAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;AAC9D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAI,SAAgB,EAAE,SAAgB;IACrE,IAAI,SAAS,CAAC,IAAI,oBAAsB,EAAE;QACxC,SAAS,IAAI,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC;QACxE,OAAO,IAAI,aAAa,CACpB,SAAS,EAAE,SAA2B,EAAE,gBAAgB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC;KACrF;IACD,OAAO,IAAI,CAAC;AACd,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 {assertLContainer} from '../render3/assert';\nimport {createLView, renderView} from '../render3/instructions/shared';\nimport {TContainerNode, TNode, TNodeType} from '../render3/interfaces/node';\nimport {DECLARATION_LCONTAINER, LView, LViewFlags, QUERIES, TView} from '../render3/interfaces/view';\nimport {getCurrentTNode, getLView} from '../render3/state';\nimport {ViewRef as R3_ViewRef} from '../render3/view_ref';\nimport {assertDefined} from '../util/assert';\nimport {noop} from '../util/noop';\nimport {createElementRef, ElementRef} from './element_ref';\nimport {EmbeddedViewRef} from './view_ref';\n\n\n\nexport const SWITCH_TEMPLATE_REF_FACTORY__POST_R3__ = injectTemplateRef;\nconst SWITCH_TEMPLATE_REF_FACTORY__PRE_R3__ = noop;\nconst SWITCH_TEMPLATE_REF_FACTORY: typeof injectTemplateRef = SWITCH_TEMPLATE_REF_FACTORY__PRE_R3__;\n\n/**\n * Represents an embedded template that can be used to instantiate embedded views.\n * To instantiate embedded views based on a template, use the `ViewContainerRef`\n * method `createEmbeddedView()`.\n *\n * Access a `TemplateRef` instance by placing a directive on an `<ng-template>`\n * element (or directive prefixed with `*`). The `TemplateRef` for the embedded view\n * is injected into the constructor of the directive,\n * using the `TemplateRef` token.\n *\n * You can also use a `Query` to find a `TemplateRef` associated with\n * a component or a directive.\n *\n * @see `ViewContainerRef`\n * @see [Navigate the Component Tree with DI](guide/dependency-injection-navtree)\n *\n * @publicApi\n */\nexport abstract class TemplateRef<C> {\n  /**\n   * The anchor element in the parent view for this embedded view.\n   *\n   * The data-binding and injection contexts of embedded views created from this `TemplateRef`\n   * inherit from the contexts of this location.\n   *\n   * Typically new embedded views are attached to the view container of this location, but in\n   * advanced use-cases, the view can be attached to a different container while keeping the\n   * data-binding and injection context from the original location.\n   *\n   */\n  // TODO(i): rename to anchor or location\n  abstract get elementRef(): ElementRef;\n\n  /**\n   * Instantiates an embedded view based on this template,\n   * and attaches it to the view container.\n   * @param context The data-binding context of the embedded view, as declared\n   * in the `<ng-template>` usage.\n   * @returns The new embedded view object.\n   */\n  abstract createEmbeddedView(context: C): EmbeddedViewRef<C>;\n\n  /**\n   * @internal\n   * @nocollapse\n   */\n  static __NG_ELEMENT_ID__: () => TemplateRef<any>| null = SWITCH_TEMPLATE_REF_FACTORY;\n}\n\nconst ViewEngineTemplateRef = TemplateRef;\n\nconst R3TemplateRef = class TemplateRef<T> extends ViewEngineTemplateRef<T> {\n  constructor(\n      private _declarationLView: LView, private _declarationTContainer: TContainerNode,\n      public elementRef: ElementRef) {\n    super();\n  }\n\n  override createEmbeddedView(context: T): EmbeddedViewRef<T> {\n    const embeddedTView = this._declarationTContainer.tViews as TView;\n    const embeddedLView = createLView(\n        this._declarationLView, embeddedTView, context, LViewFlags.CheckAlways, null,\n        embeddedTView.declTNode, null, null, null, null);\n\n    const declarationLContainer = this._declarationLView[this._declarationTContainer.index];\n    ngDevMode && assertLContainer(declarationLContainer);\n    embeddedLView[DECLARATION_LCONTAINER] = declarationLContainer;\n\n    const declarationViewLQueries = this._declarationLView[QUERIES];\n    if (declarationViewLQueries !== null) {\n      embeddedLView[QUERIES] = declarationViewLQueries.createEmbeddedView(embeddedTView);\n    }\n\n    renderView(embeddedTView, embeddedLView, context);\n\n    return new R3_ViewRef<T>(embeddedLView);\n  }\n};\n\n/**\n * Creates a TemplateRef given a node.\n *\n * @returns The TemplateRef instance to use\n */\nexport function injectTemplateRef<T>(): TemplateRef<T>|null {\n  return createTemplateRef<T>(getCurrentTNode()!, getLView());\n}\n\n/**\n * Creates a TemplateRef and stores it on the injector.\n *\n * @param hostTNode The node on which a TemplateRef is requested\n * @param hostLView The `LView` to which the node belongs\n * @returns The TemplateRef instance or null if we can't create a TemplateRef on a given node type\n */\nexport function createTemplateRef<T>(hostTNode: TNode, hostLView: LView): TemplateRef<T>|null {\n  if (hostTNode.type & TNodeType.Container) {\n    ngDevMode && assertDefined(hostTNode.tViews, 'TView must be allocated');\n    return new R3TemplateRef(\n        hostLView, hostTNode as TContainerNode, createElementRef(hostTNode, hostLView));\n  }\n  return null;\n}\n"]}

package/esm2020/src/linker/view_container_ref.mjs

@@ -0,0 +1,283 @@
+import { isType } from '../interface/type';
+import { assertNodeInjector } from '../render3/assert';
+import { ComponentFactory as R3ComponentFactory } from '../render3/component_ref';
+import { getComponentDef } from '../render3/definition';
+import { getParentInjectorLocation, NodeInjector } from '../render3/di';
+import { addToViewTree, createLContainer } from '../render3/instructions/shared';
+import { CONTAINER_HEADER_OFFSET, NATIVE, VIEW_REFS } from '../render3/interfaces/container';
+import { isLContainer } from '../render3/interfaces/type_checks';
+import { PARENT, RENDERER, T_HOST, TVIEW } from '../render3/interfaces/view';
+import { assertTNodeType } from '../render3/node_assert';
+import { addViewToContainer, destroyLView, detachView, getBeforeNodeForView, insertView, nativeInsertBefore, nativeNextSibling, nativeParentNode } from '../render3/node_manipulation';
+import { getCurrentTNode, getLView } from '../render3/state';
+import { getParentInjectorIndex, getParentInjectorView, hasParentInjector } from '../render3/util/injector_utils';
+import { getNativeByTNode, unwrapRNode, viewAttachedToContainer } from '../render3/util/view_utils';
+import { ViewRef as R3ViewRef } from '../render3/view_ref';
+import { addToArray, removeFromArray } from '../util/array_utils';
+import { assertDefined, assertEqual, assertGreaterThan, assertLessThan } from '../util/assert';
+import { noop } from '../util/noop';
+import { createElementRef } from './element_ref';
+import { NgModuleRef } from './ng_module_factory';
+export const SWITCH_VIEW_CONTAINER_REF_FACTORY__POST_R3__ = injectViewContainerRef;
+const SWITCH_VIEW_CONTAINER_REF_FACTORY__PRE_R3__ = noop;
+const SWITCH_VIEW_CONTAINER_REF_FACTORY = SWITCH_VIEW_CONTAINER_REF_FACTORY__POST_R3__;
+/**
+ * Represents a container where one or more views can be attached to a component.
+ *
+ * Can contain *host views* (created by instantiating a
+ * component with the `createComponent()` method), and *embedded views*
+ * (created by instantiating a `TemplateRef` with the `createEmbeddedView()` method).
+ *
+ * A view container instance can contain other view containers,
+ * creating a [view hierarchy](guide/glossary#view-tree).
+ *
+ * @see `ComponentRef`
+ * @see `EmbeddedViewRef`
+ *
+ * @publicApi
+ */
+export class ViewContainerRef {
+}
+/**
+ * @internal
+ * @nocollapse
+ */
+ViewContainerRef.__NG_ELEMENT_ID__ = SWITCH_VIEW_CONTAINER_REF_FACTORY;
+/**
+ * Creates a ViewContainerRef and stores it on the injector. Or, if the ViewContainerRef
+ * already exists, retrieves the existing ViewContainerRef.
+ *
+ * @returns The ViewContainerRef instance to use
+ */
+export function injectViewContainerRef() {
+    const previousTNode = getCurrentTNode();
+    return createContainerRef(previousTNode, getLView());
+}
+const VE_ViewContainerRef = ViewContainerRef;
+const R3ViewContainerRef = class ViewContainerRef extends VE_ViewContainerRef {
+    constructor(_lContainer, _hostTNode, _hostLView) {
+        super();
+        this._lContainer = _lContainer;
+        this._hostTNode = _hostTNode;
+        this._hostLView = _hostLView;
+    }
+    get element() {
+        return createElementRef(this._hostTNode, this._hostLView);
+    }
+    get injector() {
+        return new NodeInjector(this._hostTNode, this._hostLView);
+    }
+    /** @deprecated No replacement */
+    get parentInjector() {
+        const parentLocation = getParentInjectorLocation(this._hostTNode, this._hostLView);
+        if (hasParentInjector(parentLocation)) {
+            const parentView = getParentInjectorView(parentLocation, this._hostLView);
+            const injectorIndex = getParentInjectorIndex(parentLocation);
+            ngDevMode && assertNodeInjector(parentView, injectorIndex);
+            const parentTNode = parentView[TVIEW].data[injectorIndex + 8 /* TNODE */];
+            return new NodeInjector(parentTNode, parentView);
+        }
+        else {
+            return new NodeInjector(null, this._hostLView);
+        }
+    }
+    clear() {
+        while (this.length > 0) {
+            this.remove(this.length - 1);
+        }
+    }
+    get(index) {
+        const viewRefs = getViewRefs(this._lContainer);
+        return viewRefs !== null && viewRefs[index] || null;
+    }
+    get length() {
+        return this._lContainer.length - CONTAINER_HEADER_OFFSET;
+    }
+    createEmbeddedView(templateRef, context, index) {
+        const viewRef = templateRef.createEmbeddedView(context || {});
+        this.insert(viewRef, index);
+        return viewRef;
+    }
+    createComponent(componentFactoryOrType, indexOrOptions, injector, projectableNodes, ngModuleRef) {
+        const isComponentFactory = componentFactoryOrType && !isType(componentFactoryOrType);
+        let index;
+        // This function supports 2 signatures and we need to handle options correctly for both:
+        //   1. When first argument is a Component type. This signature also requires extra
+        //      options to be provided as as object (more ergonomic option).
+        //   2. First argument is a Component factory. In this case extra options are represented as
+        //      positional arguments. This signature is less ergonomic and will be deprecated.
+        if (isComponentFactory) {
+            if (ngDevMode) {
+                assertEqual(typeof indexOrOptions !== 'object', true, 'It looks like Component factory was provided as the first argument ' +
+                    'and an options object as the second argument. This combination of arguments ' +
+                    'is incompatible. You can either change the first argument to provide Component ' +
+                    'type or change the second argument to be a number (representing an index at ' +
+                    'which to insert the new component\'s host view into this container)');
+            }
+            index = indexOrOptions;
+        }
+        else {
+            if (ngDevMode) {
+                assertDefined(getComponentDef(componentFactoryOrType), `Provided Component class doesn't contain Component definition. ` +
+                    `Please check whether provided class has @Component decorator.`);
+                assertEqual(typeof indexOrOptions !== 'number', true, 'It looks like Component type was provided as the first argument ' +
+                    'and a number (representing an index at which to insert the new component\'s ' +
+                    'host view into this container as the second argument. This combination of arguments ' +
+                    'is incompatible. Please use an object as the second argument instead.');
+            }
+            const options = (indexOrOptions || {});
+            index = options.index;
+            injector = options.injector;
+            projectableNodes = options.projectableNodes;
+            ngModuleRef = options.ngModuleRef;
+        }
+        const componentFactory = isComponentFactory ?
+            componentFactoryOrType :
+            new R3ComponentFactory(getComponentDef(componentFactoryOrType));
+        const contextInjector = injector || this.parentInjector;
+        if (!ngModuleRef && componentFactory.ngModule == null && contextInjector) {
+            // DO NOT REFACTOR. The code here used to have a `value || undefined` expression
+            // which seems to cause internal google apps to fail. This is documented in the
+            // following internal bug issue: go/b/142967802
+            const result = contextInjector.get(NgModuleRef, null);
+            if (result) {
+                ngModuleRef = result;
+            }
+        }
+        const componentRef = componentFactory.create(contextInjector, projectableNodes, undefined, ngModuleRef);
+        this.insert(componentRef.hostView, index);
+        return componentRef;
+    }
+    insert(viewRef, index) {
+        const lView = viewRef._lView;
+        const tView = lView[TVIEW];
+        if (ngDevMode && viewRef.destroyed) {
+            throw new Error('Cannot insert a destroyed View in a ViewContainer!');
+        }
+        if (viewAttachedToContainer(lView)) {
+            // If view is already attached, detach it first so we clean up references appropriately.
+            const prevIdx = this.indexOf(viewRef);
+            // A view might be attached either to this or a different container. The `prevIdx` for
+            // those cases will be:
+            // equal to -1 for views attached to this ViewContainerRef
+            // >= 0 for views attached to a different ViewContainerRef
+            if (prevIdx !== -1) {
+                this.detach(prevIdx);
+            }
+            else {
+                const prevLContainer = lView[PARENT];
+                ngDevMode &&
+                    assertEqual(isLContainer(prevLContainer), true, 'An attached view should have its PARENT point to a container.');
+                // We need to re-create a R3ViewContainerRef instance since those are not stored on
+                // LView (nor anywhere else).
+                const prevVCRef = new R3ViewContainerRef(prevLContainer, prevLContainer[T_HOST], prevLContainer[PARENT]);
+                prevVCRef.detach(prevVCRef.indexOf(viewRef));
+            }
+        }
+        // Logical operation of adding `LView` to `LContainer`
+        const adjustedIdx = this._adjustIndex(index);
+        const lContainer = this._lContainer;
+        insertView(tView, lView, lContainer, adjustedIdx);
+        // Physical operation of adding the DOM nodes.
+        const beforeNode = getBeforeNodeForView(adjustedIdx, lContainer);
+        const renderer = lView[RENDERER];
+        const parentRNode = nativeParentNode(renderer, lContainer[NATIVE]);
+        if (parentRNode !== null) {
+            addViewToContainer(tView, lContainer[T_HOST], renderer, lView, parentRNode, beforeNode);
+        }
+        viewRef.attachToViewContainerRef();
+        addToArray(getOrCreateViewRefs(lContainer), adjustedIdx, viewRef);
+        return viewRef;
+    }
+    move(viewRef, newIndex) {
+        if (ngDevMode && viewRef.destroyed) {
+            throw new Error('Cannot move a destroyed View in a ViewContainer!');
+        }
+        return this.insert(viewRef, newIndex);
+    }
+    indexOf(viewRef) {
+        const viewRefsArr = getViewRefs(this._lContainer);
+        return viewRefsArr !== null ? viewRefsArr.indexOf(viewRef) : -1;
+    }
+    remove(index) {
+        const adjustedIdx = this._adjustIndex(index, -1);
+        const detachedView = detachView(this._lContainer, adjustedIdx);
+        if (detachedView) {
+            // Before destroying the view, remove it from the container's array of `ViewRef`s.
+            // This ensures the view container length is updated before calling
+            // `destroyLView`, which could recursively call view container methods that
+            // rely on an accurate container length.
+            // (e.g. a method on this view container being called by a child directive's OnDestroy
+            // lifecycle hook)
+            removeFromArray(getOrCreateViewRefs(this._lContainer), adjustedIdx);
+            destroyLView(detachedView[TVIEW], detachedView);
+        }
+    }
+    detach(index) {
+        const adjustedIdx = this._adjustIndex(index, -1);
+        const view = detachView(this._lContainer, adjustedIdx);
+        const wasDetached = view && removeFromArray(getOrCreateViewRefs(this._lContainer), adjustedIdx) != null;
+        return wasDetached ? new R3ViewRef(view) : null;
+    }
+    _adjustIndex(index, shift = 0) {
+        if (index == null) {
+            return this.length + shift;
+        }
+        if (ngDevMode) {
+            assertGreaterThan(index, -1, `ViewRef index must be positive, got ${index}`);
+            // +1 because it's legal to insert at the end.
+            assertLessThan(index, this.length + 1 + shift, 'index');
+        }
+        return index;
+    }
+};
+function getViewRefs(lContainer) {
+    return lContainer[VIEW_REFS];
+}
+function getOrCreateViewRefs(lContainer) {
+    return (lContainer[VIEW_REFS] || (lContainer[VIEW_REFS] = []));
+}
+/**
+ * Creates a ViewContainerRef and stores it on the injector.
+ *
+ * @param ViewContainerRefToken The ViewContainerRef type
+ * @param ElementRefToken The ElementRef type
+ * @param hostTNode The node that is requesting a ViewContainerRef
+ * @param hostLView The view to which the node belongs
+ * @returns The ViewContainerRef instance to use
+ */
+export function createContainerRef(hostTNode, hostLView) {
+    ngDevMode && assertTNodeType(hostTNode, 12 /* AnyContainer */ | 3 /* AnyRNode */);
+    let lContainer;
+    const slotValue = hostLView[hostTNode.index];
+    if (isLContainer(slotValue)) {
+        // If the host is a container, we don't need to create a new LContainer
+        lContainer = slotValue;
+    }
+    else {
+        let commentNode;
+        // If the host is an element container, the native host element is guaranteed to be a
+        // comment and we can reuse that comment as anchor element for the new LContainer.
+        // The comment node in question is already part of the DOM structure so we don't need to append
+        // it again.
+        if (hostTNode.type & 8 /* ElementContainer */) {
+            commentNode = unwrapRNode(slotValue);
+        }
+        else {
+            // If the host is a regular element, we have to insert a comment node manually which will
+            // be used as an anchor when inserting elements. In this specific case we use low-level DOM
+            // manipulation to insert it.
+            const renderer = hostLView[RENDERER];
+            ngDevMode && ngDevMode.rendererCreateComment++;
+            commentNode = renderer.createComment(ngDevMode ? 'container' : '');
+            const hostNative = getNativeByTNode(hostTNode, hostLView);
+            const parentOfHostNative = nativeParentNode(renderer, hostNative);
+            nativeInsertBefore(renderer, parentOfHostNative, commentNode, nativeNextSibling(renderer, hostNative), false);
+        }
+        hostLView[hostTNode.index] = lContainer =
+            createLContainer(slotValue, hostLView, commentNode, hostTNode);
+        addToViewTree(hostLView, lContainer);
+    }
+    return new R3ViewContainerRef(lContainer, hostTNode, hostLView);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view_container_ref.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/linker/view_container_ref.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 {Injector} from '../di/injector';\nimport {isType, Type} from '../interface/type';\nimport {assertNodeInjector} from '../render3/assert';\nimport {ComponentFactory as R3ComponentFactory} from '../render3/component_ref';\nimport {getComponentDef} from '../render3/definition';\nimport {getParentInjectorLocation, NodeInjector} from '../render3/di';\nimport {addToViewTree, createLContainer} from '../render3/instructions/shared';\nimport {CONTAINER_HEADER_OFFSET, LContainer, NATIVE, VIEW_REFS} from '../render3/interfaces/container';\nimport {NodeInjectorOffset} from '../render3/interfaces/injector';\nimport {TContainerNode, TDirectiveHostNode, TElementContainerNode, TElementNode, TNodeType} from '../render3/interfaces/node';\nimport {RComment, RElement} from '../render3/interfaces/renderer_dom';\nimport {isLContainer} from '../render3/interfaces/type_checks';\nimport {LView, PARENT, RENDERER, T_HOST, TVIEW} from '../render3/interfaces/view';\nimport {assertTNodeType} from '../render3/node_assert';\nimport {addViewToContainer, destroyLView, detachView, getBeforeNodeForView, insertView, nativeInsertBefore, nativeNextSibling, nativeParentNode} from '../render3/node_manipulation';\nimport {getCurrentTNode, getLView} from '../render3/state';\nimport {getParentInjectorIndex, getParentInjectorView, hasParentInjector} from '../render3/util/injector_utils';\nimport {getNativeByTNode, unwrapRNode, viewAttachedToContainer} from '../render3/util/view_utils';\nimport {ViewRef as R3ViewRef} from '../render3/view_ref';\nimport {addToArray, removeFromArray} from '../util/array_utils';\nimport {assertDefined, assertEqual, assertGreaterThan, assertLessThan} from '../util/assert';\nimport {noop} from '../util/noop';\n\nimport {ComponentFactory, ComponentRef} from './component_factory';\nimport {createElementRef, ElementRef} from './element_ref';\nimport {NgModuleRef} from './ng_module_factory';\nimport {TemplateRef} from './template_ref';\nimport {EmbeddedViewRef, ViewRef} from './view_ref';\n\n\nexport const SWITCH_VIEW_CONTAINER_REF_FACTORY__POST_R3__ = injectViewContainerRef;\nconst SWITCH_VIEW_CONTAINER_REF_FACTORY__PRE_R3__ = noop as typeof injectViewContainerRef;\nconst SWITCH_VIEW_CONTAINER_REF_FACTORY: typeof injectViewContainerRef =\n    SWITCH_VIEW_CONTAINER_REF_FACTORY__PRE_R3__;\n\n/**\n * Represents a container where one or more views can be attached to a component.\n *\n * Can contain *host views* (created by instantiating a\n * component with the `createComponent()` method), and *embedded views*\n * (created by instantiating a `TemplateRef` with the `createEmbeddedView()` method).\n *\n * A view container instance can contain other view containers,\n * creating a [view hierarchy](guide/glossary#view-tree).\n *\n * @see `ComponentRef`\n * @see `EmbeddedViewRef`\n *\n * @publicApi\n */\nexport abstract class ViewContainerRef {\n  /**\n   * Anchor element that specifies the location of this container in the containing view.\n   * Each view container can have only one anchor element, and each anchor element\n   * can have only a single view container.\n   *\n   * Root elements of views attached to this container become siblings of the anchor element in\n   * the rendered view.\n   *\n   * Access the `ViewContainerRef` of an element by placing a `Directive` injected\n   * with `ViewContainerRef` on the element, or use a `ViewChild` query.\n   *\n   * <!-- TODO: rename to anchorElement -->\n   */\n  abstract get element(): ElementRef;\n\n  /**\n   * The [dependency injector](guide/glossary#injector) for this view container.\n   */\n  abstract get injector(): Injector;\n\n  /** @deprecated No replacement */\n  abstract get parentInjector(): Injector;\n\n  /**\n   * Destroys all views in this container.\n   */\n  abstract clear(): void;\n\n  /**\n   * Retrieves a view from this container.\n   * @param index The 0-based index of the view to retrieve.\n   * @returns The `ViewRef` instance, or null if the index is out of range.\n   */\n  abstract get(index: number): ViewRef|null;\n\n  /**\n   * Reports how many views are currently attached to this container.\n   * @returns The number of views.\n   */\n  abstract get length(): number;\n\n  /**\n   * Instantiates an embedded view and inserts it\n   * into this container.\n   * @param templateRef The HTML template that defines the view.\n   * @param context The data-binding context of the embedded view, as declared\n   * in the `<ng-template>` usage.\n   * @param index The 0-based index at which to insert the new view into this container.\n   * If not specified, appends the new view as the last entry.\n   *\n   * @returns The `ViewRef` instance for the newly created view.\n   */\n  abstract createEmbeddedView<C>(templateRef: TemplateRef<C>, context?: C, index?: number):\n      EmbeddedViewRef<C>;\n\n  /**\n   * Instantiates a single component and inserts its host view into this container.\n   *\n   * @param componentType Component Type to use.\n   * @param options An object that contains extra parameters:\n   *  * index: the index at which to insert the new component's host view into this container.\n   *           If not specified, appends the new view as the last entry.\n   *  * injector: the injector to use as the parent for the new component.\n   *  * ngModuleRef: an NgModuleRef of the component's NgModule, you should almost always provide\n   *                 this to ensure that all expected providers are available for the component\n   *                 instantiation.\n   *  * projectableNodes: list of DOM nodes that should be projected through\n   *                      [`<ng-content>`](api/core/ng-content) of the new component instance.\n   *\n   * @returns The new `ComponentRef` which contains the component instance and the host view.\n   */\n  abstract createComponent<C>(componentType: Type<C>, options?: {\n    index?: number,\n    injector?: Injector,\n    ngModuleRef?: NgModuleRef<unknown>,\n    projectableNodes?: Node[][],\n  }): ComponentRef<C>;\n\n  /**\n   * Instantiates a single component and inserts its host view into this container.\n   *\n   * @param componentFactory Component factory to use.\n   * @param index The index at which to insert the new component's host view into this container.\n   * If not specified, appends the new view as the last entry.\n   * @param injector The injector to use as the parent for the new component.\n   * @param projectableNodes List of DOM nodes that should be projected through\n   *     [`<ng-content>`](api/core/ng-content) of the new component instance.\n   * @param ngModuleRef An instance of the NgModuleRef that represent an NgModule.\n   * This information is used to retrieve corresponding NgModule injector.\n   *\n   * @returns The new `ComponentRef` which contains the component instance and the host view.\n   *\n   * @deprecated Angular no longer requires component factories to dynamically create components.\n   *     Use different signature of the `createComponent` method, which allows passing\n   *     Component class directly.\n   */\n  abstract createComponent<C>(\n      componentFactory: ComponentFactory<C>, index?: number, injector?: Injector,\n      projectableNodes?: any[][], ngModuleRef?: NgModuleRef<any>): ComponentRef<C>;\n\n  /**\n   * Inserts a view into this container.\n   * @param viewRef The view to insert.\n   * @param index The 0-based index at which to insert the view.\n   * If not specified, appends the new view as the last entry.\n   * @returns The inserted `ViewRef` instance.\n   *\n   */\n  abstract insert(viewRef: ViewRef, index?: number): ViewRef;\n\n  /**\n   * Moves a view to a new location in this container.\n   * @param viewRef The view to move.\n   * @param index The 0-based index of the new location.\n   * @returns The moved `ViewRef` instance.\n   */\n  abstract move(viewRef: ViewRef, currentIndex: number): ViewRef;\n\n  /**\n   * Returns the index of a view within the current container.\n   * @param viewRef The view to query.\n   * @returns The 0-based index of the view's position in this container,\n   * or `-1` if this container doesn't contain the view.\n   */\n  abstract indexOf(viewRef: ViewRef): number;\n\n  /**\n   * Destroys a view attached to this container\n   * @param index The 0-based index of the view to destroy.\n   * If not specified, the last view in the container is removed.\n   */\n  abstract remove(index?: number): void;\n\n  /**\n   * Detaches a view from this container without destroying it.\n   * Use along with `insert()` to move a view within the current container.\n   * @param index The 0-based index of the view to detach.\n   * If not specified, the last view in the container is detached.\n   */\n  abstract detach(index?: number): ViewRef|null;\n\n  /**\n   * @internal\n   * @nocollapse\n   */\n  static __NG_ELEMENT_ID__: () => ViewContainerRef = SWITCH_VIEW_CONTAINER_REF_FACTORY;\n}\n\n/**\n * Creates a ViewContainerRef and stores it on the injector. Or, if the ViewContainerRef\n * already exists, retrieves the existing ViewContainerRef.\n *\n * @returns The ViewContainerRef instance to use\n */\nexport function injectViewContainerRef(): ViewContainerRef {\n  const previousTNode = getCurrentTNode() as TElementNode | TElementContainerNode | TContainerNode;\n  return createContainerRef(previousTNode, getLView());\n}\n\nconst VE_ViewContainerRef = ViewContainerRef;\n\nconst R3ViewContainerRef = class ViewContainerRef extends VE_ViewContainerRef {\n  constructor(\n      private _lContainer: LContainer,\n      private _hostTNode: TElementNode|TContainerNode|TElementContainerNode,\n      private _hostLView: LView) {\n    super();\n  }\n\n  override get element(): ElementRef {\n    return createElementRef(this._hostTNode, this._hostLView);\n  }\n\n  override get injector(): Injector {\n    return new NodeInjector(this._hostTNode, this._hostLView);\n  }\n\n  /** @deprecated No replacement */\n  override get parentInjector(): Injector {\n    const parentLocation = getParentInjectorLocation(this._hostTNode, this._hostLView);\n    if (hasParentInjector(parentLocation)) {\n      const parentView = getParentInjectorView(parentLocation, this._hostLView);\n      const injectorIndex = getParentInjectorIndex(parentLocation);\n      ngDevMode && assertNodeInjector(parentView, injectorIndex);\n      const parentTNode =\n          parentView[TVIEW].data[injectorIndex + NodeInjectorOffset.TNODE] as TElementNode;\n      return new NodeInjector(parentTNode, parentView);\n    } else {\n      return new NodeInjector(null, this._hostLView);\n    }\n  }\n\n  override clear(): void {\n    while (this.length > 0) {\n      this.remove(this.length - 1);\n    }\n  }\n\n  override get(index: number): ViewRef|null {\n    const viewRefs = getViewRefs(this._lContainer);\n    return viewRefs !== null && viewRefs[index] || null;\n  }\n\n  override get length(): number {\n    return this._lContainer.length - CONTAINER_HEADER_OFFSET;\n  }\n\n  override createEmbeddedView<C>(templateRef: TemplateRef<C>, context?: C, index?: number):\n      EmbeddedViewRef<C> {\n    const viewRef = templateRef.createEmbeddedView(context || <any>{});\n    this.insert(viewRef, index);\n    return viewRef;\n  }\n\n  override createComponent<C>(componentType: Type<C>, options?: {\n    index?: number,\n    injector?: Injector,\n    projectableNodes?: Node[][],\n    ngModuleRef?: NgModuleRef<unknown>,\n  }): ComponentRef<C>;\n  /**\n   * @deprecated Angular no longer requires component factories to dynamically create components.\n   *     Use different signature of the `createComponent` method, which allows passing\n   *     Component class directly.\n   */\n  override createComponent<C>(\n      componentFactory: ComponentFactory<C>, index?: number|undefined,\n      injector?: Injector|undefined, projectableNodes?: any[][]|undefined,\n      ngModuleRef?: NgModuleRef<any>|undefined): ComponentRef<C>;\n  override createComponent<C>(\n      componentFactoryOrType: ComponentFactory<C>|Type<C>, indexOrOptions?: number|undefined|{\n        index?: number,\n        injector?: Injector,\n        ngModuleRef?: NgModuleRef<unknown>,\n        projectableNodes?: Node[][],\n      },\n      injector?: Injector|undefined, projectableNodes?: any[][]|undefined,\n      ngModuleRef?: NgModuleRef<any>|undefined): ComponentRef<C> {\n    const isComponentFactory = componentFactoryOrType && !isType(componentFactoryOrType);\n    let index: number|undefined;\n\n    // This function supports 2 signatures and we need to handle options correctly for both:\n    //   1. When first argument is a Component type. This signature also requires extra\n    //      options to be provided as as object (more ergonomic option).\n    //   2. First argument is a Component factory. In this case extra options are represented as\n    //      positional arguments. This signature is less ergonomic and will be deprecated.\n    if (isComponentFactory) {\n      if (ngDevMode) {\n        assertEqual(\n            typeof indexOrOptions !== 'object', true,\n            'It looks like Component factory was provided as the first argument ' +\n                'and an options object as the second argument. This combination of arguments ' +\n                'is incompatible. You can either change the first argument to provide Component ' +\n                'type or change the second argument to be a number (representing an index at ' +\n                'which to insert the new component\\'s host view into this container)');\n      }\n      index = indexOrOptions as number | undefined;\n    } else {\n      if (ngDevMode) {\n        assertDefined(\n            getComponentDef(componentFactoryOrType),\n            `Provided Component class doesn't contain Component definition. ` +\n                `Please check whether provided class has @Component decorator.`);\n        assertEqual(\n            typeof indexOrOptions !== 'number', true,\n            'It looks like Component type was provided as the first argument ' +\n                'and a number (representing an index at which to insert the new component\\'s ' +\n                'host view into this container as the second argument. This combination of arguments ' +\n                'is incompatible. Please use an object as the second argument instead.');\n      }\n      const options = (indexOrOptions || {}) as {\n        index?: number,\n        injector?: Injector,\n        ngModuleRef?: NgModuleRef<unknown>,\n        projectableNodes?: Node[][],\n      };\n      index = options.index;\n      injector = options.injector;\n      projectableNodes = options.projectableNodes;\n      ngModuleRef = options.ngModuleRef;\n    }\n\n    const componentFactory: ComponentFactory<C> = isComponentFactory ?\n        componentFactoryOrType as ComponentFactory<C>:\n        new R3ComponentFactory(getComponentDef(componentFactoryOrType)!);\n    const contextInjector = injector || this.parentInjector;\n    if (!ngModuleRef && (componentFactory as any).ngModule == null && contextInjector) {\n      // DO NOT REFACTOR. The code here used to have a `value || undefined` expression\n      // which seems to cause internal google apps to fail. This is documented in the\n      // following internal bug issue: go/b/142967802\n      const result = contextInjector.get(NgModuleRef, null);\n      if (result) {\n        ngModuleRef = result;\n      }\n    }\n\n    const componentRef =\n        componentFactory.create(contextInjector, projectableNodes, undefined, ngModuleRef);\n    this.insert(componentRef.hostView, index);\n    return componentRef;\n  }\n\n  override insert(viewRef: ViewRef, index?: number): ViewRef {\n    const lView = (viewRef as R3ViewRef<any>)._lView!;\n    const tView = lView[TVIEW];\n\n    if (ngDevMode && viewRef.destroyed) {\n      throw new Error('Cannot insert a destroyed View in a ViewContainer!');\n    }\n\n    if (viewAttachedToContainer(lView)) {\n      // If view is already attached, detach it first so we clean up references appropriately.\n\n      const prevIdx = this.indexOf(viewRef);\n\n      // A view might be attached either to this or a different container. The `prevIdx` for\n      // those cases will be:\n      // equal to -1 for views attached to this ViewContainerRef\n      // >= 0 for views attached to a different ViewContainerRef\n      if (prevIdx !== -1) {\n        this.detach(prevIdx);\n      } else {\n        const prevLContainer = lView[PARENT] as LContainer;\n        ngDevMode &&\n            assertEqual(\n                isLContainer(prevLContainer), true,\n                'An attached view should have its PARENT point to a container.');\n\n\n        // We need to re-create a R3ViewContainerRef instance since those are not stored on\n        // LView (nor anywhere else).\n        const prevVCRef = new R3ViewContainerRef(\n            prevLContainer, prevLContainer[T_HOST] as TDirectiveHostNode, prevLContainer[PARENT]);\n\n        prevVCRef.detach(prevVCRef.indexOf(viewRef));\n      }\n    }\n\n    // Logical operation of adding `LView` to `LContainer`\n    const adjustedIdx = this._adjustIndex(index);\n    const lContainer = this._lContainer;\n    insertView(tView, lView, lContainer, adjustedIdx);\n\n    // Physical operation of adding the DOM nodes.\n    const beforeNode = getBeforeNodeForView(adjustedIdx, lContainer);\n    const renderer = lView[RENDERER];\n    const parentRNode = nativeParentNode(renderer, lContainer[NATIVE] as RElement | RComment);\n    if (parentRNode !== null) {\n      addViewToContainer(tView, lContainer[T_HOST], renderer, lView, parentRNode, beforeNode);\n    }\n\n    (viewRef as R3ViewRef<any>).attachToViewContainerRef();\n    addToArray(getOrCreateViewRefs(lContainer), adjustedIdx, viewRef);\n\n    return viewRef;\n  }\n\n  override move(viewRef: ViewRef, newIndex: number): ViewRef {\n    if (ngDevMode && viewRef.destroyed) {\n      throw new Error('Cannot move a destroyed View in a ViewContainer!');\n    }\n    return this.insert(viewRef, newIndex);\n  }\n\n  override indexOf(viewRef: ViewRef): number {\n    const viewRefsArr = getViewRefs(this._lContainer);\n    return viewRefsArr !== null ? viewRefsArr.indexOf(viewRef) : -1;\n  }\n\n  override remove(index?: number): void {\n    const adjustedIdx = this._adjustIndex(index, -1);\n    const detachedView = detachView(this._lContainer, adjustedIdx);\n\n    if (detachedView) {\n      // Before destroying the view, remove it from the container's array of `ViewRef`s.\n      // This ensures the view container length is updated before calling\n      // `destroyLView`, which could recursively call view container methods that\n      // rely on an accurate container length.\n      // (e.g. a method on this view container being called by a child directive's OnDestroy\n      // lifecycle hook)\n      removeFromArray(getOrCreateViewRefs(this._lContainer), adjustedIdx);\n      destroyLView(detachedView[TVIEW], detachedView);\n    }\n  }\n\n  override detach(index?: number): ViewRef|null {\n    const adjustedIdx = this._adjustIndex(index, -1);\n    const view = detachView(this._lContainer, adjustedIdx);\n\n    const wasDetached =\n        view && removeFromArray(getOrCreateViewRefs(this._lContainer), adjustedIdx) != null;\n    return wasDetached ? new R3ViewRef(view!) : null;\n  }\n\n  private _adjustIndex(index?: number, shift: number = 0) {\n    if (index == null) {\n      return this.length + shift;\n    }\n    if (ngDevMode) {\n      assertGreaterThan(index, -1, `ViewRef index must be positive, got ${index}`);\n      // +1 because it's legal to insert at the end.\n      assertLessThan(index, this.length + 1 + shift, 'index');\n    }\n    return index;\n  }\n};\n\nfunction getViewRefs(lContainer: LContainer): ViewRef[]|null {\n  return lContainer[VIEW_REFS] as ViewRef[];\n}\n\nfunction getOrCreateViewRefs(lContainer: LContainer): ViewRef[] {\n  return (lContainer[VIEW_REFS] || (lContainer[VIEW_REFS] = [])) as ViewRef[];\n}\n\n/**\n * Creates a ViewContainerRef and stores it on the injector.\n *\n * @param ViewContainerRefToken The ViewContainerRef type\n * @param ElementRefToken The ElementRef type\n * @param hostTNode The node that is requesting a ViewContainerRef\n * @param hostLView The view to which the node belongs\n * @returns The ViewContainerRef instance to use\n */\nexport function createContainerRef(\n    hostTNode: TElementNode|TContainerNode|TElementContainerNode,\n    hostLView: LView): ViewContainerRef {\n  ngDevMode && assertTNodeType(hostTNode, TNodeType.AnyContainer | TNodeType.AnyRNode);\n\n  let lContainer: LContainer;\n  const slotValue = hostLView[hostTNode.index];\n  if (isLContainer(slotValue)) {\n    // If the host is a container, we don't need to create a new LContainer\n    lContainer = slotValue;\n  } else {\n    let commentNode: RComment;\n    // If the host is an element container, the native host element is guaranteed to be a\n    // comment and we can reuse that comment as anchor element for the new LContainer.\n    // The comment node in question is already part of the DOM structure so we don't need to append\n    // it again.\n    if (hostTNode.type & TNodeType.ElementContainer) {\n      commentNode = unwrapRNode(slotValue) as RComment;\n    } else {\n      // If the host is a regular element, we have to insert a comment node manually which will\n      // be used as an anchor when inserting elements. In this specific case we use low-level DOM\n      // manipulation to insert it.\n      const renderer = hostLView[RENDERER];\n      ngDevMode && ngDevMode.rendererCreateComment++;\n      commentNode = renderer.createComment(ngDevMode ? 'container' : '');\n\n      const hostNative = getNativeByTNode(hostTNode, hostLView)!;\n      const parentOfHostNative = nativeParentNode(renderer, hostNative);\n      nativeInsertBefore(\n          renderer, parentOfHostNative!, commentNode, nativeNextSibling(renderer, hostNative),\n          false);\n    }\n\n    hostLView[hostTNode.index] = lContainer =\n        createLContainer(slotValue, hostLView, commentNode, hostTNode);\n\n    addToViewTree(hostLView, lContainer);\n  }\n\n  return new R3ViewContainerRef(lContainer, hostTNode, hostLView);\n}\n"]}

package/esm2020/src/linker.mjs

@@ -0,0 +1,19 @@
+/**
+ * @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
+ */
+// Public API for compiler
+export { Compiler, COMPILER_OPTIONS, CompilerFactory, ModuleWithComponentFactories } from './linker/compiler';
+export { ComponentFactory, ComponentRef } from './linker/component_factory';
+export { ComponentFactoryResolver } from './linker/component_factory_resolver';
+export { ElementRef } from './linker/element_ref';
+export { NgModuleFactory, NgModuleRef } from './linker/ng_module_factory';
+export { getModuleFactory, getNgModuleById } from './linker/ng_module_factory_loader';
+export { QueryList } from './linker/query_list';
+export { TemplateRef } from './linker/template_ref';
+export { ViewContainerRef } from './linker/view_container_ref';
+export { EmbeddedViewRef, ViewRef } from './linker/view_ref';
+//# sourceMappingURL=data:application/json;base64,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