@angular/core 10.0.6 → 10.0.10

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

@@ -0,0 +1,635 @@
+/**
+ * @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 '../../util/ng_dev_mode';
+import '../../util/ng_i18n_closure_mode';
+import { getTemplateContent, SRCSET_ATTRS, URI_ATTRS, VALID_ATTRS, VALID_ELEMENTS } from '../../sanitization/html_sanitizer';
+import { getInertBodyHelper } from '../../sanitization/inert_body';
+import { _sanitizeUrl, sanitizeSrcset } from '../../sanitization/url_sanitizer';
+import { addAllToArray } from '../../util/array_utils';
+import { assertEqual } from '../../util/assert';
+import { allocExpando, elementAttributeInternal, setInputsForProperty, setNgReflectProperties } from '../instructions/shared';
+import { getDocument } from '../interfaces/document';
+import { COMMENT_MARKER, ELEMENT_MARKER } from '../interfaces/i18n';
+import { HEADER_OFFSET, T_HOST } from '../interfaces/view';
+import { getIsParent, getPreviousOrParentTNode } from '../state';
+import { attachDebugGetter } from '../util/debug_utils';
+import { getNativeByIndex, getTNode } from '../util/view_utils';
+import { i18nMutateOpCodesToString, i18nUpdateOpCodesToString } from './i18n_debug';
+const BINDING_REGEXP = /�(\d+):?\d*�/gi;
+const ICU_REGEXP = /({\s*�\d+:?\d*�\s*,\s*\S{6}\s*,[\s\S]*})/gi;
+const NESTED_ICU = /�(\d+)�/;
+const ICU_BLOCK_REGEXP = /^\s*(�\d+:?\d*�)\s*,\s*(select|plural)\s*,/;
+// Count for the number of vars that will be allocated for each i18n block.
+// It is global because this is used in multiple functions that include loops and recursive calls.
+// This is reset to 0 when `i18nStartFirstPass` is called.
+let i18nVarsCount;
+const parentIndexStack = [];
+const MARKER = `�`;
+const SUBTEMPLATE_REGEXP = /�\/?\*(\d+:\d+)�/gi;
+const PH_REGEXP = /�(\/?[#*!]\d+):?\d*�/gi;
+/**
+ * Angular Dart introduced &ngsp; as a placeholder for non-removable space, see:
+ * https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart#L25-L32
+ * In Angular Dart &ngsp; is converted to the 0xE500 PUA (Private Use Areas) unicode character
+ * and later on replaced by a space. We are re-implementing the same idea here, since translations
+ * might contain this special character.
+ */
+const NGSP_UNICODE_REGEXP = /\uE500/g;
+function replaceNgsp(value) {
+    return value.replace(NGSP_UNICODE_REGEXP, ' ');
+}
+/**
+ * See `i18nStart` above.
+ */
+export function i18nStartFirstPass(lView, tView, index, message, subTemplateIndex) {
+    const startIndex = tView.blueprint.length - HEADER_OFFSET;
+    i18nVarsCount = 0;
+    const previousOrParentTNode = getPreviousOrParentTNode();
+    const parentTNode = getIsParent() ? previousOrParentTNode : previousOrParentTNode && previousOrParentTNode.parent;
+    let parentIndex = parentTNode && parentTNode !== lView[T_HOST] ? parentTNode.index - HEADER_OFFSET : index;
+    let parentIndexPointer = 0;
+    parentIndexStack[parentIndexPointer] = parentIndex;
+    const createOpCodes = [];
+    if (ngDevMode) {
+        attachDebugGetter(createOpCodes, i18nMutateOpCodesToString);
+    }
+    // If the previous node wasn't the direct parent then we have a translation without top level
+    // element and we need to keep a reference of the previous element if there is one. We should also
+    // keep track whether an element was a parent node or not, so that the logic that consumes
+    // the generated `I18nMutateOpCode`s can leverage this information to properly set TNode state
+    // (whether it's a parent or sibling).
+    if (index > 0 && previousOrParentTNode !== parentTNode) {
+        let previousTNodeIndex = previousOrParentTNode.index - HEADER_OFFSET;
+        // If current TNode is a sibling node, encode it using a negative index. This information is
+        // required when the `Select` action is processed (see the `readCreateOpCodes` function).
+        if (!getIsParent()) {
+            previousTNodeIndex = ~previousTNodeIndex;
+        }
+        // Create an OpCode to select the previous TNode
+        createOpCodes.push(previousTNodeIndex << 3 /* SHIFT_REF */ | 0 /* Select */);
+    }
+    const updateOpCodes = [];
+    if (ngDevMode) {
+        attachDebugGetter(updateOpCodes, i18nUpdateOpCodesToString);
+    }
+    const icuExpressions = [];
+    if (message === '' && isRootTemplateMessage(subTemplateIndex)) {
+        // If top level translation is an empty string, do not invoke additional processing
+        // and just create op codes for empty text node instead.
+        createOpCodes.push(message, allocNodeIndex(startIndex), parentIndex << 17 /* SHIFT_PARENT */ | 1 /* AppendChild */);
+    }
+    else {
+        const templateTranslation = getTranslationForTemplate(message, subTemplateIndex);
+        const msgParts = replaceNgsp(templateTranslation).split(PH_REGEXP);
+        for (let i = 0; i < msgParts.length; i++) {
+            let value = msgParts[i];
+            if (i & 1) {
+                // Odd indexes are placeholders (elements and sub-templates)
+                if (value.charAt(0) === '/') {
+                    // It is a closing tag
+                    if (value.charAt(1) === "#" /* ELEMENT */) {
+                        const phIndex = parseInt(value.substr(2), 10);
+                        parentIndex = parentIndexStack[--parentIndexPointer];
+                        createOpCodes.push(phIndex << 3 /* SHIFT_REF */ | 5 /* ElementEnd */);
+                    }
+                }
+                else {
+                    const phIndex = parseInt(value.substr(1), 10);
+                    const isElement = value.charAt(0) === "#" /* ELEMENT */;
+                    // The value represents a placeholder that we move to the designated index.
+                    // Note: positive indicies indicate that a TNode with a given index should also be marked
+                    // as parent while executing `Select` instruction.
+                    createOpCodes.push((isElement ? phIndex : ~phIndex) << 3 /* SHIFT_REF */ |
+                        0 /* Select */, parentIndex << 17 /* SHIFT_PARENT */ | 1 /* AppendChild */);
+                    if (isElement) {
+                        parentIndexStack[++parentIndexPointer] = parentIndex = phIndex;
+                    }
+                }
+            }
+            else {
+                // Even indexes are text (including bindings & ICU expressions)
+                const parts = extractParts(value);
+                for (let j = 0; j < parts.length; j++) {
+                    if (j & 1) {
+                        // Odd indexes are ICU expressions
+                        const icuExpression = parts[j];
+                        // Verify that ICU expression has the right shape. Translations might contain invalid
+                        // constructions (while original messages were correct), so ICU parsing at runtime may
+                        // not succeed (thus `icuExpression` remains a string).
+                        if (typeof icuExpression !== 'object') {
+                            throw new Error(`Unable to parse ICU expression in "${templateTranslation}" message.`);
+                        }
+                        // Create the comment node that will anchor the ICU expression
+                        const icuNodeIndex = allocNodeIndex(startIndex);
+                        createOpCodes.push(COMMENT_MARKER, ngDevMode ? `ICU ${icuNodeIndex}` : '', icuNodeIndex, parentIndex << 17 /* SHIFT_PARENT */ | 1 /* AppendChild */);
+                        // Update codes for the ICU expression
+                        const mask = getBindingMask(icuExpression);
+                        icuStart(icuExpressions, icuExpression, icuNodeIndex, icuNodeIndex);
+                        // Since this is recursive, the last TIcu that was pushed is the one we want
+                        const tIcuIndex = icuExpressions.length - 1;
+                        updateOpCodes.push(toMaskBit(icuExpression.mainBinding), // mask of the main binding
+                        3, // skip 3 opCodes if not changed
+                        -1 - icuExpression.mainBinding, icuNodeIndex << 2 /* SHIFT_REF */ | 2 /* IcuSwitch */, tIcuIndex, mask, // mask of all the bindings of this ICU expression
+                        2, // skip 2 opCodes if not changed
+                        icuNodeIndex << 2 /* SHIFT_REF */ | 3 /* IcuUpdate */, tIcuIndex);
+                    }
+                    else if (parts[j] !== '') {
+                        const text = parts[j];
+                        // Even indexes are text (including bindings)
+                        const hasBinding = text.match(BINDING_REGEXP);
+                        // Create text nodes
+                        const textNodeIndex = allocNodeIndex(startIndex);
+                        createOpCodes.push(
+                        // If there is a binding, the value will be set during update
+                        hasBinding ? '' : text, textNodeIndex, parentIndex << 17 /* SHIFT_PARENT */ | 1 /* AppendChild */);
+                        if (hasBinding) {
+                            addAllToArray(generateBindingUpdateOpCodes(text, textNodeIndex), updateOpCodes);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (i18nVarsCount > 0) {
+        allocExpando(tView, lView, i18nVarsCount);
+    }
+    // NOTE: local var needed to properly assert the type of `TI18n`.
+    const tI18n = {
+        vars: i18nVarsCount,
+        create: createOpCodes,
+        update: updateOpCodes,
+        icus: icuExpressions.length ? icuExpressions : null,
+    };
+    tView.data[index + HEADER_OFFSET] = tI18n;
+}
+/**
+ * See `i18nAttributes` above.
+ */
+export function i18nAttributesFirstPass(lView, tView, index, values) {
+    const previousElement = getPreviousOrParentTNode();
+    const previousElementIndex = previousElement.index - HEADER_OFFSET;
+    const updateOpCodes = [];
+    if (ngDevMode) {
+        attachDebugGetter(updateOpCodes, i18nUpdateOpCodesToString);
+    }
+    for (let i = 0; i < values.length; i += 2) {
+        const attrName = values[i];
+        const message = values[i + 1];
+        const parts = message.split(ICU_REGEXP);
+        for (let j = 0; j < parts.length; j++) {
+            const value = parts[j];
+            if (j & 1) {
+                // Odd indexes are ICU expressions
+                // TODO(ocombe): support ICU expressions in attributes
+                throw new Error('ICU expressions are not yet supported in attributes');
+            }
+            else if (value !== '') {
+                // Even indexes are text (including bindings)
+                const hasBinding = !!value.match(BINDING_REGEXP);
+                if (hasBinding) {
+                    if (tView.firstCreatePass && tView.data[index + HEADER_OFFSET] === null) {
+                        addAllToArray(generateBindingUpdateOpCodes(value, previousElementIndex, attrName), updateOpCodes);
+                    }
+                }
+                else {
+                    const tNode = getTNode(tView, previousElementIndex);
+                    // Set attributes for Elements only, for other types (like ElementContainer),
+                    // only set inputs below
+                    if (tNode.type === 3 /* Element */) {
+                        elementAttributeInternal(tNode, lView, attrName, value, null, null);
+                    }
+                    // Check if that attribute is a directive input
+                    const dataValue = tNode.inputs !== null && tNode.inputs[attrName];
+                    if (dataValue) {
+                        setInputsForProperty(tView, lView, dataValue, attrName, value);
+                        if (ngDevMode) {
+                            const element = getNativeByIndex(previousElementIndex, lView);
+                            setNgReflectProperties(lView, element, tNode.type, dataValue, value);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (tView.firstCreatePass && tView.data[index + HEADER_OFFSET] === null) {
+        tView.data[index + HEADER_OFFSET] = updateOpCodes;
+    }
+}
+/**
+ * Generate the OpCodes to update the bindings of a string.
+ *
+ * @param str The string containing the bindings.
+ * @param destinationNode Index of the destination node which will receive the binding.
+ * @param attrName Name of the attribute, if the string belongs to an attribute.
+ * @param sanitizeFn Sanitization function used to sanitize the string after update, if necessary.
+ */
+export function generateBindingUpdateOpCodes(str, destinationNode, attrName, sanitizeFn = null) {
+    const updateOpCodes = [null, null]; // Alloc space for mask and size
+    if (ngDevMode) {
+        attachDebugGetter(updateOpCodes, i18nUpdateOpCodesToString);
+    }
+    const textParts = str.split(BINDING_REGEXP);
+    let mask = 0;
+    for (let j = 0; j < textParts.length; j++) {
+        const textValue = textParts[j];
+        if (j & 1) {
+            // Odd indexes are bindings
+            const bindingIndex = parseInt(textValue, 10);
+            updateOpCodes.push(-1 - bindingIndex);
+            mask = mask | toMaskBit(bindingIndex);
+        }
+        else if (textValue !== '') {
+            // Even indexes are text
+            updateOpCodes.push(textValue);
+        }
+    }
+    updateOpCodes.push(destinationNode << 2 /* SHIFT_REF */ |
+        (attrName ? 1 /* Attr */ : 0 /* Text */));
+    if (attrName) {
+        updateOpCodes.push(attrName, sanitizeFn);
+    }
+    updateOpCodes[0] = mask;
+    updateOpCodes[1] = updateOpCodes.length - 2;
+    return updateOpCodes;
+}
+function getBindingMask(icuExpression, mask = 0) {
+    mask = mask | toMaskBit(icuExpression.mainBinding);
+    let match;
+    for (let i = 0; i < icuExpression.values.length; i++) {
+        const valueArr = icuExpression.values[i];
+        for (let j = 0; j < valueArr.length; j++) {
+            const value = valueArr[j];
+            if (typeof value === 'string') {
+                while (match = BINDING_REGEXP.exec(value)) {
+                    mask = mask | toMaskBit(parseInt(match[1], 10));
+                }
+            }
+            else {
+                mask = getBindingMask(value, mask);
+            }
+        }
+    }
+    return mask;
+}
+function allocNodeIndex(startIndex) {
+    return startIndex + i18nVarsCount++;
+}
+/**
+ * Convert binding index to mask bit.
+ *
+ * Each index represents a single bit on the bit-mask. Because bit-mask only has 32 bits, we make
+ * the 32nd bit share all masks for all bindings higher than 32. Since it is extremely rare to have
+ * more than 32 bindings this will be hit very rarely. The downside of hitting this corner case is
+ * that we will execute binding code more often than necessary. (penalty of performance)
+ */
+function toMaskBit(bindingIndex) {
+    return 1 << Math.min(bindingIndex, 31);
+}
+export function isRootTemplateMessage(subTemplateIndex) {
+    return subTemplateIndex === undefined;
+}
+/**
+ * Removes everything inside the sub-templates of a message.
+ */
+function removeInnerTemplateTranslation(message) {
+    let match;
+    let res = '';
+    let index = 0;
+    let inTemplate = false;
+    let tagMatched;
+    while ((match = SUBTEMPLATE_REGEXP.exec(message)) !== null) {
+        if (!inTemplate) {
+            res += message.substring(index, match.index + match[0].length);
+            tagMatched = match[1];
+            inTemplate = true;
+        }
+        else {
+            if (match[0] === `${MARKER}/*${tagMatched}${MARKER}`) {
+                index = match.index;
+                inTemplate = false;
+            }
+        }
+    }
+    ngDevMode &&
+        assertEqual(inTemplate, false, `Tag mismatch: unable to find the end of the sub-template in the translation "${message}"`);
+    res += message.substr(index);
+    return res;
+}
+/**
+ * Extracts a part of a message and removes the rest.
+ *
+ * This method is used for extracting a part of the message associated with a template. A translated
+ * message can span multiple templates.
+ *
+ * Example:
+ * ```
+ * <div i18n>Translate <span *ngIf>me</span>!</div>
+ * ```
+ *
+ * @param message The message to crop
+ * @param subTemplateIndex Index of the sub-template to extract. If undefined it returns the
+ * external template and removes all sub-templates.
+ */
+export function getTranslationForTemplate(message, subTemplateIndex) {
+    if (isRootTemplateMessage(subTemplateIndex)) {
+        // We want the root template message, ignore all sub-templates
+        return removeInnerTemplateTranslation(message);
+    }
+    else {
+        // We want a specific sub-template
+        const start = message.indexOf(`:${subTemplateIndex}${MARKER}`) + 2 + subTemplateIndex.toString().length;
+        const end = message.search(new RegExp(`${MARKER}\\/\\*\\d+:${subTemplateIndex}${MARKER}`));
+        return removeInnerTemplateTranslation(message.substring(start, end));
+    }
+}
+/**
+ * Generate the OpCodes for ICU expressions.
+ *
+ * @param tIcus
+ * @param icuExpression
+ * @param startIndex
+ * @param expandoStartIndex
+ */
+export function icuStart(tIcus, icuExpression, startIndex, expandoStartIndex) {
+    const createCodes = [];
+    const removeCodes = [];
+    const updateCodes = [];
+    const vars = [];
+    const childIcus = [];
+    const values = icuExpression.values;
+    for (let i = 0; i < values.length; i++) {
+        // Each value is an array of strings & other ICU expressions
+        const valueArr = values[i];
+        const nestedIcus = [];
+        for (let j = 0; j < valueArr.length; j++) {
+            const value = valueArr[j];
+            if (typeof value !== 'string') {
+                // It is an nested ICU expression
+                const icuIndex = nestedIcus.push(value) - 1;
+                // Replace nested ICU expression by a comment node
+                valueArr[j] = `<!--�${icuIndex}�-->`;
+            }
+        }
+        const icuCase = parseIcuCase(valueArr.join(''), startIndex, nestedIcus, tIcus, expandoStartIndex);
+        createCodes.push(icuCase.create);
+        removeCodes.push(icuCase.remove);
+        updateCodes.push(icuCase.update);
+        vars.push(icuCase.vars);
+        childIcus.push(icuCase.childIcus);
+    }
+    const tIcu = {
+        type: icuExpression.type,
+        vars,
+        currentCaseLViewIndex: HEADER_OFFSET +
+            expandoStartIndex // expandoStartIndex does not include the header so add it.
+            + 1,
+        childIcus,
+        cases: icuExpression.cases,
+        create: createCodes,
+        remove: removeCodes,
+        update: updateCodes
+    };
+    tIcus.push(tIcu);
+    // Adding the maximum possible of vars needed (based on the cases with the most vars)
+    i18nVarsCount += Math.max(...vars);
+}
+/**
+ * Parses text containing an ICU expression and produces a JSON object for it.
+ * Original code from closure library, modified for Angular.
+ *
+ * @param pattern Text containing an ICU expression that needs to be parsed.
+ *
+ */
+export function parseICUBlock(pattern) {
+    const cases = [];
+    const values = [];
+    let icuType = 1 /* plural */;
+    let mainBinding = 0;
+    pattern = pattern.replace(ICU_BLOCK_REGEXP, function (str, binding, type) {
+        if (type === 'select') {
+            icuType = 0 /* select */;
+        }
+        else {
+            icuType = 1 /* plural */;
+        }
+        mainBinding = parseInt(binding.substr(1), 10);
+        return '';
+    });
+    const parts = extractParts(pattern);
+    // Looking for (key block)+ sequence. One of the keys has to be "other".
+    for (let pos = 0; pos < parts.length;) {
+        let key = parts[pos++].trim();
+        if (icuType === 1 /* plural */) {
+            // Key can be "=x", we just want "x"
+            key = key.replace(/\s*(?:=)?(\w+)\s*/, '$1');
+        }
+        if (key.length) {
+            cases.push(key);
+        }
+        const blocks = extractParts(parts[pos++]);
+        if (cases.length > values.length) {
+            values.push(blocks);
+        }
+    }
+    // TODO(ocombe): support ICU expressions in attributes, see #21615
+    return { type: icuType, mainBinding: mainBinding, cases, values };
+}
+/**
+ * Transforms a string template into an HTML template and a list of instructions used to update
+ * attributes or nodes that contain bindings.
+ *
+ * @param unsafeHtml The string to parse
+ * @param parentIndex
+ * @param nestedIcus
+ * @param tIcus
+ * @param expandoStartIndex
+ */
+function parseIcuCase(unsafeHtml, parentIndex, nestedIcus, tIcus, expandoStartIndex) {
+    const inertBodyHelper = getInertBodyHelper(getDocument());
+    const inertBodyElement = inertBodyHelper.getInertBodyElement(unsafeHtml);
+    if (!inertBodyElement) {
+        throw new Error('Unable to generate inert body element');
+    }
+    const wrapper = getTemplateContent(inertBodyElement) || inertBodyElement;
+    const opCodes = {
+        vars: 1,
+        childIcus: [],
+        create: [],
+        remove: [],
+        update: []
+    };
+    if (ngDevMode) {
+        attachDebugGetter(opCodes.create, i18nMutateOpCodesToString);
+        attachDebugGetter(opCodes.remove, i18nMutateOpCodesToString);
+        attachDebugGetter(opCodes.update, i18nUpdateOpCodesToString);
+    }
+    parseNodes(wrapper.firstChild, opCodes, parentIndex, nestedIcus, tIcus, expandoStartIndex);
+    return opCodes;
+}
+/**
+ * Breaks pattern into strings and top level {...} blocks.
+ * Can be used to break a message into text and ICU expressions, or to break an ICU expression into
+ * keys and cases.
+ * Original code from closure library, modified for Angular.
+ *
+ * @param pattern (sub)Pattern to be broken.
+ *
+ */
+function extractParts(pattern) {
+    if (!pattern) {
+        return [];
+    }
+    let prevPos = 0;
+    const braceStack = [];
+    const results = [];
+    const braces = /[{}]/g;
+    // lastIndex doesn't get set to 0 so we have to.
+    braces.lastIndex = 0;
+    let match;
+    while (match = braces.exec(pattern)) {
+        const pos = match.index;
+        if (match[0] == '}') {
+            braceStack.pop();
+            if (braceStack.length == 0) {
+                // End of the block.
+                const block = pattern.substring(prevPos, pos);
+                if (ICU_BLOCK_REGEXP.test(block)) {
+                    results.push(parseICUBlock(block));
+                }
+                else {
+                    results.push(block);
+                }
+                prevPos = pos + 1;
+            }
+        }
+        else {
+            if (braceStack.length == 0) {
+                const substring = pattern.substring(prevPos, pos);
+                results.push(substring);
+                prevPos = pos + 1;
+            }
+            braceStack.push('{');
+        }
+    }
+    const substring = pattern.substring(prevPos);
+    results.push(substring);
+    return results;
+}
+/**
+ * Parses a node, its children and its siblings, and generates the mutate & update OpCodes.
+ *
+ * @param currentNode The first node to parse
+ * @param icuCase The data for the ICU expression case that contains those nodes
+ * @param parentIndex Index of the current node's parent
+ * @param nestedIcus Data for the nested ICU expressions that this case contains
+ * @param tIcus Data for all ICU expressions of the current message
+ * @param expandoStartIndex Expando start index for the current ICU expression
+ */
+export function parseNodes(currentNode, icuCase, parentIndex, nestedIcus, tIcus, expandoStartIndex) {
+    if (currentNode) {
+        const nestedIcusToCreate = [];
+        while (currentNode) {
+            const nextNode = currentNode.nextSibling;
+            const newIndex = expandoStartIndex + ++icuCase.vars;
+            switch (currentNode.nodeType) {
+                case Node.ELEMENT_NODE:
+                    const element = currentNode;
+                    const tagName = element.tagName.toLowerCase();
+                    if (!VALID_ELEMENTS.hasOwnProperty(tagName)) {
+                        // This isn't a valid element, we won't create an element for it
+                        icuCase.vars--;
+                    }
+                    else {
+                        icuCase.create.push(ELEMENT_MARKER, tagName, newIndex, parentIndex << 17 /* SHIFT_PARENT */ | 1 /* AppendChild */);
+                        const elAttrs = element.attributes;
+                        for (let i = 0; i < elAttrs.length; i++) {
+                            const attr = elAttrs.item(i);
+                            const lowerAttrName = attr.name.toLowerCase();
+                            const hasBinding = !!attr.value.match(BINDING_REGEXP);
+                            // we assume the input string is safe, unless it's using a binding
+                            if (hasBinding) {
+                                if (VALID_ATTRS.hasOwnProperty(lowerAttrName)) {
+                                    if (URI_ATTRS[lowerAttrName]) {
+                                        addAllToArray(generateBindingUpdateOpCodes(attr.value, newIndex, attr.name, _sanitizeUrl), icuCase.update);
+                                    }
+                                    else if (SRCSET_ATTRS[lowerAttrName]) {
+                                        addAllToArray(generateBindingUpdateOpCodes(attr.value, newIndex, attr.name, sanitizeSrcset), icuCase.update);
+                                    }
+                                    else {
+                                        addAllToArray(generateBindingUpdateOpCodes(attr.value, newIndex, attr.name), icuCase.update);
+                                    }
+                                }
+                                else {
+                                    ngDevMode &&
+                                        console.warn(`WARNING: ignoring unsafe attribute value ${lowerAttrName} on element ${tagName} (see http://g.co/ng/security#xss)`);
+                                }
+                            }
+                            else {
+                                icuCase.create.push(newIndex << 3 /* SHIFT_REF */ | 4 /* Attr */, attr.name, attr.value);
+                            }
+                        }
+                        // Parse the children of this node (if any)
+                        parseNodes(currentNode.firstChild, icuCase, newIndex, nestedIcus, tIcus, expandoStartIndex);
+                        // Remove the parent node after the children
+                        icuCase.remove.push(newIndex << 3 /* SHIFT_REF */ | 3 /* Remove */);
+                    }
+                    break;
+                case Node.TEXT_NODE:
+                    const value = currentNode.textContent || '';
+                    const hasBinding = value.match(BINDING_REGEXP);
+                    icuCase.create.push(hasBinding ? '' : value, newIndex, parentIndex << 17 /* SHIFT_PARENT */ | 1 /* AppendChild */);
+                    icuCase.remove.push(newIndex << 3 /* SHIFT_REF */ | 3 /* Remove */);
+                    if (hasBinding) {
+                        addAllToArray(generateBindingUpdateOpCodes(value, newIndex), icuCase.update);
+                    }
+                    break;
+                case Node.COMMENT_NODE:
+                    // Check if the comment node is a placeholder for a nested ICU
+                    const match = NESTED_ICU.exec(currentNode.textContent || '');
+                    if (match) {
+                        const nestedIcuIndex = parseInt(match[1], 10);
+                        const newLocal = ngDevMode ? `nested ICU ${nestedIcuIndex}` : '';
+                        // Create the comment node that will anchor the ICU expression
+                        icuCase.create.push(COMMENT_MARKER, newLocal, newIndex, parentIndex << 17 /* SHIFT_PARENT */ | 1 /* AppendChild */);
+                        const nestedIcu = nestedIcus[nestedIcuIndex];
+                        nestedIcusToCreate.push([nestedIcu, newIndex]);
+                    }
+                    else {
+                        // We do not handle any other type of comment
+                        icuCase.vars--;
+                    }
+                    break;
+                default:
+                    // We do not handle any other type of element
+                    icuCase.vars--;
+            }
+            currentNode = nextNode;
+        }
+        for (let i = 0; i < nestedIcusToCreate.length; i++) {
+            const nestedIcu = nestedIcusToCreate[i][0];
+            const nestedIcuNodeIndex = nestedIcusToCreate[i][1];
+            icuStart(tIcus, nestedIcu, nestedIcuNodeIndex, expandoStartIndex + icuCase.vars);
+            // Since this is recursive, the last TIcu that was pushed is the one we want
+            const nestTIcuIndex = tIcus.length - 1;
+            icuCase.vars += Math.max(...tIcus[nestTIcuIndex].vars);
+            icuCase.childIcus.push(nestTIcuIndex);
+            const mask = getBindingMask(nestedIcu);
+            icuCase.update.push(toMaskBit(nestedIcu.mainBinding), // mask of the main binding
+            3, // skip 3 opCodes if not changed
+            -1 - nestedIcu.mainBinding, nestedIcuNodeIndex << 2 /* SHIFT_REF */ | 2 /* IcuSwitch */, 
+            // FIXME(misko): Index should be part of the opcode
+            nestTIcuIndex, mask, // mask of all the bindings of this ICU expression
+            2, // skip 2 opCodes if not changed
+            nestedIcuNodeIndex << 2 /* SHIFT_REF */ | 3 /* IcuUpdate */, nestTIcuIndex);
+            icuCase.remove.push(nestTIcuIndex << 3 /* SHIFT_REF */ | 6 /* RemoveNestedIcu */, 
+            // FIXME(misko): Index should be part of the opcode
+            nestedIcuNodeIndex << 3 /* SHIFT_REF */ | 3 /* Remove */);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n_parse.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/i18n/i18n_parse.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 '../../util/ng_dev_mode';\nimport '../../util/ng_i18n_closure_mode';\n\nimport {getTemplateContent, SRCSET_ATTRS, URI_ATTRS, VALID_ATTRS, VALID_ELEMENTS} from '../../sanitization/html_sanitizer';\nimport {getInertBodyHelper} from '../../sanitization/inert_body';\nimport {_sanitizeUrl, sanitizeSrcset} from '../../sanitization/url_sanitizer';\nimport {addAllToArray} from '../../util/array_utils';\nimport {assertEqual} from '../../util/assert';\nimport {allocExpando, elementAttributeInternal, setInputsForProperty, setNgReflectProperties} from '../instructions/shared';\nimport {getDocument} from '../interfaces/document';\nimport {COMMENT_MARKER, ELEMENT_MARKER, I18nMutateOpCode, I18nMutateOpCodes, I18nUpdateOpCode, I18nUpdateOpCodes, IcuCase, IcuExpression, IcuType, TI18n, TIcu} from '../interfaces/i18n';\nimport {TNodeType} from '../interfaces/node';\nimport {RComment, RElement} from '../interfaces/renderer';\nimport {SanitizerFn} from '../interfaces/sanitization';\nimport {HEADER_OFFSET, LView, T_HOST, TView} from '../interfaces/view';\nimport {getIsParent, getPreviousOrParentTNode} from '../state';\nimport {attachDebugGetter} from '../util/debug_utils';\nimport {getNativeByIndex, getTNode} from '../util/view_utils';\n\nimport {i18nMutateOpCodesToString, i18nUpdateOpCodesToString} from './i18n_debug';\n\n\n\nconst BINDING_REGEXP = /�(\\d+):?\\d*�/gi;\nconst ICU_REGEXP = /({\\s*�\\d+:?\\d*�\\s*,\\s*\\S{6}\\s*,[\\s\\S]*})/gi;\nconst NESTED_ICU = /�(\\d+)�/;\nconst ICU_BLOCK_REGEXP = /^\\s*(�\\d+:?\\d*�)\\s*,\\s*(select|plural)\\s*,/;\n\n\n// Count for the number of vars that will be allocated for each i18n block.\n// It is global because this is used in multiple functions that include loops and recursive calls.\n// This is reset to 0 when `i18nStartFirstPass` is called.\nlet i18nVarsCount: number;\n\nconst parentIndexStack: number[] = [];\n\nconst MARKER = `�`;\nconst SUBTEMPLATE_REGEXP = /�\\/?\\*(\\d+:\\d+)�/gi;\nconst PH_REGEXP = /�(\\/?[#*!]\\d+):?\\d*�/gi;\nconst enum TagType {\n  ELEMENT = '#',\n  TEMPLATE = '*',\n  PROJECTION = '!',\n}\n\n/**\n * Angular Dart introduced &ngsp; as a placeholder for non-removable space, see:\n * https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart#L25-L32\n * In Angular Dart &ngsp; is converted to the 0xE500 PUA (Private Use Areas) unicode character\n * and later on replaced by a space. We are re-implementing the same idea here, since translations\n * might contain this special character.\n */\nconst NGSP_UNICODE_REGEXP = /\\uE500/g;\nfunction replaceNgsp(value: string): string {\n  return value.replace(NGSP_UNICODE_REGEXP, ' ');\n}\n\n\n/**\n * See `i18nStart` above.\n */\nexport function i18nStartFirstPass(\n    lView: LView, tView: TView, index: number, message: string, subTemplateIndex?: number) {\n  const startIndex = tView.blueprint.length - HEADER_OFFSET;\n  i18nVarsCount = 0;\n  const previousOrParentTNode = getPreviousOrParentTNode();\n  const parentTNode =\n      getIsParent() ? previousOrParentTNode : previousOrParentTNode && previousOrParentTNode.parent;\n  let parentIndex =\n      parentTNode && parentTNode !== lView[T_HOST] ? parentTNode.index - HEADER_OFFSET : index;\n  let parentIndexPointer = 0;\n  parentIndexStack[parentIndexPointer] = parentIndex;\n  const createOpCodes: I18nMutateOpCodes = [];\n  if (ngDevMode) {\n    attachDebugGetter(createOpCodes, i18nMutateOpCodesToString);\n  }\n  // If the previous node wasn't the direct parent then we have a translation without top level\n  // element and we need to keep a reference of the previous element if there is one. We should also\n  // keep track whether an element was a parent node or not, so that the logic that consumes\n  // the generated `I18nMutateOpCode`s can leverage this information to properly set TNode state\n  // (whether it's a parent or sibling).\n  if (index > 0 && previousOrParentTNode !== parentTNode) {\n    let previousTNodeIndex = previousOrParentTNode.index - HEADER_OFFSET;\n    // If current TNode is a sibling node, encode it using a negative index. This information is\n    // required when the `Select` action is processed (see the `readCreateOpCodes` function).\n    if (!getIsParent()) {\n      previousTNodeIndex = ~previousTNodeIndex;\n    }\n    // Create an OpCode to select the previous TNode\n    createOpCodes.push(previousTNodeIndex << I18nMutateOpCode.SHIFT_REF | I18nMutateOpCode.Select);\n  }\n  const updateOpCodes: I18nUpdateOpCodes = [];\n  if (ngDevMode) {\n    attachDebugGetter(updateOpCodes, i18nUpdateOpCodesToString);\n  }\n  const icuExpressions: TIcu[] = [];\n\n  if (message === '' && isRootTemplateMessage(subTemplateIndex)) {\n    // If top level translation is an empty string, do not invoke additional processing\n    // and just create op codes for empty text node instead.\n    createOpCodes.push(\n        message, allocNodeIndex(startIndex),\n        parentIndex << I18nMutateOpCode.SHIFT_PARENT | I18nMutateOpCode.AppendChild);\n  } else {\n    const templateTranslation = getTranslationForTemplate(message, subTemplateIndex);\n    const msgParts = replaceNgsp(templateTranslation).split(PH_REGEXP);\n    for (let i = 0; i < msgParts.length; i++) {\n      let value = msgParts[i];\n      if (i & 1) {\n        // Odd indexes are placeholders (elements and sub-templates)\n        if (value.charAt(0) === '/') {\n          // It is a closing tag\n          if (value.charAt(1) === TagType.ELEMENT) {\n            const phIndex = parseInt(value.substr(2), 10);\n            parentIndex = parentIndexStack[--parentIndexPointer];\n            createOpCodes.push(phIndex << I18nMutateOpCode.SHIFT_REF | I18nMutateOpCode.ElementEnd);\n          }\n        } else {\n          const phIndex = parseInt(value.substr(1), 10);\n          const isElement = value.charAt(0) === TagType.ELEMENT;\n          // The value represents a placeholder that we move to the designated index.\n          // Note: positive indicies indicate that a TNode with a given index should also be marked\n          // as parent while executing `Select` instruction.\n          createOpCodes.push(\n              (isElement ? phIndex : ~phIndex) << I18nMutateOpCode.SHIFT_REF |\n                  I18nMutateOpCode.Select,\n              parentIndex << I18nMutateOpCode.SHIFT_PARENT | I18nMutateOpCode.AppendChild);\n\n          if (isElement) {\n            parentIndexStack[++parentIndexPointer] = parentIndex = phIndex;\n          }\n        }\n      } else {\n        // Even indexes are text (including bindings & ICU expressions)\n        const parts = extractParts(value);\n        for (let j = 0; j < parts.length; j++) {\n          if (j & 1) {\n            // Odd indexes are ICU expressions\n            const icuExpression = parts[j] as IcuExpression;\n\n            // Verify that ICU expression has the right shape. Translations might contain invalid\n            // constructions (while original messages were correct), so ICU parsing at runtime may\n            // not succeed (thus `icuExpression` remains a string).\n            if (typeof icuExpression !== 'object') {\n              throw new Error(\n                  `Unable to parse ICU expression in \"${templateTranslation}\" message.`);\n            }\n\n            // Create the comment node that will anchor the ICU expression\n            const icuNodeIndex = allocNodeIndex(startIndex);\n            createOpCodes.push(\n                COMMENT_MARKER, ngDevMode ? `ICU ${icuNodeIndex}` : '', icuNodeIndex,\n                parentIndex << I18nMutateOpCode.SHIFT_PARENT | I18nMutateOpCode.AppendChild);\n\n            // Update codes for the ICU expression\n            const mask = getBindingMask(icuExpression);\n            icuStart(icuExpressions, icuExpression, icuNodeIndex, icuNodeIndex);\n            // Since this is recursive, the last TIcu that was pushed is the one we want\n            const tIcuIndex = icuExpressions.length - 1;\n            updateOpCodes.push(\n                toMaskBit(icuExpression.mainBinding),  // mask of the main binding\n                3,                                     // skip 3 opCodes if not changed\n                -1 - icuExpression.mainBinding,\n                icuNodeIndex << I18nUpdateOpCode.SHIFT_REF | I18nUpdateOpCode.IcuSwitch, tIcuIndex,\n                mask,  // mask of all the bindings of this ICU expression\n                2,     // skip 2 opCodes if not changed\n                icuNodeIndex << I18nUpdateOpCode.SHIFT_REF | I18nUpdateOpCode.IcuUpdate, tIcuIndex);\n          } else if (parts[j] !== '') {\n            const text = parts[j] as string;\n            // Even indexes are text (including bindings)\n            const hasBinding = text.match(BINDING_REGEXP);\n            // Create text nodes\n            const textNodeIndex = allocNodeIndex(startIndex);\n            createOpCodes.push(\n                // If there is a binding, the value will be set during update\n                hasBinding ? '' : text, textNodeIndex,\n                parentIndex << I18nMutateOpCode.SHIFT_PARENT | I18nMutateOpCode.AppendChild);\n\n            if (hasBinding) {\n              addAllToArray(generateBindingUpdateOpCodes(text, textNodeIndex), updateOpCodes);\n            }\n          }\n        }\n      }\n    }\n  }\n\n  if (i18nVarsCount > 0) {\n    allocExpando(tView, lView, i18nVarsCount);\n  }\n\n  // NOTE: local var needed to properly assert the type of `TI18n`.\n  const tI18n: TI18n = {\n    vars: i18nVarsCount,\n    create: createOpCodes,\n    update: updateOpCodes,\n    icus: icuExpressions.length ? icuExpressions : null,\n  };\n\n  tView.data[index + HEADER_OFFSET] = tI18n;\n}\n\n/**\n * See `i18nAttributes` above.\n */\nexport function i18nAttributesFirstPass(\n    lView: LView, tView: TView, index: number, values: string[]) {\n  const previousElement = getPreviousOrParentTNode();\n  const previousElementIndex = previousElement.index - HEADER_OFFSET;\n  const updateOpCodes: I18nUpdateOpCodes = [];\n  if (ngDevMode) {\n    attachDebugGetter(updateOpCodes, i18nUpdateOpCodesToString);\n  }\n  for (let i = 0; i < values.length; i += 2) {\n    const attrName = values[i];\n    const message = values[i + 1];\n    const parts = message.split(ICU_REGEXP);\n    for (let j = 0; j < parts.length; j++) {\n      const value = parts[j];\n\n      if (j & 1) {\n        // Odd indexes are ICU expressions\n        // TODO(ocombe): support ICU expressions in attributes\n        throw new Error('ICU expressions are not yet supported in attributes');\n      } else if (value !== '') {\n        // Even indexes are text (including bindings)\n        const hasBinding = !!value.match(BINDING_REGEXP);\n        if (hasBinding) {\n          if (tView.firstCreatePass && tView.data[index + HEADER_OFFSET] === null) {\n            addAllToArray(\n                generateBindingUpdateOpCodes(value, previousElementIndex, attrName), updateOpCodes);\n          }\n        } else {\n          const tNode = getTNode(tView, previousElementIndex);\n          // Set attributes for Elements only, for other types (like ElementContainer),\n          // only set inputs below\n          if (tNode.type === TNodeType.Element) {\n            elementAttributeInternal(tNode, lView, attrName, value, null, null);\n          }\n          // Check if that attribute is a directive input\n          const dataValue = tNode.inputs !== null && tNode.inputs[attrName];\n          if (dataValue) {\n            setInputsForProperty(tView, lView, dataValue, attrName, value);\n            if (ngDevMode) {\n              const element = getNativeByIndex(previousElementIndex, lView) as RElement | RComment;\n              setNgReflectProperties(lView, element, tNode.type, dataValue, value);\n            }\n          }\n        }\n      }\n    }\n  }\n\n  if (tView.firstCreatePass && tView.data[index + HEADER_OFFSET] === null) {\n    tView.data[index + HEADER_OFFSET] = updateOpCodes;\n  }\n}\n\n\n/**\n * Generate the OpCodes to update the bindings of a string.\n *\n * @param str The string containing the bindings.\n * @param destinationNode Index of the destination node which will receive the binding.\n * @param attrName Name of the attribute, if the string belongs to an attribute.\n * @param sanitizeFn Sanitization function used to sanitize the string after update, if necessary.\n */\nexport function generateBindingUpdateOpCodes(\n    str: string, destinationNode: number, attrName?: string,\n    sanitizeFn: SanitizerFn|null = null): I18nUpdateOpCodes {\n  const updateOpCodes: I18nUpdateOpCodes = [null, null];  // Alloc space for mask and size\n  if (ngDevMode) {\n    attachDebugGetter(updateOpCodes, i18nUpdateOpCodesToString);\n  }\n  const textParts = str.split(BINDING_REGEXP);\n  let mask = 0;\n\n  for (let j = 0; j < textParts.length; j++) {\n    const textValue = textParts[j];\n\n    if (j & 1) {\n      // Odd indexes are bindings\n      const bindingIndex = parseInt(textValue, 10);\n      updateOpCodes.push(-1 - bindingIndex);\n      mask = mask | toMaskBit(bindingIndex);\n    } else if (textValue !== '') {\n      // Even indexes are text\n      updateOpCodes.push(textValue);\n    }\n  }\n\n  updateOpCodes.push(\n      destinationNode << I18nUpdateOpCode.SHIFT_REF |\n      (attrName ? I18nUpdateOpCode.Attr : I18nUpdateOpCode.Text));\n  if (attrName) {\n    updateOpCodes.push(attrName, sanitizeFn);\n  }\n  updateOpCodes[0] = mask;\n  updateOpCodes[1] = updateOpCodes.length - 2;\n  return updateOpCodes;\n}\n\nfunction getBindingMask(icuExpression: IcuExpression, mask = 0): number {\n  mask = mask | toMaskBit(icuExpression.mainBinding);\n  let match;\n  for (let i = 0; i < icuExpression.values.length; i++) {\n    const valueArr = icuExpression.values[i];\n    for (let j = 0; j < valueArr.length; j++) {\n      const value = valueArr[j];\n      if (typeof value === 'string') {\n        while (match = BINDING_REGEXP.exec(value)) {\n          mask = mask | toMaskBit(parseInt(match[1], 10));\n        }\n      } else {\n        mask = getBindingMask(value as IcuExpression, mask);\n      }\n    }\n  }\n  return mask;\n}\n\nfunction allocNodeIndex(startIndex: number): number {\n  return startIndex + i18nVarsCount++;\n}\n\n\n/**\n * Convert binding index to mask bit.\n *\n * Each index represents a single bit on the bit-mask. Because bit-mask only has 32 bits, we make\n * the 32nd bit share all masks for all bindings higher than 32. Since it is extremely rare to have\n * more than 32 bindings this will be hit very rarely. The downside of hitting this corner case is\n * that we will execute binding code more often than necessary. (penalty of performance)\n */\nfunction toMaskBit(bindingIndex: number): number {\n  return 1 << Math.min(bindingIndex, 31);\n}\n\nexport function isRootTemplateMessage(subTemplateIndex: number|\n                                      undefined): subTemplateIndex is undefined {\n  return subTemplateIndex === undefined;\n}\n\n\n/**\n * Removes everything inside the sub-templates of a message.\n */\nfunction removeInnerTemplateTranslation(message: string): string {\n  let match;\n  let res = '';\n  let index = 0;\n  let inTemplate = false;\n  let tagMatched;\n\n  while ((match = SUBTEMPLATE_REGEXP.exec(message)) !== null) {\n    if (!inTemplate) {\n      res += message.substring(index, match.index + match[0].length);\n      tagMatched = match[1];\n      inTemplate = true;\n    } else {\n      if (match[0] === `${MARKER}/*${tagMatched}${MARKER}`) {\n        index = match.index;\n        inTemplate = false;\n      }\n    }\n  }\n\n  ngDevMode &&\n      assertEqual(\n          inTemplate, false,\n          `Tag mismatch: unable to find the end of the sub-template in the translation \"${\n              message}\"`);\n\n  res += message.substr(index);\n  return res;\n}\n\n\n/**\n * Extracts a part of a message and removes the rest.\n *\n * This method is used for extracting a part of the message associated with a template. A translated\n * message can span multiple templates.\n *\n * Example:\n * ```\n * <div i18n>Translate <span *ngIf>me</span>!</div>\n * ```\n *\n * @param message The message to crop\n * @param subTemplateIndex Index of the sub-template to extract. If undefined it returns the\n * external template and removes all sub-templates.\n */\nexport function getTranslationForTemplate(message: string, subTemplateIndex?: number) {\n  if (isRootTemplateMessage(subTemplateIndex)) {\n    // We want the root template message, ignore all sub-templates\n    return removeInnerTemplateTranslation(message);\n  } else {\n    // We want a specific sub-template\n    const start =\n        message.indexOf(`:${subTemplateIndex}${MARKER}`) + 2 + subTemplateIndex.toString().length;\n    const end = message.search(new RegExp(`${MARKER}\\\\/\\\\*\\\\d+:${subTemplateIndex}${MARKER}`));\n    return removeInnerTemplateTranslation(message.substring(start, end));\n  }\n}\n\n/**\n * Generate the OpCodes for ICU expressions.\n *\n * @param tIcus\n * @param icuExpression\n * @param startIndex\n * @param expandoStartIndex\n */\nexport function icuStart(\n    tIcus: TIcu[], icuExpression: IcuExpression, startIndex: number,\n    expandoStartIndex: number): void {\n  const createCodes: I18nMutateOpCodes[] = [];\n  const removeCodes: I18nMutateOpCodes[] = [];\n  const updateCodes: I18nUpdateOpCodes[] = [];\n  const vars = [];\n  const childIcus: number[][] = [];\n  const values = icuExpression.values;\n  for (let i = 0; i < values.length; i++) {\n    // Each value is an array of strings & other ICU expressions\n    const valueArr = values[i];\n    const nestedIcus: IcuExpression[] = [];\n    for (let j = 0; j < valueArr.length; j++) {\n      const value = valueArr[j];\n      if (typeof value !== 'string') {\n        // It is an nested ICU expression\n        const icuIndex = nestedIcus.push(value as IcuExpression) - 1;\n        // Replace nested ICU expression by a comment node\n        valueArr[j] = `<!--�${icuIndex}�-->`;\n      }\n    }\n    const icuCase: IcuCase =\n        parseIcuCase(valueArr.join(''), startIndex, nestedIcus, tIcus, expandoStartIndex);\n    createCodes.push(icuCase.create);\n    removeCodes.push(icuCase.remove);\n    updateCodes.push(icuCase.update);\n    vars.push(icuCase.vars);\n    childIcus.push(icuCase.childIcus);\n  }\n  const tIcu: TIcu = {\n    type: icuExpression.type,\n    vars,\n    currentCaseLViewIndex: HEADER_OFFSET +\n        expandoStartIndex  // expandoStartIndex does not include the header so add it.\n        + 1,               // The first item stored is the `<!--ICU #-->` anchor so skip it.\n    childIcus,\n    cases: icuExpression.cases,\n    create: createCodes,\n    remove: removeCodes,\n    update: updateCodes\n  };\n  tIcus.push(tIcu);\n  // Adding the maximum possible of vars needed (based on the cases with the most vars)\n  i18nVarsCount += Math.max(...vars);\n}\n\n/**\n * Parses text containing an ICU expression and produces a JSON object for it.\n * Original code from closure library, modified for Angular.\n *\n * @param pattern Text containing an ICU expression that needs to be parsed.\n *\n */\nexport function parseICUBlock(pattern: string): IcuExpression {\n  const cases = [];\n  const values: (string|IcuExpression)[][] = [];\n  let icuType = IcuType.plural;\n  let mainBinding = 0;\n  pattern = pattern.replace(ICU_BLOCK_REGEXP, function(str: string, binding: string, type: string) {\n    if (type === 'select') {\n      icuType = IcuType.select;\n    } else {\n      icuType = IcuType.plural;\n    }\n    mainBinding = parseInt(binding.substr(1), 10);\n    return '';\n  });\n\n  const parts = extractParts(pattern) as string[];\n  // Looking for (key block)+ sequence. One of the keys has to be \"other\".\n  for (let pos = 0; pos < parts.length;) {\n    let key = parts[pos++].trim();\n    if (icuType === IcuType.plural) {\n      // Key can be \"=x\", we just want \"x\"\n      key = key.replace(/\\s*(?:=)?(\\w+)\\s*/, '$1');\n    }\n    if (key.length) {\n      cases.push(key);\n    }\n\n    const blocks = extractParts(parts[pos++]) as string[];\n    if (cases.length > values.length) {\n      values.push(blocks);\n    }\n  }\n\n  // TODO(ocombe): support ICU expressions in attributes, see #21615\n  return {type: icuType, mainBinding: mainBinding, cases, values};\n}\n\n\n/**\n * Transforms a string template into an HTML template and a list of instructions used to update\n * attributes or nodes that contain bindings.\n *\n * @param unsafeHtml The string to parse\n * @param parentIndex\n * @param nestedIcus\n * @param tIcus\n * @param expandoStartIndex\n */\nfunction parseIcuCase(\n    unsafeHtml: string, parentIndex: number, nestedIcus: IcuExpression[], tIcus: TIcu[],\n    expandoStartIndex: number): IcuCase {\n  const inertBodyHelper = getInertBodyHelper(getDocument());\n  const inertBodyElement = inertBodyHelper.getInertBodyElement(unsafeHtml);\n  if (!inertBodyElement) {\n    throw new Error('Unable to generate inert body element');\n  }\n  const wrapper = getTemplateContent(inertBodyElement!) as Element || inertBodyElement;\n  const opCodes: IcuCase = {\n    vars: 1,  // allocate space for `TIcu.currentCaseLViewIndex`\n    childIcus: [],\n    create: [],\n    remove: [],\n    update: []\n  };\n  if (ngDevMode) {\n    attachDebugGetter(opCodes.create, i18nMutateOpCodesToString);\n    attachDebugGetter(opCodes.remove, i18nMutateOpCodesToString);\n    attachDebugGetter(opCodes.update, i18nUpdateOpCodesToString);\n  }\n  parseNodes(wrapper.firstChild, opCodes, parentIndex, nestedIcus, tIcus, expandoStartIndex);\n  return opCodes;\n}\n\n/**\n * Breaks pattern into strings and top level {...} blocks.\n * Can be used to break a message into text and ICU expressions, or to break an ICU expression into\n * keys and cases.\n * Original code from closure library, modified for Angular.\n *\n * @param pattern (sub)Pattern to be broken.\n *\n */\nfunction extractParts(pattern: string): (string|IcuExpression)[] {\n  if (!pattern) {\n    return [];\n  }\n\n  let prevPos = 0;\n  const braceStack = [];\n  const results: (string|IcuExpression)[] = [];\n  const braces = /[{}]/g;\n  // lastIndex doesn't get set to 0 so we have to.\n  braces.lastIndex = 0;\n\n  let match;\n  while (match = braces.exec(pattern)) {\n    const pos = match.index;\n    if (match[0] == '}') {\n      braceStack.pop();\n\n      if (braceStack.length == 0) {\n        // End of the block.\n        const block = pattern.substring(prevPos, pos);\n        if (ICU_BLOCK_REGEXP.test(block)) {\n          results.push(parseICUBlock(block));\n        } else {\n          results.push(block);\n        }\n\n        prevPos = pos + 1;\n      }\n    } else {\n      if (braceStack.length == 0) {\n        const substring = pattern.substring(prevPos, pos);\n        results.push(substring);\n        prevPos = pos + 1;\n      }\n      braceStack.push('{');\n    }\n  }\n\n  const substring = pattern.substring(prevPos);\n  results.push(substring);\n  return results;\n}\n\n\n/**\n * Parses a node, its children and its siblings, and generates the mutate & update OpCodes.\n *\n * @param currentNode The first node to parse\n * @param icuCase The data for the ICU expression case that contains those nodes\n * @param parentIndex Index of the current node's parent\n * @param nestedIcus Data for the nested ICU expressions that this case contains\n * @param tIcus Data for all ICU expressions of the current message\n * @param expandoStartIndex Expando start index for the current ICU expression\n */\nexport function parseNodes(\n    currentNode: Node|null, icuCase: IcuCase, parentIndex: number, nestedIcus: IcuExpression[],\n    tIcus: TIcu[], expandoStartIndex: number) {\n  if (currentNode) {\n    const nestedIcusToCreate: [IcuExpression, number][] = [];\n    while (currentNode) {\n      const nextNode: Node|null = currentNode.nextSibling;\n      const newIndex = expandoStartIndex + ++icuCase.vars;\n      switch (currentNode.nodeType) {\n        case Node.ELEMENT_NODE:\n          const element = currentNode as Element;\n          const tagName = element.tagName.toLowerCase();\n          if (!VALID_ELEMENTS.hasOwnProperty(tagName)) {\n            // This isn't a valid element, we won't create an element for it\n            icuCase.vars--;\n          } else {\n            icuCase.create.push(\n                ELEMENT_MARKER, tagName, newIndex,\n                parentIndex << I18nMutateOpCode.SHIFT_PARENT | I18nMutateOpCode.AppendChild);\n            const elAttrs = element.attributes;\n            for (let i = 0; i < elAttrs.length; i++) {\n              const attr = elAttrs.item(i)!;\n              const lowerAttrName = attr.name.toLowerCase();\n              const hasBinding = !!attr.value.match(BINDING_REGEXP);\n              // we assume the input string is safe, unless it's using a binding\n              if (hasBinding) {\n                if (VALID_ATTRS.hasOwnProperty(lowerAttrName)) {\n                  if (URI_ATTRS[lowerAttrName]) {\n                    addAllToArray(\n                        generateBindingUpdateOpCodes(attr.value, newIndex, attr.name, _sanitizeUrl),\n                        icuCase.update);\n                  } else if (SRCSET_ATTRS[lowerAttrName]) {\n                    addAllToArray(\n                        generateBindingUpdateOpCodes(\n                            attr.value, newIndex, attr.name, sanitizeSrcset),\n                        icuCase.update);\n                  } else {\n                    addAllToArray(\n                        generateBindingUpdateOpCodes(attr.value, newIndex, attr.name),\n                        icuCase.update);\n                  }\n                } else {\n                  ngDevMode &&\n                      console.warn(`WARNING: ignoring unsafe attribute value ${\n                          lowerAttrName} on element ${tagName} (see http://g.co/ng/security#xss)`);\n                }\n              } else {\n                icuCase.create.push(\n                    newIndex << I18nMutateOpCode.SHIFT_REF | I18nMutateOpCode.Attr, attr.name,\n                    attr.value);\n              }\n            }\n            // Parse the children of this node (if any)\n            parseNodes(\n                currentNode.firstChild, icuCase, newIndex, nestedIcus, tIcus, expandoStartIndex);\n            // Remove the parent node after the children\n            icuCase.remove.push(newIndex << I18nMutateOpCode.SHIFT_REF | I18nMutateOpCode.Remove);\n          }\n          break;\n        case Node.TEXT_NODE:\n          const value = currentNode.textContent || '';\n          const hasBinding = value.match(BINDING_REGEXP);\n          icuCase.create.push(\n              hasBinding ? '' : value, newIndex,\n              parentIndex << I18nMutateOpCode.SHIFT_PARENT | I18nMutateOpCode.AppendChild);\n          icuCase.remove.push(newIndex << I18nMutateOpCode.SHIFT_REF | I18nMutateOpCode.Remove);\n          if (hasBinding) {\n            addAllToArray(generateBindingUpdateOpCodes(value, newIndex), icuCase.update);\n          }\n          break;\n        case Node.COMMENT_NODE:\n          // Check if the comment node is a placeholder for a nested ICU\n          const match = NESTED_ICU.exec(currentNode.textContent || '');\n          if (match) {\n            const nestedIcuIndex = parseInt(match[1], 10);\n            const newLocal = ngDevMode ? `nested ICU ${nestedIcuIndex}` : '';\n            // Create the comment node that will anchor the ICU expression\n            icuCase.create.push(\n                COMMENT_MARKER, newLocal, newIndex,\n                parentIndex << I18nMutateOpCode.SHIFT_PARENT | I18nMutateOpCode.AppendChild);\n            const nestedIcu = nestedIcus[nestedIcuIndex];\n            nestedIcusToCreate.push([nestedIcu, newIndex]);\n          } else {\n            // We do not handle any other type of comment\n            icuCase.vars--;\n          }\n          break;\n        default:\n          // We do not handle any other type of element\n          icuCase.vars--;\n      }\n      currentNode = nextNode!;\n    }\n\n    for (let i = 0; i < nestedIcusToCreate.length; i++) {\n      const nestedIcu = nestedIcusToCreate[i][0];\n      const nestedIcuNodeIndex = nestedIcusToCreate[i][1];\n      icuStart(tIcus, nestedIcu, nestedIcuNodeIndex, expandoStartIndex + icuCase.vars);\n      // Since this is recursive, the last TIcu that was pushed is the one we want\n      const nestTIcuIndex = tIcus.length - 1;\n      icuCase.vars += Math.max(...tIcus[nestTIcuIndex].vars);\n      icuCase.childIcus.push(nestTIcuIndex);\n      const mask = getBindingMask(nestedIcu);\n      icuCase.update.push(\n          toMaskBit(nestedIcu.mainBinding),  // mask of the main binding\n          3,                                 // skip 3 opCodes if not changed\n          -1 - nestedIcu.mainBinding,\n          nestedIcuNodeIndex << I18nUpdateOpCode.SHIFT_REF | I18nUpdateOpCode.IcuSwitch,\n          // FIXME(misko): Index should be part of the opcode\n          nestTIcuIndex,\n          mask,  // mask of all the bindings of this ICU expression\n          2,     // skip 2 opCodes if not changed\n          nestedIcuNodeIndex << I18nUpdateOpCode.SHIFT_REF | I18nUpdateOpCode.IcuUpdate,\n          nestTIcuIndex);\n      icuCase.remove.push(\n          nestTIcuIndex << I18nMutateOpCode.SHIFT_REF | I18nMutateOpCode.RemoveNestedIcu,\n          // FIXME(misko): Index should be part of the opcode\n          nestedIcuNodeIndex << I18nMutateOpCode.SHIFT_REF | I18nMutateOpCode.Remove);\n    }\n  }\n}\n"]}