@angular/core 10.0.6 → 10.0.10

package/esm2015/src/render3/i18n/i18n_apply.js

@@ -0,0 +1,445 @@
+/**
+ * @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 { getPluralCase } from '../../i18n/localization';
+import { assertDefined, assertEqual, assertIndexInRange } from '../../util/assert';
+import { attachPatchData } from '../context_discovery';
+import { elementAttributeInternal, elementPropertyInternal, getOrCreateTNode, textBindingInternal } from '../instructions/shared';
+import { NATIVE } from '../interfaces/container';
+import { COMMENT_MARKER, ELEMENT_MARKER } from '../interfaces/i18n';
+import { isLContainer } from '../interfaces/type_checks';
+import { HEADER_OFFSET, RENDERER, T_HOST } from '../interfaces/view';
+import { appendChild, applyProjection, createTextNode, nativeRemoveNode } from '../node_manipulation';
+import { getBindingIndex, getPreviousOrParentTNode, setIsNotParent, setPreviousOrParentTNode } from '../state';
+import { renderStringify } from '../util/misc_utils';
+import { getNativeByIndex, getNativeByTNode, getTNode, load } from '../util/view_utils';
+import { getLocaleId } from './i18n_locale_id';
+const i18nIndexStack = [];
+let i18nIndexStackPointer = -1;
+function popI18nIndex() {
+    return i18nIndexStack[i18nIndexStackPointer--];
+}
+export function pushI18nIndex(index) {
+    i18nIndexStack[++i18nIndexStackPointer] = index;
+}
+let changeMask = 0b0;
+let shiftsCounter = 0;
+export function setMaskBit(bit) {
+    if (bit) {
+        changeMask = changeMask | (1 << shiftsCounter);
+    }
+    shiftsCounter++;
+}
+export function applyI18n(tView, lView, index) {
+    if (shiftsCounter > 0) {
+        ngDevMode && assertDefined(tView, `tView should be defined`);
+        const tI18n = tView.data[index + HEADER_OFFSET];
+        let updateOpCodes;
+        let tIcus = null;
+        if (Array.isArray(tI18n)) {
+            updateOpCodes = tI18n;
+        }
+        else {
+            updateOpCodes = tI18n.update;
+            tIcus = tI18n.icus;
+        }
+        const bindingsStartIndex = getBindingIndex() - shiftsCounter - 1;
+        applyUpdateOpCodes(tView, tIcus, lView, updateOpCodes, bindingsStartIndex, changeMask);
+        // Reset changeMask & maskBit to default for the next update cycle
+        changeMask = 0b0;
+        shiftsCounter = 0;
+    }
+}
+/**
+ * Apply `I18nMutateOpCodes` OpCodes.
+ *
+ * @param tView Current `TView`
+ * @param rootIndex Pointer to the root (parent) tNode for the i18n.
+ * @param createOpCodes OpCodes to process
+ * @param lView Current `LView`
+ */
+export function applyCreateOpCodes(tView, rootindex, createOpCodes, lView) {
+    const renderer = lView[RENDERER];
+    let currentTNode = null;
+    let previousTNode = null;
+    const visitedNodes = [];
+    for (let i = 0; i < createOpCodes.length; i++) {
+        const opCode = createOpCodes[i];
+        if (typeof opCode == 'string') {
+            const textRNode = createTextNode(opCode, renderer);
+            const textNodeIndex = createOpCodes[++i];
+            ngDevMode && ngDevMode.rendererCreateTextNode++;
+            previousTNode = currentTNode;
+            currentTNode =
+                createDynamicNodeAtIndex(tView, lView, textNodeIndex, 3 /* Element */, textRNode, null);
+            visitedNodes.push(textNodeIndex);
+            setIsNotParent();
+        }
+        else if (typeof opCode == 'number') {
+            switch (opCode & 7 /* MASK_INSTRUCTION */) {
+                case 1 /* AppendChild */:
+                    const destinationNodeIndex = opCode >>> 17 /* SHIFT_PARENT */;
+                    let destinationTNode;
+                    if (destinationNodeIndex === rootindex) {
+                        // If the destination node is `i18nStart`, we don't have a
+                        // top-level node and we should use the host node instead
+                        destinationTNode = lView[T_HOST];
+                    }
+                    else {
+                        destinationTNode = getTNode(tView, destinationNodeIndex);
+                    }
+                    ngDevMode &&
+                        assertDefined(currentTNode, `You need to create or select a node before you can insert it into the DOM`);
+                    previousTNode =
+                        appendI18nNode(tView, currentTNode, destinationTNode, previousTNode, lView);
+                    break;
+                case 0 /* Select */:
+                    // Negative indices indicate that a given TNode is a sibling node, not a parent node
+                    // (see `i18nStartFirstPass` for additional information).
+                    const isParent = opCode >= 0;
+                    // FIXME(misko): This SHIFT_REF looks suspect as it does not have mask.
+                    const nodeIndex = (isParent ? opCode : ~opCode) >>> 3 /* SHIFT_REF */;
+                    visitedNodes.push(nodeIndex);
+                    previousTNode = currentTNode;
+                    currentTNode = getTNode(tView, nodeIndex);
+                    if (currentTNode) {
+                        setPreviousOrParentTNode(currentTNode, isParent);
+                    }
+                    break;
+                case 5 /* ElementEnd */:
+                    const elementIndex = opCode >>> 3 /* SHIFT_REF */;
+                    previousTNode = currentTNode = getTNode(tView, elementIndex);
+                    setPreviousOrParentTNode(currentTNode, false);
+                    break;
+                case 4 /* Attr */:
+                    const elementNodeIndex = opCode >>> 3 /* SHIFT_REF */;
+                    const attrName = createOpCodes[++i];
+                    const attrValue = createOpCodes[++i];
+                    // This code is used for ICU expressions only, since we don't support
+                    // directives/components in ICUs, we don't need to worry about inputs here
+                    elementAttributeInternal(getTNode(tView, elementNodeIndex), lView, attrName, attrValue, null, null);
+                    break;
+                default:
+                    throw new Error(`Unable to determine the type of mutate operation for "${opCode}"`);
+            }
+        }
+        else {
+            switch (opCode) {
+                case COMMENT_MARKER:
+                    const commentValue = createOpCodes[++i];
+                    const commentNodeIndex = createOpCodes[++i];
+                    ngDevMode &&
+                        assertEqual(typeof commentValue, 'string', `Expected "${commentValue}" to be a comment node value`);
+                    const commentRNode = renderer.createComment(commentValue);
+                    ngDevMode && ngDevMode.rendererCreateComment++;
+                    previousTNode = currentTNode;
+                    currentTNode = createDynamicNodeAtIndex(tView, lView, commentNodeIndex, 5 /* IcuContainer */, commentRNode, null);
+                    visitedNodes.push(commentNodeIndex);
+                    attachPatchData(commentRNode, lView);
+                    // We will add the case nodes later, during the update phase
+                    setIsNotParent();
+                    break;
+                case ELEMENT_MARKER:
+                    const tagNameValue = createOpCodes[++i];
+                    const elementNodeIndex = createOpCodes[++i];
+                    ngDevMode &&
+                        assertEqual(typeof tagNameValue, 'string', `Expected "${tagNameValue}" to be an element node tag name`);
+                    const elementRNode = renderer.createElement(tagNameValue);
+                    ngDevMode && ngDevMode.rendererCreateElement++;
+                    previousTNode = currentTNode;
+                    currentTNode = createDynamicNodeAtIndex(tView, lView, elementNodeIndex, 3 /* Element */, elementRNode, tagNameValue);
+                    visitedNodes.push(elementNodeIndex);
+                    break;
+                default:
+                    throw new Error(`Unable to determine the type of mutate operation for "${opCode}"`);
+            }
+        }
+    }
+    setIsNotParent();
+    return visitedNodes;
+}
+/**
+ * Apply `I18nUpdateOpCodes` OpCodes
+ *
+ * @param tView Current `TView`
+ * @param tIcus If ICUs present than this contains them.
+ * @param lView Current `LView`
+ * @param updateOpCodes OpCodes to process
+ * @param bindingsStartIndex Location of the first `ɵɵi18nApply`
+ * @param changeMask Each bit corresponds to a `ɵɵi18nExp` (Counting backwards from
+ *     `bindingsStartIndex`)
+ */
+export function applyUpdateOpCodes(tView, tIcus, lView, updateOpCodes, bindingsStartIndex, changeMask) {
+    let caseCreated = false;
+    for (let i = 0; i < updateOpCodes.length; i++) {
+        // bit code to check if we should apply the next update
+        const checkBit = updateOpCodes[i];
+        // Number of opCodes to skip until next set of update codes
+        const skipCodes = updateOpCodes[++i];
+        if (checkBit & changeMask) {
+            // The value has been updated since last checked
+            let value = '';
+            for (let j = i + 1; j <= (i + skipCodes); j++) {
+                const opCode = updateOpCodes[j];
+                if (typeof opCode == 'string') {
+                    value += opCode;
+                }
+                else if (typeof opCode == 'number') {
+                    if (opCode < 0) {
+                        // Negative opCode represent `i18nExp` values offset.
+                        value += renderStringify(lView[bindingsStartIndex - opCode]);
+                    }
+                    else {
+                        const nodeIndex = opCode >>> 2 /* SHIFT_REF */;
+                        switch (opCode & 3 /* MASK_OPCODE */) {
+                            case 1 /* Attr */:
+                                const propName = updateOpCodes[++j];
+                                const sanitizeFn = updateOpCodes[++j];
+                                elementPropertyInternal(tView, getTNode(tView, nodeIndex), lView, propName, value, lView[RENDERER], sanitizeFn, false);
+                                break;
+                            case 0 /* Text */:
+                                textBindingInternal(lView, nodeIndex, value);
+                                break;
+                            case 2 /* IcuSwitch */:
+                                caseCreated =
+                                    applyIcuSwitchCase(tView, tIcus, updateOpCodes[++j], lView, value);
+                                break;
+                            case 3 /* IcuUpdate */:
+                                applyIcuUpdateCase(tView, tIcus, updateOpCodes[++j], bindingsStartIndex, lView, caseCreated);
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+        i += skipCodes;
+    }
+}
+/**
+ * Apply OpCodes associated with updating an existing ICU.
+ *
+ * @param tView Current `TView`
+ * @param tIcus ICUs active at this location.
+ * @param tIcuIndex Index into `tIcus` to process.
+ * @param bindingsStartIndex Location of the first `ɵɵi18nApply`
+ * @param lView Current `LView`
+ * @param changeMask Each bit corresponds to a `ɵɵi18nExp` (Counting backwards from
+ *     `bindingsStartIndex`)
+ */
+function applyIcuUpdateCase(tView, tIcus, tIcuIndex, bindingsStartIndex, lView, caseCreated) {
+    ngDevMode && assertIndexInRange(tIcus, tIcuIndex);
+    const tIcu = tIcus[tIcuIndex];
+    ngDevMode && assertIndexInRange(lView, tIcu.currentCaseLViewIndex);
+    const activeCaseIndex = lView[tIcu.currentCaseLViewIndex];
+    if (activeCaseIndex !== null) {
+        const mask = caseCreated ?
+            -1 : // -1 is same as all bits on, which simulates creation since it marks all bits dirty
+            changeMask;
+        applyUpdateOpCodes(tView, tIcus, lView, tIcu.update[activeCaseIndex], bindingsStartIndex, mask);
+    }
+}
+/**
+ * Apply OpCodes associated with switching a case on ICU.
+ *
+ * This involves tearing down existing case and than building up a new case.
+ *
+ * @param tView Current `TView`
+ * @param tIcus ICUs active at this location.
+ * @param tICuIndex Index into `tIcus` to process.
+ * @param lView Current `LView`
+ * @param value Value of the case to update to.
+ * @returns true if a new case was created (needed so that the update executes regardless of the
+ *     bitmask)
+ */
+function applyIcuSwitchCase(tView, tIcus, tICuIndex, lView, value) {
+    applyIcuSwitchCaseRemove(tView, tIcus, tICuIndex, lView);
+    // Rebuild a new case for this ICU
+    let caseCreated = false;
+    const tIcu = tIcus[tICuIndex];
+    const caseIndex = getCaseIndex(tIcu, value);
+    lView[tIcu.currentCaseLViewIndex] = caseIndex !== -1 ? caseIndex : null;
+    if (caseIndex > -1) {
+        // Add the nodes for the new case
+        applyCreateOpCodes(tView, -1, // -1 means we don't have parent node
+        tIcu.create[caseIndex], lView);
+        caseCreated = true;
+    }
+    return caseCreated;
+}
+/**
+ * Apply OpCodes associated with tearing down of DOM.
+ *
+ * This involves tearing down existing case and than building up a new case.
+ *
+ * @param tView Current `TView`
+ * @param tIcus ICUs active at this location.
+ * @param tIcuIndex Index into `tIcus` to process.
+ * @param lView Current `LView`
+ * @returns true if a new case was created (needed so that the update executes regardless of the
+ *     bitmask)
+ */
+function applyIcuSwitchCaseRemove(tView, tIcus, tIcuIndex, lView) {
+    ngDevMode && assertIndexInRange(tIcus, tIcuIndex);
+    const tIcu = tIcus[tIcuIndex];
+    const activeCaseIndex = lView[tIcu.currentCaseLViewIndex];
+    if (activeCaseIndex !== null) {
+        const removeCodes = tIcu.remove[activeCaseIndex];
+        for (let k = 0; k < removeCodes.length; k++) {
+            const removeOpCode = removeCodes[k];
+            const nodeOrIcuIndex = removeOpCode >>> 3 /* SHIFT_REF */;
+            switch (removeOpCode & 7 /* MASK_INSTRUCTION */) {
+                case 3 /* Remove */:
+                    // FIXME(misko): this comment is wrong!
+                    // Remove DOM element, but do *not* mark TNode as detached, since we are
+                    // just switching ICU cases (while keeping the same TNode), so a DOM element
+                    // representing a new ICU case will be re-created.
+                    removeNode(tView, lView, nodeOrIcuIndex, /* markAsDetached */ false);
+                    break;
+                case 6 /* RemoveNestedIcu */:
+                    applyIcuSwitchCaseRemove(tView, tIcus, nodeOrIcuIndex, lView);
+                    break;
+            }
+        }
+    }
+}
+function appendI18nNode(tView, tNode, parentTNode, previousTNode, lView) {
+    ngDevMode && ngDevMode.rendererMoveNode++;
+    const nextNode = tNode.next;
+    if (!previousTNode) {
+        previousTNode = parentTNode;
+    }
+    // Re-organize node tree to put this node in the correct position.
+    if (previousTNode === parentTNode && tNode !== parentTNode.child) {
+        tNode.next = parentTNode.child;
+        parentTNode.child = tNode;
+    }
+    else if (previousTNode !== parentTNode && tNode !== previousTNode.next) {
+        tNode.next = previousTNode.next;
+        previousTNode.next = tNode;
+    }
+    else {
+        tNode.next = null;
+    }
+    if (parentTNode !== lView[T_HOST]) {
+        tNode.parent = parentTNode;
+    }
+    // If tNode was moved around, we might need to fix a broken link.
+    let cursor = tNode.next;
+    while (cursor) {
+        if (cursor.next === tNode) {
+            cursor.next = nextNode;
+        }
+        cursor = cursor.next;
+    }
+    // If the placeholder to append is a projection, we need to move the projected nodes instead
+    if (tNode.type === 1 /* Projection */) {
+        applyProjection(tView, lView, tNode);
+        return tNode;
+    }
+    appendChild(tView, lView, getNativeByTNode(tNode, lView), tNode);
+    const slotValue = lView[tNode.index];
+    if (tNode.type !== 0 /* Container */ && isLContainer(slotValue)) {
+        // Nodes that inject ViewContainerRef also have a comment node that should be moved
+        appendChild(tView, lView, slotValue[NATIVE], tNode);
+    }
+    return tNode;
+}
+/**
+ * See `i18nEnd` above.
+ */
+export function i18nEndFirstPass(tView, lView) {
+    ngDevMode &&
+        assertEqual(getBindingIndex(), tView.bindingStartIndex, 'i18nEnd should be called before any binding');
+    const rootIndex = popI18nIndex();
+    const tI18n = tView.data[rootIndex + HEADER_OFFSET];
+    ngDevMode && assertDefined(tI18n, `You should call i18nStart before i18nEnd`);
+    // Find the last node that was added before `i18nEnd`
+    const lastCreatedNode = getPreviousOrParentTNode();
+    // Read the instructions to insert/move/remove DOM elements
+    const visitedNodes = applyCreateOpCodes(tView, rootIndex, tI18n.create, lView);
+    // Remove deleted nodes
+    let index = rootIndex + 1;
+    while (index <= lastCreatedNode.index - HEADER_OFFSET) {
+        if (visitedNodes.indexOf(index) === -1) {
+            removeNode(tView, lView, index, /* markAsDetached */ true);
+        }
+        // Check if an element has any local refs and skip them
+        const tNode = getTNode(tView, index);
+        if (tNode &&
+            (tNode.type === 0 /* Container */ || tNode.type === 3 /* Element */ ||
+                tNode.type === 4 /* ElementContainer */) &&
+            tNode.localNames !== null) {
+            // Divide by 2 to get the number of local refs,
+            // since they are stored as an array that also includes directive indexes,
+            // i.e. ["localRef", directiveIndex, ...]
+            index += tNode.localNames.length >> 1;
+        }
+        index++;
+    }
+}
+function removeNode(tView, lView, index, markAsDetached) {
+    const removedPhTNode = getTNode(tView, index);
+    const removedPhRNode = getNativeByIndex(index, lView);
+    if (removedPhRNode) {
+        nativeRemoveNode(lView[RENDERER], removedPhRNode);
+    }
+    const slotValue = load(lView, index);
+    if (isLContainer(slotValue)) {
+        const lContainer = slotValue;
+        if (removedPhTNode.type !== 0 /* Container */) {
+            nativeRemoveNode(lView[RENDERER], lContainer[NATIVE]);
+        }
+    }
+    if (markAsDetached) {
+        // Define this node as detached to avoid projecting it later
+        removedPhTNode.flags |= 64 /* isDetached */;
+    }
+    ngDevMode && ngDevMode.rendererRemoveNode++;
+}
+/**
+ * Creates and stores the dynamic TNode, and unhooks it from the tree for now.
+ */
+function createDynamicNodeAtIndex(tView, lView, index, type, native, name) {
+    const previousOrParentTNode = getPreviousOrParentTNode();
+    ngDevMode && assertIndexInRange(lView, index + HEADER_OFFSET);
+    lView[index + HEADER_OFFSET] = native;
+    // FIXME(misko): Why does this create A TNode??? I would not expect this to be here.
+    const tNode = getOrCreateTNode(tView, lView[T_HOST], index, type, name, null);
+    // We are creating a dynamic node, the previous tNode might not be pointing at this node.
+    // We will link ourselves into the tree later with `appendI18nNode`.
+    if (previousOrParentTNode && previousOrParentTNode.next === tNode) {
+        previousOrParentTNode.next = null;
+    }
+    return tNode;
+}
+/**
+ * Returns the index of the current case of an ICU expression depending on the main binding value
+ *
+ * @param icuExpression
+ * @param bindingValue The value of the main binding used by this ICU expression
+ */
+function getCaseIndex(icuExpression, bindingValue) {
+    let index = icuExpression.cases.indexOf(bindingValue);
+    if (index === -1) {
+        switch (icuExpression.type) {
+            case 1 /* plural */: {
+                const resolvedCase = getPluralCase(bindingValue, getLocaleId());
+                index = icuExpression.cases.indexOf(resolvedCase);
+                if (index === -1 && resolvedCase !== 'other') {
+                    index = icuExpression.cases.indexOf('other');
+                }
+                break;
+            }
+            case 0 /* select */: {
+                index = icuExpression.cases.indexOf('other');
+                break;
+            }
+        }
+    }
+    return index;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n_apply.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/i18n/i18n_apply.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 {getPluralCase} from '../../i18n/localization';\nimport {assertDefined, assertEqual, assertIndexInRange} from '../../util/assert';\nimport {attachPatchData} from '../context_discovery';\nimport {elementAttributeInternal, elementPropertyInternal, getOrCreateTNode, textBindingInternal} from '../instructions/shared';\nimport {LContainer, NATIVE} from '../interfaces/container';\nimport {COMMENT_MARKER, ELEMENT_MARKER, I18nMutateOpCode, I18nMutateOpCodes, I18nUpdateOpCode, I18nUpdateOpCodes, IcuType, TI18n, TIcu} from '../interfaces/i18n';\nimport {TElementNode, TIcuContainerNode, TNode, TNodeFlags, TNodeType, TProjectionNode} from '../interfaces/node';\nimport {RComment, RElement, RText} from '../interfaces/renderer';\nimport {SanitizerFn} from '../interfaces/sanitization';\nimport {isLContainer} from '../interfaces/type_checks';\nimport {HEADER_OFFSET, LView, RENDERER, T_HOST, TView} from '../interfaces/view';\nimport {appendChild, applyProjection, createTextNode, nativeRemoveNode} from '../node_manipulation';\nimport {getBindingIndex, getLView, getPreviousOrParentTNode, getTView, setIsNotParent, setPreviousOrParentTNode} from '../state';\nimport {renderStringify} from '../util/misc_utils';\nimport {getNativeByIndex, getNativeByTNode, getTNode, load} from '../util/view_utils';\nimport {getLocaleId} from './i18n_locale_id';\n\n\nconst i18nIndexStack: number[] = [];\nlet i18nIndexStackPointer = -1;\n\nfunction popI18nIndex() {\n  return i18nIndexStack[i18nIndexStackPointer--];\n}\n\nexport function pushI18nIndex(index: number) {\n  i18nIndexStack[++i18nIndexStackPointer] = index;\n}\n\nlet changeMask = 0b0;\nlet shiftsCounter = 0;\n\nexport function setMaskBit(bit: boolean) {\n  if (bit) {\n    changeMask = changeMask | (1 << shiftsCounter);\n  }\n  shiftsCounter++;\n}\n\nexport function applyI18n(tView: TView, lView: LView, index: number) {\n  if (shiftsCounter > 0) {\n    ngDevMode && assertDefined(tView, `tView should be defined`);\n    const tI18n = tView.data[index + HEADER_OFFSET] as TI18n | I18nUpdateOpCodes;\n    let updateOpCodes: I18nUpdateOpCodes;\n    let tIcus: TIcu[]|null = null;\n    if (Array.isArray(tI18n)) {\n      updateOpCodes = tI18n as I18nUpdateOpCodes;\n    } else {\n      updateOpCodes = (tI18n as TI18n).update;\n      tIcus = (tI18n as TI18n).icus;\n    }\n    const bindingsStartIndex = getBindingIndex() - shiftsCounter - 1;\n    applyUpdateOpCodes(tView, tIcus, lView, updateOpCodes, bindingsStartIndex, changeMask);\n\n    // Reset changeMask & maskBit to default for the next update cycle\n    changeMask = 0b0;\n    shiftsCounter = 0;\n  }\n}\n\n/**\n * Apply `I18nMutateOpCodes` OpCodes.\n *\n * @param tView Current `TView`\n * @param rootIndex Pointer to the root (parent) tNode for the i18n.\n * @param createOpCodes OpCodes to process\n * @param lView Current `LView`\n */\nexport function applyCreateOpCodes(\n    tView: TView, rootindex: number, createOpCodes: I18nMutateOpCodes, lView: LView): number[] {\n  const renderer = lView[RENDERER];\n  let currentTNode: TNode|null = null;\n  let previousTNode: TNode|null = null;\n  const visitedNodes: number[] = [];\n  for (let i = 0; i < createOpCodes.length; i++) {\n    const opCode = createOpCodes[i];\n    if (typeof opCode == 'string') {\n      const textRNode = createTextNode(opCode, renderer);\n      const textNodeIndex = createOpCodes[++i] as number;\n      ngDevMode && ngDevMode.rendererCreateTextNode++;\n      previousTNode = currentTNode;\n      currentTNode =\n          createDynamicNodeAtIndex(tView, lView, textNodeIndex, TNodeType.Element, textRNode, null);\n      visitedNodes.push(textNodeIndex);\n      setIsNotParent();\n    } else if (typeof opCode == 'number') {\n      switch (opCode & I18nMutateOpCode.MASK_INSTRUCTION) {\n        case I18nMutateOpCode.AppendChild:\n          const destinationNodeIndex = opCode >>> I18nMutateOpCode.SHIFT_PARENT;\n          let destinationTNode: TNode;\n          if (destinationNodeIndex === rootindex) {\n            // If the destination node is `i18nStart`, we don't have a\n            // top-level node and we should use the host node instead\n            destinationTNode = lView[T_HOST]!;\n          } else {\n            destinationTNode = getTNode(tView, destinationNodeIndex);\n          }\n          ngDevMode &&\n              assertDefined(\n                  currentTNode!,\n                  `You need to create or select a node before you can insert it into the DOM`);\n          previousTNode =\n              appendI18nNode(tView, currentTNode!, destinationTNode, previousTNode, lView);\n          break;\n        case I18nMutateOpCode.Select:\n          // Negative indices indicate that a given TNode is a sibling node, not a parent node\n          // (see `i18nStartFirstPass` for additional information).\n          const isParent = opCode >= 0;\n          // FIXME(misko): This SHIFT_REF looks suspect as it does not have mask.\n          const nodeIndex = (isParent ? opCode : ~opCode) >>> I18nMutateOpCode.SHIFT_REF;\n          visitedNodes.push(nodeIndex);\n          previousTNode = currentTNode;\n          currentTNode = getTNode(tView, nodeIndex);\n          if (currentTNode) {\n            setPreviousOrParentTNode(currentTNode, isParent);\n          }\n          break;\n        case I18nMutateOpCode.ElementEnd:\n          const elementIndex = opCode >>> I18nMutateOpCode.SHIFT_REF;\n          previousTNode = currentTNode = getTNode(tView, elementIndex);\n          setPreviousOrParentTNode(currentTNode, false);\n          break;\n        case I18nMutateOpCode.Attr:\n          const elementNodeIndex = opCode >>> I18nMutateOpCode.SHIFT_REF;\n          const attrName = createOpCodes[++i] as string;\n          const attrValue = createOpCodes[++i] as string;\n          // This code is used for ICU expressions only, since we don't support\n          // directives/components in ICUs, we don't need to worry about inputs here\n          elementAttributeInternal(\n              getTNode(tView, elementNodeIndex), lView, attrName, attrValue, null, null);\n          break;\n        default:\n          throw new Error(`Unable to determine the type of mutate operation for \"${opCode}\"`);\n      }\n    } else {\n      switch (opCode) {\n        case COMMENT_MARKER:\n          const commentValue = createOpCodes[++i] as string;\n          const commentNodeIndex = createOpCodes[++i] as number;\n          ngDevMode &&\n              assertEqual(\n                  typeof commentValue, 'string',\n                  `Expected \"${commentValue}\" to be a comment node value`);\n          const commentRNode = renderer.createComment(commentValue);\n          ngDevMode && ngDevMode.rendererCreateComment++;\n          previousTNode = currentTNode;\n          currentTNode = createDynamicNodeAtIndex(\n              tView, lView, commentNodeIndex, TNodeType.IcuContainer, commentRNode, null);\n          visitedNodes.push(commentNodeIndex);\n          attachPatchData(commentRNode, lView);\n          // We will add the case nodes later, during the update phase\n          setIsNotParent();\n          break;\n        case ELEMENT_MARKER:\n          const tagNameValue = createOpCodes[++i] as string;\n          const elementNodeIndex = createOpCodes[++i] as number;\n          ngDevMode &&\n              assertEqual(\n                  typeof tagNameValue, 'string',\n                  `Expected \"${tagNameValue}\" to be an element node tag name`);\n          const elementRNode = renderer.createElement(tagNameValue);\n          ngDevMode && ngDevMode.rendererCreateElement++;\n          previousTNode = currentTNode;\n          currentTNode = createDynamicNodeAtIndex(\n              tView, lView, elementNodeIndex, TNodeType.Element, elementRNode, tagNameValue);\n          visitedNodes.push(elementNodeIndex);\n          break;\n        default:\n          throw new Error(`Unable to determine the type of mutate operation for \"${opCode}\"`);\n      }\n    }\n  }\n\n  setIsNotParent();\n\n  return visitedNodes;\n}\n\n\n/**\n * Apply `I18nUpdateOpCodes` OpCodes\n *\n * @param tView Current `TView`\n * @param tIcus If ICUs present than this contains them.\n * @param lView Current `LView`\n * @param updateOpCodes OpCodes to process\n * @param bindingsStartIndex Location of the first `ɵɵi18nApply`\n * @param changeMask Each bit corresponds to a `ɵɵi18nExp` (Counting backwards from\n *     `bindingsStartIndex`)\n */\nexport function applyUpdateOpCodes(\n    tView: TView, tIcus: TIcu[]|null, lView: LView, updateOpCodes: I18nUpdateOpCodes,\n    bindingsStartIndex: number, changeMask: number) {\n  let caseCreated = false;\n  for (let i = 0; i < updateOpCodes.length; i++) {\n    // bit code to check if we should apply the next update\n    const checkBit = updateOpCodes[i] as number;\n    // Number of opCodes to skip until next set of update codes\n    const skipCodes = updateOpCodes[++i] as number;\n    if (checkBit & changeMask) {\n      // The value has been updated since last checked\n      let value = '';\n      for (let j = i + 1; j <= (i + skipCodes); j++) {\n        const opCode = updateOpCodes[j];\n        if (typeof opCode == 'string') {\n          value += opCode;\n        } else if (typeof opCode == 'number') {\n          if (opCode < 0) {\n            // Negative opCode represent `i18nExp` values offset.\n            value += renderStringify(lView[bindingsStartIndex - opCode]);\n          } else {\n            const nodeIndex = opCode >>> I18nUpdateOpCode.SHIFT_REF;\n            switch (opCode & I18nUpdateOpCode.MASK_OPCODE) {\n              case I18nUpdateOpCode.Attr:\n                const propName = updateOpCodes[++j] as string;\n                const sanitizeFn = updateOpCodes[++j] as SanitizerFn | null;\n                elementPropertyInternal(\n                    tView, getTNode(tView, nodeIndex), lView, propName, value, lView[RENDERER],\n                    sanitizeFn, false);\n                break;\n              case I18nUpdateOpCode.Text:\n                textBindingInternal(lView, nodeIndex, value);\n                break;\n              case I18nUpdateOpCode.IcuSwitch:\n                caseCreated =\n                    applyIcuSwitchCase(tView, tIcus!, updateOpCodes[++j] as number, lView, value);\n                break;\n              case I18nUpdateOpCode.IcuUpdate:\n                applyIcuUpdateCase(\n                    tView, tIcus!, updateOpCodes[++j] as number, bindingsStartIndex, lView,\n                    caseCreated);\n                break;\n            }\n          }\n        }\n      }\n    }\n    i += skipCodes;\n  }\n}\n\n/**\n * Apply OpCodes associated with updating an existing ICU.\n *\n * @param tView Current `TView`\n * @param tIcus ICUs active at this location.\n * @param tIcuIndex Index into `tIcus` to process.\n * @param bindingsStartIndex Location of the first `ɵɵi18nApply`\n * @param lView Current `LView`\n * @param changeMask Each bit corresponds to a `ɵɵi18nExp` (Counting backwards from\n *     `bindingsStartIndex`)\n */\nfunction applyIcuUpdateCase(\n    tView: TView, tIcus: TIcu[], tIcuIndex: number, bindingsStartIndex: number, lView: LView,\n    caseCreated: boolean) {\n  ngDevMode && assertIndexInRange(tIcus, tIcuIndex);\n  const tIcu = tIcus[tIcuIndex];\n  ngDevMode && assertIndexInRange(lView, tIcu.currentCaseLViewIndex);\n  const activeCaseIndex = lView[tIcu.currentCaseLViewIndex];\n  if (activeCaseIndex !== null) {\n    const mask = caseCreated ?\n        -1 :  // -1 is same as all bits on, which simulates creation since it marks all bits dirty\n        changeMask;\n    applyUpdateOpCodes(tView, tIcus, lView, tIcu.update[activeCaseIndex], bindingsStartIndex, mask);\n  }\n}\n\n/**\n * Apply OpCodes associated with switching a case on ICU.\n *\n * This involves tearing down existing case and than building up a new case.\n *\n * @param tView Current `TView`\n * @param tIcus ICUs active at this location.\n * @param tICuIndex Index into `tIcus` to process.\n * @param lView Current `LView`\n * @param value Value of the case to update to.\n * @returns true if a new case was created (needed so that the update executes regardless of the\n *     bitmask)\n */\nfunction applyIcuSwitchCase(\n    tView: TView, tIcus: TIcu[], tICuIndex: number, lView: LView, value: string): boolean {\n  applyIcuSwitchCaseRemove(tView, tIcus, tICuIndex, lView);\n\n  // Rebuild a new case for this ICU\n  let caseCreated = false;\n  const tIcu = tIcus[tICuIndex];\n  const caseIndex = getCaseIndex(tIcu, value);\n  lView[tIcu.currentCaseLViewIndex] = caseIndex !== -1 ? caseIndex : null;\n  if (caseIndex > -1) {\n    // Add the nodes for the new case\n    applyCreateOpCodes(\n        tView, -1,  // -1 means we don't have parent node\n        tIcu.create[caseIndex], lView);\n    caseCreated = true;\n  }\n  return caseCreated;\n}\n\n/**\n * Apply OpCodes associated with tearing down of DOM.\n *\n * This involves tearing down existing case and than building up a new case.\n *\n * @param tView Current `TView`\n * @param tIcus ICUs active at this location.\n * @param tIcuIndex Index into `tIcus` to process.\n * @param lView Current `LView`\n * @returns true if a new case was created (needed so that the update executes regardless of the\n *     bitmask)\n */\nfunction applyIcuSwitchCaseRemove(tView: TView, tIcus: TIcu[], tIcuIndex: number, lView: LView) {\n  ngDevMode && assertIndexInRange(tIcus, tIcuIndex);\n  const tIcu = tIcus[tIcuIndex];\n  const activeCaseIndex = lView[tIcu.currentCaseLViewIndex];\n  if (activeCaseIndex !== null) {\n    const removeCodes = tIcu.remove[activeCaseIndex];\n    for (let k = 0; k < removeCodes.length; k++) {\n      const removeOpCode = removeCodes[k] as number;\n      const nodeOrIcuIndex = removeOpCode >>> I18nMutateOpCode.SHIFT_REF;\n      switch (removeOpCode & I18nMutateOpCode.MASK_INSTRUCTION) {\n        case I18nMutateOpCode.Remove:\n          // FIXME(misko): this comment is wrong!\n          // Remove DOM element, but do *not* mark TNode as detached, since we are\n          // just switching ICU cases (while keeping the same TNode), so a DOM element\n          // representing a new ICU case will be re-created.\n          removeNode(tView, lView, nodeOrIcuIndex, /* markAsDetached */ false);\n          break;\n        case I18nMutateOpCode.RemoveNestedIcu:\n          applyIcuSwitchCaseRemove(tView, tIcus, nodeOrIcuIndex, lView);\n          break;\n      }\n    }\n  }\n}\n\nfunction appendI18nNode(\n    tView: TView, tNode: TNode, parentTNode: TNode, previousTNode: TNode|null,\n    lView: LView): TNode {\n  ngDevMode && ngDevMode.rendererMoveNode++;\n  const nextNode = tNode.next;\n  if (!previousTNode) {\n    previousTNode = parentTNode;\n  }\n\n  // Re-organize node tree to put this node in the correct position.\n  if (previousTNode === parentTNode && tNode !== parentTNode.child) {\n    tNode.next = parentTNode.child;\n    parentTNode.child = tNode;\n  } else if (previousTNode !== parentTNode && tNode !== previousTNode.next) {\n    tNode.next = previousTNode.next;\n    previousTNode.next = tNode;\n  } else {\n    tNode.next = null;\n  }\n\n  if (parentTNode !== lView[T_HOST]) {\n    tNode.parent = parentTNode as TElementNode;\n  }\n\n  // If tNode was moved around, we might need to fix a broken link.\n  let cursor: TNode|null = tNode.next;\n  while (cursor) {\n    if (cursor.next === tNode) {\n      cursor.next = nextNode;\n    }\n    cursor = cursor.next;\n  }\n\n  // If the placeholder to append is a projection, we need to move the projected nodes instead\n  if (tNode.type === TNodeType.Projection) {\n    applyProjection(tView, lView, tNode as TProjectionNode);\n    return tNode;\n  }\n\n  appendChild(tView, lView, getNativeByTNode(tNode, lView), tNode);\n\n  const slotValue = lView[tNode.index];\n  if (tNode.type !== TNodeType.Container && isLContainer(slotValue)) {\n    // Nodes that inject ViewContainerRef also have a comment node that should be moved\n    appendChild(tView, lView, slotValue[NATIVE], tNode);\n  }\n  return tNode;\n}\n\n/**\n * See `i18nEnd` above.\n */\nexport function i18nEndFirstPass(tView: TView, lView: LView) {\n  ngDevMode &&\n      assertEqual(\n          getBindingIndex(), tView.bindingStartIndex,\n          'i18nEnd should be called before any binding');\n\n  const rootIndex = popI18nIndex();\n  const tI18n = tView.data[rootIndex + HEADER_OFFSET] as TI18n;\n  ngDevMode && assertDefined(tI18n, `You should call i18nStart before i18nEnd`);\n\n  // Find the last node that was added before `i18nEnd`\n  const lastCreatedNode = getPreviousOrParentTNode();\n\n  // Read the instructions to insert/move/remove DOM elements\n  const visitedNodes = applyCreateOpCodes(tView, rootIndex, tI18n.create, lView);\n\n  // Remove deleted nodes\n  let index = rootIndex + 1;\n  while (index <= lastCreatedNode.index - HEADER_OFFSET) {\n    if (visitedNodes.indexOf(index) === -1) {\n      removeNode(tView, lView, index, /* markAsDetached */ true);\n    }\n    // Check if an element has any local refs and skip them\n    const tNode = getTNode(tView, index);\n    if (tNode &&\n        (tNode.type === TNodeType.Container || tNode.type === TNodeType.Element ||\n         tNode.type === TNodeType.ElementContainer) &&\n        tNode.localNames !== null) {\n      // Divide by 2 to get the number of local refs,\n      // since they are stored as an array that also includes directive indexes,\n      // i.e. [\"localRef\", directiveIndex, ...]\n      index += tNode.localNames.length >> 1;\n    }\n    index++;\n  }\n}\n\nfunction removeNode(tView: TView, lView: LView, index: number, markAsDetached: boolean) {\n  const removedPhTNode = getTNode(tView, index);\n  const removedPhRNode = getNativeByIndex(index, lView);\n  if (removedPhRNode) {\n    nativeRemoveNode(lView[RENDERER], removedPhRNode);\n  }\n\n  const slotValue = load(lView, index) as RElement | RComment | LContainer;\n  if (isLContainer(slotValue)) {\n    const lContainer = slotValue as LContainer;\n    if (removedPhTNode.type !== TNodeType.Container) {\n      nativeRemoveNode(lView[RENDERER], lContainer[NATIVE]);\n    }\n  }\n\n  if (markAsDetached) {\n    // Define this node as detached to avoid projecting it later\n    removedPhTNode.flags |= TNodeFlags.isDetached;\n  }\n  ngDevMode && ngDevMode.rendererRemoveNode++;\n}\n\n/**\n * Creates and stores the dynamic TNode, and unhooks it from the tree for now.\n */\nfunction createDynamicNodeAtIndex(\n    tView: TView, lView: LView, index: number, type: TNodeType, native: RElement|RText|null,\n    name: string|null): TElementNode|TIcuContainerNode {\n  const previousOrParentTNode = getPreviousOrParentTNode();\n  ngDevMode && assertIndexInRange(lView, index + HEADER_OFFSET);\n  lView[index + HEADER_OFFSET] = native;\n  // FIXME(misko): Why does this create A TNode??? I would not expect this to be here.\n  const tNode = getOrCreateTNode(tView, lView[T_HOST], index, type as any, name, null);\n\n  // We are creating a dynamic node, the previous tNode might not be pointing at this node.\n  // We will link ourselves into the tree later with `appendI18nNode`.\n  if (previousOrParentTNode && previousOrParentTNode.next === tNode) {\n    previousOrParentTNode.next = null;\n  }\n\n  return tNode;\n}\n\n\n/**\n * Returns the index of the current case of an ICU expression depending on the main binding value\n *\n * @param icuExpression\n * @param bindingValue The value of the main binding used by this ICU expression\n */\nfunction getCaseIndex(icuExpression: TIcu, bindingValue: string): number {\n  let index = icuExpression.cases.indexOf(bindingValue);\n  if (index === -1) {\n    switch (icuExpression.type) {\n      case IcuType.plural: {\n        const resolvedCase = getPluralCase(bindingValue, getLocaleId());\n        index = icuExpression.cases.indexOf(resolvedCase);\n        if (index === -1 && resolvedCase !== 'other') {\n          index = icuExpression.cases.indexOf('other');\n        }\n        break;\n      }\n      case IcuType.select: {\n        index = icuExpression.cases.indexOf('other');\n        break;\n      }\n    }\n  }\n  return index;\n}\n"]}