` elements are skipped as they are not rendered as DOM element.\n * @return {?}\n */\n _TreeBuilder.prototype._getParentElementSkippingContainers = function () {\n var /** @type {?} */ container = null;\n for (var /** @type {?} */ i = this._elementStack.length - 1; i >= 0; i--) {\n if (this._elementStack[i].name !== 'ng-container') {\n return { parent: this._elementStack[i], container: container };\n }\n container = this._elementStack[i];\n }\n return { parent: this._elementStack[this._elementStack.length - 1], container: container };\n };\n /**\n * @param {?} node\n * @return {?}\n */\n _TreeBuilder.prototype._addToParent = function (node) {\n var /** @type {?} */ parent = this._getParentElement();\n if (parent != null) {\n parent.children.push(node);\n }\n else {\n this._rootNodes.push(node);\n }\n };\n /**\n * Insert a node between the parent and the container.\n * When no container is given, the node is appended as a child of the parent.\n * Also updates the element stack accordingly.\n *\n * \\@internal\n * @param {?} parent\n * @param {?} container\n * @param {?} node\n * @return {?}\n */\n _TreeBuilder.prototype._insertBeforeContainer = function (parent, container, node) {\n if (!container) {\n this._addToParent(node);\n this._elementStack.push(node);\n }\n else {\n if (parent) {\n // replace the container with the new node in the children\n var /** @type {?} */ index = parent.children.indexOf(container);\n parent.children[index] = node;\n }\n else {\n this._rootNodes.push(node);\n }\n node.children.push(container);\n this._elementStack.splice(this._elementStack.indexOf(container), 0, node);\n }\n };\n /**\n * @param {?} prefix\n * @param {?} localName\n * @param {?} parentElement\n * @return {?}\n */\n _TreeBuilder.prototype._getElementFullName = function (prefix, localName, parentElement) {\n if (prefix == null) {\n prefix = this.getTagDefinition(localName).implicitNamespacePrefix;\n if (prefix == null && parentElement != null) {\n prefix = getNsPrefix(parentElement.name);\n }\n }\n return mergeNsAndName(prefix, localName);\n };\n return _TreeBuilder;\n}());\n/**\n * @param {?} stack\n * @param {?} element\n * @return {?}\n */\nfunction lastOnStack(stack, element) {\n return stack.length > 0 && stack[stack.length - 1] === element;\n}\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar Message = (function () {\n /**\n * @param {?} nodes message AST\n * @param {?} placeholders maps placeholder names to static content\n * @param {?} placeholderToMessage maps placeholder names to messages (used for nested ICU messages)\n * @param {?} meaning\n * @param {?} description\n * @param {?} id\n */\n function Message(nodes, placeholders, placeholderToMessage, meaning, description, id) {\n this.nodes = nodes;\n this.placeholders = placeholders;\n this.placeholderToMessage = placeholderToMessage;\n this.meaning = meaning;\n this.description = description;\n this.id = id;\n }\n return Message;\n}());\nvar Text$1 = (function () {\n /**\n * @param {?} value\n * @param {?} sourceSpan\n */\n function Text$1(value, sourceSpan) {\n this.value = value;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n Text$1.prototype.visit = function (visitor, context) { return visitor.visitText(this, context); };\n return Text$1;\n}());\nvar Container = (function () {\n /**\n * @param {?} children\n * @param {?} sourceSpan\n */\n function Container(children, sourceSpan) {\n this.children = children;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n Container.prototype.visit = function (visitor, context) { return visitor.visitContainer(this, context); };\n return Container;\n}());\nvar Icu = (function () {\n /**\n * @param {?} expression\n * @param {?} type\n * @param {?} cases\n * @param {?} sourceSpan\n */\n function Icu(expression, type, cases, sourceSpan) {\n this.expression = expression;\n this.type = type;\n this.cases = cases;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n Icu.prototype.visit = function (visitor, context) { return visitor.visitIcu(this, context); };\n return Icu;\n}());\nvar TagPlaceholder = (function () {\n /**\n * @param {?} tag\n * @param {?} attrs\n * @param {?} startName\n * @param {?} closeName\n * @param {?} children\n * @param {?} isVoid\n * @param {?} sourceSpan\n */\n function TagPlaceholder(tag, attrs, startName, closeName, children, isVoid, sourceSpan) {\n this.tag = tag;\n this.attrs = attrs;\n this.startName = startName;\n this.closeName = closeName;\n this.children = children;\n this.isVoid = isVoid;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n TagPlaceholder.prototype.visit = function (visitor, context) { return visitor.visitTagPlaceholder(this, context); };\n return TagPlaceholder;\n}());\nvar Placeholder = (function () {\n /**\n * @param {?} value\n * @param {?} name\n * @param {?} sourceSpan\n */\n function Placeholder(value, name, sourceSpan) {\n this.value = value;\n this.name = name;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n Placeholder.prototype.visit = function (visitor, context) { return visitor.visitPlaceholder(this, context); };\n return Placeholder;\n}());\nvar IcuPlaceholder = (function () {\n /**\n * @param {?} value\n * @param {?} name\n * @param {?} sourceSpan\n */\n function IcuPlaceholder(value, name, sourceSpan) {\n this.value = value;\n this.name = name;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n IcuPlaceholder.prototype.visit = function (visitor, context) { return visitor.visitIcuPlaceholder(this, context); };\n return IcuPlaceholder;\n}());\nvar CloneVisitor = (function () {\n function CloneVisitor() {\n }\n /**\n * @param {?} text\n * @param {?=} context\n * @return {?}\n */\n CloneVisitor.prototype.visitText = function (text, context) { return new Text$1(text.value, text.sourceSpan); };\n /**\n * @param {?} container\n * @param {?=} context\n * @return {?}\n */\n CloneVisitor.prototype.visitContainer = function (container, context) {\n var _this = this;\n var /** @type {?} */ children = container.children.map(function (n) { return n.visit(_this, context); });\n return new Container(children, container.sourceSpan);\n };\n /**\n * @param {?} icu\n * @param {?=} context\n * @return {?}\n */\n CloneVisitor.prototype.visitIcu = function (icu, context) {\n var _this = this;\n var /** @type {?} */ cases = {};\n Object.keys(icu.cases).forEach(function (key) { return cases[key] = icu.cases[key].visit(_this, context); });\n var /** @type {?} */ msg = new Icu(icu.expression, icu.type, cases, icu.sourceSpan);\n msg.expressionPlaceholder = icu.expressionPlaceholder;\n return msg;\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n CloneVisitor.prototype.visitTagPlaceholder = function (ph, context) {\n var _this = this;\n var /** @type {?} */ children = ph.children.map(function (n) { return n.visit(_this, context); });\n return new TagPlaceholder(ph.tag, ph.attrs, ph.startName, ph.closeName, children, ph.isVoid, ph.sourceSpan);\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n CloneVisitor.prototype.visitPlaceholder = function (ph, context) {\n return new Placeholder(ph.value, ph.name, ph.sourceSpan);\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n CloneVisitor.prototype.visitIcuPlaceholder = function (ph, context) {\n return new IcuPlaceholder(ph.value, ph.name, ph.sourceSpan);\n };\n return CloneVisitor;\n}());\nvar RecurseVisitor = (function () {\n function RecurseVisitor() {\n }\n /**\n * @param {?} text\n * @param {?=} context\n * @return {?}\n */\n RecurseVisitor.prototype.visitText = function (text, context) { };\n ;\n /**\n * @param {?} container\n * @param {?=} context\n * @return {?}\n */\n RecurseVisitor.prototype.visitContainer = function (container, context) {\n var _this = this;\n container.children.forEach(function (child) { return child.visit(_this); });\n };\n /**\n * @param {?} icu\n * @param {?=} context\n * @return {?}\n */\n RecurseVisitor.prototype.visitIcu = function (icu, context) {\n var _this = this;\n Object.keys(icu.cases).forEach(function (k) { icu.cases[k].visit(_this); });\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n RecurseVisitor.prototype.visitTagPlaceholder = function (ph, context) {\n var _this = this;\n ph.children.forEach(function (child) { return child.visit(_this); });\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n RecurseVisitor.prototype.visitPlaceholder = function (ph, context) { };\n ;\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n RecurseVisitor.prototype.visitIcuPlaceholder = function (ph, context) { };\n ;\n return RecurseVisitor;\n}());\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar TAG_TO_PLACEHOLDER_NAMES = {\n 'A': 'LINK',\n 'B': 'BOLD_TEXT',\n 'BR': 'LINE_BREAK',\n 'EM': 'EMPHASISED_TEXT',\n 'H1': 'HEADING_LEVEL1',\n 'H2': 'HEADING_LEVEL2',\n 'H3': 'HEADING_LEVEL3',\n 'H4': 'HEADING_LEVEL4',\n 'H5': 'HEADING_LEVEL5',\n 'H6': 'HEADING_LEVEL6',\n 'HR': 'HORIZONTAL_RULE',\n 'I': 'ITALIC_TEXT',\n 'LI': 'LIST_ITEM',\n 'LINK': 'MEDIA_LINK',\n 'OL': 'ORDERED_LIST',\n 'P': 'PARAGRAPH',\n 'Q': 'QUOTATION',\n 'S': 'STRIKETHROUGH_TEXT',\n 'SMALL': 'SMALL_TEXT',\n 'SUB': 'SUBSTRIPT',\n 'SUP': 'SUPERSCRIPT',\n 'TBODY': 'TABLE_BODY',\n 'TD': 'TABLE_CELL',\n 'TFOOT': 'TABLE_FOOTER',\n 'TH': 'TABLE_HEADER_CELL',\n 'THEAD': 'TABLE_HEADER',\n 'TR': 'TABLE_ROW',\n 'TT': 'MONOSPACED_TEXT',\n 'U': 'UNDERLINED_TEXT',\n 'UL': 'UNORDERED_LIST',\n};\n/**\n * Creates unique names for placeholder with different content.\n *\n * Returns the same placeholder name when the content is identical.\n *\n * \\@internal\n */\nvar PlaceholderRegistry = (function () {\n function PlaceholderRegistry() {\n this._placeHolderNameCounts = {};\n this._signatureToName = {};\n }\n /**\n * @param {?} tag\n * @param {?} attrs\n * @param {?} isVoid\n * @return {?}\n */\n PlaceholderRegistry.prototype.getStartTagPlaceholderName = function (tag, attrs, isVoid) {\n var /** @type {?} */ signature = this._hashTag(tag, attrs, isVoid);\n if (this._signatureToName[signature]) {\n return this._signatureToName[signature];\n }\n var /** @type {?} */ upperTag = tag.toUpperCase();\n var /** @type {?} */ baseName = TAG_TO_PLACEHOLDER_NAMES[upperTag] || \"TAG_\" + upperTag;\n var /** @type {?} */ name = this._generateUniqueName(isVoid ? baseName : \"START_\" + baseName);\n this._signatureToName[signature] = name;\n return name;\n };\n /**\n * @param {?} tag\n * @return {?}\n */\n PlaceholderRegistry.prototype.getCloseTagPlaceholderName = function (tag) {\n var /** @type {?} */ signature = this._hashClosingTag(tag);\n if (this._signatureToName[signature]) {\n return this._signatureToName[signature];\n }\n var /** @type {?} */ upperTag = tag.toUpperCase();\n var /** @type {?} */ baseName = TAG_TO_PLACEHOLDER_NAMES[upperTag] || \"TAG_\" + upperTag;\n var /** @type {?} */ name = this._generateUniqueName(\"CLOSE_\" + baseName);\n this._signatureToName[signature] = name;\n return name;\n };\n /**\n * @param {?} name\n * @param {?} content\n * @return {?}\n */\n PlaceholderRegistry.prototype.getPlaceholderName = function (name, content) {\n var /** @type {?} */ upperName = name.toUpperCase();\n var /** @type {?} */ signature = \"PH: \" + upperName + \"=\" + content;\n if (this._signatureToName[signature]) {\n return this._signatureToName[signature];\n }\n var /** @type {?} */ uniqueName = this._generateUniqueName(upperName);\n this._signatureToName[signature] = uniqueName;\n return uniqueName;\n };\n /**\n * @param {?} name\n * @return {?}\n */\n PlaceholderRegistry.prototype.getUniquePlaceholder = function (name) {\n return this._generateUniqueName(name.toUpperCase());\n };\n /**\n * @param {?} tag\n * @param {?} attrs\n * @param {?} isVoid\n * @return {?}\n */\n PlaceholderRegistry.prototype._hashTag = function (tag, attrs, isVoid) {\n var /** @type {?} */ start = \"<\" + tag;\n var /** @type {?} */ strAttrs = Object.keys(attrs).sort().map(function (name) { return \" \" + name + \"=\" + attrs[name]; }).join('');\n var /** @type {?} */ end = isVoid ? '/>' : \">\";\n return start + strAttrs + end;\n };\n /**\n * @param {?} tag\n * @return {?}\n */\n PlaceholderRegistry.prototype._hashClosingTag = function (tag) { return this._hashTag(\"/\" + tag, {}, false); };\n /**\n * @param {?} base\n * @return {?}\n */\n PlaceholderRegistry.prototype._generateUniqueName = function (base) {\n var /** @type {?} */ seen = this._placeHolderNameCounts.hasOwnProperty(base);\n if (!seen) {\n this._placeHolderNameCounts[base] = 1;\n return base;\n }\n var /** @type {?} */ id = this._placeHolderNameCounts[base];\n this._placeHolderNameCounts[base] = id + 1;\n return base + \"_\" + id;\n };\n return PlaceholderRegistry;\n}());\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar _expParser = new Parser(new Lexer());\n/**\n * Returns a function converting html nodes to an i18n Message given an interpolationConfig\n * @param {?} interpolationConfig\n * @return {?}\n */\nfunction createI18nMessageFactory(interpolationConfig) {\n var /** @type {?} */ visitor = new _I18nVisitor(_expParser, interpolationConfig);\n return function (nodes, meaning, description, id) { return visitor.toI18nMessage(nodes, meaning, description, id); };\n}\nvar _I18nVisitor = (function () {\n /**\n * @param {?} _expressionParser\n * @param {?} _interpolationConfig\n */\n function _I18nVisitor(_expressionParser, _interpolationConfig) {\n this._expressionParser = _expressionParser;\n this._interpolationConfig = _interpolationConfig;\n }\n /**\n * @param {?} nodes\n * @param {?} meaning\n * @param {?} description\n * @param {?} id\n * @return {?}\n */\n _I18nVisitor.prototype.toI18nMessage = function (nodes, meaning, description, id) {\n this._isIcu = nodes.length == 1 && nodes[0] instanceof Expansion;\n this._icuDepth = 0;\n this._placeholderRegistry = new PlaceholderRegistry();\n this._placeholderToContent = {};\n this._placeholderToMessage = {};\n var /** @type {?} */ i18nodes = visitAll(this, nodes, {});\n return new Message(i18nodes, this._placeholderToContent, this._placeholderToMessage, meaning, description, id);\n };\n /**\n * @param {?} el\n * @param {?} context\n * @return {?}\n */\n _I18nVisitor.prototype.visitElement = function (el, context) {\n var /** @type {?} */ children = visitAll(this, el.children);\n var /** @type {?} */ attrs = {};\n el.attrs.forEach(function (attr) {\n // Do not visit the attributes, translatable ones are top-level ASTs\n attrs[attr.name] = attr.value;\n });\n var /** @type {?} */ isVoid = getHtmlTagDefinition(el.name).isVoid;\n var /** @type {?} */ startPhName = this._placeholderRegistry.getStartTagPlaceholderName(el.name, attrs, isVoid);\n this._placeholderToContent[startPhName] = el.sourceSpan.toString();\n var /** @type {?} */ closePhName = '';\n if (!isVoid) {\n closePhName = this._placeholderRegistry.getCloseTagPlaceholderName(el.name);\n this._placeholderToContent[closePhName] = \"\";\n }\n return new TagPlaceholder(el.name, attrs, startPhName, closePhName, children, isVoid, el.sourceSpan);\n };\n /**\n * @param {?} attribute\n * @param {?} context\n * @return {?}\n */\n _I18nVisitor.prototype.visitAttribute = function (attribute, context) {\n return this._visitTextWithInterpolation(attribute.value, attribute.sourceSpan);\n };\n /**\n * @param {?} text\n * @param {?} context\n * @return {?}\n */\n _I18nVisitor.prototype.visitText = function (text, context) {\n return this._visitTextWithInterpolation(text.value, text.sourceSpan);\n };\n /**\n * @param {?} comment\n * @param {?} context\n * @return {?}\n */\n _I18nVisitor.prototype.visitComment = function (comment, context) { return null; };\n /**\n * @param {?} icu\n * @param {?} context\n * @return {?}\n */\n _I18nVisitor.prototype.visitExpansion = function (icu, context) {\n var _this = this;\n this._icuDepth++;\n var /** @type {?} */ i18nIcuCases = {};\n var /** @type {?} */ i18nIcu = new Icu(icu.switchValue, icu.type, i18nIcuCases, icu.sourceSpan);\n icu.cases.forEach(function (caze) {\n i18nIcuCases[caze.value] = new Container(caze.expression.map(function (node) { return node.visit(_this, {}); }), caze.expSourceSpan);\n });\n this._icuDepth--;\n if (this._isIcu || this._icuDepth > 0) {\n // Returns an ICU node when:\n // - the message (vs a part of the message) is an ICU message, or\n // - the ICU message is nested.\n var /** @type {?} */ expPh = this._placeholderRegistry.getUniquePlaceholder(\"VAR_\" + icu.type);\n i18nIcu.expressionPlaceholder = expPh;\n this._placeholderToContent[expPh] = icu.switchValue;\n return i18nIcu;\n }\n // Else returns a placeholder\n // ICU placeholders should not be replaced with their original content but with the their\n // translations. We need to create a new visitor (they are not re-entrant) to compute the\n // message id.\n // TODO(vicb): add a html.Node -> i18n.Message cache to avoid having to re-create the msg\n var /** @type {?} */ phName = this._placeholderRegistry.getPlaceholderName('ICU', icu.sourceSpan.toString());\n var /** @type {?} */ visitor = new _I18nVisitor(this._expressionParser, this._interpolationConfig);\n this._placeholderToMessage[phName] = visitor.toI18nMessage([icu], '', '', '');\n return new IcuPlaceholder(i18nIcu, phName, icu.sourceSpan);\n };\n /**\n * @param {?} icuCase\n * @param {?} context\n * @return {?}\n */\n _I18nVisitor.prototype.visitExpansionCase = function (icuCase, context) {\n throw new Error('Unreachable code');\n };\n /**\n * @param {?} text\n * @param {?} sourceSpan\n * @return {?}\n */\n _I18nVisitor.prototype._visitTextWithInterpolation = function (text, sourceSpan) {\n var /** @type {?} */ splitInterpolation = this._expressionParser.splitInterpolation(text, sourceSpan.start.toString(), this._interpolationConfig);\n if (!splitInterpolation) {\n // No expression, return a single text\n return new Text$1(text, sourceSpan);\n }\n // Return a group of text + expressions\n var /** @type {?} */ nodes = [];\n var /** @type {?} */ container = new Container(nodes, sourceSpan);\n var _a = this._interpolationConfig, sDelimiter = _a.start, eDelimiter = _a.end;\n for (var /** @type {?} */ i = 0; i < splitInterpolation.strings.length - 1; i++) {\n var /** @type {?} */ expression = splitInterpolation.expressions[i];\n var /** @type {?} */ baseName = _extractPlaceholderName(expression) || 'INTERPOLATION';\n var /** @type {?} */ phName = this._placeholderRegistry.getPlaceholderName(baseName, expression);\n if (splitInterpolation.strings[i].length) {\n // No need to add empty strings\n nodes.push(new Text$1(splitInterpolation.strings[i], sourceSpan));\n }\n nodes.push(new Placeholder(expression, phName, sourceSpan));\n this._placeholderToContent[phName] = sDelimiter + expression + eDelimiter;\n }\n // The last index contains no expression\n var /** @type {?} */ lastStringIdx = splitInterpolation.strings.length - 1;\n if (splitInterpolation.strings[lastStringIdx].length) {\n nodes.push(new Text$1(splitInterpolation.strings[lastStringIdx], sourceSpan));\n }\n return container;\n };\n return _I18nVisitor;\n}());\nvar _CUSTOM_PH_EXP = /\\/\\/[\\s\\S]*i18n[\\s\\S]*\\([\\s\\S]*ph[\\s\\S]*=[\\s\\S]*(\"|')([\\s\\S]*?)\\1[\\s\\S]*\\)/g;\n/**\n * @param {?} input\n * @return {?}\n */\nfunction _extractPlaceholderName(input) {\n return input.split(_CUSTOM_PH_EXP)[2];\n}\n/**\n * @license\n * Copyright Google Inc. 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/**\n * An i18n error.\n */\nvar I18nError = (function (_super) {\n __extends(I18nError, _super);\n /**\n * @param {?} span\n * @param {?} msg\n */\n function I18nError(span, msg) {\n return _super.call(this, span, msg) || this;\n }\n return I18nError;\n}(ParseError));\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar _I18N_ATTR = 'i18n';\nvar _I18N_ATTR_PREFIX = 'i18n-';\nvar _I18N_COMMENT_PREFIX_REGEXP = /^i18n:?/;\nvar MEANING_SEPARATOR = '|';\nvar ID_SEPARATOR = '@@';\n/**\n * Extract translatable messages from an html AST\n * @param {?} nodes\n * @param {?} interpolationConfig\n * @param {?} implicitTags\n * @param {?} implicitAttrs\n * @return {?}\n */\nfunction extractMessages(nodes, interpolationConfig, implicitTags, implicitAttrs) {\n var /** @type {?} */ visitor = new _Visitor(implicitTags, implicitAttrs);\n return visitor.extract(nodes, interpolationConfig);\n}\n/**\n * @param {?} nodes\n * @param {?} translations\n * @param {?} interpolationConfig\n * @param {?} implicitTags\n * @param {?} implicitAttrs\n * @return {?}\n */\nfunction mergeTranslations(nodes, translations, interpolationConfig, implicitTags, implicitAttrs) {\n var /** @type {?} */ visitor = new _Visitor(implicitTags, implicitAttrs);\n return visitor.merge(nodes, translations, interpolationConfig);\n}\nvar ExtractionResult = (function () {\n /**\n * @param {?} messages\n * @param {?} errors\n */\n function ExtractionResult(messages, errors) {\n this.messages = messages;\n this.errors = errors;\n }\n return ExtractionResult;\n}());\nvar _VisitorMode = {};\n_VisitorMode.Extract = 0;\n_VisitorMode.Merge = 1;\n_VisitorMode[_VisitorMode.Extract] = \"Extract\";\n_VisitorMode[_VisitorMode.Merge] = \"Merge\";\n/**\n * This Visitor is used:\n * 1. to extract all the translatable strings from an html AST (see `extract()`),\n * 2. to replace the translatable strings with the actual translations (see `merge()`)\n *\n * \\@internal\n */\nvar _Visitor = (function () {\n /**\n * @param {?} _implicitTags\n * @param {?} _implicitAttrs\n */\n function _Visitor(_implicitTags, _implicitAttrs) {\n this._implicitTags = _implicitTags;\n this._implicitAttrs = _implicitAttrs;\n }\n /**\n * Extracts the messages from the tree\n * @param {?} nodes\n * @param {?} interpolationConfig\n * @return {?}\n */\n _Visitor.prototype.extract = function (nodes, interpolationConfig) {\n var _this = this;\n this._init(_VisitorMode.Extract, interpolationConfig);\n nodes.forEach(function (node) { return node.visit(_this, null); });\n if (this._inI18nBlock) {\n this._reportError(nodes[nodes.length - 1], 'Unclosed block');\n }\n return new ExtractionResult(this._messages, this._errors);\n };\n /**\n * Returns a tree where all translatable nodes are translated\n * @param {?} nodes\n * @param {?} translations\n * @param {?} interpolationConfig\n * @return {?}\n */\n _Visitor.prototype.merge = function (nodes, translations, interpolationConfig) {\n this._init(_VisitorMode.Merge, interpolationConfig);\n this._translations = translations;\n // Construct a single fake root element\n var /** @type {?} */ wrapper = new Element('wrapper', [], nodes, null, null, null);\n var /** @type {?} */ translatedNode = wrapper.visit(this, null);\n if (this._inI18nBlock) {\n this._reportError(nodes[nodes.length - 1], 'Unclosed block');\n }\n return new ParseTreeResult(translatedNode.children, this._errors);\n };\n /**\n * @param {?} icuCase\n * @param {?} context\n * @return {?}\n */\n _Visitor.prototype.visitExpansionCase = function (icuCase, context) {\n // Parse cases for translatable html attributes\n var /** @type {?} */ expression = visitAll(this, icuCase.expression, context);\n if (this._mode === _VisitorMode.Merge) {\n return new ExpansionCase(icuCase.value, expression, icuCase.sourceSpan, icuCase.valueSourceSpan, icuCase.expSourceSpan);\n }\n };\n /**\n * @param {?} icu\n * @param {?} context\n * @return {?}\n */\n _Visitor.prototype.visitExpansion = function (icu, context) {\n this._mayBeAddBlockChildren(icu);\n var /** @type {?} */ wasInIcu = this._inIcu;\n if (!this._inIcu) {\n // nested ICU messages should not be extracted but top-level translated as a whole\n if (this._isInTranslatableSection) {\n this._addMessage([icu]);\n }\n this._inIcu = true;\n }\n var /** @type {?} */ cases = visitAll(this, icu.cases, context);\n if (this._mode === _VisitorMode.Merge) {\n icu = new Expansion(icu.switchValue, icu.type, cases, icu.sourceSpan, icu.switchValueSourceSpan);\n }\n this._inIcu = wasInIcu;\n return icu;\n };\n /**\n * @param {?} comment\n * @param {?} context\n * @return {?}\n */\n _Visitor.prototype.visitComment = function (comment, context) {\n var /** @type {?} */ isOpening = _isOpeningComment(comment);\n if (isOpening && this._isInTranslatableSection) {\n this._reportError(comment, 'Could not start a block inside a translatable section');\n return;\n }\n var /** @type {?} */ isClosing = _isClosingComment(comment);\n if (isClosing && !this._inI18nBlock) {\n this._reportError(comment, 'Trying to close an unopened block');\n return;\n }\n if (!this._inI18nNode && !this._inIcu) {\n if (!this._inI18nBlock) {\n if (isOpening) {\n this._inI18nBlock = true;\n this._blockStartDepth = this._depth;\n this._blockChildren = [];\n this._blockMeaningAndDesc = comment.value.replace(_I18N_COMMENT_PREFIX_REGEXP, '').trim();\n this._openTranslatableSection(comment);\n }\n }\n else {\n if (isClosing) {\n if (this._depth == this._blockStartDepth) {\n this._closeTranslatableSection(comment, this._blockChildren);\n this._inI18nBlock = false;\n var /** @type {?} */ message = this._addMessage(this._blockChildren, this._blockMeaningAndDesc);\n // merge attributes in sections\n var /** @type {?} */ nodes = this._translateMessage(comment, message);\n return visitAll(this, nodes);\n }\n else {\n this._reportError(comment, 'I18N blocks should not cross element boundaries');\n return;\n }\n }\n }\n }\n };\n /**\n * @param {?} text\n * @param {?} context\n * @return {?}\n */\n _Visitor.prototype.visitText = function (text, context) {\n if (this._isInTranslatableSection) {\n this._mayBeAddBlockChildren(text);\n }\n return text;\n };\n /**\n * @param {?} el\n * @param {?} context\n * @return {?}\n */\n _Visitor.prototype.visitElement = function (el, context) {\n var _this = this;\n this._mayBeAddBlockChildren(el);\n this._depth++;\n var /** @type {?} */ wasInI18nNode = this._inI18nNode;\n var /** @type {?} */ wasInImplicitNode = this._inImplicitNode;\n var /** @type {?} */ childNodes = [];\n var /** @type {?} */ translatedChildNodes;\n // Extract:\n // - top level nodes with the (implicit) \"i18n\" attribute if not already in a section\n // - ICU messages\n var /** @type {?} */ i18nAttr = _getI18nAttr(el);\n var /** @type {?} */ i18nMeta = i18nAttr ? i18nAttr.value : '';\n var /** @type {?} */ isImplicit = this._implicitTags.some(function (tag) { return el.name === tag; }) && !this._inIcu &&\n !this._isInTranslatableSection;\n var /** @type {?} */ isTopLevelImplicit = !wasInImplicitNode && isImplicit;\n this._inImplicitNode = wasInImplicitNode || isImplicit;\n if (!this._isInTranslatableSection && !this._inIcu) {\n if (i18nAttr || isTopLevelImplicit) {\n this._inI18nNode = true;\n var /** @type {?} */ message = this._addMessage(el.children, i18nMeta);\n translatedChildNodes = this._translateMessage(el, message);\n }\n if (this._mode == _VisitorMode.Extract) {\n var /** @type {?} */ isTranslatable = i18nAttr || isTopLevelImplicit;\n if (isTranslatable)\n this._openTranslatableSection(el);\n visitAll(this, el.children);\n if (isTranslatable)\n this._closeTranslatableSection(el, el.children);\n }\n }\n else {\n if (i18nAttr || isTopLevelImplicit) {\n this._reportError(el, 'Could not mark an element as translatable inside a translatable section');\n }\n if (this._mode == _VisitorMode.Extract) {\n // Descend into child nodes for extraction\n visitAll(this, el.children);\n }\n }\n if (this._mode === _VisitorMode.Merge) {\n var /** @type {?} */ visitNodes = translatedChildNodes || el.children;\n visitNodes.forEach(function (child) {\n var /** @type {?} */ visited = child.visit(_this, context);\n if (visited && !_this._isInTranslatableSection) {\n // Do not add the children from translatable sections (= i18n blocks here)\n // They will be added later in this loop when the block closes (i.e. on ``)\n childNodes = childNodes.concat(visited);\n }\n });\n }\n this._visitAttributesOf(el);\n this._depth--;\n this._inI18nNode = wasInI18nNode;\n this._inImplicitNode = wasInImplicitNode;\n if (this._mode === _VisitorMode.Merge) {\n var /** @type {?} */ translatedAttrs = this._translateAttributes(el);\n return new Element(el.name, translatedAttrs, childNodes, el.sourceSpan, el.startSourceSpan, el.endSourceSpan);\n }\n };\n /**\n * @param {?} attribute\n * @param {?} context\n * @return {?}\n */\n _Visitor.prototype.visitAttribute = function (attribute, context) {\n throw new Error('unreachable code');\n };\n /**\n * @param {?} mode\n * @param {?} interpolationConfig\n * @return {?}\n */\n _Visitor.prototype._init = function (mode, interpolationConfig) {\n this._mode = mode;\n this._inI18nBlock = false;\n this._inI18nNode = false;\n this._depth = 0;\n this._inIcu = false;\n this._msgCountAtSectionStart = void 0;\n this._errors = [];\n this._messages = [];\n this._inImplicitNode = false;\n this._createI18nMessage = createI18nMessageFactory(interpolationConfig);\n };\n /**\n * @param {?} el\n * @return {?}\n */\n _Visitor.prototype._visitAttributesOf = function (el) {\n var _this = this;\n var /** @type {?} */ explicitAttrNameToValue = {};\n var /** @type {?} */ implicitAttrNames = this._implicitAttrs[el.name] || [];\n el.attrs.filter(function (attr) { return attr.name.startsWith(_I18N_ATTR_PREFIX); })\n .forEach(function (attr) { return explicitAttrNameToValue[attr.name.slice(_I18N_ATTR_PREFIX.length)] =\n attr.value; });\n el.attrs.forEach(function (attr) {\n if (attr.name in explicitAttrNameToValue) {\n _this._addMessage([attr], explicitAttrNameToValue[attr.name]);\n }\n else if (implicitAttrNames.some(function (name) { return attr.name === name; })) {\n _this._addMessage([attr]);\n }\n });\n };\n /**\n * @param {?} ast\n * @param {?=} msgMeta\n * @return {?}\n */\n _Visitor.prototype._addMessage = function (ast, msgMeta) {\n if (ast.length == 0 ||\n ast.length == 1 && ast[0] instanceof Attribute$1 && !((ast[0])).value) {\n // Do not create empty messages\n return;\n }\n var _a = _parseMessageMeta(msgMeta), meaning = _a.meaning, description = _a.description, id = _a.id;\n var /** @type {?} */ message = this._createI18nMessage(ast, meaning, description, id);\n this._messages.push(message);\n return message;\n };\n /**\n * @param {?} el\n * @param {?} message\n * @return {?}\n */\n _Visitor.prototype._translateMessage = function (el, message) {\n if (message && this._mode === _VisitorMode.Merge) {\n var /** @type {?} */ nodes = this._translations.get(message);\n if (nodes) {\n return nodes;\n }\n this._reportError(el, \"Translation unavailable for message id=\\\"\" + this._translations.digest(message) + \"\\\"\");\n }\n return [];\n };\n /**\n * @param {?} el\n * @return {?}\n */\n _Visitor.prototype._translateAttributes = function (el) {\n var _this = this;\n var /** @type {?} */ attributes = el.attrs;\n var /** @type {?} */ i18nParsedMessageMeta = {};\n attributes.forEach(function (attr) {\n if (attr.name.startsWith(_I18N_ATTR_PREFIX)) {\n i18nParsedMessageMeta[attr.name.slice(_I18N_ATTR_PREFIX.length)] =\n _parseMessageMeta(attr.value);\n }\n });\n var /** @type {?} */ translatedAttributes = [];\n attributes.forEach(function (attr) {\n if (attr.name === _I18N_ATTR || attr.name.startsWith(_I18N_ATTR_PREFIX)) {\n // strip i18n specific attributes\n return;\n }\n if (attr.value && attr.value != '' && i18nParsedMessageMeta.hasOwnProperty(attr.name)) {\n var _a = i18nParsedMessageMeta[attr.name], meaning = _a.meaning, description = _a.description, id = _a.id;\n var /** @type {?} */ message = _this._createI18nMessage([attr], meaning, description, id);\n var /** @type {?} */ nodes = _this._translations.get(message);\n if (nodes) {\n if (nodes.length == 0) {\n translatedAttributes.push(new Attribute$1(attr.name, '', attr.sourceSpan));\n }\n else if (nodes[0] instanceof Text) {\n var /** @type {?} */ value = ((nodes[0])).value;\n translatedAttributes.push(new Attribute$1(attr.name, value, attr.sourceSpan));\n }\n else {\n _this._reportError(el, \"Unexpected translation for attribute \\\"\" + attr.name + \"\\\" (id=\\\"\" + (id || _this._translations.digest(message)) + \"\\\")\");\n }\n }\n else {\n _this._reportError(el, \"Translation unavailable for attribute \\\"\" + attr.name + \"\\\" (id=\\\"\" + (id || _this._translations.digest(message)) + \"\\\")\");\n }\n }\n else {\n translatedAttributes.push(attr);\n }\n });\n return translatedAttributes;\n };\n /**\n * Add the node as a child of the block when:\n * - we are in a block,\n * - we are not inside a ICU message (those are handled separately),\n * - the node is a \"direct child\" of the block\n * @param {?} node\n * @return {?}\n */\n _Visitor.prototype._mayBeAddBlockChildren = function (node) {\n if (this._inI18nBlock && !this._inIcu && this._depth == this._blockStartDepth) {\n this._blockChildren.push(node);\n }\n };\n /**\n * Marks the start of a section, see `_closeTranslatableSection`\n * @param {?} node\n * @return {?}\n */\n _Visitor.prototype._openTranslatableSection = function (node) {\n if (this._isInTranslatableSection) {\n this._reportError(node, 'Unexpected section start');\n }\n else {\n this._msgCountAtSectionStart = this._messages.length;\n }\n };\n Object.defineProperty(_Visitor.prototype, \"_isInTranslatableSection\", {\n /**\n * A translatable section could be:\n * - the content of translatable element,\n * - nodes between `` and `` comments\n * @return {?}\n */\n get: function () {\n return this._msgCountAtSectionStart !== void 0;\n },\n enumerable: true,\n configurable: true\n });\n /**\n * Terminates a section.\n *\n * If a section has only one significant children (comments not significant) then we should not\n * keep the message from this children:\n *\n * `{ICU message}
` would produce two messages:\n * - one for the content with meaning and description,\n * - another one for the ICU message.\n *\n * In this case the last message is discarded as it contains less information (the AST is\n * otherwise identical).\n *\n * Note that we should still keep messages extracted from attributes inside the section (ie in the\n * ICU message here)\n * @param {?} node\n * @param {?} directChildren\n * @return {?}\n */\n _Visitor.prototype._closeTranslatableSection = function (node, directChildren) {\n if (!this._isInTranslatableSection) {\n this._reportError(node, 'Unexpected section end');\n return;\n }\n var /** @type {?} */ startIndex = this._msgCountAtSectionStart;\n var /** @type {?} */ significantChildren = directChildren.reduce(function (count, node) { return count + (node instanceof Comment ? 0 : 1); }, 0);\n if (significantChildren == 1) {\n for (var /** @type {?} */ i = this._messages.length - 1; i >= startIndex; i--) {\n var /** @type {?} */ ast = this._messages[i].nodes;\n if (!(ast.length == 1 && ast[0] instanceof Text$1)) {\n this._messages.splice(i, 1);\n break;\n }\n }\n }\n this._msgCountAtSectionStart = void 0;\n };\n /**\n * @param {?} node\n * @param {?} msg\n * @return {?}\n */\n _Visitor.prototype._reportError = function (node, msg) {\n this._errors.push(new I18nError(node.sourceSpan, msg));\n };\n return _Visitor;\n}());\n/**\n * @param {?} n\n * @return {?}\n */\nfunction _isOpeningComment(n) {\n return n instanceof Comment && n.value && n.value.startsWith('i18n');\n}\n/**\n * @param {?} n\n * @return {?}\n */\nfunction _isClosingComment(n) {\n return n instanceof Comment && n.value && n.value === '/i18n';\n}\n/**\n * @param {?} p\n * @return {?}\n */\nfunction _getI18nAttr(p) {\n return p.attrs.find(function (attr) { return attr.name === _I18N_ATTR; }) || null;\n}\n/**\n * @param {?} i18n\n * @return {?}\n */\nfunction _parseMessageMeta(i18n) {\n if (!i18n)\n return { meaning: '', description: '', id: '' };\n var /** @type {?} */ idIndex = i18n.indexOf(ID_SEPARATOR);\n var /** @type {?} */ descIndex = i18n.indexOf(MEANING_SEPARATOR);\n var _a = (idIndex > -1) ? [i18n.slice(0, idIndex), i18n.slice(idIndex + 2)] : [i18n, ''], meaningAndDesc = _a[0], id = _a[1];\n var _b = (descIndex > -1) ?\n [meaningAndDesc.slice(0, descIndex), meaningAndDesc.slice(descIndex + 1)] :\n ['', meaningAndDesc], meaning = _b[0], description = _b[1];\n return { meaning: meaning, description: description, id: id };\n}\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar XmlTagDefinition = (function () {\n function XmlTagDefinition() {\n this.closedByParent = false;\n this.contentType = TagContentType.PARSABLE_DATA;\n this.isVoid = false;\n this.ignoreFirstLf = false;\n this.canSelfClose = true;\n }\n /**\n * @param {?} currentParent\n * @return {?}\n */\n XmlTagDefinition.prototype.requireExtraParent = function (currentParent) { return false; };\n /**\n * @param {?} name\n * @return {?}\n */\n XmlTagDefinition.prototype.isClosedByChild = function (name) { return false; };\n return XmlTagDefinition;\n}());\nvar _TAG_DEFINITION = new XmlTagDefinition();\n/**\n * @param {?} tagName\n * @return {?}\n */\nfunction getXmlTagDefinition(tagName) {\n return _TAG_DEFINITION;\n}\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar XmlParser = (function (_super) {\n __extends(XmlParser, _super);\n function XmlParser() {\n return _super.call(this, getXmlTagDefinition) || this;\n }\n /**\n * @param {?} source\n * @param {?} url\n * @param {?=} parseExpansionForms\n * @return {?}\n */\n XmlParser.prototype.parse = function (source, url, parseExpansionForms) {\n if (parseExpansionForms === void 0) { parseExpansionForms = false; }\n return _super.prototype.parse.call(this, source, url, parseExpansionForms, null);\n };\n return XmlParser;\n}(Parser$1));\n/**\n * @license\n * Copyright Google Inc. 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/**\n * @param {?} message\n * @return {?}\n */\nfunction digest(message) {\n return message.id || sha1(serializeNodes(message.nodes).join('') + (\"[\" + message.meaning + \"]\"));\n}\n/**\n * @param {?} message\n * @return {?}\n */\nfunction decimalDigest(message) {\n if (message.id) {\n return message.id;\n }\n var /** @type {?} */ visitor = new _SerializerIgnoreIcuExpVisitor();\n var /** @type {?} */ parts = message.nodes.map(function (a) { return a.visit(visitor, null); });\n return computeMsgId(parts.join(''), message.meaning);\n}\n/**\n * Serialize the i18n ast to something xml-like in order to generate an UID.\n *\n * The visitor is also used in the i18n parser tests\n *\n * \\@internal\n */\nvar _SerializerVisitor = (function () {\n function _SerializerVisitor() {\n }\n /**\n * @param {?} text\n * @param {?} context\n * @return {?}\n */\n _SerializerVisitor.prototype.visitText = function (text, context) { return text.value; };\n /**\n * @param {?} container\n * @param {?} context\n * @return {?}\n */\n _SerializerVisitor.prototype.visitContainer = function (container, context) {\n var _this = this;\n return \"[\" + container.children.map(function (child) { return child.visit(_this); }).join(', ') + \"]\";\n };\n /**\n * @param {?} icu\n * @param {?} context\n * @return {?}\n */\n _SerializerVisitor.prototype.visitIcu = function (icu, context) {\n var _this = this;\n var /** @type {?} */ strCases = Object.keys(icu.cases).map(function (k) { return k + \" {\" + icu.cases[k].visit(_this) + \"}\"; });\n return \"{\" + icu.expression + \", \" + icu.type + \", \" + strCases.join(', ') + \"}\";\n };\n /**\n * @param {?} ph\n * @param {?} context\n * @return {?}\n */\n _SerializerVisitor.prototype.visitTagPlaceholder = function (ph, context) {\n var _this = this;\n return ph.isVoid ?\n \"\" :\n \"\" + ph.children.map(function (child) { return child.visit(_this); }).join(', ') + \"\";\n };\n /**\n * @param {?} ph\n * @param {?} context\n * @return {?}\n */\n _SerializerVisitor.prototype.visitPlaceholder = function (ph, context) {\n return ph.value ? \"\" + ph.value + \"\" : \"\";\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n _SerializerVisitor.prototype.visitIcuPlaceholder = function (ph, context) {\n return \"\" + ph.value.visit(this) + \"\";\n };\n return _SerializerVisitor;\n}());\nvar serializerVisitor = new _SerializerVisitor();\n/**\n * @param {?} nodes\n * @return {?}\n */\nfunction serializeNodes(nodes) {\n return nodes.map(function (a) { return a.visit(serializerVisitor, null); });\n}\n/**\n * Serialize the i18n ast to something xml-like in order to generate an UID.\n *\n * Ignore the ICU expressions so that message IDs stays identical if only the expression changes.\n *\n * \\@internal\n */\nvar _SerializerIgnoreIcuExpVisitor = (function (_super) {\n __extends(_SerializerIgnoreIcuExpVisitor, _super);\n function _SerializerIgnoreIcuExpVisitor() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n /**\n * @param {?} icu\n * @param {?} context\n * @return {?}\n */\n _SerializerIgnoreIcuExpVisitor.prototype.visitIcu = function (icu, context) {\n var _this = this;\n var /** @type {?} */ strCases = Object.keys(icu.cases).map(function (k) { return k + \" {\" + icu.cases[k].visit(_this) + \"}\"; });\n // Do not take the expression into account\n return \"{\" + icu.type + \", \" + strCases.join(', ') + \"}\";\n };\n return _SerializerIgnoreIcuExpVisitor;\n}(_SerializerVisitor));\n/**\n * Compute the SHA1 of the given string\n *\n * see http://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf\n *\n * WARNING: this function has not been designed not tested with security in mind.\n * DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT.\n * @param {?} str\n * @return {?}\n */\nfunction sha1(str) {\n var /** @type {?} */ utf8 = utf8Encode(str);\n var /** @type {?} */ words32 = stringToWords32(utf8, Endian.Big);\n var /** @type {?} */ len = utf8.length * 8;\n var /** @type {?} */ w = new Array(80);\n var _a = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0], a = _a[0], b = _a[1], c = _a[2], d = _a[3], e = _a[4];\n words32[len >> 5] |= 0x80 << (24 - len % 32);\n words32[((len + 64 >> 9) << 4) + 15] = len;\n for (var /** @type {?} */ i = 0; i < words32.length; i += 16) {\n var _b = [a, b, c, d, e], h0 = _b[0], h1 = _b[1], h2 = _b[2], h3 = _b[3], h4 = _b[4];\n for (var /** @type {?} */ j = 0; j < 80; j++) {\n if (j < 16) {\n w[j] = words32[i + j];\n }\n else {\n w[j] = rol32(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);\n }\n var _c = fk(j, b, c, d), f = _c[0], k = _c[1];\n var /** @type {?} */ temp = [rol32(a, 5), f, e, k, w[j]].reduce(add32);\n _d = [d, c, rol32(b, 30), a, temp], e = _d[0], d = _d[1], c = _d[2], b = _d[3], a = _d[4];\n }\n _e = [add32(a, h0), add32(b, h1), add32(c, h2), add32(d, h3), add32(e, h4)], a = _e[0], b = _e[1], c = _e[2], d = _e[3], e = _e[4];\n }\n return byteStringToHexString(words32ToByteString([a, b, c, d, e]));\n var _d, _e;\n}\n/**\n * @param {?} index\n * @param {?} b\n * @param {?} c\n * @param {?} d\n * @return {?}\n */\nfunction fk(index, b, c, d) {\n if (index < 20) {\n return [(b & c) | (~b & d), 0x5a827999];\n }\n if (index < 40) {\n return [b ^ c ^ d, 0x6ed9eba1];\n }\n if (index < 60) {\n return [(b & c) | (b & d) | (c & d), 0x8f1bbcdc];\n }\n return [b ^ c ^ d, 0xca62c1d6];\n}\n/**\n * Compute the fingerprint of the given string\n *\n * The output is 64 bit number encoded as a decimal string\n *\n * based on:\n * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java\n * @param {?} str\n * @return {?}\n */\nfunction fingerprint(str) {\n var /** @type {?} */ utf8 = utf8Encode(str);\n var _a = [hash32(utf8, 0), hash32(utf8, 102072)], hi = _a[0], lo = _a[1];\n if (hi == 0 && (lo == 0 || lo == 1)) {\n hi = hi ^ 0x130f9bef;\n lo = lo ^ -0x6b5f56d8;\n }\n return [hi, lo];\n}\n/**\n * @param {?} msg\n * @param {?} meaning\n * @return {?}\n */\nfunction computeMsgId(msg, meaning) {\n var _a = fingerprint(msg), hi = _a[0], lo = _a[1];\n if (meaning) {\n var _b = fingerprint(meaning), him = _b[0], lom = _b[1];\n _c = add64(rol64([hi, lo], 1), [him, lom]), hi = _c[0], lo = _c[1];\n }\n return byteStringToDecString(words32ToByteString([hi & 0x7fffffff, lo]));\n var _c;\n}\n/**\n * @param {?} str\n * @param {?} c\n * @return {?}\n */\nfunction hash32(str, c) {\n var _a = [0x9e3779b9, 0x9e3779b9], a = _a[0], b = _a[1];\n var /** @type {?} */ i;\n var /** @type {?} */ len = str.length;\n for (i = 0; i + 12 <= len; i += 12) {\n a = add32(a, wordAt(str, i, Endian.Little));\n b = add32(b, wordAt(str, i + 4, Endian.Little));\n c = add32(c, wordAt(str, i + 8, Endian.Little));\n _b = mix([a, b, c]), a = _b[0], b = _b[1], c = _b[2];\n }\n a = add32(a, wordAt(str, i, Endian.Little));\n b = add32(b, wordAt(str, i + 4, Endian.Little));\n // the first byte of c is reserved for the length\n c = add32(c, len);\n c = add32(c, wordAt(str, i + 8, Endian.Little) << 8);\n return mix([a, b, c])[2];\n var _b;\n}\n/**\n * @param {?} __0\n * @return {?}\n */\nfunction mix(_a) {\n var a = _a[0], b = _a[1], c = _a[2];\n a = sub32(a, b);\n a = sub32(a, c);\n a ^= c >>> 13;\n b = sub32(b, c);\n b = sub32(b, a);\n b ^= a << 8;\n c = sub32(c, a);\n c = sub32(c, b);\n c ^= b >>> 13;\n a = sub32(a, b);\n a = sub32(a, c);\n a ^= c >>> 12;\n b = sub32(b, c);\n b = sub32(b, a);\n b ^= a << 16;\n c = sub32(c, a);\n c = sub32(c, b);\n c ^= b >>> 5;\n a = sub32(a, b);\n a = sub32(a, c);\n a ^= c >>> 3;\n b = sub32(b, c);\n b = sub32(b, a);\n b ^= a << 10;\n c = sub32(c, a);\n c = sub32(c, b);\n c ^= b >>> 15;\n return [a, b, c];\n}\nvar Endian = {};\nEndian.Little = 0;\nEndian.Big = 1;\nEndian[Endian.Little] = \"Little\";\nEndian[Endian.Big] = \"Big\";\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nfunction add32(a, b) {\n return add32to64(a, b)[1];\n}\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nfunction add32to64(a, b) {\n var /** @type {?} */ low = (a & 0xffff) + (b & 0xffff);\n var /** @type {?} */ high = (a >>> 16) + (b >>> 16) + (low >>> 16);\n return [high >>> 16, (high << 16) | (low & 0xffff)];\n}\n/**\n * @param {?} __0\n * @param {?} __1\n * @return {?}\n */\nfunction add64(_a, _b) {\n var ah = _a[0], al = _a[1];\n var bh = _b[0], bl = _b[1];\n var _c = add32to64(al, bl), carry = _c[0], l = _c[1];\n var /** @type {?} */ h = add32(add32(ah, bh), carry);\n return [h, l];\n}\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nfunction sub32(a, b) {\n var /** @type {?} */ low = (a & 0xffff) - (b & 0xffff);\n var /** @type {?} */ high = (a >> 16) - (b >> 16) + (low >> 16);\n return (high << 16) | (low & 0xffff);\n}\n/**\n * @param {?} a\n * @param {?} count\n * @return {?}\n */\nfunction rol32(a, count) {\n return (a << count) | (a >>> (32 - count));\n}\n/**\n * @param {?} __0\n * @param {?} count\n * @return {?}\n */\nfunction rol64(_a, count) {\n var hi = _a[0], lo = _a[1];\n var /** @type {?} */ h = (hi << count) | (lo >>> (32 - count));\n var /** @type {?} */ l = (lo << count) | (hi >>> (32 - count));\n return [h, l];\n}\n/**\n * @param {?} str\n * @param {?} endian\n * @return {?}\n */\nfunction stringToWords32(str, endian) {\n var /** @type {?} */ words32 = Array((str.length + 3) >>> 2);\n for (var /** @type {?} */ i = 0; i < words32.length; i++) {\n words32[i] = wordAt(str, i * 4, endian);\n }\n return words32;\n}\n/**\n * @param {?} str\n * @param {?} index\n * @return {?}\n */\nfunction byteAt(str, index) {\n return index >= str.length ? 0 : str.charCodeAt(index) & 0xff;\n}\n/**\n * @param {?} str\n * @param {?} index\n * @param {?} endian\n * @return {?}\n */\nfunction wordAt(str, index, endian) {\n var /** @type {?} */ word = 0;\n if (endian === Endian.Big) {\n for (var /** @type {?} */ i = 0; i < 4; i++) {\n word += byteAt(str, index + i) << (24 - 8 * i);\n }\n }\n else {\n for (var /** @type {?} */ i = 0; i < 4; i++) {\n word += byteAt(str, index + i) << 8 * i;\n }\n }\n return word;\n}\n/**\n * @param {?} words32\n * @return {?}\n */\nfunction words32ToByteString(words32) {\n return words32.reduce(function (str, word) { return str + word32ToByteString(word); }, '');\n}\n/**\n * @param {?} word\n * @return {?}\n */\nfunction word32ToByteString(word) {\n var /** @type {?} */ str = '';\n for (var /** @type {?} */ i = 0; i < 4; i++) {\n str += String.fromCharCode((word >>> 8 * (3 - i)) & 0xff);\n }\n return str;\n}\n/**\n * @param {?} str\n * @return {?}\n */\nfunction byteStringToHexString(str) {\n var /** @type {?} */ hex = '';\n for (var /** @type {?} */ i = 0; i < str.length; i++) {\n var /** @type {?} */ b = byteAt(str, i);\n hex += (b >>> 4).toString(16) + (b & 0x0f).toString(16);\n }\n return hex.toLowerCase();\n}\n/**\n * @param {?} str\n * @return {?}\n */\nfunction byteStringToDecString(str) {\n var /** @type {?} */ decimal = '';\n var /** @type {?} */ toThePower = '1';\n for (var /** @type {?} */ i = str.length - 1; i >= 0; i--) {\n decimal = addBigInt(decimal, numberTimesBigInt(byteAt(str, i), toThePower));\n toThePower = numberTimesBigInt(256, toThePower);\n }\n return decimal.split('').reverse().join('');\n}\n/**\n * @param {?} x\n * @param {?} y\n * @return {?}\n */\nfunction addBigInt(x, y) {\n var /** @type {?} */ sum = '';\n var /** @type {?} */ len = Math.max(x.length, y.length);\n for (var /** @type {?} */ i = 0, /** @type {?} */ carry = 0; i < len || carry; i++) {\n var /** @type {?} */ tmpSum = carry + +(x[i] || 0) + +(y[i] || 0);\n if (tmpSum >= 10) {\n carry = 1;\n sum += tmpSum - 10;\n }\n else {\n carry = 0;\n sum += tmpSum;\n }\n }\n return sum;\n}\n/**\n * @param {?} num\n * @param {?} b\n * @return {?}\n */\nfunction numberTimesBigInt(num, b) {\n var /** @type {?} */ product = '';\n var /** @type {?} */ bToThePower = b;\n for (; num !== 0; num = num >>> 1) {\n if (num & 1)\n product = addBigInt(product, bToThePower);\n bToThePower = addBigInt(bToThePower, bToThePower);\n }\n return product;\n}\n/**\n * @license\n * Copyright Google Inc. 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/**\n * @abstract\n */\nvar Serializer = (function () {\n function Serializer() {\n }\n /**\n * @abstract\n * @param {?} messages\n * @param {?} locale\n * @return {?}\n */\n Serializer.prototype.write = function (messages, locale) { };\n /**\n * @abstract\n * @param {?} content\n * @param {?} url\n * @return {?}\n */\n Serializer.prototype.load = function (content, url) { };\n /**\n * @abstract\n * @param {?} message\n * @return {?}\n */\n Serializer.prototype.digest = function (message) { };\n /**\n * @param {?} message\n * @return {?}\n */\n Serializer.prototype.createNameMapper = function (message) { return null; };\n return Serializer;\n}());\n/**\n * A simple mapper that take a function to transform an internal name to a public name\n */\nvar SimplePlaceholderMapper = (function (_super) {\n __extends(SimplePlaceholderMapper, _super);\n /**\n * @param {?} message\n * @param {?} mapName\n */\n function SimplePlaceholderMapper(message, mapName) {\n var _this = _super.call(this) || this;\n _this.mapName = mapName;\n _this.internalToPublic = {};\n _this.publicToNextId = {};\n _this.publicToInternal = {};\n message.nodes.forEach(function (node) { return node.visit(_this); });\n return _this;\n }\n /**\n * @param {?} internalName\n * @return {?}\n */\n SimplePlaceholderMapper.prototype.toPublicName = function (internalName) {\n return this.internalToPublic.hasOwnProperty(internalName) ?\n this.internalToPublic[internalName] :\n null;\n };\n /**\n * @param {?} publicName\n * @return {?}\n */\n SimplePlaceholderMapper.prototype.toInternalName = function (publicName) {\n return this.publicToInternal.hasOwnProperty(publicName) ? this.publicToInternal[publicName] :\n null;\n };\n /**\n * @param {?} text\n * @param {?=} context\n * @return {?}\n */\n SimplePlaceholderMapper.prototype.visitText = function (text, context) { return null; };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n SimplePlaceholderMapper.prototype.visitTagPlaceholder = function (ph, context) {\n this.visitPlaceholderName(ph.startName);\n _super.prototype.visitTagPlaceholder.call(this, ph, context);\n this.visitPlaceholderName(ph.closeName);\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n SimplePlaceholderMapper.prototype.visitPlaceholder = function (ph, context) { this.visitPlaceholderName(ph.name); };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n SimplePlaceholderMapper.prototype.visitIcuPlaceholder = function (ph, context) {\n this.visitPlaceholderName(ph.name);\n };\n /**\n * @param {?} internalName\n * @return {?}\n */\n SimplePlaceholderMapper.prototype.visitPlaceholderName = function (internalName) {\n if (!internalName || this.internalToPublic.hasOwnProperty(internalName)) {\n return;\n }\n var /** @type {?} */ publicName = this.mapName(internalName);\n if (this.publicToInternal.hasOwnProperty(publicName)) {\n // Create a new XMB when it has already been used\n var /** @type {?} */ nextId = this.publicToNextId[publicName];\n this.publicToNextId[publicName] = nextId + 1;\n publicName = publicName + \"_\" + nextId;\n }\n else {\n this.publicToNextId[publicName] = 1;\n }\n this.internalToPublic[internalName] = publicName;\n this.publicToInternal[publicName] = internalName;\n };\n return SimplePlaceholderMapper;\n}(RecurseVisitor));\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar _Visitor$1 = (function () {\n function _Visitor$1() {\n }\n /**\n * @param {?} tag\n * @return {?}\n */\n _Visitor$1.prototype.visitTag = function (tag) {\n var _this = this;\n var /** @type {?} */ strAttrs = this._serializeAttributes(tag.attrs);\n if (tag.children.length == 0) {\n return \"<\" + tag.name + strAttrs + \"/>\";\n }\n var /** @type {?} */ strChildren = tag.children.map(function (node) { return node.visit(_this); });\n return \"<\" + tag.name + strAttrs + \">\" + strChildren.join('') + \"\";\n };\n /**\n * @param {?} text\n * @return {?}\n */\n _Visitor$1.prototype.visitText = function (text) { return text.value; };\n /**\n * @param {?} decl\n * @return {?}\n */\n _Visitor$1.prototype.visitDeclaration = function (decl) {\n return \"\";\n };\n /**\n * @param {?} attrs\n * @return {?}\n */\n _Visitor$1.prototype._serializeAttributes = function (attrs) {\n var /** @type {?} */ strAttrs = Object.keys(attrs).map(function (name) { return name + \"=\\\"\" + attrs[name] + \"\\\"\"; }).join(' ');\n return strAttrs.length > 0 ? ' ' + strAttrs : '';\n };\n /**\n * @param {?} doctype\n * @return {?}\n */\n _Visitor$1.prototype.visitDoctype = function (doctype) {\n return \"\";\n };\n return _Visitor$1;\n}());\nvar _visitor = new _Visitor$1();\n/**\n * @param {?} nodes\n * @return {?}\n */\nfunction serialize(nodes) {\n return nodes.map(function (node) { return node.visit(_visitor); }).join('');\n}\nvar Declaration = (function () {\n /**\n * @param {?} unescapedAttrs\n */\n function Declaration(unescapedAttrs) {\n var _this = this;\n this.attrs = {};\n Object.keys(unescapedAttrs).forEach(function (k) {\n _this.attrs[k] = _escapeXml(unescapedAttrs[k]);\n });\n }\n /**\n * @param {?} visitor\n * @return {?}\n */\n Declaration.prototype.visit = function (visitor) { return visitor.visitDeclaration(this); };\n return Declaration;\n}());\nvar Doctype = (function () {\n /**\n * @param {?} rootTag\n * @param {?} dtd\n */\n function Doctype(rootTag, dtd) {\n this.rootTag = rootTag;\n this.dtd = dtd;\n }\n ;\n /**\n * @param {?} visitor\n * @return {?}\n */\n Doctype.prototype.visit = function (visitor) { return visitor.visitDoctype(this); };\n return Doctype;\n}());\nvar Tag = (function () {\n /**\n * @param {?} name\n * @param {?=} unescapedAttrs\n * @param {?=} children\n */\n function Tag(name, unescapedAttrs, children) {\n if (unescapedAttrs === void 0) { unescapedAttrs = {}; }\n if (children === void 0) { children = []; }\n var _this = this;\n this.name = name;\n this.children = children;\n this.attrs = {};\n Object.keys(unescapedAttrs).forEach(function (k) {\n _this.attrs[k] = _escapeXml(unescapedAttrs[k]);\n });\n }\n /**\n * @param {?} visitor\n * @return {?}\n */\n Tag.prototype.visit = function (visitor) { return visitor.visitTag(this); };\n return Tag;\n}());\nvar Text$2 = (function () {\n /**\n * @param {?} unescapedValue\n */\n function Text$2(unescapedValue) {\n this.value = _escapeXml(unescapedValue);\n }\n ;\n /**\n * @param {?} visitor\n * @return {?}\n */\n Text$2.prototype.visit = function (visitor) { return visitor.visitText(this); };\n return Text$2;\n}());\nvar CR = (function (_super) {\n __extends(CR, _super);\n /**\n * @param {?=} ws\n */\n function CR(ws) {\n if (ws === void 0) { ws = 0; }\n return _super.call(this, \"\\n\" + new Array(ws + 1).join(' ')) || this;\n }\n return CR;\n}(Text$2));\nvar _ESCAPED_CHARS = [\n [/&/g, '&'],\n [/\"/g, '"'],\n [/'/g, '''],\n [//g, '>'],\n];\n/**\n * @param {?} text\n * @return {?}\n */\nfunction _escapeXml(text) {\n return _ESCAPED_CHARS.reduce(function (text, entry) { return text.replace(entry[0], entry[1]); }, text);\n}\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar _VERSION = '1.2';\nvar _XMLNS = 'urn:oasis:names:tc:xliff:document:1.2';\n// TODO(vicb): make this a param (s/_/-/)\nvar _DEFAULT_SOURCE_LANG = 'en';\nvar _PLACEHOLDER_TAG = 'x';\nvar _FILE_TAG = 'file';\nvar _SOURCE_TAG = 'source';\nvar _TARGET_TAG = 'target';\nvar _UNIT_TAG = 'trans-unit';\nvar Xliff = (function (_super) {\n __extends(Xliff, _super);\n function Xliff() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n /**\n * @param {?} messages\n * @param {?} locale\n * @return {?}\n */\n Xliff.prototype.write = function (messages, locale) {\n var /** @type {?} */ visitor = new _WriteVisitor();\n var /** @type {?} */ transUnits = [];\n messages.forEach(function (message) {\n var /** @type {?} */ transUnit = new Tag(_UNIT_TAG, { id: message.id, datatype: 'html' });\n transUnit.children.push(new CR(8), new Tag(_SOURCE_TAG, {}, visitor.serialize(message.nodes)), new CR(8), new Tag(_TARGET_TAG));\n if (message.description) {\n transUnit.children.push(new CR(8), new Tag('note', { priority: '1', from: 'description' }, [new Text$2(message.description)]));\n }\n if (message.meaning) {\n transUnit.children.push(new CR(8), new Tag('note', { priority: '1', from: 'meaning' }, [new Text$2(message.meaning)]));\n }\n transUnit.children.push(new CR(6));\n transUnits.push(new CR(6), transUnit);\n });\n var /** @type {?} */ body = new Tag('body', {}, transUnits.concat([new CR(4)]));\n var /** @type {?} */ file = new Tag('file', {\n 'source-language': locale || _DEFAULT_SOURCE_LANG,\n datatype: 'plaintext',\n original: 'ng2.template',\n }, [new CR(4), body, new CR(2)]);\n var /** @type {?} */ xliff = new Tag('xliff', { version: _VERSION, xmlns: _XMLNS }, [new CR(2), file, new CR()]);\n return serialize([\n new Declaration({ version: '1.0', encoding: 'UTF-8' }), new CR(), xliff, new CR()\n ]);\n };\n /**\n * @param {?} content\n * @param {?} url\n * @return {?}\n */\n Xliff.prototype.load = function (content, url) {\n // xliff to xml nodes\n var /** @type {?} */ xliffParser = new XliffParser();\n var _a = xliffParser.parse(content, url), locale = _a.locale, mlNodesByMsgId = _a.mlNodesByMsgId, errors = _a.errors;\n // xml nodes to i18n nodes\n var /** @type {?} */ i18nNodesByMsgId = {};\n var /** @type {?} */ converter = new XmlToI18n();\n Object.keys(mlNodesByMsgId).forEach(function (msgId) {\n var _a = converter.convert(mlNodesByMsgId[msgId]), i18nNodes = _a.i18nNodes, e = _a.errors;\n errors.push.apply(errors, e);\n i18nNodesByMsgId[msgId] = i18nNodes;\n });\n if (errors.length) {\n throw new Error(\"xliff parse errors:\\n\" + errors.join('\\n'));\n }\n return { locale: locale, i18nNodesByMsgId: i18nNodesByMsgId };\n };\n /**\n * @param {?} message\n * @return {?}\n */\n Xliff.prototype.digest = function (message) { return digest(message); };\n return Xliff;\n}(Serializer));\nvar _WriteVisitor = (function () {\n function _WriteVisitor() {\n }\n /**\n * @param {?} text\n * @param {?=} context\n * @return {?}\n */\n _WriteVisitor.prototype.visitText = function (text, context) { return [new Text$2(text.value)]; };\n /**\n * @param {?} container\n * @param {?=} context\n * @return {?}\n */\n _WriteVisitor.prototype.visitContainer = function (container, context) {\n var _this = this;\n var /** @type {?} */ nodes = [];\n container.children.forEach(function (node) { return nodes.push.apply(nodes, node.visit(_this)); });\n return nodes;\n };\n /**\n * @param {?} icu\n * @param {?=} context\n * @return {?}\n */\n _WriteVisitor.prototype.visitIcu = function (icu, context) {\n if (this._isInIcu) {\n // nested ICU is not supported\n throw new Error('xliff does not support nested ICU messages');\n }\n this._isInIcu = true;\n // TODO(vicb): support ICU messages\n // https://lists.oasis-open.org/archives/xliff/201201/msg00028.html\n // http://docs.oasis-open.org/xliff/v1.2/xliff-profile-po/xliff-profile-po-1.2-cd02.html\n var /** @type {?} */ nodes = [];\n this._isInIcu = false;\n return nodes;\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n _WriteVisitor.prototype.visitTagPlaceholder = function (ph, context) {\n var /** @type {?} */ ctype = getCtypeForTag(ph.tag);\n var /** @type {?} */ startTagPh = new Tag(_PLACEHOLDER_TAG, { id: ph.startName, ctype: ctype });\n if (ph.isVoid) {\n // void tags have no children nor closing tags\n return [startTagPh];\n }\n var /** @type {?} */ closeTagPh = new Tag(_PLACEHOLDER_TAG, { id: ph.closeName, ctype: ctype });\n return [startTagPh].concat(this.serialize(ph.children), [closeTagPh]);\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n _WriteVisitor.prototype.visitPlaceholder = function (ph, context) {\n return [new Tag(_PLACEHOLDER_TAG, { id: ph.name })];\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n _WriteVisitor.prototype.visitIcuPlaceholder = function (ph, context) {\n return [new Tag(_PLACEHOLDER_TAG, { id: ph.name })];\n };\n /**\n * @param {?} nodes\n * @return {?}\n */\n _WriteVisitor.prototype.serialize = function (nodes) {\n var _this = this;\n this._isInIcu = false;\n return [].concat.apply([], nodes.map(function (node) { return node.visit(_this); }));\n };\n return _WriteVisitor;\n}());\nvar XliffParser = (function () {\n function XliffParser() {\n this._locale = null;\n }\n /**\n * @param {?} xliff\n * @param {?} url\n * @return {?}\n */\n XliffParser.prototype.parse = function (xliff, url) {\n this._unitMlNodes = [];\n this._mlNodesByMsgId = {};\n var /** @type {?} */ xml = new XmlParser().parse(xliff, url, false);\n this._errors = xml.errors;\n visitAll(this, xml.rootNodes, null);\n return {\n mlNodesByMsgId: this._mlNodesByMsgId,\n errors: this._errors,\n locale: this._locale,\n };\n };\n /**\n * @param {?} element\n * @param {?} context\n * @return {?}\n */\n XliffParser.prototype.visitElement = function (element, context) {\n switch (element.name) {\n case _UNIT_TAG:\n this._unitMlNodes = null;\n var /** @type {?} */ idAttr = element.attrs.find(function (attr) { return attr.name === 'id'; });\n if (!idAttr) {\n this._addError(element, \"<\" + _UNIT_TAG + \"> misses the \\\"id\\\" attribute\");\n }\n else {\n var /** @type {?} */ id = idAttr.value;\n if (this._mlNodesByMsgId.hasOwnProperty(id)) {\n this._addError(element, \"Duplicated translations for msg \" + id);\n }\n else {\n visitAll(this, element.children, null);\n if (this._unitMlNodes) {\n this._mlNodesByMsgId[id] = this._unitMlNodes;\n }\n else {\n this._addError(element, \"Message \" + id + \" misses a translation\");\n }\n }\n }\n break;\n case _SOURCE_TAG:\n // ignore source message\n break;\n case _TARGET_TAG:\n this._unitMlNodes = element.children;\n break;\n case _FILE_TAG:\n var /** @type {?} */ localeAttr = element.attrs.find(function (attr) { return attr.name === 'target-language'; });\n if (localeAttr) {\n this._locale = localeAttr.value;\n }\n visitAll(this, element.children, null);\n break;\n default:\n // TODO(vicb): assert file structure, xliff version\n // For now only recurse on unhandled nodes\n visitAll(this, element.children, null);\n }\n };\n /**\n * @param {?} attribute\n * @param {?} context\n * @return {?}\n */\n XliffParser.prototype.visitAttribute = function (attribute, context) { };\n /**\n * @param {?} text\n * @param {?} context\n * @return {?}\n */\n XliffParser.prototype.visitText = function (text, context) { };\n /**\n * @param {?} comment\n * @param {?} context\n * @return {?}\n */\n XliffParser.prototype.visitComment = function (comment, context) { };\n /**\n * @param {?} expansion\n * @param {?} context\n * @return {?}\n */\n XliffParser.prototype.visitExpansion = function (expansion, context) { };\n /**\n * @param {?} expansionCase\n * @param {?} context\n * @return {?}\n */\n XliffParser.prototype.visitExpansionCase = function (expansionCase, context) { };\n /**\n * @param {?} node\n * @param {?} message\n * @return {?}\n */\n XliffParser.prototype._addError = function (node, message) {\n this._errors.push(new I18nError(node.sourceSpan, message));\n };\n return XliffParser;\n}());\nvar XmlToI18n = (function () {\n function XmlToI18n() {\n }\n /**\n * @param {?} nodes\n * @return {?}\n */\n XmlToI18n.prototype.convert = function (nodes) {\n this._errors = [];\n return {\n i18nNodes: visitAll(this, nodes),\n errors: this._errors,\n };\n };\n /**\n * @param {?} text\n * @param {?} context\n * @return {?}\n */\n XmlToI18n.prototype.visitText = function (text, context) { return new Text$1(text.value, text.sourceSpan); };\n /**\n * @param {?} el\n * @param {?} context\n * @return {?}\n */\n XmlToI18n.prototype.visitElement = function (el, context) {\n if (el.name === _PLACEHOLDER_TAG) {\n var /** @type {?} */ nameAttr = el.attrs.find(function (attr) { return attr.name === 'id'; });\n if (nameAttr) {\n return new Placeholder('', nameAttr.value, el.sourceSpan);\n }\n this._addError(el, \"<\" + _PLACEHOLDER_TAG + \"> misses the \\\"id\\\" attribute\");\n }\n else {\n this._addError(el, \"Unexpected tag\");\n }\n };\n /**\n * @param {?} icu\n * @param {?} context\n * @return {?}\n */\n XmlToI18n.prototype.visitExpansion = function (icu, context) { };\n /**\n * @param {?} icuCase\n * @param {?} context\n * @return {?}\n */\n XmlToI18n.prototype.visitExpansionCase = function (icuCase, context) { };\n /**\n * @param {?} comment\n * @param {?} context\n * @return {?}\n */\n XmlToI18n.prototype.visitComment = function (comment, context) { };\n /**\n * @param {?} attribute\n * @param {?} context\n * @return {?}\n */\n XmlToI18n.prototype.visitAttribute = function (attribute, context) { };\n /**\n * @param {?} node\n * @param {?} message\n * @return {?}\n */\n XmlToI18n.prototype._addError = function (node, message) {\n this._errors.push(new I18nError(node.sourceSpan, message));\n };\n return XmlToI18n;\n}());\n/**\n * @param {?} tag\n * @return {?}\n */\nfunction getCtypeForTag(tag) {\n switch (tag.toLowerCase()) {\n case 'br':\n return 'lb';\n case 'img':\n return 'image';\n default:\n return \"x-\" + tag;\n }\n}\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar _MESSAGES_TAG = 'messagebundle';\nvar _MESSAGE_TAG = 'msg';\nvar _PLACEHOLDER_TAG$1 = 'ph';\nvar _EXEMPLE_TAG = 'ex';\nvar _DOCTYPE = \"\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\";\nvar Xmb = (function (_super) {\n __extends(Xmb, _super);\n function Xmb() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n /**\n * @param {?} messages\n * @param {?} locale\n * @return {?}\n */\n Xmb.prototype.write = function (messages, locale) {\n var /** @type {?} */ exampleVisitor = new ExampleVisitor();\n var /** @type {?} */ visitor = new _Visitor$2();\n var /** @type {?} */ rootNode = new Tag(_MESSAGES_TAG);\n messages.forEach(function (message) {\n var /** @type {?} */ attrs = { id: message.id };\n if (message.description) {\n attrs['desc'] = message.description;\n }\n if (message.meaning) {\n attrs['meaning'] = message.meaning;\n }\n rootNode.children.push(new CR(2), new Tag(_MESSAGE_TAG, attrs, visitor.serialize(message.nodes)));\n });\n rootNode.children.push(new CR());\n return serialize([\n new Declaration({ version: '1.0', encoding: 'UTF-8' }),\n new CR(),\n new Doctype(_MESSAGES_TAG, _DOCTYPE),\n new CR(),\n exampleVisitor.addDefaultExamples(rootNode),\n new CR(),\n ]);\n };\n /**\n * @param {?} content\n * @param {?} url\n * @return {?}\n */\n Xmb.prototype.load = function (content, url) {\n throw new Error('Unsupported');\n };\n /**\n * @param {?} message\n * @return {?}\n */\n Xmb.prototype.digest = function (message) { return digest$1(message); };\n /**\n * @param {?} message\n * @return {?}\n */\n Xmb.prototype.createNameMapper = function (message) {\n return new SimplePlaceholderMapper(message, toPublicName);\n };\n return Xmb;\n}(Serializer));\nvar _Visitor$2 = (function () {\n function _Visitor$2() {\n }\n /**\n * @param {?} text\n * @param {?=} context\n * @return {?}\n */\n _Visitor$2.prototype.visitText = function (text, context) { return [new Text$2(text.value)]; };\n /**\n * @param {?} container\n * @param {?} context\n * @return {?}\n */\n _Visitor$2.prototype.visitContainer = function (container, context) {\n var _this = this;\n var /** @type {?} */ nodes = [];\n container.children.forEach(function (node) { return nodes.push.apply(nodes, node.visit(_this)); });\n return nodes;\n };\n /**\n * @param {?} icu\n * @param {?=} context\n * @return {?}\n */\n _Visitor$2.prototype.visitIcu = function (icu, context) {\n var _this = this;\n var /** @type {?} */ nodes = [new Text$2(\"{\" + icu.expressionPlaceholder + \", \" + icu.type + \", \")];\n Object.keys(icu.cases).forEach(function (c) {\n nodes.push.apply(nodes, [new Text$2(c + \" {\")].concat(icu.cases[c].visit(_this), [new Text$2(\"} \")]));\n });\n nodes.push(new Text$2(\"}\"));\n return nodes;\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n _Visitor$2.prototype.visitTagPlaceholder = function (ph, context) {\n var /** @type {?} */ startEx = new Tag(_EXEMPLE_TAG, {}, [new Text$2(\"<\" + ph.tag + \">\")]);\n var /** @type {?} */ startTagPh = new Tag(_PLACEHOLDER_TAG$1, { name: ph.startName }, [startEx]);\n if (ph.isVoid) {\n // void tags have no children nor closing tags\n return [startTagPh];\n }\n var /** @type {?} */ closeEx = new Tag(_EXEMPLE_TAG, {}, [new Text$2(\"\")]);\n var /** @type {?} */ closeTagPh = new Tag(_PLACEHOLDER_TAG$1, { name: ph.closeName }, [closeEx]);\n return [startTagPh].concat(this.serialize(ph.children), [closeTagPh]);\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n _Visitor$2.prototype.visitPlaceholder = function (ph, context) {\n return [new Tag(_PLACEHOLDER_TAG$1, { name: ph.name })];\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n _Visitor$2.prototype.visitIcuPlaceholder = function (ph, context) {\n return [new Tag(_PLACEHOLDER_TAG$1, { name: ph.name })];\n };\n /**\n * @param {?} nodes\n * @return {?}\n */\n _Visitor$2.prototype.serialize = function (nodes) {\n var _this = this;\n return [].concat.apply([], nodes.map(function (node) { return node.visit(_this); }));\n };\n return _Visitor$2;\n}());\n/**\n * @param {?} message\n * @return {?}\n */\nfunction digest$1(message) {\n return decimalDigest(message);\n}\nvar ExampleVisitor = (function () {\n function ExampleVisitor() {\n }\n /**\n * @param {?} node\n * @return {?}\n */\n ExampleVisitor.prototype.addDefaultExamples = function (node) {\n node.visit(this);\n return node;\n };\n /**\n * @param {?} tag\n * @return {?}\n */\n ExampleVisitor.prototype.visitTag = function (tag) {\n var _this = this;\n if (tag.name === _PLACEHOLDER_TAG$1) {\n if (!tag.children || tag.children.length == 0) {\n var /** @type {?} */ exText = new Text$2(tag.attrs['name'] || '...');\n tag.children = [new Tag(_EXEMPLE_TAG, {}, [exText])];\n }\n }\n else if (tag.children) {\n tag.children.forEach(function (node) { return node.visit(_this); });\n }\n };\n /**\n * @param {?} text\n * @return {?}\n */\n ExampleVisitor.prototype.visitText = function (text) { };\n /**\n * @param {?} decl\n * @return {?}\n */\n ExampleVisitor.prototype.visitDeclaration = function (decl) { };\n /**\n * @param {?} doctype\n * @return {?}\n */\n ExampleVisitor.prototype.visitDoctype = function (doctype) { };\n return ExampleVisitor;\n}());\n/**\n * @param {?} internalName\n * @return {?}\n */\nfunction toPublicName(internalName) {\n return internalName.toUpperCase().replace(/[^A-Z0-9_]/g, '_');\n}\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar _TRANSLATIONS_TAG = 'translationbundle';\nvar _TRANSLATION_TAG = 'translation';\nvar _PLACEHOLDER_TAG$2 = 'ph';\nvar Xtb = (function (_super) {\n __extends(Xtb, _super);\n function Xtb() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n /**\n * @param {?} messages\n * @param {?} locale\n * @return {?}\n */\n Xtb.prototype.write = function (messages, locale) { throw new Error('Unsupported'); };\n /**\n * @param {?} content\n * @param {?} url\n * @return {?}\n */\n Xtb.prototype.load = function (content, url) {\n // xtb to xml nodes\n var /** @type {?} */ xtbParser = new XtbParser();\n var _a = xtbParser.parse(content, url), locale = _a.locale, msgIdToHtml = _a.msgIdToHtml, errors = _a.errors;\n // xml nodes to i18n nodes\n var /** @type {?} */ i18nNodesByMsgId = {};\n var /** @type {?} */ converter = new XmlToI18n$1();\n // Because we should be able to load xtb files that rely on features not supported by angular,\n // we need to delay the conversion of html to i18n nodes so that non angular messages are not\n // converted\n Object.keys(msgIdToHtml).forEach(function (msgId) {\n var /** @type {?} */ valueFn = function () {\n var _a = converter.convert(msgIdToHtml[msgId], url), i18nNodes = _a.i18nNodes, errors = _a.errors;\n if (errors.length) {\n throw new Error(\"xtb parse errors:\\n\" + errors.join('\\n'));\n }\n return i18nNodes;\n };\n createLazyProperty(i18nNodesByMsgId, msgId, valueFn);\n });\n if (errors.length) {\n throw new Error(\"xtb parse errors:\\n\" + errors.join('\\n'));\n }\n return { locale: locale, i18nNodesByMsgId: i18nNodesByMsgId };\n };\n /**\n * @param {?} message\n * @return {?}\n */\n Xtb.prototype.digest = function (message) { return digest$1(message); };\n /**\n * @param {?} message\n * @return {?}\n */\n Xtb.prototype.createNameMapper = function (message) {\n return new SimplePlaceholderMapper(message, toPublicName);\n };\n return Xtb;\n}(Serializer));\n/**\n * @param {?} messages\n * @param {?} id\n * @param {?} valueFn\n * @return {?}\n */\nfunction createLazyProperty(messages, id, valueFn) {\n Object.defineProperty(messages, id, {\n configurable: true,\n enumerable: true,\n get: function () {\n var /** @type {?} */ value = valueFn();\n Object.defineProperty(messages, id, { enumerable: true, value: value });\n return value;\n },\n set: function (_) { throw new Error('Could not overwrite an XTB translation'); },\n });\n}\nvar XtbParser = (function () {\n function XtbParser() {\n this._locale = null;\n }\n /**\n * @param {?} xtb\n * @param {?} url\n * @return {?}\n */\n XtbParser.prototype.parse = function (xtb, url) {\n this._bundleDepth = 0;\n this._msgIdToHtml = {};\n // We can not parse the ICU messages at this point as some messages might not originate\n // from Angular that could not be lex'd.\n var /** @type {?} */ xml = new XmlParser().parse(xtb, url, false);\n this._errors = xml.errors;\n visitAll(this, xml.rootNodes);\n return {\n msgIdToHtml: this._msgIdToHtml,\n errors: this._errors,\n locale: this._locale,\n };\n };\n /**\n * @param {?} element\n * @param {?} context\n * @return {?}\n */\n XtbParser.prototype.visitElement = function (element, context) {\n switch (element.name) {\n case _TRANSLATIONS_TAG:\n this._bundleDepth++;\n if (this._bundleDepth > 1) {\n this._addError(element, \"<\" + _TRANSLATIONS_TAG + \"> elements can not be nested\");\n }\n var /** @type {?} */ langAttr = element.attrs.find(function (attr) { return attr.name === 'lang'; });\n if (langAttr) {\n this._locale = langAttr.value;\n }\n visitAll(this, element.children, null);\n this._bundleDepth--;\n break;\n case _TRANSLATION_TAG:\n var /** @type {?} */ idAttr = element.attrs.find(function (attr) { return attr.name === 'id'; });\n if (!idAttr) {\n this._addError(element, \"<\" + _TRANSLATION_TAG + \"> misses the \\\"id\\\" attribute\");\n }\n else {\n var /** @type {?} */ id = idAttr.value;\n if (this._msgIdToHtml.hasOwnProperty(id)) {\n this._addError(element, \"Duplicated translations for msg \" + id);\n }\n else {\n var /** @type {?} */ innerTextStart = element.startSourceSpan.end.offset;\n var /** @type {?} */ innerTextEnd = element.endSourceSpan.start.offset;\n var /** @type {?} */ content = element.startSourceSpan.start.file.content;\n var /** @type {?} */ innerText = content.slice(innerTextStart, innerTextEnd);\n this._msgIdToHtml[id] = innerText;\n }\n }\n break;\n default:\n this._addError(element, 'Unexpected tag');\n }\n };\n /**\n * @param {?} attribute\n * @param {?} context\n * @return {?}\n */\n XtbParser.prototype.visitAttribute = function (attribute, context) { };\n /**\n * @param {?} text\n * @param {?} context\n * @return {?}\n */\n XtbParser.prototype.visitText = function (text, context) { };\n /**\n * @param {?} comment\n * @param {?} context\n * @return {?}\n */\n XtbParser.prototype.visitComment = function (comment, context) { };\n /**\n * @param {?} expansion\n * @param {?} context\n * @return {?}\n */\n XtbParser.prototype.visitExpansion = function (expansion, context) { };\n /**\n * @param {?} expansionCase\n * @param {?} context\n * @return {?}\n */\n XtbParser.prototype.visitExpansionCase = function (expansionCase, context) { };\n /**\n * @param {?} node\n * @param {?} message\n * @return {?}\n */\n XtbParser.prototype._addError = function (node, message) {\n this._errors.push(new I18nError(node.sourceSpan, message));\n };\n return XtbParser;\n}());\nvar XmlToI18n$1 = (function () {\n function XmlToI18n$1() {\n }\n /**\n * @param {?} message\n * @param {?} url\n * @return {?}\n */\n XmlToI18n$1.prototype.convert = function (message, url) {\n var /** @type {?} */ xmlIcu = new XmlParser().parse(message, url, true);\n this._errors = xmlIcu.errors;\n var /** @type {?} */ i18nNodes = this._errors.length > 0 || xmlIcu.rootNodes.length == 0 ?\n [] :\n visitAll(this, xmlIcu.rootNodes);\n return {\n i18nNodes: i18nNodes,\n errors: this._errors,\n };\n };\n /**\n * @param {?} text\n * @param {?} context\n * @return {?}\n */\n XmlToI18n$1.prototype.visitText = function (text, context) { return new Text$1(text.value, text.sourceSpan); };\n /**\n * @param {?} icu\n * @param {?} context\n * @return {?}\n */\n XmlToI18n$1.prototype.visitExpansion = function (icu, context) {\n var /** @type {?} */ caseMap = {};\n visitAll(this, icu.cases).forEach(function (c) {\n caseMap[c.value] = new Container(c.nodes, icu.sourceSpan);\n });\n return new Icu(icu.switchValue, icu.type, caseMap, icu.sourceSpan);\n };\n /**\n * @param {?} icuCase\n * @param {?} context\n * @return {?}\n */\n XmlToI18n$1.prototype.visitExpansionCase = function (icuCase, context) {\n return {\n value: icuCase.value,\n nodes: visitAll(this, icuCase.expression),\n };\n };\n /**\n * @param {?} el\n * @param {?} context\n * @return {?}\n */\n XmlToI18n$1.prototype.visitElement = function (el, context) {\n if (el.name === _PLACEHOLDER_TAG$2) {\n var /** @type {?} */ nameAttr = el.attrs.find(function (attr) { return attr.name === 'name'; });\n if (nameAttr) {\n return new Placeholder('', nameAttr.value, el.sourceSpan);\n }\n this._addError(el, \"<\" + _PLACEHOLDER_TAG$2 + \"> misses the \\\"name\\\" attribute\");\n }\n else {\n this._addError(el, \"Unexpected tag\");\n }\n };\n /**\n * @param {?} comment\n * @param {?} context\n * @return {?}\n */\n XmlToI18n$1.prototype.visitComment = function (comment, context) { };\n /**\n * @param {?} attribute\n * @param {?} context\n * @return {?}\n */\n XmlToI18n$1.prototype.visitAttribute = function (attribute, context) { };\n /**\n * @param {?} node\n * @param {?} message\n * @return {?}\n */\n XmlToI18n$1.prototype._addError = function (node, message) {\n this._errors.push(new I18nError(node.sourceSpan, message));\n };\n return XmlToI18n$1;\n}());\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar HtmlParser = (function (_super) {\n __extends(HtmlParser, _super);\n function HtmlParser() {\n return _super.call(this, getHtmlTagDefinition) || this;\n }\n /**\n * @param {?} source\n * @param {?} url\n * @param {?=} parseExpansionForms\n * @param {?=} interpolationConfig\n * @return {?}\n */\n HtmlParser.prototype.parse = function (source, url, parseExpansionForms, interpolationConfig) {\n if (parseExpansionForms === void 0) { parseExpansionForms = false; }\n if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n return _super.prototype.parse.call(this, source, url, parseExpansionForms, interpolationConfig);\n };\n return HtmlParser;\n}(Parser$1));\nHtmlParser.decorators = [\n { type: CompilerInjectable },\n];\n/**\n * @nocollapse\n */\nHtmlParser.ctorParameters = function () { return []; };\n/**\n * @license\n * Copyright Google Inc. 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/**\n * A container for translated messages\n */\nvar TranslationBundle = (function () {\n /**\n * @param {?=} _i18nNodesByMsgId\n * @param {?=} locale\n * @param {?=} digest\n * @param {?=} mapperFactory\n * @param {?=} missingTranslationStrategy\n * @param {?=} console\n */\n function TranslationBundle(_i18nNodesByMsgId, locale, digest, mapperFactory, missingTranslationStrategy, console) {\n if (_i18nNodesByMsgId === void 0) { _i18nNodesByMsgId = {}; }\n if (missingTranslationStrategy === void 0) { missingTranslationStrategy = MissingTranslationStrategy.Warning; }\n this._i18nNodesByMsgId = _i18nNodesByMsgId;\n this.digest = digest;\n this.mapperFactory = mapperFactory;\n this._i18nToHtml = new I18nToHtmlVisitor(_i18nNodesByMsgId, locale, digest, mapperFactory, missingTranslationStrategy, console);\n }\n /**\n * @param {?} content\n * @param {?} url\n * @param {?} serializer\n * @param {?} missingTranslationStrategy\n * @param {?=} console\n * @return {?}\n */\n TranslationBundle.load = function (content, url, serializer, missingTranslationStrategy, console) {\n var _a = serializer.load(content, url), locale = _a.locale, i18nNodesByMsgId = _a.i18nNodesByMsgId;\n var /** @type {?} */ digestFn = function (m) { return serializer.digest(m); };\n var /** @type {?} */ mapperFactory = function (m) { return serializer.createNameMapper(m); };\n return new TranslationBundle(i18nNodesByMsgId, locale, digestFn, mapperFactory, missingTranslationStrategy, console);\n };\n /**\n * @param {?} srcMsg\n * @return {?}\n */\n TranslationBundle.prototype.get = function (srcMsg) {\n var /** @type {?} */ html = this._i18nToHtml.convert(srcMsg);\n if (html.errors.length) {\n throw new Error(html.errors.join('\\n'));\n }\n return html.nodes;\n };\n /**\n * @param {?} srcMsg\n * @return {?}\n */\n TranslationBundle.prototype.has = function (srcMsg) { return this.digest(srcMsg) in this._i18nNodesByMsgId; };\n return TranslationBundle;\n}());\nvar I18nToHtmlVisitor = (function () {\n /**\n * @param {?=} _i18nNodesByMsgId\n * @param {?=} _locale\n * @param {?=} _digest\n * @param {?=} _mapperFactory\n * @param {?=} _missingTranslationStrategy\n * @param {?=} _console\n */\n function I18nToHtmlVisitor(_i18nNodesByMsgId, _locale, _digest, _mapperFactory, _missingTranslationStrategy, _console) {\n if (_i18nNodesByMsgId === void 0) { _i18nNodesByMsgId = {}; }\n this._i18nNodesByMsgId = _i18nNodesByMsgId;\n this._locale = _locale;\n this._digest = _digest;\n this._mapperFactory = _mapperFactory;\n this._missingTranslationStrategy = _missingTranslationStrategy;\n this._console = _console;\n this._contextStack = [];\n this._errors = [];\n }\n /**\n * @param {?} srcMsg\n * @return {?}\n */\n I18nToHtmlVisitor.prototype.convert = function (srcMsg) {\n this._contextStack.length = 0;\n this._errors.length = 0;\n // i18n to text\n var /** @type {?} */ text = this._convertToText(srcMsg);\n // text to html\n var /** @type {?} */ url = srcMsg.nodes[0].sourceSpan.start.file.url;\n var /** @type {?} */ html = new HtmlParser().parse(text, url, true);\n return {\n nodes: html.rootNodes,\n errors: this._errors.concat(html.errors),\n };\n };\n /**\n * @param {?} text\n * @param {?=} context\n * @return {?}\n */\n I18nToHtmlVisitor.prototype.visitText = function (text, context) { return text.value; };\n /**\n * @param {?} container\n * @param {?=} context\n * @return {?}\n */\n I18nToHtmlVisitor.prototype.visitContainer = function (container, context) {\n var _this = this;\n return container.children.map(function (n) { return n.visit(_this); }).join('');\n };\n /**\n * @param {?} icu\n * @param {?=} context\n * @return {?}\n */\n I18nToHtmlVisitor.prototype.visitIcu = function (icu, context) {\n var _this = this;\n var /** @type {?} */ cases = Object.keys(icu.cases).map(function (k) { return k + \" {\" + icu.cases[k].visit(_this) + \"}\"; });\n // TODO(vicb): Once all format switch to using expression placeholders\n // we should throw when the placeholder is not in the source message\n var /** @type {?} */ exp = this._srcMsg.placeholders.hasOwnProperty(icu.expression) ?\n this._srcMsg.placeholders[icu.expression] :\n icu.expression;\n return \"{\" + exp + \", \" + icu.type + \", \" + cases.join(' ') + \"}\";\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n I18nToHtmlVisitor.prototype.visitPlaceholder = function (ph, context) {\n var /** @type {?} */ phName = this._mapper(ph.name);\n if (this._srcMsg.placeholders.hasOwnProperty(phName)) {\n return this._srcMsg.placeholders[phName];\n }\n if (this._srcMsg.placeholderToMessage.hasOwnProperty(phName)) {\n return this._convertToText(this._srcMsg.placeholderToMessage[phName]);\n }\n this._addError(ph, \"Unknown placeholder \\\"\" + ph.name + \"\\\"\");\n return '';\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n I18nToHtmlVisitor.prototype.visitTagPlaceholder = function (ph, context) {\n var _this = this;\n var /** @type {?} */ tag = \"\" + ph.tag;\n var /** @type {?} */ attrs = Object.keys(ph.attrs).map(function (name) { return name + \"=\\\"\" + ph.attrs[name] + \"\\\"\"; }).join(' ');\n if (ph.isVoid) {\n return \"<\" + tag + \" \" + attrs + \"/>\";\n }\n var /** @type {?} */ children = ph.children.map(function (c) { return c.visit(_this); }).join('');\n return \"<\" + tag + \" \" + attrs + \">\" + children + \"\";\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n I18nToHtmlVisitor.prototype.visitIcuPlaceholder = function (ph, context) {\n // An ICU placeholder references the source message to be serialized\n return this._convertToText(this._srcMsg.placeholderToMessage[ph.name]);\n };\n /**\n * Convert a source message to a translated text string:\n * - text nodes are replaced with their translation,\n * - placeholders are replaced with their content,\n * - ICU nodes are converted to ICU expressions.\n * @param {?} srcMsg\n * @return {?}\n */\n I18nToHtmlVisitor.prototype._convertToText = function (srcMsg) {\n var _this = this;\n var /** @type {?} */ id = this._digest(srcMsg);\n var /** @type {?} */ mapper = this._mapperFactory ? this._mapperFactory(srcMsg) : null;\n var /** @type {?} */ nodes;\n this._contextStack.push({ msg: this._srcMsg, mapper: this._mapper });\n this._srcMsg = srcMsg;\n if (this._i18nNodesByMsgId.hasOwnProperty(id)) {\n // When there is a translation use its nodes as the source\n // And create a mapper to convert serialized placeholder names to internal names\n nodes = this._i18nNodesByMsgId[id];\n this._mapper = function (name) { return mapper ? mapper.toInternalName(name) : name; };\n }\n else {\n // When no translation has been found\n // - report an error / a warning / nothing,\n // - use the nodes from the original message\n // - placeholders are already internal and need no mapper\n if (this._missingTranslationStrategy === MissingTranslationStrategy.Error) {\n var /** @type {?} */ ctx = this._locale ? \" for locale \\\"\" + this._locale + \"\\\"\" : '';\n this._addError(srcMsg.nodes[0], \"Missing translation for message \\\"\" + id + \"\\\"\" + ctx);\n }\n else if (this._console &&\n this._missingTranslationStrategy === MissingTranslationStrategy.Warning) {\n var /** @type {?} */ ctx = this._locale ? \" for locale \\\"\" + this._locale + \"\\\"\" : '';\n this._console.warn(\"Missing translation for message \\\"\" + id + \"\\\"\" + ctx);\n }\n nodes = srcMsg.nodes;\n this._mapper = function (name) { return name; };\n }\n var /** @type {?} */ text = nodes.map(function (node) { return node.visit(_this); }).join('');\n var /** @type {?} */ context = this._contextStack.pop();\n this._srcMsg = context.msg;\n this._mapper = context.mapper;\n return text;\n };\n /**\n * @param {?} el\n * @param {?} msg\n * @return {?}\n */\n I18nToHtmlVisitor.prototype._addError = function (el, msg) {\n this._errors.push(new I18nError(el.sourceSpan, msg));\n };\n return I18nToHtmlVisitor;\n}());\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar I18NHtmlParser = (function () {\n /**\n * @param {?} _htmlParser\n * @param {?=} translations\n * @param {?=} translationsFormat\n * @param {?=} missingTranslation\n * @param {?=} console\n */\n function I18NHtmlParser(_htmlParser, translations, translationsFormat, missingTranslation, console) {\n if (missingTranslation === void 0) { missingTranslation = MissingTranslationStrategy.Warning; }\n this._htmlParser = _htmlParser;\n if (translations) {\n var serializer = createSerializer(translationsFormat);\n this._translationBundle =\n TranslationBundle.load(translations, 'i18n', serializer, missingTranslation, console);\n }\n }\n /**\n * @param {?} source\n * @param {?} url\n * @param {?=} parseExpansionForms\n * @param {?=} interpolationConfig\n * @return {?}\n */\n I18NHtmlParser.prototype.parse = function (source, url, parseExpansionForms, interpolationConfig) {\n if (parseExpansionForms === void 0) { parseExpansionForms = false; }\n if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n var /** @type {?} */ parseResult = this._htmlParser.parse(source, url, parseExpansionForms, interpolationConfig);\n if (!this._translationBundle) {\n // Do not enable i18n when no translation bundle is provided\n return parseResult;\n }\n if (parseResult.errors.length) {\n return new ParseTreeResult(parseResult.rootNodes, parseResult.errors);\n }\n return mergeTranslations(parseResult.rootNodes, this._translationBundle, interpolationConfig, [], {});\n };\n return I18NHtmlParser;\n}());\n/**\n * @param {?=} format\n * @return {?}\n */\nfunction createSerializer(format) {\n format = (format || 'xlf').toLowerCase();\n switch (format) {\n case 'xmb':\n return new Xmb();\n case 'xtb':\n return new Xtb();\n case 'xliff':\n case 'xlf':\n default:\n return new Xliff();\n }\n}\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar CORE = assetUrl('core');\nvar Identifiers = (function () {\n function Identifiers() {\n }\n return Identifiers;\n}());\nIdentifiers.ANALYZE_FOR_ENTRY_COMPONENTS = {\n name: 'ANALYZE_FOR_ENTRY_COMPONENTS',\n moduleUrl: CORE,\n runtime: ANALYZE_FOR_ENTRY_COMPONENTS\n};\nIdentifiers.ElementRef = { name: 'ElementRef', moduleUrl: CORE, runtime: ElementRef };\nIdentifiers.NgModuleRef = { name: 'NgModuleRef', moduleUrl: CORE, runtime: NgModuleRef };\nIdentifiers.ViewContainerRef = { name: 'ViewContainerRef', moduleUrl: CORE, runtime: ViewContainerRef };\nIdentifiers.ChangeDetectorRef = { name: 'ChangeDetectorRef', moduleUrl: CORE, runtime: ChangeDetectorRef };\nIdentifiers.QueryList = { name: 'QueryList', moduleUrl: CORE, runtime: QueryList };\nIdentifiers.TemplateRef = { name: 'TemplateRef', moduleUrl: CORE, runtime: TemplateRef };\nIdentifiers.CodegenComponentFactoryResolver = {\n name: 'ɵCodegenComponentFactoryResolver',\n moduleUrl: CORE,\n runtime: ɵCodegenComponentFactoryResolver\n};\nIdentifiers.ComponentFactoryResolver = {\n name: 'ComponentFactoryResolver',\n moduleUrl: CORE,\n runtime: ComponentFactoryResolver\n};\nIdentifiers.ComponentFactory = { name: 'ComponentFactory', moduleUrl: CORE, runtime: ComponentFactory };\nIdentifiers.ComponentRef = { name: 'ComponentRef', moduleUrl: CORE, runtime: ComponentRef };\nIdentifiers.NgModuleFactory = { name: 'NgModuleFactory', moduleUrl: CORE, runtime: NgModuleFactory };\nIdentifiers.NgModuleInjector = {\n name: 'ɵNgModuleInjector',\n moduleUrl: CORE,\n runtime: ɵNgModuleInjector,\n};\nIdentifiers.RegisterModuleFactoryFn = {\n name: 'ɵregisterModuleFactory',\n moduleUrl: CORE,\n runtime: ɵregisterModuleFactory,\n};\nIdentifiers.Injector = { name: 'Injector', moduleUrl: CORE, runtime: Injector };\nIdentifiers.ViewEncapsulation = { name: 'ViewEncapsulation', moduleUrl: CORE, runtime: ViewEncapsulation };\nIdentifiers.ChangeDetectionStrategy = {\n name: 'ChangeDetectionStrategy',\n moduleUrl: CORE,\n runtime: ChangeDetectionStrategy\n};\nIdentifiers.SecurityContext = {\n name: 'SecurityContext',\n moduleUrl: CORE,\n runtime: SecurityContext,\n};\nIdentifiers.LOCALE_ID = { name: 'LOCALE_ID', moduleUrl: CORE, runtime: LOCALE_ID };\nIdentifiers.TRANSLATIONS_FORMAT = { name: 'TRANSLATIONS_FORMAT', moduleUrl: CORE, runtime: TRANSLATIONS_FORMAT };\nIdentifiers.inlineInterpolate = { name: 'ɵinlineInterpolate', moduleUrl: CORE, runtime: ɵinlineInterpolate };\nIdentifiers.interpolate = { name: 'ɵinterpolate', moduleUrl: CORE, runtime: ɵinterpolate };\nIdentifiers.EMPTY_ARRAY = { name: 'ɵEMPTY_ARRAY', moduleUrl: CORE, runtime: ɵEMPTY_ARRAY };\nIdentifiers.EMPTY_MAP = { name: 'ɵEMPTY_MAP', moduleUrl: CORE, runtime: ɵEMPTY_MAP };\nIdentifiers.Renderer = { name: 'Renderer', moduleUrl: CORE, runtime: Renderer };\nIdentifiers.viewDef = { name: 'ɵvid', moduleUrl: CORE, runtime: ɵvid };\nIdentifiers.elementDef = { name: 'ɵeld', moduleUrl: CORE, runtime: ɵeld };\nIdentifiers.anchorDef = { name: 'ɵand', moduleUrl: CORE, runtime: ɵand };\nIdentifiers.textDef = { name: 'ɵted', moduleUrl: CORE, runtime: ɵted };\nIdentifiers.directiveDef = { name: 'ɵdid', moduleUrl: CORE, runtime: ɵdid };\nIdentifiers.providerDef = { name: 'ɵprd', moduleUrl: CORE, runtime: ɵprd };\nIdentifiers.queryDef = { name: 'ɵqud', moduleUrl: CORE, runtime: ɵqud };\nIdentifiers.pureArrayDef = { name: 'ɵpad', moduleUrl: CORE, runtime: ɵpad };\nIdentifiers.pureObjectDef = { name: 'ɵpod', moduleUrl: CORE, runtime: ɵpod };\nIdentifiers.purePipeDef = { name: 'ɵppd', moduleUrl: CORE, runtime: ɵppd };\nIdentifiers.pipeDef = { name: 'ɵpid', moduleUrl: CORE, runtime: ɵpid };\nIdentifiers.nodeValue = { name: 'ɵnov', moduleUrl: CORE, runtime: ɵnov };\nIdentifiers.ngContentDef = { name: 'ɵncd', moduleUrl: CORE, runtime: ɵncd };\nIdentifiers.unwrapValue = { name: 'ɵunv', moduleUrl: CORE, runtime: ɵunv };\nIdentifiers.createRendererType2 = { name: 'ɵcrt', moduleUrl: CORE, runtime: ɵcrt };\nIdentifiers.RendererType2 = {\n name: 'RendererType2',\n moduleUrl: CORE,\n // type only\n runtime: null\n};\nIdentifiers.ViewDefinition = {\n name: 'ɵViewDefinition',\n moduleUrl: CORE,\n // type only\n runtime: null\n};\nIdentifiers.createComponentFactory = { name: 'ɵccf', moduleUrl: CORE, runtime: ɵccf };\n/**\n * @param {?} pkg\n * @param {?=} path\n * @param {?=} type\n * @return {?}\n */\nfunction assetUrl(pkg, path, type) {\n if (path === void 0) { path = null; }\n if (type === void 0) { type = 'src'; }\n if (path == null) {\n return \"@angular/\" + pkg;\n }\n else {\n return \"@angular/\" + pkg + \"/\" + type + \"/\" + path;\n }\n}\n/**\n * @param {?} identifier\n * @return {?}\n */\nfunction resolveIdentifier(identifier) {\n var /** @type {?} */ name = identifier.name;\n return ɵreflector.resolveIdentifier(name, identifier.moduleUrl, null, identifier.runtime);\n}\n/**\n * @param {?} identifier\n * @return {?}\n */\nfunction createIdentifier(identifier) {\n return { reference: resolveIdentifier(identifier) };\n}\n/**\n * @param {?} identifier\n * @return {?}\n */\nfunction identifierToken(identifier) {\n return { identifier: identifier };\n}\n/**\n * @param {?} identifier\n * @return {?}\n */\nfunction createIdentifierToken(identifier) {\n return identifierToken(createIdentifier(identifier));\n}\n/**\n * @param {?} enumType\n * @param {?} name\n * @return {?}\n */\n/**\n * @license\n * Copyright Google Inc. 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// http://cldr.unicode.org/index/cldr-spec/plural-rules\nvar PLURAL_CASES = ['zero', 'one', 'two', 'few', 'many', 'other'];\n/**\n * Expands special forms into elements.\n *\n * For example,\n *\n * ```\n * { messages.length, plural,\n * =0 {zero}\n * =1 {one}\n * other {more than one}\n * }\n * ```\n *\n * will be expanded into\n *\n * ```\n * \n * zero\n * one\n * more than one\n * \n * ```\n * @param {?} nodes\n * @return {?}\n */\nfunction expandNodes(nodes) {\n var /** @type {?} */ expander = new _Expander();\n return new ExpansionResult(visitAll(expander, nodes), expander.isExpanded, expander.errors);\n}\nvar ExpansionResult = (function () {\n /**\n * @param {?} nodes\n * @param {?} expanded\n * @param {?} errors\n */\n function ExpansionResult(nodes, expanded, errors) {\n this.nodes = nodes;\n this.expanded = expanded;\n this.errors = errors;\n }\n return ExpansionResult;\n}());\nvar ExpansionError = (function (_super) {\n __extends(ExpansionError, _super);\n /**\n * @param {?} span\n * @param {?} errorMsg\n */\n function ExpansionError(span, errorMsg) {\n return _super.call(this, span, errorMsg) || this;\n }\n return ExpansionError;\n}(ParseError));\n/**\n * Expand expansion forms (plural, select) to directives\n *\n * \\@internal\n */\nvar _Expander = (function () {\n function _Expander() {\n this.isExpanded = false;\n this.errors = [];\n }\n /**\n * @param {?} element\n * @param {?} context\n * @return {?}\n */\n _Expander.prototype.visitElement = function (element, context) {\n return new Element(element.name, element.attrs, visitAll(this, element.children), element.sourceSpan, element.startSourceSpan, element.endSourceSpan);\n };\n /**\n * @param {?} attribute\n * @param {?} context\n * @return {?}\n */\n _Expander.prototype.visitAttribute = function (attribute, context) { return attribute; };\n /**\n * @param {?} text\n * @param {?} context\n * @return {?}\n */\n _Expander.prototype.visitText = function (text, context) { return text; };\n /**\n * @param {?} comment\n * @param {?} context\n * @return {?}\n */\n _Expander.prototype.visitComment = function (comment, context) { return comment; };\n /**\n * @param {?} icu\n * @param {?} context\n * @return {?}\n */\n _Expander.prototype.visitExpansion = function (icu, context) {\n this.isExpanded = true;\n return icu.type == 'plural' ? _expandPluralForm(icu, this.errors) :\n _expandDefaultForm(icu, this.errors);\n };\n /**\n * @param {?} icuCase\n * @param {?} context\n * @return {?}\n */\n _Expander.prototype.visitExpansionCase = function (icuCase, context) {\n throw new Error('Should not be reached');\n };\n return _Expander;\n}());\n/**\n * @param {?} ast\n * @param {?} errors\n * @return {?}\n */\nfunction _expandPluralForm(ast, errors) {\n var /** @type {?} */ children = ast.cases.map(function (c) {\n if (PLURAL_CASES.indexOf(c.value) == -1 && !c.value.match(/^=\\d+$/)) {\n errors.push(new ExpansionError(c.valueSourceSpan, \"Plural cases should be \\\"=\\\" or one of \" + PLURAL_CASES.join(\", \")));\n }\n var /** @type {?} */ expansionResult = expandNodes(c.expression);\n errors.push.apply(errors, expansionResult.errors);\n return new Element(\"ng-template\", [new Attribute$1('ngPluralCase', \"\" + c.value, c.valueSourceSpan)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);\n });\n var /** @type {?} */ switchAttr = new Attribute$1('[ngPlural]', ast.switchValue, ast.switchValueSourceSpan);\n return new Element('ng-container', [switchAttr], children, ast.sourceSpan, ast.sourceSpan, ast.sourceSpan);\n}\n/**\n * @param {?} ast\n * @param {?} errors\n * @return {?}\n */\nfunction _expandDefaultForm(ast, errors) {\n var /** @type {?} */ children = ast.cases.map(function (c) {\n var /** @type {?} */ expansionResult = expandNodes(c.expression);\n errors.push.apply(errors, expansionResult.errors);\n if (c.value === 'other') {\n // other is the default case when no values match\n return new Element(\"ng-template\", [new Attribute$1('ngSwitchDefault', '', c.valueSourceSpan)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);\n }\n return new Element(\"ng-template\", [new Attribute$1('ngSwitchCase', \"\" + c.value, c.valueSourceSpan)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);\n });\n var /** @type {?} */ switchAttr = new Attribute$1('[ngSwitch]', ast.switchValue, ast.switchValueSourceSpan);\n return new Element('ng-container', [switchAttr], children, ast.sourceSpan, ast.sourceSpan, ast.sourceSpan);\n}\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar ProviderError = (function (_super) {\n __extends(ProviderError, _super);\n /**\n * @param {?} message\n * @param {?} span\n */\n function ProviderError(message, span) {\n return _super.call(this, span, message) || this;\n }\n return ProviderError;\n}(ParseError));\nvar ProviderViewContext = (function () {\n /**\n * @param {?} component\n */\n function ProviderViewContext(component) {\n var _this = this;\n this.component = component;\n this.errors = [];\n this.viewQueries = _getViewQueries(component);\n this.viewProviders = new Map();\n component.viewProviders.forEach(function (provider) {\n if (_this.viewProviders.get(tokenReference(provider.token)) == null) {\n _this.viewProviders.set(tokenReference(provider.token), true);\n }\n });\n }\n return ProviderViewContext;\n}());\nvar ProviderElementContext = (function () {\n /**\n * @param {?} viewContext\n * @param {?} _parent\n * @param {?} _isViewRoot\n * @param {?} _directiveAsts\n * @param {?} attrs\n * @param {?} refs\n * @param {?} isTemplate\n * @param {?} contentQueryStartId\n * @param {?} _sourceSpan\n */\n function ProviderElementContext(viewContext, _parent, _isViewRoot, _directiveAsts, attrs, refs, isTemplate, contentQueryStartId, _sourceSpan) {\n var _this = this;\n this.viewContext = viewContext;\n this._parent = _parent;\n this._isViewRoot = _isViewRoot;\n this._directiveAsts = _directiveAsts;\n this._sourceSpan = _sourceSpan;\n this._transformedProviders = new Map();\n this._seenProviders = new Map();\n this._hasViewContainer = false;\n this._queriedTokens = new Map();\n this._attrs = {};\n attrs.forEach(function (attrAst) { return _this._attrs[attrAst.name] = attrAst.value; });\n var directivesMeta = _directiveAsts.map(function (directiveAst) { return directiveAst.directive; });\n this._allProviders =\n _resolveProvidersFromDirectives(directivesMeta, _sourceSpan, viewContext.errors);\n this._contentQueries = _getContentQueries(contentQueryStartId, directivesMeta);\n Array.from(this._allProviders.values()).forEach(function (provider) {\n _this._addQueryReadsTo(provider.token, provider.token, _this._queriedTokens);\n });\n if (isTemplate) {\n var templateRefId = createIdentifierToken(Identifiers.TemplateRef);\n this._addQueryReadsTo(templateRefId, templateRefId, this._queriedTokens);\n }\n refs.forEach(function (refAst) {\n var defaultQueryValue = refAst.value || createIdentifierToken(Identifiers.ElementRef);\n _this._addQueryReadsTo({ value: refAst.name }, defaultQueryValue, _this._queriedTokens);\n });\n if (this._queriedTokens.get(resolveIdentifier(Identifiers.ViewContainerRef))) {\n this._hasViewContainer = true;\n }\n // create the providers that we know are eager first\n Array.from(this._allProviders.values()).forEach(function (provider) {\n var eager = provider.eager || _this._queriedTokens.get(tokenReference(provider.token));\n if (eager) {\n _this._getOrCreateLocalProvider(provider.providerType, provider.token, true);\n }\n });\n }\n /**\n * @return {?}\n */\n ProviderElementContext.prototype.afterElement = function () {\n var _this = this;\n // collect lazy providers\n Array.from(this._allProviders.values()).forEach(function (provider) {\n _this._getOrCreateLocalProvider(provider.providerType, provider.token, false);\n });\n };\n Object.defineProperty(ProviderElementContext.prototype, \"transformProviders\", {\n /**\n * @return {?}\n */\n get: function () {\n return Array.from(this._transformedProviders.values());\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ProviderElementContext.prototype, \"transformedDirectiveAsts\", {\n /**\n * @return {?}\n */\n get: function () {\n var /** @type {?} */ sortedProviderTypes = this.transformProviders.map(function (provider) { return provider.token.identifier; });\n var /** @type {?} */ sortedDirectives = this._directiveAsts.slice();\n sortedDirectives.sort(function (dir1, dir2) { return sortedProviderTypes.indexOf(dir1.directive.type) -\n sortedProviderTypes.indexOf(dir2.directive.type); });\n return sortedDirectives;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ProviderElementContext.prototype, \"transformedHasViewContainer\", {\n /**\n * @return {?}\n */\n get: function () { return this._hasViewContainer; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ProviderElementContext.prototype, \"queryMatches\", {\n /**\n * @return {?}\n */\n get: function () {\n var /** @type {?} */ allMatches = [];\n this._queriedTokens.forEach(function (matches) { allMatches.push.apply(allMatches, matches); });\n return allMatches;\n },\n enumerable: true,\n configurable: true\n });\n /**\n * @param {?} token\n * @param {?} defaultValue\n * @param {?} queryReadTokens\n * @return {?}\n */\n ProviderElementContext.prototype._addQueryReadsTo = function (token, defaultValue, queryReadTokens) {\n this._getQueriesFor(token).forEach(function (query) {\n var /** @type {?} */ queryValue = query.meta.read || defaultValue;\n var /** @type {?} */ tokenRef = tokenReference(queryValue);\n var /** @type {?} */ queryMatches = queryReadTokens.get(tokenRef);\n if (!queryMatches) {\n queryMatches = [];\n queryReadTokens.set(tokenRef, queryMatches);\n }\n queryMatches.push({ queryId: query.queryId, value: queryValue });\n });\n };\n /**\n * @param {?} token\n * @return {?}\n */\n ProviderElementContext.prototype._getQueriesFor = function (token) {\n var /** @type {?} */ result = [];\n var /** @type {?} */ currentEl = this;\n var /** @type {?} */ distance = 0;\n var /** @type {?} */ queries;\n while (currentEl !== null) {\n queries = currentEl._contentQueries.get(tokenReference(token));\n if (queries) {\n result.push.apply(result, queries.filter(function (query) { return query.meta.descendants || distance <= 1; }));\n }\n if (currentEl._directiveAsts.length > 0) {\n distance++;\n }\n currentEl = currentEl._parent;\n }\n queries = this.viewContext.viewQueries.get(tokenReference(token));\n if (queries) {\n result.push.apply(result, queries);\n }\n return result;\n };\n /**\n * @param {?} requestingProviderType\n * @param {?} token\n * @param {?} eager\n * @return {?}\n */\n ProviderElementContext.prototype._getOrCreateLocalProvider = function (requestingProviderType, token, eager) {\n var _this = this;\n var /** @type {?} */ resolvedProvider = this._allProviders.get(tokenReference(token));\n if (!resolvedProvider || ((requestingProviderType === ProviderAstType.Directive ||\n requestingProviderType === ProviderAstType.PublicService) &&\n resolvedProvider.providerType === ProviderAstType.PrivateService) ||\n ((requestingProviderType === ProviderAstType.PrivateService ||\n requestingProviderType === ProviderAstType.PublicService) &&\n resolvedProvider.providerType === ProviderAstType.Builtin)) {\n return null;\n }\n var /** @type {?} */ transformedProviderAst = this._transformedProviders.get(tokenReference(token));\n if (transformedProviderAst) {\n return transformedProviderAst;\n }\n if (this._seenProviders.get(tokenReference(token)) != null) {\n this.viewContext.errors.push(new ProviderError(\"Cannot instantiate cyclic dependency! \" + tokenName(token), this._sourceSpan));\n return null;\n }\n this._seenProviders.set(tokenReference(token), true);\n var /** @type {?} */ transformedProviders = resolvedProvider.providers.map(function (provider) {\n var /** @type {?} */ transformedUseValue = provider.useValue;\n var /** @type {?} */ transformedUseExisting = provider.useExisting;\n var /** @type {?} */ transformedDeps;\n if (provider.useExisting != null) {\n var /** @type {?} */ existingDiDep = _this._getDependency(resolvedProvider.providerType, { token: provider.useExisting }, eager);\n if (existingDiDep.token != null) {\n transformedUseExisting = existingDiDep.token;\n }\n else {\n transformedUseExisting = null;\n transformedUseValue = existingDiDep.value;\n }\n }\n else if (provider.useFactory) {\n var /** @type {?} */ deps = provider.deps || provider.useFactory.diDeps;\n transformedDeps =\n deps.map(function (dep) { return _this._getDependency(resolvedProvider.providerType, dep, eager); });\n }\n else if (provider.useClass) {\n var /** @type {?} */ deps = provider.deps || provider.useClass.diDeps;\n transformedDeps =\n deps.map(function (dep) { return _this._getDependency(resolvedProvider.providerType, dep, eager); });\n }\n return _transformProvider(provider, {\n useExisting: transformedUseExisting,\n useValue: transformedUseValue,\n deps: transformedDeps\n });\n });\n transformedProviderAst =\n _transformProviderAst(resolvedProvider, { eager: eager, providers: transformedProviders });\n this._transformedProviders.set(tokenReference(token), transformedProviderAst);\n return transformedProviderAst;\n };\n /**\n * @param {?} requestingProviderType\n * @param {?} dep\n * @param {?=} eager\n * @return {?}\n */\n ProviderElementContext.prototype._getLocalDependency = function (requestingProviderType, dep, eager) {\n if (eager === void 0) { eager = null; }\n if (dep.isAttribute) {\n var /** @type {?} */ attrValue = this._attrs[dep.token.value];\n return { isValue: true, value: attrValue == null ? null : attrValue };\n }\n if (dep.token != null) {\n // access builtints\n if ((requestingProviderType === ProviderAstType.Directive ||\n requestingProviderType === ProviderAstType.Component)) {\n if (tokenReference(dep.token) === resolveIdentifier(Identifiers.Renderer) ||\n tokenReference(dep.token) === resolveIdentifier(Identifiers.ElementRef) ||\n tokenReference(dep.token) === resolveIdentifier(Identifiers.ChangeDetectorRef) ||\n tokenReference(dep.token) === resolveIdentifier(Identifiers.TemplateRef)) {\n return dep;\n }\n if (tokenReference(dep.token) === resolveIdentifier(Identifiers.ViewContainerRef)) {\n this._hasViewContainer = true;\n }\n }\n // access the injector\n if (tokenReference(dep.token) === resolveIdentifier(Identifiers.Injector)) {\n return dep;\n }\n // access providers\n if (this._getOrCreateLocalProvider(requestingProviderType, dep.token, eager) != null) {\n return dep;\n }\n }\n return null;\n };\n /**\n * @param {?} requestingProviderType\n * @param {?} dep\n * @param {?=} eager\n * @return {?}\n */\n ProviderElementContext.prototype._getDependency = function (requestingProviderType, dep, eager) {\n if (eager === void 0) { eager = null; }\n var /** @type {?} */ currElement = this;\n var /** @type {?} */ currEager = eager;\n var /** @type {?} */ result = null;\n if (!dep.isSkipSelf) {\n result = this._getLocalDependency(requestingProviderType, dep, eager);\n }\n if (dep.isSelf) {\n if (!result && dep.isOptional) {\n result = { isValue: true, value: null };\n }\n }\n else {\n // check parent elements\n while (!result && currElement._parent) {\n var /** @type {?} */ prevElement = currElement;\n currElement = currElement._parent;\n if (prevElement._isViewRoot) {\n currEager = false;\n }\n result = currElement._getLocalDependency(ProviderAstType.PublicService, dep, currEager);\n }\n // check @Host restriction\n if (!result) {\n if (!dep.isHost || this.viewContext.component.isHost ||\n this.viewContext.component.type.reference === tokenReference(dep.token) ||\n this.viewContext.viewProviders.get(tokenReference(dep.token)) != null) {\n result = dep;\n }\n else {\n result = dep.isOptional ? result = { isValue: true, value: null } : null;\n }\n }\n }\n if (!result) {\n this.viewContext.errors.push(new ProviderError(\"No provider for \" + tokenName(dep.token), this._sourceSpan));\n }\n return result;\n };\n return ProviderElementContext;\n}());\nvar NgModuleProviderAnalyzer = (function () {\n /**\n * @param {?} ngModule\n * @param {?} extraProviders\n * @param {?} sourceSpan\n */\n function NgModuleProviderAnalyzer(ngModule, extraProviders, sourceSpan) {\n var _this = this;\n this._transformedProviders = new Map();\n this._seenProviders = new Map();\n this._errors = [];\n this._allProviders = new Map();\n ngModule.transitiveModule.modules.forEach(function (ngModuleType) {\n var ngModuleProvider = { token: { identifier: ngModuleType }, useClass: ngModuleType };\n _resolveProviders([ngModuleProvider], ProviderAstType.PublicService, true, sourceSpan, _this._errors, _this._allProviders);\n });\n _resolveProviders(ngModule.transitiveModule.providers.map(function (entry) { return entry.provider; }).concat(extraProviders), ProviderAstType.PublicService, false, sourceSpan, this._errors, this._allProviders);\n }\n /**\n * @return {?}\n */\n NgModuleProviderAnalyzer.prototype.parse = function () {\n var _this = this;\n Array.from(this._allProviders.values()).forEach(function (provider) {\n _this._getOrCreateLocalProvider(provider.token, provider.eager);\n });\n if (this._errors.length > 0) {\n var /** @type {?} */ errorString = this._errors.join('\\n');\n throw new Error(\"Provider parse errors:\\n\" + errorString);\n }\n return Array.from(this._transformedProviders.values());\n };\n /**\n * @param {?} token\n * @param {?} eager\n * @return {?}\n */\n NgModuleProviderAnalyzer.prototype._getOrCreateLocalProvider = function (token, eager) {\n var _this = this;\n var /** @type {?} */ resolvedProvider = this._allProviders.get(tokenReference(token));\n if (!resolvedProvider) {\n return null;\n }\n var /** @type {?} */ transformedProviderAst = this._transformedProviders.get(tokenReference(token));\n if (transformedProviderAst) {\n return transformedProviderAst;\n }\n if (this._seenProviders.get(tokenReference(token)) != null) {\n this._errors.push(new ProviderError(\"Cannot instantiate cyclic dependency! \" + tokenName(token), resolvedProvider.sourceSpan));\n return null;\n }\n this._seenProviders.set(tokenReference(token), true);\n var /** @type {?} */ transformedProviders = resolvedProvider.providers.map(function (provider) {\n var /** @type {?} */ transformedUseValue = provider.useValue;\n var /** @type {?} */ transformedUseExisting = provider.useExisting;\n var /** @type {?} */ transformedDeps;\n if (provider.useExisting != null) {\n var /** @type {?} */ existingDiDep = _this._getDependency({ token: provider.useExisting }, eager, resolvedProvider.sourceSpan);\n if (existingDiDep.token != null) {\n transformedUseExisting = existingDiDep.token;\n }\n else {\n transformedUseExisting = null;\n transformedUseValue = existingDiDep.value;\n }\n }\n else if (provider.useFactory) {\n var /** @type {?} */ deps = provider.deps || provider.useFactory.diDeps;\n transformedDeps =\n deps.map(function (dep) { return _this._getDependency(dep, eager, resolvedProvider.sourceSpan); });\n }\n else if (provider.useClass) {\n var /** @type {?} */ deps = provider.deps || provider.useClass.diDeps;\n transformedDeps =\n deps.map(function (dep) { return _this._getDependency(dep, eager, resolvedProvider.sourceSpan); });\n }\n return _transformProvider(provider, {\n useExisting: transformedUseExisting,\n useValue: transformedUseValue,\n deps: transformedDeps\n });\n });\n transformedProviderAst =\n _transformProviderAst(resolvedProvider, { eager: eager, providers: transformedProviders });\n this._transformedProviders.set(tokenReference(token), transformedProviderAst);\n return transformedProviderAst;\n };\n /**\n * @param {?} dep\n * @param {?=} eager\n * @param {?=} requestorSourceSpan\n * @return {?}\n */\n NgModuleProviderAnalyzer.prototype._getDependency = function (dep, eager, requestorSourceSpan) {\n if (eager === void 0) { eager = null; }\n var /** @type {?} */ foundLocal = false;\n if (!dep.isSkipSelf && dep.token != null) {\n // access the injector\n if (tokenReference(dep.token) === resolveIdentifier(Identifiers.Injector) ||\n tokenReference(dep.token) === resolveIdentifier(Identifiers.ComponentFactoryResolver)) {\n foundLocal = true;\n }\n else if (this._getOrCreateLocalProvider(dep.token, eager) != null) {\n foundLocal = true;\n }\n }\n var /** @type {?} */ result = dep;\n if (dep.isSelf && !foundLocal) {\n if (dep.isOptional) {\n result = { isValue: true, value: null };\n }\n else {\n this._errors.push(new ProviderError(\"No provider for \" + tokenName(dep.token), requestorSourceSpan));\n }\n }\n return result;\n };\n return NgModuleProviderAnalyzer;\n}());\n/**\n * @param {?} provider\n * @param {?} __1\n * @return {?}\n */\nfunction _transformProvider(provider, _a) {\n var useExisting = _a.useExisting, useValue = _a.useValue, deps = _a.deps;\n return {\n token: provider.token,\n useClass: provider.useClass,\n useExisting: useExisting,\n useFactory: provider.useFactory,\n useValue: useValue,\n deps: deps,\n multi: provider.multi\n };\n}\n/**\n * @param {?} provider\n * @param {?} __1\n * @return {?}\n */\nfunction _transformProviderAst(provider, _a) {\n var eager = _a.eager, providers = _a.providers;\n return new ProviderAst(provider.token, provider.multiProvider, provider.eager || eager, providers, provider.providerType, provider.lifecycleHooks, provider.sourceSpan);\n}\n/**\n * @param {?} directives\n * @param {?} sourceSpan\n * @param {?} targetErrors\n * @return {?}\n */\nfunction _resolveProvidersFromDirectives(directives, sourceSpan, targetErrors) {\n var /** @type {?} */ providersByToken = new Map();\n directives.forEach(function (directive) {\n var /** @type {?} */ dirProvider = { token: { identifier: directive.type }, useClass: directive.type };\n _resolveProviders([dirProvider], directive.isComponent ? ProviderAstType.Component : ProviderAstType.Directive, true, sourceSpan, targetErrors, providersByToken);\n });\n // Note: directives need to be able to overwrite providers of a component!\n var /** @type {?} */ directivesWithComponentFirst = directives.filter(function (dir) { return dir.isComponent; }).concat(directives.filter(function (dir) { return !dir.isComponent; }));\n directivesWithComponentFirst.forEach(function (directive) {\n _resolveProviders(directive.providers, ProviderAstType.PublicService, false, sourceSpan, targetErrors, providersByToken);\n _resolveProviders(directive.viewProviders, ProviderAstType.PrivateService, false, sourceSpan, targetErrors, providersByToken);\n });\n return providersByToken;\n}\n/**\n * @param {?} providers\n * @param {?} providerType\n * @param {?} eager\n * @param {?} sourceSpan\n * @param {?} targetErrors\n * @param {?} targetProvidersByToken\n * @return {?}\n */\nfunction _resolveProviders(providers, providerType, eager, sourceSpan, targetErrors, targetProvidersByToken) {\n providers.forEach(function (provider) {\n var /** @type {?} */ resolvedProvider = targetProvidersByToken.get(tokenReference(provider.token));\n if (resolvedProvider != null && !!resolvedProvider.multiProvider !== !!provider.multi) {\n targetErrors.push(new ProviderError(\"Mixing multi and non multi provider is not possible for token \" + tokenName(resolvedProvider.token), sourceSpan));\n }\n if (!resolvedProvider) {\n var /** @type {?} */ lifecycleHooks = provider.token.identifier &&\n ((provider.token.identifier)).lifecycleHooks ?\n ((provider.token.identifier)).lifecycleHooks :\n [];\n var /** @type {?} */ isUseValue = !(provider.useClass || provider.useExisting || provider.useFactory);\n resolvedProvider = new ProviderAst(provider.token, provider.multi, eager || isUseValue, [provider], providerType, lifecycleHooks, sourceSpan);\n targetProvidersByToken.set(tokenReference(provider.token), resolvedProvider);\n }\n else {\n if (!provider.multi) {\n resolvedProvider.providers.length = 0;\n }\n resolvedProvider.providers.push(provider);\n }\n });\n}\n/**\n * @param {?} component\n * @return {?}\n */\nfunction _getViewQueries(component) {\n // Note: queries start with id 1 so we can use the number in a Bloom filter!\n var /** @type {?} */ viewQueryId = 1;\n var /** @type {?} */ viewQueries = new Map();\n if (component.viewQueries) {\n component.viewQueries.forEach(function (query) { return _addQueryToTokenMap(viewQueries, { meta: query, queryId: viewQueryId++ }); });\n }\n return viewQueries;\n}\n/**\n * @param {?} contentQueryStartId\n * @param {?} directives\n * @return {?}\n */\nfunction _getContentQueries(contentQueryStartId, directives) {\n var /** @type {?} */ contentQueryId = contentQueryStartId;\n var /** @type {?} */ contentQueries = new Map();\n directives.forEach(function (directive, directiveIndex) {\n if (directive.queries) {\n directive.queries.forEach(function (query) { return _addQueryToTokenMap(contentQueries, { meta: query, queryId: contentQueryId++ }); });\n }\n });\n return contentQueries;\n}\n/**\n * @param {?} map\n * @param {?} query\n * @return {?}\n */\nfunction _addQueryToTokenMap(map, query) {\n query.meta.selectors.forEach(function (token) {\n var /** @type {?} */ entry = map.get(tokenReference(token));\n if (!entry) {\n entry = [];\n map.set(tokenReference(token), entry);\n }\n entry.push(query);\n });\n}\n/**\n * @license\n * Copyright Google Inc. 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/**\n * @abstract\n */\nvar ElementSchemaRegistry = (function () {\n function ElementSchemaRegistry() {\n }\n /**\n * @abstract\n * @param {?} tagName\n * @param {?} propName\n * @param {?} schemaMetas\n * @return {?}\n */\n ElementSchemaRegistry.prototype.hasProperty = function (tagName, propName, schemaMetas) { };\n /**\n * @abstract\n * @param {?} tagName\n * @param {?} schemaMetas\n * @return {?}\n */\n ElementSchemaRegistry.prototype.hasElement = function (tagName, schemaMetas) { };\n /**\n * @abstract\n * @param {?} elementName\n * @param {?} propName\n * @param {?} isAttribute\n * @return {?}\n */\n ElementSchemaRegistry.prototype.securityContext = function (elementName, propName, isAttribute) { };\n /**\n * @abstract\n * @return {?}\n */\n ElementSchemaRegistry.prototype.allKnownElementNames = function () { };\n /**\n * @abstract\n * @param {?} propName\n * @return {?}\n */\n ElementSchemaRegistry.prototype.getMappedPropName = function (propName) { };\n /**\n * @abstract\n * @return {?}\n */\n ElementSchemaRegistry.prototype.getDefaultComponentElementName = function () { };\n /**\n * @abstract\n * @param {?} name\n * @return {?}\n */\n ElementSchemaRegistry.prototype.validateProperty = function (name) { };\n /**\n * @abstract\n * @param {?} name\n * @return {?}\n */\n ElementSchemaRegistry.prototype.validateAttribute = function (name) { };\n /**\n * @abstract\n * @param {?} propName\n * @return {?}\n */\n ElementSchemaRegistry.prototype.normalizeAnimationStyleProperty = function (propName) { };\n /**\n * @abstract\n * @param {?} camelCaseProp\n * @param {?} userProvidedProp\n * @param {?} val\n * @return {?}\n */\n ElementSchemaRegistry.prototype.normalizeAnimationStyleValue = function (camelCaseProp, userProvidedProp, val) { };\n return ElementSchemaRegistry;\n}());\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar StyleWithImports = (function () {\n /**\n * @param {?} style\n * @param {?} styleUrls\n */\n function StyleWithImports(style$$1, styleUrls) {\n this.style = style$$1;\n this.styleUrls = styleUrls;\n }\n return StyleWithImports;\n}());\n/**\n * @param {?} url\n * @return {?}\n */\nfunction isStyleUrlResolvable(url) {\n if (url == null || url.length === 0 || url[0] == '/')\n return false;\n var /** @type {?} */ schemeMatch = url.match(URL_WITH_SCHEMA_REGEXP);\n return schemeMatch === null || schemeMatch[1] == 'package' || schemeMatch[1] == 'asset';\n}\n/**\n * Rewrites stylesheets by resolving and removing the \\@import urls that\n * are either relative or don't have a `package:` scheme\n * @param {?} resolver\n * @param {?} baseUrl\n * @param {?} cssText\n * @return {?}\n */\nfunction extractStyleUrls(resolver, baseUrl, cssText) {\n var /** @type {?} */ foundUrls = [];\n var /** @type {?} */ modifiedCssText = cssText.replace(CSS_COMMENT_REGEXP, '').replace(CSS_IMPORT_REGEXP, function () {\n var m = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n m[_i] = arguments[_i];\n }\n var /** @type {?} */ url = m[1] || m[2];\n if (!isStyleUrlResolvable(url)) {\n // Do not attempt to resolve non-package absolute URLs with URI scheme\n return m[0];\n }\n foundUrls.push(resolver.resolve(baseUrl, url));\n return '';\n });\n return new StyleWithImports(modifiedCssText, foundUrls);\n}\nvar CSS_IMPORT_REGEXP = /@import\\s+(?:url\\()?\\s*(?:(?:['\"]([^'\"]*))|([^;\\)\\s]*))[^;]*;?/g;\nvar CSS_COMMENT_REGEXP = /\\/\\*.+?\\*\\//g;\nvar URL_WITH_SCHEMA_REGEXP = /^([^:/?#]+):/;\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar PROPERTY_PARTS_SEPARATOR = '.';\nvar ATTRIBUTE_PREFIX = 'attr';\nvar CLASS_PREFIX = 'class';\nvar STYLE_PREFIX = 'style';\nvar ANIMATE_PROP_PREFIX = 'animate-';\nvar BoundPropertyType = {};\nBoundPropertyType.DEFAULT = 0;\nBoundPropertyType.LITERAL_ATTR = 1;\nBoundPropertyType.ANIMATION = 2;\nBoundPropertyType[BoundPropertyType.DEFAULT] = \"DEFAULT\";\nBoundPropertyType[BoundPropertyType.LITERAL_ATTR] = \"LITERAL_ATTR\";\nBoundPropertyType[BoundPropertyType.ANIMATION] = \"ANIMATION\";\n/**\n * Represents a parsed property.\n */\nvar BoundProperty = (function () {\n /**\n * @param {?} name\n * @param {?} expression\n * @param {?} type\n * @param {?} sourceSpan\n */\n function BoundProperty(name, expression, type, sourceSpan) {\n this.name = name;\n this.expression = expression;\n this.type = type;\n this.sourceSpan = sourceSpan;\n }\n Object.defineProperty(BoundProperty.prototype, \"isLiteral\", {\n /**\n * @return {?}\n */\n get: function () { return this.type === BoundPropertyType.LITERAL_ATTR; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(BoundProperty.prototype, \"isAnimation\", {\n /**\n * @return {?}\n */\n get: function () { return this.type === BoundPropertyType.ANIMATION; },\n enumerable: true,\n configurable: true\n });\n return BoundProperty;\n}());\n/**\n * Parses bindings in templates and in the directive host area.\n */\nvar BindingParser = (function () {\n /**\n * @param {?} _exprParser\n * @param {?} _interpolationConfig\n * @param {?} _schemaRegistry\n * @param {?} pipes\n * @param {?} _targetErrors\n */\n function BindingParser(_exprParser, _interpolationConfig, _schemaRegistry, pipes, _targetErrors) {\n var _this = this;\n this._exprParser = _exprParser;\n this._interpolationConfig = _interpolationConfig;\n this._schemaRegistry = _schemaRegistry;\n this._targetErrors = _targetErrors;\n this.pipesByName = new Map();\n this._usedPipes = new Map();\n pipes.forEach(function (pipe) { return _this.pipesByName.set(pipe.name, pipe); });\n }\n /**\n * @return {?}\n */\n BindingParser.prototype.getUsedPipes = function () { return Array.from(this._usedPipes.values()); };\n /**\n * @param {?} dirMeta\n * @param {?} elementSelector\n * @param {?} sourceSpan\n * @return {?}\n */\n BindingParser.prototype.createDirectiveHostPropertyAsts = function (dirMeta, elementSelector, sourceSpan) {\n var _this = this;\n if (dirMeta.hostProperties) {\n var /** @type {?} */ boundProps_1 = [];\n Object.keys(dirMeta.hostProperties).forEach(function (propName) {\n var /** @type {?} */ expression = dirMeta.hostProperties[propName];\n if (typeof expression === 'string') {\n _this.parsePropertyBinding(propName, expression, true, sourceSpan, [], boundProps_1);\n }\n else {\n _this._reportError(\"Value of the host property binding \\\"\" + propName + \"\\\" needs to be a string representing an expression but got \\\"\" + expression + \"\\\" (\" + typeof expression + \")\", sourceSpan);\n }\n });\n return boundProps_1.map(function (prop) { return _this.createElementPropertyAst(elementSelector, prop); });\n }\n };\n /**\n * @param {?} dirMeta\n * @param {?} sourceSpan\n * @return {?}\n */\n BindingParser.prototype.createDirectiveHostEventAsts = function (dirMeta, sourceSpan) {\n var _this = this;\n if (dirMeta.hostListeners) {\n var /** @type {?} */ targetEventAsts_1 = [];\n Object.keys(dirMeta.hostListeners).forEach(function (propName) {\n var /** @type {?} */ expression = dirMeta.hostListeners[propName];\n if (typeof expression === 'string') {\n _this.parseEvent(propName, expression, sourceSpan, [], targetEventAsts_1);\n }\n else {\n _this._reportError(\"Value of the host listener \\\"\" + propName + \"\\\" needs to be a string representing an expression but got \\\"\" + expression + \"\\\" (\" + typeof expression + \")\", sourceSpan);\n }\n });\n return targetEventAsts_1;\n }\n };\n /**\n * @param {?} value\n * @param {?} sourceSpan\n * @return {?}\n */\n BindingParser.prototype.parseInterpolation = function (value, sourceSpan) {\n var /** @type {?} */ sourceInfo = sourceSpan.start.toString();\n try {\n var /** @type {?} */ ast = this._exprParser.parseInterpolation(value, sourceInfo, this._interpolationConfig);\n if (ast)\n this._reportExpressionParserErrors(ast.errors, sourceSpan);\n this._checkPipes(ast, sourceSpan);\n return ast;\n }\n catch (e) {\n this._reportError(\"\" + e, sourceSpan);\n return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);\n }\n };\n /**\n * @param {?} prefixToken\n * @param {?} value\n * @param {?} sourceSpan\n * @param {?} targetMatchableAttrs\n * @param {?} targetProps\n * @param {?} targetVars\n * @return {?}\n */\n BindingParser.prototype.parseInlineTemplateBinding = function (prefixToken, value, sourceSpan, targetMatchableAttrs, targetProps, targetVars) {\n var /** @type {?} */ bindings = this._parseTemplateBindings(prefixToken, value, sourceSpan);\n for (var /** @type {?} */ i = 0; i < bindings.length; i++) {\n var /** @type {?} */ binding = bindings[i];\n if (binding.keyIsVar) {\n targetVars.push(new VariableAst(binding.key, binding.name, sourceSpan));\n }\n else if (binding.expression) {\n this._parsePropertyAst(binding.key, binding.expression, sourceSpan, targetMatchableAttrs, targetProps);\n }\n else {\n targetMatchableAttrs.push([binding.key, '']);\n this.parseLiteralAttr(binding.key, null, sourceSpan, targetMatchableAttrs, targetProps);\n }\n }\n };\n /**\n * @param {?} prefixToken\n * @param {?} value\n * @param {?} sourceSpan\n * @return {?}\n */\n BindingParser.prototype._parseTemplateBindings = function (prefixToken, value, sourceSpan) {\n var _this = this;\n var /** @type {?} */ sourceInfo = sourceSpan.start.toString();\n try {\n var /** @type {?} */ bindingsResult = this._exprParser.parseTemplateBindings(prefixToken, value, sourceInfo);\n this._reportExpressionParserErrors(bindingsResult.errors, sourceSpan);\n bindingsResult.templateBindings.forEach(function (binding) {\n if (binding.expression) {\n _this._checkPipes(binding.expression, sourceSpan);\n }\n });\n bindingsResult.warnings.forEach(function (warning) { _this._reportError(warning, sourceSpan, ParseErrorLevel.WARNING); });\n return bindingsResult.templateBindings;\n }\n catch (e) {\n this._reportError(\"\" + e, sourceSpan);\n return [];\n }\n };\n /**\n * @param {?} name\n * @param {?} value\n * @param {?} sourceSpan\n * @param {?} targetMatchableAttrs\n * @param {?} targetProps\n * @return {?}\n */\n BindingParser.prototype.parseLiteralAttr = function (name, value, sourceSpan, targetMatchableAttrs, targetProps) {\n if (_isAnimationLabel(name)) {\n name = name.substring(1);\n if (value) {\n this._reportError(\"Assigning animation triggers via @prop=\\\"exp\\\" attributes with an expression is invalid.\" +\n \" Use property bindings (e.g. [@prop]=\\\"exp\\\") or use an attribute without a value (e.g. @prop) instead.\", sourceSpan, ParseErrorLevel.ERROR);\n }\n this._parseAnimation(name, value, sourceSpan, targetMatchableAttrs, targetProps);\n }\n else {\n targetProps.push(new BoundProperty(name, this._exprParser.wrapLiteralPrimitive(value, ''), BoundPropertyType.LITERAL_ATTR, sourceSpan));\n }\n };\n /**\n * @param {?} name\n * @param {?} expression\n * @param {?} isHost\n * @param {?} sourceSpan\n * @param {?} targetMatchableAttrs\n * @param {?} targetProps\n * @return {?}\n */\n BindingParser.prototype.parsePropertyBinding = function (name, expression, isHost, sourceSpan, targetMatchableAttrs, targetProps) {\n var /** @type {?} */ isAnimationProp = false;\n if (name.startsWith(ANIMATE_PROP_PREFIX)) {\n isAnimationProp = true;\n name = name.substring(ANIMATE_PROP_PREFIX.length);\n }\n else if (_isAnimationLabel(name)) {\n isAnimationProp = true;\n name = name.substring(1);\n }\n if (isAnimationProp) {\n this._parseAnimation(name, expression, sourceSpan, targetMatchableAttrs, targetProps);\n }\n else {\n this._parsePropertyAst(name, this._parseBinding(expression, isHost, sourceSpan), sourceSpan, targetMatchableAttrs, targetProps);\n }\n };\n /**\n * @param {?} name\n * @param {?} value\n * @param {?} sourceSpan\n * @param {?} targetMatchableAttrs\n * @param {?} targetProps\n * @return {?}\n */\n BindingParser.prototype.parsePropertyInterpolation = function (name, value, sourceSpan, targetMatchableAttrs, targetProps) {\n var /** @type {?} */ expr = this.parseInterpolation(value, sourceSpan);\n if (expr) {\n this._parsePropertyAst(name, expr, sourceSpan, targetMatchableAttrs, targetProps);\n return true;\n }\n return false;\n };\n /**\n * @param {?} name\n * @param {?} ast\n * @param {?} sourceSpan\n * @param {?} targetMatchableAttrs\n * @param {?} targetProps\n * @return {?}\n */\n BindingParser.prototype._parsePropertyAst = function (name, ast, sourceSpan, targetMatchableAttrs, targetProps) {\n targetMatchableAttrs.push([name, ast.source]);\n targetProps.push(new BoundProperty(name, ast, BoundPropertyType.DEFAULT, sourceSpan));\n };\n /**\n * @param {?} name\n * @param {?} expression\n * @param {?} sourceSpan\n * @param {?} targetMatchableAttrs\n * @param {?} targetProps\n * @return {?}\n */\n BindingParser.prototype._parseAnimation = function (name, expression, sourceSpan, targetMatchableAttrs, targetProps) {\n // This will occur when a @trigger is not paired with an expression.\n // For animations it is valid to not have an expression since */void\n // states will be applied by angular when the element is attached/detached\n var /** @type {?} */ ast = this._parseBinding(expression || 'null', false, sourceSpan);\n targetMatchableAttrs.push([name, ast.source]);\n targetProps.push(new BoundProperty(name, ast, BoundPropertyType.ANIMATION, sourceSpan));\n };\n /**\n * @param {?} value\n * @param {?} isHostBinding\n * @param {?} sourceSpan\n * @return {?}\n */\n BindingParser.prototype._parseBinding = function (value, isHostBinding, sourceSpan) {\n var /** @type {?} */ sourceInfo = sourceSpan.start.toString();\n try {\n var /** @type {?} */ ast = isHostBinding ?\n this._exprParser.parseSimpleBinding(value, sourceInfo, this._interpolationConfig) :\n this._exprParser.parseBinding(value, sourceInfo, this._interpolationConfig);\n if (ast)\n this._reportExpressionParserErrors(ast.errors, sourceSpan);\n this._checkPipes(ast, sourceSpan);\n return ast;\n }\n catch (e) {\n this._reportError(\"\" + e, sourceSpan);\n return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);\n }\n };\n /**\n * @param {?} elementSelector\n * @param {?} boundProp\n * @return {?}\n */\n BindingParser.prototype.createElementPropertyAst = function (elementSelector, boundProp) {\n if (boundProp.isAnimation) {\n return new BoundElementPropertyAst(boundProp.name, PropertyBindingType.Animation, SecurityContext.NONE, boundProp.expression, null, boundProp.sourceSpan);\n }\n var /** @type {?} */ unit = null;\n var /** @type {?} */ bindingType;\n var /** @type {?} */ boundPropertyName = null;\n var /** @type {?} */ parts = boundProp.name.split(PROPERTY_PARTS_SEPARATOR);\n var /** @type {?} */ securityContexts;\n // Check check for special cases (prefix style, attr, class)\n if (parts.length > 1) {\n if (parts[0] == ATTRIBUTE_PREFIX) {\n boundPropertyName = parts[1];\n this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, true);\n securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, boundPropertyName, true);\n var /** @type {?} */ nsSeparatorIdx = boundPropertyName.indexOf(':');\n if (nsSeparatorIdx > -1) {\n var /** @type {?} */ ns = boundPropertyName.substring(0, nsSeparatorIdx);\n var /** @type {?} */ name = boundPropertyName.substring(nsSeparatorIdx + 1);\n boundPropertyName = mergeNsAndName(ns, name);\n }\n bindingType = PropertyBindingType.Attribute;\n }\n else if (parts[0] == CLASS_PREFIX) {\n boundPropertyName = parts[1];\n bindingType = PropertyBindingType.Class;\n securityContexts = [SecurityContext.NONE];\n }\n else if (parts[0] == STYLE_PREFIX) {\n unit = parts.length > 2 ? parts[2] : null;\n boundPropertyName = parts[1];\n bindingType = PropertyBindingType.Style;\n securityContexts = [SecurityContext.STYLE];\n }\n }\n // If not a special case, use the full property name\n if (boundPropertyName === null) {\n boundPropertyName = this._schemaRegistry.getMappedPropName(boundProp.name);\n securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, boundPropertyName, false);\n bindingType = PropertyBindingType.Property;\n this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, false);\n }\n return new BoundElementPropertyAst(boundPropertyName, bindingType, securityContexts[0], boundProp.expression, unit, boundProp.sourceSpan);\n };\n /**\n * @param {?} name\n * @param {?} expression\n * @param {?} sourceSpan\n * @param {?} targetMatchableAttrs\n * @param {?} targetEvents\n * @return {?}\n */\n BindingParser.prototype.parseEvent = function (name, expression, sourceSpan, targetMatchableAttrs, targetEvents) {\n if (_isAnimationLabel(name)) {\n name = name.substr(1);\n this._parseAnimationEvent(name, expression, sourceSpan, targetEvents);\n }\n else {\n this._parseEvent(name, expression, sourceSpan, targetMatchableAttrs, targetEvents);\n }\n };\n /**\n * @param {?} name\n * @param {?} expression\n * @param {?} sourceSpan\n * @param {?} targetEvents\n * @return {?}\n */\n BindingParser.prototype._parseAnimationEvent = function (name, expression, sourceSpan, targetEvents) {\n var /** @type {?} */ matches = splitAtPeriod(name, [name, '']);\n var /** @type {?} */ eventName = matches[0];\n var /** @type {?} */ phase = matches[1].toLowerCase();\n if (phase) {\n switch (phase) {\n case 'start':\n case 'done':\n var /** @type {?} */ ast = this._parseAction(expression, sourceSpan);\n targetEvents.push(new BoundEventAst(eventName, null, phase, ast, sourceSpan));\n break;\n default:\n this._reportError(\"The provided animation output phase value \\\"\" + phase + \"\\\" for \\\"@\" + eventName + \"\\\" is not supported (use start or done)\", sourceSpan);\n break;\n }\n }\n else {\n this._reportError(\"The animation trigger output event (@\" + eventName + \") is missing its phase value name (start or done are currently supported)\", sourceSpan);\n }\n };\n /**\n * @param {?} name\n * @param {?} expression\n * @param {?} sourceSpan\n * @param {?} targetMatchableAttrs\n * @param {?} targetEvents\n * @return {?}\n */\n BindingParser.prototype._parseEvent = function (name, expression, sourceSpan, targetMatchableAttrs, targetEvents) {\n // long format: 'target: eventName'\n var _a = splitAtColon(name, [null, name]), target = _a[0], eventName = _a[1];\n var /** @type {?} */ ast = this._parseAction(expression, sourceSpan);\n targetMatchableAttrs.push([name, ast.source]);\n targetEvents.push(new BoundEventAst(eventName, target, null, ast, sourceSpan));\n // Don't detect directives for event names for now,\n // so don't add the event name to the matchableAttrs\n };\n /**\n * @param {?} value\n * @param {?} sourceSpan\n * @return {?}\n */\n BindingParser.prototype._parseAction = function (value, sourceSpan) {\n var /** @type {?} */ sourceInfo = sourceSpan.start.toString();\n try {\n var /** @type {?} */ ast = this._exprParser.parseAction(value, sourceInfo, this._interpolationConfig);\n if (ast) {\n this._reportExpressionParserErrors(ast.errors, sourceSpan);\n }\n if (!ast || ast.ast instanceof EmptyExpr) {\n this._reportError(\"Empty expressions are not allowed\", sourceSpan);\n return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);\n }\n this._checkPipes(ast, sourceSpan);\n return ast;\n }\n catch (e) {\n this._reportError(\"\" + e, sourceSpan);\n return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);\n }\n };\n /**\n * @param {?} message\n * @param {?} sourceSpan\n * @param {?=} level\n * @return {?}\n */\n BindingParser.prototype._reportError = function (message, sourceSpan, level) {\n if (level === void 0) { level = ParseErrorLevel.ERROR; }\n this._targetErrors.push(new ParseError(sourceSpan, message, level));\n };\n /**\n * @param {?} errors\n * @param {?} sourceSpan\n * @return {?}\n */\n BindingParser.prototype._reportExpressionParserErrors = function (errors, sourceSpan) {\n for (var _i = 0, errors_1 = errors; _i < errors_1.length; _i++) {\n var error = errors_1[_i];\n this._reportError(error.message, sourceSpan);\n }\n };\n /**\n * @param {?} ast\n * @param {?} sourceSpan\n * @return {?}\n */\n BindingParser.prototype._checkPipes = function (ast, sourceSpan) {\n var _this = this;\n if (ast) {\n var /** @type {?} */ collector = new PipeCollector();\n ast.visit(collector);\n collector.pipes.forEach(function (ast, pipeName) {\n var /** @type {?} */ pipeMeta = _this.pipesByName.get(pipeName);\n if (!pipeMeta) {\n _this._reportError(\"The pipe '\" + pipeName + \"' could not be found\", new ParseSourceSpan(sourceSpan.start.moveBy(ast.span.start), sourceSpan.start.moveBy(ast.span.end)));\n }\n else {\n _this._usedPipes.set(pipeName, pipeMeta);\n }\n });\n }\n };\n /**\n * @param {?} propName the name of the property / attribute\n * @param {?} sourceSpan\n * @param {?} isAttr true when binding to an attribute\n * @return {?}\n */\n BindingParser.prototype._validatePropertyOrAttributeName = function (propName, sourceSpan, isAttr) {\n var /** @type {?} */ report = isAttr ? this._schemaRegistry.validateAttribute(propName) :\n this._schemaRegistry.validateProperty(propName);\n if (report.error) {\n this._reportError(report.msg, sourceSpan, ParseErrorLevel.ERROR);\n }\n };\n return BindingParser;\n}());\nvar PipeCollector = (function (_super) {\n __extends(PipeCollector, _super);\n function PipeCollector() {\n var _this = _super.apply(this, arguments) || this;\n _this.pipes = new Map();\n return _this;\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n PipeCollector.prototype.visitPipe = function (ast, context) {\n this.pipes.set(ast.name, ast);\n ast.exp.visit(this);\n this.visitAll(ast.args, context);\n return null;\n };\n return PipeCollector;\n}(RecursiveAstVisitor));\n/**\n * @param {?} name\n * @return {?}\n */\nfunction _isAnimationLabel(name) {\n return name[0] == '@';\n}\n/**\n * @param {?} registry\n * @param {?} selector\n * @param {?} propName\n * @param {?} isAttribute\n * @return {?}\n */\nfunction calcPossibleSecurityContexts(registry, selector, propName, isAttribute) {\n var /** @type {?} */ ctxs = [];\n CssSelector.parse(selector).forEach(function (selector) {\n var /** @type {?} */ elementNames = selector.element ? [selector.element] : registry.allKnownElementNames();\n var /** @type {?} */ notElementNames = new Set(selector.notSelectors.filter(function (selector) { return selector.isElementSelector(); })\n .map(function (selector) { return selector.element; }));\n var /** @type {?} */ possibleElementNames = elementNames.filter(function (elementName) { return !notElementNames.has(elementName); });\n ctxs.push.apply(ctxs, possibleElementNames.map(function (elementName) { return registry.securityContext(elementName, propName, isAttribute); }));\n });\n return ctxs.length === 0 ? [SecurityContext.NONE] : Array.from(new Set(ctxs)).sort();\n}\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar NG_CONTENT_SELECT_ATTR = 'select';\nvar NG_CONTENT_ELEMENT = 'ng-content';\nvar LINK_ELEMENT = 'link';\nvar LINK_STYLE_REL_ATTR = 'rel';\nvar LINK_STYLE_HREF_ATTR = 'href';\nvar LINK_STYLE_REL_VALUE = 'stylesheet';\nvar STYLE_ELEMENT = 'style';\nvar SCRIPT_ELEMENT = 'script';\nvar NG_NON_BINDABLE_ATTR = 'ngNonBindable';\nvar NG_PROJECT_AS = 'ngProjectAs';\n/**\n * @param {?} ast\n * @return {?}\n */\nfunction preparseElement(ast) {\n var /** @type {?} */ selectAttr = null;\n var /** @type {?} */ hrefAttr = null;\n var /** @type {?} */ relAttr = null;\n var /** @type {?} */ nonBindable = false;\n var /** @type {?} */ projectAs = null;\n ast.attrs.forEach(function (attr) {\n var /** @type {?} */ lcAttrName = attr.name.toLowerCase();\n if (lcAttrName == NG_CONTENT_SELECT_ATTR) {\n selectAttr = attr.value;\n }\n else if (lcAttrName == LINK_STYLE_HREF_ATTR) {\n hrefAttr = attr.value;\n }\n else if (lcAttrName == LINK_STYLE_REL_ATTR) {\n relAttr = attr.value;\n }\n else if (attr.name == NG_NON_BINDABLE_ATTR) {\n nonBindable = true;\n }\n else if (attr.name == NG_PROJECT_AS) {\n if (attr.value.length > 0) {\n projectAs = attr.value;\n }\n }\n });\n selectAttr = normalizeNgContentSelect(selectAttr);\n var /** @type {?} */ nodeName = ast.name.toLowerCase();\n var /** @type {?} */ type = PreparsedElementType.OTHER;\n if (splitNsName(nodeName)[1] == NG_CONTENT_ELEMENT) {\n type = PreparsedElementType.NG_CONTENT;\n }\n else if (nodeName == STYLE_ELEMENT) {\n type = PreparsedElementType.STYLE;\n }\n else if (nodeName == SCRIPT_ELEMENT) {\n type = PreparsedElementType.SCRIPT;\n }\n else if (nodeName == LINK_ELEMENT && relAttr == LINK_STYLE_REL_VALUE) {\n type = PreparsedElementType.STYLESHEET;\n }\n return new PreparsedElement(type, selectAttr, hrefAttr, nonBindable, projectAs);\n}\nvar PreparsedElementType = {};\nPreparsedElementType.NG_CONTENT = 0;\nPreparsedElementType.STYLE = 1;\nPreparsedElementType.STYLESHEET = 2;\nPreparsedElementType.SCRIPT = 3;\nPreparsedElementType.OTHER = 4;\nPreparsedElementType[PreparsedElementType.NG_CONTENT] = \"NG_CONTENT\";\nPreparsedElementType[PreparsedElementType.STYLE] = \"STYLE\";\nPreparsedElementType[PreparsedElementType.STYLESHEET] = \"STYLESHEET\";\nPreparsedElementType[PreparsedElementType.SCRIPT] = \"SCRIPT\";\nPreparsedElementType[PreparsedElementType.OTHER] = \"OTHER\";\nvar PreparsedElement = (function () {\n /**\n * @param {?} type\n * @param {?} selectAttr\n * @param {?} hrefAttr\n * @param {?} nonBindable\n * @param {?} projectAs\n */\n function PreparsedElement(type, selectAttr, hrefAttr, nonBindable, projectAs) {\n this.type = type;\n this.selectAttr = selectAttr;\n this.hrefAttr = hrefAttr;\n this.nonBindable = nonBindable;\n this.projectAs = projectAs;\n }\n return PreparsedElement;\n}());\n/**\n * @param {?} selectAttr\n * @return {?}\n */\nfunction normalizeNgContentSelect(selectAttr) {\n if (selectAttr === null || selectAttr.length === 0) {\n return '*';\n }\n return selectAttr;\n}\n/**\n * @license\n * Copyright Google Inc. 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 */\nvar BIND_NAME_REGEXP = /^(?:(?:(?:(bind-)|(let-)|(ref-|#)|(on-)|(bindon-)|(@))(.+))|\\[\\(([^\\)]+)\\)\\]|\\[([^\\]]+)\\]|\\(([^\\)]+)\\))$/;\n// Group 1 = \"bind-\"\nvar KW_BIND_IDX = 1;\n// Group 2 = \"let-\"\nvar KW_LET_IDX = 2;\n// Group 3 = \"ref-/#\"\nvar KW_REF_IDX = 3;\n// Group 4 = \"on-\"\nvar KW_ON_IDX = 4;\n// Group 5 = \"bindon-\"\nvar KW_BINDON_IDX = 5;\n// Group 6 = \"@\"\nvar KW_AT_IDX = 6;\n// Group 7 = the identifier after \"bind-\", \"let-\", \"ref-/#\", \"on-\", \"bindon-\" or \"@\"\nvar IDENT_KW_IDX = 7;\n// Group 8 = identifier inside [()]\nvar IDENT_BANANA_BOX_IDX = 8;\n// Group 9 = identifier inside []\nvar IDENT_PROPERTY_IDX = 9;\n// Group 10 = identifier inside ()\nvar IDENT_EVENT_IDX = 10;\nvar NG_TEMPLATE_ELEMENT = 'ng-template';\n// deprecated in 4.x\nvar TEMPLATE_ELEMENT = 'template';\n// deprecated in 4.x\nvar TEMPLATE_ATTR = 'template';\nvar TEMPLATE_ATTR_PREFIX = '*';\nvar CLASS_ATTR = 'class';\nvar TEXT_CSS_SELECTOR = CssSelector.parse('*')[0];\nvar TEMPLATE_ELEMENT_DEPRECATION_WARNING = 'The element is deprecated. Use instead';\nvar TEMPLATE_ATTR_DEPRECATION_WARNING = 'The template attribute is deprecated. Use an ng-template element instead.';\nvar warningCounts = {};\n/**\n * @param {?} warnings\n * @return {?}\n */\nfunction warnOnlyOnce(warnings) {\n return function (error) {\n if (warnings.indexOf(error.msg) !== -1) {\n warningCounts[error.msg] = (warningCounts[error.msg] || 0) + 1;\n return warningCounts[error.msg] <= 1;\n }\n return true;\n };\n}\n/**\n * Provides an array of {@link TemplateAstVisitor}s which will be used to transform\n * parsed templates before compilation is invoked, allowing custom expression syntax\n * and other advanced transformations.\n *\n * This is currently an internal-only feature and not meant for general use.\n */\nvar TEMPLATE_TRANSFORMS = new InjectionToken('TemplateTransforms');\nvar TemplateParseError = (function (_super) {\n __extends(TemplateParseError, _super);\n /**\n * @param {?} message\n * @param {?} span\n * @param {?} level\n */\n function TemplateParseError(message, span, level) {\n return _super.call(this, span, message, level) || this;\n }\n return TemplateParseError;\n}(ParseError));\nvar TemplateParseResult = (function () {\n /**\n * @param {?=} templateAst\n * @param {?=} usedPipes\n * @param {?=} errors\n */\n function TemplateParseResult(templateAst, usedPipes, errors) {\n this.templateAst = templateAst;\n this.usedPipes = usedPipes;\n this.errors = errors;\n }\n return TemplateParseResult;\n}());\nvar TemplateParser = (function () {\n /**\n * @param {?} _config\n * @param {?} _exprParser\n * @param {?} _schemaRegistry\n * @param {?} _htmlParser\n * @param {?} _console\n * @param {?} transforms\n */\n function TemplateParser(_config, _exprParser, _schemaRegistry, _htmlParser, _console, transforms) {\n this._config = _config;\n this._exprParser = _exprParser;\n this._schemaRegistry = _schemaRegistry;\n this._htmlParser = _htmlParser;\n this._console = _console;\n this.transforms = transforms;\n }\n /**\n * @param {?} component\n * @param {?} template\n * @param {?} directives\n * @param {?} pipes\n * @param {?} schemas\n * @param {?} templateUrl\n * @return {?}\n */\n TemplateParser.prototype.parse = function (component, template, directives, pipes, schemas, templateUrl) {\n var /** @type {?} */ result = this.tryParse(component, template, directives, pipes, schemas, templateUrl);\n var /** @type {?} */ warnings = result.errors.filter(function (error) { return error.level === ParseErrorLevel.WARNING; }).filter(warnOnlyOnce([\n TEMPLATE_ATTR_DEPRECATION_WARNING, TEMPLATE_ELEMENT_DEPRECATION_WARNING\n ]));\n var /** @type {?} */ errors = result.errors.filter(function (error) { return error.level === ParseErrorLevel.ERROR; });\n if (warnings.length > 0) {\n this._console.warn(\"Template parse warnings:\\n\" + warnings.join('\\n'));\n }\n if (errors.length > 0) {\n var /** @type {?} */ errorString = errors.join('\\n');\n throw syntaxError(\"Template parse errors:\\n\" + errorString);\n }\n return { template: result.templateAst, pipes: result.usedPipes };\n };\n /**\n * @param {?} component\n * @param {?} template\n * @param {?} directives\n * @param {?} pipes\n * @param {?} schemas\n * @param {?} templateUrl\n * @return {?}\n */\n TemplateParser.prototype.tryParse = function (component, template, directives, pipes, schemas, templateUrl) {\n return this.tryParseHtml(this.expandHtml(this._htmlParser.parse(template, templateUrl, true, this.getInterpolationConfig(component))), component, template, directives, pipes, schemas, templateUrl);\n };\n /**\n * @param {?} htmlAstWithErrors\n * @param {?} component\n * @param {?} template\n * @param {?} directives\n * @param {?} pipes\n * @param {?} schemas\n * @param {?} templateUrl\n * @return {?}\n */\n TemplateParser.prototype.tryParseHtml = function (htmlAstWithErrors, component, template, directives, pipes, schemas, templateUrl) {\n var /** @type {?} */ result;\n var /** @type {?} */ errors = htmlAstWithErrors.errors;\n var /** @type {?} */ usedPipes = [];\n if (htmlAstWithErrors.rootNodes.length > 0) {\n var /** @type {?} */ uniqDirectives = removeSummaryDuplicates(directives);\n var /** @type {?} */ uniqPipes = removeSummaryDuplicates(pipes);\n var /** @type {?} */ providerViewContext = new ProviderViewContext(component);\n var /** @type {?} */ interpolationConfig = void 0;\n if (component.template && component.template.interpolation) {\n interpolationConfig = {\n start: component.template.interpolation[0],\n end: component.template.interpolation[1]\n };\n }\n var /** @type {?} */ bindingParser = new BindingParser(this._exprParser, interpolationConfig, this._schemaRegistry, uniqPipes, errors);\n var /** @type {?} */ parseVisitor = new TemplateParseVisitor(this._config, providerViewContext, uniqDirectives, bindingParser, this._schemaRegistry, schemas, errors);\n result = visitAll(parseVisitor, htmlAstWithErrors.rootNodes, EMPTY_ELEMENT_CONTEXT);\n errors.push.apply(errors, providerViewContext.errors);\n usedPipes.push.apply(usedPipes, bindingParser.getUsedPipes());\n }\n else {\n result = [];\n }\n this._assertNoReferenceDuplicationOnTemplate(result, errors);\n if (errors.length > 0) {\n return new TemplateParseResult(result, usedPipes, errors);\n }\n if (this.transforms) {\n this.transforms.forEach(function (transform) { result = templateVisitAll(transform, result); });\n }\n return new TemplateParseResult(result, usedPipes, errors);\n };\n /**\n * @param {?} htmlAstWithErrors\n * @param {?=} forced\n * @return {?}\n */\n TemplateParser.prototype.expandHtml = function (htmlAstWithErrors, forced) {\n if (forced === void 0) { forced = false; }\n var /** @type {?} */ errors = htmlAstWithErrors.errors;\n if (errors.length == 0 || forced) {\n // Transform ICU messages to angular directives\n var /** @type {?} */ expandedHtmlAst = expandNodes(htmlAstWithErrors.rootNodes);\n errors.push.apply(errors, expandedHtmlAst.errors);\n htmlAstWithErrors = new ParseTreeResult(expandedHtmlAst.nodes, errors);\n }\n return htmlAstWithErrors;\n };\n /**\n * @param {?} component\n * @return {?}\n */\n TemplateParser.prototype.getInterpolationConfig = function (component) {\n if (component.template) {\n return InterpolationConfig.fromArray(component.template.interpolation);\n }\n };\n /**\n * \\@internal\n * @param {?} result\n * @param {?} errors\n * @return {?}\n */\n TemplateParser.prototype._assertNoReferenceDuplicationOnTemplate = function (result, errors) {\n var /** @type {?} */ existingReferences = [];\n result.filter(function (element) { return !!((element)).references; })\n .forEach(function (element) { return ((element)).references.forEach(function (reference) {\n var /** @type {?} */ name = reference.name;\n if (existingReferences.indexOf(name) < 0) {\n existingReferences.push(name);\n }\n else {\n var /** @type {?} */ error = new TemplateParseError(\"Reference \\\"#\" + name + \"\\\" is defined several times\", reference.sourceSpan, ParseErrorLevel.ERROR);\n errors.push(error);\n }\n }); });\n };\n return TemplateParser;\n}());\nTemplateParser.decorators = [\n { type: CompilerInjectable },\n];\n/**\n * @nocollapse\n */\nTemplateParser.ctorParameters = function () { return [\n { type: CompilerConfig, },\n { type: Parser, },\n { type: ElementSchemaRegistry, },\n { type: I18NHtmlParser, },\n { type: ɵConsole, },\n { type: Array, decorators: [{ type: Optional }, { type: Inject, args: [TEMPLATE_TRANSFORMS,] },] },\n]; };\nvar TemplateParseVisitor = (function () {\n /**\n * @param {?} config\n * @param {?} providerViewContext\n * @param {?} directives\n * @param {?} _bindingParser\n * @param {?} _schemaRegistry\n * @param {?} _schemas\n * @param {?} _targetErrors\n */\n function TemplateParseVisitor(config, providerViewContext, directives, _bindingParser, _schemaRegistry, _schemas, _targetErrors) {\n var _this = this;\n this.config = config;\n this.providerViewContext = providerViewContext;\n this._bindingParser = _bindingParser;\n this._schemaRegistry = _schemaRegistry;\n this._schemas = _schemas;\n this._targetErrors = _targetErrors;\n this.selectorMatcher = new SelectorMatcher();\n this.directivesIndex = new Map();\n this.ngContentCount = 0;\n // Note: queries start with id 1 so we can use the number in a Bloom filter!\n this.contentQueryStartId = providerViewContext.component.viewQueries.length + 1;\n directives.forEach(function (directive, index) {\n var selector = CssSelector.parse(directive.selector);\n _this.selectorMatcher.addSelectables(selector, directive);\n _this.directivesIndex.set(directive, index);\n });\n }\n /**\n * @param {?} expansion\n * @param {?} context\n * @return {?}\n */\n TemplateParseVisitor.prototype.visitExpansion = function (expansion, context) { return null; };\n /**\n * @param {?} expansionCase\n * @param {?} context\n * @return {?}\n */\n TemplateParseVisitor.prototype.visitExpansionCase = function (expansionCase, context) { return null; };\n /**\n * @param {?} text\n * @param {?} parent\n * @return {?}\n */\n TemplateParseVisitor.prototype.visitText = function (text, parent) {\n var /** @type {?} */ ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR);\n var /** @type {?} */ expr = this._bindingParser.parseInterpolation(text.value, text.sourceSpan);\n return expr ? new BoundTextAst(expr, ngContentIndex, text.sourceSpan) :\n new TextAst(text.value, ngContentIndex, text.sourceSpan);\n };\n /**\n * @param {?} attribute\n * @param {?} context\n * @return {?}\n */\n TemplateParseVisitor.prototype.visitAttribute = function (attribute, context) {\n return new AttrAst(attribute.name, attribute.value, attribute.sourceSpan);\n };\n /**\n * @param {?} comment\n * @param {?} context\n * @return {?}\n */\n TemplateParseVisitor.prototype.visitComment = function (comment, context) { return null; };\n /**\n * @param {?} element\n * @param {?} parent\n * @return {?}\n */\n TemplateParseVisitor.prototype.visitElement = function (element, parent) {\n var _this = this;\n var /** @type {?} */ queryStartIndex = this.contentQueryStartId;\n var /** @type {?} */ nodeName = element.name;\n var /** @type {?} */ preparsedElement = preparseElement(element);\n if (preparsedElement.type === PreparsedElementType.SCRIPT ||\n preparsedElement.type === PreparsedElementType.STYLE) {\n // Skipping