/**
 * @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 { EnvironmentInjector } from '../di/r3_injector';
import { validateMatchingNode } from '../hydration/error_handling';
import { CONTAINERS } from '../hydration/interfaces';
import { hasInSkipHydrationBlockFlag, isInSkipHydrationBlock } from '../hydration/skip_hydration';
import { getSegmentHead, isDisconnectedNode, markRNodeAsClaimedByHydration } from '../hydration/utils';
import { findMatchingDehydratedView, locateDehydratedViewsInContainer } from '../hydration/views';
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, DEHYDRATED_VIEWS, NATIVE, VIEW_REFS } from '../render3/interfaces/container';
import { isLContainer } from '../render3/interfaces/type_checks';
import { HEADER_OFFSET, HYDRATION, PARENT, RENDERER, T_HOST, TVIEW } from '../render3/interfaces/view';
import { assertTNodeType } from '../render3/node_assert';
import { destroyLView, detachView, 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 { addLViewToLContainer } from '../render3/view_manipulation';
import { ViewRef as R3ViewRef } from '../render3/view_ref';
import { addToArray, removeFromArray } from '../util/array_utils';
import { assertDefined, assertEqual, assertGreaterThan, assertLessThan, throwError } from '../util/assert';
import { createElementRef } from './element_ref';
/**
 * 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-hierarchy).
 *
 * @usageNotes
 *
 * The example below demonstrates how the `createComponent` function can be used
 * to create an instance of a ComponentRef dynamically and attach it to an ApplicationRef,
 * so that it gets included into change detection cycles.
 *
 * Note: the example uses standalone components, but the function can also be used for
 * non-standalone components (declared in an NgModule) as well.
 *
 * ```typescript
 * @Component({
 *   standalone: true,
 *   selector: 'dynamic',
 *   template: `<span>This is a content of a dynamic component.</span>`,
 * })
 * class DynamicComponent {
 *   vcr = inject(ViewContainerRef);
 * }
 *
 * @Component({
 *   standalone: true,
 *   selector: 'app',
 *   template: `<main>Hi! This is the main content.</main>`,
 * })
 * class AppComponent {
 *   vcr = inject(ViewContainerRef);
 *
 *   ngAfterViewInit() {
 *     const compRef = this.vcr.createComponent(DynamicComponent);
 *     compRef.changeDetectorRef.detectChanges();
 *   }
 * }
 * ```
 *
 * @see {@link ComponentRef}
 * @see {@link EmbeddedViewRef}
 *
 * @publicApi
 */
export class ViewContainerRef {
    /**
     * @internal
     * @nocollapse
     */
    static { this.__NG_ELEMENT_ID__ = injectViewContainerRef; }
}
/**
 * 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;
// TODO(alxhub): cleaning up this indirection triggers a subtle bug in Closure in g3. Once the fix
// for that lands, this can be cleaned up.
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 /* NodeInjectorOffset.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, indexOrOptions) {
        let index;
        let injector;
        if (typeof indexOrOptions === 'number') {
            index = indexOrOptions;
        }
        else if (indexOrOptions != null) {
            index = indexOrOptions.index;
            injector = indexOrOptions.injector;
        }
        const hydrationInfo = findMatchingDehydratedView(this._lContainer, templateRef.ssrId);
        const viewRef = templateRef.createEmbeddedViewImpl(context || {}, injector, hydrationInfo);
        // If there is a matching dehydrated view, but the host TNode is located in the skip
        // hydration block, this means that the content was detached (as a part of the skip
        // hydration logic) and it needs to be appended into the DOM.
        const skipDomInsertion = !!hydrationInfo && !hasInSkipHydrationBlockFlag(this._hostTNode);
        this.insertImpl(viewRef, index, skipDomInsertion);
        return viewRef;
    }
    createComponent(componentFactoryOrType, indexOrOptions, injector, projectableNodes, environmentInjector) {
        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 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 || {});
            if (ngDevMode && options.environmentInjector && options.ngModuleRef) {
                throwError(`Cannot pass both environmentInjector and ngModuleRef options to createComponent().`);
            }
            index = options.index;
            injector = options.injector;
            projectableNodes = options.projectableNodes;
            environmentInjector = options.environmentInjector || options.ngModuleRef;
        }
        const componentFactory = isComponentFactory ?
            componentFactoryOrType :
            new R3ComponentFactory(getComponentDef(componentFactoryOrType));
        const contextInjector = injector || this.parentInjector;
        // If an `NgModuleRef` is not provided explicitly, try retrieving it from the DI tree.
        if (!environmentInjector && componentFactory.ngModule == null) {
            // For the `ComponentFactory` case, entering this logic is very unlikely, since we expect that
            // an instance of a `ComponentFactory`, resolved via `ComponentFactoryResolver` would have an
            // `ngModule` field. This is possible in some test scenarios and potentially in some JIT-based
            // use-cases. For the `ComponentFactory` case we preserve backwards-compatibility and try
            // using a provided injector first, then fall back to the parent injector of this
            // `ViewContainerRef` instance.
            //
            // For the factory-less case, it's critical to establish a connection with the module
            // injector tree (by retrieving an instance of an `NgModuleRef` and accessing its injector),
            // so that a component can use DI tokens provided in MgModules. For this reason, we can not
            // rely on the provided injector, since it might be detached from the DI tree (for example, if
            // it was created via `Injector.create` without specifying a parent injector, or if an
            // injector is retrieved from an `NgModuleRef` created via `createNgModule` using an
            // NgModule outside of a module tree). Instead, we always use `ViewContainerRef`'s parent
            // injector, which is normally connected to the DI tree, which includes module injector
            // subtree.
            const _injector = isComponentFactory ? contextInjector : this.parentInjector;
            // DO NOT REFACTOR. The code here used to have a `injector.get(NgModuleRef, null) ||
            // 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 = _injector.get(EnvironmentInjector, null);
            if (result) {
                environmentInjector = result;
            }
        }
        const componentDef = getComponentDef(componentFactory.componentType ?? {});
        const dehydratedView = findMatchingDehydratedView(this._lContainer, componentDef?.id ?? null);
        const rNode = dehydratedView?.firstChild ?? null;
        const componentRef = componentFactory.create(contextInjector, projectableNodes, rNode, environmentInjector);
        // If there is a matching dehydrated view, but the host TNode is located in the skip
        // hydration block, this means that the content was detached (as a part of the skip
        // hydration logic) and it needs to be appended into the DOM.
        const skipDomInsertion = !!dehydratedView && !hasInSkipHydrationBlockFlag(this._hostTNode);
        this.insertImpl(componentRef.hostView, index, skipDomInsertion);
        return componentRef;
    }
    insert(viewRef, index) {
        return this.insertImpl(viewRef, index, false);
    }
    insertImpl(viewRef, index, skipDomInsertion) {
        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;
        addLViewToLContainer(lContainer, lView, adjustedIdx, !skipDomInsertion);
        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 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 /* TNodeType.AnyContainer */ | 3 /* TNodeType.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 {
        // An LContainer anchor can not be `null`, but we set it here temporarily
        // and update to the actual value later in this function (see
        // `_locateOrCreateAnchorNode`).
        lContainer = createLContainer(slotValue, hostLView, null, hostTNode);
        hostLView[hostTNode.index] = lContainer;
        addToViewTree(hostLView, lContainer);
    }
    _locateOrCreateAnchorNode(lContainer, hostLView, hostTNode, slotValue);
    return new R3ViewContainerRef(lContainer, hostTNode, hostLView);
}
/**
 * Creates and inserts a comment node that acts as an anchor for a view container.
 *
 * 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.
 */
function insertAnchorNode(hostLView, hostTNode) {
    const renderer = hostLView[RENDERER];
    ngDevMode && ngDevMode.rendererCreateComment++;
    const commentNode = renderer.createComment(ngDevMode ? 'container' : '');
    const hostNative = getNativeByTNode(hostTNode, hostLView);
    const parentOfHostNative = nativeParentNode(renderer, hostNative);
    nativeInsertBefore(renderer, parentOfHostNative, commentNode, nativeNextSibling(renderer, hostNative), false);
    return commentNode;
}
let _locateOrCreateAnchorNode = createAnchorNode;
/**
 * Regular creation mode: an anchor is created and
 * assigned to the `lContainer[NATIVE]` slot.
 */
function createAnchorNode(lContainer, hostLView, hostTNode, slotValue) {
    // We already have a native element (anchor) set, return.
    if (lContainer[NATIVE])
        return;
    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 /* TNodeType.ElementContainer */) {
        commentNode = unwrapRNode(slotValue);
    }
    else {
        commentNode = insertAnchorNode(hostLView, hostTNode);
    }
    lContainer[NATIVE] = commentNode;
}
/**
 * Hydration logic that looks up:
 *  - an anchor node in the DOM and stores the node in `lContainer[NATIVE]`
 *  - all dehydrated views in this container and puts them into `lContainer[DEHYDRATED_VIEWS]`
 */
function locateOrCreateAnchorNode(lContainer, hostLView, hostTNode, slotValue) {
    // We already have a native element (anchor) set and the process
    // of finding dehydrated views happened (so the `lContainer[DEHYDRATED_VIEWS]`
    // is not null), exit early.
    if (lContainer[NATIVE] && lContainer[DEHYDRATED_VIEWS])
        return;
    const hydrationInfo = hostLView[HYDRATION];
    const noOffsetIndex = hostTNode.index - HEADER_OFFSET;
    // TODO(akushnir): this should really be a single condition, refactor the code
    // to use `hasInSkipHydrationBlockFlag` logic inside `isInSkipHydrationBlock`.
    const skipHydration = isInSkipHydrationBlock(hostTNode) || hasInSkipHydrationBlockFlag(hostTNode);
    const isNodeCreationMode = !hydrationInfo || skipHydration || isDisconnectedNode(hydrationInfo, noOffsetIndex);
    // Regular creation mode.
    if (isNodeCreationMode) {
        return createAnchorNode(lContainer, hostLView, hostTNode, slotValue);
    }
    // Hydration mode, looking up an anchor node and dehydrated views in DOM.
    const currentRNode = getSegmentHead(hydrationInfo, noOffsetIndex);
    const serializedViews = hydrationInfo.data[CONTAINERS]?.[noOffsetIndex];
    ngDevMode &&
        assertDefined(serializedViews, 'Unexpected state: no hydration info available for a given TNode, ' +
            'which represents a view container.');
    const [commentNode, dehydratedViews] = locateDehydratedViewsInContainer(currentRNode, serializedViews);
    if (ngDevMode) {
        validateMatchingNode(commentNode, Node.COMMENT_NODE, null, hostLView, hostTNode, true);
        // Do not throw in case this node is already claimed (thus `false` as a second
        // argument). If this container is created based on an `<ng-template>`, the comment
        // node would be already claimed from the `template` instruction. If an element acts
        // as an anchor (e.g. <div #vcRef>), a separate comment node would be created/located,
        // so we need to claim it here.
        markRNodeAsClaimedByHydration(commentNode, false);
    }
    lContainer[NATIVE] = commentNode;
    lContainer[DEHYDRATED_VIEWS] = dehydratedViews;
}
export function enableLocateOrCreateContainerRefImpl() {
    _locateOrCreateAnchorNode = locateOrCreateAnchorNode;
}
//# 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 {EnvironmentInjector} from '../di/r3_injector';\nimport {validateMatchingNode} from '../hydration/error_handling';\nimport {CONTAINERS} from '../hydration/interfaces';\nimport {hasInSkipHydrationBlockFlag, isInSkipHydrationBlock} from '../hydration/skip_hydration';\nimport {getSegmentHead, isDisconnectedNode, markRNodeAsClaimedByHydration} from '../hydration/utils';\nimport {findMatchingDehydratedView, locateDehydratedViewsInContainer} from '../hydration/views';\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, DEHYDRATED_VIEWS, LContainer, NATIVE, VIEW_REFS} from '../render3/interfaces/container';\nimport {NodeInjectorOffset} from '../render3/interfaces/injector';\nimport {TContainerNode, TDirectiveHostNode, TElementContainerNode, TElementNode, TNode, TNodeType} from '../render3/interfaces/node';\nimport {RComment, RNode} from '../render3/interfaces/renderer_dom';\nimport {isLContainer} from '../render3/interfaces/type_checks';\nimport {HEADER_OFFSET, HYDRATION, LView, PARENT, RENDERER, T_HOST, TVIEW} from '../render3/interfaces/view';\nimport {assertTNodeType} from '../render3/node_assert';\nimport {destroyLView, detachView, 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 {addLViewToLContainer} from '../render3/view_manipulation';\nimport {ViewRef as R3ViewRef} from '../render3/view_ref';\nimport {addToArray, removeFromArray} from '../util/array_utils';\nimport {assertDefined, assertEqual, assertGreaterThan, assertLessThan, throwError} from '../util/assert';\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/**\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-hierarchy).\n *\n * @usageNotes\n *\n * The example below demonstrates how the `createComponent` function can be used\n * to create an instance of a ComponentRef dynamically and attach it to an ApplicationRef,\n * so that it gets included into change detection cycles.\n *\n * Note: the example uses standalone components, but the function can also be used for\n * non-standalone components (declared in an NgModule) as well.\n *\n * ```typescript\n * @Component({\n *   standalone: true,\n *   selector: 'dynamic',\n *   template: `<span>This is a content of a dynamic component.</span>`,\n * })\n * class DynamicComponent {\n *   vcr = inject(ViewContainerRef);\n * }\n *\n * @Component({\n *   standalone: true,\n *   selector: 'app',\n *   template: `<main>Hi! This is the main content.</main>`,\n * })\n * class AppComponent {\n *   vcr = inject(ViewContainerRef);\n *\n *   ngAfterViewInit() {\n *     const compRef = this.vcr.createComponent(DynamicComponent);\n *     compRef.changeDetectorRef.detectChanges();\n *   }\n * }\n * ```\n *\n * @see {@link ComponentRef}\n * @see {@link 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 options Extra configuration for the created view. Includes:\n   *  * 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   *  * injector: Injector to be used within the embedded view.\n   *\n   * @returns The `ViewRef` instance for the newly created view.\n   */\n  abstract createEmbeddedView<C>(templateRef: TemplateRef<C>, context?: C, options?: {\n    index?: number,\n    injector?: Injector\n  }): EmbeddedViewRef<C>;\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   *  * environmentInjector: an EnvironmentInjector which will provide the component's environment.\n   *                 you should almost always provide this to ensure that all expected providers\n   *                 are available for the component instantiation. This option is intended to\n   *                 replace the `ngModuleRef` parameter.\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    environmentInjector?: EnvironmentInjector|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[][],\n      environmentInjector?: EnvironmentInjector|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 = injectViewContainerRef;\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\n// TODO(alxhub): cleaning up this indirection triggers a subtle bug in Closure in g3. Once the fix\n// for that lands, this can be cleaned up.\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, options?: {\n    index?: number,\n    injector?: Injector\n  }): EmbeddedViewRef<C>;\n  override createEmbeddedView<C>(templateRef: TemplateRef<C>, context?: C, index?: number):\n      EmbeddedViewRef<C>;\n  override createEmbeddedView<C>(templateRef: TemplateRef<C>, context?: C, indexOrOptions?: number|{\n    index?: number,\n    injector?: Injector\n  }): EmbeddedViewRef<C> {\n    let index: number|undefined;\n    let injector: Injector|undefined;\n\n    if (typeof indexOrOptions === 'number') {\n      index = indexOrOptions;\n    } else if (indexOrOptions != null) {\n      index = indexOrOptions.index;\n      injector = indexOrOptions.injector;\n    }\n\n    const hydrationInfo = findMatchingDehydratedView(this._lContainer, templateRef.ssrId);\n    const viewRef = templateRef.createEmbeddedViewImpl(context || <any>{}, injector, hydrationInfo);\n    // If there is a matching dehydrated view, but the host TNode is located in the skip\n    // hydration block, this means that the content was detached (as a part of the skip\n    // hydration logic) and it needs to be appended into the DOM.\n    const skipDomInsertion = !!hydrationInfo && !hasInSkipHydrationBlockFlag(this._hostTNode);\n    this.insertImpl(viewRef, index, skipDomInsertion);\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      environmentInjector?: EnvironmentInjector|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        environmentInjector?: EnvironmentInjector|NgModuleRef<unknown>,\n        projectableNodes?: Node[][],\n      },\n      injector?: Injector|undefined, projectableNodes?: any[][]|undefined,\n      environmentInjector?: EnvironmentInjector|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 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        environmentInjector?: EnvironmentInjector | NgModuleRef<unknown>,\n        projectableNodes?: Node[][],\n      };\n      if (ngDevMode && options.environmentInjector && options.ngModuleRef) {\n        throwError(\n            `Cannot pass both environmentInjector and ngModuleRef options to createComponent().`);\n      }\n      index = options.index;\n      injector = options.injector;\n      projectableNodes = options.projectableNodes;\n      environmentInjector = options.environmentInjector || 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\n    // If an `NgModuleRef` is not provided explicitly, try retrieving it from the DI tree.\n    if (!environmentInjector && (componentFactory as any).ngModule == null) {\n      // For the `ComponentFactory` case, entering this logic is very unlikely, since we expect that\n      // an instance of a `ComponentFactory`, resolved via `ComponentFactoryResolver` would have an\n      // `ngModule` field. This is possible in some test scenarios and potentially in some JIT-based\n      // use-cases. For the `ComponentFactory` case we preserve backwards-compatibility and try\n      // using a provided injector first, then fall back to the parent injector of this\n      // `ViewContainerRef` instance.\n      //\n      // For the factory-less case, it's critical to establish a connection with the module\n      // injector tree (by retrieving an instance of an `NgModuleRef` and accessing its injector),\n      // so that a component can use DI tokens provided in MgModules. For this reason, we can not\n      // rely on the provided injector, since it might be detached from the DI tree (for example, if\n      // it was created via `Injector.create` without specifying a parent injector, or if an\n      // injector is retrieved from an `NgModuleRef` created via `createNgModule` using an\n      // NgModule outside of a module tree). Instead, we always use `ViewContainerRef`'s parent\n      // injector, which is normally connected to the DI tree, which includes module injector\n      // subtree.\n      const _injector = isComponentFactory ? contextInjector : this.parentInjector;\n\n      // DO NOT REFACTOR. The code here used to have a `injector.get(NgModuleRef, null) ||\n      // undefined` expression which seems to cause internal google apps to fail. This is documented\n      // in the following internal bug issue: go/b/142967802\n      const result = _injector.get(EnvironmentInjector, null);\n      if (result) {\n        environmentInjector = result;\n      }\n    }\n\n    const componentDef = getComponentDef(componentFactory.componentType ?? {});\n    const dehydratedView = findMatchingDehydratedView(this._lContainer, componentDef?.id ?? null);\n    const rNode = dehydratedView?.firstChild ?? null;\n    const componentRef =\n        componentFactory.create(contextInjector, projectableNodes, rNode, environmentInjector);\n    // If there is a matching dehydrated view, but the host TNode is located in the skip\n    // hydration block, this means that the content was detached (as a part of the skip\n    // hydration logic) and it needs to be appended into the DOM.\n    const skipDomInsertion = !!dehydratedView && !hasInSkipHydrationBlockFlag(this._hostTNode);\n    this.insertImpl(componentRef.hostView, index, skipDomInsertion);\n    return componentRef;\n  }\n\n  override insert(viewRef: ViewRef, index?: number): ViewRef {\n    return this.insertImpl(viewRef, index, false);\n  }\n\n  private insertImpl(viewRef: ViewRef, index?: number, skipDomInsertion?: boolean): 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\n    addLViewToLContainer(lContainer, lView, adjustedIdx, !skipDomInsertion);\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 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    // An LContainer anchor can not be `null`, but we set it here temporarily\n    // and update to the actual value later in this function (see\n    // `_locateOrCreateAnchorNode`).\n    lContainer = createLContainer(slotValue, hostLView, null!, hostTNode);\n    hostLView[hostTNode.index] = lContainer;\n    addToViewTree(hostLView, lContainer);\n  }\n  _locateOrCreateAnchorNode(lContainer, hostLView, hostTNode, slotValue);\n\n  return new R3ViewContainerRef(lContainer, hostTNode, hostLView);\n}\n\n/**\n * Creates and inserts a comment node that acts as an anchor for a view container.\n *\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 */\nfunction insertAnchorNode(hostLView: LView, hostTNode: TNode): RComment {\n  const renderer = hostLView[RENDERER];\n  ngDevMode && ngDevMode.rendererCreateComment++;\n  const 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), false);\n  return commentNode;\n}\n\nlet _locateOrCreateAnchorNode = createAnchorNode;\n\n/**\n * Regular creation mode: an anchor is created and\n * assigned to the `lContainer[NATIVE]` slot.\n */\nfunction createAnchorNode(\n    lContainer: LContainer, hostLView: LView, hostTNode: TNode, slotValue: any) {\n  // We already have a native element (anchor) set, return.\n  if (lContainer[NATIVE]) return;\n\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    commentNode = insertAnchorNode(hostLView, hostTNode);\n  }\n  lContainer[NATIVE] = commentNode;\n}\n\n/**\n * Hydration logic that looks up:\n *  - an anchor node in the DOM and stores the node in `lContainer[NATIVE]`\n *  - all dehydrated views in this container and puts them into `lContainer[DEHYDRATED_VIEWS]`\n */\nfunction locateOrCreateAnchorNode(\n    lContainer: LContainer, hostLView: LView, hostTNode: TNode, slotValue: any) {\n  // We already have a native element (anchor) set and the process\n  // of finding dehydrated views happened (so the `lContainer[DEHYDRATED_VIEWS]`\n  // is not null), exit early.\n  if (lContainer[NATIVE] && lContainer[DEHYDRATED_VIEWS]) return;\n\n  const hydrationInfo = hostLView[HYDRATION];\n  const noOffsetIndex = hostTNode.index - HEADER_OFFSET;\n\n  // TODO(akushnir): this should really be a single condition, refactor the code\n  // to use `hasInSkipHydrationBlockFlag` logic inside `isInSkipHydrationBlock`.\n  const skipHydration = isInSkipHydrationBlock(hostTNode) || hasInSkipHydrationBlockFlag(hostTNode);\n\n  const isNodeCreationMode =\n      !hydrationInfo || skipHydration || isDisconnectedNode(hydrationInfo, noOffsetIndex);\n\n  // Regular creation mode.\n  if (isNodeCreationMode) {\n    return createAnchorNode(lContainer, hostLView, hostTNode, slotValue);\n  }\n\n  // Hydration mode, looking up an anchor node and dehydrated views in DOM.\n  const currentRNode: RNode|null = getSegmentHead(hydrationInfo, noOffsetIndex);\n\n  const serializedViews = hydrationInfo.data[CONTAINERS]?.[noOffsetIndex];\n  ngDevMode &&\n      assertDefined(\n          serializedViews,\n          'Unexpected state: no hydration info available for a given TNode, ' +\n              'which represents a view container.');\n\n  const [commentNode, dehydratedViews] =\n      locateDehydratedViewsInContainer(currentRNode!, serializedViews!);\n\n  if (ngDevMode) {\n    validateMatchingNode(commentNode, Node.COMMENT_NODE, null, hostLView, hostTNode, true);\n    // Do not throw in case this node is already claimed (thus `false` as a second\n    // argument). If this container is created based on an `<ng-template>`, the comment\n    // node would be already claimed from the `template` instruction. If an element acts\n    // as an anchor (e.g. <div #vcRef>), a separate comment node would be created/located,\n    // so we need to claim it here.\n    markRNodeAsClaimedByHydration(commentNode, false);\n  }\n\n  lContainer[NATIVE] = commentNode as RComment;\n  lContainer[DEHYDRATED_VIEWS] = dehydratedViews;\n}\n\nexport function enableLocateOrCreateContainerRefImpl() {\n  _locateOrCreateAnchorNode = locateOrCreateAnchorNode;\n}\n"]}