@angular/core 16.0.0-next.3 → 16.0.0-next.5

package/esm2022/src/render3/features/standalone_feature.mjs

@@ -0,0 +1,70 @@
+/**
+ * @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 { ɵɵinject as inject } from '../../di/injector_compatibility';
+import { ɵɵdefineInjectable as defineInjectable } from '../../di/interface/defs';
+import { internalImportProvidersFrom } from '../../di/provider_collection';
+import { EnvironmentInjector } from '../../di/r3_injector';
+import { createEnvironmentInjector } from '../ng_module_ref';
+/**
+ * A service used by the framework to create instances of standalone injectors. Those injectors are
+ * created on demand in case of dynamic component instantiation and contain ambient providers
+ * collected from the imports graph rooted at a given standalone component.
+ */
+class StandaloneService {
+    constructor(_injector) {
+        this._injector = _injector;
+        this.cachedInjectors = new Map();
+    }
+    getOrCreateStandaloneInjector(componentDef) {
+        if (!componentDef.standalone) {
+            return null;
+        }
+        if (!this.cachedInjectors.has(componentDef.id)) {
+            const providers = internalImportProvidersFrom(false, componentDef.type);
+            const standaloneInjector = providers.length > 0 ?
+                createEnvironmentInjector([providers], this._injector, `Standalone[${componentDef.type.name}]`) :
+                null;
+            this.cachedInjectors.set(componentDef.id, standaloneInjector);
+        }
+        return this.cachedInjectors.get(componentDef.id);
+    }
+    ngOnDestroy() {
+        try {
+            for (const injector of this.cachedInjectors.values()) {
+                if (injector !== null) {
+                    injector.destroy();
+                }
+            }
+        }
+        finally {
+            this.cachedInjectors.clear();
+        }
+    }
+    /** @nocollapse */
+    static { this.ɵprov = defineInjectable({
+        token: StandaloneService,
+        providedIn: 'environment',
+        factory: () => new StandaloneService(inject(EnvironmentInjector)),
+    }); }
+}
+/**
+ * A feature that acts as a setup code for the {@link StandaloneService}.
+ *
+ * The most important responsibility of this feature is to expose the "getStandaloneInjector"
+ * function (an entry points to a standalone injector creation) on a component definition object. We
+ * go through the features infrastructure to make sure that the standalone injector creation logic
+ * is tree-shakable and not included in applications that don't use standalone components.
+ *
+ * @codeGenApi
+ */
+export function ɵɵStandaloneFeature(definition) {
+    definition.getStandaloneInjector = (parentInjector) => {
+        return parentInjector.get(StandaloneService).getOrCreateStandaloneInjector(definition);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/render3/instructions/element.mjs

@@ -0,0 +1,205 @@
+/**
+ * @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 { invalidSkipHydrationHost, validateMatchingNode, validateNodeExists } from '../../hydration/error_handling';
+import { locateNextRNode } from '../../hydration/node_lookup_utils';
+import { hasNgSkipHydrationAttr } from '../../hydration/skip_hydration';
+import { getSerializedContainerViews, isDisconnectedNode, markRNodeAsClaimedByHydration, setSegmentHead } from '../../hydration/utils';
+import { assertDefined, assertEqual, assertIndexInRange } from '../../util/assert';
+import { assertFirstCreatePass, assertHasParent } from '../assert';
+import { attachPatchData } from '../context_discovery';
+import { registerPostOrderHooks } from '../hooks';
+import { hasClassInput, hasStyleInput } from '../interfaces/node';
+import { isComponentHost, isContentQueryHost, isDirectiveHost } from '../interfaces/type_checks';
+import { HEADER_OFFSET, HYDRATION, RENDERER } from '../interfaces/view';
+import { assertTNodeType } from '../node_assert';
+import { appendChild, clearElementContents, createElementNode, setupStaticAttributes } from '../node_manipulation';
+import { decreaseElementDepthCount, enterSkipHydrationBlock, getBindingIndex, getCurrentTNode, getElementDepthCount, getLView, getNamespace, getTView, increaseElementDepthCount, isCurrentTNodeParent, isInSkipHydrationBlock, isSkipHydrationRootTNode, lastNodeWasCreated, leaveSkipHydrationBlock, setCurrentTNode, setCurrentTNodeAsNotParent, wasLastNodeCreated } from '../state';
+import { computeStaticStyling } from '../styling/static_styling';
+import { getConstant } from '../util/view_utils';
+import { validateElementIsKnown } from './element_validation';
+import { setDirectiveInputsWhichShadowsStyling } from './property';
+import { createDirectivesInstances, executeContentQueries, getOrCreateTNode, resolveDirectives, saveResolvedLocalsInData } from './shared';
+function elementStartFirstCreatePass(index, tView, lView, name, attrsIndex, localRefsIndex) {
+    ngDevMode && assertFirstCreatePass(tView);
+    ngDevMode && ngDevMode.firstCreatePass++;
+    const tViewConsts = tView.consts;
+    const attrs = getConstant(tViewConsts, attrsIndex);
+    const tNode = getOrCreateTNode(tView, index, 2 /* TNodeType.Element */, name, attrs);
+    resolveDirectives(tView, lView, tNode, getConstant(tViewConsts, localRefsIndex));
+    if (tNode.attrs !== null) {
+        computeStaticStyling(tNode, tNode.attrs, false);
+    }
+    if (tNode.mergedAttrs !== null) {
+        computeStaticStyling(tNode, tNode.mergedAttrs, true);
+    }
+    if (tView.queries !== null) {
+        tView.queries.elementStart(tView, tNode);
+    }
+    return tNode;
+}
+/**
+ * Create DOM element. The instruction must later be followed by `elementEnd()` call.
+ *
+ * @param index Index of the element in the LView array
+ * @param name Name of the DOM Node
+ * @param attrsIndex Index of the element's attributes in the `consts` array.
+ * @param localRefsIndex Index of the element's local references in the `consts` array.
+ * @returns This function returns itself so that it may be chained.
+ *
+ * Attributes and localRefs are passed as an array of strings where elements with an even index
+ * hold an attribute name and elements with an odd index hold an attribute value, ex.:
+ * ['id', 'warning5', 'class', 'alert']
+ *
+ * @codeGenApi
+ */
+export function ɵɵelementStart(index, name, attrsIndex, localRefsIndex) {
+    const lView = getLView();
+    const tView = getTView();
+    const adjustedIndex = HEADER_OFFSET + index;
+    ngDevMode &&
+        assertEqual(getBindingIndex(), tView.bindingStartIndex, 'elements should be created before any bindings');
+    ngDevMode && assertIndexInRange(lView, adjustedIndex);
+    const renderer = lView[RENDERER];
+    const tNode = tView.firstCreatePass ?
+        elementStartFirstCreatePass(adjustedIndex, tView, lView, name, attrsIndex, localRefsIndex) :
+        tView.data[adjustedIndex];
+    const native = _locateOrCreateElementNode(tView, lView, tNode, renderer, name, index);
+    lView[adjustedIndex] = native;
+    const hasDirectives = isDirectiveHost(tNode);
+    if (ngDevMode && tView.firstCreatePass) {
+        validateElementIsKnown(native, lView, tNode.value, tView.schemas, hasDirectives);
+    }
+    setCurrentTNode(tNode, true);
+    setupStaticAttributes(renderer, native, tNode);
+    if ((tNode.flags & 32 /* TNodeFlags.isDetached */) !== 32 /* TNodeFlags.isDetached */ && wasLastNodeCreated()) {
+        // In the i18n case, the translation may have removed this element, so only add it if it is not
+        // detached. See `TNodeType.Placeholder` and `LFrame.inI18n` for more context.
+        appendChild(tView, lView, native, tNode);
+    }
+    // any immediate children of a component or template container must be pre-emptively
+    // monkey-patched with the component view data so that the element can be inspected
+    // later on using any element discovery utility methods (see `element_discovery.ts`)
+    if (getElementDepthCount() === 0) {
+        attachPatchData(native, lView);
+    }
+    increaseElementDepthCount();
+    if (hasDirectives) {
+        createDirectivesInstances(tView, lView, tNode);
+        executeContentQueries(tView, tNode, lView);
+    }
+    if (localRefsIndex !== null) {
+        saveResolvedLocalsInData(lView, tNode);
+    }
+    return ɵɵelementStart;
+}
+/**
+ * Mark the end of the element.
+ * @returns This function returns itself so that it may be chained.
+ *
+ * @codeGenApi
+ */
+export function ɵɵelementEnd() {
+    let currentTNode = getCurrentTNode();
+    ngDevMode && assertDefined(currentTNode, 'No parent node to close.');
+    if (isCurrentTNodeParent()) {
+        setCurrentTNodeAsNotParent();
+    }
+    else {
+        ngDevMode && assertHasParent(getCurrentTNode());
+        currentTNode = currentTNode.parent;
+        setCurrentTNode(currentTNode, false);
+    }
+    const tNode = currentTNode;
+    ngDevMode && assertTNodeType(tNode, 3 /* TNodeType.AnyRNode */);
+    if (isSkipHydrationRootTNode(tNode)) {
+        leaveSkipHydrationBlock();
+    }
+    decreaseElementDepthCount();
+    const tView = getTView();
+    if (tView.firstCreatePass) {
+        registerPostOrderHooks(tView, currentTNode);
+        if (isContentQueryHost(currentTNode)) {
+            tView.queries.elementEnd(currentTNode);
+        }
+    }
+    if (tNode.classesWithoutHost != null && hasClassInput(tNode)) {
+        setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.classesWithoutHost, true);
+    }
+    if (tNode.stylesWithoutHost != null && hasStyleInput(tNode)) {
+        setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.stylesWithoutHost, false);
+    }
+    return ɵɵelementEnd;
+}
+/**
+ * Creates an empty element using {@link elementStart} and {@link elementEnd}
+ *
+ * @param index Index of the element in the data array
+ * @param name Name of the DOM Node
+ * @param attrsIndex Index of the element's attributes in the `consts` array.
+ * @param localRefsIndex Index of the element's local references in the `consts` array.
+ * @returns This function returns itself so that it may be chained.
+ *
+ * @codeGenApi
+ */
+export function ɵɵelement(index, name, attrsIndex, localRefsIndex) {
+    ɵɵelementStart(index, name, attrsIndex, localRefsIndex);
+    ɵɵelementEnd();
+    return ɵɵelement;
+}
+let _locateOrCreateElementNode = (tView, lView, tNode, renderer, name, index) => {
+    lastNodeWasCreated(true);
+    return createElementNode(renderer, name, getNamespace());
+};
+/**
+ * Enables hydration code path (to lookup existing elements in DOM)
+ * in addition to the regular creation mode of element nodes.
+ */
+function locateOrCreateElementNodeImpl(tView, lView, tNode, renderer, name, index) {
+    const hydrationInfo = lView[HYDRATION];
+    const isNodeCreationMode = !hydrationInfo || isInSkipHydrationBlock() || isDisconnectedNode(hydrationInfo, index);
+    lastNodeWasCreated(isNodeCreationMode);
+    // Regular creation mode.
+    if (isNodeCreationMode) {
+        return createElementNode(renderer, name, getNamespace());
+    }
+    // Hydration mode, looking up an existing element in DOM.
+    const native = locateNextRNode(hydrationInfo, tView, lView, tNode);
+    ngDevMode && validateMatchingNode(native, Node.ELEMENT_NODE, name, lView, tNode);
+    ngDevMode && markRNodeAsClaimedByHydration(native);
+    // This element might also be an anchor of a view container.
+    if (getSerializedContainerViews(hydrationInfo, index)) {
+        // Important note: this element acts as an anchor, but it's **not** a part
+        // of the embedded view, so we start the segment **after** this element, taking
+        // a reference to the next sibling. For example, the following template:
+        // `<div #vcrTarget>` is represented in the DOM as `<div></div>...<!--container-->`,
+        // so while processing a `<div>` instruction, point to the next sibling as a
+        // start of a segment.
+        ngDevMode && validateNodeExists(native.nextSibling);
+        setSegmentHead(hydrationInfo, index, native.nextSibling);
+    }
+    // Checks if the skip hydration attribute is present during hydration so we know to
+    // skip attempting to hydrate this block.
+    if (hydrationInfo && hasNgSkipHydrationAttr(tNode)) {
+        if (isComponentHost(tNode)) {
+            enterSkipHydrationBlock(tNode);
+            // Since this isn't hydratable, we need to empty the node
+            // so there's no duplicate content after render
+            clearElementContents(native);
+        }
+        else if (ngDevMode) {
+            // If this is not a component host, throw an error.
+            // Hydration can be skipped on per-component basis only.
+            throw invalidSkipHydrationHost(native);
+        }
+    }
+    return native;
+}
+export function enableLocateOrCreateElementNodeImpl() {
+    _locateOrCreateElementNode = locateOrCreateElementNodeImpl;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"element.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/element.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 {invalidSkipHydrationHost, validateMatchingNode, validateNodeExists} from '../../hydration/error_handling';\nimport {locateNextRNode} from '../../hydration/node_lookup_utils';\nimport {hasNgSkipHydrationAttr} from '../../hydration/skip_hydration';\nimport {getSerializedContainerViews, isDisconnectedNode, markRNodeAsClaimedByHydration, setSegmentHead} from '../../hydration/utils';\nimport {assertDefined, assertEqual, assertIndexInRange} from '../../util/assert';\nimport {assertFirstCreatePass, assertHasParent} from '../assert';\nimport {attachPatchData} from '../context_discovery';\nimport {registerPostOrderHooks} from '../hooks';\nimport {hasClassInput, hasStyleInput, TAttributes, TElementNode, TNode, TNodeFlags, TNodeType} from '../interfaces/node';\nimport {Renderer} from '../interfaces/renderer';\nimport {RElement} from '../interfaces/renderer_dom';\nimport {isComponentHost, isContentQueryHost, isDirectiveHost} from '../interfaces/type_checks';\nimport {HEADER_OFFSET, HYDRATION, LView, RENDERER, TView} from '../interfaces/view';\nimport {assertTNodeType} from '../node_assert';\nimport {appendChild, clearElementContents, createElementNode, setupStaticAttributes} from '../node_manipulation';\nimport {decreaseElementDepthCount, enterSkipHydrationBlock, getBindingIndex, getCurrentTNode, getElementDepthCount, getLView, getNamespace, getTView, increaseElementDepthCount, isCurrentTNodeParent, isInSkipHydrationBlock, isSkipHydrationRootTNode, lastNodeWasCreated, leaveSkipHydrationBlock, setCurrentTNode, setCurrentTNodeAsNotParent, wasLastNodeCreated} from '../state';\nimport {computeStaticStyling} from '../styling/static_styling';\nimport {getConstant} from '../util/view_utils';\n\nimport {validateElementIsKnown} from './element_validation';\nimport {setDirectiveInputsWhichShadowsStyling} from './property';\nimport {createDirectivesInstances, executeContentQueries, getOrCreateTNode, resolveDirectives, saveResolvedLocalsInData} from './shared';\n\n\nfunction elementStartFirstCreatePass(\n    index: number, tView: TView, lView: LView, name: string, attrsIndex?: number|null,\n    localRefsIndex?: number): TElementNode {\n  ngDevMode && assertFirstCreatePass(tView);\n  ngDevMode && ngDevMode.firstCreatePass++;\n\n  const tViewConsts = tView.consts;\n  const attrs = getConstant<TAttributes>(tViewConsts, attrsIndex);\n  const tNode = getOrCreateTNode(tView, index, TNodeType.Element, name, attrs);\n\n  resolveDirectives(tView, lView, tNode, getConstant<string[]>(tViewConsts, localRefsIndex));\n\n  if (tNode.attrs !== null) {\n    computeStaticStyling(tNode, tNode.attrs, false);\n  }\n\n  if (tNode.mergedAttrs !== null) {\n    computeStaticStyling(tNode, tNode.mergedAttrs, true);\n  }\n\n  if (tView.queries !== null) {\n    tView.queries.elementStart(tView, tNode);\n  }\n\n  return tNode;\n}\n\n/**\n * Create DOM element. The instruction must later be followed by `elementEnd()` call.\n *\n * @param index Index of the element in the LView array\n * @param name Name of the DOM Node\n * @param attrsIndex Index of the element's attributes in the `consts` array.\n * @param localRefsIndex Index of the element's local references in the `consts` array.\n * @returns This function returns itself so that it may be chained.\n *\n * Attributes and localRefs are passed as an array of strings where elements with an even index\n * hold an attribute name and elements with an odd index hold an attribute value, ex.:\n * ['id', 'warning5', 'class', 'alert']\n *\n * @codeGenApi\n */\nexport function ɵɵelementStart(\n    index: number, name: string, attrsIndex?: number|null,\n    localRefsIndex?: number): typeof ɵɵelementStart {\n  const lView = getLView();\n  const tView = getTView();\n  const adjustedIndex = HEADER_OFFSET + index;\n\n  ngDevMode &&\n      assertEqual(\n          getBindingIndex(), tView.bindingStartIndex,\n          'elements should be created before any bindings');\n  ngDevMode && assertIndexInRange(lView, adjustedIndex);\n\n  const renderer = lView[RENDERER];\n  const tNode = tView.firstCreatePass ?\n      elementStartFirstCreatePass(adjustedIndex, tView, lView, name, attrsIndex, localRefsIndex) :\n      tView.data[adjustedIndex] as TElementNode;\n\n  const native = _locateOrCreateElementNode(tView, lView, tNode, renderer, name, index);\n  lView[adjustedIndex] = native;\n\n  const hasDirectives = isDirectiveHost(tNode);\n\n  if (ngDevMode && tView.firstCreatePass) {\n    validateElementIsKnown(native, lView, tNode.value, tView.schemas, hasDirectives);\n  }\n\n  setCurrentTNode(tNode, true);\n  setupStaticAttributes(renderer, native, tNode);\n\n  if ((tNode.flags & TNodeFlags.isDetached) !== TNodeFlags.isDetached && wasLastNodeCreated()) {\n    // In the i18n case, the translation may have removed this element, so only add it if it is not\n    // detached. See `TNodeType.Placeholder` and `LFrame.inI18n` for more context.\n    appendChild(tView, lView, native, tNode);\n  }\n\n  // any immediate children of a component or template container must be pre-emptively\n  // monkey-patched with the component view data so that the element can be inspected\n  // later on using any element discovery utility methods (see `element_discovery.ts`)\n  if (getElementDepthCount() === 0) {\n    attachPatchData(native, lView);\n  }\n  increaseElementDepthCount();\n\n  if (hasDirectives) {\n    createDirectivesInstances(tView, lView, tNode);\n    executeContentQueries(tView, tNode, lView);\n  }\n  if (localRefsIndex !== null) {\n    saveResolvedLocalsInData(lView, tNode);\n  }\n  return ɵɵelementStart;\n}\n\n/**\n * Mark the end of the element.\n * @returns This function returns itself so that it may be chained.\n *\n * @codeGenApi\n */\nexport function ɵɵelementEnd(): typeof ɵɵelementEnd {\n  let currentTNode = getCurrentTNode()!;\n  ngDevMode && assertDefined(currentTNode, 'No parent node to close.');\n  if (isCurrentTNodeParent()) {\n    setCurrentTNodeAsNotParent();\n  } else {\n    ngDevMode && assertHasParent(getCurrentTNode());\n    currentTNode = currentTNode.parent!;\n    setCurrentTNode(currentTNode, false);\n  }\n\n  const tNode = currentTNode;\n  ngDevMode && assertTNodeType(tNode, TNodeType.AnyRNode);\n\n  if (isSkipHydrationRootTNode(tNode)) {\n    leaveSkipHydrationBlock();\n  }\n\n  decreaseElementDepthCount();\n\n  const tView = getTView();\n  if (tView.firstCreatePass) {\n    registerPostOrderHooks(tView, currentTNode);\n    if (isContentQueryHost(currentTNode)) {\n      tView.queries!.elementEnd(currentTNode);\n    }\n  }\n\n  if (tNode.classesWithoutHost != null && hasClassInput(tNode)) {\n    setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.classesWithoutHost, true);\n  }\n\n  if (tNode.stylesWithoutHost != null && hasStyleInput(tNode)) {\n    setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.stylesWithoutHost, false);\n  }\n  return ɵɵelementEnd;\n}\n\n/**\n * Creates an empty element using {@link elementStart} and {@link elementEnd}\n *\n * @param index Index of the element in the data array\n * @param name Name of the DOM Node\n * @param attrsIndex Index of the element's attributes in the `consts` array.\n * @param localRefsIndex Index of the element's local references in the `consts` array.\n * @returns This function returns itself so that it may be chained.\n *\n * @codeGenApi\n */\nexport function ɵɵelement(\n    index: number, name: string, attrsIndex?: number|null,\n    localRefsIndex?: number): typeof ɵɵelement {\n  ɵɵelementStart(index, name, attrsIndex, localRefsIndex);\n  ɵɵelementEnd();\n  return ɵɵelement;\n}\n\nlet _locateOrCreateElementNode: typeof locateOrCreateElementNodeImpl =\n    (tView: TView, lView: LView, tNode: TNode, renderer: Renderer, name: string, index: number) => {\n      lastNodeWasCreated(true);\n      return createElementNode(renderer, name, getNamespace());\n    };\n\n/**\n * Enables hydration code path (to lookup existing elements in DOM)\n * in addition to the regular creation mode of element nodes.\n */\nfunction locateOrCreateElementNodeImpl(\n    tView: TView, lView: LView, tNode: TNode, renderer: Renderer, name: string,\n    index: number): RElement {\n  const hydrationInfo = lView[HYDRATION];\n  const isNodeCreationMode =\n      !hydrationInfo || isInSkipHydrationBlock() || isDisconnectedNode(hydrationInfo, index);\n  lastNodeWasCreated(isNodeCreationMode);\n\n  // Regular creation mode.\n  if (isNodeCreationMode) {\n    return createElementNode(renderer, name, getNamespace());\n  }\n\n  // Hydration mode, looking up an existing element in DOM.\n  const native = locateNextRNode<RElement>(hydrationInfo, tView, lView, tNode)!;\n  ngDevMode && validateMatchingNode(native, Node.ELEMENT_NODE, name, lView, tNode);\n  ngDevMode && markRNodeAsClaimedByHydration(native);\n\n  // This element might also be an anchor of a view container.\n  if (getSerializedContainerViews(hydrationInfo, index)) {\n    // Important note: this element acts as an anchor, but it's **not** a part\n    // of the embedded view, so we start the segment **after** this element, taking\n    // a reference to the next sibling. For example, the following template:\n    // `<div #vcrTarget>` is represented in the DOM as `<div></div>...<!--container-->`,\n    // so while processing a `<div>` instruction, point to the next sibling as a\n    // start of a segment.\n    ngDevMode && validateNodeExists(native.nextSibling);\n    setSegmentHead(hydrationInfo, index, native.nextSibling);\n  }\n\n  // Checks if the skip hydration attribute is present during hydration so we know to\n  // skip attempting to hydrate this block.\n  if (hydrationInfo && hasNgSkipHydrationAttr(tNode)) {\n    if (isComponentHost(tNode)) {\n      enterSkipHydrationBlock(tNode);\n\n      // Since this isn't hydratable, we need to empty the node\n      // so there's no duplicate content after render\n      clearElementContents(native);\n    } else if (ngDevMode) {\n      // If this is not a component host, throw an error.\n      // Hydration can be skipped on per-component basis only.\n      throw invalidSkipHydrationHost(native);\n    }\n  }\n  return native;\n}\n\nexport function enableLocateOrCreateElementNodeImpl() {\n  _locateOrCreateElementNode = locateOrCreateElementNodeImpl;\n}\n"]}

package/{esm2020 → esm2022}/src/render3/instructions/element_container.mjs

@@ -146,10 +146,7 @@ function locateOrCreateElementContainerNode(tView, lView, tNode, index) {
     ngDevMode &&
         assertNumber(ngContainerSize, 'Unexpected state: hydrating an <ng-container>, ' +
             'but no hydration info is available.');
-    // If this container is non-empty, store the first node as a segment head,
-    // otherwise, this node is an anchor and segment head doesn't exist (thus `null`).
-    const segmentHead = ngContainerSize > 0 ? currentRNode : null;
-    setSegmentHead(hydrationInfo, index, segmentHead);
+    setSegmentHead(hydrationInfo, index, currentRNode);
     comment = siblingAfter(ngContainerSize, currentRNode);
     if (ngDevMode) {
         validateMatchingNode(comment, Node.COMMENT_NODE, null, lView, tNode);
@@ -160,4 +157,4 @@ function locateOrCreateElementContainerNode(tView, lView, tNode, index) {
 export function enableLocateOrCreateElementContainerNodeImpl() {
     _locateOrCreateElementContainerNode = locateOrCreateElementContainerNode;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"element_container.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/element_container.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 */\nimport {validateMatchingNode, validateNodeExists} from '../../hydration/error_handling';\nimport {locateNextRNode, siblingAfter} from '../../hydration/node_lookup_utils';\nimport {getNgContainerSize, markRNodeAsClaimedByHydration, setSegmentHead} from '../../hydration/utils';\nimport {assertEqual, assertIndexInRange, assertNumber} from '../../util/assert';\nimport {assertHasParent} from '../assert';\nimport {attachPatchData} from '../context_discovery';\nimport {registerPostOrderHooks} from '../hooks';\nimport {TAttributes, TElementContainerNode, TNode, TNodeType} from '../interfaces/node';\nimport {RComment} from '../interfaces/renderer_dom';\nimport {isContentQueryHost, isDirectiveHost} from '../interfaces/type_checks';\nimport {HEADER_OFFSET, HYDRATION, LView, RENDERER, TView} from '../interfaces/view';\nimport {assertTNodeType} from '../node_assert';\nimport {appendChild, createCommentNode} from '../node_manipulation';\nimport {getBindingIndex, getCurrentTNode, getLView, getTView, isCurrentTNodeParent, isInSkipHydrationBlock, lastNodeWasCreated, setCurrentTNode, setCurrentTNodeAsNotParent, wasLastNodeCreated} from '../state';\nimport {computeStaticStyling} from '../styling/static_styling';\nimport {getConstant} from '../util/view_utils';\n\nimport {createDirectivesInstances, executeContentQueries, getOrCreateTNode, resolveDirectives, saveResolvedLocalsInData} from './shared';\n\nfunction elementContainerStartFirstCreatePass(\n    index: number, tView: TView, lView: LView, attrsIndex?: number|null,\n    localRefsIndex?: number): TElementContainerNode {\n  ngDevMode && ngDevMode.firstCreatePass++;\n\n  const tViewConsts = tView.consts;\n  const attrs = getConstant<TAttributes>(tViewConsts, attrsIndex);\n  const tNode = getOrCreateTNode(tView, index, TNodeType.ElementContainer, 'ng-container', attrs);\n\n  // While ng-container doesn't necessarily support styling, we use the style context to identify\n  // and execute directives on the ng-container.\n  if (attrs !== null) {\n    computeStaticStyling(tNode, attrs, true);\n  }\n\n  const localRefs = getConstant<string[]>(tViewConsts, localRefsIndex);\n  resolveDirectives(tView, lView, tNode, localRefs);\n\n  if (tView.queries !== null) {\n    tView.queries.elementStart(tView, tNode);\n  }\n\n  return tNode;\n}\n\n/**\n * Creates a logical container for other nodes (<ng-container>) backed by a comment node in the DOM.\n * The instruction must later be followed by `elementContainerEnd()` call.\n *\n * @param index Index of the element in the LView array\n * @param attrsIndex Index of the container attributes in the `consts` array.\n * @param localRefsIndex Index of the container's local references in the `consts` array.\n * @returns This function returns itself so that it may be chained.\n *\n * Even if this instruction accepts a set of attributes no actual attribute values are propagated to\n * the DOM (as a comment node can't have attributes). Attributes are here only for directive\n * matching purposes and setting initial inputs of directives.\n *\n * @codeGenApi\n */\nexport function ɵɵelementContainerStart(\n    index: number, attrsIndex?: number|null,\n    localRefsIndex?: number): typeof ɵɵelementContainerStart {\n  const lView = getLView();\n  const tView = getTView();\n  const adjustedIndex = index + HEADER_OFFSET;\n\n  ngDevMode && assertIndexInRange(lView, adjustedIndex);\n  ngDevMode &&\n      assertEqual(\n          getBindingIndex(), tView.bindingStartIndex,\n          'element containers should be created before any bindings');\n\n  const tNode = tView.firstCreatePass ?\n      elementContainerStartFirstCreatePass(\n          adjustedIndex, tView, lView, attrsIndex, localRefsIndex) :\n      tView.data[adjustedIndex] as TElementContainerNode;\n  setCurrentTNode(tNode, true);\n\n  ngDevMode && ngDevMode.rendererCreateComment++;\n\n  const comment = _locateOrCreateElementContainerNode(tView, lView, tNode, index);\n  lView[adjustedIndex] = comment;\n\n  if (wasLastNodeCreated()) {\n    appendChild(tView, lView, comment, tNode);\n  }\n  attachPatchData(comment, lView);\n\n  if (isDirectiveHost(tNode)) {\n    createDirectivesInstances(tView, lView, tNode);\n    executeContentQueries(tView, tNode, lView);\n  }\n\n  if (localRefsIndex != null) {\n    saveResolvedLocalsInData(lView, tNode);\n  }\n\n  return ɵɵelementContainerStart;\n}\n\n/**\n * Mark the end of the <ng-container>.\n * @returns This function returns itself so that it may be chained.\n *\n * @codeGenApi\n */\nexport function ɵɵelementContainerEnd(): typeof ɵɵelementContainerEnd {\n  let currentTNode = getCurrentTNode()!;\n  const tView = getTView();\n  if (isCurrentTNodeParent()) {\n    setCurrentTNodeAsNotParent();\n  } else {\n    ngDevMode && assertHasParent(currentTNode);\n    currentTNode = currentTNode.parent!;\n    setCurrentTNode(currentTNode, false);\n  }\n\n  ngDevMode && assertTNodeType(currentTNode, TNodeType.ElementContainer);\n\n  if (tView.firstCreatePass) {\n    registerPostOrderHooks(tView, currentTNode);\n    if (isContentQueryHost(currentTNode)) {\n      tView.queries!.elementEnd(currentTNode);\n    }\n  }\n  return ɵɵelementContainerEnd;\n}\n\n/**\n * Creates an empty logical container using {@link elementContainerStart}\n * and {@link elementContainerEnd}\n *\n * @param index Index of the element in the LView array\n * @param attrsIndex Index of the container attributes in the `consts` array.\n * @param localRefsIndex Index of the container's local references in the `consts` array.\n * @returns This function returns itself so that it may be chained.\n *\n * @codeGenApi\n */\nexport function ɵɵelementContainer(\n    index: number, attrsIndex?: number|null, localRefsIndex?: number): typeof ɵɵelementContainer {\n  ɵɵelementContainerStart(index, attrsIndex, localRefsIndex);\n  ɵɵelementContainerEnd();\n  return ɵɵelementContainer;\n}\n\nlet _locateOrCreateElementContainerNode: typeof locateOrCreateElementContainerNode =\n    (tView: TView, lView: LView, tNode: TNode, index: number) => {\n      lastNodeWasCreated(true);\n      return createCommentNode(lView[RENDERER], ngDevMode ? 'ng-container' : '');\n    };\n\n/**\n * Enables hydration code path (to lookup existing elements in DOM)\n * in addition to the regular creation mode of comment nodes that\n * represent <ng-container>'s anchor.\n */\nfunction locateOrCreateElementContainerNode(\n    tView: TView, lView: LView, tNode: TNode, index: number): RComment {\n  let comment: RComment;\n  const hydrationInfo = lView[HYDRATION];\n  const isNodeCreationMode = !hydrationInfo || isInSkipHydrationBlock();\n\n  lastNodeWasCreated(isNodeCreationMode);\n\n  // Regular creation mode.\n  if (isNodeCreationMode) {\n    return createCommentNode(lView[RENDERER], ngDevMode ? 'ng-container' : '');\n  }\n\n  // Hydration mode, looking up existing elements in DOM.\n  const currentRNode = locateNextRNode(hydrationInfo, tView, lView, tNode)!;\n  ngDevMode && validateNodeExists(currentRNode);\n\n  const ngContainerSize = getNgContainerSize(hydrationInfo, index) as number;\n  ngDevMode &&\n      assertNumber(\n          ngContainerSize,\n          'Unexpected state: hydrating an <ng-container>, ' +\n              'but no hydration info is available.');\n\n  // If this container is non-empty, store the first node as a segment head,\n  // otherwise, this node is an anchor and segment head doesn't exist (thus `null`).\n  const segmentHead = ngContainerSize > 0 ? currentRNode : null;\n  setSegmentHead(hydrationInfo, index, segmentHead);\n  comment = siblingAfter<RComment>(ngContainerSize, currentRNode)!;\n\n  if (ngDevMode) {\n    validateMatchingNode(comment, Node.COMMENT_NODE, null, lView, tNode);\n    markRNodeAsClaimedByHydration(comment);\n  }\n\n  return comment;\n}\n\nexport function enableLocateOrCreateElementContainerNodeImpl() {\n  _locateOrCreateElementContainerNode = locateOrCreateElementContainerNode;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"element_container.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/element_container.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAC,oBAAoB,EAAE,kBAAkB,EAAC,MAAM,gCAAgC,CAAC;AACxF,OAAO,EAAC,eAAe,EAAE,YAAY,EAAC,MAAM,mCAAmC,CAAC;AAChF,OAAO,EAAC,kBAAkB,EAAE,6BAA6B,EAAE,cAAc,EAAC,MAAM,uBAAuB,CAAC;AACxG,OAAO,EAAC,WAAW,EAAE,kBAAkB,EAAE,YAAY,EAAC,MAAM,mBAAmB,CAAC;AAChF,OAAO,EAAC,eAAe,EAAC,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAC,sBAAsB,EAAC,MAAM,UAAU,CAAC;AAGhD,OAAO,EAAC,kBAAkB,EAAE,eAAe,EAAC,MAAM,2BAA2B,CAAC;AAC9E,OAAO,EAAC,aAAa,EAAE,SAAS,EAAS,QAAQ,EAAQ,MAAM,oBAAoB,CAAC;AACpF,OAAO,EAAC,eAAe,EAAC,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAC,WAAW,EAAE,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAC,eAAe,EAAE,eAAe,EAAE,QAAQ,EAAE,QAAQ,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,eAAe,EAAE,0BAA0B,EAAE,kBAAkB,EAAC,MAAM,UAAU,CAAC;AACjN,OAAO,EAAC,oBAAoB,EAAC,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,OAAO,EAAC,yBAAyB,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,wBAAwB,EAAC,MAAM,UAAU,CAAC;AAEzI,SAAS,oCAAoC,CACzC,KAAa,EAAE,KAAY,EAAE,KAAY,EAAE,UAAwB,EACnE,cAAuB;IACzB,SAAS,IAAI,SAAS,CAAC,eAAe,EAAE,CAAC;IAEzC,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,CAAC;IACjC,MAAM,KAAK,GAAG,WAAW,CAAc,WAAW,EAAE,UAAU,CAAC,CAAC;IAChE,MAAM,KAAK,GAAG,gBAAgB,CAAC,KAAK,EAAE,KAAK,sCAA8B,cAAc,EAAE,KAAK,CAAC,CAAC;IAEhG,+FAA+F;IAC/F,8CAA8C;IAC9C,IAAI,KAAK,KAAK,IAAI,EAAE;QAClB,oBAAoB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;KAC1C;IAED,MAAM,SAAS,GAAG,WAAW,CAAW,WAAW,EAAE,cAAc,CAAC,CAAC;IACrE,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;IAElD,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI,EAAE;QAC1B,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;KAC1C;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,uBAAuB,CACnC,KAAa,EAAE,UAAwB,EACvC,cAAuB;IACzB,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,MAAM,aAAa,GAAG,KAAK,GAAG,aAAa,CAAC;IAE5C,SAAS,IAAI,kBAAkB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;IACtD,SAAS;QACL,WAAW,CACP,eAAe,EAAE,EAAE,KAAK,CAAC,iBAAiB,EAC1C,0DAA0D,CAAC,CAAC;IAEpE,MAAM,KAAK,GAAG,KAAK,CAAC,eAAe,CAAC,CAAC;QACjC,oCAAoC,CAChC,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,cAAc,CAAC,CAAC,CAAC;QAC9D,KAAK,CAAC,IAAI,CAAC,aAAa,CAA0B,CAAC;IACvD,eAAe,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAE7B,SAAS,IAAI,SAAS,CAAC,qBAAqB,EAAE,CAAC;IAE/C,MAAM,OAAO,GAAG,mCAAmC,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IAChF,KAAK,CAAC,aAAa,CAAC,GAAG,OAAO,CAAC;IAE/B,IAAI,kBAAkB,EAAE,EAAE;QACxB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;KAC3C;IACD,eAAe,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAEhC,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE;QAC1B,yBAAyB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;QAC/C,qBAAqB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;KAC5C;IAED,IAAI,cAAc,IAAI,IAAI,EAAE;QAC1B,wBAAwB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;KACxC;IAED,OAAO,uBAAuB,CAAC;AACjC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB;IACnC,IAAI,YAAY,GAAG,eAAe,EAAG,CAAC;IACtC,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,IAAI,oBAAoB,EAAE,EAAE;QAC1B,0BAA0B,EAAE,CAAC;KAC9B;SAAM;QACL,SAAS,IAAI,eAAe,CAAC,YAAY,CAAC,CAAC;QAC3C,YAAY,GAAG,YAAY,CAAC,MAAO,CAAC;QACpC,eAAe,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;KACtC;IAED,SAAS,IAAI,eAAe,CAAC,YAAY,qCAA6B,CAAC;IAEvE,IAAI,KAAK,CAAC,eAAe,EAAE;QACzB,sBAAsB,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;QAC5C,IAAI,kBAAkB,CAAC,YAAY,CAAC,EAAE;YACpC,KAAK,CAAC,OAAQ,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;SACzC;KACF;IACD,OAAO,qBAAqB,CAAC;AAC/B,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAC9B,KAAa,EAAE,UAAwB,EAAE,cAAuB;IAClE,uBAAuB,CAAC,KAAK,EAAE,UAAU,EAAE,cAAc,CAAC,CAAC;IAC3D,qBAAqB,EAAE,CAAC;IACxB,OAAO,kBAAkB,CAAC;AAC5B,CAAC;AAED,IAAI,mCAAmC,GACnC,CAAC,KAAY,EAAE,KAAY,EAAE,KAAY,EAAE,KAAa,EAAE,EAAE;IAC1D,kBAAkB,CAAC,IAAI,CAAC,CAAC;IACzB,OAAO,iBAAiB,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AAC7E,CAAC,CAAC;AAEN;;;;GAIG;AACH,SAAS,kCAAkC,CACvC,KAAY,EAAE,KAAY,EAAE,KAAY,EAAE,KAAa;IACzD,IAAI,OAAiB,CAAC;IACtB,MAAM,aAAa,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;IACvC,MAAM,kBAAkB,GAAG,CAAC,aAAa,IAAI,sBAAsB,EAAE,CAAC;IAEtE,kBAAkB,CAAC,kBAAkB,CAAC,CAAC;IAEvC,yBAAyB;IACzB,IAAI,kBAAkB,EAAE;QACtB,OAAO,iBAAiB,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;KAC5E;IAED,uDAAuD;IACvD,MAAM,YAAY,GAAG,eAAe,CAAC,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAE,CAAC;IAC1E,SAAS,IAAI,kBAAkB,CAAC,YAAY,CAAC,CAAC;IAE9C,MAAM,eAAe,GAAG,kBAAkB,CAAC,aAAa,EAAE,KAAK,CAAW,CAAC;IAC3E,SAAS;QACL,YAAY,CACR,eAAe,EACf,iDAAiD;YAC7C,qCAAqC,CAAC,CAAC;IAEnD,cAAc,CAAC,aAAa,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC;IACnD,OAAO,GAAG,YAAY,CAAW,eAAe,EAAE,YAAY,CAAE,CAAC;IAEjE,IAAI,SAAS,EAAE;QACb,oBAAoB,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;QACrE,6BAA6B,CAAC,OAAO,CAAC,CAAC;KACxC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,MAAM,UAAU,4CAA4C;IAC1D,mCAAmC,GAAG,kCAAkC,CAAC;AAC3E,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 */\nimport {validateMatchingNode, validateNodeExists} from '../../hydration/error_handling';\nimport {locateNextRNode, siblingAfter} from '../../hydration/node_lookup_utils';\nimport {getNgContainerSize, markRNodeAsClaimedByHydration, setSegmentHead} from '../../hydration/utils';\nimport {assertEqual, assertIndexInRange, assertNumber} from '../../util/assert';\nimport {assertHasParent} from '../assert';\nimport {attachPatchData} from '../context_discovery';\nimport {registerPostOrderHooks} from '../hooks';\nimport {TAttributes, TElementContainerNode, TNode, TNodeType} from '../interfaces/node';\nimport {RComment} from '../interfaces/renderer_dom';\nimport {isContentQueryHost, isDirectiveHost} from '../interfaces/type_checks';\nimport {HEADER_OFFSET, HYDRATION, LView, RENDERER, TView} from '../interfaces/view';\nimport {assertTNodeType} from '../node_assert';\nimport {appendChild, createCommentNode} from '../node_manipulation';\nimport {getBindingIndex, getCurrentTNode, getLView, getTView, isCurrentTNodeParent, isInSkipHydrationBlock, lastNodeWasCreated, setCurrentTNode, setCurrentTNodeAsNotParent, wasLastNodeCreated} from '../state';\nimport {computeStaticStyling} from '../styling/static_styling';\nimport {getConstant} from '../util/view_utils';\n\nimport {createDirectivesInstances, executeContentQueries, getOrCreateTNode, resolveDirectives, saveResolvedLocalsInData} from './shared';\n\nfunction elementContainerStartFirstCreatePass(\n    index: number, tView: TView, lView: LView, attrsIndex?: number|null,\n    localRefsIndex?: number): TElementContainerNode {\n  ngDevMode && ngDevMode.firstCreatePass++;\n\n  const tViewConsts = tView.consts;\n  const attrs = getConstant<TAttributes>(tViewConsts, attrsIndex);\n  const tNode = getOrCreateTNode(tView, index, TNodeType.ElementContainer, 'ng-container', attrs);\n\n  // While ng-container doesn't necessarily support styling, we use the style context to identify\n  // and execute directives on the ng-container.\n  if (attrs !== null) {\n    computeStaticStyling(tNode, attrs, true);\n  }\n\n  const localRefs = getConstant<string[]>(tViewConsts, localRefsIndex);\n  resolveDirectives(tView, lView, tNode, localRefs);\n\n  if (tView.queries !== null) {\n    tView.queries.elementStart(tView, tNode);\n  }\n\n  return tNode;\n}\n\n/**\n * Creates a logical container for other nodes (<ng-container>) backed by a comment node in the DOM.\n * The instruction must later be followed by `elementContainerEnd()` call.\n *\n * @param index Index of the element in the LView array\n * @param attrsIndex Index of the container attributes in the `consts` array.\n * @param localRefsIndex Index of the container's local references in the `consts` array.\n * @returns This function returns itself so that it may be chained.\n *\n * Even if this instruction accepts a set of attributes no actual attribute values are propagated to\n * the DOM (as a comment node can't have attributes). Attributes are here only for directive\n * matching purposes and setting initial inputs of directives.\n *\n * @codeGenApi\n */\nexport function ɵɵelementContainerStart(\n    index: number, attrsIndex?: number|null,\n    localRefsIndex?: number): typeof ɵɵelementContainerStart {\n  const lView = getLView();\n  const tView = getTView();\n  const adjustedIndex = index + HEADER_OFFSET;\n\n  ngDevMode && assertIndexInRange(lView, adjustedIndex);\n  ngDevMode &&\n      assertEqual(\n          getBindingIndex(), tView.bindingStartIndex,\n          'element containers should be created before any bindings');\n\n  const tNode = tView.firstCreatePass ?\n      elementContainerStartFirstCreatePass(\n          adjustedIndex, tView, lView, attrsIndex, localRefsIndex) :\n      tView.data[adjustedIndex] as TElementContainerNode;\n  setCurrentTNode(tNode, true);\n\n  ngDevMode && ngDevMode.rendererCreateComment++;\n\n  const comment = _locateOrCreateElementContainerNode(tView, lView, tNode, index);\n  lView[adjustedIndex] = comment;\n\n  if (wasLastNodeCreated()) {\n    appendChild(tView, lView, comment, tNode);\n  }\n  attachPatchData(comment, lView);\n\n  if (isDirectiveHost(tNode)) {\n    createDirectivesInstances(tView, lView, tNode);\n    executeContentQueries(tView, tNode, lView);\n  }\n\n  if (localRefsIndex != null) {\n    saveResolvedLocalsInData(lView, tNode);\n  }\n\n  return ɵɵelementContainerStart;\n}\n\n/**\n * Mark the end of the <ng-container>.\n * @returns This function returns itself so that it may be chained.\n *\n * @codeGenApi\n */\nexport function ɵɵelementContainerEnd(): typeof ɵɵelementContainerEnd {\n  let currentTNode = getCurrentTNode()!;\n  const tView = getTView();\n  if (isCurrentTNodeParent()) {\n    setCurrentTNodeAsNotParent();\n  } else {\n    ngDevMode && assertHasParent(currentTNode);\n    currentTNode = currentTNode.parent!;\n    setCurrentTNode(currentTNode, false);\n  }\n\n  ngDevMode && assertTNodeType(currentTNode, TNodeType.ElementContainer);\n\n  if (tView.firstCreatePass) {\n    registerPostOrderHooks(tView, currentTNode);\n    if (isContentQueryHost(currentTNode)) {\n      tView.queries!.elementEnd(currentTNode);\n    }\n  }\n  return ɵɵelementContainerEnd;\n}\n\n/**\n * Creates an empty logical container using {@link elementContainerStart}\n * and {@link elementContainerEnd}\n *\n * @param index Index of the element in the LView array\n * @param attrsIndex Index of the container attributes in the `consts` array.\n * @param localRefsIndex Index of the container's local references in the `consts` array.\n * @returns This function returns itself so that it may be chained.\n *\n * @codeGenApi\n */\nexport function ɵɵelementContainer(\n    index: number, attrsIndex?: number|null, localRefsIndex?: number): typeof ɵɵelementContainer {\n  ɵɵelementContainerStart(index, attrsIndex, localRefsIndex);\n  ɵɵelementContainerEnd();\n  return ɵɵelementContainer;\n}\n\nlet _locateOrCreateElementContainerNode: typeof locateOrCreateElementContainerNode =\n    (tView: TView, lView: LView, tNode: TNode, index: number) => {\n      lastNodeWasCreated(true);\n      return createCommentNode(lView[RENDERER], ngDevMode ? 'ng-container' : '');\n    };\n\n/**\n * Enables hydration code path (to lookup existing elements in DOM)\n * in addition to the regular creation mode of comment nodes that\n * represent <ng-container>'s anchor.\n */\nfunction locateOrCreateElementContainerNode(\n    tView: TView, lView: LView, tNode: TNode, index: number): RComment {\n  let comment: RComment;\n  const hydrationInfo = lView[HYDRATION];\n  const isNodeCreationMode = !hydrationInfo || isInSkipHydrationBlock();\n\n  lastNodeWasCreated(isNodeCreationMode);\n\n  // Regular creation mode.\n  if (isNodeCreationMode) {\n    return createCommentNode(lView[RENDERER], ngDevMode ? 'ng-container' : '');\n  }\n\n  // Hydration mode, looking up existing elements in DOM.\n  const currentRNode = locateNextRNode(hydrationInfo, tView, lView, tNode)!;\n  ngDevMode && validateNodeExists(currentRNode);\n\n  const ngContainerSize = getNgContainerSize(hydrationInfo, index) as number;\n  ngDevMode &&\n      assertNumber(\n          ngContainerSize,\n          'Unexpected state: hydrating an <ng-container>, ' +\n              'but no hydration info is available.');\n\n  setSegmentHead(hydrationInfo, index, currentRNode);\n  comment = siblingAfter<RComment>(ngContainerSize, currentRNode)!;\n\n  if (ngDevMode) {\n    validateMatchingNode(comment, Node.COMMENT_NODE, null, lView, tNode);\n    markRNodeAsClaimedByHydration(comment);\n  }\n\n  return comment;\n}\n\nexport function enableLocateOrCreateElementContainerNodeImpl() {\n  _locateOrCreateElementContainerNode = locateOrCreateElementContainerNode;\n}\n"]}