'.\");\n }\n host[(\"[\" + hostBinding.hostPropertyName + \"]\")] = propName;\n }\n else {\n host[(\"[\" + propName + \"]\")] = propName;\n }\n });\n var /** @type {?} */ hostListeners = propertyMetadata[propName].filter(function (a) { return a && a instanceof HostListener; });\n hostListeners.forEach(function (hostListener) {\n var /** @type {?} */ args = hostListener.args || [];\n host[(\"(\" + hostListener.eventName + \")\")] = propName + \"(\" + args.join(',') + \")\";\n });\n var /** @type {?} */ query = ListWrapper.findLast(propertyMetadata[propName], function (a) { return a instanceof Query; });\n if (query) {\n queries[propName] = query;\n }\n });\n return this._merge(dm, inputs, outputs, host, queries, directiveType);\n };\n /**\n * @param {?} def\n * @return {?}\n */\n DirectiveResolver.prototype._extractPublicName = function (def) { return splitAtColon(def, [null, def])[1].trim(); };\n /**\n * @param {?} bindings\n * @return {?}\n */\n DirectiveResolver.prototype._dedupeBindings = function (bindings) {\n var /** @type {?} */ names = new Set();\n var /** @type {?} */ reversedResult = [];\n // go last to first to allow later entries to overwrite previous entries\n for (var /** @type {?} */ i = bindings.length - 1; i >= 0; i--) {\n var /** @type {?} */ binding = bindings[i];\n var /** @type {?} */ name_1 = this._extractPublicName(binding);\n if (!names.has(name_1)) {\n names.add(name_1);\n reversedResult.push(binding);\n }\n }\n return reversedResult.reverse();\n };\n /**\n * @param {?} directive\n * @param {?} inputs\n * @param {?} outputs\n * @param {?} host\n * @param {?} queries\n * @param {?} directiveType\n * @return {?}\n */\n DirectiveResolver.prototype._merge = function (directive, inputs, outputs, host, queries, directiveType) {\n var /** @type {?} */ mergedInputs = this._dedupeBindings(directive.inputs ? directive.inputs.concat(inputs) : inputs);\n var /** @type {?} */ mergedOutputs = this._dedupeBindings(directive.outputs ? directive.outputs.concat(outputs) : outputs);\n var /** @type {?} */ mergedHost = directive.host ? StringMapWrapper.merge(directive.host, host) : host;\n var /** @type {?} */ mergedQueries = directive.queries ? StringMapWrapper.merge(directive.queries, queries) : queries;\n if (directive instanceof Component) {\n return new Component({\n selector: directive.selector,\n inputs: mergedInputs,\n outputs: mergedOutputs,\n host: mergedHost,\n exportAs: directive.exportAs,\n moduleId: directive.moduleId,\n queries: mergedQueries,\n changeDetection: directive.changeDetection,\n providers: directive.providers,\n viewProviders: directive.viewProviders,\n entryComponents: directive.entryComponents,\n template: directive.template,\n templateUrl: directive.templateUrl,\n styles: directive.styles,\n styleUrls: directive.styleUrls,\n encapsulation: directive.encapsulation,\n animations: directive.animations,\n interpolation: directive.interpolation\n });\n }\n else {\n return new Directive({\n selector: directive.selector,\n inputs: mergedInputs,\n outputs: mergedOutputs,\n host: mergedHost,\n exportAs: directive.exportAs,\n queries: mergedQueries,\n providers: directive.providers\n });\n }\n };\n DirectiveResolver = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [ReflectorReader])\n ], DirectiveResolver);\n return DirectiveResolver;\n}());\nfunction DirectiveResolver_tsickle_Closure_declarations() {\n /** @type {?} */\n DirectiveResolver.prototype._reflector;\n}\n/**\n * @param {?} type\n * @return {?}\n */\nfunction isDirectiveMetadata(type) {\n return type instanceof Directive;\n}\n//# sourceMappingURL=directive_resolver.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/directive_resolver.js\n// module id = ./node_modules/@angular/compiler/src/directive_resolver.js\n// module chunks = 0","/**\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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { identifierModuleUrl, identifierName } from './compile_metadata';\nimport { createCheckBindingField, createCheckBindingStmt } from './compiler_util/binding_util';\nimport { EventHandlerVars, convertActionBinding, convertPropertyBinding } from './compiler_util/expression_converter';\nimport { triggerAnimation, writeToRenderer } from './compiler_util/render_util';\nimport { CompilerConfig } from './config';\nimport { Parser } from './expression_parser/parser';\nimport { Identifiers, createIdentifier } from './identifiers';\nimport { CompilerInjectable } from './injectable';\nimport { DEFAULT_INTERPOLATION_CONFIG } from './ml_parser/interpolation_config';\nimport { createClassStmt } from './output/class_builder';\nimport * as o from './output/output_ast';\nimport { ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan } from './parse_util';\nimport { Console, LifecycleHooks } from './private_import_core';\nimport { ElementSchemaRegistry } from './schema/element_schema_registry';\nimport { BindingParser } from './template_parser/binding_parser';\nexport var DirectiveWrapperCompileResult = (function () {\n /**\n * @param {?} statements\n * @param {?} dirWrapperClassVar\n */\n function DirectiveWrapperCompileResult(statements, dirWrapperClassVar) {\n this.statements = statements;\n this.dirWrapperClassVar = dirWrapperClassVar;\n }\n return DirectiveWrapperCompileResult;\n}());\nfunction DirectiveWrapperCompileResult_tsickle_Closure_declarations() {\n /** @type {?} */\n DirectiveWrapperCompileResult.prototype.statements;\n /** @type {?} */\n DirectiveWrapperCompileResult.prototype.dirWrapperClassVar;\n}\nvar /** @type {?} */ CONTEXT_FIELD_NAME = 'context';\nvar /** @type {?} */ CHANGES_FIELD_NAME = '_changes';\nvar /** @type {?} */ CHANGED_FIELD_NAME = '_changed';\nvar /** @type {?} */ EVENT_HANDLER_FIELD_NAME = '_eventHandler';\nvar /** @type {?} */ CURR_VALUE_VAR = o.variable('currValue');\nvar /** @type {?} */ THROW_ON_CHANGE_VAR = o.variable('throwOnChange');\nvar /** @type {?} */ FORCE_UPDATE_VAR = o.variable('forceUpdate');\nvar /** @type {?} */ VIEW_VAR = o.variable('view');\nvar /** @type {?} */ COMPONENT_VIEW_VAR = o.variable('componentView');\nvar /** @type {?} */ RENDER_EL_VAR = o.variable('el');\nvar /** @type {?} */ EVENT_NAME_VAR = o.variable('eventName');\nvar /** @type {?} */ RESET_CHANGES_STMT = o.THIS_EXPR.prop(CHANGES_FIELD_NAME).set(o.literalMap([])).toStmt();\n/**\n * We generate directive wrappers to prevent code bloat when a directive is used.\n * A directive wrapper encapsulates\n * the dirty checking for `@Input`, the handling of `@HostListener` / `@HostBinding`\n * and calling the lifecyclehooks `ngOnInit`, `ngOnChanges`, `ngDoCheck`.\n * *\n * So far, only `@Input` and the lifecycle hooks have been implemented.\n */\nexport var DirectiveWrapperCompiler = (function () {\n /**\n * @param {?} compilerConfig\n * @param {?} _exprParser\n * @param {?} _schemaRegistry\n * @param {?} _console\n */\n function DirectiveWrapperCompiler(compilerConfig, _exprParser, _schemaRegistry, _console) {\n this.compilerConfig = compilerConfig;\n this._exprParser = _exprParser;\n this._schemaRegistry = _schemaRegistry;\n this._console = _console;\n }\n /**\n * @param {?} id\n * @return {?}\n */\n DirectiveWrapperCompiler.dirWrapperClassName = function (id) {\n return \"Wrapper_\" + identifierName(id);\n };\n /**\n * @param {?} dirMeta\n * @return {?}\n */\n DirectiveWrapperCompiler.prototype.compile = function (dirMeta) {\n var /** @type {?} */ hostParseResult = parseHostBindings(dirMeta, this._exprParser, this._schemaRegistry);\n reportParseErrors(hostParseResult.errors, this._console);\n var /** @type {?} */ builder = new DirectiveWrapperBuilder(this.compilerConfig, dirMeta);\n Object.keys(dirMeta.inputs).forEach(function (inputFieldName) {\n addCheckInputMethod(inputFieldName, builder);\n });\n addNgDoCheckMethod(builder);\n addCheckHostMethod(hostParseResult.hostProps, hostParseResult.hostListeners, builder);\n addHandleEventMethod(hostParseResult.hostListeners, builder);\n addSubscribeMethod(dirMeta, builder);\n var /** @type {?} */ classStmt = builder.build();\n return new DirectiveWrapperCompileResult([classStmt], classStmt.name);\n };\n DirectiveWrapperCompiler = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [CompilerConfig, Parser, ElementSchemaRegistry, Console])\n ], DirectiveWrapperCompiler);\n return DirectiveWrapperCompiler;\n}());\nfunction DirectiveWrapperCompiler_tsickle_Closure_declarations() {\n /** @type {?} */\n DirectiveWrapperCompiler.prototype.compilerConfig;\n /** @type {?} */\n DirectiveWrapperCompiler.prototype._exprParser;\n /** @type {?} */\n DirectiveWrapperCompiler.prototype._schemaRegistry;\n /** @type {?} */\n DirectiveWrapperCompiler.prototype._console;\n}\nvar DirectiveWrapperBuilder = (function () {\n /**\n * @param {?} compilerConfig\n * @param {?} dirMeta\n */\n function DirectiveWrapperBuilder(compilerConfig, dirMeta) {\n this.compilerConfig = compilerConfig;\n this.dirMeta = dirMeta;\n this.fields = [];\n this.getters = [];\n this.methods = [];\n this.ctorStmts = [];\n this.detachStmts = [];\n this.destroyStmts = [];\n var dirLifecycleHooks = dirMeta.type.lifecycleHooks;\n this.genChanges = dirLifecycleHooks.indexOf(LifecycleHooks.OnChanges) !== -1 ||\n this.compilerConfig.logBindingUpdate;\n this.ngOnChanges = dirLifecycleHooks.indexOf(LifecycleHooks.OnChanges) !== -1;\n this.ngOnInit = dirLifecycleHooks.indexOf(LifecycleHooks.OnInit) !== -1;\n this.ngDoCheck = dirLifecycleHooks.indexOf(LifecycleHooks.DoCheck) !== -1;\n this.ngOnDestroy = dirLifecycleHooks.indexOf(LifecycleHooks.OnDestroy) !== -1;\n if (this.ngOnDestroy) {\n this.destroyStmts.push(o.THIS_EXPR.prop(CONTEXT_FIELD_NAME).callMethod('ngOnDestroy', []).toStmt());\n }\n }\n /**\n * @return {?}\n */\n DirectiveWrapperBuilder.prototype.build = function () {\n var /** @type {?} */ dirDepParamNames = [];\n for (var /** @type {?} */ i = 0; i < this.dirMeta.type.diDeps.length; i++) {\n dirDepParamNames.push(\"p\" + i);\n }\n var /** @type {?} */ methods = [\n new o.ClassMethod('ngOnDetach', [\n new o.FnParam(VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),\n new o.FnParam(COMPONENT_VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),\n new o.FnParam(RENDER_EL_VAR.name, o.DYNAMIC_TYPE),\n ], this.detachStmts),\n new o.ClassMethod('ngOnDestroy', [], this.destroyStmts),\n ];\n var /** @type {?} */ fields = [\n new o.ClassField(EVENT_HANDLER_FIELD_NAME, o.FUNCTION_TYPE, [o.StmtModifier.Private]),\n new o.ClassField(CONTEXT_FIELD_NAME, o.importType(this.dirMeta.type)),\n new o.ClassField(CHANGED_FIELD_NAME, o.BOOL_TYPE, [o.StmtModifier.Private]),\n ];\n var /** @type {?} */ ctorStmts = [o.THIS_EXPR.prop(CHANGED_FIELD_NAME).set(o.literal(false)).toStmt()];\n if (this.genChanges) {\n fields.push(new o.ClassField(CHANGES_FIELD_NAME, new o.MapType(o.DYNAMIC_TYPE), [o.StmtModifier.Private]));\n ctorStmts.push(RESET_CHANGES_STMT);\n }\n ctorStmts.push(o.THIS_EXPR.prop(CONTEXT_FIELD_NAME)\n .set(o.importExpr(this.dirMeta.type)\n .instantiate(dirDepParamNames.map(function (paramName) { return o.variable(paramName); })))\n .toStmt());\n return createClassStmt({\n name: DirectiveWrapperCompiler.dirWrapperClassName(this.dirMeta.type),\n ctorParams: dirDepParamNames.map(function (paramName) { return new o.FnParam(paramName, o.DYNAMIC_TYPE); }),\n builders: [{ fields: fields, ctorStmts: ctorStmts, methods: methods }, this]\n });\n };\n return DirectiveWrapperBuilder;\n}());\nfunction DirectiveWrapperBuilder_tsickle_Closure_declarations() {\n /** @type {?} */\n DirectiveWrapperBuilder.prototype.fields;\n /** @type {?} */\n DirectiveWrapperBuilder.prototype.getters;\n /** @type {?} */\n DirectiveWrapperBuilder.prototype.methods;\n /** @type {?} */\n DirectiveWrapperBuilder.prototype.ctorStmts;\n /** @type {?} */\n DirectiveWrapperBuilder.prototype.detachStmts;\n /** @type {?} */\n DirectiveWrapperBuilder.prototype.destroyStmts;\n /** @type {?} */\n DirectiveWrapperBuilder.prototype.genChanges;\n /** @type {?} */\n DirectiveWrapperBuilder.prototype.ngOnChanges;\n /** @type {?} */\n DirectiveWrapperBuilder.prototype.ngOnInit;\n /** @type {?} */\n DirectiveWrapperBuilder.prototype.ngDoCheck;\n /** @type {?} */\n DirectiveWrapperBuilder.prototype.ngOnDestroy;\n /** @type {?} */\n DirectiveWrapperBuilder.prototype.compilerConfig;\n /** @type {?} */\n DirectiveWrapperBuilder.prototype.dirMeta;\n}\n/**\n * @param {?} builder\n * @return {?}\n */\nfunction addNgDoCheckMethod(builder) {\n var /** @type {?} */ changedVar = o.variable('changed');\n var /** @type {?} */ stmts = [\n changedVar.set(o.THIS_EXPR.prop(CHANGED_FIELD_NAME)).toDeclStmt(),\n o.THIS_EXPR.prop(CHANGED_FIELD_NAME).set(o.literal(false)).toStmt(),\n ];\n var /** @type {?} */ lifecycleStmts = [];\n if (builder.genChanges) {\n var /** @type {?} */ onChangesStmts = [];\n if (builder.ngOnChanges) {\n onChangesStmts.push(o.THIS_EXPR.prop(CONTEXT_FIELD_NAME)\n .callMethod('ngOnChanges', [o.THIS_EXPR.prop(CHANGES_FIELD_NAME)])\n .toStmt());\n }\n if (builder.compilerConfig.logBindingUpdate) {\n onChangesStmts.push(o.importExpr(createIdentifier(Identifiers.setBindingDebugInfoForChanges))\n .callFn([VIEW_VAR.prop('renderer'), RENDER_EL_VAR, o.THIS_EXPR.prop(CHANGES_FIELD_NAME)])\n .toStmt());\n }\n onChangesStmts.push(RESET_CHANGES_STMT);\n lifecycleStmts.push(new o.IfStmt(changedVar, onChangesStmts));\n }\n if (builder.ngOnInit) {\n lifecycleStmts.push(new o.IfStmt(VIEW_VAR.prop('numberOfChecks').identical(new o.LiteralExpr(0)), [o.THIS_EXPR.prop(CONTEXT_FIELD_NAME).callMethod('ngOnInit', []).toStmt()]));\n }\n if (builder.ngDoCheck) {\n lifecycleStmts.push(o.THIS_EXPR.prop(CONTEXT_FIELD_NAME).callMethod('ngDoCheck', []).toStmt());\n }\n if (lifecycleStmts.length > 0) {\n stmts.push(new o.IfStmt(o.not(THROW_ON_CHANGE_VAR), lifecycleStmts));\n }\n stmts.push(new o.ReturnStatement(changedVar));\n builder.methods.push(new o.ClassMethod('ngDoCheck', [\n new o.FnParam(VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),\n new o.FnParam(RENDER_EL_VAR.name, o.DYNAMIC_TYPE),\n new o.FnParam(THROW_ON_CHANGE_VAR.name, o.BOOL_TYPE),\n ], stmts, o.BOOL_TYPE));\n}\n/**\n * @param {?} input\n * @param {?} builder\n * @return {?}\n */\nfunction addCheckInputMethod(input, builder) {\n var /** @type {?} */ field = createCheckBindingField(builder);\n var /** @type {?} */ onChangeStatements = [\n o.THIS_EXPR.prop(CHANGED_FIELD_NAME).set(o.literal(true)).toStmt(),\n o.THIS_EXPR.prop(CONTEXT_FIELD_NAME).prop(input).set(CURR_VALUE_VAR).toStmt(),\n ];\n if (builder.genChanges) {\n onChangeStatements.push(o.THIS_EXPR.prop(CHANGES_FIELD_NAME)\n .key(o.literal(input))\n .set(o.importExpr(createIdentifier(Identifiers.SimpleChange))\n .instantiate([field.expression, CURR_VALUE_VAR]))\n .toStmt());\n }\n var /** @type {?} */ methodBody = createCheckBindingStmt({ currValExpr: CURR_VALUE_VAR, forceUpdate: FORCE_UPDATE_VAR, stmts: [] }, field.expression, THROW_ON_CHANGE_VAR, onChangeStatements);\n builder.methods.push(new o.ClassMethod(\"check_\" + input, [\n new o.FnParam(CURR_VALUE_VAR.name, o.DYNAMIC_TYPE),\n new o.FnParam(THROW_ON_CHANGE_VAR.name, o.BOOL_TYPE),\n new o.FnParam(FORCE_UPDATE_VAR.name, o.BOOL_TYPE),\n ], methodBody));\n}\n/**\n * @param {?} hostProps\n * @param {?} hostEvents\n * @param {?} builder\n * @return {?}\n */\nfunction addCheckHostMethod(hostProps, hostEvents, builder) {\n var /** @type {?} */ stmts = [];\n var /** @type {?} */ methodParams = [\n new o.FnParam(VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),\n new o.FnParam(COMPONENT_VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),\n new o.FnParam(RENDER_EL_VAR.name, o.DYNAMIC_TYPE),\n new o.FnParam(THROW_ON_CHANGE_VAR.name, o.BOOL_TYPE),\n ];\n hostProps.forEach(function (hostProp, hostPropIdx) {\n var /** @type {?} */ field = createCheckBindingField(builder);\n var /** @type {?} */ evalResult = convertPropertyBinding(builder, null, o.THIS_EXPR.prop(CONTEXT_FIELD_NAME), hostProp.value, field.bindingId);\n if (!evalResult) {\n return;\n }\n var /** @type {?} */ securityContextExpr;\n if (hostProp.needsRuntimeSecurityContext) {\n securityContextExpr = o.variable(\"secCtx_\" + methodParams.length);\n methodParams.push(new o.FnParam(securityContextExpr.name, o.importType(createIdentifier(Identifiers.SecurityContext))));\n }\n var /** @type {?} */ checkBindingStmts;\n if (hostProp.isAnimation) {\n var _a = triggerAnimation(VIEW_VAR, COMPONENT_VIEW_VAR, hostProp, hostEvents, o.THIS_EXPR.prop(EVENT_HANDLER_FIELD_NAME)\n .or(o.importExpr(createIdentifier(Identifiers.noop))), RENDER_EL_VAR, evalResult.currValExpr, field.expression), updateStmts = _a.updateStmts, detachStmts = _a.detachStmts;\n checkBindingStmts = updateStmts;\n (_b = builder.detachStmts).push.apply(_b, detachStmts);\n }\n else {\n checkBindingStmts = writeToRenderer(VIEW_VAR, hostProp, RENDER_EL_VAR, evalResult.currValExpr, builder.compilerConfig.logBindingUpdate, securityContextExpr);\n }\n stmts.push.apply(stmts, createCheckBindingStmt(evalResult, field.expression, THROW_ON_CHANGE_VAR, checkBindingStmts));\n var _b;\n });\n builder.methods.push(new o.ClassMethod('checkHost', methodParams, stmts));\n}\n/**\n * @param {?} hostListeners\n * @param {?} builder\n * @return {?}\n */\nfunction addHandleEventMethod(hostListeners, builder) {\n var /** @type {?} */ resultVar = o.variable(\"result\");\n var /** @type {?} */ actionStmts = [resultVar.set(o.literal(true)).toDeclStmt(o.BOOL_TYPE)];\n hostListeners.forEach(function (hostListener, eventIdx) {\n var /** @type {?} */ evalResult = convertActionBinding(builder, null, o.THIS_EXPR.prop(CONTEXT_FIELD_NAME), hostListener.handler, \"sub_\" + eventIdx);\n var /** @type {?} */ trueStmts = evalResult.stmts;\n if (evalResult.preventDefault) {\n trueStmts.push(resultVar.set(evalResult.preventDefault.and(resultVar)).toStmt());\n }\n // TODO(tbosch): convert this into a `switch` once our OutputAst supports it.\n actionStmts.push(new o.IfStmt(EVENT_NAME_VAR.equals(o.literal(hostListener.fullName)), trueStmts));\n });\n actionStmts.push(new o.ReturnStatement(resultVar));\n builder.methods.push(new o.ClassMethod('handleEvent', [\n new o.FnParam(EVENT_NAME_VAR.name, o.STRING_TYPE),\n new o.FnParam(EventHandlerVars.event.name, o.DYNAMIC_TYPE)\n ], actionStmts, o.BOOL_TYPE));\n}\n/**\n * @param {?} dirMeta\n * @param {?} builder\n * @return {?}\n */\nfunction addSubscribeMethod(dirMeta, builder) {\n var /** @type {?} */ methodParams = [\n new o.FnParam(VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),\n new o.FnParam(EVENT_HANDLER_FIELD_NAME, o.DYNAMIC_TYPE)\n ];\n var /** @type {?} */ stmts = [\n o.THIS_EXPR.prop(EVENT_HANDLER_FIELD_NAME).set(o.variable(EVENT_HANDLER_FIELD_NAME)).toStmt()\n ];\n Object.keys(dirMeta.outputs).forEach(function (emitterPropName, emitterIdx) {\n var /** @type {?} */ eventName = dirMeta.outputs[emitterPropName];\n var /** @type {?} */ paramName = \"emit\" + emitterIdx;\n methodParams.push(new o.FnParam(paramName, o.BOOL_TYPE));\n var /** @type {?} */ subscriptionFieldName = \"subscription\" + emitterIdx;\n builder.fields.push(new o.ClassField(subscriptionFieldName, o.DYNAMIC_TYPE));\n stmts.push(new o.IfStmt(o.variable(paramName), [\n o.THIS_EXPR.prop(subscriptionFieldName)\n .set(o.THIS_EXPR.prop(CONTEXT_FIELD_NAME)\n .prop(emitterPropName)\n .callMethod(o.BuiltinMethod.SubscribeObservable, [o.variable(EVENT_HANDLER_FIELD_NAME)\n .callMethod(o.BuiltinMethod.Bind, [VIEW_VAR, o.literal(eventName)])]))\n .toStmt()\n ]));\n builder.destroyStmts.push(o.THIS_EXPR.prop(subscriptionFieldName)\n .and(o.THIS_EXPR.prop(subscriptionFieldName).callMethod('unsubscribe', []))\n .toStmt());\n });\n builder.methods.push(new o.ClassMethod('subscribe', methodParams, stmts));\n}\nvar ParseResult = (function () {\n /**\n * @param {?} hostProps\n * @param {?} hostListeners\n * @param {?} errors\n */\n function ParseResult(hostProps, hostListeners, errors) {\n this.hostProps = hostProps;\n this.hostListeners = hostListeners;\n this.errors = errors;\n }\n return ParseResult;\n}());\nfunction ParseResult_tsickle_Closure_declarations() {\n /** @type {?} */\n ParseResult.prototype.hostProps;\n /** @type {?} */\n ParseResult.prototype.hostListeners;\n /** @type {?} */\n ParseResult.prototype.errors;\n}\n/**\n * @param {?} dirMeta\n * @param {?} exprParser\n * @param {?} schemaRegistry\n * @return {?}\n */\nfunction parseHostBindings(dirMeta, exprParser, schemaRegistry) {\n var /** @type {?} */ errors = [];\n var /** @type {?} */ parser = new BindingParser(exprParser, DEFAULT_INTERPOLATION_CONFIG, schemaRegistry, [], errors);\n var /** @type {?} */ moduleUrl = identifierModuleUrl(dirMeta.type);\n var /** @type {?} */ sourceFileName = moduleUrl ?\n \"in Directive \" + identifierName(dirMeta.type) + \" in \" + moduleUrl :\n \"in Directive \" + identifierName(dirMeta.type);\n var /** @type {?} */ sourceFile = new ParseSourceFile('', sourceFileName);\n var /** @type {?} */ sourceSpan = new ParseSourceSpan(new ParseLocation(sourceFile, null, null, null), new ParseLocation(sourceFile, null, null, null));\n var /** @type {?} */ parsedHostProps = parser.createDirectiveHostPropertyAsts(dirMeta.toSummary(), sourceSpan);\n var /** @type {?} */ parsedHostListeners = parser.createDirectiveHostEventAsts(dirMeta.toSummary(), sourceSpan);\n return new ParseResult(parsedHostProps, parsedHostListeners, errors);\n}\n/**\n * @param {?} parseErrors\n * @param {?} console\n * @return {?}\n */\nfunction reportParseErrors(parseErrors, console) {\n var /** @type {?} */ warnings = parseErrors.filter(function (error) { return error.level === ParseErrorLevel.WARNING; });\n var /** @type {?} */ errors = parseErrors.filter(function (error) { return error.level === ParseErrorLevel.FATAL; });\n if (warnings.length > 0) {\n this._console.warn(\"Directive parse warnings:\\n\" + warnings.join('\\n'));\n }\n if (errors.length > 0) {\n throw new Error(\"Directive parse errors:\\n\" + errors.join('\\n'));\n }\n}\nexport var DirectiveWrapperExpressions = (function () {\n function DirectiveWrapperExpressions() {\n }\n /**\n * @param {?} dir\n * @param {?} depsExpr\n * @return {?}\n */\n DirectiveWrapperExpressions.create = function (dir, depsExpr) {\n return o.importExpr(dir).instantiate(depsExpr, o.importType(dir));\n };\n /**\n * @param {?} dirWrapper\n * @return {?}\n */\n DirectiveWrapperExpressions.context = function (dirWrapper) {\n return dirWrapper.prop(CONTEXT_FIELD_NAME);\n };\n /**\n * @param {?} dirWrapper\n * @param {?} view\n * @param {?} renderElement\n * @param {?} throwOnChange\n * @return {?}\n */\n DirectiveWrapperExpressions.ngDoCheck = function (dirWrapper, view, renderElement, throwOnChange) {\n return dirWrapper.callMethod('ngDoCheck', [view, renderElement, throwOnChange]);\n };\n /**\n * @param {?} hostProps\n * @param {?} dirWrapper\n * @param {?} view\n * @param {?} componentView\n * @param {?} renderElement\n * @param {?} throwOnChange\n * @param {?} runtimeSecurityContexts\n * @return {?}\n */\n DirectiveWrapperExpressions.checkHost = function (hostProps, dirWrapper, view, componentView, renderElement, throwOnChange, runtimeSecurityContexts) {\n if (hostProps.length) {\n return [dirWrapper\n .callMethod('checkHost', [view, componentView, renderElement, throwOnChange].concat(runtimeSecurityContexts))\n .toStmt()];\n }\n else {\n return [];\n }\n };\n /**\n * @param {?} hostProps\n * @param {?} dirWrapper\n * @param {?} view\n * @param {?} componentView\n * @param {?} renderEl\n * @return {?}\n */\n DirectiveWrapperExpressions.ngOnDetach = function (hostProps, dirWrapper, view, componentView, renderEl) {\n if (hostProps.some(function (prop) { return prop.isAnimation; })) {\n return [dirWrapper\n .callMethod('ngOnDetach', [\n view,\n componentView,\n renderEl,\n ])\n .toStmt()];\n }\n else {\n return [];\n }\n };\n /**\n * @param {?} dir\n * @param {?} dirWrapper\n * @return {?}\n */\n DirectiveWrapperExpressions.ngOnDestroy = function (dir, dirWrapper) {\n if (dir.type.lifecycleHooks.indexOf(LifecycleHooks.OnDestroy) !== -1 ||\n Object.keys(dir.outputs).length > 0) {\n return [dirWrapper.callMethod('ngOnDestroy', []).toStmt()];\n }\n else {\n return [];\n }\n };\n /**\n * @param {?} dirMeta\n * @param {?} hostProps\n * @param {?} usedEvents\n * @param {?} dirWrapper\n * @param {?} view\n * @param {?} eventListener\n * @return {?}\n */\n DirectiveWrapperExpressions.subscribe = function (dirMeta, hostProps, usedEvents, dirWrapper, view, eventListener) {\n var /** @type {?} */ needsSubscribe = false;\n var /** @type {?} */ eventFlags = [];\n Object.keys(dirMeta.outputs).forEach(function (propName) {\n var /** @type {?} */ eventName = dirMeta.outputs[propName];\n var /** @type {?} */ eventUsed = usedEvents.indexOf(eventName) > -1;\n needsSubscribe = needsSubscribe || eventUsed;\n eventFlags.push(o.literal(eventUsed));\n });\n hostProps.forEach(function (hostProp) {\n if (hostProp.isAnimation && usedEvents.length > 0) {\n needsSubscribe = true;\n }\n });\n if (needsSubscribe) {\n return [\n dirWrapper.callMethod('subscribe', [view, eventListener].concat(eventFlags)).toStmt()\n ];\n }\n else {\n return [];\n }\n };\n /**\n * @param {?} hostEvents\n * @param {?} dirWrapper\n * @param {?} eventName\n * @param {?} event\n * @return {?}\n */\n DirectiveWrapperExpressions.handleEvent = function (hostEvents, dirWrapper, eventName, event) {\n return dirWrapper.callMethod('handleEvent', [eventName, event]);\n };\n return DirectiveWrapperExpressions;\n}());\n//# sourceMappingURL=directive_wrapper_compiler.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/directive_wrapper_compiler.js\n// module id = ./node_modules/@angular/compiler/src/directive_wrapper_compiler.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nimport { isBlank } from '../facade/lang';\nexport var ParserError = (function () {\n /**\n * @param {?} message\n * @param {?} input\n * @param {?} errLocation\n * @param {?=} ctxLocation\n */\n function ParserError(message, input, errLocation, ctxLocation) {\n this.input = input;\n this.errLocation = errLocation;\n this.ctxLocation = ctxLocation;\n this.message = \"Parser Error: \" + message + \" \" + errLocation + \" [\" + input + \"] in \" + ctxLocation;\n }\n return ParserError;\n}());\nfunction ParserError_tsickle_Closure_declarations() {\n /** @type {?} */\n ParserError.prototype.message;\n /** @type {?} */\n ParserError.prototype.input;\n /** @type {?} */\n ParserError.prototype.errLocation;\n /** @type {?} */\n ParserError.prototype.ctxLocation;\n}\nexport var ParseSpan = (function () {\n /**\n * @param {?} start\n * @param {?} end\n */\n function ParseSpan(start, end) {\n this.start = start;\n this.end = end;\n }\n return ParseSpan;\n}());\nfunction ParseSpan_tsickle_Closure_declarations() {\n /** @type {?} */\n ParseSpan.prototype.start;\n /** @type {?} */\n ParseSpan.prototype.end;\n}\nexport var AST = (function () {\n /**\n * @param {?} span\n */\n function AST(span) {\n this.span = span;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n AST.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return null;\n };\n /**\n * @return {?}\n */\n AST.prototype.toString = function () { return 'AST'; };\n return AST;\n}());\nfunction AST_tsickle_Closure_declarations() {\n /** @type {?} */\n AST.prototype.span;\n}\n/**\n * Represents a quoted expression of the form:\n * *\n * quote = prefix `:` uninterpretedExpression\n * prefix = identifier\n * uninterpretedExpression = arbitrary string\n * *\n * A quoted expression is meant to be pre-processed by an AST transformer that\n * converts it into another AST that no longer contains quoted expressions.\n * It is meant to allow third-party developers to extend Angular template\n * expression language. The `uninterpretedExpression` part of the quote is\n * therefore not interpreted by the Angular's own expression parser.\n */\nexport var Quote = (function (_super) {\n __extends(Quote, _super);\n /**\n * @param {?} span\n * @param {?} prefix\n * @param {?} uninterpretedExpression\n * @param {?} location\n */\n function Quote(span, prefix, uninterpretedExpression, location) {\n _super.call(this, span);\n this.prefix = prefix;\n this.uninterpretedExpression = uninterpretedExpression;\n this.location = location;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n Quote.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitQuote(this, context);\n };\n /**\n * @return {?}\n */\n Quote.prototype.toString = function () { return 'Quote'; };\n return Quote;\n}(AST));\nfunction Quote_tsickle_Closure_declarations() {\n /** @type {?} */\n Quote.prototype.prefix;\n /** @type {?} */\n Quote.prototype.uninterpretedExpression;\n /** @type {?} */\n Quote.prototype.location;\n}\nexport var EmptyExpr = (function (_super) {\n __extends(EmptyExpr, _super);\n function EmptyExpr() {\n _super.apply(this, arguments);\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n EmptyExpr.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n // do nothing\n };\n return EmptyExpr;\n}(AST));\nexport var ImplicitReceiver = (function (_super) {\n __extends(ImplicitReceiver, _super);\n function ImplicitReceiver() {\n _super.apply(this, arguments);\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n ImplicitReceiver.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitImplicitReceiver(this, context);\n };\n return ImplicitReceiver;\n}(AST));\n/**\n * Multiple expressions separated by a semicolon.\n */\nexport var Chain = (function (_super) {\n __extends(Chain, _super);\n /**\n * @param {?} span\n * @param {?} expressions\n */\n function Chain(span, expressions) {\n _super.call(this, span);\n this.expressions = expressions;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n Chain.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitChain(this, context);\n };\n return Chain;\n}(AST));\nfunction Chain_tsickle_Closure_declarations() {\n /** @type {?} */\n Chain.prototype.expressions;\n}\nexport var Conditional = (function (_super) {\n __extends(Conditional, _super);\n /**\n * @param {?} span\n * @param {?} condition\n * @param {?} trueExp\n * @param {?} falseExp\n */\n function Conditional(span, condition, trueExp, falseExp) {\n _super.call(this, span);\n this.condition = condition;\n this.trueExp = trueExp;\n this.falseExp = falseExp;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n Conditional.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitConditional(this, context);\n };\n return Conditional;\n}(AST));\nfunction Conditional_tsickle_Closure_declarations() {\n /** @type {?} */\n Conditional.prototype.condition;\n /** @type {?} */\n Conditional.prototype.trueExp;\n /** @type {?} */\n Conditional.prototype.falseExp;\n}\nexport var PropertyRead = (function (_super) {\n __extends(PropertyRead, _super);\n /**\n * @param {?} span\n * @param {?} receiver\n * @param {?} name\n */\n function PropertyRead(span, receiver, name) {\n _super.call(this, span);\n this.receiver = receiver;\n this.name = name;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n PropertyRead.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitPropertyRead(this, context);\n };\n return PropertyRead;\n}(AST));\nfunction PropertyRead_tsickle_Closure_declarations() {\n /** @type {?} */\n PropertyRead.prototype.receiver;\n /** @type {?} */\n PropertyRead.prototype.name;\n}\nexport var PropertyWrite = (function (_super) {\n __extends(PropertyWrite, _super);\n /**\n * @param {?} span\n * @param {?} receiver\n * @param {?} name\n * @param {?} value\n */\n function PropertyWrite(span, receiver, name, value) {\n _super.call(this, span);\n this.receiver = receiver;\n this.name = name;\n this.value = value;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n PropertyWrite.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitPropertyWrite(this, context);\n };\n return PropertyWrite;\n}(AST));\nfunction PropertyWrite_tsickle_Closure_declarations() {\n /** @type {?} */\n PropertyWrite.prototype.receiver;\n /** @type {?} */\n PropertyWrite.prototype.name;\n /** @type {?} */\n PropertyWrite.prototype.value;\n}\nexport var SafePropertyRead = (function (_super) {\n __extends(SafePropertyRead, _super);\n /**\n * @param {?} span\n * @param {?} receiver\n * @param {?} name\n */\n function SafePropertyRead(span, receiver, name) {\n _super.call(this, span);\n this.receiver = receiver;\n this.name = name;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n SafePropertyRead.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitSafePropertyRead(this, context);\n };\n return SafePropertyRead;\n}(AST));\nfunction SafePropertyRead_tsickle_Closure_declarations() {\n /** @type {?} */\n SafePropertyRead.prototype.receiver;\n /** @type {?} */\n SafePropertyRead.prototype.name;\n}\nexport var KeyedRead = (function (_super) {\n __extends(KeyedRead, _super);\n /**\n * @param {?} span\n * @param {?} obj\n * @param {?} key\n */\n function KeyedRead(span, obj, key) {\n _super.call(this, span);\n this.obj = obj;\n this.key = key;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n KeyedRead.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitKeyedRead(this, context);\n };\n return KeyedRead;\n}(AST));\nfunction KeyedRead_tsickle_Closure_declarations() {\n /** @type {?} */\n KeyedRead.prototype.obj;\n /** @type {?} */\n KeyedRead.prototype.key;\n}\nexport var KeyedWrite = (function (_super) {\n __extends(KeyedWrite, _super);\n /**\n * @param {?} span\n * @param {?} obj\n * @param {?} key\n * @param {?} value\n */\n function KeyedWrite(span, obj, key, value) {\n _super.call(this, span);\n this.obj = obj;\n this.key = key;\n this.value = value;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n KeyedWrite.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitKeyedWrite(this, context);\n };\n return KeyedWrite;\n}(AST));\nfunction KeyedWrite_tsickle_Closure_declarations() {\n /** @type {?} */\n KeyedWrite.prototype.obj;\n /** @type {?} */\n KeyedWrite.prototype.key;\n /** @type {?} */\n KeyedWrite.prototype.value;\n}\nexport var BindingPipe = (function (_super) {\n __extends(BindingPipe, _super);\n /**\n * @param {?} span\n * @param {?} exp\n * @param {?} name\n * @param {?} args\n */\n function BindingPipe(span, exp, name, args) {\n _super.call(this, span);\n this.exp = exp;\n this.name = name;\n this.args = args;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n BindingPipe.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitPipe(this, context);\n };\n return BindingPipe;\n}(AST));\nfunction BindingPipe_tsickle_Closure_declarations() {\n /** @type {?} */\n BindingPipe.prototype.exp;\n /** @type {?} */\n BindingPipe.prototype.name;\n /** @type {?} */\n BindingPipe.prototype.args;\n}\nexport var LiteralPrimitive = (function (_super) {\n __extends(LiteralPrimitive, _super);\n /**\n * @param {?} span\n * @param {?} value\n */\n function LiteralPrimitive(span, value) {\n _super.call(this, span);\n this.value = value;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n LiteralPrimitive.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitLiteralPrimitive(this, context);\n };\n return LiteralPrimitive;\n}(AST));\nfunction LiteralPrimitive_tsickle_Closure_declarations() {\n /** @type {?} */\n LiteralPrimitive.prototype.value;\n}\nexport var LiteralArray = (function (_super) {\n __extends(LiteralArray, _super);\n /**\n * @param {?} span\n * @param {?} expressions\n */\n function LiteralArray(span, expressions) {\n _super.call(this, span);\n this.expressions = expressions;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n LiteralArray.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitLiteralArray(this, context);\n };\n return LiteralArray;\n}(AST));\nfunction LiteralArray_tsickle_Closure_declarations() {\n /** @type {?} */\n LiteralArray.prototype.expressions;\n}\nexport var LiteralMap = (function (_super) {\n __extends(LiteralMap, _super);\n /**\n * @param {?} span\n * @param {?} keys\n * @param {?} values\n */\n function LiteralMap(span, keys, values) {\n _super.call(this, span);\n this.keys = keys;\n this.values = values;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n LiteralMap.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitLiteralMap(this, context);\n };\n return LiteralMap;\n}(AST));\nfunction LiteralMap_tsickle_Closure_declarations() {\n /** @type {?} */\n LiteralMap.prototype.keys;\n /** @type {?} */\n LiteralMap.prototype.values;\n}\nexport var Interpolation = (function (_super) {\n __extends(Interpolation, _super);\n /**\n * @param {?} span\n * @param {?} strings\n * @param {?} expressions\n */\n function Interpolation(span, strings, expressions) {\n _super.call(this, span);\n this.strings = strings;\n this.expressions = expressions;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n Interpolation.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitInterpolation(this, context);\n };\n return Interpolation;\n}(AST));\nfunction Interpolation_tsickle_Closure_declarations() {\n /** @type {?} */\n Interpolation.prototype.strings;\n /** @type {?} */\n Interpolation.prototype.expressions;\n}\nexport var Binary = (function (_super) {\n __extends(Binary, _super);\n /**\n * @param {?} span\n * @param {?} operation\n * @param {?} left\n * @param {?} right\n */\n function Binary(span, operation, left, right) {\n _super.call(this, span);\n this.operation = operation;\n this.left = left;\n this.right = right;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n Binary.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitBinary(this, context);\n };\n return Binary;\n}(AST));\nfunction Binary_tsickle_Closure_declarations() {\n /** @type {?} */\n Binary.prototype.operation;\n /** @type {?} */\n Binary.prototype.left;\n /** @type {?} */\n Binary.prototype.right;\n}\nexport var PrefixNot = (function (_super) {\n __extends(PrefixNot, _super);\n /**\n * @param {?} span\n * @param {?} expression\n */\n function PrefixNot(span, expression) {\n _super.call(this, span);\n this.expression = expression;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n PrefixNot.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitPrefixNot(this, context);\n };\n return PrefixNot;\n}(AST));\nfunction PrefixNot_tsickle_Closure_declarations() {\n /** @type {?} */\n PrefixNot.prototype.expression;\n}\nexport var MethodCall = (function (_super) {\n __extends(MethodCall, _super);\n /**\n * @param {?} span\n * @param {?} receiver\n * @param {?} name\n * @param {?} args\n */\n function MethodCall(span, receiver, name, args) {\n _super.call(this, span);\n this.receiver = receiver;\n this.name = name;\n this.args = args;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n MethodCall.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitMethodCall(this, context);\n };\n return MethodCall;\n}(AST));\nfunction MethodCall_tsickle_Closure_declarations() {\n /** @type {?} */\n MethodCall.prototype.receiver;\n /** @type {?} */\n MethodCall.prototype.name;\n /** @type {?} */\n MethodCall.prototype.args;\n}\nexport var SafeMethodCall = (function (_super) {\n __extends(SafeMethodCall, _super);\n /**\n * @param {?} span\n * @param {?} receiver\n * @param {?} name\n * @param {?} args\n */\n function SafeMethodCall(span, receiver, name, args) {\n _super.call(this, span);\n this.receiver = receiver;\n this.name = name;\n this.args = args;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n SafeMethodCall.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitSafeMethodCall(this, context);\n };\n return SafeMethodCall;\n}(AST));\nfunction SafeMethodCall_tsickle_Closure_declarations() {\n /** @type {?} */\n SafeMethodCall.prototype.receiver;\n /** @type {?} */\n SafeMethodCall.prototype.name;\n /** @type {?} */\n SafeMethodCall.prototype.args;\n}\nexport var FunctionCall = (function (_super) {\n __extends(FunctionCall, _super);\n /**\n * @param {?} span\n * @param {?} target\n * @param {?} args\n */\n function FunctionCall(span, target, args) {\n _super.call(this, span);\n this.target = target;\n this.args = args;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n FunctionCall.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return visitor.visitFunctionCall(this, context);\n };\n return FunctionCall;\n}(AST));\nfunction FunctionCall_tsickle_Closure_declarations() {\n /** @type {?} */\n FunctionCall.prototype.target;\n /** @type {?} */\n FunctionCall.prototype.args;\n}\nexport var ASTWithSource = (function (_super) {\n __extends(ASTWithSource, _super);\n /**\n * @param {?} ast\n * @param {?} source\n * @param {?} location\n * @param {?} errors\n */\n function ASTWithSource(ast, source, location, errors) {\n _super.call(this, new ParseSpan(0, isBlank(source) ? 0 : source.length));\n this.ast = ast;\n this.source = source;\n this.location = location;\n this.errors = errors;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n ASTWithSource.prototype.visit = function (visitor, context) {\n if (context === void 0) { context = null; }\n return this.ast.visit(visitor, context);\n };\n /**\n * @return {?}\n */\n ASTWithSource.prototype.toString = function () { return this.source + \" in \" + this.location; };\n return ASTWithSource;\n}(AST));\nfunction ASTWithSource_tsickle_Closure_declarations() {\n /** @type {?} */\n ASTWithSource.prototype.ast;\n /** @type {?} */\n ASTWithSource.prototype.source;\n /** @type {?} */\n ASTWithSource.prototype.location;\n /** @type {?} */\n ASTWithSource.prototype.errors;\n}\nexport var TemplateBinding = (function () {\n /**\n * @param {?} span\n * @param {?} key\n * @param {?} keyIsVar\n * @param {?} name\n * @param {?} expression\n */\n function TemplateBinding(span, key, keyIsVar, name, expression) {\n this.span = span;\n this.key = key;\n this.keyIsVar = keyIsVar;\n this.name = name;\n this.expression = expression;\n }\n return TemplateBinding;\n}());\nfunction TemplateBinding_tsickle_Closure_declarations() {\n /** @type {?} */\n TemplateBinding.prototype.span;\n /** @type {?} */\n TemplateBinding.prototype.key;\n /** @type {?} */\n TemplateBinding.prototype.keyIsVar;\n /** @type {?} */\n TemplateBinding.prototype.name;\n /** @type {?} */\n TemplateBinding.prototype.expression;\n}\nexport var RecursiveAstVisitor = (function () {\n function RecursiveAstVisitor() {\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitBinary = function (ast, context) {\n ast.left.visit(this);\n ast.right.visit(this);\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitChain = function (ast, context) { return this.visitAll(ast.expressions, context); };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitConditional = function (ast, context) {\n ast.condition.visit(this);\n ast.trueExp.visit(this);\n ast.falseExp.visit(this);\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitPipe = function (ast, context) {\n ast.exp.visit(this);\n this.visitAll(ast.args, context);\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitFunctionCall = function (ast, context) {\n ast.target.visit(this);\n this.visitAll(ast.args, context);\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitImplicitReceiver = function (ast, context) { return null; };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitInterpolation = function (ast, context) {\n return this.visitAll(ast.expressions, context);\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitKeyedRead = function (ast, context) {\n ast.obj.visit(this);\n ast.key.visit(this);\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitKeyedWrite = function (ast, context) {\n ast.obj.visit(this);\n ast.key.visit(this);\n ast.value.visit(this);\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitLiteralArray = function (ast, context) {\n return this.visitAll(ast.expressions, context);\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitLiteralMap = function (ast, context) { return this.visitAll(ast.values, context); };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitLiteralPrimitive = function (ast, context) { return null; };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitMethodCall = function (ast, context) {\n ast.receiver.visit(this);\n return this.visitAll(ast.args, context);\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitPrefixNot = function (ast, context) {\n ast.expression.visit(this);\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitPropertyRead = function (ast, context) {\n ast.receiver.visit(this);\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitPropertyWrite = function (ast, context) {\n ast.receiver.visit(this);\n ast.value.visit(this);\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitSafePropertyRead = function (ast, context) {\n ast.receiver.visit(this);\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitSafeMethodCall = function (ast, context) {\n ast.receiver.visit(this);\n return this.visitAll(ast.args, context);\n };\n /**\n * @param {?} asts\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitAll = function (asts, context) {\n var _this = this;\n asts.forEach(function (ast) { return ast.visit(_this, context); });\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveAstVisitor.prototype.visitQuote = function (ast, context) { return null; };\n return RecursiveAstVisitor;\n}());\nexport var AstTransformer = (function () {\n function AstTransformer() {\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitImplicitReceiver = function (ast, context) { return ast; };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitInterpolation = function (ast, context) {\n return new Interpolation(ast.span, ast.strings, this.visitAll(ast.expressions));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitLiteralPrimitive = function (ast, context) {\n return new LiteralPrimitive(ast.span, ast.value);\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitPropertyRead = function (ast, context) {\n return new PropertyRead(ast.span, ast.receiver.visit(this), ast.name);\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitPropertyWrite = function (ast, context) {\n return new PropertyWrite(ast.span, ast.receiver.visit(this), ast.name, ast.value);\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitSafePropertyRead = function (ast, context) {\n return new SafePropertyRead(ast.span, ast.receiver.visit(this), ast.name);\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitMethodCall = function (ast, context) {\n return new MethodCall(ast.span, ast.receiver.visit(this), ast.name, this.visitAll(ast.args));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitSafeMethodCall = function (ast, context) {\n return new SafeMethodCall(ast.span, ast.receiver.visit(this), ast.name, this.visitAll(ast.args));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitFunctionCall = function (ast, context) {\n return new FunctionCall(ast.span, ast.target.visit(this), this.visitAll(ast.args));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitLiteralArray = function (ast, context) {\n return new LiteralArray(ast.span, this.visitAll(ast.expressions));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitLiteralMap = function (ast, context) {\n return new LiteralMap(ast.span, ast.keys, this.visitAll(ast.values));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitBinary = function (ast, context) {\n return new Binary(ast.span, ast.operation, ast.left.visit(this), ast.right.visit(this));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitPrefixNot = function (ast, context) {\n return new PrefixNot(ast.span, ast.expression.visit(this));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitConditional = function (ast, context) {\n return new Conditional(ast.span, ast.condition.visit(this), ast.trueExp.visit(this), ast.falseExp.visit(this));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitPipe = function (ast, context) {\n return new BindingPipe(ast.span, ast.exp.visit(this), ast.name, this.visitAll(ast.args));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitKeyedRead = function (ast, context) {\n return new KeyedRead(ast.span, ast.obj.visit(this), ast.key.visit(this));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitKeyedWrite = function (ast, context) {\n return new KeyedWrite(ast.span, ast.obj.visit(this), ast.key.visit(this), ast.value.visit(this));\n };\n /**\n * @param {?} asts\n * @return {?}\n */\n AstTransformer.prototype.visitAll = function (asts) {\n var /** @type {?} */ res = new Array(asts.length);\n for (var /** @type {?} */ i = 0; i < asts.length; ++i) {\n res[i] = asts[i].visit(this);\n }\n return res;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitChain = function (ast, context) {\n return new Chain(ast.span, this.visitAll(ast.expressions));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AstTransformer.prototype.visitQuote = function (ast, context) {\n return new Quote(ast.span, ast.prefix, ast.uninterpretedExpression, ast.location);\n };\n return AstTransformer;\n}());\n//# sourceMappingURL=ast.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/expression_parser/ast.js\n// module id = ./node_modules/@angular/compiler/src/expression_parser/ast.js\n// module chunks = 0","/**\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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport * as chars from '../chars';\nimport { NumberWrapper, isPresent } from '../facade/lang';\nimport { CompilerInjectable } from '../injectable';\nexport var TokenType = {};\nTokenType.Character = 0;\nTokenType.Identifier = 1;\nTokenType.Keyword = 2;\nTokenType.String = 3;\nTokenType.Operator = 4;\nTokenType.Number = 5;\nTokenType.Error = 6;\nTokenType[TokenType.Character] = \"Character\";\nTokenType[TokenType.Identifier] = \"Identifier\";\nTokenType[TokenType.Keyword] = \"Keyword\";\nTokenType[TokenType.String] = \"String\";\nTokenType[TokenType.Operator] = \"Operator\";\nTokenType[TokenType.Number] = \"Number\";\nTokenType[TokenType.Error] = \"Error\";\nvar /** @type {?} */ KEYWORDS = ['var', 'let', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this'];\nexport var Lexer = (function () {\n function Lexer() {\n }\n /**\n * @param {?} text\n * @return {?}\n */\n Lexer.prototype.tokenize = function (text) {\n var /** @type {?} */ scanner = new _Scanner(text);\n var /** @type {?} */ tokens = [];\n var /** @type {?} */ token = scanner.scanToken();\n while (token != null) {\n tokens.push(token);\n token = scanner.scanToken();\n }\n return tokens;\n };\n Lexer = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [])\n ], Lexer);\n return Lexer;\n}());\nexport var Token = (function () {\n /**\n * @param {?} index\n * @param {?} type\n * @param {?} numValue\n * @param {?} strValue\n */\n function Token(index, type, numValue, strValue) {\n this.index = index;\n this.type = type;\n this.numValue = numValue;\n this.strValue = strValue;\n }\n /**\n * @param {?} code\n * @return {?}\n */\n Token.prototype.isCharacter = function (code) {\n return this.type == TokenType.Character && this.numValue == code;\n };\n /**\n * @return {?}\n */\n Token.prototype.isNumber = function () { return this.type == TokenType.Number; };\n /**\n * @return {?}\n */\n Token.prototype.isString = function () { return this.type == TokenType.String; };\n /**\n * @param {?} operater\n * @return {?}\n */\n Token.prototype.isOperator = function (operater) {\n return this.type == TokenType.Operator && this.strValue == operater;\n };\n /**\n * @return {?}\n */\n Token.prototype.isIdentifier = function () { return this.type == TokenType.Identifier; };\n /**\n * @return {?}\n */\n Token.prototype.isKeyword = function () { return this.type == TokenType.Keyword; };\n /**\n * @return {?}\n */\n Token.prototype.isKeywordLet = function () { return this.type == TokenType.Keyword && this.strValue == 'let'; };\n /**\n * @return {?}\n */\n Token.prototype.isKeywordNull = function () { return this.type == TokenType.Keyword && this.strValue == 'null'; };\n /**\n * @return {?}\n */\n Token.prototype.isKeywordUndefined = function () {\n return this.type == TokenType.Keyword && this.strValue == 'undefined';\n };\n /**\n * @return {?}\n */\n Token.prototype.isKeywordTrue = function () { return this.type == TokenType.Keyword && this.strValue == 'true'; };\n /**\n * @return {?}\n */\n Token.prototype.isKeywordFalse = function () { return this.type == TokenType.Keyword && this.strValue == 'false'; };\n /**\n * @return {?}\n */\n Token.prototype.isKeywordThis = function () { return this.type == TokenType.Keyword && this.strValue == 'this'; };\n /**\n * @return {?}\n */\n Token.prototype.isError = function () { return this.type == TokenType.Error; };\n /**\n * @return {?}\n */\n Token.prototype.toNumber = function () { return this.type == TokenType.Number ? this.numValue : -1; };\n /**\n * @return {?}\n */\n Token.prototype.toString = function () {\n switch (this.type) {\n case TokenType.Character:\n case TokenType.Identifier:\n case TokenType.Keyword:\n case TokenType.Operator:\n case TokenType.String:\n case TokenType.Error:\n return this.strValue;\n case TokenType.Number:\n return this.numValue.toString();\n default:\n return null;\n }\n };\n return Token;\n}());\nfunction Token_tsickle_Closure_declarations() {\n /** @type {?} */\n Token.prototype.index;\n /** @type {?} */\n Token.prototype.type;\n /** @type {?} */\n Token.prototype.numValue;\n /** @type {?} */\n Token.prototype.strValue;\n}\n/**\n * @param {?} index\n * @param {?} code\n * @return {?}\n */\nfunction newCharacterToken(index, code) {\n return new Token(index, TokenType.Character, code, String.fromCharCode(code));\n}\n/**\n * @param {?} index\n * @param {?} text\n * @return {?}\n */\nfunction newIdentifierToken(index, text) {\n return new Token(index, TokenType.Identifier, 0, text);\n}\n/**\n * @param {?} index\n * @param {?} text\n * @return {?}\n */\nfunction newKeywordToken(index, text) {\n return new Token(index, TokenType.Keyword, 0, text);\n}\n/**\n * @param {?} index\n * @param {?} text\n * @return {?}\n */\nfunction newOperatorToken(index, text) {\n return new Token(index, TokenType.Operator, 0, text);\n}\n/**\n * @param {?} index\n * @param {?} text\n * @return {?}\n */\nfunction newStringToken(index, text) {\n return new Token(index, TokenType.String, 0, text);\n}\n/**\n * @param {?} index\n * @param {?} n\n * @return {?}\n */\nfunction newNumberToken(index, n) {\n return new Token(index, TokenType.Number, n, '');\n}\n/**\n * @param {?} index\n * @param {?} message\n * @return {?}\n */\nfunction newErrorToken(index, message) {\n return new Token(index, TokenType.Error, 0, message);\n}\nexport var /** @type {?} */ EOF = new Token(-1, TokenType.Character, 0, '');\nvar _Scanner = (function () {\n /**\n * @param {?} input\n */\n function _Scanner(input) {\n this.input = input;\n this.peek = 0;\n this.index = -1;\n this.length = input.length;\n this.advance();\n }\n /**\n * @return {?}\n */\n _Scanner.prototype.advance = function () {\n this.peek = ++this.index >= this.length ? chars.$EOF : this.input.charCodeAt(this.index);\n };\n /**\n * @return {?}\n */\n _Scanner.prototype.scanToken = function () {\n var /** @type {?} */ input = this.input, /** @type {?} */ length = this.length;\n var /** @type {?} */ peek = this.peek, /** @type {?} */ index = this.index;\n // Skip whitespace.\n while (peek <= chars.$SPACE) {\n if (++index >= length) {\n peek = chars.$EOF;\n break;\n }\n else {\n peek = input.charCodeAt(index);\n }\n }\n this.peek = peek;\n this.index = index;\n if (index >= length) {\n return null;\n }\n // Handle identifiers and numbers.\n if (isIdentifierStart(peek))\n return this.scanIdentifier();\n if (chars.isDigit(peek))\n return this.scanNumber(index);\n var /** @type {?} */ start = index;\n switch (peek) {\n case chars.$PERIOD:\n this.advance();\n return chars.isDigit(this.peek) ? this.scanNumber(start) :\n newCharacterToken(start, chars.$PERIOD);\n case chars.$LPAREN:\n case chars.$RPAREN:\n case chars.$LBRACE:\n case chars.$RBRACE:\n case chars.$LBRACKET:\n case chars.$RBRACKET:\n case chars.$COMMA:\n case chars.$COLON:\n case chars.$SEMICOLON:\n return this.scanCharacter(start, peek);\n case chars.$SQ:\n case chars.$DQ:\n return this.scanString();\n case chars.$HASH:\n case chars.$PLUS:\n case chars.$MINUS:\n case chars.$STAR:\n case chars.$SLASH:\n case chars.$PERCENT:\n case chars.$CARET:\n return this.scanOperator(start, String.fromCharCode(peek));\n case chars.$QUESTION:\n return this.scanComplexOperator(start, '?', chars.$PERIOD, '.');\n case chars.$LT:\n case chars.$GT:\n return this.scanComplexOperator(start, String.fromCharCode(peek), chars.$EQ, '=');\n case chars.$BANG:\n case chars.$EQ:\n return this.scanComplexOperator(start, String.fromCharCode(peek), chars.$EQ, '=', chars.$EQ, '=');\n case chars.$AMPERSAND:\n return this.scanComplexOperator(start, '&', chars.$AMPERSAND, '&');\n case chars.$BAR:\n return this.scanComplexOperator(start, '|', chars.$BAR, '|');\n case chars.$NBSP:\n while (chars.isWhitespace(this.peek))\n this.advance();\n return this.scanToken();\n }\n this.advance();\n return this.error(\"Unexpected character [\" + String.fromCharCode(peek) + \"]\", 0);\n };\n /**\n * @param {?} start\n * @param {?} code\n * @return {?}\n */\n _Scanner.prototype.scanCharacter = function (start, code) {\n this.advance();\n return newCharacterToken(start, code);\n };\n /**\n * @param {?} start\n * @param {?} str\n * @return {?}\n */\n _Scanner.prototype.scanOperator = function (start, str) {\n this.advance();\n return newOperatorToken(start, str);\n };\n /**\n * Tokenize a 2/3 char long operator\n * *\n * @param {?} start start index in the expression\n * @param {?} one first symbol (always part of the operator)\n * @param {?} twoCode code point for the second symbol\n * @param {?} two second symbol (part of the operator when the second code point matches)\n * @param {?=} threeCode code point for the third symbol\n * @param {?=} three third symbol (part of the operator when provided and matches source expression)\n * @return {?}\n */\n _Scanner.prototype.scanComplexOperator = function (start, one, twoCode, two, threeCode, three) {\n this.advance();\n var /** @type {?} */ str = one;\n if (this.peek == twoCode) {\n this.advance();\n str += two;\n }\n if (isPresent(threeCode) && this.peek == threeCode) {\n this.advance();\n str += three;\n }\n return newOperatorToken(start, str);\n };\n /**\n * @return {?}\n */\n _Scanner.prototype.scanIdentifier = function () {\n var /** @type {?} */ start = this.index;\n this.advance();\n while (isIdentifierPart(this.peek))\n this.advance();\n var /** @type {?} */ str = this.input.substring(start, this.index);\n return KEYWORDS.indexOf(str) > -1 ? newKeywordToken(start, str) :\n newIdentifierToken(start, str);\n };\n /**\n * @param {?} start\n * @return {?}\n */\n _Scanner.prototype.scanNumber = function (start) {\n var /** @type {?} */ simple = (this.index === start);\n this.advance(); // Skip initial digit.\n while (true) {\n if (chars.isDigit(this.peek)) {\n }\n else if (this.peek == chars.$PERIOD) {\n simple = false;\n }\n else if (isExponentStart(this.peek)) {\n this.advance();\n if (isExponentSign(this.peek))\n this.advance();\n if (!chars.isDigit(this.peek))\n return this.error('Invalid exponent', -1);\n simple = false;\n }\n else {\n break;\n }\n this.advance();\n }\n var /** @type {?} */ str = this.input.substring(start, this.index);\n var /** @type {?} */ value = simple ? NumberWrapper.parseIntAutoRadix(str) : parseFloat(str);\n return newNumberToken(start, value);\n };\n /**\n * @return {?}\n */\n _Scanner.prototype.scanString = function () {\n var /** @type {?} */ start = this.index;\n var /** @type {?} */ quote = this.peek;\n this.advance(); // Skip initial quote.\n var /** @type {?} */ buffer = '';\n var /** @type {?} */ marker = this.index;\n var /** @type {?} */ input = this.input;\n while (this.peek != quote) {\n if (this.peek == chars.$BACKSLASH) {\n buffer += input.substring(marker, this.index);\n this.advance();\n var /** @type {?} */ unescapedCode = void 0;\n if (this.peek == chars.$u) {\n // 4 character hex code for unicode character.\n var /** @type {?} */ hex = input.substring(this.index + 1, this.index + 5);\n if (/^[0-9a-f]+$/i.test(hex)) {\n unescapedCode = parseInt(hex, 16);\n }\n else {\n return this.error(\"Invalid unicode escape [\\\\u\" + hex + \"]\", 0);\n }\n for (var /** @type {?} */ i = 0; i < 5; i++) {\n this.advance();\n }\n }\n else {\n unescapedCode = unescape(this.peek);\n this.advance();\n }\n buffer += String.fromCharCode(unescapedCode);\n marker = this.index;\n }\n else if (this.peek == chars.$EOF) {\n return this.error('Unterminated quote', 0);\n }\n else {\n this.advance();\n }\n }\n var /** @type {?} */ last = input.substring(marker, this.index);\n this.advance(); // Skip terminating quote.\n return newStringToken(start, buffer + last);\n };\n /**\n * @param {?} message\n * @param {?} offset\n * @return {?}\n */\n _Scanner.prototype.error = function (message, offset) {\n var /** @type {?} */ position = this.index + offset;\n return newErrorToken(position, \"Lexer Error: \" + message + \" at column \" + position + \" in expression [\" + this.input + \"]\");\n };\n return _Scanner;\n}());\nfunction _Scanner_tsickle_Closure_declarations() {\n /** @type {?} */\n _Scanner.prototype.length;\n /** @type {?} */\n _Scanner.prototype.peek;\n /** @type {?} */\n _Scanner.prototype.index;\n /** @type {?} */\n _Scanner.prototype.input;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isIdentifierStart(code) {\n return (chars.$a <= code && code <= chars.$z) || (chars.$A <= code && code <= chars.$Z) ||\n (code == chars.$_) || (code == chars.$$);\n}\n/**\n * @param {?} input\n * @return {?}\n */\nexport function isIdentifier(input) {\n if (input.length == 0)\n return false;\n var /** @type {?} */ scanner = new _Scanner(input);\n if (!isIdentifierStart(scanner.peek))\n return false;\n scanner.advance();\n while (scanner.peek !== chars.$EOF) {\n if (!isIdentifierPart(scanner.peek))\n return false;\n scanner.advance();\n }\n return true;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isIdentifierPart(code) {\n return chars.isAsciiLetter(code) || chars.isDigit(code) || (code == chars.$_) ||\n (code == chars.$$);\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isExponentStart(code) {\n return code == chars.$e || code == chars.$E;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isExponentSign(code) {\n return code == chars.$MINUS || code == chars.$PLUS;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nexport function isQuote(code) {\n return code === chars.$SQ || code === chars.$DQ || code === chars.$BT;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction unescape(code) {\n switch (code) {\n case chars.$n:\n return chars.$LF;\n case chars.$f:\n return chars.$FF;\n case chars.$r:\n return chars.$CR;\n case chars.$t:\n return chars.$TAB;\n case chars.$v:\n return chars.$VTAB;\n default:\n return code;\n }\n}\n//# sourceMappingURL=lexer.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/expression_parser/lexer.js\n// module id = ./node_modules/@angular/compiler/src/expression_parser/lexer.js\n// module chunks = 0","/**\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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport * as chars from '../chars';\nimport { escapeRegExp, isBlank, isPresent } from '../facade/lang';\nimport { CompilerInjectable } from '../injectable';\nimport { DEFAULT_INTERPOLATION_CONFIG } from '../ml_parser/interpolation_config';\nimport { ASTWithSource, Binary, BindingPipe, Chain, Conditional, EmptyExpr, FunctionCall, ImplicitReceiver, Interpolation, KeyedRead, KeyedWrite, LiteralArray, LiteralMap, LiteralPrimitive, MethodCall, ParseSpan, ParserError, PrefixNot, PropertyRead, PropertyWrite, Quote, SafeMethodCall, SafePropertyRead, TemplateBinding } from './ast';\nimport { EOF, Lexer, TokenType, isIdentifier, isQuote } from './lexer';\nexport var SplitInterpolation = (function () {\n /**\n * @param {?} strings\n * @param {?} expressions\n * @param {?} offsets\n */\n function SplitInterpolation(strings, expressions, offsets) {\n this.strings = strings;\n this.expressions = expressions;\n this.offsets = offsets;\n }\n return SplitInterpolation;\n}());\nfunction SplitInterpolation_tsickle_Closure_declarations() {\n /** @type {?} */\n SplitInterpolation.prototype.strings;\n /** @type {?} */\n SplitInterpolation.prototype.expressions;\n /** @type {?} */\n SplitInterpolation.prototype.offsets;\n}\nexport var TemplateBindingParseResult = (function () {\n /**\n * @param {?} templateBindings\n * @param {?} warnings\n * @param {?} errors\n */\n function TemplateBindingParseResult(templateBindings, warnings, errors) {\n this.templateBindings = templateBindings;\n this.warnings = warnings;\n this.errors = errors;\n }\n return TemplateBindingParseResult;\n}());\nfunction TemplateBindingParseResult_tsickle_Closure_declarations() {\n /** @type {?} */\n TemplateBindingParseResult.prototype.templateBindings;\n /** @type {?} */\n TemplateBindingParseResult.prototype.warnings;\n /** @type {?} */\n TemplateBindingParseResult.prototype.errors;\n}\n/**\n * @param {?} config\n * @return {?}\n */\nfunction _createInterpolateRegExp(config) {\n var /** @type {?} */ pattern = escapeRegExp(config.start) + '([\\\\s\\\\S]*?)' + escapeRegExp(config.end);\n return new RegExp(pattern, 'g');\n}\nexport var Parser = (function () {\n /**\n * @param {?} _lexer\n */\n function Parser(_lexer) {\n this._lexer = _lexer;\n this.errors = [];\n }\n /**\n * @param {?} input\n * @param {?} location\n * @param {?=} interpolationConfig\n * @return {?}\n */\n Parser.prototype.parseAction = function (input, location, interpolationConfig) {\n if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n this._checkNoInterpolation(input, location, interpolationConfig);\n var /** @type {?} */ sourceToLex = this._stripComments(input);\n var /** @type {?} */ tokens = this._lexer.tokenize(this._stripComments(input));\n var /** @type {?} */ ast = new _ParseAST(input, location, tokens, sourceToLex.length, true, this.errors, input.length - sourceToLex.length)\n .parseChain();\n return new ASTWithSource(ast, input, location, this.errors);\n };\n /**\n * @param {?} input\n * @param {?} location\n * @param {?=} interpolationConfig\n * @return {?}\n */\n Parser.prototype.parseBinding = function (input, location, interpolationConfig) {\n if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n var /** @type {?} */ ast = this._parseBindingAst(input, location, interpolationConfig);\n return new ASTWithSource(ast, input, location, this.errors);\n };\n /**\n * @param {?} input\n * @param {?} location\n * @param {?=} interpolationConfig\n * @return {?}\n */\n Parser.prototype.parseSimpleBinding = function (input, location, interpolationConfig) {\n if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n var /** @type {?} */ ast = this._parseBindingAst(input, location, interpolationConfig);\n var /** @type {?} */ errors = SimpleExpressionChecker.check(ast);\n if (errors.length > 0) {\n this._reportError(\"Host binding expression cannot contain \" + errors.join(' '), input, location);\n }\n return new ASTWithSource(ast, input, location, this.errors);\n };\n /**\n * @param {?} message\n * @param {?} input\n * @param {?} errLocation\n * @param {?=} ctxLocation\n * @return {?}\n */\n Parser.prototype._reportError = function (message, input, errLocation, ctxLocation) {\n this.errors.push(new ParserError(message, input, errLocation, ctxLocation));\n };\n /**\n * @param {?} input\n * @param {?} location\n * @param {?} interpolationConfig\n * @return {?}\n */\n Parser.prototype._parseBindingAst = function (input, location, interpolationConfig) {\n // Quotes expressions use 3rd-party expression language. We don't want to use\n // our lexer or parser for that, so we check for that ahead of time.\n var /** @type {?} */ quote = this._parseQuote(input, location);\n if (isPresent(quote)) {\n return quote;\n }\n this._checkNoInterpolation(input, location, interpolationConfig);\n var /** @type {?} */ sourceToLex = this._stripComments(input);\n var /** @type {?} */ tokens = this._lexer.tokenize(sourceToLex);\n return new _ParseAST(input, location, tokens, sourceToLex.length, false, this.errors, input.length - sourceToLex.length)\n .parseChain();\n };\n /**\n * @param {?} input\n * @param {?} location\n * @return {?}\n */\n Parser.prototype._parseQuote = function (input, location) {\n if (isBlank(input))\n return null;\n var /** @type {?} */ prefixSeparatorIndex = input.indexOf(':');\n if (prefixSeparatorIndex == -1)\n return null;\n var /** @type {?} */ prefix = input.substring(0, prefixSeparatorIndex).trim();\n if (!isIdentifier(prefix))\n return null;\n var /** @type {?} */ uninterpretedExpression = input.substring(prefixSeparatorIndex + 1);\n return new Quote(new ParseSpan(0, input.length), prefix, uninterpretedExpression, location);\n };\n /**\n * @param {?} prefixToken\n * @param {?} input\n * @param {?} location\n * @return {?}\n */\n Parser.prototype.parseTemplateBindings = function (prefixToken, input, location) {\n var /** @type {?} */ tokens = this._lexer.tokenize(input);\n if (prefixToken) {\n // Prefix the tokens with the tokens from prefixToken but have them take no space (0 index).\n var /** @type {?} */ prefixTokens = this._lexer.tokenize(prefixToken).map(function (t) {\n t.index = 0;\n return t;\n });\n tokens.unshift.apply(tokens, prefixTokens);\n }\n return new _ParseAST(input, location, tokens, input.length, false, this.errors, 0)\n .parseTemplateBindings();\n };\n /**\n * @param {?} input\n * @param {?} location\n * @param {?=} interpolationConfig\n * @return {?}\n */\n Parser.prototype.parseInterpolation = function (input, location, interpolationConfig) {\n if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n var /** @type {?} */ split = this.splitInterpolation(input, location, interpolationConfig);\n if (split == null)\n return null;\n var /** @type {?} */ expressions = [];\n for (var /** @type {?} */ i = 0; i < split.expressions.length; ++i) {\n var /** @type {?} */ expressionText = split.expressions[i];\n var /** @type {?} */ sourceToLex = this._stripComments(expressionText);\n var /** @type {?} */ tokens = this._lexer.tokenize(this._stripComments(split.expressions[i]));\n var /** @type {?} */ ast = new _ParseAST(input, location, tokens, sourceToLex.length, false, this.errors, split.offsets[i] + (expressionText.length - sourceToLex.length))\n .parseChain();\n expressions.push(ast);\n }\n return new ASTWithSource(new Interpolation(new ParseSpan(0, isBlank(input) ? 0 : input.length), split.strings, expressions), input, location, this.errors);\n };\n /**\n * @param {?} input\n * @param {?} location\n * @param {?=} interpolationConfig\n * @return {?}\n */\n Parser.prototype.splitInterpolation = function (input, location, interpolationConfig) {\n if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n var /** @type {?} */ regexp = _createInterpolateRegExp(interpolationConfig);\n var /** @type {?} */ parts = input.split(regexp);\n if (parts.length <= 1) {\n return null;\n }\n var /** @type {?} */ strings = [];\n var /** @type {?} */ expressions = [];\n var /** @type {?} */ offsets = [];\n var /** @type {?} */ offset = 0;\n for (var /** @type {?} */ i = 0; i < parts.length; i++) {\n var /** @type {?} */ part = parts[i];\n if (i % 2 === 0) {\n // fixed string\n strings.push(part);\n offset += part.length;\n }\n else if (part.trim().length > 0) {\n offset += interpolationConfig.start.length;\n expressions.push(part);\n offsets.push(offset);\n offset += part.length + interpolationConfig.end.length;\n }\n else {\n this._reportError('Blank expressions are not allowed in interpolated strings', input, \"at column \" + this._findInterpolationErrorColumn(parts, i, interpolationConfig) + \" in\", location);\n expressions.push('$implict');\n offsets.push(offset);\n }\n }\n return new SplitInterpolation(strings, expressions, offsets);\n };\n /**\n * @param {?} input\n * @param {?} location\n * @return {?}\n */\n Parser.prototype.wrapLiteralPrimitive = function (input, location) {\n return new ASTWithSource(new LiteralPrimitive(new ParseSpan(0, isBlank(input) ? 0 : input.length), input), input, location, this.errors);\n };\n /**\n * @param {?} input\n * @return {?}\n */\n Parser.prototype._stripComments = function (input) {\n var /** @type {?} */ i = this._commentStart(input);\n return isPresent(i) ? input.substring(0, i).trim() : input;\n };\n /**\n * @param {?} input\n * @return {?}\n */\n Parser.prototype._commentStart = function (input) {\n var /** @type {?} */ outerQuote = null;\n for (var /** @type {?} */ i = 0; i < input.length - 1; i++) {\n var /** @type {?} */ char = input.charCodeAt(i);\n var /** @type {?} */ nextChar = input.charCodeAt(i + 1);\n if (char === chars.$SLASH && nextChar == chars.$SLASH && isBlank(outerQuote))\n return i;\n if (outerQuote === char) {\n outerQuote = null;\n }\n else if (isBlank(outerQuote) && isQuote(char)) {\n outerQuote = char;\n }\n }\n return null;\n };\n /**\n * @param {?} input\n * @param {?} location\n * @param {?} interpolationConfig\n * @return {?}\n */\n Parser.prototype._checkNoInterpolation = function (input, location, interpolationConfig) {\n var /** @type {?} */ regexp = _createInterpolateRegExp(interpolationConfig);\n var /** @type {?} */ parts = input.split(regexp);\n if (parts.length > 1) {\n this._reportError(\"Got interpolation (\" + interpolationConfig.start + interpolationConfig.end + \") where expression was expected\", input, \"at column \" + this._findInterpolationErrorColumn(parts, 1, interpolationConfig) + \" in\", location);\n }\n };\n /**\n * @param {?} parts\n * @param {?} partInErrIdx\n * @param {?} interpolationConfig\n * @return {?}\n */\n Parser.prototype._findInterpolationErrorColumn = function (parts, partInErrIdx, interpolationConfig) {\n var /** @type {?} */ errLocation = '';\n for (var /** @type {?} */ j = 0; j < partInErrIdx; j++) {\n errLocation += j % 2 === 0 ?\n parts[j] :\n \"\" + interpolationConfig.start + parts[j] + interpolationConfig.end;\n }\n return errLocation.length;\n };\n Parser = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [Lexer])\n ], Parser);\n return Parser;\n}());\nfunction Parser_tsickle_Closure_declarations() {\n /** @type {?} */\n Parser.prototype.errors;\n /** @type {?} */\n Parser.prototype._lexer;\n}\nexport var _ParseAST = (function () {\n /**\n * @param {?} input\n * @param {?} location\n * @param {?} tokens\n * @param {?} inputLength\n * @param {?} parseAction\n * @param {?} errors\n * @param {?} offset\n */\n function _ParseAST(input, location, tokens, inputLength, parseAction, errors, offset) {\n this.input = input;\n this.location = location;\n this.tokens = tokens;\n this.inputLength = inputLength;\n this.parseAction = parseAction;\n this.errors = errors;\n this.offset = offset;\n this.rparensExpected = 0;\n this.rbracketsExpected = 0;\n this.rbracesExpected = 0;\n this.index = 0;\n }\n /**\n * @param {?} offset\n * @return {?}\n */\n _ParseAST.prototype.peek = function (offset) {\n var /** @type {?} */ i = this.index + offset;\n return i < this.tokens.length ? this.tokens[i] : EOF;\n };\n Object.defineProperty(_ParseAST.prototype, \"next\", {\n /**\n * @return {?}\n */\n get: function () { return this.peek(0); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(_ParseAST.prototype, \"inputIndex\", {\n /**\n * @return {?}\n */\n get: function () {\n return (this.index < this.tokens.length) ? this.next.index + this.offset :\n this.inputLength + this.offset;\n },\n enumerable: true,\n configurable: true\n });\n /**\n * @param {?} start\n * @return {?}\n */\n _ParseAST.prototype.span = function (start) { return new ParseSpan(start, this.inputIndex); };\n /**\n * @return {?}\n */\n _ParseAST.prototype.advance = function () { this.index++; };\n /**\n * @param {?} code\n * @return {?}\n */\n _ParseAST.prototype.optionalCharacter = function (code) {\n if (this.next.isCharacter(code)) {\n this.advance();\n return true;\n }\n else {\n return false;\n }\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.peekKeywordLet = function () { return this.next.isKeywordLet(); };\n /**\n * @param {?} code\n * @return {?}\n */\n _ParseAST.prototype.expectCharacter = function (code) {\n if (this.optionalCharacter(code))\n return;\n this.error(\"Missing expected \" + String.fromCharCode(code));\n };\n /**\n * @param {?} op\n * @return {?}\n */\n _ParseAST.prototype.optionalOperator = function (op) {\n if (this.next.isOperator(op)) {\n this.advance();\n return true;\n }\n else {\n return false;\n }\n };\n /**\n * @param {?} operator\n * @return {?}\n */\n _ParseAST.prototype.expectOperator = function (operator) {\n if (this.optionalOperator(operator))\n return;\n this.error(\"Missing expected operator \" + operator);\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.expectIdentifierOrKeyword = function () {\n var /** @type {?} */ n = this.next;\n if (!n.isIdentifier() && !n.isKeyword()) {\n this.error(\"Unexpected token \" + n + \", expected identifier or keyword\");\n return '';\n }\n this.advance();\n return n.toString();\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.expectIdentifierOrKeywordOrString = function () {\n var /** @type {?} */ n = this.next;\n if (!n.isIdentifier() && !n.isKeyword() && !n.isString()) {\n this.error(\"Unexpected token \" + n + \", expected identifier, keyword, or string\");\n return '';\n }\n this.advance();\n return n.toString();\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parseChain = function () {\n var /** @type {?} */ exprs = [];\n var /** @type {?} */ start = this.inputIndex;\n while (this.index < this.tokens.length) {\n var /** @type {?} */ expr = this.parsePipe();\n exprs.push(expr);\n if (this.optionalCharacter(chars.$SEMICOLON)) {\n if (!this.parseAction) {\n this.error('Binding expression cannot contain chained expression');\n }\n while (this.optionalCharacter(chars.$SEMICOLON)) {\n } // read all semicolons\n }\n else if (this.index < this.tokens.length) {\n this.error(\"Unexpected token '\" + this.next + \"'\");\n }\n }\n if (exprs.length == 0)\n return new EmptyExpr(this.span(start));\n if (exprs.length == 1)\n return exprs[0];\n return new Chain(this.span(start), exprs);\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parsePipe = function () {\n var /** @type {?} */ result = this.parseExpression();\n if (this.optionalOperator('|')) {\n if (this.parseAction) {\n this.error('Cannot have a pipe in an action expression');\n }\n do {\n var /** @type {?} */ name_1 = this.expectIdentifierOrKeyword();\n var /** @type {?} */ args = [];\n while (this.optionalCharacter(chars.$COLON)) {\n args.push(this.parseExpression());\n }\n result = new BindingPipe(this.span(result.span.start), result, name_1, args);\n } while (this.optionalOperator('|'));\n }\n return result;\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parseExpression = function () { return this.parseConditional(); };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parseConditional = function () {\n var /** @type {?} */ start = this.inputIndex;\n var /** @type {?} */ result = this.parseLogicalOr();\n if (this.optionalOperator('?')) {\n var /** @type {?} */ yes = this.parsePipe();\n var /** @type {?} */ no = void 0;\n if (!this.optionalCharacter(chars.$COLON)) {\n var /** @type {?} */ end = this.inputIndex;\n var /** @type {?} */ expression = this.input.substring(start, end);\n this.error(\"Conditional expression \" + expression + \" requires all 3 expressions\");\n no = new EmptyExpr(this.span(start));\n }\n else {\n no = this.parsePipe();\n }\n return new Conditional(this.span(start), result, yes, no);\n }\n else {\n return result;\n }\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parseLogicalOr = function () {\n // '||'\n var /** @type {?} */ result = this.parseLogicalAnd();\n while (this.optionalOperator('||')) {\n var /** @type {?} */ right = this.parseLogicalAnd();\n result = new Binary(this.span(result.span.start), '||', result, right);\n }\n return result;\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parseLogicalAnd = function () {\n // '&&'\n var /** @type {?} */ result = this.parseEquality();\n while (this.optionalOperator('&&')) {\n var /** @type {?} */ right = this.parseEquality();\n result = new Binary(this.span(result.span.start), '&&', result, right);\n }\n return result;\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parseEquality = function () {\n // '==','!=','===','!=='\n var /** @type {?} */ result = this.parseRelational();\n while (this.next.type == TokenType.Operator) {\n var /** @type {?} */ operator = this.next.strValue;\n switch (operator) {\n case '==':\n case '===':\n case '!=':\n case '!==':\n this.advance();\n var /** @type {?} */ right = this.parseRelational();\n result = new Binary(this.span(result.span.start), operator, result, right);\n continue;\n }\n break;\n }\n return result;\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parseRelational = function () {\n // '<', '>', '<=', '>='\n var /** @type {?} */ result = this.parseAdditive();\n while (this.next.type == TokenType.Operator) {\n var /** @type {?} */ operator = this.next.strValue;\n switch (operator) {\n case '<':\n case '>':\n case '<=':\n case '>=':\n this.advance();\n var /** @type {?} */ right = this.parseAdditive();\n result = new Binary(this.span(result.span.start), operator, result, right);\n continue;\n }\n break;\n }\n return result;\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parseAdditive = function () {\n // '+', '-'\n var /** @type {?} */ result = this.parseMultiplicative();\n while (this.next.type == TokenType.Operator) {\n var /** @type {?} */ operator = this.next.strValue;\n switch (operator) {\n case '+':\n case '-':\n this.advance();\n var /** @type {?} */ right = this.parseMultiplicative();\n result = new Binary(this.span(result.span.start), operator, result, right);\n continue;\n }\n break;\n }\n return result;\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parseMultiplicative = function () {\n // '*', '%', '/'\n var /** @type {?} */ result = this.parsePrefix();\n while (this.next.type == TokenType.Operator) {\n var /** @type {?} */ operator = this.next.strValue;\n switch (operator) {\n case '*':\n case '%':\n case '/':\n this.advance();\n var /** @type {?} */ right = this.parsePrefix();\n result = new Binary(this.span(result.span.start), operator, result, right);\n continue;\n }\n break;\n }\n return result;\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parsePrefix = function () {\n if (this.next.type == TokenType.Operator) {\n var /** @type {?} */ start = this.inputIndex;\n var /** @type {?} */ operator = this.next.strValue;\n var /** @type {?} */ result = void 0;\n switch (operator) {\n case '+':\n this.advance();\n return this.parsePrefix();\n case '-':\n this.advance();\n result = this.parsePrefix();\n return new Binary(this.span(start), operator, new LiteralPrimitive(new ParseSpan(start, start), 0), result);\n case '!':\n this.advance();\n result = this.parsePrefix();\n return new PrefixNot(this.span(start), result);\n }\n }\n return this.parseCallChain();\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parseCallChain = function () {\n var /** @type {?} */ result = this.parsePrimary();\n while (true) {\n if (this.optionalCharacter(chars.$PERIOD)) {\n result = this.parseAccessMemberOrMethodCall(result, false);\n }\n else if (this.optionalOperator('?.')) {\n result = this.parseAccessMemberOrMethodCall(result, true);\n }\n else if (this.optionalCharacter(chars.$LBRACKET)) {\n this.rbracketsExpected++;\n var /** @type {?} */ key = this.parsePipe();\n this.rbracketsExpected--;\n this.expectCharacter(chars.$RBRACKET);\n if (this.optionalOperator('=')) {\n var /** @type {?} */ value = this.parseConditional();\n result = new KeyedWrite(this.span(result.span.start), result, key, value);\n }\n else {\n result = new KeyedRead(this.span(result.span.start), result, key);\n }\n }\n else if (this.optionalCharacter(chars.$LPAREN)) {\n this.rparensExpected++;\n var /** @type {?} */ args = this.parseCallArguments();\n this.rparensExpected--;\n this.expectCharacter(chars.$RPAREN);\n result = new FunctionCall(this.span(result.span.start), result, args);\n }\n else {\n return result;\n }\n }\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parsePrimary = function () {\n var /** @type {?} */ start = this.inputIndex;\n if (this.optionalCharacter(chars.$LPAREN)) {\n this.rparensExpected++;\n var /** @type {?} */ result = this.parsePipe();\n this.rparensExpected--;\n this.expectCharacter(chars.$RPAREN);\n return result;\n }\n else if (this.next.isKeywordNull()) {\n this.advance();\n return new LiteralPrimitive(this.span(start), null);\n }\n else if (this.next.isKeywordUndefined()) {\n this.advance();\n return new LiteralPrimitive(this.span(start), void 0);\n }\n else if (this.next.isKeywordTrue()) {\n this.advance();\n return new LiteralPrimitive(this.span(start), true);\n }\n else if (this.next.isKeywordFalse()) {\n this.advance();\n return new LiteralPrimitive(this.span(start), false);\n }\n else if (this.next.isKeywordThis()) {\n this.advance();\n return new ImplicitReceiver(this.span(start));\n }\n else if (this.optionalCharacter(chars.$LBRACKET)) {\n this.rbracketsExpected++;\n var /** @type {?} */ elements = this.parseExpressionList(chars.$RBRACKET);\n this.rbracketsExpected--;\n this.expectCharacter(chars.$RBRACKET);\n return new LiteralArray(this.span(start), elements);\n }\n else if (this.next.isCharacter(chars.$LBRACE)) {\n return this.parseLiteralMap();\n }\n else if (this.next.isIdentifier()) {\n return this.parseAccessMemberOrMethodCall(new ImplicitReceiver(this.span(start)), false);\n }\n else if (this.next.isNumber()) {\n var /** @type {?} */ value = this.next.toNumber();\n this.advance();\n return new LiteralPrimitive(this.span(start), value);\n }\n else if (this.next.isString()) {\n var /** @type {?} */ literalValue = this.next.toString();\n this.advance();\n return new LiteralPrimitive(this.span(start), literalValue);\n }\n else if (this.index >= this.tokens.length) {\n this.error(\"Unexpected end of expression: \" + this.input);\n return new EmptyExpr(this.span(start));\n }\n else {\n this.error(\"Unexpected token \" + this.next);\n return new EmptyExpr(this.span(start));\n }\n };\n /**\n * @param {?} terminator\n * @return {?}\n */\n _ParseAST.prototype.parseExpressionList = function (terminator) {\n var /** @type {?} */ result = [];\n if (!this.next.isCharacter(terminator)) {\n do {\n result.push(this.parsePipe());\n } while (this.optionalCharacter(chars.$COMMA));\n }\n return result;\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parseLiteralMap = function () {\n var /** @type {?} */ keys = [];\n var /** @type {?} */ values = [];\n var /** @type {?} */ start = this.inputIndex;\n this.expectCharacter(chars.$LBRACE);\n if (!this.optionalCharacter(chars.$RBRACE)) {\n this.rbracesExpected++;\n do {\n var /** @type {?} */ key = this.expectIdentifierOrKeywordOrString();\n keys.push(key);\n this.expectCharacter(chars.$COLON);\n values.push(this.parsePipe());\n } while (this.optionalCharacter(chars.$COMMA));\n this.rbracesExpected--;\n this.expectCharacter(chars.$RBRACE);\n }\n return new LiteralMap(this.span(start), keys, values);\n };\n /**\n * @param {?} receiver\n * @param {?=} isSafe\n * @return {?}\n */\n _ParseAST.prototype.parseAccessMemberOrMethodCall = function (receiver, isSafe) {\n if (isSafe === void 0) { isSafe = false; }\n var /** @type {?} */ start = receiver.span.start;\n var /** @type {?} */ id = this.expectIdentifierOrKeyword();\n if (this.optionalCharacter(chars.$LPAREN)) {\n this.rparensExpected++;\n var /** @type {?} */ args = this.parseCallArguments();\n this.expectCharacter(chars.$RPAREN);\n this.rparensExpected--;\n var /** @type {?} */ span = this.span(start);\n return isSafe ? new SafeMethodCall(span, receiver, id, args) :\n new MethodCall(span, receiver, id, args);\n }\n else {\n if (isSafe) {\n if (this.optionalOperator('=')) {\n this.error('The \\'?.\\' operator cannot be used in the assignment');\n return new EmptyExpr(this.span(start));\n }\n else {\n return new SafePropertyRead(this.span(start), receiver, id);\n }\n }\n else {\n if (this.optionalOperator('=')) {\n if (!this.parseAction) {\n this.error('Bindings cannot contain assignments');\n return new EmptyExpr(this.span(start));\n }\n var /** @type {?} */ value = this.parseConditional();\n return new PropertyWrite(this.span(start), receiver, id, value);\n }\n else {\n return new PropertyRead(this.span(start), receiver, id);\n }\n }\n }\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parseCallArguments = function () {\n if (this.next.isCharacter(chars.$RPAREN))\n return [];\n var /** @type {?} */ positionals = [];\n do {\n positionals.push(this.parsePipe());\n } while (this.optionalCharacter(chars.$COMMA));\n return (positionals);\n };\n /**\n * An identifier, a keyword, a string with an optional `-` inbetween.\n * @return {?}\n */\n _ParseAST.prototype.expectTemplateBindingKey = function () {\n var /** @type {?} */ result = '';\n var /** @type {?} */ operatorFound = false;\n do {\n result += this.expectIdentifierOrKeywordOrString();\n operatorFound = this.optionalOperator('-');\n if (operatorFound) {\n result += '-';\n }\n } while (operatorFound);\n return result.toString();\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.parseTemplateBindings = function () {\n var /** @type {?} */ bindings = [];\n var /** @type {?} */ prefix = null;\n var /** @type {?} */ warnings = [];\n while (this.index < this.tokens.length) {\n var /** @type {?} */ start = this.inputIndex;\n var /** @type {?} */ keyIsVar = this.peekKeywordLet();\n if (keyIsVar) {\n this.advance();\n }\n var /** @type {?} */ key = this.expectTemplateBindingKey();\n if (!keyIsVar) {\n if (prefix == null) {\n prefix = key;\n }\n else {\n key = prefix + key[0].toUpperCase() + key.substring(1);\n }\n }\n this.optionalCharacter(chars.$COLON);\n var /** @type {?} */ name_2 = null;\n var /** @type {?} */ expression = null;\n if (keyIsVar) {\n if (this.optionalOperator('=')) {\n name_2 = this.expectTemplateBindingKey();\n }\n else {\n name_2 = '\\$implicit';\n }\n }\n else if (this.next !== EOF && !this.peekKeywordLet()) {\n var /** @type {?} */ start_1 = this.inputIndex;\n var /** @type {?} */ ast = this.parsePipe();\n var /** @type {?} */ source = this.input.substring(start_1 - this.offset, this.inputIndex - this.offset);\n expression = new ASTWithSource(ast, source, this.location, this.errors);\n }\n bindings.push(new TemplateBinding(this.span(start), key, keyIsVar, name_2, expression));\n if (!this.optionalCharacter(chars.$SEMICOLON)) {\n this.optionalCharacter(chars.$COMMA);\n }\n }\n return new TemplateBindingParseResult(bindings, warnings, this.errors);\n };\n /**\n * @param {?} message\n * @param {?=} index\n * @return {?}\n */\n _ParseAST.prototype.error = function (message, index) {\n if (index === void 0) { index = null; }\n this.errors.push(new ParserError(message, this.input, this.locationText(index), this.location));\n this.skip();\n };\n /**\n * @param {?=} index\n * @return {?}\n */\n _ParseAST.prototype.locationText = function (index) {\n if (index === void 0) { index = null; }\n if (isBlank(index))\n index = this.index;\n return (index < this.tokens.length) ? \"at column \" + (this.tokens[index].index + 1) + \" in\" :\n \"at the end of the expression\";\n };\n /**\n * @return {?}\n */\n _ParseAST.prototype.skip = function () {\n var /** @type {?} */ n = this.next;\n while (this.index < this.tokens.length && !n.isCharacter(chars.$SEMICOLON) &&\n (this.rparensExpected <= 0 || !n.isCharacter(chars.$RPAREN)) &&\n (this.rbracesExpected <= 0 || !n.isCharacter(chars.$RBRACE)) &&\n (this.rbracketsExpected <= 0 || !n.isCharacter(chars.$RBRACKET))) {\n if (this.next.isError()) {\n this.errors.push(new ParserError(this.next.toString(), this.input, this.locationText(), this.location));\n }\n this.advance();\n n = this.next;\n }\n };\n return _ParseAST;\n}());\nfunction _ParseAST_tsickle_Closure_declarations() {\n /** @type {?} */\n _ParseAST.prototype.rparensExpected;\n /** @type {?} */\n _ParseAST.prototype.rbracketsExpected;\n /** @type {?} */\n _ParseAST.prototype.rbracesExpected;\n /** @type {?} */\n _ParseAST.prototype.index;\n /** @type {?} */\n _ParseAST.prototype.input;\n /** @type {?} */\n _ParseAST.prototype.location;\n /** @type {?} */\n _ParseAST.prototype.tokens;\n /** @type {?} */\n _ParseAST.prototype.inputLength;\n /** @type {?} */\n _ParseAST.prototype.parseAction;\n /** @type {?} */\n _ParseAST.prototype.errors;\n /** @type {?} */\n _ParseAST.prototype.offset;\n}\nvar SimpleExpressionChecker = (function () {\n function SimpleExpressionChecker() {\n this.errors = [];\n }\n /**\n * @param {?} ast\n * @return {?}\n */\n SimpleExpressionChecker.check = function (ast) {\n var /** @type {?} */ s = new SimpleExpressionChecker();\n ast.visit(s);\n return s.errors;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitImplicitReceiver = function (ast, context) { };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitInterpolation = function (ast, context) { };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitLiteralPrimitive = function (ast, context) { };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitPropertyRead = function (ast, context) { };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitPropertyWrite = function (ast, context) { };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitSafePropertyRead = function (ast, context) { };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitMethodCall = function (ast, context) { };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitSafeMethodCall = function (ast, context) { };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitFunctionCall = function (ast, context) { };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitLiteralArray = function (ast, context) { this.visitAll(ast.expressions); };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitLiteralMap = function (ast, context) { this.visitAll(ast.values); };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitBinary = function (ast, context) { };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitPrefixNot = function (ast, context) { };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitConditional = function (ast, context) { };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitPipe = function (ast, context) { this.errors.push('pipes'); };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitKeyedRead = function (ast, context) { };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitKeyedWrite = function (ast, context) { };\n /**\n * @param {?} asts\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitAll = function (asts) {\n var _this = this;\n return asts.map(function (node) { return node.visit(_this); });\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitChain = function (ast, context) { };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n SimpleExpressionChecker.prototype.visitQuote = function (ast, context) { };\n return SimpleExpressionChecker;\n}());\nfunction SimpleExpressionChecker_tsickle_Closure_declarations() {\n /** @type {?} */\n SimpleExpressionChecker.prototype.errors;\n}\n//# sourceMappingURL=parser.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/expression_parser/parser.js\n// module id = ./node_modules/@angular/compiler/src/expression_parser/parser.js\n// module chunks = 0","/**\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 */\nimport { getSymbolIterator, isJsObject } from './lang';\n/**\n * Wraps Javascript Objects\n */\nexport var StringMapWrapper = (function () {\n function StringMapWrapper() {\n }\n /**\n * @param {?} m1\n * @param {?} m2\n * @return {?}\n */\n StringMapWrapper.merge = function (m1, m2) {\n var /** @type {?} */ m = {};\n for (var _i = 0, _a = Object.keys(m1); _i < _a.length; _i++) {\n var k = _a[_i];\n m[k] = m1[k];\n }\n for (var _b = 0, _c = Object.keys(m2); _b < _c.length; _b++) {\n var k = _c[_b];\n m[k] = m2[k];\n }\n return m;\n };\n /**\n * @param {?} m1\n * @param {?} m2\n * @return {?}\n */\n StringMapWrapper.equals = function (m1, m2) {\n var /** @type {?} */ k1 = Object.keys(m1);\n var /** @type {?} */ k2 = Object.keys(m2);\n if (k1.length != k2.length) {\n return false;\n }\n for (var /** @type {?} */ i = 0; i < k1.length; i++) {\n var /** @type {?} */ key = k1[i];\n if (m1[key] !== m2[key]) {\n return false;\n }\n }\n return true;\n };\n return StringMapWrapper;\n}());\nexport var ListWrapper = (function () {\n function ListWrapper() {\n }\n /**\n * @param {?} arr\n * @param {?} condition\n * @return {?}\n */\n ListWrapper.findLast = function (arr, condition) {\n for (var /** @type {?} */ i = arr.length - 1; i >= 0; i--) {\n if (condition(arr[i])) {\n return arr[i];\n }\n }\n return null;\n };\n /**\n * @param {?} list\n * @param {?} items\n * @return {?}\n */\n ListWrapper.removeAll = function (list, items) {\n for (var /** @type {?} */ i = 0; i < items.length; ++i) {\n var /** @type {?} */ index = list.indexOf(items[i]);\n if (index > -1) {\n list.splice(index, 1);\n }\n }\n };\n /**\n * @param {?} list\n * @param {?} el\n * @return {?}\n */\n ListWrapper.remove = function (list, el) {\n var /** @type {?} */ index = list.indexOf(el);\n if (index > -1) {\n list.splice(index, 1);\n return true;\n }\n return false;\n };\n /**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\n ListWrapper.equals = function (a, b) {\n if (a.length != b.length)\n return false;\n for (var /** @type {?} */ i = 0; i < a.length; ++i) {\n if (a[i] !== b[i])\n return false;\n }\n return true;\n };\n /**\n * @param {?} list\n * @return {?}\n */\n ListWrapper.flatten = function (list) {\n return list.reduce(function (flat, item) {\n var /** @type {?} */ flatItem = Array.isArray(item) ? ListWrapper.flatten(item) : item;\n return ((flat)).concat(flatItem);\n }, []);\n };\n return ListWrapper;\n}());\n/**\n * @param {?} obj\n * @return {?}\n */\nexport function isListLikeIterable(obj) {\n if (!isJsObject(obj))\n return false;\n return Array.isArray(obj) ||\n (!(obj instanceof Map) &&\n getSymbolIterator() in obj); // JS Iterable have a Symbol.iterator prop\n}\n/**\n * @param {?} a\n * @param {?} b\n * @param {?} comparator\n * @return {?}\n */\nexport function areIterablesEqual(a, b, comparator) {\n var /** @type {?} */ iterator1 = a[getSymbolIterator()]();\n var /** @type {?} */ iterator2 = b[getSymbolIterator()]();\n while (true) {\n var /** @type {?} */ item1 = iterator1.next();\n var /** @type {?} */ item2 = iterator2.next();\n if (item1.done && item2.done)\n return true;\n if (item1.done || item2.done)\n return false;\n if (!comparator(item1.value, item2.value))\n return false;\n }\n}\n/**\n * @param {?} obj\n * @param {?} fn\n * @return {?}\n */\nexport function iterateListLike(obj, fn) {\n if (Array.isArray(obj)) {\n for (var /** @type {?} */ i = 0; i < obj.length; i++) {\n fn(obj[i]);\n }\n }\n else {\n var /** @type {?} */ iterator = obj[getSymbolIterator()]();\n var /** @type {?} */ item = void 0;\n while (!((item = iterator.next()).done)) {\n fn(item.value);\n }\n }\n}\n//# sourceMappingURL=collection.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/facade/collection.js\n// module id = ./node_modules/@angular/compiler/src/facade/collection.js\n// module chunks = 0","var __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * @license undefined\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 * @return {?}\n */\nexport function unimplemented() {\n throw new Error('unimplemented');\n}\n/**\n * @stable\n */\nexport var BaseError = (function (_super) {\n __extends(BaseError, _super);\n /**\n * @param {?} message\n */\n function BaseError(message) {\n _super.call(this, message);\n // Errors don't use current this, instead they create a new instance.\n // We have to do forward all of our api to the nativeInstance.\n // TODO(bradfordcsmith): Remove this hack when\n // google/closure-compiler/issues/2102 is fixed.\n var nativeError = new Error(message);\n this._nativeError = nativeError;\n }\n Object.defineProperty(BaseError.prototype, \"message\", {\n /**\n * @return {?}\n */\n get: function () { return this._nativeError.message; },\n /**\n * @param {?} message\n * @return {?}\n */\n set: function (message) { this._nativeError.message = message; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(BaseError.prototype, \"name\", {\n /**\n * @return {?}\n */\n get: function () { return this._nativeError.name; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(BaseError.prototype, \"stack\", {\n /**\n * @return {?}\n */\n get: function () { return ((this._nativeError)).stack; },\n /**\n * @param {?} value\n * @return {?}\n */\n set: function (value) { ((this._nativeError)).stack = value; },\n enumerable: true,\n configurable: true\n });\n /**\n * @return {?}\n */\n BaseError.prototype.toString = function () { return this._nativeError.toString(); };\n return BaseError;\n}(Error));\nfunction BaseError_tsickle_Closure_declarations() {\n /** @type {?} */\n BaseError.prototype._nativeError;\n}\n/**\n * @stable\n */\nexport var WrappedError = (function (_super) {\n __extends(WrappedError, _super);\n /**\n * @param {?} message\n * @param {?} error\n */\n function WrappedError(message, error) {\n _super.call(this, message + \" caused by: \" + (error instanceof Error ? error.message : error));\n this.originalError = error;\n }\n Object.defineProperty(WrappedError.prototype, \"stack\", {\n /**\n * @return {?}\n */\n get: function () {\n return (((this.originalError instanceof Error ? this.originalError : this._nativeError)))\n .stack;\n },\n enumerable: true,\n configurable: true\n });\n return WrappedError;\n}(BaseError));\nfunction WrappedError_tsickle_Closure_declarations() {\n /** @type {?} */\n WrappedError.prototype.originalError;\n}\n//# sourceMappingURL=errors.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/facade/errors.js\n// module id = ./node_modules/@angular/compiler/src/facade/errors.js\n// module chunks = 0","/**\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 /** @type {?} */ globalScope;\nif (typeof window === 'undefined') {\n if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {\n // TODO: Replace any with WorkerGlobalScope from lib.webworker.d.ts #3492\n globalScope = (self);\n }\n else {\n globalScope = (global);\n }\n}\nelse {\n globalScope = (window);\n}\n/**\n * @param {?} fn\n * @return {?}\n */\nexport function scheduleMicroTask(fn) {\n Zone.current.scheduleMicroTask('scheduleMicrotask', fn);\n}\n// Need to declare a new variable for global here since TypeScript\n// exports the original value of the symbol.\nvar /** @type {?} */ _global = globalScope;\nexport { _global as global };\n/**\n * @param {?} type\n * @return {?}\n */\nexport function getTypeNameForDebugging(type) {\n return type['name'] || typeof type;\n}\n// TODO: remove calls to assert in production environment\n// Note: Can't just export this and import in in other files\n// as `assert` is a reserved keyword in Dart\n_global.assert = function assert(condition) {\n // TODO: to be fixed properly via #2830, noop for now\n};\n/**\n * @param {?} obj\n * @return {?}\n */\nexport function isPresent(obj) {\n return obj != null;\n}\n/**\n * @param {?} obj\n * @return {?}\n */\nexport function isBlank(obj) {\n return obj == null;\n}\nvar /** @type {?} */ STRING_MAP_PROTO = Object.getPrototypeOf({});\n/**\n * @param {?} obj\n * @return {?}\n */\nexport function isStrictStringMap(obj) {\n return typeof obj === 'object' && obj !== null && Object.getPrototypeOf(obj) === STRING_MAP_PROTO;\n}\n/**\n * @param {?} obj\n * @return {?}\n */\nexport function isDate(obj) {\n return obj instanceof Date && !isNaN(obj.valueOf());\n}\n/**\n * @param {?} token\n * @return {?}\n */\nexport function stringify(token) {\n if (typeof token === 'string') {\n return token;\n }\n if (token == null) {\n return '' + token;\n }\n if (token.overriddenName) {\n return \"\" + token.overriddenName;\n }\n if (token.name) {\n return \"\" + token.name;\n }\n var /** @type {?} */ res = token.toString();\n var /** @type {?} */ newLineIndex = res.indexOf('\\n');\n return newLineIndex === -1 ? res : res.substring(0, newLineIndex);\n}\nexport var NumberWrapper = (function () {\n function NumberWrapper() {\n }\n /**\n * @param {?} text\n * @return {?}\n */\n NumberWrapper.parseIntAutoRadix = function (text) {\n var /** @type {?} */ result = parseInt(text);\n if (isNaN(result)) {\n throw new Error('Invalid integer literal when parsing ' + text);\n }\n return result;\n };\n /**\n * @param {?} value\n * @return {?}\n */\n NumberWrapper.isNumeric = function (value) { return !isNaN(value - parseFloat(value)); };\n return NumberWrapper;\n}());\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nexport function looseIdentical(a, b) {\n return a === b || typeof a === 'number' && typeof b === 'number' && isNaN(a) && isNaN(b);\n}\n/**\n * @param {?} o\n * @return {?}\n */\nexport function isJsObject(o) {\n return o !== null && (typeof o === 'function' || typeof o === 'object');\n}\n/**\n * @param {?} obj\n * @return {?}\n */\nexport function print(obj) {\n // tslint:disable-next-line:no-console\n console.log(obj);\n}\n/**\n * @param {?} obj\n * @return {?}\n */\nexport function warn(obj) {\n console.warn(obj);\n}\n/**\n * @param {?} global\n * @param {?} path\n * @param {?} value\n * @return {?}\n */\nexport function setValueOnPath(global, path, value) {\n var /** @type {?} */ parts = path.split('.');\n var /** @type {?} */ obj = global;\n while (parts.length > 1) {\n var /** @type {?} */ name_1 = parts.shift();\n if (obj.hasOwnProperty(name_1) && obj[name_1] != null) {\n obj = obj[name_1];\n }\n else {\n obj = obj[name_1] = {};\n }\n }\n if (obj === undefined || obj === null) {\n obj = {};\n }\n obj[parts.shift()] = value;\n}\nvar /** @type {?} */ _symbolIterator = null;\n/**\n * @return {?}\n */\nexport function getSymbolIterator() {\n if (!_symbolIterator) {\n if (((globalScope)).Symbol && Symbol.iterator) {\n _symbolIterator = Symbol.iterator;\n }\n else {\n // es6-shim specific logic\n var /** @type {?} */ keys = Object.getOwnPropertyNames(Map.prototype);\n for (var /** @type {?} */ i = 0; i < keys.length; ++i) {\n var /** @type {?} */ key = keys[i];\n if (key !== 'entries' && key !== 'size' &&\n ((Map)).prototype[key] === Map.prototype['entries']) {\n _symbolIterator = key;\n }\n }\n }\n }\n return _symbolIterator;\n}\n/**\n * @param {?} obj\n * @return {?}\n */\nexport function isPrimitive(obj) {\n return !isJsObject(obj);\n}\n/**\n * @param {?} s\n * @return {?}\n */\nexport function escapeRegExp(s) {\n return s.replace(/([.*+?^=!:${}()|[\\]\\/\\\\])/g, '\\\\$1');\n}\n//# sourceMappingURL=lang.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/facade/lang.js\n// module id = ./node_modules/@angular/compiler/src/facade/lang.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * @param {?} message\n * @return {?}\n */\nexport function digest(message) {\n return message.id || sha1(serializeNodes(message.nodes).join('') + (\"[\" + message.meaning + \"]\"));\n}\n/**\n * @param {?} message\n * @return {?}\n */\nexport function decimalDigest(message) {\n var /** @type {?} */ visitor = new _SerializerIgnoreIcuExpVisitor();\n var /** @type {?} */ parts = message.nodes.map(function (a) { return a.visit(visitor, null); });\n return message.id || 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 */\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 /** @type {?} */ serializerVisitor = new _SerializerVisitor();\n/**\n * @param {?} nodes\n * @return {?}\n */\nexport function 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 */\nvar _SerializerIgnoreIcuExpVisitor = (function (_super) {\n __extends(_SerializerIgnoreIcuExpVisitor, _super);\n function _SerializerIgnoreIcuExpVisitor() {\n _super.apply(this, arguments);\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 */\nexport function 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 */\nexport function 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 */\nexport function 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 {?} str\n * @return {?}\n */\nfunction utf8Encode(str) {\n var /** @type {?} */ encoded = '';\n for (var /** @type {?} */ index = 0; index < str.length; index++) {\n var /** @type {?} */ codePoint = decodeSurrogatePairs(str, index);\n if (codePoint <= 0x7f) {\n encoded += String.fromCharCode(codePoint);\n }\n else if (codePoint <= 0x7ff) {\n encoded += String.fromCharCode(0xc0 | codePoint >>> 6, 0x80 | codePoint & 0x3f);\n }\n else if (codePoint <= 0xffff) {\n encoded += String.fromCharCode(0xe0 | codePoint >>> 12, 0x80 | codePoint >>> 6 & 0x3f, 0x80 | codePoint & 0x3f);\n }\n else if (codePoint <= 0x1fffff) {\n encoded += String.fromCharCode(0xf0 | codePoint >>> 18, 0x80 | codePoint >>> 12 & 0x3f, 0x80 | codePoint >>> 6 & 0x3f, 0x80 | codePoint & 0x3f);\n }\n }\n return encoded;\n}\n/**\n * @param {?} str\n * @param {?} index\n * @return {?}\n */\nfunction decodeSurrogatePairs(str, index) {\n if (index < 0 || index >= str.length) {\n throw new Error(\"index=\" + index + \" is out of range in \\\"\" + str + \"\\\"\");\n }\n var /** @type {?} */ high = str.charCodeAt(index);\n if (high >= 0xd800 && high <= 0xdfff && str.length > index + 1) {\n var /** @type {?} */ low = byteAt(str, index + 1);\n if (low >= 0xdc00 && low <= 0xdfff) {\n return (high - 0xd800) * 0x400 + low - 0xdc00 + 0x10000;\n }\n }\n return high;\n}\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//# sourceMappingURL=digest.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/digest.js\n// module id = ./node_modules/@angular/compiler/src/i18n/digest.js\n// module chunks = 0","/**\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 */\nimport { ViewEncapsulation } from '@angular/core';\nimport { analyzeAndValidateNgModules, extractProgramSymbols } from '../aot/compiler';\nimport { StaticAndDynamicReflectionCapabilities } from '../aot/static_reflection_capabilities';\nimport { StaticReflector } from '../aot/static_reflector';\nimport { StaticSymbolCache } from '../aot/static_symbol';\nimport { StaticSymbolResolver } from '../aot/static_symbol_resolver';\nimport { AotSummaryResolver } from '../aot/summary_resolver';\nimport { CompilerConfig } from '../config';\nimport { DirectiveNormalizer } from '../directive_normalizer';\nimport { DirectiveResolver } from '../directive_resolver';\nimport { CompileMetadataResolver } from '../metadata_resolver';\nimport { HtmlParser } from '../ml_parser/html_parser';\nimport { InterpolationConfig } from '../ml_parser/interpolation_config';\nimport { NgModuleResolver } from '../ng_module_resolver';\nimport { PipeResolver } from '../pipe_resolver';\nimport { DomElementSchemaRegistry } from '../schema/dom_element_schema_registry';\nimport { createOfflineCompileUrlResolver } from '../url_resolver';\nimport { I18NHtmlParser } from './i18n_html_parser';\nimport { MessageBundle } from './message_bundle';\nexport var Extractor = (function () {\n /**\n * @param {?} host\n * @param {?} staticSymbolResolver\n * @param {?} messageBundle\n * @param {?} metadataResolver\n */\n function Extractor(host, staticSymbolResolver, messageBundle, metadataResolver) {\n this.host = host;\n this.staticSymbolResolver = staticSymbolResolver;\n this.messageBundle = messageBundle;\n this.metadataResolver = metadataResolver;\n }\n /**\n * @param {?} rootFiles\n * @return {?}\n */\n Extractor.prototype.extract = function (rootFiles) {\n var _this = this;\n var /** @type {?} */ programSymbols = extractProgramSymbols(this.staticSymbolResolver, rootFiles, this.host);\n var _a = analyzeAndValidateNgModules(programSymbols, this.host, this.metadataResolver), ngModuleByPipeOrDirective = _a.ngModuleByPipeOrDirective, files = _a.files, ngModules = _a.ngModules;\n return Promise\n .all(ngModules.map(function (ngModule) { return _this.metadataResolver.loadNgModuleDirectiveAndPipeMetadata(ngModule.type.reference, false); }))\n .then(function () {\n var /** @type {?} */ errors = [];\n files.forEach(function (file) {\n var /** @type {?} */ compMetas = [];\n file.directives.forEach(function (directiveType) {\n var /** @type {?} */ dirMeta = _this.metadataResolver.getDirectiveMetadata(directiveType);\n if (dirMeta && dirMeta.isComponent) {\n compMetas.push(dirMeta);\n }\n });\n compMetas.forEach(function (compMeta) {\n var /** @type {?} */ html = compMeta.template.template;\n var /** @type {?} */ interpolationConfig = InterpolationConfig.fromArray(compMeta.template.interpolation);\n errors.push.apply(errors, _this.messageBundle.updateFromTemplate(html, file.srcUrl, interpolationConfig));\n });\n });\n if (errors.length) {\n throw new Error(errors.map(function (e) { return e.toString(); }).join('\\n'));\n }\n return _this.messageBundle;\n });\n };\n /**\n * @param {?} host\n * @return {?}\n */\n Extractor.create = function (host) {\n var /** @type {?} */ htmlParser = new I18NHtmlParser(new HtmlParser());\n var /** @type {?} */ urlResolver = createOfflineCompileUrlResolver();\n var /** @type {?} */ symbolCache = new StaticSymbolCache();\n var /** @type {?} */ summaryResolver = new AotSummaryResolver(host, symbolCache);\n var /** @type {?} */ staticSymbolResolver = new StaticSymbolResolver(host, symbolCache, summaryResolver);\n var /** @type {?} */ staticReflector = new StaticReflector(staticSymbolResolver);\n StaticAndDynamicReflectionCapabilities.install(staticReflector);\n var /** @type {?} */ config = new CompilerConfig({\n genDebugInfo: false,\n defaultEncapsulation: ViewEncapsulation.Emulated,\n logBindingUpdate: false,\n useJit: false\n });\n var /** @type {?} */ normalizer = new DirectiveNormalizer({ get: function (url) { return host.loadResource(url); } }, urlResolver, htmlParser, config);\n var /** @type {?} */ elementSchemaRegistry = new DomElementSchemaRegistry();\n var /** @type {?} */ resolver = new CompileMetadataResolver(new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector), new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer, staticReflector);\n // TODO(vicb): implicit tags & attributes\n var /** @type {?} */ messageBundle = new MessageBundle(htmlParser, [], {});\n var /** @type {?} */ extractor = new Extractor(host, staticSymbolResolver, messageBundle, resolver);\n return { extractor: extractor, staticReflector: staticReflector };\n };\n return Extractor;\n}());\nfunction Extractor_tsickle_Closure_declarations() {\n /** @type {?} */\n Extractor.prototype.host;\n /** @type {?} */\n Extractor.prototype.staticSymbolResolver;\n /** @type {?} */\n Extractor.prototype.messageBundle;\n /** @type {?} */\n Extractor.prototype.metadataResolver;\n}\n//# sourceMappingURL=extractor.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/extractor.js\n// module id = ./node_modules/@angular/compiler/src/i18n/extractor.js\n// module chunks = 0","/**\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 */\nimport * as html from '../ml_parser/ast';\nimport { ParseTreeResult } from '../ml_parser/parser';\nimport * as i18n from './i18n_ast';\nimport { createI18nMessageFactory } from './i18n_parser';\nimport { I18nError } from './parse_util';\nvar /** @type {?} */ _I18N_ATTR = 'i18n';\nvar /** @type {?} */ _I18N_ATTR_PREFIX = 'i18n-';\nvar /** @type {?} */ _I18N_COMMENT_PREFIX_REGEXP = /^i18n:?/;\nvar /** @type {?} */ MEANING_SEPARATOR = '|';\nvar /** @type {?} */ 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 */\nexport function 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 */\nexport function mergeTranslations(nodes, translations, interpolationConfig, implicitTags, implicitAttrs) {\n var /** @type {?} */ visitor = new _Visitor(implicitTags, implicitAttrs);\n return visitor.merge(nodes, translations, interpolationConfig);\n}\nexport var 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}());\nfunction ExtractionResult_tsickle_Closure_declarations() {\n /** @type {?} */\n ExtractionResult.prototype.messages;\n /** @type {?} */\n ExtractionResult.prototype.errors;\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 */\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 html.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 = html.visitAll(this, icuCase.expression, context);\n if (this._mode === _VisitorMode.Merge) {\n return new html.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 = html.visitAll(this, icu.cases, context);\n if (this._mode === _VisitorMode.Merge) {\n icu = new html.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 html.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 // Extract only top level nodes with the (implicit) \"i18n\" attribute if not in a block or an ICU\n // message\n var /** @type {?} */ i18nAttr = _getI18nAttr(el);\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 = this._inImplicitNode || isImplicit;\n if (!this._isInTranslatableSection && !this._inIcu) {\n if (i18nAttr) {\n // explicit translation\n this._inI18nNode = true;\n var /** @type {?} */ message = this._addMessage(el.children, i18nAttr.value);\n childNodes = this._translateMessage(el, message);\n }\n else if (isTopLevelImplicit) {\n // implicit translation\n this._inI18nNode = true;\n var /** @type {?} */ message = this._addMessage(el.children);\n childNodes = 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 }\n html.visitAll(this, el.children);\n if (isTranslatable) {\n this._closeTranslatableSection(el, el.children);\n }\n }\n if (this._mode === _VisitorMode.Merge && !i18nAttr && !isTopLevelImplicit) {\n childNodes = [];\n el.children.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 when the section is close (i.e. on ``)\n childNodes = childNodes.concat(visited);\n }\n });\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 html.visitAll(this, el.children);\n }\n if (this._mode == _VisitorMode.Merge) {\n // Translate attributes in ICU messages\n childNodes = [];\n el.children.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 when the section is close (i.e. on ``)\n childNodes = childNodes.concat(visited);\n }\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 // There are no childNodes in translatable sections - those nodes will be replace anyway\n var /** @type {?} */ translatedAttrs = this._translateAttributes(el);\n return new html.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 html.Attribute && !((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 {?} */ i18nAttributeMeanings = {};\n attributes.forEach(function (attr) {\n if (attr.name.startsWith(_I18N_ATTR_PREFIX)) {\n i18nAttributeMeanings[attr.name.slice(_I18N_ATTR_PREFIX.length)] =\n _parseMessageMeta(attr.value).meaning;\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 != '' && i18nAttributeMeanings.hasOwnProperty(attr.name)) {\n var /** @type {?} */ meaning = i18nAttributeMeanings[attr.name];\n var /** @type {?} */ message = _this._createI18nMessage([attr], meaning, '', '');\n var /** @type {?} */ nodes = _this._translations.get(message);\n if (nodes) {\n if (nodes[0] instanceof html.Text) {\n var /** @type {?} */ value = ((nodes[0])).value;\n translatedAttributes.push(new html.Attribute(attr.name, value, attr.sourceSpan));\n }\n else {\n _this._reportError(el, \"Unexpected translation for attribute \\\"\" + attr.name + \"\\\" (id=\\\"\" + _this._translations.digest(message) + \"\\\")\");\n }\n }\n else {\n _this._reportError(el, \"Translation unavailable for attribute \\\"\" + attr.name + \"\\\" (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 `_endSection`\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 * - a 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 html.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 i18n.Text)) {\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}());\nfunction _Visitor_tsickle_Closure_declarations() {\n /** @type {?} */\n _Visitor.prototype._inI18nNode;\n /** @type {?} */\n _Visitor.prototype._depth;\n /** @type {?} */\n _Visitor.prototype._inImplicitNode;\n /** @type {?} */\n _Visitor.prototype._blockMeaningAndDesc;\n /** @type {?} */\n _Visitor.prototype._blockChildren;\n /** @type {?} */\n _Visitor.prototype._blockStartDepth;\n /** @type {?} */\n _Visitor.prototype._inI18nBlock;\n /** @type {?} */\n _Visitor.prototype._inIcu;\n /** @type {?} */\n _Visitor.prototype._msgCountAtSectionStart;\n /** @type {?} */\n _Visitor.prototype._errors;\n /** @type {?} */\n _Visitor.prototype._mode;\n /** @type {?} */\n _Visitor.prototype._messages;\n /** @type {?} */\n _Visitor.prototype._translations;\n /** @type {?} */\n _Visitor.prototype._createI18nMessage;\n /** @type {?} */\n _Visitor.prototype._implicitTags;\n /** @type {?} */\n _Visitor.prototype._implicitAttrs;\n}\n/**\n * @param {?} n\n * @return {?}\n */\nfunction _isOpeningComment(n) {\n return n instanceof html.Comment && n.value && n.value.startsWith('i18n');\n}\n/**\n * @param {?} n\n * @return {?}\n */\nfunction _isClosingComment(n) {\n return n instanceof html.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//# sourceMappingURL=extractor_merger.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/extractor_merger.js\n// module id = ./node_modules/@angular/compiler/src/i18n/extractor_merger.js\n// module chunks = 0","/**\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 */\nexport var 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}());\nfunction Message_tsickle_Closure_declarations() {\n /** @type {?} */\n Message.prototype.nodes;\n /** @type {?} */\n Message.prototype.placeholders;\n /** @type {?} */\n Message.prototype.placeholderToMessage;\n /** @type {?} */\n Message.prototype.meaning;\n /** @type {?} */\n Message.prototype.description;\n /** @type {?} */\n Message.prototype.id;\n}\nexport var Text = (function () {\n /**\n * @param {?} value\n * @param {?} sourceSpan\n */\n function Text(value, sourceSpan) {\n this.value = value;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\n Text.prototype.visit = function (visitor, context) { return visitor.visitText(this, context); };\n return Text;\n}());\nfunction Text_tsickle_Closure_declarations() {\n /** @type {?} */\n Text.prototype.value;\n /** @type {?} */\n Text.prototype.sourceSpan;\n}\n// TODO(vicb): do we really need this node (vs an array) ?\nexport var 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}());\nfunction Container_tsickle_Closure_declarations() {\n /** @type {?} */\n Container.prototype.children;\n /** @type {?} */\n Container.prototype.sourceSpan;\n}\nexport var 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}());\nfunction Icu_tsickle_Closure_declarations() {\n /** @type {?} */\n Icu.prototype.expressionPlaceholder;\n /** @type {?} */\n Icu.prototype.expression;\n /** @type {?} */\n Icu.prototype.type;\n /** @type {?} */\n Icu.prototype.cases;\n /** @type {?} */\n Icu.prototype.sourceSpan;\n}\nexport var 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}());\nfunction TagPlaceholder_tsickle_Closure_declarations() {\n /** @type {?} */\n TagPlaceholder.prototype.tag;\n /** @type {?} */\n TagPlaceholder.prototype.attrs;\n /** @type {?} */\n TagPlaceholder.prototype.startName;\n /** @type {?} */\n TagPlaceholder.prototype.closeName;\n /** @type {?} */\n TagPlaceholder.prototype.children;\n /** @type {?} */\n TagPlaceholder.prototype.isVoid;\n /** @type {?} */\n TagPlaceholder.prototype.sourceSpan;\n}\nexport var 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}());\nfunction Placeholder_tsickle_Closure_declarations() {\n /** @type {?} */\n Placeholder.prototype.value;\n /** @type {?} */\n Placeholder.prototype.name;\n /** @type {?} */\n Placeholder.prototype.sourceSpan;\n}\nexport var 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}());\nfunction IcuPlaceholder_tsickle_Closure_declarations() {\n /** @type {?} */\n IcuPlaceholder.prototype.value;\n /** @type {?} */\n IcuPlaceholder.prototype.name;\n /** @type {?} */\n IcuPlaceholder.prototype.sourceSpan;\n}\n//# sourceMappingURL=i18n_ast.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/i18n_ast.js\n// module id = ./node_modules/@angular/compiler/src/i18n/i18n_ast.js\n// module chunks = 0","/**\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 */\nimport { DEFAULT_INTERPOLATION_CONFIG } from '../ml_parser/interpolation_config';\nimport { ParseTreeResult } from '../ml_parser/parser';\nimport { mergeTranslations } from './extractor_merger';\nimport { Xliff } from './serializers/xliff';\nimport { Xmb } from './serializers/xmb';\nimport { Xtb } from './serializers/xtb';\nimport { TranslationBundle } from './translation_bundle';\nexport var I18NHtmlParser = (function () {\n /**\n * @param {?} _htmlParser\n * @param {?=} _translations\n * @param {?=} _translationsFormat\n */\n function I18NHtmlParser(_htmlParser, _translations, _translationsFormat) {\n this._htmlParser = _htmlParser;\n this._translations = _translations;\n this._translationsFormat = _translationsFormat;\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._translations || this._translations === '') {\n // Do not enable i18n when no translation bundle is provided\n return parseResult;\n }\n // TODO(vicb): add support for implicit tags / attributes\n if (parseResult.errors.length) {\n return new ParseTreeResult(parseResult.rootNodes, parseResult.errors);\n }\n var /** @type {?} */ serializer = this._createSerializer();\n var /** @type {?} */ translationBundle = TranslationBundle.load(this._translations, url, serializer);\n return mergeTranslations(parseResult.rootNodes, translationBundle, interpolationConfig, [], {});\n };\n /**\n * @return {?}\n */\n I18NHtmlParser.prototype._createSerializer = function () {\n var /** @type {?} */ format = (this._translationsFormat || '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 return I18NHtmlParser;\n}());\nfunction I18NHtmlParser_tsickle_Closure_declarations() {\n /** @type {?} */\n I18NHtmlParser.prototype.getTagDefinition;\n /** @type {?} */\n I18NHtmlParser.prototype._htmlParser;\n /** @type {?} */\n I18NHtmlParser.prototype._translations;\n /** @type {?} */\n I18NHtmlParser.prototype._translationsFormat;\n}\n//# sourceMappingURL=i18n_html_parser.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/i18n_html_parser.js\n// module id = ./node_modules/@angular/compiler/src/i18n/i18n_html_parser.js\n// module chunks = 0","/**\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 */\nimport { Lexer as ExpressionLexer } from '../expression_parser/lexer';\nimport { Parser as ExpressionParser } from '../expression_parser/parser';\nimport * as html from '../ml_parser/ast';\nimport { getHtmlTagDefinition } from '../ml_parser/html_tags';\nimport * as i18n from './i18n_ast';\nimport { PlaceholderRegistry } from './serializers/placeholder';\nvar /** @type {?} */ _expParser = new ExpressionParser(new ExpressionLexer());\n/**\n * Returns a function converting html nodes to an i18n Message given an interpolationConfig\n * @param {?} interpolationConfig\n * @return {?}\n */\nexport function createI18nMessageFactory(interpolationConfig) {\n var /** @type {?} */ visitor = new _I18nVisitor(_expParser, interpolationConfig);\n return function (nodes, meaning, description, id) {\n return visitor.toI18nMessage(nodes, meaning, description, id);\n };\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 html.Expansion;\n this._icuDepth = 0;\n this._placeholderRegistry = new PlaceholderRegistry();\n this._placeholderToContent = {};\n this._placeholderToMessage = {};\n var /** @type {?} */ i18nodes = html.visitAll(this, nodes, {});\n return new i18n.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 = html.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 i18n.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 i18n.Icu(icu.switchValue, icu.type, i18nIcuCases, icu.sourceSpan);\n icu.cases.forEach(function (caze) {\n i18nIcuCases[caze.value] = new i18n.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 i18n.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 i18n.Text(text, sourceSpan);\n }\n // Return a group of text + expressions\n var /** @type {?} */ nodes = [];\n var /** @type {?} */ container = new i18n.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 i18n.Text(splitInterpolation.strings[i], sourceSpan));\n }\n nodes.push(new i18n.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 i18n.Text(splitInterpolation.strings[lastStringIdx], sourceSpan));\n }\n return container;\n };\n return _I18nVisitor;\n}());\nfunction _I18nVisitor_tsickle_Closure_declarations() {\n /** @type {?} */\n _I18nVisitor.prototype._isIcu;\n /** @type {?} */\n _I18nVisitor.prototype._icuDepth;\n /** @type {?} */\n _I18nVisitor.prototype._placeholderRegistry;\n /** @type {?} */\n _I18nVisitor.prototype._placeholderToContent;\n /** @type {?} */\n _I18nVisitor.prototype._placeholderToMessage;\n /** @type {?} */\n _I18nVisitor.prototype._expressionParser;\n /** @type {?} */\n _I18nVisitor.prototype._interpolationConfig;\n}\nvar /** @type {?} */ _CUSTOM_PH_EXP = /\\/\\/[\\s\\S]*i18n[\\s\\S]*\\([\\s\\S]*ph[\\s\\S]*=[\\s\\S]*\"([\\s\\S]*?)\"[\\s\\S]*\\)/g;\n/**\n * @param {?} input\n * @return {?}\n */\nfunction _extractPlaceholderName(input) {\n return input.split(_CUSTOM_PH_EXP)[1];\n}\n//# sourceMappingURL=i18n_parser.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/i18n_parser.js\n// module id = ./node_modules/@angular/compiler/src/i18n/i18n_parser.js\n// module chunks = 0","/**\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 */\nexport { Extractor } from './extractor';\nexport { I18NHtmlParser } from './i18n_html_parser';\nexport { MessageBundle } from './message_bundle';\nexport { Xliff } from './serializers/xliff';\nexport { Xmb } from './serializers/xmb';\nexport { Xtb } from './serializers/xtb';\n//# sourceMappingURL=index.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/index.js\n// module id = ./node_modules/@angular/compiler/src/i18n/index.js\n// module chunks = 0","/**\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 */\nimport { extractMessages } from './extractor_merger';\n/**\n * A container for message extracted from the templates.\n */\nexport var MessageBundle = (function () {\n /**\n * @param {?} _htmlParser\n * @param {?} _implicitTags\n * @param {?} _implicitAttrs\n */\n function MessageBundle(_htmlParser, _implicitTags, _implicitAttrs) {\n this._htmlParser = _htmlParser;\n this._implicitTags = _implicitTags;\n this._implicitAttrs = _implicitAttrs;\n this._messages = [];\n }\n /**\n * @param {?} html\n * @param {?} url\n * @param {?} interpolationConfig\n * @return {?}\n */\n MessageBundle.prototype.updateFromTemplate = function (html, url, interpolationConfig) {\n var /** @type {?} */ htmlParserResult = this._htmlParser.parse(html, url, true, interpolationConfig);\n if (htmlParserResult.errors.length) {\n return htmlParserResult.errors;\n }\n var /** @type {?} */ i18nParserResult = extractMessages(htmlParserResult.rootNodes, interpolationConfig, this._implicitTags, this._implicitAttrs);\n if (i18nParserResult.errors.length) {\n return i18nParserResult.errors;\n }\n (_a = this._messages).push.apply(_a, i18nParserResult.messages);\n var _a;\n };\n /**\n * @return {?}\n */\n MessageBundle.prototype.getMessages = function () { return this._messages; };\n /**\n * @param {?} serializer\n * @return {?}\n */\n MessageBundle.prototype.write = function (serializer) { return serializer.write(this._messages); };\n return MessageBundle;\n}());\nfunction MessageBundle_tsickle_Closure_declarations() {\n /** @type {?} */\n MessageBundle.prototype._messages;\n /** @type {?} */\n MessageBundle.prototype._htmlParser;\n /** @type {?} */\n MessageBundle.prototype._implicitTags;\n /** @type {?} */\n MessageBundle.prototype._implicitAttrs;\n}\n//# sourceMappingURL=message_bundle.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/message_bundle.js\n// module id = ./node_modules/@angular/compiler/src/i18n/message_bundle.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nimport { ParseError } from '../parse_util';\n/**\n * An i18n error.\n */\nexport var I18nError = (function (_super) {\n __extends(I18nError, _super);\n /**\n * @param {?} span\n * @param {?} msg\n */\n function I18nError(span, msg) {\n _super.call(this, span, msg);\n }\n return I18nError;\n}(ParseError));\n//# sourceMappingURL=parse_util.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/parse_util.js\n// module id = ./node_modules/@angular/compiler/src/i18n/parse_util.js\n// module chunks = 0","/**\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 /** @type {?} */ 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 */\nexport var 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 {?} */ next = this._placeHolderNameCounts[base];\n this._placeHolderNameCounts[base] = next ? next + 1 : 1;\n return next ? base + \"_\" + next : base;\n };\n return PlaceholderRegistry;\n}());\nfunction PlaceholderRegistry_tsickle_Closure_declarations() {\n /** @type {?} */\n PlaceholderRegistry.prototype._placeHolderNameCounts;\n /** @type {?} */\n PlaceholderRegistry.prototype._signatureToName;\n}\n//# sourceMappingURL=placeholder.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/serializers/placeholder.js\n// module id = ./node_modules/@angular/compiler/src/i18n/serializers/placeholder.js\n// module chunks = 0","/**\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 */\nimport * as ml from '../../ml_parser/ast';\nimport { XmlParser } from '../../ml_parser/xml_parser';\nimport { digest } from '../digest';\nimport * as i18n from '../i18n_ast';\nimport { I18nError } from '../parse_util';\nimport * as xml from './xml_helper';\nvar /** @type {?} */ _VERSION = '1.2';\nvar /** @type {?} */ _XMLNS = 'urn:oasis:names:tc:xliff:document:1.2';\n// TODO(vicb): make this a param (s/_/-/)\nvar /** @type {?} */ _SOURCE_LANG = 'en';\nvar /** @type {?} */ _PLACEHOLDER_TAG = 'x';\nvar /** @type {?} */ _SOURCE_TAG = 'source';\nvar /** @type {?} */ _TARGET_TAG = 'target';\nvar /** @type {?} */ _UNIT_TAG = 'trans-unit';\n// http://docs.oasis-open.org/xliff/v1.2/os/xliff-core.html\n// http://docs.oasis-open.org/xliff/v1.2/xliff-profile-html/xliff-profile-html-1.2.html\nexport var Xliff = (function () {\n function Xliff() {\n }\n /**\n * @param {?} messages\n * @return {?}\n */\n Xliff.prototype.write = function (messages) {\n var _this = this;\n var /** @type {?} */ visitor = new _WriteVisitor();\n var /** @type {?} */ visited = {};\n var /** @type {?} */ transUnits = [];\n messages.forEach(function (message) {\n var /** @type {?} */ id = _this.digest(message);\n // deduplicate messages\n if (visited[id])\n return;\n visited[id] = true;\n var /** @type {?} */ transUnit = new xml.Tag(_UNIT_TAG, { id: id, datatype: 'html' });\n transUnit.children.push(new xml.CR(8), new xml.Tag(_SOURCE_TAG, {}, visitor.serialize(message.nodes)), new xml.CR(8), new xml.Tag(_TARGET_TAG));\n if (message.description) {\n transUnit.children.push(new xml.CR(8), new xml.Tag('note', { priority: '1', from: 'description' }, [new xml.Text(message.description)]));\n }\n if (message.meaning) {\n transUnit.children.push(new xml.CR(8), new xml.Tag('note', { priority: '1', from: 'meaning' }, [new xml.Text(message.meaning)]));\n }\n transUnit.children.push(new xml.CR(6));\n transUnits.push(new xml.CR(6), transUnit);\n });\n var /** @type {?} */ body = new xml.Tag('body', {}, transUnits.concat([new xml.CR(4)]));\n var /** @type {?} */ file = new xml.Tag('file', { 'source-language': _SOURCE_LANG, datatype: 'plaintext', original: 'ng2.template' }, [new xml.CR(4), body, new xml.CR(2)]);\n var /** @type {?} */ xliff = new xml.Tag('xliff', { version: _VERSION, xmlns: _XMLNS }, [new xml.CR(2), file, new xml.CR()]);\n return xml.serialize([\n new xml.Declaration({ version: '1.0', encoding: 'UTF-8' }), new xml.CR(), xliff, new xml.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), 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 i18nNodesByMsgId;\n };\n /**\n * @param {?} message\n * @return {?}\n */\n Xliff.prototype.digest = function (message) { return digest(message); };\n return Xliff;\n}());\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 xml.Text(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 xml.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 xml.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 xml.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 xml.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 (_a = []).concat.apply(_a, nodes.map(function (node) { return node.visit(_this); }));\n var _a;\n };\n return _WriteVisitor;\n}());\nfunction _WriteVisitor_tsickle_Closure_declarations() {\n /** @type {?} */\n _WriteVisitor.prototype._isInIcu;\n}\n// TODO(vicb): add error management (structure)\n// Extract messages as xml nodes from the xliff file\nvar XliffParser = (function () {\n function XliffParser() {\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 ml.visitAll(this, xml.rootNodes, null);\n return {\n mlNodesByMsgId: this._mlNodesByMsgId,\n errors: this._errors,\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 ml.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 default:\n // TODO(vicb): assert file structure, xliff version\n // For now only recurse on unhandled nodes\n ml.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}());\nfunction XliffParser_tsickle_Closure_declarations() {\n /** @type {?} */\n XliffParser.prototype._unitMlNodes;\n /** @type {?} */\n XliffParser.prototype._errors;\n /** @type {?} */\n XliffParser.prototype._mlNodesByMsgId;\n}\n// Convert ml nodes (xliff syntax) to i18n nodes\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: ml.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 i18n.Text(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 i18n.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}());\nfunction XmlToI18n_tsickle_Closure_declarations() {\n /** @type {?} */\n XmlToI18n.prototype._errors;\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//# sourceMappingURL=xliff.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/serializers/xliff.js\n// module id = ./node_modules/@angular/compiler/src/i18n/serializers/xliff.js\n// module chunks = 0","/**\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 */\nimport { decimalDigest } from '../digest';\nimport * as xml from './xml_helper';\nvar /** @type {?} */ _MESSAGES_TAG = 'messagebundle';\nvar /** @type {?} */ _MESSAGE_TAG = 'msg';\nvar /** @type {?} */ _PLACEHOLDER_TAG = 'ph';\nvar /** @type {?} */ _EXEMPLE_TAG = 'ex';\nvar /** @type {?} */ _DOCTYPE = \"\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\";\nexport var Xmb = (function () {\n function Xmb() {\n }\n /**\n * @param {?} messages\n * @return {?}\n */\n Xmb.prototype.write = function (messages) {\n var _this = this;\n var /** @type {?} */ exampleVisitor = new ExampleVisitor();\n var /** @type {?} */ visitor = new _Visitor();\n var /** @type {?} */ visited = {};\n var /** @type {?} */ rootNode = new xml.Tag(_MESSAGES_TAG);\n messages.forEach(function (message) {\n var /** @type {?} */ id = _this.digest(message);\n // deduplicate messages\n if (visited[id])\n return;\n visited[id] = true;\n var /** @type {?} */ attrs = { id: 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 xml.CR(2), new xml.Tag(_MESSAGE_TAG, attrs, visitor.serialize(message.nodes)));\n });\n rootNode.children.push(new xml.CR());\n return xml.serialize([\n new xml.Declaration({ version: '1.0', encoding: 'UTF-8' }),\n new xml.CR(),\n new xml.Doctype(_MESSAGES_TAG, _DOCTYPE),\n new xml.CR(),\n exampleVisitor.addDefaultExamples(rootNode),\n new xml.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(message); };\n return Xmb;\n}());\nvar _Visitor = (function () {\n function _Visitor() {\n }\n /**\n * @param {?} text\n * @param {?=} context\n * @return {?}\n */\n _Visitor.prototype.visitText = function (text, context) { return [new xml.Text(text.value)]; };\n /**\n * @param {?} container\n * @param {?=} context\n * @return {?}\n */\n _Visitor.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.prototype.visitIcu = function (icu, context) {\n var _this = this;\n var /** @type {?} */ nodes = [new xml.Text(\"{\" + icu.expressionPlaceholder + \", \" + icu.type + \", \")];\n Object.keys(icu.cases).forEach(function (c) {\n nodes.push.apply(nodes, [new xml.Text(c + \" {\")].concat(icu.cases[c].visit(_this), [new xml.Text(\"} \")]));\n });\n nodes.push(new xml.Text(\"}\"));\n return nodes;\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n _Visitor.prototype.visitTagPlaceholder = function (ph, context) {\n var /** @type {?} */ startEx = new xml.Tag(_EXEMPLE_TAG, {}, [new xml.Text(\"<\" + ph.tag + \">\")]);\n var /** @type {?} */ startTagPh = new xml.Tag(_PLACEHOLDER_TAG, { 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 xml.Tag(_EXEMPLE_TAG, {}, [new xml.Text(\"\")]);\n var /** @type {?} */ closeTagPh = new xml.Tag(_PLACEHOLDER_TAG, { 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.prototype.visitPlaceholder = function (ph, context) {\n return [new xml.Tag(_PLACEHOLDER_TAG, { name: ph.name })];\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n _Visitor.prototype.visitIcuPlaceholder = function (ph, context) {\n return [new xml.Tag(_PLACEHOLDER_TAG, { name: ph.name })];\n };\n /**\n * @param {?} nodes\n * @return {?}\n */\n _Visitor.prototype.serialize = function (nodes) {\n var _this = this;\n return (_a = []).concat.apply(_a, nodes.map(function (node) { return node.visit(_this); }));\n var _a;\n };\n return _Visitor;\n}());\n/**\n * @param {?} message\n * @return {?}\n */\nexport function digest(message) {\n return decimalDigest(message);\n}\n// TC requires at least one non-empty example on placeholders\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) {\n if (!tag.children || tag.children.length == 0) {\n var /** @type {?} */ exText = new xml.Text(tag.attrs['name'] || '...');\n tag.children = [new xml.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//# sourceMappingURL=xmb.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/serializers/xmb.js\n// module id = ./node_modules/@angular/compiler/src/i18n/serializers/xmb.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar _Visitor = (function () {\n function _Visitor() {\n }\n /**\n * @param {?} tag\n * @return {?}\n */\n _Visitor.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.prototype.visitText = function (text) { return text.value; };\n /**\n * @param {?} decl\n * @return {?}\n */\n _Visitor.prototype.visitDeclaration = function (decl) {\n return \"\";\n };\n /**\n * @param {?} attrs\n * @return {?}\n */\n _Visitor.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.prototype.visitDoctype = function (doctype) {\n return \"\";\n };\n return _Visitor;\n}());\nvar /** @type {?} */ _visitor = new _Visitor();\n/**\n * @param {?} nodes\n * @return {?}\n */\nexport function serialize(nodes) {\n return nodes.map(function (node) { return node.visit(_visitor); }).join('');\n}\nexport var 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}());\nfunction Declaration_tsickle_Closure_declarations() {\n /** @type {?} */\n Declaration.prototype.attrs;\n}\nexport var 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}());\nfunction Doctype_tsickle_Closure_declarations() {\n /** @type {?} */\n Doctype.prototype.rootTag;\n /** @type {?} */\n Doctype.prototype.dtd;\n}\nexport var Tag = (function () {\n /**\n * @param {?} name\n * @param {?=} unescapedAttrs\n * @param {?=} children\n */\n function Tag(name, unescapedAttrs, children) {\n var _this = this;\n if (unescapedAttrs === void 0) { unescapedAttrs = {}; }\n if (children === void 0) { children = []; }\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}());\nfunction Tag_tsickle_Closure_declarations() {\n /** @type {?} */\n Tag.prototype.attrs;\n /** @type {?} */\n Tag.prototype.name;\n /** @type {?} */\n Tag.prototype.children;\n}\nexport var Text = (function () {\n /**\n * @param {?} unescapedValue\n */\n function Text(unescapedValue) {\n this.value = _escapeXml(unescapedValue);\n }\n ;\n /**\n * @param {?} visitor\n * @return {?}\n */\n Text.prototype.visit = function (visitor) { return visitor.visitText(this); };\n return Text;\n}());\nfunction Text_tsickle_Closure_declarations() {\n /** @type {?} */\n Text.prototype.value;\n}\nexport var CR = (function (_super) {\n __extends(CR, _super);\n /**\n * @param {?=} ws\n */\n function CR(ws) {\n if (ws === void 0) { ws = 0; }\n _super.call(this, \"\\n\" + new Array(ws + 1).join(' '));\n }\n return CR;\n}(Text));\nvar /** @type {?} */ _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//# sourceMappingURL=xml_helper.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/serializers/xml_helper.js\n// module id = ./node_modules/@angular/compiler/src/i18n/serializers/xml_helper.js\n// module chunks = 0","/**\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 */\nimport * as ml from '../../ml_parser/ast';\nimport { XmlParser } from '../../ml_parser/xml_parser';\nimport * as i18n from '../i18n_ast';\nimport { I18nError } from '../parse_util';\nimport { digest } from './xmb';\nvar /** @type {?} */ _TRANSLATIONS_TAG = 'translationbundle';\nvar /** @type {?} */ _TRANSLATION_TAG = 'translation';\nvar /** @type {?} */ _PLACEHOLDER_TAG = 'ph';\nexport var Xtb = (function () {\n function Xtb() {\n }\n /**\n * @param {?} messages\n * @return {?}\n */\n Xtb.prototype.write = function (messages) { 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), 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(\"xtb parse errors:\\n\" + errors.join('\\n'));\n }\n return i18nNodesByMsgId;\n };\n /**\n * @param {?} message\n * @return {?}\n */\n Xtb.prototype.digest = function (message) { return digest(message); };\n return Xtb;\n}());\n// Extract messages as xml nodes from the xtb file\nvar XtbParser = (function () {\n function XtbParser() {\n }\n /**\n * @param {?} xtb\n * @param {?} url\n * @return {?}\n */\n XtbParser.prototype.parse = function (xtb, url) {\n this._bundleDepth = 0;\n this._mlNodesByMsgId = {};\n var /** @type {?} */ xml = new XmlParser().parse(xtb, url, true);\n this._errors = xml.errors;\n ml.visitAll(this, xml.rootNodes);\n return {\n mlNodesByMsgId: this._mlNodesByMsgId,\n errors: this._errors,\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 ml.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._mlNodesByMsgId.hasOwnProperty(id)) {\n this._addError(element, \"Duplicated translations for msg \" + id);\n }\n else {\n this._mlNodesByMsgId[id] = element.children;\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}());\nfunction XtbParser_tsickle_Closure_declarations() {\n /** @type {?} */\n XtbParser.prototype._bundleDepth;\n /** @type {?} */\n XtbParser.prototype._errors;\n /** @type {?} */\n XtbParser.prototype._mlNodesByMsgId;\n}\n// Convert ml nodes (xtb syntax) to i18n nodes\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: ml.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 i18n.Text(text.value, text.sourceSpan); };\n /**\n * @param {?} icu\n * @param {?} context\n * @return {?}\n */\n XmlToI18n.prototype.visitExpansion = function (icu, context) {\n var /** @type {?} */ caseMap = {};\n ml.visitAll(this, icu.cases).forEach(function (c) {\n caseMap[c.value] = new i18n.Container(c.nodes, icu.sourceSpan);\n });\n return new i18n.Icu(icu.switchValue, icu.type, caseMap, icu.sourceSpan);\n };\n /**\n * @param {?} icuCase\n * @param {?} context\n * @return {?}\n */\n XmlToI18n.prototype.visitExpansionCase = function (icuCase, context) {\n return {\n value: icuCase.value,\n nodes: ml.visitAll(this, icuCase.expression),\n };\n };\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 === 'name'; });\n if (nameAttr) {\n return new i18n.Placeholder('', nameAttr.value, el.sourceSpan);\n }\n this._addError(el, \"<\" + _PLACEHOLDER_TAG + \"> 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.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}());\nfunction XmlToI18n_tsickle_Closure_declarations() {\n /** @type {?} */\n XmlToI18n.prototype._errors;\n}\n//# sourceMappingURL=xtb.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/serializers/xtb.js\n// module id = ./node_modules/@angular/compiler/src/i18n/serializers/xtb.js\n// module chunks = 0","/**\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 */\nimport { HtmlParser } from '../ml_parser/html_parser';\nimport { I18nError } from './parse_util';\n/**\n * A container for translated messages\n */\nexport var TranslationBundle = (function () {\n /**\n * @param {?=} _i18nNodesByMsgId\n * @param {?} digest\n */\n function TranslationBundle(_i18nNodesByMsgId, digest) {\n if (_i18nNodesByMsgId === void 0) { _i18nNodesByMsgId = {}; }\n this._i18nNodesByMsgId = _i18nNodesByMsgId;\n this.digest = digest;\n this._i18nToHtml = new I18nToHtmlVisitor(_i18nNodesByMsgId, digest);\n }\n /**\n * @param {?} content\n * @param {?} url\n * @param {?} serializer\n * @return {?}\n */\n TranslationBundle.load = function (content, url, serializer) {\n var /** @type {?} */ i18nNodesByMsgId = serializer.load(content, url);\n var /** @type {?} */ digestFn = function (m) { return serializer.digest(m); };\n return new TranslationBundle(i18nNodesByMsgId, digestFn);\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}());\nfunction TranslationBundle_tsickle_Closure_declarations() {\n /** @type {?} */\n TranslationBundle.prototype._i18nToHtml;\n /** @type {?} */\n TranslationBundle.prototype._i18nNodesByMsgId;\n /** @type {?} */\n TranslationBundle.prototype.digest;\n}\nvar I18nToHtmlVisitor = (function () {\n /**\n * @param {?=} _i18nNodesByMsgId\n * @param {?} _digest\n */\n function I18nToHtmlVisitor(_i18nNodesByMsgId, _digest) {\n if (_i18nNodesByMsgId === void 0) { _i18nNodesByMsgId = {}; }\n this._i18nNodesByMsgId = _i18nNodesByMsgId;\n this._digest = _digest;\n this._srcMsgStack = [];\n this._errors = [];\n }\n /**\n * @param {?} srcMsg\n * @return {?}\n */\n I18nToHtmlVisitor.prototype.convert = function (srcMsg) {\n this._srcMsgStack.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 = 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\");\n return '';\n };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n I18nToHtmlVisitor.prototype.visitTagPlaceholder = function (ph, context) { throw 'unreachable code'; };\n /**\n * @param {?} ph\n * @param {?=} context\n * @return {?}\n */\n I18nToHtmlVisitor.prototype.visitIcuPlaceholder = function (ph, context) { throw 'unreachable code'; };\n /**\n * @param {?} srcMsg\n * @return {?}\n */\n I18nToHtmlVisitor.prototype._convertToText = function (srcMsg) {\n var _this = this;\n var /** @type {?} */ digest = this._digest(srcMsg);\n if (this._i18nNodesByMsgId.hasOwnProperty(digest)) {\n this._srcMsgStack.push(this._srcMsg);\n this._srcMsg = srcMsg;\n var /** @type {?} */ nodes = this._i18nNodesByMsgId[digest];\n var /** @type {?} */ text = nodes.map(function (node) { return node.visit(_this); }).join('');\n this._srcMsg = this._srcMsgStack.pop();\n return text;\n }\n this._addError(srcMsg.nodes[0], \"Missing translation for message \" + digest);\n return '';\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}());\nfunction I18nToHtmlVisitor_tsickle_Closure_declarations() {\n /** @type {?} */\n I18nToHtmlVisitor.prototype._srcMsg;\n /** @type {?} */\n I18nToHtmlVisitor.prototype._srcMsgStack;\n /** @type {?} */\n I18nToHtmlVisitor.prototype._errors;\n /** @type {?} */\n I18nToHtmlVisitor.prototype._i18nNodesByMsgId;\n /** @type {?} */\n I18nToHtmlVisitor.prototype._digest;\n}\n//# sourceMappingURL=translation_bundle.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/i18n/translation_bundle.js\n// module id = ./node_modules/@angular/compiler/src/i18n/translation_bundle.js\n// module chunks = 0","/**\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 */\nimport { ANALYZE_FOR_ENTRY_COMPONENTS, ChangeDetectionStrategy, ChangeDetectorRef, ComponentFactory, ComponentFactoryResolver, ComponentRef, ElementRef, Injector, LOCALE_ID, NgModuleFactory, QueryList, RenderComponentType, Renderer, SecurityContext, SimpleChange, TRANSLATIONS_FORMAT, TemplateRef, ViewContainerRef, ViewEncapsulation } from '@angular/core';\nimport { AnimationGroupPlayer, AnimationKeyframe, AnimationSequencePlayer, AnimationStyles, AnimationTransition, AppView, ChangeDetectorStatus, CodegenComponentFactoryResolver, ComponentRef_, DebugAppView, DebugContext, NgModuleInjector, NoOpAnimationPlayer, StaticNodeDebugInfo, TemplateRef_, UNINITIALIZED, ValueUnwrapper, ViewContainer, ViewType, balanceAnimationKeyframes, clearStyles, collectAndResolveStyles, devModeEqual, prepareFinalAnimationStyles, reflector, registerModuleFactory, renderStyles, view_utils } from './private_import_core';\nvar /** @type {?} */ APP_VIEW_MODULE_URL = assetUrl('core', 'linker/view');\nvar /** @type {?} */ VIEW_UTILS_MODULE_URL = assetUrl('core', 'linker/view_utils');\nvar /** @type {?} */ CD_MODULE_URL = assetUrl('core', 'change_detection/change_detection');\nvar /** @type {?} */ ANIMATION_STYLE_UTIL_ASSET_URL = assetUrl('core', 'animation/animation_style_util');\nexport var Identifiers = (function () {\n function Identifiers() {\n }\n Identifiers.ANALYZE_FOR_ENTRY_COMPONENTS = {\n name: 'ANALYZE_FOR_ENTRY_COMPONENTS',\n moduleUrl: assetUrl('core', 'metadata/di'),\n runtime: ANALYZE_FOR_ENTRY_COMPONENTS\n };\n Identifiers.ViewUtils = {\n name: 'ViewUtils',\n moduleUrl: assetUrl('core', 'linker/view_utils'),\n runtime: view_utils.ViewUtils\n };\n Identifiers.AppView = { name: 'AppView', moduleUrl: APP_VIEW_MODULE_URL, runtime: AppView };\n Identifiers.DebugAppView = {\n name: 'DebugAppView',\n moduleUrl: APP_VIEW_MODULE_URL,\n runtime: DebugAppView\n };\n Identifiers.ViewContainer = {\n name: 'ViewContainer',\n moduleUrl: assetUrl('core', 'linker/view_container'),\n runtime: ViewContainer\n };\n Identifiers.ElementRef = {\n name: 'ElementRef',\n moduleUrl: assetUrl('core', 'linker/element_ref'),\n runtime: ElementRef\n };\n Identifiers.ViewContainerRef = {\n name: 'ViewContainerRef',\n moduleUrl: assetUrl('core', 'linker/view_container_ref'),\n runtime: ViewContainerRef\n };\n Identifiers.ChangeDetectorRef = {\n name: 'ChangeDetectorRef',\n moduleUrl: assetUrl('core', 'change_detection/change_detector_ref'),\n runtime: ChangeDetectorRef\n };\n Identifiers.RenderComponentType = {\n name: 'RenderComponentType',\n moduleUrl: assetUrl('core', 'render/api'),\n runtime: RenderComponentType\n };\n Identifiers.QueryList = {\n name: 'QueryList',\n moduleUrl: assetUrl('core', 'linker/query_list'),\n runtime: QueryList\n };\n Identifiers.TemplateRef = {\n name: 'TemplateRef',\n moduleUrl: assetUrl('core', 'linker/template_ref'),\n runtime: TemplateRef\n };\n Identifiers.TemplateRef_ = {\n name: 'TemplateRef_',\n moduleUrl: assetUrl('core', 'linker/template_ref'),\n runtime: TemplateRef_\n };\n Identifiers.CodegenComponentFactoryResolver = {\n name: 'CodegenComponentFactoryResolver',\n moduleUrl: assetUrl('core', 'linker/component_factory_resolver'),\n runtime: CodegenComponentFactoryResolver\n };\n Identifiers.ComponentFactoryResolver = {\n name: 'ComponentFactoryResolver',\n moduleUrl: assetUrl('core', 'linker/component_factory_resolver'),\n runtime: ComponentFactoryResolver\n };\n Identifiers.ComponentFactory = {\n name: 'ComponentFactory',\n runtime: ComponentFactory,\n moduleUrl: assetUrl('core', 'linker/component_factory')\n };\n Identifiers.ComponentRef_ = {\n name: 'ComponentRef_',\n runtime: ComponentRef_,\n moduleUrl: assetUrl('core', 'linker/component_factory')\n };\n Identifiers.ComponentRef = {\n name: 'ComponentRef',\n runtime: ComponentRef,\n moduleUrl: assetUrl('core', 'linker/component_factory')\n };\n Identifiers.NgModuleFactory = {\n name: 'NgModuleFactory',\n runtime: NgModuleFactory,\n moduleUrl: assetUrl('core', 'linker/ng_module_factory')\n };\n Identifiers.NgModuleInjector = {\n name: 'NgModuleInjector',\n runtime: NgModuleInjector,\n moduleUrl: assetUrl('core', 'linker/ng_module_factory')\n };\n Identifiers.RegisterModuleFactoryFn = {\n name: 'registerModuleFactory',\n runtime: registerModuleFactory,\n moduleUrl: assetUrl('core', 'linker/ng_module_factory_loader')\n };\n Identifiers.ValueUnwrapper = { name: 'ValueUnwrapper', moduleUrl: CD_MODULE_URL, runtime: ValueUnwrapper };\n Identifiers.Injector = {\n name: 'Injector',\n moduleUrl: assetUrl('core', 'di/injector'),\n runtime: Injector\n };\n Identifiers.ViewEncapsulation = {\n name: 'ViewEncapsulation',\n moduleUrl: assetUrl('core', 'metadata/view'),\n runtime: ViewEncapsulation\n };\n Identifiers.ViewType = {\n name: 'ViewType',\n moduleUrl: assetUrl('core', 'linker/view_type'),\n runtime: ViewType\n };\n Identifiers.ChangeDetectionStrategy = {\n name: 'ChangeDetectionStrategy',\n moduleUrl: CD_MODULE_URL,\n runtime: ChangeDetectionStrategy\n };\n Identifiers.StaticNodeDebugInfo = {\n name: 'StaticNodeDebugInfo',\n moduleUrl: assetUrl('core', 'linker/debug_context'),\n runtime: StaticNodeDebugInfo\n };\n Identifiers.DebugContext = {\n name: 'DebugContext',\n moduleUrl: assetUrl('core', 'linker/debug_context'),\n runtime: DebugContext\n };\n Identifiers.Renderer = {\n name: 'Renderer',\n moduleUrl: assetUrl('core', 'render/api'),\n runtime: Renderer\n };\n Identifiers.SimpleChange = { name: 'SimpleChange', moduleUrl: CD_MODULE_URL, runtime: SimpleChange };\n Identifiers.UNINITIALIZED = { name: 'UNINITIALIZED', moduleUrl: CD_MODULE_URL, runtime: UNINITIALIZED };\n Identifiers.ChangeDetectorStatus = {\n name: 'ChangeDetectorStatus',\n moduleUrl: CD_MODULE_URL,\n runtime: ChangeDetectorStatus\n };\n Identifiers.checkBinding = {\n name: 'checkBinding',\n moduleUrl: VIEW_UTILS_MODULE_URL,\n runtime: view_utils.checkBinding\n };\n Identifiers.devModeEqual = { name: 'devModeEqual', moduleUrl: CD_MODULE_URL, runtime: devModeEqual };\n Identifiers.inlineInterpolate = {\n name: 'inlineInterpolate',\n moduleUrl: VIEW_UTILS_MODULE_URL,\n runtime: view_utils.inlineInterpolate\n };\n Identifiers.interpolate = {\n name: 'interpolate',\n moduleUrl: VIEW_UTILS_MODULE_URL,\n runtime: view_utils.interpolate\n };\n Identifiers.castByValue = {\n name: 'castByValue',\n moduleUrl: VIEW_UTILS_MODULE_URL,\n runtime: view_utils.castByValue\n };\n Identifiers.EMPTY_ARRAY = {\n name: 'EMPTY_ARRAY',\n moduleUrl: VIEW_UTILS_MODULE_URL,\n runtime: view_utils.EMPTY_ARRAY\n };\n Identifiers.EMPTY_MAP = {\n name: 'EMPTY_MAP',\n moduleUrl: VIEW_UTILS_MODULE_URL,\n runtime: view_utils.EMPTY_MAP\n };\n Identifiers.createRenderElement = {\n name: 'createRenderElement',\n moduleUrl: VIEW_UTILS_MODULE_URL,\n runtime: view_utils.createRenderElement\n };\n Identifiers.selectOrCreateRenderHostElement = {\n name: 'selectOrCreateRenderHostElement',\n moduleUrl: VIEW_UTILS_MODULE_URL,\n runtime: view_utils.selectOrCreateRenderHostElement\n };\n Identifiers.pureProxies = [\n null,\n { name: 'pureProxy1', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy1 },\n { name: 'pureProxy2', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy2 },\n { name: 'pureProxy3', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy3 },\n { name: 'pureProxy4', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy4 },\n { name: 'pureProxy5', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy5 },\n { name: 'pureProxy6', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy6 },\n { name: 'pureProxy7', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy7 },\n { name: 'pureProxy8', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy8 },\n { name: 'pureProxy9', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy9 },\n { name: 'pureProxy10', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy10 },\n ];\n Identifiers.SecurityContext = {\n name: 'SecurityContext',\n moduleUrl: assetUrl('core', 'security'),\n runtime: SecurityContext,\n };\n Identifiers.AnimationKeyframe = {\n name: 'AnimationKeyframe',\n moduleUrl: assetUrl('core', 'animation/animation_keyframe'),\n runtime: AnimationKeyframe\n };\n Identifiers.AnimationStyles = {\n name: 'AnimationStyles',\n moduleUrl: assetUrl('core', 'animation/animation_styles'),\n runtime: AnimationStyles\n };\n Identifiers.NoOpAnimationPlayer = {\n name: 'NoOpAnimationPlayer',\n moduleUrl: assetUrl('core', 'animation/animation_player'),\n runtime: NoOpAnimationPlayer\n };\n Identifiers.AnimationGroupPlayer = {\n name: 'AnimationGroupPlayer',\n moduleUrl: assetUrl('core', 'animation/animation_group_player'),\n runtime: AnimationGroupPlayer\n };\n Identifiers.AnimationSequencePlayer = {\n name: 'AnimationSequencePlayer',\n moduleUrl: assetUrl('core', 'animation/animation_sequence_player'),\n runtime: AnimationSequencePlayer\n };\n Identifiers.prepareFinalAnimationStyles = {\n name: 'prepareFinalAnimationStyles',\n moduleUrl: ANIMATION_STYLE_UTIL_ASSET_URL,\n runtime: prepareFinalAnimationStyles\n };\n Identifiers.balanceAnimationKeyframes = {\n name: 'balanceAnimationKeyframes',\n moduleUrl: ANIMATION_STYLE_UTIL_ASSET_URL,\n runtime: balanceAnimationKeyframes\n };\n Identifiers.clearStyles = {\n name: 'clearStyles',\n moduleUrl: ANIMATION_STYLE_UTIL_ASSET_URL,\n runtime: clearStyles\n };\n Identifiers.renderStyles = {\n name: 'renderStyles',\n moduleUrl: ANIMATION_STYLE_UTIL_ASSET_URL,\n runtime: renderStyles\n };\n Identifiers.collectAndResolveStyles = {\n name: 'collectAndResolveStyles',\n moduleUrl: ANIMATION_STYLE_UTIL_ASSET_URL,\n runtime: collectAndResolveStyles\n };\n Identifiers.LOCALE_ID = {\n name: 'LOCALE_ID',\n moduleUrl: assetUrl('core', 'i18n/tokens'),\n runtime: LOCALE_ID\n };\n Identifiers.TRANSLATIONS_FORMAT = {\n name: 'TRANSLATIONS_FORMAT',\n moduleUrl: assetUrl('core', 'i18n/tokens'),\n runtime: TRANSLATIONS_FORMAT\n };\n Identifiers.setBindingDebugInfo = {\n name: 'setBindingDebugInfo',\n moduleUrl: VIEW_UTILS_MODULE_URL,\n runtime: view_utils.setBindingDebugInfo\n };\n Identifiers.setBindingDebugInfoForChanges = {\n name: 'setBindingDebugInfoForChanges',\n moduleUrl: VIEW_UTILS_MODULE_URL,\n runtime: view_utils.setBindingDebugInfoForChanges\n };\n Identifiers.AnimationTransition = {\n name: 'AnimationTransition',\n moduleUrl: assetUrl('core', 'animation/animation_transition'),\n runtime: AnimationTransition\n };\n // This is just the interface!\n Identifiers.InlineArray = { name: 'InlineArray', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: null };\n Identifiers.inlineArrays = [\n { name: 'InlineArray2', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.InlineArray2 },\n { name: 'InlineArray2', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.InlineArray2 },\n { name: 'InlineArray4', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.InlineArray4 },\n { name: 'InlineArray8', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.InlineArray8 },\n { name: 'InlineArray16', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.InlineArray16 },\n ];\n Identifiers.EMPTY_INLINE_ARRAY = {\n name: 'EMPTY_INLINE_ARRAY',\n moduleUrl: VIEW_UTILS_MODULE_URL,\n runtime: view_utils.EMPTY_INLINE_ARRAY\n };\n Identifiers.InlineArrayDynamic = {\n name: 'InlineArrayDynamic',\n moduleUrl: VIEW_UTILS_MODULE_URL,\n runtime: view_utils.InlineArrayDynamic\n };\n Identifiers.subscribeToRenderElement = {\n name: 'subscribeToRenderElement',\n moduleUrl: VIEW_UTILS_MODULE_URL,\n runtime: view_utils.subscribeToRenderElement\n };\n Identifiers.createRenderComponentType = {\n name: 'createRenderComponentType',\n moduleUrl: VIEW_UTILS_MODULE_URL,\n runtime: view_utils.createRenderComponentType\n };\n Identifiers.noop = { name: 'noop', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.noop };\n return Identifiers;\n}());\nfunction Identifiers_tsickle_Closure_declarations() {\n /** @type {?} */\n Identifiers.ANALYZE_FOR_ENTRY_COMPONENTS;\n /** @type {?} */\n Identifiers.ViewUtils;\n /** @type {?} */\n Identifiers.AppView;\n /** @type {?} */\n Identifiers.DebugAppView;\n /** @type {?} */\n Identifiers.ViewContainer;\n /** @type {?} */\n Identifiers.ElementRef;\n /** @type {?} */\n Identifiers.ViewContainerRef;\n /** @type {?} */\n Identifiers.ChangeDetectorRef;\n /** @type {?} */\n Identifiers.RenderComponentType;\n /** @type {?} */\n Identifiers.QueryList;\n /** @type {?} */\n Identifiers.TemplateRef;\n /** @type {?} */\n Identifiers.TemplateRef_;\n /** @type {?} */\n Identifiers.CodegenComponentFactoryResolver;\n /** @type {?} */\n Identifiers.ComponentFactoryResolver;\n /** @type {?} */\n Identifiers.ComponentFactory;\n /** @type {?} */\n Identifiers.ComponentRef_;\n /** @type {?} */\n Identifiers.ComponentRef;\n /** @type {?} */\n Identifiers.NgModuleFactory;\n /** @type {?} */\n Identifiers.NgModuleInjector;\n /** @type {?} */\n Identifiers.RegisterModuleFactoryFn;\n /** @type {?} */\n Identifiers.ValueUnwrapper;\n /** @type {?} */\n Identifiers.Injector;\n /** @type {?} */\n Identifiers.ViewEncapsulation;\n /** @type {?} */\n Identifiers.ViewType;\n /** @type {?} */\n Identifiers.ChangeDetectionStrategy;\n /** @type {?} */\n Identifiers.StaticNodeDebugInfo;\n /** @type {?} */\n Identifiers.DebugContext;\n /** @type {?} */\n Identifiers.Renderer;\n /** @type {?} */\n Identifiers.SimpleChange;\n /** @type {?} */\n Identifiers.UNINITIALIZED;\n /** @type {?} */\n Identifiers.ChangeDetectorStatus;\n /** @type {?} */\n Identifiers.checkBinding;\n /** @type {?} */\n Identifiers.devModeEqual;\n /** @type {?} */\n Identifiers.inlineInterpolate;\n /** @type {?} */\n Identifiers.interpolate;\n /** @type {?} */\n Identifiers.castByValue;\n /** @type {?} */\n Identifiers.EMPTY_ARRAY;\n /** @type {?} */\n Identifiers.EMPTY_MAP;\n /** @type {?} */\n Identifiers.createRenderElement;\n /** @type {?} */\n Identifiers.selectOrCreateRenderHostElement;\n /** @type {?} */\n Identifiers.pureProxies;\n /** @type {?} */\n Identifiers.SecurityContext;\n /** @type {?} */\n Identifiers.AnimationKeyframe;\n /** @type {?} */\n Identifiers.AnimationStyles;\n /** @type {?} */\n Identifiers.NoOpAnimationPlayer;\n /** @type {?} */\n Identifiers.AnimationGroupPlayer;\n /** @type {?} */\n Identifiers.AnimationSequencePlayer;\n /** @type {?} */\n Identifiers.prepareFinalAnimationStyles;\n /** @type {?} */\n Identifiers.balanceAnimationKeyframes;\n /** @type {?} */\n Identifiers.clearStyles;\n /** @type {?} */\n Identifiers.renderStyles;\n /** @type {?} */\n Identifiers.collectAndResolveStyles;\n /** @type {?} */\n Identifiers.LOCALE_ID;\n /** @type {?} */\n Identifiers.TRANSLATIONS_FORMAT;\n /** @type {?} */\n Identifiers.setBindingDebugInfo;\n /** @type {?} */\n Identifiers.setBindingDebugInfoForChanges;\n /** @type {?} */\n Identifiers.AnimationTransition;\n /** @type {?} */\n Identifiers.InlineArray;\n /** @type {?} */\n Identifiers.inlineArrays;\n /** @type {?} */\n Identifiers.EMPTY_INLINE_ARRAY;\n /** @type {?} */\n Identifiers.InlineArrayDynamic;\n /** @type {?} */\n Identifiers.subscribeToRenderElement;\n /** @type {?} */\n Identifiers.createRenderComponentType;\n /** @type {?} */\n Identifiers.noop;\n}\n/**\n * @param {?} pkg\n * @param {?=} path\n * @param {?=} type\n * @return {?}\n */\nexport function 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 + \"/index\";\n }\n else {\n return \"@angular/\" + pkg + \"/\" + type + \"/\" + path;\n }\n}\n/**\n * @param {?} identifier\n * @return {?}\n */\nexport function resolveIdentifier(identifier) {\n return reflector.resolveIdentifier(identifier.name, identifier.moduleUrl, identifier.runtime);\n}\n/**\n * @param {?} identifier\n * @return {?}\n */\nexport function createIdentifier(identifier) {\n var /** @type {?} */ reference = reflector.resolveIdentifier(identifier.name, identifier.moduleUrl, identifier.runtime);\n return { reference: reference };\n}\n/**\n * @param {?} identifier\n * @return {?}\n */\nexport function identifierToken(identifier) {\n return { identifier: identifier };\n}\n/**\n * @param {?} identifier\n * @return {?}\n */\nexport function createIdentifierToken(identifier) {\n return identifierToken(createIdentifier(identifier));\n}\n/**\n * @param {?} enumType\n * @param {?} name\n * @return {?}\n */\nexport function createEnumIdentifier(enumType, name) {\n var /** @type {?} */ resolvedEnum = reflector.resolveEnum(resolveIdentifier(enumType), name);\n return { reference: resolvedEnum };\n}\n//# sourceMappingURL=identifiers.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/identifiers.js\n// module id = ./node_modules/@angular/compiler/src/identifiers.js\n// module chunks = 0","/**\n * A replacement for @Injectable to be used in the compiler, so that\n * we don't try to evaluate the metadata in the compiler during AoT.\n * This decorator is enough to make the compiler work with the ReflectiveInjector though.\n * @return {?}\n */\nexport function CompilerInjectable() {\n return function (x) { return x; };\n}\n//# sourceMappingURL=injectable.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/injectable.js\n// module id = ./node_modules/@angular/compiler/src/injectable.js\n// module chunks = 0","/**\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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { Compiler, ComponentFactory, Injector, ModuleWithComponentFactories } from '@angular/core';\nimport { AnimationCompiler } from '../animation/animation_compiler';\nimport { AnimationParser } from '../animation/animation_parser';\nimport { ProviderMeta, createHostComponentMeta, identifierName } from '../compile_metadata';\nimport { CompilerConfig } from '../config';\nimport { DirectiveWrapperCompiler } from '../directive_wrapper_compiler';\nimport { stringify } from '../facade/lang';\nimport { CompilerInjectable } from '../injectable';\nimport { CompileMetadataResolver } from '../metadata_resolver';\nimport { NgModuleCompiler } from '../ng_module_compiler';\nimport * as ir from '../output/output_ast';\nimport { interpretStatements } from '../output/output_interpreter';\nimport { jitStatements } from '../output/output_jit';\nimport { StyleCompiler } from '../style_compiler';\nimport { TemplateParser } from '../template_parser/template_parser';\nimport { SyncAsyncResult } from '../util';\nimport { ComponentFactoryDependency, DirectiveWrapperDependency, ViewClassDependency, ViewCompiler } from '../view_compiler/view_compiler';\n/**\n * An internal module of the Angular compiler that begins with component types,\n * extracts templates, and eventually produces a compiled version of the component\n * ready for linking into an application.\n * *\n * from a trusted source. Attacker-controlled data introduced by a template could expose your\n * application to XSS risks. For more detail, see the [Security Guide](http://g.co/ng/security).\n */\nexport var JitCompiler = (function () {\n /**\n * @param {?} _injector\n * @param {?} _metadataResolver\n * @param {?} _templateParser\n * @param {?} _styleCompiler\n * @param {?} _viewCompiler\n * @param {?} _ngModuleCompiler\n * @param {?} _directiveWrapperCompiler\n * @param {?} _compilerConfig\n * @param {?} _animationParser\n */\n function JitCompiler(_injector, _metadataResolver, _templateParser, _styleCompiler, _viewCompiler, _ngModuleCompiler, _directiveWrapperCompiler, _compilerConfig, _animationParser) {\n this._injector = _injector;\n this._metadataResolver = _metadataResolver;\n this._templateParser = _templateParser;\n this._styleCompiler = _styleCompiler;\n this._viewCompiler = _viewCompiler;\n this._ngModuleCompiler = _ngModuleCompiler;\n this._directiveWrapperCompiler = _directiveWrapperCompiler;\n this._compilerConfig = _compilerConfig;\n this._animationParser = _animationParser;\n this._compiledTemplateCache = new Map();\n this._compiledHostTemplateCache = new Map();\n this._compiledDirectiveWrapperCache = new Map();\n this._compiledNgModuleCache = new Map();\n this._animationCompiler = new AnimationCompiler();\n }\n Object.defineProperty(JitCompiler.prototype, \"injector\", {\n /**\n * @return {?}\n */\n get: function () { return this._injector; },\n enumerable: true,\n configurable: true\n });\n /**\n * @param {?} moduleType\n * @return {?}\n */\n JitCompiler.prototype.compileModuleSync = function (moduleType) {\n return this._compileModuleAndComponents(moduleType, true).syncResult;\n };\n /**\n * @param {?} moduleType\n * @return {?}\n */\n JitCompiler.prototype.compileModuleAsync = function (moduleType) {\n return this._compileModuleAndComponents(moduleType, false).asyncResult;\n };\n /**\n * @param {?} moduleType\n * @return {?}\n */\n JitCompiler.prototype.compileModuleAndAllComponentsSync = function (moduleType) {\n return this._compileModuleAndAllComponents(moduleType, true).syncResult;\n };\n /**\n * @param {?} moduleType\n * @return {?}\n */\n JitCompiler.prototype.compileModuleAndAllComponentsAsync = function (moduleType) {\n return this._compileModuleAndAllComponents(moduleType, false).asyncResult;\n };\n /**\n * @param {?} component\n * @return {?}\n */\n JitCompiler.prototype.getNgContentSelectors = function (component) {\n var /** @type {?} */ template = this._compiledTemplateCache.get(component);\n if (!template) {\n throw new Error(\"The component \" + stringify(component) + \" is not yet compiled!\");\n }\n return template.compMeta.template.ngContentSelectors;\n };\n /**\n * @param {?} moduleType\n * @param {?} isSync\n * @return {?}\n */\n JitCompiler.prototype._compileModuleAndComponents = function (moduleType, isSync) {\n var _this = this;\n var /** @type {?} */ loadingPromise = this._loadModules(moduleType, isSync);\n var /** @type {?} */ createResult = function () {\n _this._compileComponents(moduleType, null);\n return _this._compileModule(moduleType);\n };\n if (isSync) {\n return new SyncAsyncResult(createResult());\n }\n else {\n return new SyncAsyncResult(null, loadingPromise.then(createResult));\n }\n };\n /**\n * @param {?} moduleType\n * @param {?} isSync\n * @return {?}\n */\n JitCompiler.prototype._compileModuleAndAllComponents = function (moduleType, isSync) {\n var _this = this;\n var /** @type {?} */ loadingPromise = this._loadModules(moduleType, isSync);\n var /** @type {?} */ createResult = function () {\n var /** @type {?} */ componentFactories = [];\n _this._compileComponents(moduleType, componentFactories);\n return new ModuleWithComponentFactories(_this._compileModule(moduleType), componentFactories);\n };\n if (isSync) {\n return new SyncAsyncResult(createResult());\n }\n else {\n return new SyncAsyncResult(null, loadingPromise.then(createResult));\n }\n };\n /**\n * @param {?} mainModule\n * @param {?} isSync\n * @return {?}\n */\n JitCompiler.prototype._loadModules = function (mainModule, isSync) {\n var _this = this;\n var /** @type {?} */ loadingPromises = [];\n var /** @type {?} */ ngModule = this._metadataResolver.getNgModuleMetadata(mainModule);\n // Note: the loadingPromise for a module only includes the loading of the exported directives\n // of imported modules.\n // However, for runtime compilation, we want to transitively compile all modules,\n // so we also need to call loadNgModuleMetadata for all nested modules.\n ngModule.transitiveModule.modules.forEach(function (localModuleMeta) {\n loadingPromises.push(_this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(localModuleMeta.reference, isSync));\n });\n return Promise.all(loadingPromises);\n };\n /**\n * @param {?} moduleType\n * @return {?}\n */\n JitCompiler.prototype._compileModule = function (moduleType) {\n var _this = this;\n var /** @type {?} */ ngModuleFactory = this._compiledNgModuleCache.get(moduleType);\n if (!ngModuleFactory) {\n var /** @type {?} */ moduleMeta_1 = this._metadataResolver.getNgModuleMetadata(moduleType);\n // Always provide a bound Compiler\n var /** @type {?} */ extraProviders = [this._metadataResolver.getProviderMetadata(new ProviderMeta(Compiler, { useFactory: function () { return new ModuleBoundCompiler(_this, moduleMeta_1.type.reference); } }))];\n var /** @type {?} */ compileResult = this._ngModuleCompiler.compile(moduleMeta_1, extraProviders);\n compileResult.dependencies.forEach(function (dep) {\n dep.placeholder.reference =\n _this._assertComponentKnown(dep.comp.reference, true).proxyComponentFactory;\n });\n if (!this._compilerConfig.useJit) {\n ngModuleFactory =\n interpretStatements(compileResult.statements, compileResult.ngModuleFactoryVar);\n }\n else {\n ngModuleFactory = jitStatements(\"/\" + identifierName(moduleMeta_1.type) + \"/module.ngfactory.js\", compileResult.statements, compileResult.ngModuleFactoryVar);\n }\n this._compiledNgModuleCache.set(moduleMeta_1.type.reference, ngModuleFactory);\n }\n return ngModuleFactory;\n };\n /**\n * @param {?} mainModule\n * @param {?} allComponentFactories\n * @return {?}\n */\n JitCompiler.prototype._compileComponents = function (mainModule, allComponentFactories) {\n var _this = this;\n var /** @type {?} */ ngModule = this._metadataResolver.getNgModuleMetadata(mainModule);\n var /** @type {?} */ moduleByDirective = new Map();\n var /** @type {?} */ templates = new Set();\n ngModule.transitiveModule.modules.forEach(function (localModuleSummary) {\n var /** @type {?} */ localModuleMeta = _this._metadataResolver.getNgModuleMetadata(localModuleSummary.reference);\n localModuleMeta.declaredDirectives.forEach(function (dirIdentifier) {\n moduleByDirective.set(dirIdentifier.reference, localModuleMeta);\n var /** @type {?} */ dirMeta = _this._metadataResolver.getDirectiveMetadata(dirIdentifier.reference);\n _this._compileDirectiveWrapper(dirMeta, localModuleMeta);\n if (dirMeta.isComponent) {\n templates.add(_this._createCompiledTemplate(dirMeta, localModuleMeta));\n if (allComponentFactories) {\n var /** @type {?} */ template = _this._createCompiledHostTemplate(dirMeta.type.reference, localModuleMeta);\n templates.add(template);\n allComponentFactories.push(template.proxyComponentFactory);\n }\n }\n });\n });\n ngModule.transitiveModule.modules.forEach(function (localModuleSummary) {\n var /** @type {?} */ localModuleMeta = _this._metadataResolver.getNgModuleMetadata(localModuleSummary.reference);\n localModuleMeta.declaredDirectives.forEach(function (dirIdentifier) {\n var /** @type {?} */ dirMeta = _this._metadataResolver.getDirectiveMetadata(dirIdentifier.reference);\n if (dirMeta.isComponent) {\n dirMeta.entryComponents.forEach(function (entryComponentType) {\n var /** @type {?} */ moduleMeta = moduleByDirective.get(entryComponentType.reference);\n templates.add(_this._createCompiledHostTemplate(entryComponentType.reference, moduleMeta));\n });\n }\n });\n localModuleMeta.entryComponents.forEach(function (entryComponentType) {\n var /** @type {?} */ moduleMeta = moduleByDirective.get(entryComponentType.reference);\n templates.add(_this._createCompiledHostTemplate(entryComponentType.reference, moduleMeta));\n });\n });\n templates.forEach(function (template) { return _this._compileTemplate(template); });\n };\n /**\n * @param {?} type\n * @return {?}\n */\n JitCompiler.prototype.clearCacheFor = function (type) {\n this._compiledNgModuleCache.delete(type);\n this._metadataResolver.clearCacheFor(type);\n this._compiledHostTemplateCache.delete(type);\n var /** @type {?} */ compiledTemplate = this._compiledTemplateCache.get(type);\n if (compiledTemplate) {\n this._compiledTemplateCache.delete(type);\n }\n };\n /**\n * @return {?}\n */\n JitCompiler.prototype.clearCache = function () {\n this._metadataResolver.clearCache();\n this._compiledTemplateCache.clear();\n this._compiledHostTemplateCache.clear();\n this._compiledNgModuleCache.clear();\n };\n /**\n * @param {?} compType\n * @param {?} ngModule\n * @return {?}\n */\n JitCompiler.prototype._createCompiledHostTemplate = function (compType, ngModule) {\n if (!ngModule) {\n throw new Error(\"Component \" + stringify(compType) + \" is not part of any NgModule or the module has not been imported into your module.\");\n }\n var /** @type {?} */ compiledTemplate = this._compiledHostTemplateCache.get(compType);\n if (!compiledTemplate) {\n var /** @type {?} */ compMeta = this._metadataResolver.getDirectiveMetadata(compType);\n assertComponent(compMeta);\n var /** @type {?} */ HostClass = function HostClass() { };\n ((HostClass)).overriddenName = identifierName(compMeta.type) + \"_Host\";\n var /** @type {?} */ hostMeta = createHostComponentMeta(HostClass, compMeta);\n compiledTemplate = new CompiledTemplate(true, compMeta.selector, compMeta.type, hostMeta, ngModule, [compMeta.type]);\n this._compiledHostTemplateCache.set(compType, compiledTemplate);\n }\n return compiledTemplate;\n };\n /**\n * @param {?} compMeta\n * @param {?} ngModule\n * @return {?}\n */\n JitCompiler.prototype._createCompiledTemplate = function (compMeta, ngModule) {\n var /** @type {?} */ compiledTemplate = this._compiledTemplateCache.get(compMeta.type.reference);\n if (!compiledTemplate) {\n assertComponent(compMeta);\n compiledTemplate = new CompiledTemplate(false, compMeta.selector, compMeta.type, compMeta, ngModule, ngModule.transitiveModule.directives);\n this._compiledTemplateCache.set(compMeta.type.reference, compiledTemplate);\n }\n return compiledTemplate;\n };\n /**\n * @param {?} compType\n * @param {?} isHost\n * @return {?}\n */\n JitCompiler.prototype._assertComponentKnown = function (compType, isHost) {\n var /** @type {?} */ compiledTemplate = isHost ? this._compiledHostTemplateCache.get(compType) :\n this._compiledTemplateCache.get(compType);\n if (!compiledTemplate) {\n throw new Error(\"Illegal state: Compiled view for component \" + stringify(compType) + \" (host: \" + isHost + \") does not exist!\");\n }\n return compiledTemplate;\n };\n /**\n * @param {?} dirType\n * @return {?}\n */\n JitCompiler.prototype._assertDirectiveWrapper = function (dirType) {\n var /** @type {?} */ dirWrapper = this._compiledDirectiveWrapperCache.get(dirType);\n if (!dirWrapper) {\n throw new Error(\"Illegal state: Directive wrapper for \" + stringify(dirType) + \" has not been compiled!\");\n }\n return dirWrapper;\n };\n /**\n * @param {?} dirMeta\n * @param {?} moduleMeta\n * @return {?}\n */\n JitCompiler.prototype._compileDirectiveWrapper = function (dirMeta, moduleMeta) {\n var /** @type {?} */ compileResult = this._directiveWrapperCompiler.compile(dirMeta);\n var /** @type {?} */ statements = compileResult.statements;\n var /** @type {?} */ directiveWrapperClass;\n if (!this._compilerConfig.useJit) {\n directiveWrapperClass = interpretStatements(statements, compileResult.dirWrapperClassVar);\n }\n else {\n directiveWrapperClass = jitStatements(\"/\" + identifierName(moduleMeta.type) + \"/\" + identifierName(dirMeta.type) + \"/wrapper.ngfactory.js\", statements, compileResult.dirWrapperClassVar);\n }\n this._compiledDirectiveWrapperCache.set(dirMeta.type.reference, directiveWrapperClass);\n };\n /**\n * @param {?} template\n * @return {?}\n */\n JitCompiler.prototype._compileTemplate = function (template) {\n var _this = this;\n if (template.isCompiled) {\n return;\n }\n var /** @type {?} */ compMeta = template.compMeta;\n var /** @type {?} */ externalStylesheetsByModuleUrl = new Map();\n var /** @type {?} */ stylesCompileResult = this._styleCompiler.compileComponent(compMeta);\n stylesCompileResult.externalStylesheets.forEach(function (r) { externalStylesheetsByModuleUrl.set(r.meta.moduleUrl, r); });\n this._resolveStylesCompileResult(stylesCompileResult.componentStylesheet, externalStylesheetsByModuleUrl);\n var /** @type {?} */ parsedAnimations = this._animationParser.parseComponent(compMeta);\n var /** @type {?} */ directives = template.directives.map(function (dir) { return _this._metadataResolver.getDirectiveSummary(dir.reference); });\n var /** @type {?} */ pipes = template.ngModule.transitiveModule.pipes.map(function (pipe) { return _this._metadataResolver.getPipeSummary(pipe.reference); });\n var /** @type {?} */ parsedTemplate = this._templateParser.parse(compMeta, compMeta.template.template, directives, pipes, template.ngModule.schemas, identifierName(compMeta.type));\n var /** @type {?} */ compiledAnimations = this._animationCompiler.compile(identifierName(compMeta.type), parsedAnimations);\n var /** @type {?} */ compileResult = this._viewCompiler.compileComponent(compMeta, parsedTemplate, ir.variable(stylesCompileResult.componentStylesheet.stylesVar), pipes, compiledAnimations);\n compileResult.dependencies.forEach(function (dep) {\n var /** @type {?} */ depTemplate;\n if (dep instanceof ViewClassDependency) {\n var /** @type {?} */ vfd = (dep);\n depTemplate = _this._assertComponentKnown(vfd.comp.reference, false);\n vfd.placeholder.reference = depTemplate.proxyViewClass;\n }\n else if (dep instanceof ComponentFactoryDependency) {\n var /** @type {?} */ cfd = (dep);\n depTemplate = _this._assertComponentKnown(cfd.comp.reference, true);\n cfd.placeholder.reference = depTemplate.proxyComponentFactory;\n }\n else if (dep instanceof DirectiveWrapperDependency) {\n var /** @type {?} */ dwd = (dep);\n dwd.placeholder.reference = _this._assertDirectiveWrapper(dwd.dir.reference);\n }\n });\n var /** @type {?} */ statements = (_a = stylesCompileResult.componentStylesheet.statements).concat.apply(_a, compiledAnimations.map(function (ca) { return ca.statements; }))\n .concat(compileResult.statements);\n var /** @type {?} */ viewClass;\n if (!this._compilerConfig.useJit) {\n viewClass = interpretStatements(statements, compileResult.viewClassVar);\n }\n else {\n viewClass = jitStatements(\"/\" + identifierName(template.ngModule.type) + \"/\" + identifierName(template.compType) + \"/\" + (template.isHost ? 'host' : 'component') + \".ngfactory.js\", statements, compileResult.viewClassVar);\n }\n template.compiled(viewClass);\n var _a;\n };\n /**\n * @param {?} result\n * @param {?} externalStylesheetsByModuleUrl\n * @return {?}\n */\n JitCompiler.prototype._resolveStylesCompileResult = function (result, externalStylesheetsByModuleUrl) {\n var _this = this;\n result.dependencies.forEach(function (dep, i) {\n var /** @type {?} */ nestedCompileResult = externalStylesheetsByModuleUrl.get(dep.moduleUrl);\n var /** @type {?} */ nestedStylesArr = _this._resolveAndEvalStylesCompileResult(nestedCompileResult, externalStylesheetsByModuleUrl);\n dep.valuePlaceholder.reference = nestedStylesArr;\n });\n };\n /**\n * @param {?} result\n * @param {?} externalStylesheetsByModuleUrl\n * @return {?}\n */\n JitCompiler.prototype._resolveAndEvalStylesCompileResult = function (result, externalStylesheetsByModuleUrl) {\n this._resolveStylesCompileResult(result, externalStylesheetsByModuleUrl);\n if (!this._compilerConfig.useJit) {\n return interpretStatements(result.statements, result.stylesVar);\n }\n else {\n return jitStatements(\"/\" + result.meta.moduleUrl + \".ngstyle.js\", result.statements, result.stylesVar);\n }\n };\n JitCompiler = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [Injector, CompileMetadataResolver, TemplateParser, StyleCompiler, ViewCompiler, NgModuleCompiler, DirectiveWrapperCompiler, CompilerConfig, AnimationParser])\n ], JitCompiler);\n return JitCompiler;\n}());\nfunction JitCompiler_tsickle_Closure_declarations() {\n /** @type {?} */\n JitCompiler.prototype._compiledTemplateCache;\n /** @type {?} */\n JitCompiler.prototype._compiledHostTemplateCache;\n /** @type {?} */\n JitCompiler.prototype._compiledDirectiveWrapperCache;\n /** @type {?} */\n JitCompiler.prototype._compiledNgModuleCache;\n /** @type {?} */\n JitCompiler.prototype._animationCompiler;\n /** @type {?} */\n JitCompiler.prototype._injector;\n /** @type {?} */\n JitCompiler.prototype._metadataResolver;\n /** @type {?} */\n JitCompiler.prototype._templateParser;\n /** @type {?} */\n JitCompiler.prototype._styleCompiler;\n /** @type {?} */\n JitCompiler.prototype._viewCompiler;\n /** @type {?} */\n JitCompiler.prototype._ngModuleCompiler;\n /** @type {?} */\n JitCompiler.prototype._directiveWrapperCompiler;\n /** @type {?} */\n JitCompiler.prototype._compilerConfig;\n /** @type {?} */\n JitCompiler.prototype._animationParser;\n}\nvar CompiledTemplate = (function () {\n /**\n * @param {?} isHost\n * @param {?} selector\n * @param {?} compType\n * @param {?} compMeta\n * @param {?} ngModule\n * @param {?} directives\n */\n function CompiledTemplate(isHost, selector, compType, compMeta, ngModule, directives) {\n this.isHost = isHost;\n this.compType = compType;\n this.compMeta = compMeta;\n this.ngModule = ngModule;\n this.directives = directives;\n this._viewClass = null;\n this.isCompiled = false;\n var self = this;\n this.proxyViewClass = function () {\n if (!self._viewClass) {\n throw new Error(\"Illegal state: CompiledTemplate for \" + stringify(self.compType) + \" is not compiled yet!\");\n }\n return self._viewClass.apply(this, arguments);\n };\n this.proxyComponentFactory = isHost ?\n new ComponentFactory(selector, this.proxyViewClass, compType.reference) :\n null;\n }\n /**\n * @param {?} viewClass\n * @return {?}\n */\n CompiledTemplate.prototype.compiled = function (viewClass) {\n this._viewClass = viewClass;\n this.proxyViewClass.prototype = viewClass.prototype;\n this.isCompiled = true;\n };\n return CompiledTemplate;\n}());\nfunction CompiledTemplate_tsickle_Closure_declarations() {\n /** @type {?} */\n CompiledTemplate.prototype._viewClass;\n /** @type {?} */\n CompiledTemplate.prototype.proxyViewClass;\n /** @type {?} */\n CompiledTemplate.prototype.proxyComponentFactory;\n /** @type {?} */\n CompiledTemplate.prototype.isCompiled;\n /** @type {?} */\n CompiledTemplate.prototype.isHost;\n /** @type {?} */\n CompiledTemplate.prototype.compType;\n /** @type {?} */\n CompiledTemplate.prototype.compMeta;\n /** @type {?} */\n CompiledTemplate.prototype.ngModule;\n /** @type {?} */\n CompiledTemplate.prototype.directives;\n}\n/**\n * @param {?} meta\n * @return {?}\n */\nfunction assertComponent(meta) {\n if (!meta.isComponent) {\n throw new Error(\"Could not compile '\" + identifierName(meta.type) + \"' because it is not a component.\");\n }\n}\n/**\n * Implements `Compiler` by delegating to the JitCompiler using a known module.\n */\nvar ModuleBoundCompiler = (function () {\n /**\n * @param {?} _delegate\n * @param {?} _ngModule\n */\n function ModuleBoundCompiler(_delegate, _ngModule) {\n this._delegate = _delegate;\n this._ngModule = _ngModule;\n }\n Object.defineProperty(ModuleBoundCompiler.prototype, \"_injector\", {\n /**\n * @return {?}\n */\n get: function () { return this._delegate.injector; },\n enumerable: true,\n configurable: true\n });\n /**\n * @param {?} moduleType\n * @return {?}\n */\n ModuleBoundCompiler.prototype.compileModuleSync = function (moduleType) {\n return this._delegate.compileModuleSync(moduleType);\n };\n /**\n * @param {?} moduleType\n * @return {?}\n */\n ModuleBoundCompiler.prototype.compileModuleAsync = function (moduleType) {\n return this._delegate.compileModuleAsync(moduleType);\n };\n /**\n * @param {?} moduleType\n * @return {?}\n */\n ModuleBoundCompiler.prototype.compileModuleAndAllComponentsSync = function (moduleType) {\n return this._delegate.compileModuleAndAllComponentsSync(moduleType);\n };\n /**\n * @param {?} moduleType\n * @return {?}\n */\n ModuleBoundCompiler.prototype.compileModuleAndAllComponentsAsync = function (moduleType) {\n return this._delegate.compileModuleAndAllComponentsAsync(moduleType);\n };\n /**\n * @param {?} component\n * @return {?}\n */\n ModuleBoundCompiler.prototype.getNgContentSelectors = function (component) {\n return this._delegate.getNgContentSelectors(component);\n };\n /**\n * Clears all caches\n * @return {?}\n */\n ModuleBoundCompiler.prototype.clearCache = function () { this._delegate.clearCache(); };\n /**\n * Clears the cache for the given component/ngModule.\n * @param {?} type\n * @return {?}\n */\n ModuleBoundCompiler.prototype.clearCacheFor = function (type) { this._delegate.clearCacheFor(type); };\n return ModuleBoundCompiler;\n}());\nfunction ModuleBoundCompiler_tsickle_Closure_declarations() {\n /** @type {?} */\n ModuleBoundCompiler.prototype._delegate;\n /** @type {?} */\n ModuleBoundCompiler.prototype._ngModule;\n}\n//# sourceMappingURL=compiler.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/jit/compiler.js\n// module id = ./node_modules/@angular/compiler/src/jit/compiler.js\n// module chunks = 0","/**\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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { COMPILER_OPTIONS, Compiler, CompilerFactory, Inject, Optional, PLATFORM_INITIALIZER, ReflectiveInjector, TRANSLATIONS, TRANSLATIONS_FORMAT, ViewEncapsulation, createPlatformFactory, isDevMode, platformCore } from '@angular/core';\nimport { AnimationParser } from '../animation/animation_parser';\nimport { CompilerConfig } from '../config';\nimport { DirectiveNormalizer } from '../directive_normalizer';\nimport { DirectiveResolver } from '../directive_resolver';\nimport { DirectiveWrapperCompiler } from '../directive_wrapper_compiler';\nimport { Lexer } from '../expression_parser/lexer';\nimport { Parser } from '../expression_parser/parser';\nimport * as i18n from '../i18n/index';\nimport { CompilerInjectable } from '../injectable';\nimport { CompileMetadataResolver } from '../metadata_resolver';\nimport { HtmlParser } from '../ml_parser/html_parser';\nimport { NgModuleCompiler } from '../ng_module_compiler';\nimport { NgModuleResolver } from '../ng_module_resolver';\nimport { PipeResolver } from '../pipe_resolver';\nimport { Console, ReflectionCapabilities, Reflector, ReflectorReader, reflector } from '../private_import_core';\nimport { ResourceLoader } from '../resource_loader';\nimport { DomElementSchemaRegistry } from '../schema/dom_element_schema_registry';\nimport { ElementSchemaRegistry } from '../schema/element_schema_registry';\nimport { StyleCompiler } from '../style_compiler';\nimport { SummaryResolver } from '../summary_resolver';\nimport { TemplateParser } from '../template_parser/template_parser';\nimport { DEFAULT_PACKAGE_URL_PROVIDER, UrlResolver } from '../url_resolver';\nimport { ViewCompiler } from '../view_compiler/view_compiler';\nimport { JitCompiler } from './compiler';\nvar /** @type {?} */ _NO_RESOURCE_LOADER = {\n /**\n * @param {?} url\n * @return {?}\n */\n get: function (url) {\n throw new Error(\"No ResourceLoader implementation has been provided. Can't read the url \\\"\" + url + \"\\\"\");\n }\n};\n/**\n * A set of providers that provide `JitCompiler` and its dependencies to use for\n * template compilation.\n */\nexport var /** @type {?} */ COMPILER_PROVIDERS = [\n { provide: Reflector, useValue: reflector },\n { provide: ReflectorReader, useExisting: Reflector },\n { provide: ResourceLoader, useValue: _NO_RESOURCE_LOADER },\n SummaryResolver,\n Console,\n Lexer,\n Parser,\n HtmlParser,\n {\n provide: i18n.I18NHtmlParser,\n useFactory: function (parser, translations, format) {\n return new i18n.I18NHtmlParser(parser, translations, format);\n },\n deps: [\n HtmlParser,\n [new Optional(), new Inject(TRANSLATIONS)],\n [new Optional(), new Inject(TRANSLATIONS_FORMAT)],\n ]\n },\n TemplateParser,\n DirectiveNormalizer,\n CompileMetadataResolver,\n DEFAULT_PACKAGE_URL_PROVIDER,\n StyleCompiler,\n ViewCompiler,\n NgModuleCompiler,\n DirectiveWrapperCompiler,\n { provide: CompilerConfig, useValue: new CompilerConfig() },\n JitCompiler,\n { provide: Compiler, useExisting: JitCompiler },\n DomElementSchemaRegistry,\n { provide: ElementSchemaRegistry, useExisting: DomElementSchemaRegistry },\n UrlResolver,\n DirectiveResolver,\n PipeResolver,\n NgModuleResolver,\n AnimationParser\n];\nexport var JitCompilerFactory = (function () {\n /**\n * @param {?} defaultOptions\n */\n function JitCompilerFactory(defaultOptions) {\n this._defaultOptions = [{\n useDebug: isDevMode(),\n useJit: true,\n defaultEncapsulation: ViewEncapsulation.Emulated\n }].concat(defaultOptions);\n }\n /**\n * @param {?=} options\n * @return {?}\n */\n JitCompilerFactory.prototype.createCompiler = function (options) {\n if (options === void 0) { options = []; }\n var /** @type {?} */ mergedOptions = _mergeOptions(this._defaultOptions.concat(options));\n var /** @type {?} */ injector = ReflectiveInjector.resolveAndCreate([\n COMPILER_PROVIDERS, {\n provide: CompilerConfig,\n useFactory: function () {\n return new CompilerConfig({\n // let explicit values from the compiler options overwrite options\n // from the app providers. E.g. important for the testing platform.\n genDebugInfo: mergedOptions.useDebug,\n // let explicit values from the compiler options overwrite options\n // from the app providers\n useJit: mergedOptions.useJit,\n // let explicit values from the compiler options overwrite options\n // from the app providers\n defaultEncapsulation: mergedOptions.defaultEncapsulation,\n logBindingUpdate: mergedOptions.useDebug\n });\n },\n deps: []\n },\n mergedOptions.providers\n ]);\n return injector.get(Compiler);\n };\n /** @nocollapse */\n JitCompilerFactory.ctorParameters = function () { return [\n { type: Array, decorators: [{ type: Inject, args: [COMPILER_OPTIONS,] },] },\n ]; };\n JitCompilerFactory = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [Array])\n ], JitCompilerFactory);\n return JitCompilerFactory;\n}());\nfunction JitCompilerFactory_tsickle_Closure_declarations() {\n /**\n * @nocollapse\n * @type {?}\n */\n JitCompilerFactory.ctorParameters;\n /** @type {?} */\n JitCompilerFactory.prototype._defaultOptions;\n}\n/**\n * @return {?}\n */\nfunction _initReflector() {\n reflector.reflectionCapabilities = new ReflectionCapabilities();\n}\n/**\n * A platform that included corePlatform and the compiler.\n *\n * @experimental\n */\nexport var /** @type {?} */ platformCoreDynamic = createPlatformFactory(platformCore, 'coreDynamic', [\n { provide: COMPILER_OPTIONS, useValue: {}, multi: true },\n { provide: CompilerFactory, useClass: JitCompilerFactory },\n { provide: PLATFORM_INITIALIZER, useValue: _initReflector, multi: true },\n]);\n/**\n * @param {?} optionsArr\n * @return {?}\n */\nfunction _mergeOptions(optionsArr) {\n return {\n useDebug: _lastDefined(optionsArr.map(function (options) { return options.useDebug; })),\n useJit: _lastDefined(optionsArr.map(function (options) { return options.useJit; })),\n defaultEncapsulation: _lastDefined(optionsArr.map(function (options) { return options.defaultEncapsulation; })),\n providers: _mergeArrays(optionsArr.map(function (options) { return options.providers; }))\n };\n}\n/**\n * @param {?} args\n * @return {?}\n */\nfunction _lastDefined(args) {\n for (var /** @type {?} */ i = args.length - 1; i >= 0; i--) {\n if (args[i] !== undefined) {\n return args[i];\n }\n }\n return undefined;\n}\n/**\n * @param {?} parts\n * @return {?}\n */\nfunction _mergeArrays(parts) {\n var /** @type {?} */ result = [];\n parts.forEach(function (part) { return part && result.push.apply(result, part); });\n return result;\n}\n//# sourceMappingURL=compiler_factory.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/jit/compiler_factory.js\n// module id = ./node_modules/@angular/compiler/src/jit/compiler_factory.js\n// module chunks = 0","/**\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 */\nimport { LifecycleHooks, reflector } from './private_import_core';\n/**\n * @param {?} hook\n * @param {?} token\n * @return {?}\n */\nexport function hasLifecycleHook(hook, token) {\n return reflector.hasLifecycleHook(token, getHookName(hook));\n}\n/**\n * @param {?} hook\n * @return {?}\n */\nfunction getHookName(hook) {\n switch (hook) {\n case LifecycleHooks.OnInit:\n return 'ngOnInit';\n case LifecycleHooks.OnDestroy:\n return 'ngOnDestroy';\n case LifecycleHooks.DoCheck:\n return 'ngDoCheck';\n case LifecycleHooks.OnChanges:\n return 'ngOnChanges';\n case LifecycleHooks.AfterContentInit:\n return 'ngAfterContentInit';\n case LifecycleHooks.AfterContentChecked:\n return 'ngAfterContentChecked';\n case LifecycleHooks.AfterViewInit:\n return 'ngAfterViewInit';\n case LifecycleHooks.AfterViewChecked:\n return 'ngAfterViewChecked';\n }\n}\n//# sourceMappingURL=lifecycle_reflector.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/lifecycle_reflector.js\n// module id = ./node_modules/@angular/compiler/src/lifecycle_reflector.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { AnimationAnimateMetadata, AnimationGroupMetadata, AnimationKeyframesSequenceMetadata, AnimationStateDeclarationMetadata, AnimationStateTransitionMetadata, AnimationStyleMetadata, AnimationWithStepsMetadata, Attribute, Component, Host, Inject, Injectable, OpaqueToken, Optional, Self, SkipSelf, Type, resolveForwardRef } from '@angular/core';\nimport { StaticSymbol } from './aot/static_symbol';\nimport { assertArrayOfStrings, assertInterpolationSymbols } from './assertions';\nimport * as cpl from './compile_metadata';\nimport { DirectiveNormalizer } from './directive_normalizer';\nimport { DirectiveResolver } from './directive_resolver';\nimport { isBlank, isPresent, stringify } from './facade/lang';\nimport { Identifiers, resolveIdentifier } from './identifiers';\nimport { CompilerInjectable } from './injectable';\nimport { hasLifecycleHook } from './lifecycle_reflector';\nimport { NgModuleResolver } from './ng_module_resolver';\nimport { PipeResolver } from './pipe_resolver';\nimport { ComponentStillLoadingError, LIFECYCLE_HOOKS_VALUES, ReflectorReader, reflector } from './private_import_core';\nimport { ElementSchemaRegistry } from './schema/element_schema_registry';\nimport { SummaryResolver } from './summary_resolver';\nimport { getUrlScheme } from './url_resolver';\nimport { MODULE_SUFFIX, SyntaxError, ValueTransformer, visitValue } from './util';\nexport var /** @type {?} */ ERROR_COLLECTOR_TOKEN = new OpaqueToken('ErrorCollector');\n// Design notes:\n// - don't lazily create metadata:\n// For some metadata, we need to do async work sometimes,\n// so the user has to kick off this loading.\n// But we want to report errors even when the async work is\n// not required to check that the user would have been able\n// to wait correctly.\nexport var CompileMetadataResolver = (function () {\n /**\n * @param {?} _ngModuleResolver\n * @param {?} _directiveResolver\n * @param {?} _pipeResolver\n * @param {?} _summaryResolver\n * @param {?} _schemaRegistry\n * @param {?} _directiveNormalizer\n * @param {?=} _reflector\n * @param {?=} _errorCollector\n */\n function CompileMetadataResolver(_ngModuleResolver, _directiveResolver, _pipeResolver, _summaryResolver, _schemaRegistry, _directiveNormalizer, _reflector, _errorCollector) {\n if (_reflector === void 0) { _reflector = reflector; }\n this._ngModuleResolver = _ngModuleResolver;\n this._directiveResolver = _directiveResolver;\n this._pipeResolver = _pipeResolver;\n this._summaryResolver = _summaryResolver;\n this._schemaRegistry = _schemaRegistry;\n this._directiveNormalizer = _directiveNormalizer;\n this._reflector = _reflector;\n this._errorCollector = _errorCollector;\n this._directiveCache = new Map();\n this._summaryCache = new Map();\n this._pipeCache = new Map();\n this._ngModuleCache = new Map();\n this._ngModuleOfTypes = new Map();\n }\n /**\n * @param {?} type\n * @return {?}\n */\n CompileMetadataResolver.prototype.clearCacheFor = function (type) {\n var /** @type {?} */ dirMeta = this._directiveCache.get(type);\n this._directiveCache.delete(type);\n this._summaryCache.delete(type);\n this._pipeCache.delete(type);\n this._ngModuleOfTypes.delete(type);\n // Clear all of the NgModule as they contain transitive information!\n this._ngModuleCache.clear();\n if (dirMeta) {\n this._directiveNormalizer.clearCacheFor(dirMeta);\n }\n };\n /**\n * @return {?}\n */\n CompileMetadataResolver.prototype.clearCache = function () {\n this._directiveCache.clear();\n this._summaryCache.clear();\n this._pipeCache.clear();\n this._ngModuleCache.clear();\n this._ngModuleOfTypes.clear();\n this._directiveNormalizer.clearCache();\n };\n /**\n * @param {?} entry\n * @return {?}\n */\n CompileMetadataResolver.prototype.getAnimationEntryMetadata = function (entry) {\n var _this = this;\n var /** @type {?} */ defs = entry.definitions.map(function (def) { return _this._getAnimationStateMetadata(def); });\n return new cpl.CompileAnimationEntryMetadata(entry.name, defs);\n };\n /**\n * @param {?} value\n * @return {?}\n */\n CompileMetadataResolver.prototype._getAnimationStateMetadata = function (value) {\n if (value instanceof AnimationStateDeclarationMetadata) {\n var /** @type {?} */ styles = this._getAnimationStyleMetadata(value.styles);\n return new cpl.CompileAnimationStateDeclarationMetadata(value.stateNameExpr, styles);\n }\n if (value instanceof AnimationStateTransitionMetadata) {\n return new cpl.CompileAnimationStateTransitionMetadata(value.stateChangeExpr, this._getAnimationMetadata(value.steps));\n }\n return null;\n };\n /**\n * @param {?} value\n * @return {?}\n */\n CompileMetadataResolver.prototype._getAnimationStyleMetadata = function (value) {\n return new cpl.CompileAnimationStyleMetadata(value.offset, value.styles);\n };\n /**\n * @param {?} value\n * @return {?}\n */\n CompileMetadataResolver.prototype._getAnimationMetadata = function (value) {\n var _this = this;\n if (value instanceof AnimationStyleMetadata) {\n return this._getAnimationStyleMetadata(value);\n }\n if (value instanceof AnimationKeyframesSequenceMetadata) {\n return new cpl.CompileAnimationKeyframesSequenceMetadata(value.steps.map(function (entry) { return _this._getAnimationStyleMetadata(entry); }));\n }\n if (value instanceof AnimationAnimateMetadata) {\n var /** @type {?} */ animateData = (this\n ._getAnimationMetadata(value.styles));\n return new cpl.CompileAnimationAnimateMetadata(value.timings, animateData);\n }\n if (value instanceof AnimationWithStepsMetadata) {\n var /** @type {?} */ steps = value.steps.map(function (step) { return _this._getAnimationMetadata(step); });\n if (value instanceof AnimationGroupMetadata) {\n return new cpl.CompileAnimationGroupMetadata(steps);\n }\n return new cpl.CompileAnimationSequenceMetadata(steps);\n }\n return null;\n };\n /**\n * @param {?} type\n * @param {?} kind\n * @return {?}\n */\n CompileMetadataResolver.prototype._loadSummary = function (type, kind) {\n var /** @type {?} */ typeSummary = this._summaryCache.get(type);\n if (!typeSummary) {\n var /** @type {?} */ summary = this._summaryResolver.resolveSummary(type);\n typeSummary = summary ? summary.type : null;\n this._summaryCache.set(type, typeSummary);\n }\n return typeSummary && typeSummary.summaryKind === kind ? typeSummary : null;\n };\n /**\n * @param {?} directiveType\n * @param {?} isSync\n * @return {?}\n */\n CompileMetadataResolver.prototype._loadDirectiveMetadata = function (directiveType, isSync) {\n var _this = this;\n if (this._directiveCache.has(directiveType)) {\n return;\n }\n directiveType = resolveForwardRef(directiveType);\n var _a = this.getNonNormalizedDirectiveMetadata(directiveType), annotation = _a.annotation, metadata = _a.metadata;\n var /** @type {?} */ createDirectiveMetadata = function (templateMetadata) {\n var /** @type {?} */ normalizedDirMeta = new cpl.CompileDirectiveMetadata({\n type: metadata.type,\n isComponent: metadata.isComponent,\n selector: metadata.selector,\n exportAs: metadata.exportAs,\n changeDetection: metadata.changeDetection,\n inputs: metadata.inputs,\n outputs: metadata.outputs,\n hostListeners: metadata.hostListeners,\n hostProperties: metadata.hostProperties,\n hostAttributes: metadata.hostAttributes,\n providers: metadata.providers,\n viewProviders: metadata.viewProviders,\n queries: metadata.queries,\n viewQueries: metadata.viewQueries,\n entryComponents: metadata.entryComponents,\n template: templateMetadata\n });\n _this._directiveCache.set(directiveType, normalizedDirMeta);\n _this._summaryCache.set(directiveType, normalizedDirMeta.toSummary());\n return normalizedDirMeta;\n };\n if (metadata.isComponent) {\n var /** @type {?} */ templateMeta = this._directiveNormalizer.normalizeTemplate({\n componentType: directiveType,\n moduleUrl: componentModuleUrl(this._reflector, directiveType, annotation),\n encapsulation: metadata.template.encapsulation,\n template: metadata.template.template,\n templateUrl: metadata.template.templateUrl,\n styles: metadata.template.styles,\n styleUrls: metadata.template.styleUrls,\n animations: metadata.template.animations,\n interpolation: metadata.template.interpolation\n });\n if (templateMeta.syncResult) {\n createDirectiveMetadata(templateMeta.syncResult);\n return null;\n }\n else {\n if (isSync) {\n this._reportError(new ComponentStillLoadingError(directiveType), directiveType);\n return null;\n }\n return templateMeta.asyncResult.then(createDirectiveMetadata);\n }\n }\n else {\n // directive\n createDirectiveMetadata(null);\n return null;\n }\n };\n /**\n * @param {?} directiveType\n * @return {?}\n */\n CompileMetadataResolver.prototype.getNonNormalizedDirectiveMetadata = function (directiveType) {\n var _this = this;\n directiveType = resolveForwardRef(directiveType);\n var /** @type {?} */ dirMeta = this._directiveResolver.resolve(directiveType);\n if (!dirMeta) {\n return null;\n }\n var /** @type {?} */ nonNormalizedTemplateMetadata;\n if (dirMeta instanceof Component) {\n // component\n assertArrayOfStrings('styles', dirMeta.styles);\n assertArrayOfStrings('styleUrls', dirMeta.styleUrls);\n assertInterpolationSymbols('interpolation', dirMeta.interpolation);\n var /** @type {?} */ animations = dirMeta.animations ?\n dirMeta.animations.map(function (e) { return _this.getAnimationEntryMetadata(e); }) :\n null;\n nonNormalizedTemplateMetadata = new cpl.CompileTemplateMetadata({\n encapsulation: dirMeta.encapsulation,\n template: dirMeta.template,\n templateUrl: dirMeta.templateUrl,\n styles: dirMeta.styles,\n styleUrls: dirMeta.styleUrls,\n animations: animations,\n interpolation: dirMeta.interpolation\n });\n }\n var /** @type {?} */ changeDetectionStrategy = null;\n var /** @type {?} */ viewProviders = [];\n var /** @type {?} */ entryComponentMetadata = [];\n var /** @type {?} */ selector = dirMeta.selector;\n if (dirMeta instanceof Component) {\n // Component\n changeDetectionStrategy = dirMeta.changeDetection;\n if (dirMeta.viewProviders) {\n viewProviders = this._getProvidersMetadata(dirMeta.viewProviders, entryComponentMetadata, \"viewProviders for \\\"\" + stringifyType(directiveType) + \"\\\"\", [], directiveType);\n }\n if (dirMeta.entryComponents) {\n entryComponentMetadata = flattenAndDedupeArray(dirMeta.entryComponents)\n .map(function (type) { return _this._getIdentifierMetadata(type); })\n .concat(entryComponentMetadata);\n }\n if (!selector) {\n selector = this._schemaRegistry.getDefaultComponentElementName();\n }\n }\n else {\n // Directive\n if (!selector) {\n this._reportError(new SyntaxError(\"Directive \" + stringifyType(directiveType) + \" has no selector, please add it!\"), directiveType);\n selector = 'error';\n }\n }\n var /** @type {?} */ providers = [];\n if (isPresent(dirMeta.providers)) {\n providers = this._getProvidersMetadata(dirMeta.providers, entryComponentMetadata, \"providers for \\\"\" + stringifyType(directiveType) + \"\\\"\", [], directiveType);\n }\n var /** @type {?} */ queries = [];\n var /** @type {?} */ viewQueries = [];\n if (isPresent(dirMeta.queries)) {\n queries = this._getQueriesMetadata(dirMeta.queries, false, directiveType);\n viewQueries = this._getQueriesMetadata(dirMeta.queries, true, directiveType);\n }\n var /** @type {?} */ metadata = cpl.CompileDirectiveMetadata.create({\n selector: selector,\n exportAs: dirMeta.exportAs,\n isComponent: !!nonNormalizedTemplateMetadata,\n type: this._getTypeMetadata(directiveType),\n template: nonNormalizedTemplateMetadata,\n changeDetection: changeDetectionStrategy,\n inputs: dirMeta.inputs,\n outputs: dirMeta.outputs,\n host: dirMeta.host,\n providers: providers,\n viewProviders: viewProviders,\n queries: queries,\n viewQueries: viewQueries,\n entryComponents: entryComponentMetadata\n });\n return { metadata: metadata, annotation: dirMeta };\n };\n /**\n * Gets the metadata for the given directive.\n * This assumes `loadNgModuleMetadata` has been called first.\n * @param {?} directiveType\n * @return {?}\n */\n CompileMetadataResolver.prototype.getDirectiveMetadata = function (directiveType) {\n var /** @type {?} */ dirMeta = this._directiveCache.get(directiveType);\n if (!dirMeta) {\n this._reportError(new SyntaxError(\"Illegal state: getDirectiveMetadata can only be called after loadNgModuleMetadata for a module that declares it. Directive \" + stringifyType(directiveType) + \".\"), directiveType);\n }\n return dirMeta;\n };\n /**\n * @param {?} dirType\n * @return {?}\n */\n CompileMetadataResolver.prototype.getDirectiveSummary = function (dirType) {\n var /** @type {?} */ dirSummary = (this._loadSummary(dirType, cpl.CompileSummaryKind.Directive));\n if (!dirSummary) {\n this._reportError(new SyntaxError(\"Illegal state: Could not load the summary for directive \" + stringifyType(dirType) + \".\"), dirType);\n }\n return dirSummary;\n };\n /**\n * @param {?} type\n * @return {?}\n */\n CompileMetadataResolver.prototype.isDirective = function (type) { return this._directiveResolver.isDirective(type); };\n /**\n * @param {?} type\n * @return {?}\n */\n CompileMetadataResolver.prototype.isPipe = function (type) { return this._pipeResolver.isPipe(type); };\n /**\n * @param {?} moduleType\n * @return {?}\n */\n CompileMetadataResolver.prototype.getNgModuleSummary = function (moduleType) {\n var /** @type {?} */ moduleSummary = (this._loadSummary(moduleType, cpl.CompileSummaryKind.NgModule));\n if (!moduleSummary) {\n var /** @type {?} */ moduleMeta = this.getNgModuleMetadata(moduleType, false);\n moduleSummary = moduleMeta ? moduleMeta.toSummary() : null;\n if (moduleSummary) {\n this._summaryCache.set(moduleType, moduleSummary);\n }\n }\n return moduleSummary;\n };\n /**\n * Loads the declared directives and pipes of an NgModule.\n * @param {?} moduleType\n * @param {?} isSync\n * @param {?=} throwIfNotFound\n * @return {?}\n */\n CompileMetadataResolver.prototype.loadNgModuleDirectiveAndPipeMetadata = function (moduleType, isSync, throwIfNotFound) {\n var _this = this;\n if (throwIfNotFound === void 0) { throwIfNotFound = true; }\n var /** @type {?} */ ngModule = this.getNgModuleMetadata(moduleType, throwIfNotFound);\n var /** @type {?} */ loading = [];\n if (ngModule) {\n ngModule.declaredDirectives.forEach(function (id) {\n var /** @type {?} */ promise = _this._loadDirectiveMetadata(id.reference, isSync);\n if (promise) {\n loading.push(promise);\n }\n });\n ngModule.declaredPipes.forEach(function (id) { return _this._loadPipeMetadata(id.reference); });\n }\n return Promise.all(loading);\n };\n /**\n * @param {?} moduleType\n * @param {?=} throwIfNotFound\n * @return {?}\n */\n CompileMetadataResolver.prototype.getNgModuleMetadata = function (moduleType, throwIfNotFound) {\n var _this = this;\n if (throwIfNotFound === void 0) { throwIfNotFound = true; }\n moduleType = resolveForwardRef(moduleType);\n var /** @type {?} */ compileMeta = this._ngModuleCache.get(moduleType);\n if (compileMeta) {\n return compileMeta;\n }\n var /** @type {?} */ meta = this._ngModuleResolver.resolve(moduleType, throwIfNotFound);\n if (!meta) {\n return null;\n }\n var /** @type {?} */ declaredDirectives = [];\n var /** @type {?} */ exportedNonModuleIdentifiers = [];\n var /** @type {?} */ declaredPipes = [];\n var /** @type {?} */ importedModules = [];\n var /** @type {?} */ exportedModules = [];\n var /** @type {?} */ providers = [];\n var /** @type {?} */ entryComponents = [];\n var /** @type {?} */ bootstrapComponents = [];\n var /** @type {?} */ schemas = [];\n if (meta.imports) {\n flattenAndDedupeArray(meta.imports).forEach(function (importedType) {\n var /** @type {?} */ importedModuleType;\n if (isValidType(importedType)) {\n importedModuleType = importedType;\n }\n else if (importedType && importedType.ngModule) {\n var /** @type {?} */ moduleWithProviders = importedType;\n importedModuleType = moduleWithProviders.ngModule;\n if (moduleWithProviders.providers) {\n providers.push.apply(providers, _this._getProvidersMetadata(moduleWithProviders.providers, entryComponents, \"provider for the NgModule '\" + stringifyType(importedModuleType) + \"'\", [], importedType));\n }\n }\n if (importedModuleType) {\n var /** @type {?} */ importedModuleSummary = _this.getNgModuleSummary(importedModuleType);\n if (!importedModuleSummary) {\n _this._reportError(new SyntaxError(\"Unexpected \" + _this._getTypeDescriptor(importedType) + \" '\" + stringifyType(importedType) + \"' imported by the module '\" + stringifyType(moduleType) + \"'\"), moduleType);\n return;\n }\n importedModules.push(importedModuleSummary);\n }\n else {\n _this._reportError(new SyntaxError(\"Unexpected value '\" + stringifyType(importedType) + \"' imported by the module '\" + stringifyType(moduleType) + \"'\"), moduleType);\n return;\n }\n });\n }\n if (meta.exports) {\n flattenAndDedupeArray(meta.exports).forEach(function (exportedType) {\n if (!isValidType(exportedType)) {\n _this._reportError(new SyntaxError(\"Unexpected value '\" + stringifyType(exportedType) + \"' exported by the module '\" + stringifyType(moduleType) + \"'\"), moduleType);\n return;\n }\n var /** @type {?} */ exportedModuleSummary = _this.getNgModuleSummary(exportedType);\n if (exportedModuleSummary) {\n exportedModules.push(exportedModuleSummary);\n }\n else {\n exportedNonModuleIdentifiers.push(_this._getIdentifierMetadata(exportedType));\n }\n });\n }\n // Note: This will be modified later, so we rely on\n // getting a new instance every time!\n var /** @type {?} */ transitiveModule = this._getTransitiveNgModuleMetadata(importedModules, exportedModules);\n if (meta.declarations) {\n flattenAndDedupeArray(meta.declarations).forEach(function (declaredType) {\n if (!isValidType(declaredType)) {\n _this._reportError(new SyntaxError(\"Unexpected value '\" + stringifyType(declaredType) + \"' declared by the module '\" + stringifyType(moduleType) + \"'\"), moduleType);\n return;\n }\n var /** @type {?} */ declaredIdentifier = _this._getIdentifierMetadata(declaredType);\n if (_this._directiveResolver.isDirective(declaredType)) {\n transitiveModule.addDirective(declaredIdentifier);\n declaredDirectives.push(declaredIdentifier);\n _this._addTypeToModule(declaredType, moduleType);\n }\n else if (_this._pipeResolver.isPipe(declaredType)) {\n transitiveModule.addPipe(declaredIdentifier);\n transitiveModule.pipes.push(declaredIdentifier);\n declaredPipes.push(declaredIdentifier);\n _this._addTypeToModule(declaredType, moduleType);\n }\n else {\n _this._reportError(new SyntaxError(\"Unexpected \" + _this._getTypeDescriptor(declaredType) + \" '\" + stringifyType(declaredType) + \"' declared by the module '\" + stringifyType(moduleType) + \"'\"), moduleType);\n return;\n }\n });\n }\n var /** @type {?} */ exportedDirectives = [];\n var /** @type {?} */ exportedPipes = [];\n exportedNonModuleIdentifiers.forEach(function (exportedId) {\n if (transitiveModule.directivesSet.has(exportedId.reference)) {\n exportedDirectives.push(exportedId);\n transitiveModule.addExportedDirective(exportedId);\n }\n else if (transitiveModule.pipesSet.has(exportedId.reference)) {\n exportedPipes.push(exportedId);\n transitiveModule.addExportedPipe(exportedId);\n }\n else {\n _this._reportError(new SyntaxError(\"Can't export \" + _this._getTypeDescriptor(exportedId.reference) + \" \" + stringifyType(exportedId.reference) + \" from \" + stringifyType(moduleType) + \" as it was neither declared nor imported!\"), moduleType);\n }\n });\n // The providers of the module have to go last\n // so that they overwrite any other provider we already added.\n if (meta.providers) {\n providers.push.apply(providers, this._getProvidersMetadata(meta.providers, entryComponents, \"provider for the NgModule '\" + stringifyType(moduleType) + \"'\", [], moduleType));\n }\n if (meta.entryComponents) {\n entryComponents.push.apply(entryComponents, flattenAndDedupeArray(meta.entryComponents)\n .map(function (type) { return _this._getIdentifierMetadata(type); }));\n }\n if (meta.bootstrap) {\n flattenAndDedupeArray(meta.bootstrap).forEach(function (type) {\n if (!isValidType(type)) {\n _this._reportError(new SyntaxError(\"Unexpected value '\" + stringifyType(type) + \"' used in the bootstrap property of module '\" + stringifyType(moduleType) + \"'\"), moduleType);\n return;\n }\n bootstrapComponents.push(_this._getIdentifierMetadata(type));\n });\n }\n entryComponents.push.apply(entryComponents, bootstrapComponents);\n if (meta.schemas) {\n schemas.push.apply(schemas, flattenAndDedupeArray(meta.schemas));\n }\n compileMeta = new cpl.CompileNgModuleMetadata({\n type: this._getTypeMetadata(moduleType),\n providers: providers,\n entryComponents: entryComponents,\n bootstrapComponents: bootstrapComponents,\n schemas: schemas,\n declaredDirectives: declaredDirectives,\n exportedDirectives: exportedDirectives,\n declaredPipes: declaredPipes,\n exportedPipes: exportedPipes,\n importedModules: importedModules,\n exportedModules: exportedModules,\n transitiveModule: transitiveModule,\n id: meta.id,\n });\n entryComponents.forEach(function (id) { return transitiveModule.addEntryComponent(id); });\n providers.forEach(function (provider) { return transitiveModule.addProvider(provider, compileMeta.type); });\n transitiveModule.addModule(compileMeta.type);\n this._ngModuleCache.set(moduleType, compileMeta);\n return compileMeta;\n };\n /**\n * @param {?} type\n * @return {?}\n */\n CompileMetadataResolver.prototype._getTypeDescriptor = function (type) {\n if (this._directiveResolver.isDirective(type)) {\n return 'directive';\n }\n if (this._pipeResolver.isPipe(type)) {\n return 'pipe';\n }\n if (this._ngModuleResolver.isNgModule(type)) {\n return 'module';\n }\n if (((type)).provide) {\n return 'provider';\n }\n return 'value';\n };\n /**\n * @param {?} type\n * @param {?} moduleType\n * @return {?}\n */\n CompileMetadataResolver.prototype._addTypeToModule = function (type, moduleType) {\n var /** @type {?} */ oldModule = this._ngModuleOfTypes.get(type);\n if (oldModule && oldModule !== moduleType) {\n this._reportError(new SyntaxError((\"Type \" + stringifyType(type) + \" is part of the declarations of 2 modules: \" + stringifyType(oldModule) + \" and \" + stringifyType(moduleType) + \"! \") +\n (\"Please consider moving \" + stringifyType(type) + \" to a higher module that imports \" + stringifyType(oldModule) + \" and \" + stringifyType(moduleType) + \". \") +\n (\"You can also create a new NgModule that exports and includes \" + stringifyType(type) + \" then import that NgModule in \" + stringifyType(oldModule) + \" and \" + stringifyType(moduleType) + \".\")), moduleType);\n }\n this._ngModuleOfTypes.set(type, moduleType);\n };\n /**\n * @param {?} importedModules\n * @param {?} exportedModules\n * @return {?}\n */\n CompileMetadataResolver.prototype._getTransitiveNgModuleMetadata = function (importedModules, exportedModules) {\n // collect `providers` / `entryComponents` from all imported and all exported modules\n var /** @type {?} */ result = new cpl.TransitiveCompileNgModuleMetadata();\n var /** @type {?} */ modulesByToken = new Map();\n importedModules.concat(exportedModules).forEach(function (modSummary) {\n modSummary.modules.forEach(function (mod) { return result.addModule(mod); });\n modSummary.entryComponents.forEach(function (comp) { return result.addEntryComponent(comp); });\n var /** @type {?} */ addedTokens = new Set();\n modSummary.providers.forEach(function (entry) {\n var /** @type {?} */ tokenRef = cpl.tokenReference(entry.provider.token);\n var /** @type {?} */ prevModules = modulesByToken.get(tokenRef);\n if (!prevModules) {\n prevModules = new Set();\n modulesByToken.set(tokenRef, prevModules);\n }\n var /** @type {?} */ moduleRef = entry.module.reference;\n // Note: the providers of one module may still contain multiple providers\n // per token (e.g. for multi providers), and we need to preserve these.\n if (addedTokens.has(tokenRef) || !prevModules.has(moduleRef)) {\n prevModules.add(moduleRef);\n addedTokens.add(tokenRef);\n result.addProvider(entry.provider, entry.module);\n }\n });\n });\n exportedModules.forEach(function (modSummary) {\n modSummary.exportedDirectives.forEach(function (id) { return result.addExportedDirective(id); });\n modSummary.exportedPipes.forEach(function (id) { return result.addExportedPipe(id); });\n });\n importedModules.forEach(function (modSummary) {\n modSummary.exportedDirectives.forEach(function (id) { return result.addDirective(id); });\n modSummary.exportedPipes.forEach(function (id) { return result.addPipe(id); });\n });\n return result;\n };\n /**\n * @param {?} type\n * @return {?}\n */\n CompileMetadataResolver.prototype._getIdentifierMetadata = function (type) {\n type = resolveForwardRef(type);\n return { reference: type };\n };\n /**\n * @param {?} type\n * @return {?}\n */\n CompileMetadataResolver.prototype.isInjectable = function (type) {\n var /** @type {?} */ annotations = this._reflector.annotations(type);\n // Note: We need an exact check here as @Component / @Directive / ... inherit\n // from @CompilerInjectable!\n return annotations.some(function (ann) { return ann.constructor === Injectable; });\n };\n /**\n * @param {?} type\n * @return {?}\n */\n CompileMetadataResolver.prototype.getInjectableSummary = function (type) {\n return { summaryKind: cpl.CompileSummaryKind.Injectable, type: this._getTypeMetadata(type) };\n };\n /**\n * @param {?} type\n * @param {?=} dependencies\n * @return {?}\n */\n CompileMetadataResolver.prototype._getInjectableMetadata = function (type, dependencies) {\n if (dependencies === void 0) { dependencies = null; }\n var /** @type {?} */ typeSummary = this._loadSummary(type, cpl.CompileSummaryKind.Injectable);\n if (typeSummary) {\n return typeSummary.type;\n }\n return this._getTypeMetadata(type, dependencies);\n };\n /**\n * @param {?} type\n * @param {?=} dependencies\n * @return {?}\n */\n CompileMetadataResolver.prototype._getTypeMetadata = function (type, dependencies) {\n if (dependencies === void 0) { dependencies = null; }\n var /** @type {?} */ identifier = this._getIdentifierMetadata(type);\n return {\n reference: identifier.reference,\n diDeps: this._getDependenciesMetadata(identifier.reference, dependencies),\n lifecycleHooks: LIFECYCLE_HOOKS_VALUES.filter(function (hook) { return hasLifecycleHook(hook, identifier.reference); }),\n };\n };\n /**\n * @param {?} factory\n * @param {?=} dependencies\n * @return {?}\n */\n CompileMetadataResolver.prototype._getFactoryMetadata = function (factory, dependencies) {\n if (dependencies === void 0) { dependencies = null; }\n factory = resolveForwardRef(factory);\n return { reference: factory, diDeps: this._getDependenciesMetadata(factory, dependencies) };\n };\n /**\n * Gets the metadata for the given pipe.\n * This assumes `loadNgModuleMetadata` has been called first.\n * @param {?} pipeType\n * @return {?}\n */\n CompileMetadataResolver.prototype.getPipeMetadata = function (pipeType) {\n var /** @type {?} */ pipeMeta = this._pipeCache.get(pipeType);\n if (!pipeMeta) {\n this._reportError(new SyntaxError(\"Illegal state: getPipeMetadata can only be called after loadNgModuleMetadata for a module that declares it. Pipe \" + stringifyType(pipeType) + \".\"), pipeType);\n }\n return pipeMeta;\n };\n /**\n * @param {?} pipeType\n * @return {?}\n */\n CompileMetadataResolver.prototype.getPipeSummary = function (pipeType) {\n var /** @type {?} */ pipeSummary = (this._loadSummary(pipeType, cpl.CompileSummaryKind.Pipe));\n if (!pipeSummary) {\n this._reportError(new SyntaxError(\"Illegal state: Could not load the summary for pipe \" + stringifyType(pipeType) + \".\"), pipeType);\n }\n return pipeSummary;\n };\n /**\n * @param {?} pipeType\n * @return {?}\n */\n CompileMetadataResolver.prototype.getOrLoadPipeMetadata = function (pipeType) {\n var /** @type {?} */ pipeMeta = this._pipeCache.get(pipeType);\n if (!pipeMeta) {\n pipeMeta = this._loadPipeMetadata(pipeType);\n }\n return pipeMeta;\n };\n /**\n * @param {?} pipeType\n * @return {?}\n */\n CompileMetadataResolver.prototype._loadPipeMetadata = function (pipeType) {\n pipeType = resolveForwardRef(pipeType);\n var /** @type {?} */ pipeAnnotation = this._pipeResolver.resolve(pipeType);\n var /** @type {?} */ pipeMeta = new cpl.CompilePipeMetadata({\n type: this._getTypeMetadata(pipeType),\n name: pipeAnnotation.name,\n pure: pipeAnnotation.pure\n });\n this._pipeCache.set(pipeType, pipeMeta);\n this._summaryCache.set(pipeType, pipeMeta.toSummary());\n return pipeMeta;\n };\n /**\n * @param {?} typeOrFunc\n * @param {?} dependencies\n * @return {?}\n */\n CompileMetadataResolver.prototype._getDependenciesMetadata = function (typeOrFunc, dependencies) {\n var _this = this;\n var /** @type {?} */ hasUnknownDeps = false;\n var /** @type {?} */ params = dependencies || this._reflector.parameters(typeOrFunc) || [];\n var /** @type {?} */ dependenciesMetadata = params.map(function (param) {\n var /** @type {?} */ isAttribute = false;\n var /** @type {?} */ isHost = false;\n var /** @type {?} */ isSelf = false;\n var /** @type {?} */ isSkipSelf = false;\n var /** @type {?} */ isOptional = false;\n var /** @type {?} */ token = null;\n if (Array.isArray(param)) {\n param.forEach(function (paramEntry) {\n if (paramEntry instanceof Host) {\n isHost = true;\n }\n else if (paramEntry instanceof Self) {\n isSelf = true;\n }\n else if (paramEntry instanceof SkipSelf) {\n isSkipSelf = true;\n }\n else if (paramEntry instanceof Optional) {\n isOptional = true;\n }\n else if (paramEntry instanceof Attribute) {\n isAttribute = true;\n token = paramEntry.attributeName;\n }\n else if (paramEntry instanceof Inject) {\n token = paramEntry.token;\n }\n else if (isValidType(paramEntry) && isBlank(token)) {\n token = paramEntry;\n }\n });\n }\n else {\n token = param;\n }\n if (isBlank(token)) {\n hasUnknownDeps = true;\n return null;\n }\n return {\n isAttribute: isAttribute,\n isHost: isHost,\n isSelf: isSelf,\n isSkipSelf: isSkipSelf,\n isOptional: isOptional,\n token: _this._getTokenMetadata(token)\n };\n });\n if (hasUnknownDeps) {\n var /** @type {?} */ depsTokens = dependenciesMetadata.map(function (dep) { return dep ? stringifyType(dep.token) : '?'; }).join(', ');\n this._reportError(new SyntaxError(\"Can't resolve all parameters for \" + stringifyType(typeOrFunc) + \": (\" + depsTokens + \").\"), typeOrFunc);\n }\n return dependenciesMetadata;\n };\n /**\n * @param {?} token\n * @return {?}\n */\n CompileMetadataResolver.prototype._getTokenMetadata = function (token) {\n token = resolveForwardRef(token);\n var /** @type {?} */ compileToken;\n if (typeof token === 'string') {\n compileToken = { value: token };\n }\n else {\n compileToken = { identifier: { reference: token } };\n }\n return compileToken;\n };\n /**\n * @param {?} providers\n * @param {?} targetEntryComponents\n * @param {?=} debugInfo\n * @param {?=} compileProviders\n * @param {?=} type\n * @return {?}\n */\n CompileMetadataResolver.prototype._getProvidersMetadata = function (providers, targetEntryComponents, debugInfo, compileProviders, type) {\n var _this = this;\n if (compileProviders === void 0) { compileProviders = []; }\n providers.forEach(function (provider, providerIdx) {\n if (Array.isArray(provider)) {\n _this._getProvidersMetadata(provider, targetEntryComponents, debugInfo, compileProviders);\n }\n else {\n provider = resolveForwardRef(provider);\n var /** @type {?} */ providerMeta = void 0;\n if (provider && typeof provider == 'object' && provider.hasOwnProperty('provide')) {\n providerMeta = new cpl.ProviderMeta(provider.provide, provider);\n }\n else if (isValidType(provider)) {\n providerMeta = new cpl.ProviderMeta(provider, { useClass: provider });\n }\n else {\n var /** @type {?} */ providersInfo = ((providers.reduce(function (soFar, seenProvider, seenProviderIdx) {\n if (seenProviderIdx < providerIdx) {\n soFar.push(\"\" + stringifyType(seenProvider));\n }\n else if (seenProviderIdx == providerIdx) {\n soFar.push(\"?\" + stringifyType(seenProvider) + \"?\");\n }\n else if (seenProviderIdx == providerIdx + 1) {\n soFar.push('...');\n }\n return soFar;\n }, [])))\n .join(', ');\n _this._reportError(new SyntaxError(\"Invalid \" + (debugInfo ? debugInfo : 'provider') + \" - only instances of Provider and Type are allowed, got: [\" + providersInfo + \"]\"), type);\n }\n if (providerMeta.token === resolveIdentifier(Identifiers.ANALYZE_FOR_ENTRY_COMPONENTS)) {\n targetEntryComponents.push.apply(targetEntryComponents, _this._getEntryComponentsFromProvider(providerMeta, type));\n }\n else {\n compileProviders.push(_this.getProviderMetadata(providerMeta));\n }\n }\n });\n return compileProviders;\n };\n /**\n * @param {?} provider\n * @param {?=} type\n * @return {?}\n */\n CompileMetadataResolver.prototype._getEntryComponentsFromProvider = function (provider, type) {\n var _this = this;\n var /** @type {?} */ components = [];\n var /** @type {?} */ collectedIdentifiers = [];\n if (provider.useFactory || provider.useExisting || provider.useClass) {\n this._reportError(new SyntaxError(\"The ANALYZE_FOR_ENTRY_COMPONENTS token only supports useValue!\"), type);\n return [];\n }\n if (!provider.multi) {\n this._reportError(new SyntaxError(\"The ANALYZE_FOR_ENTRY_COMPONENTS token only supports 'multi = true'!\"), type);\n return [];\n }\n extractIdentifiers(provider.useValue, collectedIdentifiers);\n collectedIdentifiers.forEach(function (identifier) {\n if (_this._directiveResolver.isDirective(identifier.reference) ||\n _this._loadSummary(identifier.reference, cpl.CompileSummaryKind.Directive)) {\n components.push(identifier);\n }\n });\n return components;\n };\n /**\n * @param {?} provider\n * @return {?}\n */\n CompileMetadataResolver.prototype.getProviderMetadata = function (provider) {\n var /** @type {?} */ compileDeps;\n var /** @type {?} */ compileTypeMetadata = null;\n var /** @type {?} */ compileFactoryMetadata = null;\n var /** @type {?} */ token = this._getTokenMetadata(provider.token);\n if (provider.useClass) {\n compileTypeMetadata = this._getInjectableMetadata(provider.useClass, provider.dependencies);\n compileDeps = compileTypeMetadata.diDeps;\n if (provider.token === provider.useClass) {\n // use the compileTypeMetadata as it contains information about lifecycleHooks...\n token = { identifier: compileTypeMetadata };\n }\n }\n else if (provider.useFactory) {\n compileFactoryMetadata = this._getFactoryMetadata(provider.useFactory, provider.dependencies);\n compileDeps = compileFactoryMetadata.diDeps;\n }\n return {\n token: token,\n useClass: compileTypeMetadata,\n useValue: provider.useValue,\n useFactory: compileFactoryMetadata,\n useExisting: provider.useExisting ? this._getTokenMetadata(provider.useExisting) : null,\n deps: compileDeps,\n multi: provider.multi\n };\n };\n /**\n * @param {?} queries\n * @param {?} isViewQuery\n * @param {?} directiveType\n * @return {?}\n */\n CompileMetadataResolver.prototype._getQueriesMetadata = function (queries, isViewQuery, directiveType) {\n var _this = this;\n var /** @type {?} */ res = [];\n Object.keys(queries).forEach(function (propertyName) {\n var /** @type {?} */ query = queries[propertyName];\n if (query.isViewQuery === isViewQuery) {\n res.push(_this._getQueryMetadata(query, propertyName, directiveType));\n }\n });\n return res;\n };\n /**\n * @param {?} selector\n * @return {?}\n */\n CompileMetadataResolver.prototype._queryVarBindings = function (selector) { return selector.split(/\\s*,\\s*/); };\n /**\n * @param {?} q\n * @param {?} propertyName\n * @param {?} typeOrFunc\n * @return {?}\n */\n CompileMetadataResolver.prototype._getQueryMetadata = function (q, propertyName, typeOrFunc) {\n var _this = this;\n var /** @type {?} */ selectors;\n if (typeof q.selector === 'string') {\n selectors =\n this._queryVarBindings(q.selector).map(function (varName) { return _this._getTokenMetadata(varName); });\n }\n else {\n if (!q.selector) {\n this._reportError(new SyntaxError(\"Can't construct a query for the property \\\"\" + propertyName + \"\\\" of \\\"\" + stringifyType(typeOrFunc) + \"\\\" since the query selector wasn't defined.\"), typeOrFunc);\n }\n selectors = [this._getTokenMetadata(q.selector)];\n }\n return {\n selectors: selectors,\n first: q.first,\n descendants: q.descendants, propertyName: propertyName,\n read: q.read ? this._getTokenMetadata(q.read) : null\n };\n };\n /**\n * @param {?} error\n * @param {?=} type\n * @param {?=} otherType\n * @return {?}\n */\n CompileMetadataResolver.prototype._reportError = function (error, type, otherType) {\n if (this._errorCollector) {\n this._errorCollector(error, type);\n if (otherType) {\n this._errorCollector(error, otherType);\n }\n }\n else {\n throw error;\n }\n };\n /** @nocollapse */\n CompileMetadataResolver.ctorParameters = function () { return [\n { type: NgModuleResolver, },\n { type: DirectiveResolver, },\n { type: PipeResolver, },\n { type: SummaryResolver, },\n { type: ElementSchemaRegistry, },\n { type: DirectiveNormalizer, },\n { type: ReflectorReader, },\n { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [ERROR_COLLECTOR_TOKEN,] },] },\n ]; };\n CompileMetadataResolver = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [NgModuleResolver, DirectiveResolver, PipeResolver, SummaryResolver, ElementSchemaRegistry, DirectiveNormalizer, ReflectorReader, Function])\n ], CompileMetadataResolver);\n return CompileMetadataResolver;\n}());\nfunction CompileMetadataResolver_tsickle_Closure_declarations() {\n /**\n * @nocollapse\n * @type {?}\n */\n CompileMetadataResolver.ctorParameters;\n /** @type {?} */\n CompileMetadataResolver.prototype._directiveCache;\n /** @type {?} */\n CompileMetadataResolver.prototype._summaryCache;\n /** @type {?} */\n CompileMetadataResolver.prototype._pipeCache;\n /** @type {?} */\n CompileMetadataResolver.prototype._ngModuleCache;\n /** @type {?} */\n CompileMetadataResolver.prototype._ngModuleOfTypes;\n /** @type {?} */\n CompileMetadataResolver.prototype._ngModuleResolver;\n /** @type {?} */\n CompileMetadataResolver.prototype._directiveResolver;\n /** @type {?} */\n CompileMetadataResolver.prototype._pipeResolver;\n /** @type {?} */\n CompileMetadataResolver.prototype._summaryResolver;\n /** @type {?} */\n CompileMetadataResolver.prototype._schemaRegistry;\n /** @type {?} */\n CompileMetadataResolver.prototype._directiveNormalizer;\n /** @type {?} */\n CompileMetadataResolver.prototype._reflector;\n /** @type {?} */\n CompileMetadataResolver.prototype._errorCollector;\n}\n/**\n * @param {?} tree\n * @param {?=} out\n * @return {?}\n */\nfunction flattenArray(tree, out) {\n if (out === void 0) { out = []; }\n if (tree) {\n for (var /** @type {?} */ i = 0; i < tree.length; i++) {\n var /** @type {?} */ item = resolveForwardRef(tree[i]);\n if (Array.isArray(item)) {\n flattenArray(item, out);\n }\n else {\n out.push(item);\n }\n }\n }\n return out;\n}\n/**\n * @param {?} array\n * @return {?}\n */\nfunction dedupeArray(array) {\n if (array) {\n return Array.from(new Set(array));\n }\n return [];\n}\n/**\n * @param {?} tree\n * @return {?}\n */\nfunction flattenAndDedupeArray(tree) {\n return dedupeArray(flattenArray(tree));\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction isValidType(value) {\n return (value instanceof StaticSymbol) || (value instanceof Type);\n}\n/**\n * @param {?} reflector\n * @param {?} type\n * @param {?} cmpMetadata\n * @return {?}\n */\nexport function componentModuleUrl(reflector, type, cmpMetadata) {\n if (type instanceof StaticSymbol) {\n return type.filePath;\n }\n var /** @type {?} */ moduleId = cmpMetadata.moduleId;\n if (typeof moduleId === 'string') {\n var /** @type {?} */ scheme = getUrlScheme(moduleId);\n return scheme ? moduleId : \"package:\" + moduleId + MODULE_SUFFIX;\n }\n else if (moduleId !== null && moduleId !== void 0) {\n throw new SyntaxError((\"moduleId should be a string in \\\"\" + stringifyType(type) + \"\\\". See https://goo.gl/wIDDiL for more information.\\n\") +\n \"If you're using Webpack you should inline the template and the styles, see https://goo.gl/X2J8zc.\");\n }\n return reflector.importUri(type);\n}\n/**\n * @param {?} value\n * @param {?} targetIdentifiers\n * @return {?}\n */\nfunction extractIdentifiers(value, targetIdentifiers) {\n visitValue(value, new _CompileValueConverter(), targetIdentifiers);\n}\nvar _CompileValueConverter = (function (_super) {\n __extends(_CompileValueConverter, _super);\n function _CompileValueConverter() {\n _super.apply(this, arguments);\n }\n /**\n * @param {?} value\n * @param {?} targetIdentifiers\n * @return {?}\n */\n _CompileValueConverter.prototype.visitOther = function (value, targetIdentifiers) {\n targetIdentifiers.push({ reference: value });\n };\n return _CompileValueConverter;\n}(ValueTransformer));\n/**\n * @param {?} type\n * @return {?}\n */\nfunction stringifyType(type) {\n if (type instanceof StaticSymbol) {\n return type.name + \" in \" + type.filePath;\n }\n else {\n return stringify(type);\n }\n}\n//# sourceMappingURL=metadata_resolver.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/metadata_resolver.js\n// module id = ./node_modules/@angular/compiler/src/metadata_resolver.js\n// module chunks = 0","/**\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 */\nexport var Text = (function () {\n /**\n * @param {?} value\n * @param {?} sourceSpan\n */\n function Text(value, sourceSpan) {\n this.value = value;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n Text.prototype.visit = function (visitor, context) { return visitor.visitText(this, context); };\n return Text;\n}());\nfunction Text_tsickle_Closure_declarations() {\n /** @type {?} */\n Text.prototype.value;\n /** @type {?} */\n Text.prototype.sourceSpan;\n}\nexport var Expansion = (function () {\n /**\n * @param {?} switchValue\n * @param {?} type\n * @param {?} cases\n * @param {?} sourceSpan\n * @param {?} switchValueSourceSpan\n */\n function Expansion(switchValue, type, cases, sourceSpan, switchValueSourceSpan) {\n this.switchValue = switchValue;\n this.type = type;\n this.cases = cases;\n this.sourceSpan = sourceSpan;\n this.switchValueSourceSpan = switchValueSourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n Expansion.prototype.visit = function (visitor, context) { return visitor.visitExpansion(this, context); };\n return Expansion;\n}());\nfunction Expansion_tsickle_Closure_declarations() {\n /** @type {?} */\n Expansion.prototype.switchValue;\n /** @type {?} */\n Expansion.prototype.type;\n /** @type {?} */\n Expansion.prototype.cases;\n /** @type {?} */\n Expansion.prototype.sourceSpan;\n /** @type {?} */\n Expansion.prototype.switchValueSourceSpan;\n}\nexport var ExpansionCase = (function () {\n /**\n * @param {?} value\n * @param {?} expression\n * @param {?} sourceSpan\n * @param {?} valueSourceSpan\n * @param {?} expSourceSpan\n */\n function ExpansionCase(value, expression, sourceSpan, valueSourceSpan, expSourceSpan) {\n this.value = value;\n this.expression = expression;\n this.sourceSpan = sourceSpan;\n this.valueSourceSpan = valueSourceSpan;\n this.expSourceSpan = expSourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ExpansionCase.prototype.visit = function (visitor, context) { return visitor.visitExpansionCase(this, context); };\n return ExpansionCase;\n}());\nfunction ExpansionCase_tsickle_Closure_declarations() {\n /** @type {?} */\n ExpansionCase.prototype.value;\n /** @type {?} */\n ExpansionCase.prototype.expression;\n /** @type {?} */\n ExpansionCase.prototype.sourceSpan;\n /** @type {?} */\n ExpansionCase.prototype.valueSourceSpan;\n /** @type {?} */\n ExpansionCase.prototype.expSourceSpan;\n}\nexport var Attribute = (function () {\n /**\n * @param {?} name\n * @param {?} value\n * @param {?} sourceSpan\n * @param {?=} valueSpan\n */\n function Attribute(name, value, sourceSpan, valueSpan) {\n this.name = name;\n this.value = value;\n this.sourceSpan = sourceSpan;\n this.valueSpan = valueSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n Attribute.prototype.visit = function (visitor, context) { return visitor.visitAttribute(this, context); };\n return Attribute;\n}());\nfunction Attribute_tsickle_Closure_declarations() {\n /** @type {?} */\n Attribute.prototype.name;\n /** @type {?} */\n Attribute.prototype.value;\n /** @type {?} */\n Attribute.prototype.sourceSpan;\n /** @type {?} */\n Attribute.prototype.valueSpan;\n}\nexport var Element = (function () {\n /**\n * @param {?} name\n * @param {?} attrs\n * @param {?} children\n * @param {?} sourceSpan\n * @param {?} startSourceSpan\n * @param {?} endSourceSpan\n */\n function Element(name, attrs, children, sourceSpan, startSourceSpan, endSourceSpan) {\n this.name = name;\n this.attrs = attrs;\n this.children = children;\n this.sourceSpan = sourceSpan;\n this.startSourceSpan = startSourceSpan;\n this.endSourceSpan = endSourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n Element.prototype.visit = function (visitor, context) { return visitor.visitElement(this, context); };\n return Element;\n}());\nfunction Element_tsickle_Closure_declarations() {\n /** @type {?} */\n Element.prototype.name;\n /** @type {?} */\n Element.prototype.attrs;\n /** @type {?} */\n Element.prototype.children;\n /** @type {?} */\n Element.prototype.sourceSpan;\n /** @type {?} */\n Element.prototype.startSourceSpan;\n /** @type {?} */\n Element.prototype.endSourceSpan;\n}\nexport var Comment = (function () {\n /**\n * @param {?} value\n * @param {?} sourceSpan\n */\n function Comment(value, sourceSpan) {\n this.value = value;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n Comment.prototype.visit = function (visitor, context) { return visitor.visitComment(this, context); };\n return Comment;\n}());\nfunction Comment_tsickle_Closure_declarations() {\n /** @type {?} */\n Comment.prototype.value;\n /** @type {?} */\n Comment.prototype.sourceSpan;\n}\n/**\n * @param {?} visitor\n * @param {?} nodes\n * @param {?=} context\n * @return {?}\n */\nexport function visitAll(visitor, nodes, context) {\n if (context === void 0) { context = null; }\n var /** @type {?} */ result = [];\n var /** @type {?} */ visit = visitor.visit ?\n function (ast) { return visitor.visit(ast, context) || ast.visit(visitor, context); } :\n function (ast) { return ast.visit(visitor, context); };\n nodes.forEach(function (ast) {\n var /** @type {?} */ astResult = visit(ast);\n if (astResult) {\n result.push(astResult);\n }\n });\n return result;\n}\n//# sourceMappingURL=ast.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/ml_parser/ast.js\n// module id = ./node_modules/@angular/compiler/src/ml_parser/ast.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { CompilerInjectable } from '../injectable';\nimport { getHtmlTagDefinition } from './html_tags';\nimport { DEFAULT_INTERPOLATION_CONFIG } from './interpolation_config';\nimport { Parser } from './parser';\nexport { ParseTreeResult, TreeError } from './parser';\nexport var HtmlParser = (function (_super) {\n __extends(HtmlParser, _super);\n function HtmlParser() {\n _super.call(this, getHtmlTagDefinition);\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 HtmlParser = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [])\n ], HtmlParser);\n return HtmlParser;\n}(Parser));\n//# sourceMappingURL=html_parser.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/ml_parser/html_parser.js\n// module id = ./node_modules/@angular/compiler/src/ml_parser/html_parser.js\n// module chunks = 0","/**\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 */\nimport { TagContentType } from './tags';\nexport var HtmlTagDefinition = (function () {\n /**\n * @param {?=} __0\n */\n function HtmlTagDefinition(_a) {\n var _this = this;\n var _b = _a === void 0 ? {} : _a, closedByChildren = _b.closedByChildren, requiredParents = _b.requiredParents, implicitNamespacePrefix = _b.implicitNamespacePrefix, _c = _b.contentType, contentType = _c === void 0 ? TagContentType.PARSABLE_DATA : _c, _d = _b.closedByParent, closedByParent = _d === void 0 ? false : _d, _e = _b.isVoid, isVoid = _e === void 0 ? false : _e, _f = _b.ignoreFirstLf, ignoreFirstLf = _f === void 0 ? false : _f;\n this.closedByChildren = {};\n this.closedByParent = false;\n this.canSelfClose = false;\n if (closedByChildren && closedByChildren.length > 0) {\n closedByChildren.forEach(function (tagName) { return _this.closedByChildren[tagName] = true; });\n }\n this.isVoid = isVoid;\n this.closedByParent = closedByParent || isVoid;\n if (requiredParents && requiredParents.length > 0) {\n this.requiredParents = {};\n // The first parent is the list is automatically when none of the listed parents are present\n this.parentToAdd = requiredParents[0];\n requiredParents.forEach(function (tagName) { return _this.requiredParents[tagName] = true; });\n }\n this.implicitNamespacePrefix = implicitNamespacePrefix;\n this.contentType = contentType;\n this.ignoreFirstLf = ignoreFirstLf;\n }\n /**\n * @param {?} currentParent\n * @return {?}\n */\n HtmlTagDefinition.prototype.requireExtraParent = function (currentParent) {\n if (!this.requiredParents) {\n return false;\n }\n if (!currentParent) {\n return true;\n }\n var /** @type {?} */ lcParent = currentParent.toLowerCase();\n return this.requiredParents[lcParent] != true && lcParent != 'template';\n };\n /**\n * @param {?} name\n * @return {?}\n */\n HtmlTagDefinition.prototype.isClosedByChild = function (name) {\n return this.isVoid || name.toLowerCase() in this.closedByChildren;\n };\n return HtmlTagDefinition;\n}());\nfunction HtmlTagDefinition_tsickle_Closure_declarations() {\n /** @type {?} */\n HtmlTagDefinition.prototype.closedByChildren;\n /** @type {?} */\n HtmlTagDefinition.prototype.closedByParent;\n /** @type {?} */\n HtmlTagDefinition.prototype.requiredParents;\n /** @type {?} */\n HtmlTagDefinition.prototype.parentToAdd;\n /** @type {?} */\n HtmlTagDefinition.prototype.implicitNamespacePrefix;\n /** @type {?} */\n HtmlTagDefinition.prototype.contentType;\n /** @type {?} */\n HtmlTagDefinition.prototype.isVoid;\n /** @type {?} */\n HtmlTagDefinition.prototype.ignoreFirstLf;\n /** @type {?} */\n HtmlTagDefinition.prototype.canSelfClose;\n}\n// see http://www.w3.org/TR/html51/syntax.html#optional-tags\n// This implementation does not fully conform to the HTML5 spec.\nvar /** @type {?} */ TAG_DEFINITIONS = {\n 'base': new HtmlTagDefinition({ isVoid: true }),\n 'meta': new HtmlTagDefinition({ isVoid: true }),\n 'area': new HtmlTagDefinition({ isVoid: true }),\n 'embed': new HtmlTagDefinition({ isVoid: true }),\n 'link': new HtmlTagDefinition({ isVoid: true }),\n 'img': new HtmlTagDefinition({ isVoid: true }),\n 'input': new HtmlTagDefinition({ isVoid: true }),\n 'param': new HtmlTagDefinition({ isVoid: true }),\n 'hr': new HtmlTagDefinition({ isVoid: true }),\n 'br': new HtmlTagDefinition({ isVoid: true }),\n 'source': new HtmlTagDefinition({ isVoid: true }),\n 'track': new HtmlTagDefinition({ isVoid: true }),\n 'wbr': new HtmlTagDefinition({ isVoid: true }),\n 'p': new HtmlTagDefinition({\n closedByChildren: [\n 'address', 'article', 'aside', 'blockquote', 'div', 'dl', 'fieldset', 'footer', 'form',\n 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'hr',\n 'main', 'nav', 'ol', 'p', 'pre', 'section', 'table', 'ul'\n ],\n closedByParent: true\n }),\n 'thead': new HtmlTagDefinition({ closedByChildren: ['tbody', 'tfoot'] }),\n 'tbody': new HtmlTagDefinition({ closedByChildren: ['tbody', 'tfoot'], closedByParent: true }),\n 'tfoot': new HtmlTagDefinition({ closedByChildren: ['tbody'], closedByParent: true }),\n 'tr': new HtmlTagDefinition({\n closedByChildren: ['tr'],\n requiredParents: ['tbody', 'tfoot', 'thead'],\n closedByParent: true\n }),\n 'td': new HtmlTagDefinition({ closedByChildren: ['td', 'th'], closedByParent: true }),\n 'th': new HtmlTagDefinition({ closedByChildren: ['td', 'th'], closedByParent: true }),\n 'col': new HtmlTagDefinition({ requiredParents: ['colgroup'], isVoid: true }),\n 'svg': new HtmlTagDefinition({ implicitNamespacePrefix: 'svg' }),\n 'math': new HtmlTagDefinition({ implicitNamespacePrefix: 'math' }),\n 'li': new HtmlTagDefinition({ closedByChildren: ['li'], closedByParent: true }),\n 'dt': new HtmlTagDefinition({ closedByChildren: ['dt', 'dd'] }),\n 'dd': new HtmlTagDefinition({ closedByChildren: ['dt', 'dd'], closedByParent: true }),\n 'rb': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),\n 'rt': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),\n 'rtc': new HtmlTagDefinition({ closedByChildren: ['rb', 'rtc', 'rp'], closedByParent: true }),\n 'rp': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),\n 'optgroup': new HtmlTagDefinition({ closedByChildren: ['optgroup'], closedByParent: true }),\n 'option': new HtmlTagDefinition({ closedByChildren: ['option', 'optgroup'], closedByParent: true }),\n 'pre': new HtmlTagDefinition({ ignoreFirstLf: true }),\n 'listing': new HtmlTagDefinition({ ignoreFirstLf: true }),\n 'style': new HtmlTagDefinition({ contentType: TagContentType.RAW_TEXT }),\n 'script': new HtmlTagDefinition({ contentType: TagContentType.RAW_TEXT }),\n 'title': new HtmlTagDefinition({ contentType: TagContentType.ESCAPABLE_RAW_TEXT }),\n 'textarea': new HtmlTagDefinition({ contentType: TagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true }),\n};\nvar /** @type {?} */ _DEFAULT_TAG_DEFINITION = new HtmlTagDefinition();\n/**\n * @param {?} tagName\n * @return {?}\n */\nexport function getHtmlTagDefinition(tagName) {\n return TAG_DEFINITIONS[tagName.toLowerCase()] || _DEFAULT_TAG_DEFINITION;\n}\n//# sourceMappingURL=html_tags.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/ml_parser/html_tags.js\n// module id = ./node_modules/@angular/compiler/src/ml_parser/html_tags.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nimport { ParseError } from '../parse_util';\nimport * as html from './ast';\n// http://cldr.unicode.org/index/cldr-spec/plural-rules\nvar /** @type {?} */ 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 */\nexport function expandNodes(nodes) {\n var /** @type {?} */ expander = new _Expander();\n return new ExpansionResult(html.visitAll(expander, nodes), expander.isExpanded, expander.errors);\n}\nexport var 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}());\nfunction ExpansionResult_tsickle_Closure_declarations() {\n /** @type {?} */\n ExpansionResult.prototype.nodes;\n /** @type {?} */\n ExpansionResult.prototype.expanded;\n /** @type {?} */\n ExpansionResult.prototype.errors;\n}\nexport var ExpansionError = (function (_super) {\n __extends(ExpansionError, _super);\n /**\n * @param {?} span\n * @param {?} errorMsg\n */\n function ExpansionError(span, errorMsg) {\n _super.call(this, span, errorMsg);\n }\n return ExpansionError;\n}(ParseError));\n/**\n * Expand expansion forms (plural, select) to directives\n * *\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 html.Element(element.name, element.attrs, html.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}());\nfunction _Expander_tsickle_Closure_declarations() {\n /** @type {?} */\n _Expander.prototype.isExpanded;\n /** @type {?} */\n _Expander.prototype.errors;\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 html.Element(\"template\", [new html.Attribute('ngPluralCase', \"\" + c.value, c.valueSourceSpan)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);\n });\n var /** @type {?} */ switchAttr = new html.Attribute('[ngPlural]', ast.switchValue, ast.switchValueSourceSpan);\n return new html.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 html.Element(\"template\", [new html.Attribute('ngSwitchDefault', '', c.valueSourceSpan)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);\n }\n return new html.Element(\"template\", [new html.Attribute('ngSwitchCase', \"\" + c.value, c.valueSourceSpan)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);\n });\n var /** @type {?} */ switchAttr = new html.Attribute('[ngSwitch]', ast.switchValue, ast.switchValueSourceSpan);\n return new html.Element('ng-container', [switchAttr], children, ast.sourceSpan, ast.sourceSpan, ast.sourceSpan);\n}\n//# sourceMappingURL=icu_ast_expander.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/ml_parser/icu_ast_expander.js\n// module id = ./node_modules/@angular/compiler/src/ml_parser/icu_ast_expander.js\n// module chunks = 0","/**\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 */\nimport { assertInterpolationSymbols } from '../assertions';\nexport var InterpolationConfig = (function () {\n /**\n * @param {?} start\n * @param {?} end\n */\n function InterpolationConfig(start, end) {\n this.start = start;\n this.end = end;\n }\n /**\n * @param {?} markers\n * @return {?}\n */\n InterpolationConfig.fromArray = function (markers) {\n if (!markers) {\n return DEFAULT_INTERPOLATION_CONFIG;\n }\n assertInterpolationSymbols('interpolation', markers);\n return new InterpolationConfig(markers[0], markers[1]);\n };\n ;\n return InterpolationConfig;\n}());\nfunction InterpolationConfig_tsickle_Closure_declarations() {\n /** @type {?} */\n InterpolationConfig.prototype.start;\n /** @type {?} */\n InterpolationConfig.prototype.end;\n}\nexport var /** @type {?} */ DEFAULT_INTERPOLATION_CONFIG = new InterpolationConfig('{{', '}}');\n//# sourceMappingURL=interpolation_config.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/ml_parser/interpolation_config.js\n// module id = ./node_modules/@angular/compiler/src/ml_parser/interpolation_config.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nimport * as chars from '../chars';\nimport { ParseError, ParseLocation, ParseSourceFile, ParseSourceSpan } from '../parse_util';\nimport { DEFAULT_INTERPOLATION_CONFIG } from './interpolation_config';\nimport { NAMED_ENTITIES, TagContentType } from './tags';\nexport var TokenType = {};\nTokenType.TAG_OPEN_START = 0;\nTokenType.TAG_OPEN_END = 1;\nTokenType.TAG_OPEN_END_VOID = 2;\nTokenType.TAG_CLOSE = 3;\nTokenType.TEXT = 4;\nTokenType.ESCAPABLE_RAW_TEXT = 5;\nTokenType.RAW_TEXT = 6;\nTokenType.COMMENT_START = 7;\nTokenType.COMMENT_END = 8;\nTokenType.CDATA_START = 9;\nTokenType.CDATA_END = 10;\nTokenType.ATTR_NAME = 11;\nTokenType.ATTR_VALUE = 12;\nTokenType.DOC_TYPE = 13;\nTokenType.EXPANSION_FORM_START = 14;\nTokenType.EXPANSION_CASE_VALUE = 15;\nTokenType.EXPANSION_CASE_EXP_START = 16;\nTokenType.EXPANSION_CASE_EXP_END = 17;\nTokenType.EXPANSION_FORM_END = 18;\nTokenType.EOF = 19;\nTokenType[TokenType.TAG_OPEN_START] = \"TAG_OPEN_START\";\nTokenType[TokenType.TAG_OPEN_END] = \"TAG_OPEN_END\";\nTokenType[TokenType.TAG_OPEN_END_VOID] = \"TAG_OPEN_END_VOID\";\nTokenType[TokenType.TAG_CLOSE] = \"TAG_CLOSE\";\nTokenType[TokenType.TEXT] = \"TEXT\";\nTokenType[TokenType.ESCAPABLE_RAW_TEXT] = \"ESCAPABLE_RAW_TEXT\";\nTokenType[TokenType.RAW_TEXT] = \"RAW_TEXT\";\nTokenType[TokenType.COMMENT_START] = \"COMMENT_START\";\nTokenType[TokenType.COMMENT_END] = \"COMMENT_END\";\nTokenType[TokenType.CDATA_START] = \"CDATA_START\";\nTokenType[TokenType.CDATA_END] = \"CDATA_END\";\nTokenType[TokenType.ATTR_NAME] = \"ATTR_NAME\";\nTokenType[TokenType.ATTR_VALUE] = \"ATTR_VALUE\";\nTokenType[TokenType.DOC_TYPE] = \"DOC_TYPE\";\nTokenType[TokenType.EXPANSION_FORM_START] = \"EXPANSION_FORM_START\";\nTokenType[TokenType.EXPANSION_CASE_VALUE] = \"EXPANSION_CASE_VALUE\";\nTokenType[TokenType.EXPANSION_CASE_EXP_START] = \"EXPANSION_CASE_EXP_START\";\nTokenType[TokenType.EXPANSION_CASE_EXP_END] = \"EXPANSION_CASE_EXP_END\";\nTokenType[TokenType.EXPANSION_FORM_END] = \"EXPANSION_FORM_END\";\nTokenType[TokenType.EOF] = \"EOF\";\nexport var Token = (function () {\n /**\n * @param {?} type\n * @param {?} parts\n * @param {?} sourceSpan\n */\n function Token(type, parts, sourceSpan) {\n this.type = type;\n this.parts = parts;\n this.sourceSpan = sourceSpan;\n }\n return Token;\n}());\nfunction Token_tsickle_Closure_declarations() {\n /** @type {?} */\n Token.prototype.type;\n /** @type {?} */\n Token.prototype.parts;\n /** @type {?} */\n Token.prototype.sourceSpan;\n}\nexport var TokenError = (function (_super) {\n __extends(TokenError, _super);\n /**\n * @param {?} errorMsg\n * @param {?} tokenType\n * @param {?} span\n */\n function TokenError(errorMsg, tokenType, span) {\n _super.call(this, span, errorMsg);\n this.tokenType = tokenType;\n }\n return TokenError;\n}(ParseError));\nfunction TokenError_tsickle_Closure_declarations() {\n /** @type {?} */\n TokenError.prototype.tokenType;\n}\nexport var TokenizeResult = (function () {\n /**\n * @param {?} tokens\n * @param {?} errors\n */\n function TokenizeResult(tokens, errors) {\n this.tokens = tokens;\n this.errors = errors;\n }\n return TokenizeResult;\n}());\nfunction TokenizeResult_tsickle_Closure_declarations() {\n /** @type {?} */\n TokenizeResult.prototype.tokens;\n /** @type {?} */\n TokenizeResult.prototype.errors;\n}\n/**\n * @param {?} source\n * @param {?} url\n * @param {?} getTagDefinition\n * @param {?=} tokenizeExpansionForms\n * @param {?=} interpolationConfig\n * @return {?}\n */\nexport function tokenize(source, url, getTagDefinition, tokenizeExpansionForms, interpolationConfig) {\n if (tokenizeExpansionForms === void 0) { tokenizeExpansionForms = false; }\n if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n return new _Tokenizer(new ParseSourceFile(source, url), getTagDefinition, tokenizeExpansionForms, interpolationConfig)\n .tokenize();\n}\nvar /** @type {?} */ _CR_OR_CRLF_REGEXP = /\\r\\n?/g;\n/**\n * @param {?} charCode\n * @return {?}\n */\nfunction _unexpectedCharacterErrorMsg(charCode) {\n var /** @type {?} */ char = charCode === chars.$EOF ? 'EOF' : String.fromCharCode(charCode);\n return \"Unexpected character \\\"\" + char + \"\\\"\";\n}\n/**\n * @param {?} entitySrc\n * @return {?}\n */\nfunction _unknownEntityErrorMsg(entitySrc) {\n return \"Unknown entity \\\"\" + entitySrc + \"\\\" - use the \\\"&#;\\\" or \\\"&#x;\\\" syntax\";\n}\nvar _ControlFlowError = (function () {\n /**\n * @param {?} error\n */\n function _ControlFlowError(error) {\n this.error = error;\n }\n return _ControlFlowError;\n}());\nfunction _ControlFlowError_tsickle_Closure_declarations() {\n /** @type {?} */\n _ControlFlowError.prototype.error;\n}\n// See http://www.w3.org/TR/html51/syntax.html#writing\nvar _Tokenizer = (function () {\n /**\n * @param {?} _file The html source\n * @param {?} _getTagDefinition\n * @param {?} _tokenizeIcu Whether to tokenize ICU messages (considered as text nodes when false)\n * @param {?=} _interpolationConfig\n */\n function _Tokenizer(_file, _getTagDefinition, _tokenizeIcu, _interpolationConfig) {\n if (_interpolationConfig === void 0) { _interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n this._file = _file;\n this._getTagDefinition = _getTagDefinition;\n this._tokenizeIcu = _tokenizeIcu;\n this._interpolationConfig = _interpolationConfig;\n this._peek = -1;\n this._nextPeek = -1;\n this._index = -1;\n this._line = 0;\n this._column = -1;\n this._expansionCaseStack = [];\n this._inInterpolation = false;\n this.tokens = [];\n this.errors = [];\n this._input = _file.content;\n this._length = _file.content.length;\n this._advance();\n }\n /**\n * @param {?} content\n * @return {?}\n */\n _Tokenizer.prototype._processCarriageReturns = function (content) {\n // http://www.w3.org/TR/html5/syntax.html#preprocessing-the-input-stream\n // In order to keep the original position in the source, we can not\n // pre-process it.\n // Instead CRs are processed right before instantiating the tokens.\n return content.replace(_CR_OR_CRLF_REGEXP, '\\n');\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype.tokenize = function () {\n while (this._peek !== chars.$EOF) {\n var /** @type {?} */ start = this._getLocation();\n try {\n if (this._attemptCharCode(chars.$LT)) {\n if (this._attemptCharCode(chars.$BANG)) {\n if (this._attemptCharCode(chars.$LBRACKET)) {\n this._consumeCdata(start);\n }\n else if (this._attemptCharCode(chars.$MINUS)) {\n this._consumeComment(start);\n }\n else {\n this._consumeDocType(start);\n }\n }\n else if (this._attemptCharCode(chars.$SLASH)) {\n this._consumeTagClose(start);\n }\n else {\n this._consumeTagOpen(start);\n }\n }\n else if (!(this._tokenizeIcu && this._tokenizeExpansionForm())) {\n this._consumeText();\n }\n }\n catch (e) {\n if (e instanceof _ControlFlowError) {\n this.errors.push(e.error);\n }\n else {\n throw e;\n }\n }\n }\n this._beginToken(TokenType.EOF);\n this._endToken([]);\n return new TokenizeResult(mergeTextTokens(this.tokens), this.errors);\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._tokenizeExpansionForm = function () {\n if (isExpansionFormStart(this._input, this._index, this._interpolationConfig)) {\n this._consumeExpansionFormStart();\n return true;\n }\n if (isExpansionCaseStart(this._peek) && this._isInExpansionForm()) {\n this._consumeExpansionCaseStart();\n return true;\n }\n if (this._peek === chars.$RBRACE) {\n if (this._isInExpansionCase()) {\n this._consumeExpansionCaseEnd();\n return true;\n }\n if (this._isInExpansionForm()) {\n this._consumeExpansionFormEnd();\n return true;\n }\n }\n return false;\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._getLocation = function () {\n return new ParseLocation(this._file, this._index, this._line, this._column);\n };\n /**\n * @param {?=} start\n * @param {?=} end\n * @return {?}\n */\n _Tokenizer.prototype._getSpan = function (start, end) {\n if (start === void 0) { start = this._getLocation(); }\n if (end === void 0) { end = this._getLocation(); }\n return new ParseSourceSpan(start, end);\n };\n /**\n * @param {?} type\n * @param {?=} start\n * @return {?}\n */\n _Tokenizer.prototype._beginToken = function (type, start) {\n if (start === void 0) { start = this._getLocation(); }\n this._currentTokenStart = start;\n this._currentTokenType = type;\n };\n /**\n * @param {?} parts\n * @param {?=} end\n * @return {?}\n */\n _Tokenizer.prototype._endToken = function (parts, end) {\n if (end === void 0) { end = this._getLocation(); }\n var /** @type {?} */ token = new Token(this._currentTokenType, parts, new ParseSourceSpan(this._currentTokenStart, end));\n this.tokens.push(token);\n this._currentTokenStart = null;\n this._currentTokenType = null;\n return token;\n };\n /**\n * @param {?} msg\n * @param {?} span\n * @return {?}\n */\n _Tokenizer.prototype._createError = function (msg, span) {\n if (this._isInExpansionForm()) {\n msg += \" (Do you have an unescaped \\\"{\\\" in your template? Use \\\"{{ '{' }}\\\") to escape it.)\";\n }\n var /** @type {?} */ error = new TokenError(msg, this._currentTokenType, span);\n this._currentTokenStart = null;\n this._currentTokenType = null;\n return new _ControlFlowError(error);\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._advance = function () {\n if (this._index >= this._length) {\n throw this._createError(_unexpectedCharacterErrorMsg(chars.$EOF), this._getSpan());\n }\n if (this._peek === chars.$LF) {\n this._line++;\n this._column = 0;\n }\n else if (this._peek !== chars.$LF && this._peek !== chars.$CR) {\n this._column++;\n }\n this._index++;\n this._peek = this._index >= this._length ? chars.$EOF : this._input.charCodeAt(this._index);\n this._nextPeek =\n this._index + 1 >= this._length ? chars.$EOF : this._input.charCodeAt(this._index + 1);\n };\n /**\n * @param {?} charCode\n * @return {?}\n */\n _Tokenizer.prototype._attemptCharCode = function (charCode) {\n if (this._peek === charCode) {\n this._advance();\n return true;\n }\n return false;\n };\n /**\n * @param {?} charCode\n * @return {?}\n */\n _Tokenizer.prototype._attemptCharCodeCaseInsensitive = function (charCode) {\n if (compareCharCodeCaseInsensitive(this._peek, charCode)) {\n this._advance();\n return true;\n }\n return false;\n };\n /**\n * @param {?} charCode\n * @return {?}\n */\n _Tokenizer.prototype._requireCharCode = function (charCode) {\n var /** @type {?} */ location = this._getLocation();\n if (!this._attemptCharCode(charCode)) {\n throw this._createError(_unexpectedCharacterErrorMsg(this._peek), this._getSpan(location, location));\n }\n };\n /**\n * @param {?} chars\n * @return {?}\n */\n _Tokenizer.prototype._attemptStr = function (chars) {\n var /** @type {?} */ len = chars.length;\n if (this._index + len > this._length) {\n return false;\n }\n var /** @type {?} */ initialPosition = this._savePosition();\n for (var /** @type {?} */ i = 0; i < len; i++) {\n if (!this._attemptCharCode(chars.charCodeAt(i))) {\n // If attempting to parse the string fails, we want to reset the parser\n // to where it was before the attempt\n this._restorePosition(initialPosition);\n return false;\n }\n }\n return true;\n };\n /**\n * @param {?} chars\n * @return {?}\n */\n _Tokenizer.prototype._attemptStrCaseInsensitive = function (chars) {\n for (var /** @type {?} */ i = 0; i < chars.length; i++) {\n if (!this._attemptCharCodeCaseInsensitive(chars.charCodeAt(i))) {\n return false;\n }\n }\n return true;\n };\n /**\n * @param {?} chars\n * @return {?}\n */\n _Tokenizer.prototype._requireStr = function (chars) {\n var /** @type {?} */ location = this._getLocation();\n if (!this._attemptStr(chars)) {\n throw this._createError(_unexpectedCharacterErrorMsg(this._peek), this._getSpan(location));\n }\n };\n /**\n * @param {?} predicate\n * @return {?}\n */\n _Tokenizer.prototype._attemptCharCodeUntilFn = function (predicate) {\n while (!predicate(this._peek)) {\n this._advance();\n }\n };\n /**\n * @param {?} predicate\n * @param {?} len\n * @return {?}\n */\n _Tokenizer.prototype._requireCharCodeUntilFn = function (predicate, len) {\n var /** @type {?} */ start = this._getLocation();\n this._attemptCharCodeUntilFn(predicate);\n if (this._index - start.offset < len) {\n throw this._createError(_unexpectedCharacterErrorMsg(this._peek), this._getSpan(start, start));\n }\n };\n /**\n * @param {?} char\n * @return {?}\n */\n _Tokenizer.prototype._attemptUntilChar = function (char) {\n while (this._peek !== char) {\n this._advance();\n }\n };\n /**\n * @param {?} decodeEntities\n * @return {?}\n */\n _Tokenizer.prototype._readChar = function (decodeEntities) {\n if (decodeEntities && this._peek === chars.$AMPERSAND) {\n return this._decodeEntity();\n }\n else {\n var /** @type {?} */ index = this._index;\n this._advance();\n return this._input[index];\n }\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._decodeEntity = function () {\n var /** @type {?} */ start = this._getLocation();\n this._advance();\n if (this._attemptCharCode(chars.$HASH)) {\n var /** @type {?} */ isHex = this._attemptCharCode(chars.$x) || this._attemptCharCode(chars.$X);\n var /** @type {?} */ numberStart = this._getLocation().offset;\n this._attemptCharCodeUntilFn(isDigitEntityEnd);\n if (this._peek != chars.$SEMICOLON) {\n throw this._createError(_unexpectedCharacterErrorMsg(this._peek), this._getSpan());\n }\n this._advance();\n var /** @type {?} */ strNum = this._input.substring(numberStart, this._index - 1);\n try {\n var /** @type {?} */ charCode = parseInt(strNum, isHex ? 16 : 10);\n return String.fromCharCode(charCode);\n }\n catch (e) {\n var /** @type {?} */ entity = this._input.substring(start.offset + 1, this._index - 1);\n throw this._createError(_unknownEntityErrorMsg(entity), this._getSpan(start));\n }\n }\n else {\n var /** @type {?} */ startPosition = this._savePosition();\n this._attemptCharCodeUntilFn(isNamedEntityEnd);\n if (this._peek != chars.$SEMICOLON) {\n this._restorePosition(startPosition);\n return '&';\n }\n this._advance();\n var /** @type {?} */ name_1 = this._input.substring(start.offset + 1, this._index - 1);\n var /** @type {?} */ char = NAMED_ENTITIES[name_1];\n if (!char) {\n throw this._createError(_unknownEntityErrorMsg(name_1), this._getSpan(start));\n }\n return char;\n }\n };\n /**\n * @param {?} decodeEntities\n * @param {?} firstCharOfEnd\n * @param {?} attemptEndRest\n * @return {?}\n */\n _Tokenizer.prototype._consumeRawText = function (decodeEntities, firstCharOfEnd, attemptEndRest) {\n var /** @type {?} */ tagCloseStart;\n var /** @type {?} */ textStart = this._getLocation();\n this._beginToken(decodeEntities ? TokenType.ESCAPABLE_RAW_TEXT : TokenType.RAW_TEXT, textStart);\n var /** @type {?} */ parts = [];\n while (true) {\n tagCloseStart = this._getLocation();\n if (this._attemptCharCode(firstCharOfEnd) && attemptEndRest()) {\n break;\n }\n if (this._index > tagCloseStart.offset) {\n // add the characters consumed by the previous if statement to the output\n parts.push(this._input.substring(tagCloseStart.offset, this._index));\n }\n while (this._peek !== firstCharOfEnd) {\n parts.push(this._readChar(decodeEntities));\n }\n }\n return this._endToken([this._processCarriageReturns(parts.join(''))], tagCloseStart);\n };\n /**\n * @param {?} start\n * @return {?}\n */\n _Tokenizer.prototype._consumeComment = function (start) {\n var _this = this;\n this._beginToken(TokenType.COMMENT_START, start);\n this._requireCharCode(chars.$MINUS);\n this._endToken([]);\n var /** @type {?} */ textToken = this._consumeRawText(false, chars.$MINUS, function () { return _this._attemptStr('->'); });\n this._beginToken(TokenType.COMMENT_END, textToken.sourceSpan.end);\n this._endToken([]);\n };\n /**\n * @param {?} start\n * @return {?}\n */\n _Tokenizer.prototype._consumeCdata = function (start) {\n var _this = this;\n this._beginToken(TokenType.CDATA_START, start);\n this._requireStr('CDATA[');\n this._endToken([]);\n var /** @type {?} */ textToken = this._consumeRawText(false, chars.$RBRACKET, function () { return _this._attemptStr(']>'); });\n this._beginToken(TokenType.CDATA_END, textToken.sourceSpan.end);\n this._endToken([]);\n };\n /**\n * @param {?} start\n * @return {?}\n */\n _Tokenizer.prototype._consumeDocType = function (start) {\n this._beginToken(TokenType.DOC_TYPE, start);\n this._attemptUntilChar(chars.$GT);\n this._advance();\n this._endToken([this._input.substring(start.offset + 2, this._index - 1)]);\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._consumePrefixAndName = function () {\n var /** @type {?} */ nameOrPrefixStart = this._index;\n var /** @type {?} */ prefix = null;\n while (this._peek !== chars.$COLON && !isPrefixEnd(this._peek)) {\n this._advance();\n }\n var /** @type {?} */ nameStart;\n if (this._peek === chars.$COLON) {\n this._advance();\n prefix = this._input.substring(nameOrPrefixStart, this._index - 1);\n nameStart = this._index;\n }\n else {\n nameStart = nameOrPrefixStart;\n }\n this._requireCharCodeUntilFn(isNameEnd, this._index === nameStart ? 1 : 0);\n var /** @type {?} */ name = this._input.substring(nameStart, this._index);\n return [prefix, name];\n };\n /**\n * @param {?} start\n * @return {?}\n */\n _Tokenizer.prototype._consumeTagOpen = function (start) {\n var /** @type {?} */ savedPos = this._savePosition();\n var /** @type {?} */ tagName;\n var /** @type {?} */ lowercaseTagName;\n try {\n if (!chars.isAsciiLetter(this._peek)) {\n throw this._createError(_unexpectedCharacterErrorMsg(this._peek), this._getSpan());\n }\n var /** @type {?} */ nameStart = this._index;\n this._consumeTagOpenStart(start);\n tagName = this._input.substring(nameStart, this._index);\n lowercaseTagName = tagName.toLowerCase();\n this._attemptCharCodeUntilFn(isNotWhitespace);\n while (this._peek !== chars.$SLASH && this._peek !== chars.$GT) {\n this._consumeAttributeName();\n this._attemptCharCodeUntilFn(isNotWhitespace);\n if (this._attemptCharCode(chars.$EQ)) {\n this._attemptCharCodeUntilFn(isNotWhitespace);\n this._consumeAttributeValue();\n }\n this._attemptCharCodeUntilFn(isNotWhitespace);\n }\n this._consumeTagOpenEnd();\n }\n catch (e) {\n if (e instanceof _ControlFlowError) {\n // When the start tag is invalid, assume we want a \"<\"\n this._restorePosition(savedPos);\n // Back to back text tokens are merged at the end\n this._beginToken(TokenType.TEXT, start);\n this._endToken(['<']);\n return;\n }\n throw e;\n }\n var /** @type {?} */ contentTokenType = this._getTagDefinition(tagName).contentType;\n if (contentTokenType === TagContentType.RAW_TEXT) {\n this._consumeRawTextWithTagClose(lowercaseTagName, false);\n }\n else if (contentTokenType === TagContentType.ESCAPABLE_RAW_TEXT) {\n this._consumeRawTextWithTagClose(lowercaseTagName, true);\n }\n };\n /**\n * @param {?} lowercaseTagName\n * @param {?} decodeEntities\n * @return {?}\n */\n _Tokenizer.prototype._consumeRawTextWithTagClose = function (lowercaseTagName, decodeEntities) {\n var _this = this;\n var /** @type {?} */ textToken = this._consumeRawText(decodeEntities, chars.$LT, function () {\n if (!_this._attemptCharCode(chars.$SLASH))\n return false;\n _this._attemptCharCodeUntilFn(isNotWhitespace);\n if (!_this._attemptStrCaseInsensitive(lowercaseTagName))\n return false;\n _this._attemptCharCodeUntilFn(isNotWhitespace);\n return _this._attemptCharCode(chars.$GT);\n });\n this._beginToken(TokenType.TAG_CLOSE, textToken.sourceSpan.end);\n this._endToken([null, lowercaseTagName]);\n };\n /**\n * @param {?} start\n * @return {?}\n */\n _Tokenizer.prototype._consumeTagOpenStart = function (start) {\n this._beginToken(TokenType.TAG_OPEN_START, start);\n var /** @type {?} */ parts = this._consumePrefixAndName();\n this._endToken(parts);\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._consumeAttributeName = function () {\n this._beginToken(TokenType.ATTR_NAME);\n var /** @type {?} */ prefixAndName = this._consumePrefixAndName();\n this._endToken(prefixAndName);\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._consumeAttributeValue = function () {\n this._beginToken(TokenType.ATTR_VALUE);\n var /** @type {?} */ value;\n if (this._peek === chars.$SQ || this._peek === chars.$DQ) {\n var /** @type {?} */ quoteChar = this._peek;\n this._advance();\n var /** @type {?} */ parts = [];\n while (this._peek !== quoteChar) {\n parts.push(this._readChar(true));\n }\n value = parts.join('');\n this._advance();\n }\n else {\n var /** @type {?} */ valueStart = this._index;\n this._requireCharCodeUntilFn(isNameEnd, 1);\n value = this._input.substring(valueStart, this._index);\n }\n this._endToken([this._processCarriageReturns(value)]);\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._consumeTagOpenEnd = function () {\n var /** @type {?} */ tokenType = this._attemptCharCode(chars.$SLASH) ? TokenType.TAG_OPEN_END_VOID : TokenType.TAG_OPEN_END;\n this._beginToken(tokenType);\n this._requireCharCode(chars.$GT);\n this._endToken([]);\n };\n /**\n * @param {?} start\n * @return {?}\n */\n _Tokenizer.prototype._consumeTagClose = function (start) {\n this._beginToken(TokenType.TAG_CLOSE, start);\n this._attemptCharCodeUntilFn(isNotWhitespace);\n var /** @type {?} */ prefixAndName = this._consumePrefixAndName();\n this._attemptCharCodeUntilFn(isNotWhitespace);\n this._requireCharCode(chars.$GT);\n this._endToken(prefixAndName);\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._consumeExpansionFormStart = function () {\n this._beginToken(TokenType.EXPANSION_FORM_START, this._getLocation());\n this._requireCharCode(chars.$LBRACE);\n this._endToken([]);\n this._expansionCaseStack.push(TokenType.EXPANSION_FORM_START);\n this._beginToken(TokenType.RAW_TEXT, this._getLocation());\n var /** @type {?} */ condition = this._readUntil(chars.$COMMA);\n this._endToken([condition], this._getLocation());\n this._requireCharCode(chars.$COMMA);\n this._attemptCharCodeUntilFn(isNotWhitespace);\n this._beginToken(TokenType.RAW_TEXT, this._getLocation());\n var /** @type {?} */ type = this._readUntil(chars.$COMMA);\n this._endToken([type], this._getLocation());\n this._requireCharCode(chars.$COMMA);\n this._attemptCharCodeUntilFn(isNotWhitespace);\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._consumeExpansionCaseStart = function () {\n this._beginToken(TokenType.EXPANSION_CASE_VALUE, this._getLocation());\n var /** @type {?} */ value = this._readUntil(chars.$LBRACE).trim();\n this._endToken([value], this._getLocation());\n this._attemptCharCodeUntilFn(isNotWhitespace);\n this._beginToken(TokenType.EXPANSION_CASE_EXP_START, this._getLocation());\n this._requireCharCode(chars.$LBRACE);\n this._endToken([], this._getLocation());\n this._attemptCharCodeUntilFn(isNotWhitespace);\n this._expansionCaseStack.push(TokenType.EXPANSION_CASE_EXP_START);\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._consumeExpansionCaseEnd = function () {\n this._beginToken(TokenType.EXPANSION_CASE_EXP_END, this._getLocation());\n this._requireCharCode(chars.$RBRACE);\n this._endToken([], this._getLocation());\n this._attemptCharCodeUntilFn(isNotWhitespace);\n this._expansionCaseStack.pop();\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._consumeExpansionFormEnd = function () {\n this._beginToken(TokenType.EXPANSION_FORM_END, this._getLocation());\n this._requireCharCode(chars.$RBRACE);\n this._endToken([]);\n this._expansionCaseStack.pop();\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._consumeText = function () {\n var /** @type {?} */ start = this._getLocation();\n this._beginToken(TokenType.TEXT, start);\n var /** @type {?} */ parts = [];\n do {\n if (this._interpolationConfig && this._attemptStr(this._interpolationConfig.start)) {\n parts.push(this._interpolationConfig.start);\n this._inInterpolation = true;\n }\n else if (this._interpolationConfig && this._inInterpolation &&\n this._attemptStr(this._interpolationConfig.end)) {\n parts.push(this._interpolationConfig.end);\n this._inInterpolation = false;\n }\n else {\n parts.push(this._readChar(true));\n }\n } while (!this._isTextEnd());\n this._endToken([this._processCarriageReturns(parts.join(''))]);\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._isTextEnd = function () {\n if (this._peek === chars.$LT || this._peek === chars.$EOF) {\n return true;\n }\n if (this._tokenizeIcu && !this._inInterpolation) {\n if (isExpansionFormStart(this._input, this._index, this._interpolationConfig)) {\n // start of an expansion form\n return true;\n }\n if (this._peek === chars.$RBRACE && this._isInExpansionCase()) {\n // end of and expansion case\n return true;\n }\n }\n return false;\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._savePosition = function () {\n return [this._peek, this._index, this._column, this._line, this.tokens.length];\n };\n /**\n * @param {?} char\n * @return {?}\n */\n _Tokenizer.prototype._readUntil = function (char) {\n var /** @type {?} */ start = this._index;\n this._attemptUntilChar(char);\n return this._input.substring(start, this._index);\n };\n /**\n * @param {?} position\n * @return {?}\n */\n _Tokenizer.prototype._restorePosition = function (position) {\n this._peek = position[0];\n this._index = position[1];\n this._column = position[2];\n this._line = position[3];\n var /** @type {?} */ nbTokens = position[4];\n if (nbTokens < this.tokens.length) {\n // remove any extra tokens\n this.tokens = this.tokens.slice(0, nbTokens);\n }\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._isInExpansionCase = function () {\n return this._expansionCaseStack.length > 0 &&\n this._expansionCaseStack[this._expansionCaseStack.length - 1] ===\n TokenType.EXPANSION_CASE_EXP_START;\n };\n /**\n * @return {?}\n */\n _Tokenizer.prototype._isInExpansionForm = function () {\n return this._expansionCaseStack.length > 0 &&\n this._expansionCaseStack[this._expansionCaseStack.length - 1] ===\n TokenType.EXPANSION_FORM_START;\n };\n return _Tokenizer;\n}());\nfunction _Tokenizer_tsickle_Closure_declarations() {\n /** @type {?} */\n _Tokenizer.prototype._input;\n /** @type {?} */\n _Tokenizer.prototype._length;\n /** @type {?} */\n _Tokenizer.prototype._peek;\n /** @type {?} */\n _Tokenizer.prototype._nextPeek;\n /** @type {?} */\n _Tokenizer.prototype._index;\n /** @type {?} */\n _Tokenizer.prototype._line;\n /** @type {?} */\n _Tokenizer.prototype._column;\n /** @type {?} */\n _Tokenizer.prototype._currentTokenStart;\n /** @type {?} */\n _Tokenizer.prototype._currentTokenType;\n /** @type {?} */\n _Tokenizer.prototype._expansionCaseStack;\n /** @type {?} */\n _Tokenizer.prototype._inInterpolation;\n /** @type {?} */\n _Tokenizer.prototype.tokens;\n /** @type {?} */\n _Tokenizer.prototype.errors;\n /** @type {?} */\n _Tokenizer.prototype._file;\n /** @type {?} */\n _Tokenizer.prototype._getTagDefinition;\n /** @type {?} */\n _Tokenizer.prototype._tokenizeIcu;\n /** @type {?} */\n _Tokenizer.prototype._interpolationConfig;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isNotWhitespace(code) {\n return !chars.isWhitespace(code) || code === chars.$EOF;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isNameEnd(code) {\n return chars.isWhitespace(code) || code === chars.$GT || code === chars.$SLASH ||\n code === chars.$SQ || code === chars.$DQ || code === chars.$EQ;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isPrefixEnd(code) {\n return (code < chars.$a || chars.$z < code) && (code < chars.$A || chars.$Z < code) &&\n (code < chars.$0 || code > chars.$9);\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isDigitEntityEnd(code) {\n return code == chars.$SEMICOLON || code == chars.$EOF || !chars.isAsciiHexDigit(code);\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isNamedEntityEnd(code) {\n return code == chars.$SEMICOLON || code == chars.$EOF || !chars.isAsciiLetter(code);\n}\n/**\n * @param {?} input\n * @param {?} offset\n * @param {?} interpolationConfig\n * @return {?}\n */\nfunction isExpansionFormStart(input, offset, interpolationConfig) {\n var /** @type {?} */ isInterpolationStart = interpolationConfig ? input.indexOf(interpolationConfig.start, offset) == offset : false;\n return input.charCodeAt(offset) == chars.$LBRACE && !isInterpolationStart;\n}\n/**\n * @param {?} peek\n * @return {?}\n */\nfunction isExpansionCaseStart(peek) {\n return peek === chars.$EQ || chars.isAsciiLetter(peek);\n}\n/**\n * @param {?} code1\n * @param {?} code2\n * @return {?}\n */\nfunction compareCharCodeCaseInsensitive(code1, code2) {\n return toUpperCaseCharCode(code1) == toUpperCaseCharCode(code2);\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction toUpperCaseCharCode(code) {\n return code >= chars.$a && code <= chars.$z ? code - chars.$a + chars.$A : code;\n}\n/**\n * @param {?} srcTokens\n * @return {?}\n */\nfunction mergeTextTokens(srcTokens) {\n var /** @type {?} */ dstTokens = [];\n var /** @type {?} */ lastDstToken;\n for (var /** @type {?} */ i = 0; i < srcTokens.length; i++) {\n var /** @type {?} */ token = srcTokens[i];\n if (lastDstToken && lastDstToken.type == TokenType.TEXT && token.type == TokenType.TEXT) {\n lastDstToken.parts[0] += token.parts[0];\n lastDstToken.sourceSpan.end = token.sourceSpan.end;\n }\n else {\n lastDstToken = token;\n dstTokens.push(lastDstToken);\n }\n }\n return dstTokens;\n}\n//# sourceMappingURL=lexer.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/ml_parser/lexer.js\n// module id = ./node_modules/@angular/compiler/src/ml_parser/lexer.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nimport { isBlank, isPresent } from '../facade/lang';\nimport { ParseError, ParseSourceSpan } from '../parse_util';\nimport * as html from './ast';\nimport { DEFAULT_INTERPOLATION_CONFIG } from './interpolation_config';\nimport * as lex from './lexer';\nimport { getNsPrefix, mergeNsAndName } from './tags';\nexport var TreeError = (function (_super) {\n __extends(TreeError, _super);\n /**\n * @param {?} elementName\n * @param {?} span\n * @param {?} msg\n */\n function TreeError(elementName, span, msg) {\n _super.call(this, span, msg);\n this.elementName = elementName;\n }\n /**\n * @param {?} elementName\n * @param {?} span\n * @param {?} msg\n * @return {?}\n */\n TreeError.create = function (elementName, span, msg) {\n return new TreeError(elementName, span, msg);\n };\n return TreeError;\n}(ParseError));\nfunction TreeError_tsickle_Closure_declarations() {\n /** @type {?} */\n TreeError.prototype.elementName;\n}\nexport var ParseTreeResult = (function () {\n /**\n * @param {?} rootNodes\n * @param {?} errors\n */\n function ParseTreeResult(rootNodes, errors) {\n this.rootNodes = rootNodes;\n this.errors = errors;\n }\n return ParseTreeResult;\n}());\nfunction ParseTreeResult_tsickle_Closure_declarations() {\n /** @type {?} */\n ParseTreeResult.prototype.rootNodes;\n /** @type {?} */\n ParseTreeResult.prototype.errors;\n}\nexport var Parser = (function () {\n /**\n * @param {?} getTagDefinition\n */\n function Parser(getTagDefinition) {\n this.getTagDefinition = getTagDefinition;\n }\n /**\n * @param {?} source\n * @param {?} url\n * @param {?=} parseExpansionForms\n * @param {?=} interpolationConfig\n * @return {?}\n */\n Parser.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 {?} */ tokensAndErrors = lex.tokenize(source, url, this.getTagDefinition, parseExpansionForms, interpolationConfig);\n var /** @type {?} */ treeAndErrors = new _TreeBuilder(tokensAndErrors.tokens, this.getTagDefinition).build();\n return new ParseTreeResult(treeAndErrors.rootNodes, ((tokensAndErrors.errors)).concat(treeAndErrors.errors));\n };\n return Parser;\n}());\nfunction Parser_tsickle_Closure_declarations() {\n /** @type {?} */\n Parser.prototype.getTagDefinition;\n}\nvar _TreeBuilder = (function () {\n /**\n * @param {?} tokens\n * @param {?} getTagDefinition\n */\n function _TreeBuilder(tokens, getTagDefinition) {\n this.tokens = tokens;\n this.getTagDefinition = getTagDefinition;\n this._index = -1;\n this._rootNodes = [];\n this._errors = [];\n this._elementStack = [];\n this._advance();\n }\n /**\n * @return {?}\n */\n _TreeBuilder.prototype.build = function () {\n while (this._peek.type !== lex.TokenType.EOF) {\n if (this._peek.type === lex.TokenType.TAG_OPEN_START) {\n this._consumeStartTag(this._advance());\n }\n else if (this._peek.type === lex.TokenType.TAG_CLOSE) {\n this._consumeEndTag(this._advance());\n }\n else if (this._peek.type === lex.TokenType.CDATA_START) {\n this._closeVoidElement();\n this._consumeCdata(this._advance());\n }\n else if (this._peek.type === lex.TokenType.COMMENT_START) {\n this._closeVoidElement();\n this._consumeComment(this._advance());\n }\n else if (this._peek.type === lex.TokenType.TEXT || this._peek.type === lex.TokenType.RAW_TEXT ||\n this._peek.type === lex.TokenType.ESCAPABLE_RAW_TEXT) {\n this._closeVoidElement();\n this._consumeText(this._advance());\n }\n else if (this._peek.type === lex.TokenType.EXPANSION_FORM_START) {\n this._consumeExpansion(this._advance());\n }\n else {\n // Skip all other tokens...\n this._advance();\n }\n }\n return new ParseTreeResult(this._rootNodes, this._errors);\n };\n /**\n * @return {?}\n */\n _TreeBuilder.prototype._advance = function () {\n var /** @type {?} */ prev = this._peek;\n if (this._index < this.tokens.length - 1) {\n // Note: there is always an EOF token at the end\n this._index++;\n }\n this._peek = this.tokens[this._index];\n return prev;\n };\n /**\n * @param {?} type\n * @return {?}\n */\n _TreeBuilder.prototype._advanceIf = function (type) {\n if (this._peek.type === type) {\n return this._advance();\n }\n return null;\n };\n /**\n * @param {?} startToken\n * @return {?}\n */\n _TreeBuilder.prototype._consumeCdata = function (startToken) {\n this._consumeText(this._advance());\n this._advanceIf(lex.TokenType.CDATA_END);\n };\n /**\n * @param {?} token\n * @return {?}\n */\n _TreeBuilder.prototype._consumeComment = function (token) {\n var /** @type {?} */ text = this._advanceIf(lex.TokenType.RAW_TEXT);\n this._advanceIf(lex.TokenType.COMMENT_END);\n var /** @type {?} */ value = isPresent(text) ? text.parts[0].trim() : null;\n this._addToParent(new html.Comment(value, token.sourceSpan));\n };\n /**\n * @param {?} token\n * @return {?}\n */\n _TreeBuilder.prototype._consumeExpansion = function (token) {\n var /** @type {?} */ switchValue = this._advance();\n var /** @type {?} */ type = this._advance();\n var /** @type {?} */ cases = [];\n // read =\n while (this._peek.type === lex.TokenType.EXPANSION_CASE_VALUE) {\n var /** @type {?} */ expCase = this._parseExpansionCase();\n if (!expCase)\n return; // error\n cases.push(expCase);\n }\n // read the final }\n if (this._peek.type !== lex.TokenType.EXPANSION_FORM_END) {\n this._errors.push(TreeError.create(null, this._peek.sourceSpan, \"Invalid ICU message. Missing '}'.\"));\n return;\n }\n var /** @type {?} */ sourceSpan = new ParseSourceSpan(token.sourceSpan.start, this._peek.sourceSpan.end);\n this._addToParent(new html.Expansion(switchValue.parts[0], type.parts[0], cases, sourceSpan, switchValue.sourceSpan));\n this._advance();\n };\n /**\n * @return {?}\n */\n _TreeBuilder.prototype._parseExpansionCase = function () {\n var /** @type {?} */ value = this._advance();\n // read {\n if (this._peek.type !== lex.TokenType.EXPANSION_CASE_EXP_START) {\n this._errors.push(TreeError.create(null, this._peek.sourceSpan, \"Invalid ICU message. Missing '{'.\"));\n return null;\n }\n // read until }\n var /** @type {?} */ start = this._advance();\n var /** @type {?} */ exp = this._collectExpansionExpTokens(start);\n if (!exp)\n return null;\n var /** @type {?} */ end = this._advance();\n exp.push(new lex.Token(lex.TokenType.EOF, [], end.sourceSpan));\n // parse everything in between { and }\n var /** @type {?} */ parsedExp = new _TreeBuilder(exp, this.getTagDefinition).build();\n if (parsedExp.errors.length > 0) {\n this._errors = this._errors.concat(/** @type {?} */ (parsedExp.errors));\n return null;\n }\n var /** @type {?} */ sourceSpan = new ParseSourceSpan(value.sourceSpan.start, end.sourceSpan.end);\n var /** @type {?} */ expSourceSpan = new ParseSourceSpan(start.sourceSpan.start, end.sourceSpan.end);\n return new html.ExpansionCase(value.parts[0], parsedExp.rootNodes, sourceSpan, value.sourceSpan, expSourceSpan);\n };\n /**\n * @param {?} start\n * @return {?}\n */\n _TreeBuilder.prototype._collectExpansionExpTokens = function (start) {\n var /** @type {?} */ exp = [];\n var /** @type {?} */ expansionFormStack = [lex.TokenType.EXPANSION_CASE_EXP_START];\n while (true) {\n if (this._peek.type === lex.TokenType.EXPANSION_FORM_START ||\n this._peek.type === lex.TokenType.EXPANSION_CASE_EXP_START) {\n expansionFormStack.push(this._peek.type);\n }\n if (this._peek.type === lex.TokenType.EXPANSION_CASE_EXP_END) {\n if (lastOnStack(expansionFormStack, lex.TokenType.EXPANSION_CASE_EXP_START)) {\n expansionFormStack.pop();\n if (expansionFormStack.length == 0)\n return exp;\n }\n else {\n this._errors.push(TreeError.create(null, start.sourceSpan, \"Invalid ICU message. Missing '}'.\"));\n return null;\n }\n }\n if (this._peek.type === lex.TokenType.EXPANSION_FORM_END) {\n if (lastOnStack(expansionFormStack, lex.TokenType.EXPANSION_FORM_START)) {\n expansionFormStack.pop();\n }\n else {\n this._errors.push(TreeError.create(null, start.sourceSpan, \"Invalid ICU message. Missing '}'.\"));\n return null;\n }\n }\n if (this._peek.type === lex.TokenType.EOF) {\n this._errors.push(TreeError.create(null, start.sourceSpan, \"Invalid ICU message. Missing '}'.\"));\n return null;\n }\n exp.push(this._advance());\n }\n };\n /**\n * @param {?} token\n * @return {?}\n */\n _TreeBuilder.prototype._consumeText = function (token) {\n var /** @type {?} */ text = token.parts[0];\n if (text.length > 0 && text[0] == '\\n') {\n var /** @type {?} */ parent_1 = this._getParentElement();\n if (isPresent(parent_1) && parent_1.children.length == 0 &&\n this.getTagDefinition(parent_1.name).ignoreFirstLf) {\n text = text.substring(1);\n }\n }\n if (text.length > 0) {\n this._addToParent(new html.Text(text, token.sourceSpan));\n }\n };\n /**\n * @return {?}\n */\n _TreeBuilder.prototype._closeVoidElement = function () {\n if (this._elementStack.length > 0) {\n var /** @type {?} */ el = this._elementStack[this._elementStack.length - 1];\n if (this.getTagDefinition(el.name).isVoid) {\n this._elementStack.pop();\n }\n }\n };\n /**\n * @param {?} startTagToken\n * @return {?}\n */\n _TreeBuilder.prototype._consumeStartTag = function (startTagToken) {\n var /** @type {?} */ prefix = startTagToken.parts[0];\n var /** @type {?} */ name = startTagToken.parts[1];\n var /** @type {?} */ attrs = [];\n while (this._peek.type === lex.TokenType.ATTR_NAME) {\n attrs.push(this._consumeAttr(this._advance()));\n }\n var /** @type {?} */ fullName = this._getElementFullName(prefix, name, this._getParentElement());\n var /** @type {?} */ selfClosing = false;\n // Note: There could have been a tokenizer error\n // so that we don't get a token for the end tag...\n if (this._peek.type === lex.TokenType.TAG_OPEN_END_VOID) {\n this._advance();\n selfClosing = true;\n var /** @type {?} */ tagDef = this.getTagDefinition(fullName);\n if (!(tagDef.canSelfClose || getNsPrefix(fullName) !== null || tagDef.isVoid)) {\n this._errors.push(TreeError.create(fullName, startTagToken.sourceSpan, \"Only void and foreign elements can be self closed \\\"\" + startTagToken.parts[1] + \"\\\"\"));\n }\n }\n else if (this._peek.type === lex.TokenType.TAG_OPEN_END) {\n this._advance();\n selfClosing = false;\n }\n var /** @type {?} */ end = this._peek.sourceSpan.start;\n var /** @type {?} */ span = new ParseSourceSpan(startTagToken.sourceSpan.start, end);\n var /** @type {?} */ el = new html.Element(fullName, attrs, [], span, span, null);\n this._pushElement(el);\n if (selfClosing) {\n this._popElement(fullName);\n el.endSourceSpan = span;\n }\n };\n /**\n * @param {?} el\n * @return {?}\n */\n _TreeBuilder.prototype._pushElement = function (el) {\n if (this._elementStack.length > 0) {\n var /** @type {?} */ parentEl = this._elementStack[this._elementStack.length - 1];\n if (this.getTagDefinition(parentEl.name).isClosedByChild(el.name)) {\n this._elementStack.pop();\n }\n }\n var /** @type {?} */ tagDef = this.getTagDefinition(el.name);\n var _a = this._getParentElementSkippingContainers(), parent = _a.parent, container = _a.container;\n if (isPresent(parent) && tagDef.requireExtraParent(parent.name)) {\n var /** @type {?} */ newParent = new html.Element(tagDef.parentToAdd, [], [], el.sourceSpan, el.startSourceSpan, el.endSourceSpan);\n this._insertBeforeContainer(parent, container, newParent);\n }\n this._addToParent(el);\n this._elementStack.push(el);\n };\n /**\n * @param {?} endTagToken\n * @return {?}\n */\n _TreeBuilder.prototype._consumeEndTag = function (endTagToken) {\n var /** @type {?} */ fullName = this._getElementFullName(endTagToken.parts[0], endTagToken.parts[1], this._getParentElement());\n if (this._getParentElement()) {\n this._getParentElement().endSourceSpan = endTagToken.sourceSpan;\n }\n if (this.getTagDefinition(fullName).isVoid) {\n this._errors.push(TreeError.create(fullName, endTagToken.sourceSpan, \"Void elements do not have end tags \\\"\" + endTagToken.parts[1] + \"\\\"\"));\n }\n else if (!this._popElement(fullName)) {\n this._errors.push(TreeError.create(fullName, endTagToken.sourceSpan, \"Unexpected closing tag \\\"\" + endTagToken.parts[1] + \"\\\"\"));\n }\n };\n /**\n * @param {?} fullName\n * @return {?}\n */\n _TreeBuilder.prototype._popElement = function (fullName) {\n for (var /** @type {?} */ stackIndex = this._elementStack.length - 1; stackIndex >= 0; stackIndex--) {\n var /** @type {?} */ el = this._elementStack[stackIndex];\n if (el.name == fullName) {\n this._elementStack.splice(stackIndex, this._elementStack.length - stackIndex);\n return true;\n }\n if (!this.getTagDefinition(el.name).closedByParent) {\n return false;\n }\n }\n return false;\n };\n /**\n * @param {?} attrName\n * @return {?}\n */\n _TreeBuilder.prototype._consumeAttr = function (attrName) {\n var /** @type {?} */ fullName = mergeNsAndName(attrName.parts[0], attrName.parts[1]);\n var /** @type {?} */ end = attrName.sourceSpan.end;\n var /** @type {?} */ value = '';\n var /** @type {?} */ valueSpan;\n if (this._peek.type === lex.TokenType.ATTR_VALUE) {\n var /** @type {?} */ valueToken = this._advance();\n value = valueToken.parts[0];\n end = valueToken.sourceSpan.end;\n valueSpan = valueToken.sourceSpan;\n }\n return new html.Attribute(fullName, value, new ParseSourceSpan(attrName.sourceSpan.start, end), valueSpan);\n };\n /**\n * @return {?}\n */\n _TreeBuilder.prototype._getParentElement = function () {\n return this._elementStack.length > 0 ? this._elementStack[this._elementStack.length - 1] : null;\n };\n /**\n * Returns the parent in the DOM and the container.\n * *\n * `` 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 (isPresent(parent)) {\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 * @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 (isBlank(prefix)) {\n prefix = this.getTagDefinition(localName).implicitNamespacePrefix;\n if (isBlank(prefix) && isPresent(parentElement)) {\n prefix = getNsPrefix(parentElement.name);\n }\n }\n return mergeNsAndName(prefix, localName);\n };\n return _TreeBuilder;\n}());\nfunction _TreeBuilder_tsickle_Closure_declarations() {\n /** @type {?} */\n _TreeBuilder.prototype._index;\n /** @type {?} */\n _TreeBuilder.prototype._peek;\n /** @type {?} */\n _TreeBuilder.prototype._rootNodes;\n /** @type {?} */\n _TreeBuilder.prototype._errors;\n /** @type {?} */\n _TreeBuilder.prototype._elementStack;\n /** @type {?} */\n _TreeBuilder.prototype.tokens;\n /** @type {?} */\n _TreeBuilder.prototype.getTagDefinition;\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//# sourceMappingURL=parser.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/ml_parser/parser.js\n// module id = ./node_modules/@angular/compiler/src/ml_parser/parser.js\n// module chunks = 0","export var TagContentType = {};\nTagContentType.RAW_TEXT = 0;\nTagContentType.ESCAPABLE_RAW_TEXT = 1;\nTagContentType.PARSABLE_DATA = 2;\nTagContentType[TagContentType.RAW_TEXT] = \"RAW_TEXT\";\nTagContentType[TagContentType.ESCAPABLE_RAW_TEXT] = \"ESCAPABLE_RAW_TEXT\";\nTagContentType[TagContentType.PARSABLE_DATA] = \"PARSABLE_DATA\";\n/**\n * @param {?} elementName\n * @return {?}\n */\nexport function splitNsName(elementName) {\n if (elementName[0] != ':') {\n return [null, elementName];\n }\n var /** @type {?} */ colonIndex = elementName.indexOf(':', 1);\n if (colonIndex == -1) {\n throw new Error(\"Unsupported format \\\"\" + elementName + \"\\\" expecting \\\":namespace:name\\\"\");\n }\n return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)];\n}\n/**\n * @param {?} fullName\n * @return {?}\n */\nexport function getNsPrefix(fullName) {\n return fullName === null ? null : splitNsName(fullName)[0];\n}\n/**\n * @param {?} prefix\n * @param {?} localName\n * @return {?}\n */\nexport function mergeNsAndName(prefix, localName) {\n return prefix ? \":\" + prefix + \":\" + localName : localName;\n}\n// see http://www.w3.org/TR/html51/syntax.html#named-character-references\n// see https://html.spec.whatwg.org/multipage/entities.json\n// This list is not exhaustive to keep the compiler footprint low.\n// The `{` / `ƫ` syntax should be used when the named character reference does not exist.\nexport var /** @type {?} */ NAMED_ENTITIES = {\n 'Aacute': '\\u00C1',\n 'aacute': '\\u00E1',\n 'Acirc': '\\u00C2',\n 'acirc': '\\u00E2',\n 'acute': '\\u00B4',\n 'AElig': '\\u00C6',\n 'aelig': '\\u00E6',\n 'Agrave': '\\u00C0',\n 'agrave': '\\u00E0',\n 'alefsym': '\\u2135',\n 'Alpha': '\\u0391',\n 'alpha': '\\u03B1',\n 'amp': '&',\n 'and': '\\u2227',\n 'ang': '\\u2220',\n 'apos': '\\u0027',\n 'Aring': '\\u00C5',\n 'aring': '\\u00E5',\n 'asymp': '\\u2248',\n 'Atilde': '\\u00C3',\n 'atilde': '\\u00E3',\n 'Auml': '\\u00C4',\n 'auml': '\\u00E4',\n 'bdquo': '\\u201E',\n 'Beta': '\\u0392',\n 'beta': '\\u03B2',\n 'brvbar': '\\u00A6',\n 'bull': '\\u2022',\n 'cap': '\\u2229',\n 'Ccedil': '\\u00C7',\n 'ccedil': '\\u00E7',\n 'cedil': '\\u00B8',\n 'cent': '\\u00A2',\n 'Chi': '\\u03A7',\n 'chi': '\\u03C7',\n 'circ': '\\u02C6',\n 'clubs': '\\u2663',\n 'cong': '\\u2245',\n 'copy': '\\u00A9',\n 'crarr': '\\u21B5',\n 'cup': '\\u222A',\n 'curren': '\\u00A4',\n 'dagger': '\\u2020',\n 'Dagger': '\\u2021',\n 'darr': '\\u2193',\n 'dArr': '\\u21D3',\n 'deg': '\\u00B0',\n 'Delta': '\\u0394',\n 'delta': '\\u03B4',\n 'diams': '\\u2666',\n 'divide': '\\u00F7',\n 'Eacute': '\\u00C9',\n 'eacute': '\\u00E9',\n 'Ecirc': '\\u00CA',\n 'ecirc': '\\u00EA',\n 'Egrave': '\\u00C8',\n 'egrave': '\\u00E8',\n 'empty': '\\u2205',\n 'emsp': '\\u2003',\n 'ensp': '\\u2002',\n 'Epsilon': '\\u0395',\n 'epsilon': '\\u03B5',\n 'equiv': '\\u2261',\n 'Eta': '\\u0397',\n 'eta': '\\u03B7',\n 'ETH': '\\u00D0',\n 'eth': '\\u00F0',\n 'Euml': '\\u00CB',\n 'euml': '\\u00EB',\n 'euro': '\\u20AC',\n 'exist': '\\u2203',\n 'fnof': '\\u0192',\n 'forall': '\\u2200',\n 'frac12': '\\u00BD',\n 'frac14': '\\u00BC',\n 'frac34': '\\u00BE',\n 'frasl': '\\u2044',\n 'Gamma': '\\u0393',\n 'gamma': '\\u03B3',\n 'ge': '\\u2265',\n 'gt': '>',\n 'harr': '\\u2194',\n 'hArr': '\\u21D4',\n 'hearts': '\\u2665',\n 'hellip': '\\u2026',\n 'Iacute': '\\u00CD',\n 'iacute': '\\u00ED',\n 'Icirc': '\\u00CE',\n 'icirc': '\\u00EE',\n 'iexcl': '\\u00A1',\n 'Igrave': '\\u00CC',\n 'igrave': '\\u00EC',\n 'image': '\\u2111',\n 'infin': '\\u221E',\n 'int': '\\u222B',\n 'Iota': '\\u0399',\n 'iota': '\\u03B9',\n 'iquest': '\\u00BF',\n 'isin': '\\u2208',\n 'Iuml': '\\u00CF',\n 'iuml': '\\u00EF',\n 'Kappa': '\\u039A',\n 'kappa': '\\u03BA',\n 'Lambda': '\\u039B',\n 'lambda': '\\u03BB',\n 'lang': '\\u27E8',\n 'laquo': '\\u00AB',\n 'larr': '\\u2190',\n 'lArr': '\\u21D0',\n 'lceil': '\\u2308',\n 'ldquo': '\\u201C',\n 'le': '\\u2264',\n 'lfloor': '\\u230A',\n 'lowast': '\\u2217',\n 'loz': '\\u25CA',\n 'lrm': '\\u200E',\n 'lsaquo': '\\u2039',\n 'lsquo': '\\u2018',\n 'lt': '<',\n 'macr': '\\u00AF',\n 'mdash': '\\u2014',\n 'micro': '\\u00B5',\n 'middot': '\\u00B7',\n 'minus': '\\u2212',\n 'Mu': '\\u039C',\n 'mu': '\\u03BC',\n 'nabla': '\\u2207',\n 'nbsp': '\\u00A0',\n 'ndash': '\\u2013',\n 'ne': '\\u2260',\n 'ni': '\\u220B',\n 'not': '\\u00AC',\n 'notin': '\\u2209',\n 'nsub': '\\u2284',\n 'Ntilde': '\\u00D1',\n 'ntilde': '\\u00F1',\n 'Nu': '\\u039D',\n 'nu': '\\u03BD',\n 'Oacute': '\\u00D3',\n 'oacute': '\\u00F3',\n 'Ocirc': '\\u00D4',\n 'ocirc': '\\u00F4',\n 'OElig': '\\u0152',\n 'oelig': '\\u0153',\n 'Ograve': '\\u00D2',\n 'ograve': '\\u00F2',\n 'oline': '\\u203E',\n 'Omega': '\\u03A9',\n 'omega': '\\u03C9',\n 'Omicron': '\\u039F',\n 'omicron': '\\u03BF',\n 'oplus': '\\u2295',\n 'or': '\\u2228',\n 'ordf': '\\u00AA',\n 'ordm': '\\u00BA',\n 'Oslash': '\\u00D8',\n 'oslash': '\\u00F8',\n 'Otilde': '\\u00D5',\n 'otilde': '\\u00F5',\n 'otimes': '\\u2297',\n 'Ouml': '\\u00D6',\n 'ouml': '\\u00F6',\n 'para': '\\u00B6',\n 'permil': '\\u2030',\n 'perp': '\\u22A5',\n 'Phi': '\\u03A6',\n 'phi': '\\u03C6',\n 'Pi': '\\u03A0',\n 'pi': '\\u03C0',\n 'piv': '\\u03D6',\n 'plusmn': '\\u00B1',\n 'pound': '\\u00A3',\n 'prime': '\\u2032',\n 'Prime': '\\u2033',\n 'prod': '\\u220F',\n 'prop': '\\u221D',\n 'Psi': '\\u03A8',\n 'psi': '\\u03C8',\n 'quot': '\\u0022',\n 'radic': '\\u221A',\n 'rang': '\\u27E9',\n 'raquo': '\\u00BB',\n 'rarr': '\\u2192',\n 'rArr': '\\u21D2',\n 'rceil': '\\u2309',\n 'rdquo': '\\u201D',\n 'real': '\\u211C',\n 'reg': '\\u00AE',\n 'rfloor': '\\u230B',\n 'Rho': '\\u03A1',\n 'rho': '\\u03C1',\n 'rlm': '\\u200F',\n 'rsaquo': '\\u203A',\n 'rsquo': '\\u2019',\n 'sbquo': '\\u201A',\n 'Scaron': '\\u0160',\n 'scaron': '\\u0161',\n 'sdot': '\\u22C5',\n 'sect': '\\u00A7',\n 'shy': '\\u00AD',\n 'Sigma': '\\u03A3',\n 'sigma': '\\u03C3',\n 'sigmaf': '\\u03C2',\n 'sim': '\\u223C',\n 'spades': '\\u2660',\n 'sub': '\\u2282',\n 'sube': '\\u2286',\n 'sum': '\\u2211',\n 'sup': '\\u2283',\n 'sup1': '\\u00B9',\n 'sup2': '\\u00B2',\n 'sup3': '\\u00B3',\n 'supe': '\\u2287',\n 'szlig': '\\u00DF',\n 'Tau': '\\u03A4',\n 'tau': '\\u03C4',\n 'there4': '\\u2234',\n 'Theta': '\\u0398',\n 'theta': '\\u03B8',\n 'thetasym': '\\u03D1',\n 'thinsp': '\\u2009',\n 'THORN': '\\u00DE',\n 'thorn': '\\u00FE',\n 'tilde': '\\u02DC',\n 'times': '\\u00D7',\n 'trade': '\\u2122',\n 'Uacute': '\\u00DA',\n 'uacute': '\\u00FA',\n 'uarr': '\\u2191',\n 'uArr': '\\u21D1',\n 'Ucirc': '\\u00DB',\n 'ucirc': '\\u00FB',\n 'Ugrave': '\\u00D9',\n 'ugrave': '\\u00F9',\n 'uml': '\\u00A8',\n 'upsih': '\\u03D2',\n 'Upsilon': '\\u03A5',\n 'upsilon': '\\u03C5',\n 'Uuml': '\\u00DC',\n 'uuml': '\\u00FC',\n 'weierp': '\\u2118',\n 'Xi': '\\u039E',\n 'xi': '\\u03BE',\n 'Yacute': '\\u00DD',\n 'yacute': '\\u00FD',\n 'yen': '\\u00A5',\n 'yuml': '\\u00FF',\n 'Yuml': '\\u0178',\n 'Zeta': '\\u0396',\n 'zeta': '\\u03B6',\n 'zwj': '\\u200D',\n 'zwnj': '\\u200C',\n};\n//# sourceMappingURL=tags.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/ml_parser/tags.js\n// module id = ./node_modules/@angular/compiler/src/ml_parser/tags.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nimport { Parser } from './parser';\nimport { getXmlTagDefinition } from './xml_tags';\nexport { ParseTreeResult, TreeError } from './parser';\nexport var XmlParser = (function (_super) {\n __extends(XmlParser, _super);\n function XmlParser() {\n _super.call(this, getXmlTagDefinition);\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));\n//# sourceMappingURL=xml_parser.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/ml_parser/xml_parser.js\n// module id = ./node_modules/@angular/compiler/src/ml_parser/xml_parser.js\n// module chunks = 0","/**\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 */\nimport { TagContentType } from './tags';\nexport var 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}());\nfunction XmlTagDefinition_tsickle_Closure_declarations() {\n /** @type {?} */\n XmlTagDefinition.prototype.closedByParent;\n /** @type {?} */\n XmlTagDefinition.prototype.requiredParents;\n /** @type {?} */\n XmlTagDefinition.prototype.parentToAdd;\n /** @type {?} */\n XmlTagDefinition.prototype.implicitNamespacePrefix;\n /** @type {?} */\n XmlTagDefinition.prototype.contentType;\n /** @type {?} */\n XmlTagDefinition.prototype.isVoid;\n /** @type {?} */\n XmlTagDefinition.prototype.ignoreFirstLf;\n /** @type {?} */\n XmlTagDefinition.prototype.canSelfClose;\n}\nvar /** @type {?} */ _TAG_DEFINITION = new XmlTagDefinition();\n/**\n * @param {?} tagName\n * @return {?}\n */\nexport function getXmlTagDefinition(tagName) {\n return _TAG_DEFINITION;\n}\n//# sourceMappingURL=xml_tags.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/ml_parser/xml_tags.js\n// module id = ./node_modules/@angular/compiler/src/ml_parser/xml_tags.js\n// module chunks = 0","/**\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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { identifierModuleUrl, identifierName, tokenName, tokenReference } from './compile_metadata';\nimport { createDiTokenExpression } from './compiler_util/identifier_util';\nimport { isPresent } from './facade/lang';\nimport { Identifiers, createIdentifier, resolveIdentifier } from './identifiers';\nimport { CompilerInjectable } from './injectable';\nimport { createClassStmt } from './output/class_builder';\nimport * as o from './output/output_ast';\nimport { convertValueToOutputAst } from './output/value_util';\nimport { ParseLocation, ParseSourceFile, ParseSourceSpan } from './parse_util';\nimport { LifecycleHooks } from './private_import_core';\nimport { NgModuleProviderAnalyzer } from './provider_analyzer';\nexport var ComponentFactoryDependency = (function () {\n /**\n * @param {?} comp\n * @param {?} placeholder\n */\n function ComponentFactoryDependency(comp, placeholder) {\n this.comp = comp;\n this.placeholder = placeholder;\n }\n return ComponentFactoryDependency;\n}());\nfunction ComponentFactoryDependency_tsickle_Closure_declarations() {\n /** @type {?} */\n ComponentFactoryDependency.prototype.comp;\n /** @type {?} */\n ComponentFactoryDependency.prototype.placeholder;\n}\nexport var NgModuleCompileResult = (function () {\n /**\n * @param {?} statements\n * @param {?} ngModuleFactoryVar\n * @param {?} dependencies\n */\n function NgModuleCompileResult(statements, ngModuleFactoryVar, dependencies) {\n this.statements = statements;\n this.ngModuleFactoryVar = ngModuleFactoryVar;\n this.dependencies = dependencies;\n }\n return NgModuleCompileResult;\n}());\nfunction NgModuleCompileResult_tsickle_Closure_declarations() {\n /** @type {?} */\n NgModuleCompileResult.prototype.statements;\n /** @type {?} */\n NgModuleCompileResult.prototype.ngModuleFactoryVar;\n /** @type {?} */\n NgModuleCompileResult.prototype.dependencies;\n}\nexport var NgModuleCompiler = (function () {\n function NgModuleCompiler() {\n }\n /**\n * @param {?} ngModuleMeta\n * @param {?} extraProviders\n * @return {?}\n */\n NgModuleCompiler.prototype.compile = function (ngModuleMeta, extraProviders) {\n var /** @type {?} */ moduleUrl = identifierModuleUrl(ngModuleMeta.type);\n var /** @type {?} */ sourceFileName = isPresent(moduleUrl) ?\n \"in NgModule \" + identifierName(ngModuleMeta.type) + \" in \" + moduleUrl :\n \"in NgModule \" + identifierName(ngModuleMeta.type);\n var /** @type {?} */ sourceFile = new ParseSourceFile('', sourceFileName);\n var /** @type {?} */ sourceSpan = new ParseSourceSpan(new ParseLocation(sourceFile, null, null, null), new ParseLocation(sourceFile, null, null, null));\n var /** @type {?} */ deps = [];\n var /** @type {?} */ bootstrapComponentFactories = [];\n var /** @type {?} */ entryComponentFactories = ngModuleMeta.transitiveModule.entryComponents.map(function (entryComponent) {\n var /** @type {?} */ id = { reference: null };\n if (ngModuleMeta.bootstrapComponents.some(function (id) { return id.reference === entryComponent.reference; })) {\n bootstrapComponentFactories.push(id);\n }\n deps.push(new ComponentFactoryDependency(entryComponent, id));\n return id;\n });\n var /** @type {?} */ builder = new _InjectorBuilder(ngModuleMeta, entryComponentFactories, bootstrapComponentFactories, sourceSpan);\n var /** @type {?} */ providerParser = new NgModuleProviderAnalyzer(ngModuleMeta, extraProviders, sourceSpan);\n providerParser.parse().forEach(function (provider) { return builder.addProvider(provider); });\n var /** @type {?} */ injectorClass = builder.build();\n var /** @type {?} */ ngModuleFactoryVar = identifierName(ngModuleMeta.type) + \"NgFactory\";\n var /** @type {?} */ ngModuleFactoryStmt = o.variable(ngModuleFactoryVar)\n .set(o.importExpr(createIdentifier(Identifiers.NgModuleFactory))\n .instantiate([o.variable(injectorClass.name), o.importExpr(ngModuleMeta.type)], o.importType(createIdentifier(Identifiers.NgModuleFactory), [o.importType(ngModuleMeta.type)], [o.TypeModifier.Const])))\n .toDeclStmt(null, [o.StmtModifier.Final]);\n var /** @type {?} */ stmts = [injectorClass, ngModuleFactoryStmt];\n if (ngModuleMeta.id) {\n var /** @type {?} */ registerFactoryStmt = o.importExpr(createIdentifier(Identifiers.RegisterModuleFactoryFn))\n .callFn([o.literal(ngModuleMeta.id), o.variable(ngModuleFactoryVar)])\n .toStmt();\n stmts.push(registerFactoryStmt);\n }\n return new NgModuleCompileResult(stmts, ngModuleFactoryVar, deps);\n };\n NgModuleCompiler = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [])\n ], NgModuleCompiler);\n return NgModuleCompiler;\n}());\nvar _InjectorBuilder = (function () {\n /**\n * @param {?} _ngModuleMeta\n * @param {?} _entryComponentFactories\n * @param {?} _bootstrapComponentFactories\n * @param {?} _sourceSpan\n */\n function _InjectorBuilder(_ngModuleMeta, _entryComponentFactories, _bootstrapComponentFactories, _sourceSpan) {\n this._ngModuleMeta = _ngModuleMeta;\n this._entryComponentFactories = _entryComponentFactories;\n this._bootstrapComponentFactories = _bootstrapComponentFactories;\n this._sourceSpan = _sourceSpan;\n this.fields = [];\n this.getters = [];\n this.methods = [];\n this.ctorStmts = [];\n this._tokens = [];\n this._instances = new Map();\n this._createStmts = [];\n this._destroyStmts = [];\n }\n /**\n * @param {?} resolvedProvider\n * @return {?}\n */\n _InjectorBuilder.prototype.addProvider = function (resolvedProvider) {\n var _this = this;\n var /** @type {?} */ providerValueExpressions = resolvedProvider.providers.map(function (provider) { return _this._getProviderValue(provider); });\n var /** @type {?} */ propName = \"_\" + tokenName(resolvedProvider.token) + \"_\" + this._instances.size;\n var /** @type {?} */ instance = this._createProviderProperty(propName, resolvedProvider, providerValueExpressions, resolvedProvider.multiProvider, resolvedProvider.eager);\n if (resolvedProvider.lifecycleHooks.indexOf(LifecycleHooks.OnDestroy) !== -1) {\n this._destroyStmts.push(instance.callMethod('ngOnDestroy', []).toStmt());\n }\n this._tokens.push(resolvedProvider.token);\n this._instances.set(tokenReference(resolvedProvider.token), instance);\n };\n /**\n * @return {?}\n */\n _InjectorBuilder.prototype.build = function () {\n var _this = this;\n var /** @type {?} */ getMethodStmts = this._tokens.map(function (token) {\n var /** @type {?} */ providerExpr = _this._instances.get(tokenReference(token));\n return new o.IfStmt(InjectMethodVars.token.identical(createDiTokenExpression(token)), [new o.ReturnStatement(providerExpr)]);\n });\n var /** @type {?} */ methods = [\n new o.ClassMethod('createInternal', [], this._createStmts.concat(new o.ReturnStatement(this._instances.get(this._ngModuleMeta.type.reference))), o.importType(this._ngModuleMeta.type)),\n new o.ClassMethod('getInternal', [\n new o.FnParam(InjectMethodVars.token.name, o.DYNAMIC_TYPE),\n new o.FnParam(InjectMethodVars.notFoundResult.name, o.DYNAMIC_TYPE)\n ], getMethodStmts.concat([new o.ReturnStatement(InjectMethodVars.notFoundResult)]), o.DYNAMIC_TYPE),\n new o.ClassMethod('destroyInternal', [], this._destroyStmts),\n ];\n var /** @type {?} */ parentArgs = [\n o.variable(InjectorProps.parent.name),\n o.literalArr(this._entryComponentFactories.map(function (componentFactory) { return o.importExpr(componentFactory); })),\n o.literalArr(this._bootstrapComponentFactories.map(function (componentFactory) { return o.importExpr(componentFactory); }))\n ];\n var /** @type {?} */ injClassName = identifierName(this._ngModuleMeta.type) + \"Injector\";\n return createClassStmt({\n name: injClassName,\n ctorParams: [new o.FnParam(InjectorProps.parent.name, o.importType(createIdentifier(Identifiers.Injector)))],\n parent: o.importExpr(createIdentifier(Identifiers.NgModuleInjector), [o.importType(this._ngModuleMeta.type)]),\n parentArgs: parentArgs,\n builders: [{ methods: methods }, this]\n });\n };\n /**\n * @param {?} provider\n * @return {?}\n */\n _InjectorBuilder.prototype._getProviderValue = function (provider) {\n var _this = this;\n var /** @type {?} */ result;\n if (isPresent(provider.useExisting)) {\n result = this._getDependency({ token: provider.useExisting });\n }\n else if (isPresent(provider.useFactory)) {\n var /** @type {?} */ deps = provider.deps || provider.useFactory.diDeps;\n var /** @type {?} */ depsExpr = deps.map(function (dep) { return _this._getDependency(dep); });\n result = o.importExpr(provider.useFactory).callFn(depsExpr);\n }\n else if (isPresent(provider.useClass)) {\n var /** @type {?} */ deps = provider.deps || provider.useClass.diDeps;\n var /** @type {?} */ depsExpr = deps.map(function (dep) { return _this._getDependency(dep); });\n result =\n o.importExpr(provider.useClass).instantiate(depsExpr, o.importType(provider.useClass));\n }\n else {\n result = convertValueToOutputAst(provider.useValue);\n }\n return result;\n };\n /**\n * @param {?} propName\n * @param {?} provider\n * @param {?} providerValueExpressions\n * @param {?} isMulti\n * @param {?} isEager\n * @return {?}\n */\n _InjectorBuilder.prototype._createProviderProperty = function (propName, provider, providerValueExpressions, isMulti, isEager) {\n var /** @type {?} */ resolvedProviderValueExpr;\n var /** @type {?} */ type;\n if (isMulti) {\n resolvedProviderValueExpr = o.literalArr(providerValueExpressions);\n type = new o.ArrayType(o.DYNAMIC_TYPE);\n }\n else {\n resolvedProviderValueExpr = providerValueExpressions[0];\n type = providerValueExpressions[0].type;\n }\n if (!type) {\n type = o.DYNAMIC_TYPE;\n }\n if (isEager) {\n this.fields.push(new o.ClassField(propName, type));\n this._createStmts.push(o.THIS_EXPR.prop(propName).set(resolvedProviderValueExpr).toStmt());\n }\n else {\n var /** @type {?} */ internalField = \"_\" + propName;\n this.fields.push(new o.ClassField(internalField, type));\n // Note: Equals is important for JS so that it also checks the undefined case!\n var /** @type {?} */ getterStmts = [\n new o.IfStmt(o.THIS_EXPR.prop(internalField).isBlank(), [o.THIS_EXPR.prop(internalField).set(resolvedProviderValueExpr).toStmt()]),\n new o.ReturnStatement(o.THIS_EXPR.prop(internalField))\n ];\n this.getters.push(new o.ClassGetter(propName, getterStmts, type));\n }\n return o.THIS_EXPR.prop(propName);\n };\n /**\n * @param {?} dep\n * @return {?}\n */\n _InjectorBuilder.prototype._getDependency = function (dep) {\n var /** @type {?} */ result = null;\n if (dep.isValue) {\n result = o.literal(dep.value);\n }\n if (!dep.isSkipSelf) {\n if (dep.token &&\n (tokenReference(dep.token) === resolveIdentifier(Identifiers.Injector) ||\n tokenReference(dep.token) === resolveIdentifier(Identifiers.ComponentFactoryResolver))) {\n result = o.THIS_EXPR;\n }\n if (!result) {\n result = this._instances.get(tokenReference(dep.token));\n }\n }\n if (!result) {\n var /** @type {?} */ args = [createDiTokenExpression(dep.token)];\n if (dep.isOptional) {\n args.push(o.NULL_EXPR);\n }\n result = InjectorProps.parent.callMethod('get', args);\n }\n return result;\n };\n return _InjectorBuilder;\n}());\nfunction _InjectorBuilder_tsickle_Closure_declarations() {\n /** @type {?} */\n _InjectorBuilder.prototype.fields;\n /** @type {?} */\n _InjectorBuilder.prototype.getters;\n /** @type {?} */\n _InjectorBuilder.prototype.methods;\n /** @type {?} */\n _InjectorBuilder.prototype.ctorStmts;\n /** @type {?} */\n _InjectorBuilder.prototype._tokens;\n /** @type {?} */\n _InjectorBuilder.prototype._instances;\n /** @type {?} */\n _InjectorBuilder.prototype._createStmts;\n /** @type {?} */\n _InjectorBuilder.prototype._destroyStmts;\n /** @type {?} */\n _InjectorBuilder.prototype._ngModuleMeta;\n /** @type {?} */\n _InjectorBuilder.prototype._entryComponentFactories;\n /** @type {?} */\n _InjectorBuilder.prototype._bootstrapComponentFactories;\n /** @type {?} */\n _InjectorBuilder.prototype._sourceSpan;\n}\nvar InjectorProps = (function () {\n function InjectorProps() {\n }\n InjectorProps.parent = o.THIS_EXPR.prop('parent');\n return InjectorProps;\n}());\nfunction InjectorProps_tsickle_Closure_declarations() {\n /** @type {?} */\n InjectorProps.parent;\n}\nvar InjectMethodVars = (function () {\n function InjectMethodVars() {\n }\n InjectMethodVars.token = o.variable('token');\n InjectMethodVars.notFoundResult = o.variable('notFoundResult');\n return InjectMethodVars;\n}());\nfunction InjectMethodVars_tsickle_Closure_declarations() {\n /** @type {?} */\n InjectMethodVars.token;\n /** @type {?} */\n InjectMethodVars.notFoundResult;\n}\n//# sourceMappingURL=ng_module_compiler.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/ng_module_compiler.js\n// module id = ./node_modules/@angular/compiler/src/ng_module_compiler.js\n// module chunks = 0","/**\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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { NgModule } from '@angular/core';\nimport { ListWrapper } from './facade/collection';\nimport { isPresent, stringify } from './facade/lang';\nimport { CompilerInjectable } from './injectable';\nimport { ReflectorReader, reflector } from './private_import_core';\n/**\n * @param {?} obj\n * @return {?}\n */\nfunction _isNgModuleMetadata(obj) {\n return obj instanceof NgModule;\n}\n/**\n * Resolves types to {@link NgModule}.\n */\nexport var NgModuleResolver = (function () {\n /**\n * @param {?=} _reflector\n */\n function NgModuleResolver(_reflector) {\n if (_reflector === void 0) { _reflector = reflector; }\n this._reflector = _reflector;\n }\n /**\n * @param {?} type\n * @return {?}\n */\n NgModuleResolver.prototype.isNgModule = function (type) { return this._reflector.annotations(type).some(_isNgModuleMetadata); };\n /**\n * @param {?} type\n * @param {?=} throwIfNotFound\n * @return {?}\n */\n NgModuleResolver.prototype.resolve = function (type, throwIfNotFound) {\n if (throwIfNotFound === void 0) { throwIfNotFound = true; }\n var /** @type {?} */ ngModuleMeta = ListWrapper.findLast(this._reflector.annotations(type), _isNgModuleMetadata);\n if (isPresent(ngModuleMeta)) {\n return ngModuleMeta;\n }\n else {\n if (throwIfNotFound) {\n throw new Error(\"No NgModule metadata found for '\" + stringify(type) + \"'.\");\n }\n return null;\n }\n };\n NgModuleResolver = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [ReflectorReader])\n ], NgModuleResolver);\n return NgModuleResolver;\n}());\nfunction NgModuleResolver_tsickle_Closure_declarations() {\n /** @type {?} */\n NgModuleResolver.prototype._reflector;\n}\n//# sourceMappingURL=ng_module_resolver.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/ng_module_resolver.js\n// module id = ./node_modules/@angular/compiler/src/ng_module_resolver.js\n// module chunks = 0","/**\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 */\nimport { isBlank, isPresent } from '../facade/lang';\nimport * as o from './output_ast';\nvar /** @type {?} */ _SINGLE_QUOTE_ESCAPE_STRING_RE = /'|\\\\|\\n|\\r|\\$/g;\nvar /** @type {?} */ _LEGAL_IDENTIFIER_RE = /^[$A-Z_][0-9A-Z_$]*$/i;\nexport var /** @type {?} */ CATCH_ERROR_VAR = o.variable('error');\nexport var /** @type {?} */ CATCH_STACK_VAR = o.variable('stack');\n/**\n * @abstract\n */\nexport var OutputEmitter = (function () {\n function OutputEmitter() {\n }\n /**\n * @abstract\n * @param {?} moduleUrl\n * @param {?} stmts\n * @param {?} exportedVars\n * @return {?}\n */\n OutputEmitter.prototype.emitStatements = function (moduleUrl, stmts, exportedVars) { };\n return OutputEmitter;\n}());\nvar _EmittedLine = (function () {\n /**\n * @param {?} indent\n */\n function _EmittedLine(indent) {\n this.indent = indent;\n this.parts = [];\n }\n return _EmittedLine;\n}());\nfunction _EmittedLine_tsickle_Closure_declarations() {\n /** @type {?} */\n _EmittedLine.prototype.parts;\n /** @type {?} */\n _EmittedLine.prototype.indent;\n}\nexport var EmitterVisitorContext = (function () {\n /**\n * @param {?} _exportedVars\n * @param {?} _indent\n */\n function EmitterVisitorContext(_exportedVars, _indent) {\n this._exportedVars = _exportedVars;\n this._indent = _indent;\n this._classes = [];\n this._lines = [new _EmittedLine(_indent)];\n }\n /**\n * @param {?} exportedVars\n * @return {?}\n */\n EmitterVisitorContext.createRoot = function (exportedVars) {\n return new EmitterVisitorContext(exportedVars, 0);\n };\n Object.defineProperty(EmitterVisitorContext.prototype, \"_currentLine\", {\n /**\n * @return {?}\n */\n get: function () { return this._lines[this._lines.length - 1]; },\n enumerable: true,\n configurable: true\n });\n /**\n * @param {?} varName\n * @return {?}\n */\n EmitterVisitorContext.prototype.isExportedVar = function (varName) { return this._exportedVars.indexOf(varName) !== -1; };\n /**\n * @param {?=} lastPart\n * @return {?}\n */\n EmitterVisitorContext.prototype.println = function (lastPart) {\n if (lastPart === void 0) { lastPart = ''; }\n this.print(lastPart, true);\n };\n /**\n * @return {?}\n */\n EmitterVisitorContext.prototype.lineIsEmpty = function () { return this._currentLine.parts.length === 0; };\n /**\n * @param {?} part\n * @param {?=} newLine\n * @return {?}\n */\n EmitterVisitorContext.prototype.print = function (part, newLine) {\n if (newLine === void 0) { newLine = false; }\n if (part.length > 0) {\n this._currentLine.parts.push(part);\n }\n if (newLine) {\n this._lines.push(new _EmittedLine(this._indent));\n }\n };\n /**\n * @return {?}\n */\n EmitterVisitorContext.prototype.removeEmptyLastLine = function () {\n if (this.lineIsEmpty()) {\n this._lines.pop();\n }\n };\n /**\n * @return {?}\n */\n EmitterVisitorContext.prototype.incIndent = function () {\n this._indent++;\n this._currentLine.indent = this._indent;\n };\n /**\n * @return {?}\n */\n EmitterVisitorContext.prototype.decIndent = function () {\n this._indent--;\n this._currentLine.indent = this._indent;\n };\n /**\n * @param {?} clazz\n * @return {?}\n */\n EmitterVisitorContext.prototype.pushClass = function (clazz) { this._classes.push(clazz); };\n /**\n * @return {?}\n */\n EmitterVisitorContext.prototype.popClass = function () { return this._classes.pop(); };\n Object.defineProperty(EmitterVisitorContext.prototype, \"currentClass\", {\n /**\n * @return {?}\n */\n get: function () {\n return this._classes.length > 0 ? this._classes[this._classes.length - 1] : null;\n },\n enumerable: true,\n configurable: true\n });\n /**\n * @return {?}\n */\n EmitterVisitorContext.prototype.toSource = function () {\n var /** @type {?} */ lines = this._lines;\n if (lines[lines.length - 1].parts.length === 0) {\n lines = lines.slice(0, lines.length - 1);\n }\n return lines\n .map(function (line) {\n if (line.parts.length > 0) {\n return _createIndent(line.indent) + line.parts.join('');\n }\n else {\n return '';\n }\n })\n .join('\\n');\n };\n return EmitterVisitorContext;\n}());\nfunction EmitterVisitorContext_tsickle_Closure_declarations() {\n /** @type {?} */\n EmitterVisitorContext.prototype._lines;\n /** @type {?} */\n EmitterVisitorContext.prototype._classes;\n /** @type {?} */\n EmitterVisitorContext.prototype._exportedVars;\n /** @type {?} */\n EmitterVisitorContext.prototype._indent;\n}\n/**\n * @abstract\n */\nexport var AbstractEmitterVisitor = (function () {\n /**\n * @param {?} _escapeDollarInStrings\n */\n function AbstractEmitterVisitor(_escapeDollarInStrings) {\n this._escapeDollarInStrings = _escapeDollarInStrings;\n }\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitExpressionStmt = function (stmt, ctx) {\n stmt.expr.visitExpression(this, ctx);\n ctx.println(';');\n return null;\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitReturnStmt = function (stmt, ctx) {\n ctx.print(\"return \");\n stmt.value.visitExpression(this, ctx);\n ctx.println(';');\n return null;\n };\n /**\n * @abstract\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitCastExpr = function (ast, context) { };\n /**\n * @abstract\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitDeclareClassStmt = function (stmt, ctx) { };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitIfStmt = function (stmt, ctx) {\n ctx.print(\"if (\");\n stmt.condition.visitExpression(this, ctx);\n ctx.print(\") {\");\n var /** @type {?} */ hasElseCase = isPresent(stmt.falseCase) && stmt.falseCase.length > 0;\n if (stmt.trueCase.length <= 1 && !hasElseCase) {\n ctx.print(\" \");\n this.visitAllStatements(stmt.trueCase, ctx);\n ctx.removeEmptyLastLine();\n ctx.print(\" \");\n }\n else {\n ctx.println();\n ctx.incIndent();\n this.visitAllStatements(stmt.trueCase, ctx);\n ctx.decIndent();\n if (hasElseCase) {\n ctx.println(\"} else {\");\n ctx.incIndent();\n this.visitAllStatements(stmt.falseCase, ctx);\n ctx.decIndent();\n }\n }\n ctx.println(\"}\");\n return null;\n };\n /**\n * @abstract\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitTryCatchStmt = function (stmt, ctx) { };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitThrowStmt = function (stmt, ctx) {\n ctx.print(\"throw \");\n stmt.error.visitExpression(this, ctx);\n ctx.println(\";\");\n return null;\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitCommentStmt = function (stmt, ctx) {\n var /** @type {?} */ lines = stmt.comment.split('\\n');\n lines.forEach(function (line) { ctx.println(\"// \" + line); });\n return null;\n };\n /**\n * @abstract\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitDeclareVarStmt = function (stmt, ctx) { };\n /**\n * @param {?} expr\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitWriteVarExpr = function (expr, ctx) {\n var /** @type {?} */ lineWasEmpty = ctx.lineIsEmpty();\n if (!lineWasEmpty) {\n ctx.print('(');\n }\n ctx.print(expr.name + \" = \");\n expr.value.visitExpression(this, ctx);\n if (!lineWasEmpty) {\n ctx.print(')');\n }\n return null;\n };\n /**\n * @param {?} expr\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitWriteKeyExpr = function (expr, ctx) {\n var /** @type {?} */ lineWasEmpty = ctx.lineIsEmpty();\n if (!lineWasEmpty) {\n ctx.print('(');\n }\n expr.receiver.visitExpression(this, ctx);\n ctx.print(\"[\");\n expr.index.visitExpression(this, ctx);\n ctx.print(\"] = \");\n expr.value.visitExpression(this, ctx);\n if (!lineWasEmpty) {\n ctx.print(')');\n }\n return null;\n };\n /**\n * @param {?} expr\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitWritePropExpr = function (expr, ctx) {\n var /** @type {?} */ lineWasEmpty = ctx.lineIsEmpty();\n if (!lineWasEmpty) {\n ctx.print('(');\n }\n expr.receiver.visitExpression(this, ctx);\n ctx.print(\".\" + expr.name + \" = \");\n expr.value.visitExpression(this, ctx);\n if (!lineWasEmpty) {\n ctx.print(')');\n }\n return null;\n };\n /**\n * @param {?} expr\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitInvokeMethodExpr = function (expr, ctx) {\n expr.receiver.visitExpression(this, ctx);\n var /** @type {?} */ name = expr.name;\n if (isPresent(expr.builtin)) {\n name = this.getBuiltinMethodName(expr.builtin);\n if (isBlank(name)) {\n // some builtins just mean to skip the call.\n return null;\n }\n }\n ctx.print(\".\" + name + \"(\");\n this.visitAllExpressions(expr.args, ctx, \",\");\n ctx.print(\")\");\n return null;\n };\n /**\n * @abstract\n * @param {?} method\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.getBuiltinMethodName = function (method) { };\n /**\n * @param {?} expr\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitInvokeFunctionExpr = function (expr, ctx) {\n expr.fn.visitExpression(this, ctx);\n ctx.print(\"(\");\n this.visitAllExpressions(expr.args, ctx, ',');\n ctx.print(\")\");\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitReadVarExpr = function (ast, ctx) {\n var /** @type {?} */ varName = ast.name;\n if (isPresent(ast.builtin)) {\n switch (ast.builtin) {\n case o.BuiltinVar.Super:\n varName = 'super';\n break;\n case o.BuiltinVar.This:\n varName = 'this';\n break;\n case o.BuiltinVar.CatchError:\n varName = CATCH_ERROR_VAR.name;\n break;\n case o.BuiltinVar.CatchStack:\n varName = CATCH_STACK_VAR.name;\n break;\n default:\n throw new Error(\"Unknown builtin variable \" + ast.builtin);\n }\n }\n ctx.print(varName);\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitInstantiateExpr = function (ast, ctx) {\n ctx.print(\"new \");\n ast.classExpr.visitExpression(this, ctx);\n ctx.print(\"(\");\n this.visitAllExpressions(ast.args, ctx, ',');\n ctx.print(\")\");\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitLiteralExpr = function (ast, ctx) {\n var /** @type {?} */ value = ast.value;\n if (typeof value === 'string') {\n ctx.print(escapeIdentifier(value, this._escapeDollarInStrings));\n }\n else {\n ctx.print(\"\" + value);\n }\n return null;\n };\n /**\n * @abstract\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitExternalExpr = function (ast, ctx) { };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitConditionalExpr = function (ast, ctx) {\n ctx.print(\"(\");\n ast.condition.visitExpression(this, ctx);\n ctx.print('? ');\n ast.trueCase.visitExpression(this, ctx);\n ctx.print(': ');\n ast.falseCase.visitExpression(this, ctx);\n ctx.print(\")\");\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitNotExpr = function (ast, ctx) {\n ctx.print('!');\n ast.condition.visitExpression(this, ctx);\n return null;\n };\n /**\n * @abstract\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitFunctionExpr = function (ast, ctx) { };\n /**\n * @abstract\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitDeclareFunctionStmt = function (stmt, context) { };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitBinaryOperatorExpr = function (ast, ctx) {\n var /** @type {?} */ opStr;\n switch (ast.operator) {\n case o.BinaryOperator.Equals:\n opStr = '==';\n break;\n case o.BinaryOperator.Identical:\n opStr = '===';\n break;\n case o.BinaryOperator.NotEquals:\n opStr = '!=';\n break;\n case o.BinaryOperator.NotIdentical:\n opStr = '!==';\n break;\n case o.BinaryOperator.And:\n opStr = '&&';\n break;\n case o.BinaryOperator.Or:\n opStr = '||';\n break;\n case o.BinaryOperator.Plus:\n opStr = '+';\n break;\n case o.BinaryOperator.Minus:\n opStr = '-';\n break;\n case o.BinaryOperator.Divide:\n opStr = '/';\n break;\n case o.BinaryOperator.Multiply:\n opStr = '*';\n break;\n case o.BinaryOperator.Modulo:\n opStr = '%';\n break;\n case o.BinaryOperator.Lower:\n opStr = '<';\n break;\n case o.BinaryOperator.LowerEquals:\n opStr = '<=';\n break;\n case o.BinaryOperator.Bigger:\n opStr = '>';\n break;\n case o.BinaryOperator.BiggerEquals:\n opStr = '>=';\n break;\n default:\n throw new Error(\"Unknown operator \" + ast.operator);\n }\n ctx.print(\"(\");\n ast.lhs.visitExpression(this, ctx);\n ctx.print(\" \" + opStr + \" \");\n ast.rhs.visitExpression(this, ctx);\n ctx.print(\")\");\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitReadPropExpr = function (ast, ctx) {\n ast.receiver.visitExpression(this, ctx);\n ctx.print(\".\");\n ctx.print(ast.name);\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitReadKeyExpr = function (ast, ctx) {\n ast.receiver.visitExpression(this, ctx);\n ctx.print(\"[\");\n ast.index.visitExpression(this, ctx);\n ctx.print(\"]\");\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitLiteralArrayExpr = function (ast, ctx) {\n var /** @type {?} */ useNewLine = ast.entries.length > 1;\n ctx.print(\"[\", useNewLine);\n ctx.incIndent();\n this.visitAllExpressions(ast.entries, ctx, ',', useNewLine);\n ctx.decIndent();\n ctx.print(\"]\", useNewLine);\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitLiteralMapExpr = function (ast, ctx) {\n var _this = this;\n var /** @type {?} */ useNewLine = ast.entries.length > 1;\n ctx.print(\"{\", useNewLine);\n ctx.incIndent();\n this.visitAllObjects(function (entry) {\n ctx.print(escapeIdentifier(entry.key, _this._escapeDollarInStrings, entry.quoted) + \": \");\n entry.value.visitExpression(_this, ctx);\n }, ast.entries, ctx, ',', useNewLine);\n ctx.decIndent();\n ctx.print(\"}\", useNewLine);\n return null;\n };\n /**\n * @param {?} expressions\n * @param {?} ctx\n * @param {?} separator\n * @param {?=} newLine\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitAllExpressions = function (expressions, ctx, separator, newLine) {\n var _this = this;\n if (newLine === void 0) { newLine = false; }\n this.visitAllObjects(function (expr) { return expr.visitExpression(_this, ctx); }, expressions, ctx, separator, newLine);\n };\n /**\n * @param {?} handler\n * @param {?} expressions\n * @param {?} ctx\n * @param {?} separator\n * @param {?=} newLine\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitAllObjects = function (handler, expressions, ctx, separator, newLine) {\n if (newLine === void 0) { newLine = false; }\n for (var /** @type {?} */ i = 0; i < expressions.length; i++) {\n if (i > 0) {\n ctx.print(separator, newLine);\n }\n handler(expressions[i]);\n }\n if (newLine) {\n ctx.println();\n }\n };\n /**\n * @param {?} statements\n * @param {?} ctx\n * @return {?}\n */\n AbstractEmitterVisitor.prototype.visitAllStatements = function (statements, ctx) {\n var _this = this;\n statements.forEach(function (stmt) { return stmt.visitStatement(_this, ctx); });\n };\n return AbstractEmitterVisitor;\n}());\nfunction AbstractEmitterVisitor_tsickle_Closure_declarations() {\n /** @type {?} */\n AbstractEmitterVisitor.prototype._escapeDollarInStrings;\n}\n/**\n * @param {?} input\n * @param {?} escapeDollar\n * @param {?=} alwaysQuote\n * @return {?}\n */\nexport function escapeIdentifier(input, escapeDollar, alwaysQuote) {\n if (alwaysQuote === void 0) { alwaysQuote = true; }\n if (isBlank(input)) {\n return null;\n }\n var /** @type {?} */ body = input.replace(_SINGLE_QUOTE_ESCAPE_STRING_RE, function () {\n var match = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n match[_i - 0] = arguments[_i];\n }\n if (match[0] == '$') {\n return escapeDollar ? '\\\\$' : '$';\n }\n else if (match[0] == '\\n') {\n return '\\\\n';\n }\n else if (match[0] == '\\r') {\n return '\\\\r';\n }\n else {\n return \"\\\\\" + match[0];\n }\n });\n var /** @type {?} */ requiresQuotes = alwaysQuote || !_LEGAL_IDENTIFIER_RE.test(body);\n return requiresQuotes ? \"'\" + body + \"'\" : body;\n}\n/**\n * @param {?} count\n * @return {?}\n */\nfunction _createIndent(count) {\n var /** @type {?} */ res = '';\n for (var /** @type {?} */ i = 0; i < count; i++) {\n res += ' ';\n }\n return res;\n}\n//# sourceMappingURL=abstract_emitter.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/output/abstract_emitter.js\n// module id = ./node_modules/@angular/compiler/src/output/abstract_emitter.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nimport { isPresent } from '../facade/lang';\nimport { AbstractEmitterVisitor, CATCH_ERROR_VAR, CATCH_STACK_VAR } from './abstract_emitter';\nimport * as o from './output_ast';\n/**\n * @abstract\n */\nexport var AbstractJsEmitterVisitor = (function (_super) {\n __extends(AbstractJsEmitterVisitor, _super);\n function AbstractJsEmitterVisitor() {\n _super.call(this, false);\n }\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n AbstractJsEmitterVisitor.prototype.visitDeclareClassStmt = function (stmt, ctx) {\n var _this = this;\n ctx.pushClass(stmt);\n this._visitClassConstructor(stmt, ctx);\n if (isPresent(stmt.parent)) {\n ctx.print(stmt.name + \".prototype = Object.create(\");\n stmt.parent.visitExpression(this, ctx);\n ctx.println(\".prototype);\");\n }\n stmt.getters.forEach(function (getter) { return _this._visitClassGetter(stmt, getter, ctx); });\n stmt.methods.forEach(function (method) { return _this._visitClassMethod(stmt, method, ctx); });\n ctx.popClass();\n return null;\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n AbstractJsEmitterVisitor.prototype._visitClassConstructor = function (stmt, ctx) {\n ctx.print(\"function \" + stmt.name + \"(\");\n if (isPresent(stmt.constructorMethod)) {\n this._visitParams(stmt.constructorMethod.params, ctx);\n }\n ctx.println(\") {\");\n ctx.incIndent();\n if (isPresent(stmt.constructorMethod)) {\n if (stmt.constructorMethod.body.length > 0) {\n ctx.println(\"var self = this;\");\n this.visitAllStatements(stmt.constructorMethod.body, ctx);\n }\n }\n ctx.decIndent();\n ctx.println(\"}\");\n };\n /**\n * @param {?} stmt\n * @param {?} getter\n * @param {?} ctx\n * @return {?}\n */\n AbstractJsEmitterVisitor.prototype._visitClassGetter = function (stmt, getter, ctx) {\n ctx.println(\"Object.defineProperty(\" + stmt.name + \".prototype, '\" + getter.name + \"', { get: function() {\");\n ctx.incIndent();\n if (getter.body.length > 0) {\n ctx.println(\"var self = this;\");\n this.visitAllStatements(getter.body, ctx);\n }\n ctx.decIndent();\n ctx.println(\"}});\");\n };\n /**\n * @param {?} stmt\n * @param {?} method\n * @param {?} ctx\n * @return {?}\n */\n AbstractJsEmitterVisitor.prototype._visitClassMethod = function (stmt, method, ctx) {\n ctx.print(stmt.name + \".prototype.\" + method.name + \" = function(\");\n this._visitParams(method.params, ctx);\n ctx.println(\") {\");\n ctx.incIndent();\n if (method.body.length > 0) {\n ctx.println(\"var self = this;\");\n this.visitAllStatements(method.body, ctx);\n }\n ctx.decIndent();\n ctx.println(\"};\");\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractJsEmitterVisitor.prototype.visitReadVarExpr = function (ast, ctx) {\n if (ast.builtin === o.BuiltinVar.This) {\n ctx.print('self');\n }\n else if (ast.builtin === o.BuiltinVar.Super) {\n throw new Error(\"'super' needs to be handled at a parent ast node, not at the variable level!\");\n }\n else {\n _super.prototype.visitReadVarExpr.call(this, ast, ctx);\n }\n return null;\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n AbstractJsEmitterVisitor.prototype.visitDeclareVarStmt = function (stmt, ctx) {\n ctx.print(\"var \" + stmt.name + \" = \");\n stmt.value.visitExpression(this, ctx);\n ctx.println(\";\");\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractJsEmitterVisitor.prototype.visitCastExpr = function (ast, ctx) {\n ast.value.visitExpression(this, ctx);\n return null;\n };\n /**\n * @param {?} expr\n * @param {?} ctx\n * @return {?}\n */\n AbstractJsEmitterVisitor.prototype.visitInvokeFunctionExpr = function (expr, ctx) {\n var /** @type {?} */ fnExpr = expr.fn;\n if (fnExpr instanceof o.ReadVarExpr && fnExpr.builtin === o.BuiltinVar.Super) {\n ctx.currentClass.parent.visitExpression(this, ctx);\n ctx.print(\".call(this\");\n if (expr.args.length > 0) {\n ctx.print(\", \");\n this.visitAllExpressions(expr.args, ctx, ',');\n }\n ctx.print(\")\");\n }\n else {\n _super.prototype.visitInvokeFunctionExpr.call(this, expr, ctx);\n }\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n AbstractJsEmitterVisitor.prototype.visitFunctionExpr = function (ast, ctx) {\n ctx.print(\"function(\");\n this._visitParams(ast.params, ctx);\n ctx.println(\") {\");\n ctx.incIndent();\n this.visitAllStatements(ast.statements, ctx);\n ctx.decIndent();\n ctx.print(\"}\");\n return null;\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n AbstractJsEmitterVisitor.prototype.visitDeclareFunctionStmt = function (stmt, ctx) {\n ctx.print(\"function \" + stmt.name + \"(\");\n this._visitParams(stmt.params, ctx);\n ctx.println(\") {\");\n ctx.incIndent();\n this.visitAllStatements(stmt.statements, ctx);\n ctx.decIndent();\n ctx.println(\"}\");\n return null;\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n AbstractJsEmitterVisitor.prototype.visitTryCatchStmt = function (stmt, ctx) {\n ctx.println(\"try {\");\n ctx.incIndent();\n this.visitAllStatements(stmt.bodyStmts, ctx);\n ctx.decIndent();\n ctx.println(\"} catch (\" + CATCH_ERROR_VAR.name + \") {\");\n ctx.incIndent();\n var /** @type {?} */ catchStmts = [(CATCH_STACK_VAR.set(CATCH_ERROR_VAR.prop('stack')).toDeclStmt(null, [\n o.StmtModifier.Final\n ]))].concat(stmt.catchStmts);\n this.visitAllStatements(catchStmts, ctx);\n ctx.decIndent();\n ctx.println(\"}\");\n return null;\n };\n /**\n * @param {?} params\n * @param {?} ctx\n * @return {?}\n */\n AbstractJsEmitterVisitor.prototype._visitParams = function (params, ctx) {\n this.visitAllObjects(function (param) { return ctx.print(param.name); }, params, ctx, ',');\n };\n /**\n * @param {?} method\n * @return {?}\n */\n AbstractJsEmitterVisitor.prototype.getBuiltinMethodName = function (method) {\n var /** @type {?} */ name;\n switch (method) {\n case o.BuiltinMethod.ConcatArray:\n name = 'concat';\n break;\n case o.BuiltinMethod.SubscribeObservable:\n name = 'subscribe';\n break;\n case o.BuiltinMethod.Bind:\n name = 'bind';\n break;\n default:\n throw new Error(\"Unknown builtin method: \" + method);\n }\n return name;\n };\n return AbstractJsEmitterVisitor;\n}(AbstractEmitterVisitor));\n//# sourceMappingURL=abstract_js_emitter.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/output/abstract_js_emitter.js\n// module id = ./node_modules/@angular/compiler/src/output/abstract_js_emitter.js\n// module chunks = 0","/**\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 */\nimport * as o from './output_ast';\n/**\n * Create a new class stmts based on the given data.\n * @param {?} config\n * @return {?}\n */\nexport function createClassStmt(config) {\n var /** @type {?} */ parentArgs = config.parentArgs || [];\n var /** @type {?} */ superCtorStmts = config.parent ? [o.SUPER_EXPR.callFn(parentArgs).toStmt()] : [];\n var /** @type {?} */ builder = concatClassBuilderParts(Array.isArray(config.builders) ? config.builders : [config.builders]);\n var /** @type {?} */ ctor = new o.ClassMethod(null, config.ctorParams || [], superCtorStmts.concat(builder.ctorStmts));\n return new o.ClassStmt(config.name, config.parent, builder.fields, builder.getters, ctor, builder.methods, config.modifiers || []);\n}\n/**\n * @param {?} builders\n * @return {?}\n */\nfunction concatClassBuilderParts(builders) {\n return {\n fields: (_a = []).concat.apply(_a, builders.map(function (builder) { return builder.fields || []; })),\n methods: (_b = []).concat.apply(_b, builders.map(function (builder) { return builder.methods || []; })),\n getters: (_c = []).concat.apply(_c, builders.map(function (builder) { return builder.getters || []; })),\n ctorStmts: (_d = []).concat.apply(_d, builders.map(function (builder) { return builder.ctorStmts || []; })),\n };\n var _a, _b, _c, _d;\n}\n//# sourceMappingURL=class_builder.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/output/class_builder.js\n// module id = ./node_modules/@angular/compiler/src/output/class_builder.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nimport { isPresent } from '../facade/lang';\nexport var TypeModifier = {};\nTypeModifier.Const = 0;\nTypeModifier[TypeModifier.Const] = \"Const\";\n/**\n * @abstract\n */\nexport var Type = (function () {\n /**\n * @param {?=} modifiers\n */\n function Type(modifiers) {\n if (modifiers === void 0) { modifiers = null; }\n this.modifiers = modifiers;\n if (!modifiers) {\n this.modifiers = [];\n }\n }\n /**\n * @abstract\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n Type.prototype.visitType = function (visitor, context) { };\n /**\n * @param {?} modifier\n * @return {?}\n */\n Type.prototype.hasModifier = function (modifier) { return this.modifiers.indexOf(modifier) !== -1; };\n return Type;\n}());\nfunction Type_tsickle_Closure_declarations() {\n /** @type {?} */\n Type.prototype.modifiers;\n}\nexport var BuiltinTypeName = {};\nBuiltinTypeName.Dynamic = 0;\nBuiltinTypeName.Bool = 1;\nBuiltinTypeName.String = 2;\nBuiltinTypeName.Int = 3;\nBuiltinTypeName.Number = 4;\nBuiltinTypeName.Function = 5;\nBuiltinTypeName.Null = 6;\nBuiltinTypeName[BuiltinTypeName.Dynamic] = \"Dynamic\";\nBuiltinTypeName[BuiltinTypeName.Bool] = \"Bool\";\nBuiltinTypeName[BuiltinTypeName.String] = \"String\";\nBuiltinTypeName[BuiltinTypeName.Int] = \"Int\";\nBuiltinTypeName[BuiltinTypeName.Number] = \"Number\";\nBuiltinTypeName[BuiltinTypeName.Function] = \"Function\";\nBuiltinTypeName[BuiltinTypeName.Null] = \"Null\";\nexport var BuiltinType = (function (_super) {\n __extends(BuiltinType, _super);\n /**\n * @param {?} name\n * @param {?=} modifiers\n */\n function BuiltinType(name, modifiers) {\n if (modifiers === void 0) { modifiers = null; }\n _super.call(this, modifiers);\n this.name = name;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n BuiltinType.prototype.visitType = function (visitor, context) {\n return visitor.visitBuiltintType(this, context);\n };\n return BuiltinType;\n}(Type));\nfunction BuiltinType_tsickle_Closure_declarations() {\n /** @type {?} */\n BuiltinType.prototype.name;\n}\nexport var ExpressionType = (function (_super) {\n __extends(ExpressionType, _super);\n /**\n * @param {?} value\n * @param {?=} typeParams\n * @param {?=} modifiers\n */\n function ExpressionType(value, typeParams, modifiers) {\n if (typeParams === void 0) { typeParams = null; }\n if (modifiers === void 0) { modifiers = null; }\n _super.call(this, modifiers);\n this.value = value;\n this.typeParams = typeParams;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ExpressionType.prototype.visitType = function (visitor, context) {\n return visitor.visitExpressionType(this, context);\n };\n return ExpressionType;\n}(Type));\nfunction ExpressionType_tsickle_Closure_declarations() {\n /** @type {?} */\n ExpressionType.prototype.value;\n /** @type {?} */\n ExpressionType.prototype.typeParams;\n}\nexport var ArrayType = (function (_super) {\n __extends(ArrayType, _super);\n /**\n * @param {?} of\n * @param {?=} modifiers\n */\n function ArrayType(of, modifiers) {\n if (modifiers === void 0) { modifiers = null; }\n _super.call(this, modifiers);\n this.of = of;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ArrayType.prototype.visitType = function (visitor, context) {\n return visitor.visitArrayType(this, context);\n };\n return ArrayType;\n}(Type));\nfunction ArrayType_tsickle_Closure_declarations() {\n /** @type {?} */\n ArrayType.prototype.of;\n}\nexport var MapType = (function (_super) {\n __extends(MapType, _super);\n /**\n * @param {?} valueType\n * @param {?=} modifiers\n */\n function MapType(valueType, modifiers) {\n if (modifiers === void 0) { modifiers = null; }\n _super.call(this, modifiers);\n this.valueType = valueType;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n MapType.prototype.visitType = function (visitor, context) { return visitor.visitMapType(this, context); };\n return MapType;\n}(Type));\nfunction MapType_tsickle_Closure_declarations() {\n /** @type {?} */\n MapType.prototype.valueType;\n}\nexport var /** @type {?} */ DYNAMIC_TYPE = new BuiltinType(BuiltinTypeName.Dynamic);\nexport var /** @type {?} */ BOOL_TYPE = new BuiltinType(BuiltinTypeName.Bool);\nexport var /** @type {?} */ INT_TYPE = new BuiltinType(BuiltinTypeName.Int);\nexport var /** @type {?} */ NUMBER_TYPE = new BuiltinType(BuiltinTypeName.Number);\nexport var /** @type {?} */ STRING_TYPE = new BuiltinType(BuiltinTypeName.String);\nexport var /** @type {?} */ FUNCTION_TYPE = new BuiltinType(BuiltinTypeName.Function);\nexport var /** @type {?} */ NULL_TYPE = new BuiltinType(BuiltinTypeName.Null);\nexport var BinaryOperator = {};\nBinaryOperator.Equals = 0;\nBinaryOperator.NotEquals = 1;\nBinaryOperator.Identical = 2;\nBinaryOperator.NotIdentical = 3;\nBinaryOperator.Minus = 4;\nBinaryOperator.Plus = 5;\nBinaryOperator.Divide = 6;\nBinaryOperator.Multiply = 7;\nBinaryOperator.Modulo = 8;\nBinaryOperator.And = 9;\nBinaryOperator.Or = 10;\nBinaryOperator.Lower = 11;\nBinaryOperator.LowerEquals = 12;\nBinaryOperator.Bigger = 13;\nBinaryOperator.BiggerEquals = 14;\nBinaryOperator[BinaryOperator.Equals] = \"Equals\";\nBinaryOperator[BinaryOperator.NotEquals] = \"NotEquals\";\nBinaryOperator[BinaryOperator.Identical] = \"Identical\";\nBinaryOperator[BinaryOperator.NotIdentical] = \"NotIdentical\";\nBinaryOperator[BinaryOperator.Minus] = \"Minus\";\nBinaryOperator[BinaryOperator.Plus] = \"Plus\";\nBinaryOperator[BinaryOperator.Divide] = \"Divide\";\nBinaryOperator[BinaryOperator.Multiply] = \"Multiply\";\nBinaryOperator[BinaryOperator.Modulo] = \"Modulo\";\nBinaryOperator[BinaryOperator.And] = \"And\";\nBinaryOperator[BinaryOperator.Or] = \"Or\";\nBinaryOperator[BinaryOperator.Lower] = \"Lower\";\nBinaryOperator[BinaryOperator.LowerEquals] = \"LowerEquals\";\nBinaryOperator[BinaryOperator.Bigger] = \"Bigger\";\nBinaryOperator[BinaryOperator.BiggerEquals] = \"BiggerEquals\";\n/**\n * @abstract\n */\nexport var Expression = (function () {\n /**\n * @param {?} type\n */\n function Expression(type) {\n this.type = type;\n }\n /**\n * @abstract\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n Expression.prototype.visitExpression = function (visitor, context) { };\n /**\n * @param {?} name\n * @return {?}\n */\n Expression.prototype.prop = function (name) { return new ReadPropExpr(this, name); };\n /**\n * @param {?} index\n * @param {?=} type\n * @return {?}\n */\n Expression.prototype.key = function (index, type) {\n if (type === void 0) { type = null; }\n return new ReadKeyExpr(this, index, type);\n };\n /**\n * @param {?} name\n * @param {?} params\n * @return {?}\n */\n Expression.prototype.callMethod = function (name, params) {\n return new InvokeMethodExpr(this, name, params);\n };\n /**\n * @param {?} params\n * @return {?}\n */\n Expression.prototype.callFn = function (params) { return new InvokeFunctionExpr(this, params); };\n /**\n * @param {?} params\n * @param {?=} type\n * @return {?}\n */\n Expression.prototype.instantiate = function (params, type) {\n if (type === void 0) { type = null; }\n return new InstantiateExpr(this, params, type);\n };\n /**\n * @param {?} trueCase\n * @param {?=} falseCase\n * @return {?}\n */\n Expression.prototype.conditional = function (trueCase, falseCase) {\n if (falseCase === void 0) { falseCase = null; }\n return new ConditionalExpr(this, trueCase, falseCase);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.equals = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.Equals, this, rhs);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.notEquals = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.NotEquals, this, rhs);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.identical = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.Identical, this, rhs);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.notIdentical = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.NotIdentical, this, rhs);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.minus = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.Minus, this, rhs);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.plus = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.Plus, this, rhs);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.divide = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.Divide, this, rhs);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.multiply = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.Multiply, this, rhs);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.modulo = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.Modulo, this, rhs);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.and = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.And, this, rhs);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.or = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.Or, this, rhs);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.lower = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.Lower, this, rhs);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.lowerEquals = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.LowerEquals, this, rhs);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.bigger = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.Bigger, this, rhs);\n };\n /**\n * @param {?} rhs\n * @return {?}\n */\n Expression.prototype.biggerEquals = function (rhs) {\n return new BinaryOperatorExpr(BinaryOperator.BiggerEquals, this, rhs);\n };\n /**\n * @return {?}\n */\n Expression.prototype.isBlank = function () {\n // Note: We use equals by purpose here to compare to null and undefined in JS.\n // We use the typed null to allow strictNullChecks to narrow types.\n return this.equals(TYPED_NULL_EXPR);\n };\n /**\n * @param {?} type\n * @return {?}\n */\n Expression.prototype.cast = function (type) { return new CastExpr(this, type); };\n /**\n * @return {?}\n */\n Expression.prototype.toStmt = function () { return new ExpressionStatement(this); };\n return Expression;\n}());\nfunction Expression_tsickle_Closure_declarations() {\n /** @type {?} */\n Expression.prototype.type;\n}\nexport var BuiltinVar = {};\nBuiltinVar.This = 0;\nBuiltinVar.Super = 1;\nBuiltinVar.CatchError = 2;\nBuiltinVar.CatchStack = 3;\nBuiltinVar[BuiltinVar.This] = \"This\";\nBuiltinVar[BuiltinVar.Super] = \"Super\";\nBuiltinVar[BuiltinVar.CatchError] = \"CatchError\";\nBuiltinVar[BuiltinVar.CatchStack] = \"CatchStack\";\nexport var ReadVarExpr = (function (_super) {\n __extends(ReadVarExpr, _super);\n /**\n * @param {?} name\n * @param {?=} type\n */\n function ReadVarExpr(name, type) {\n if (type === void 0) { type = null; }\n _super.call(this, type);\n if (typeof name === 'string') {\n this.name = name;\n this.builtin = null;\n }\n else {\n this.name = null;\n this.builtin = name;\n }\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ReadVarExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitReadVarExpr(this, context);\n };\n /**\n * @param {?} value\n * @return {?}\n */\n ReadVarExpr.prototype.set = function (value) { return new WriteVarExpr(this.name, value); };\n return ReadVarExpr;\n}(Expression));\nfunction ReadVarExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n ReadVarExpr.prototype.name;\n /** @type {?} */\n ReadVarExpr.prototype.builtin;\n}\nexport var WriteVarExpr = (function (_super) {\n __extends(WriteVarExpr, _super);\n /**\n * @param {?} name\n * @param {?} value\n * @param {?=} type\n */\n function WriteVarExpr(name, value, type) {\n if (type === void 0) { type = null; }\n _super.call(this, type || value.type);\n this.name = name;\n this.value = value;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n WriteVarExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitWriteVarExpr(this, context);\n };\n /**\n * @param {?=} type\n * @param {?=} modifiers\n * @return {?}\n */\n WriteVarExpr.prototype.toDeclStmt = function (type, modifiers) {\n if (type === void 0) { type = null; }\n if (modifiers === void 0) { modifiers = null; }\n return new DeclareVarStmt(this.name, this.value, type, modifiers);\n };\n return WriteVarExpr;\n}(Expression));\nfunction WriteVarExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n WriteVarExpr.prototype.value;\n /** @type {?} */\n WriteVarExpr.prototype.name;\n}\nexport var WriteKeyExpr = (function (_super) {\n __extends(WriteKeyExpr, _super);\n /**\n * @param {?} receiver\n * @param {?} index\n * @param {?} value\n * @param {?=} type\n */\n function WriteKeyExpr(receiver, index, value, type) {\n if (type === void 0) { type = null; }\n _super.call(this, type || value.type);\n this.receiver = receiver;\n this.index = index;\n this.value = value;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n WriteKeyExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitWriteKeyExpr(this, context);\n };\n return WriteKeyExpr;\n}(Expression));\nfunction WriteKeyExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n WriteKeyExpr.prototype.value;\n /** @type {?} */\n WriteKeyExpr.prototype.receiver;\n /** @type {?} */\n WriteKeyExpr.prototype.index;\n}\nexport var WritePropExpr = (function (_super) {\n __extends(WritePropExpr, _super);\n /**\n * @param {?} receiver\n * @param {?} name\n * @param {?} value\n * @param {?=} type\n */\n function WritePropExpr(receiver, name, value, type) {\n if (type === void 0) { type = null; }\n _super.call(this, type || value.type);\n this.receiver = receiver;\n this.name = name;\n this.value = value;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n WritePropExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitWritePropExpr(this, context);\n };\n return WritePropExpr;\n}(Expression));\nfunction WritePropExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n WritePropExpr.prototype.value;\n /** @type {?} */\n WritePropExpr.prototype.receiver;\n /** @type {?} */\n WritePropExpr.prototype.name;\n}\nexport var BuiltinMethod = {};\nBuiltinMethod.ConcatArray = 0;\nBuiltinMethod.SubscribeObservable = 1;\nBuiltinMethod.Bind = 2;\nBuiltinMethod[BuiltinMethod.ConcatArray] = \"ConcatArray\";\nBuiltinMethod[BuiltinMethod.SubscribeObservable] = \"SubscribeObservable\";\nBuiltinMethod[BuiltinMethod.Bind] = \"Bind\";\nexport var InvokeMethodExpr = (function (_super) {\n __extends(InvokeMethodExpr, _super);\n /**\n * @param {?} receiver\n * @param {?} method\n * @param {?} args\n * @param {?=} type\n */\n function InvokeMethodExpr(receiver, method, args, type) {\n if (type === void 0) { type = null; }\n _super.call(this, type);\n this.receiver = receiver;\n this.args = args;\n if (typeof method === 'string') {\n this.name = method;\n this.builtin = null;\n }\n else {\n this.name = null;\n this.builtin = method;\n }\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n InvokeMethodExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitInvokeMethodExpr(this, context);\n };\n return InvokeMethodExpr;\n}(Expression));\nfunction InvokeMethodExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n InvokeMethodExpr.prototype.name;\n /** @type {?} */\n InvokeMethodExpr.prototype.builtin;\n /** @type {?} */\n InvokeMethodExpr.prototype.receiver;\n /** @type {?} */\n InvokeMethodExpr.prototype.args;\n}\nexport var InvokeFunctionExpr = (function (_super) {\n __extends(InvokeFunctionExpr, _super);\n /**\n * @param {?} fn\n * @param {?} args\n * @param {?=} type\n */\n function InvokeFunctionExpr(fn, args, type) {\n if (type === void 0) { type = null; }\n _super.call(this, type);\n this.fn = fn;\n this.args = args;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n InvokeFunctionExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitInvokeFunctionExpr(this, context);\n };\n return InvokeFunctionExpr;\n}(Expression));\nfunction InvokeFunctionExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n InvokeFunctionExpr.prototype.fn;\n /** @type {?} */\n InvokeFunctionExpr.prototype.args;\n}\nexport var InstantiateExpr = (function (_super) {\n __extends(InstantiateExpr, _super);\n /**\n * @param {?} classExpr\n * @param {?} args\n * @param {?=} type\n */\n function InstantiateExpr(classExpr, args, type) {\n _super.call(this, type);\n this.classExpr = classExpr;\n this.args = args;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n InstantiateExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitInstantiateExpr(this, context);\n };\n return InstantiateExpr;\n}(Expression));\nfunction InstantiateExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n InstantiateExpr.prototype.classExpr;\n /** @type {?} */\n InstantiateExpr.prototype.args;\n}\nexport var LiteralExpr = (function (_super) {\n __extends(LiteralExpr, _super);\n /**\n * @param {?} value\n * @param {?=} type\n */\n function LiteralExpr(value, type) {\n if (type === void 0) { type = null; }\n _super.call(this, type);\n this.value = value;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n LiteralExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitLiteralExpr(this, context);\n };\n return LiteralExpr;\n}(Expression));\nfunction LiteralExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n LiteralExpr.prototype.value;\n}\nexport var ExternalExpr = (function (_super) {\n __extends(ExternalExpr, _super);\n /**\n * @param {?} value\n * @param {?=} type\n * @param {?=} typeParams\n */\n function ExternalExpr(value, type, typeParams) {\n if (type === void 0) { type = null; }\n if (typeParams === void 0) { typeParams = null; }\n _super.call(this, type);\n this.value = value;\n this.typeParams = typeParams;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ExternalExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitExternalExpr(this, context);\n };\n return ExternalExpr;\n}(Expression));\nfunction ExternalExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n ExternalExpr.prototype.value;\n /** @type {?} */\n ExternalExpr.prototype.typeParams;\n}\nexport var ConditionalExpr = (function (_super) {\n __extends(ConditionalExpr, _super);\n /**\n * @param {?} condition\n * @param {?} trueCase\n * @param {?=} falseCase\n * @param {?=} type\n */\n function ConditionalExpr(condition, trueCase, falseCase, type) {\n if (falseCase === void 0) { falseCase = null; }\n if (type === void 0) { type = null; }\n _super.call(this, type || trueCase.type);\n this.condition = condition;\n this.falseCase = falseCase;\n this.trueCase = trueCase;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ConditionalExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitConditionalExpr(this, context);\n };\n return ConditionalExpr;\n}(Expression));\nfunction ConditionalExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n ConditionalExpr.prototype.trueCase;\n /** @type {?} */\n ConditionalExpr.prototype.condition;\n /** @type {?} */\n ConditionalExpr.prototype.falseCase;\n}\nexport var NotExpr = (function (_super) {\n __extends(NotExpr, _super);\n /**\n * @param {?} condition\n */\n function NotExpr(condition) {\n _super.call(this, BOOL_TYPE);\n this.condition = condition;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n NotExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitNotExpr(this, context);\n };\n return NotExpr;\n}(Expression));\nfunction NotExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n NotExpr.prototype.condition;\n}\nexport var CastExpr = (function (_super) {\n __extends(CastExpr, _super);\n /**\n * @param {?} value\n * @param {?} type\n */\n function CastExpr(value, type) {\n _super.call(this, type);\n this.value = value;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n CastExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitCastExpr(this, context);\n };\n return CastExpr;\n}(Expression));\nfunction CastExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n CastExpr.prototype.value;\n}\nexport var FnParam = (function () {\n /**\n * @param {?} name\n * @param {?=} type\n */\n function FnParam(name, type) {\n if (type === void 0) { type = null; }\n this.name = name;\n this.type = type;\n }\n return FnParam;\n}());\nfunction FnParam_tsickle_Closure_declarations() {\n /** @type {?} */\n FnParam.prototype.name;\n /** @type {?} */\n FnParam.prototype.type;\n}\nexport var FunctionExpr = (function (_super) {\n __extends(FunctionExpr, _super);\n /**\n * @param {?} params\n * @param {?} statements\n * @param {?=} type\n */\n function FunctionExpr(params, statements, type) {\n if (type === void 0) { type = null; }\n _super.call(this, type);\n this.params = params;\n this.statements = statements;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n FunctionExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitFunctionExpr(this, context);\n };\n /**\n * @param {?} name\n * @param {?=} modifiers\n * @return {?}\n */\n FunctionExpr.prototype.toDeclStmt = function (name, modifiers) {\n if (modifiers === void 0) { modifiers = null; }\n return new DeclareFunctionStmt(name, this.params, this.statements, this.type, modifiers);\n };\n return FunctionExpr;\n}(Expression));\nfunction FunctionExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n FunctionExpr.prototype.params;\n /** @type {?} */\n FunctionExpr.prototype.statements;\n}\nexport var BinaryOperatorExpr = (function (_super) {\n __extends(BinaryOperatorExpr, _super);\n /**\n * @param {?} operator\n * @param {?} lhs\n * @param {?} rhs\n * @param {?=} type\n */\n function BinaryOperatorExpr(operator, lhs, rhs, type) {\n if (type === void 0) { type = null; }\n _super.call(this, type || lhs.type);\n this.operator = operator;\n this.rhs = rhs;\n this.lhs = lhs;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n BinaryOperatorExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitBinaryOperatorExpr(this, context);\n };\n return BinaryOperatorExpr;\n}(Expression));\nfunction BinaryOperatorExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n BinaryOperatorExpr.prototype.lhs;\n /** @type {?} */\n BinaryOperatorExpr.prototype.operator;\n /** @type {?} */\n BinaryOperatorExpr.prototype.rhs;\n}\nexport var ReadPropExpr = (function (_super) {\n __extends(ReadPropExpr, _super);\n /**\n * @param {?} receiver\n * @param {?} name\n * @param {?=} type\n */\n function ReadPropExpr(receiver, name, type) {\n if (type === void 0) { type = null; }\n _super.call(this, type);\n this.receiver = receiver;\n this.name = name;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ReadPropExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitReadPropExpr(this, context);\n };\n /**\n * @param {?} value\n * @return {?}\n */\n ReadPropExpr.prototype.set = function (value) {\n return new WritePropExpr(this.receiver, this.name, value);\n };\n return ReadPropExpr;\n}(Expression));\nfunction ReadPropExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n ReadPropExpr.prototype.receiver;\n /** @type {?} */\n ReadPropExpr.prototype.name;\n}\nexport var ReadKeyExpr = (function (_super) {\n __extends(ReadKeyExpr, _super);\n /**\n * @param {?} receiver\n * @param {?} index\n * @param {?=} type\n */\n function ReadKeyExpr(receiver, index, type) {\n if (type === void 0) { type = null; }\n _super.call(this, type);\n this.receiver = receiver;\n this.index = index;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ReadKeyExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitReadKeyExpr(this, context);\n };\n /**\n * @param {?} value\n * @return {?}\n */\n ReadKeyExpr.prototype.set = function (value) {\n return new WriteKeyExpr(this.receiver, this.index, value);\n };\n return ReadKeyExpr;\n}(Expression));\nfunction ReadKeyExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n ReadKeyExpr.prototype.receiver;\n /** @type {?} */\n ReadKeyExpr.prototype.index;\n}\nexport var LiteralArrayExpr = (function (_super) {\n __extends(LiteralArrayExpr, _super);\n /**\n * @param {?} entries\n * @param {?=} type\n */\n function LiteralArrayExpr(entries, type) {\n if (type === void 0) { type = null; }\n _super.call(this, type);\n this.entries = entries;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n LiteralArrayExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitLiteralArrayExpr(this, context);\n };\n return LiteralArrayExpr;\n}(Expression));\nfunction LiteralArrayExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n LiteralArrayExpr.prototype.entries;\n}\nexport var LiteralMapEntry = (function () {\n /**\n * @param {?} key\n * @param {?} value\n * @param {?=} quoted\n */\n function LiteralMapEntry(key, value, quoted) {\n if (quoted === void 0) { quoted = false; }\n this.key = key;\n this.value = value;\n this.quoted = quoted;\n }\n return LiteralMapEntry;\n}());\nfunction LiteralMapEntry_tsickle_Closure_declarations() {\n /** @type {?} */\n LiteralMapEntry.prototype.key;\n /** @type {?} */\n LiteralMapEntry.prototype.value;\n /** @type {?} */\n LiteralMapEntry.prototype.quoted;\n}\nexport var LiteralMapExpr = (function (_super) {\n __extends(LiteralMapExpr, _super);\n /**\n * @param {?} entries\n * @param {?=} type\n */\n function LiteralMapExpr(entries, type) {\n if (type === void 0) { type = null; }\n _super.call(this, type);\n this.entries = entries;\n this.valueType = null;\n if (isPresent(type)) {\n this.valueType = type.valueType;\n }\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n LiteralMapExpr.prototype.visitExpression = function (visitor, context) {\n return visitor.visitLiteralMapExpr(this, context);\n };\n return LiteralMapExpr;\n}(Expression));\nfunction LiteralMapExpr_tsickle_Closure_declarations() {\n /** @type {?} */\n LiteralMapExpr.prototype.valueType;\n /** @type {?} */\n LiteralMapExpr.prototype.entries;\n}\nexport var /** @type {?} */ THIS_EXPR = new ReadVarExpr(BuiltinVar.This);\nexport var /** @type {?} */ SUPER_EXPR = new ReadVarExpr(BuiltinVar.Super);\nexport var /** @type {?} */ CATCH_ERROR_VAR = new ReadVarExpr(BuiltinVar.CatchError);\nexport var /** @type {?} */ CATCH_STACK_VAR = new ReadVarExpr(BuiltinVar.CatchStack);\nexport var /** @type {?} */ NULL_EXPR = new LiteralExpr(null, null);\nexport var /** @type {?} */ TYPED_NULL_EXPR = new LiteralExpr(null, NULL_TYPE);\nexport var StmtModifier = {};\nStmtModifier.Final = 0;\nStmtModifier.Private = 1;\nStmtModifier[StmtModifier.Final] = \"Final\";\nStmtModifier[StmtModifier.Private] = \"Private\";\n/**\n * @abstract\n */\nexport var Statement = (function () {\n /**\n * @param {?=} modifiers\n */\n function Statement(modifiers) {\n if (modifiers === void 0) { modifiers = null; }\n this.modifiers = modifiers;\n if (!modifiers) {\n this.modifiers = [];\n }\n }\n /**\n * @abstract\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n Statement.prototype.visitStatement = function (visitor, context) { };\n /**\n * @param {?} modifier\n * @return {?}\n */\n Statement.prototype.hasModifier = function (modifier) { return this.modifiers.indexOf(modifier) !== -1; };\n return Statement;\n}());\nfunction Statement_tsickle_Closure_declarations() {\n /** @type {?} */\n Statement.prototype.modifiers;\n}\nexport var DeclareVarStmt = (function (_super) {\n __extends(DeclareVarStmt, _super);\n /**\n * @param {?} name\n * @param {?} value\n * @param {?=} type\n * @param {?=} modifiers\n */\n function DeclareVarStmt(name, value, type, modifiers) {\n if (type === void 0) { type = null; }\n if (modifiers === void 0) { modifiers = null; }\n _super.call(this, modifiers);\n this.name = name;\n this.value = value;\n this.type = type || value.type;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n DeclareVarStmt.prototype.visitStatement = function (visitor, context) {\n return visitor.visitDeclareVarStmt(this, context);\n };\n return DeclareVarStmt;\n}(Statement));\nfunction DeclareVarStmt_tsickle_Closure_declarations() {\n /** @type {?} */\n DeclareVarStmt.prototype.type;\n /** @type {?} */\n DeclareVarStmt.prototype.name;\n /** @type {?} */\n DeclareVarStmt.prototype.value;\n}\nexport var DeclareFunctionStmt = (function (_super) {\n __extends(DeclareFunctionStmt, _super);\n /**\n * @param {?} name\n * @param {?} params\n * @param {?} statements\n * @param {?=} type\n * @param {?=} modifiers\n */\n function DeclareFunctionStmt(name, params, statements, type, modifiers) {\n if (type === void 0) { type = null; }\n if (modifiers === void 0) { modifiers = null; }\n _super.call(this, modifiers);\n this.name = name;\n this.params = params;\n this.statements = statements;\n this.type = type;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n DeclareFunctionStmt.prototype.visitStatement = function (visitor, context) {\n return visitor.visitDeclareFunctionStmt(this, context);\n };\n return DeclareFunctionStmt;\n}(Statement));\nfunction DeclareFunctionStmt_tsickle_Closure_declarations() {\n /** @type {?} */\n DeclareFunctionStmt.prototype.name;\n /** @type {?} */\n DeclareFunctionStmt.prototype.params;\n /** @type {?} */\n DeclareFunctionStmt.prototype.statements;\n /** @type {?} */\n DeclareFunctionStmt.prototype.type;\n}\nexport var ExpressionStatement = (function (_super) {\n __extends(ExpressionStatement, _super);\n /**\n * @param {?} expr\n */\n function ExpressionStatement(expr) {\n _super.call(this);\n this.expr = expr;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ExpressionStatement.prototype.visitStatement = function (visitor, context) {\n return visitor.visitExpressionStmt(this, context);\n };\n return ExpressionStatement;\n}(Statement));\nfunction ExpressionStatement_tsickle_Closure_declarations() {\n /** @type {?} */\n ExpressionStatement.prototype.expr;\n}\nexport var ReturnStatement = (function (_super) {\n __extends(ReturnStatement, _super);\n /**\n * @param {?} value\n */\n function ReturnStatement(value) {\n _super.call(this);\n this.value = value;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ReturnStatement.prototype.visitStatement = function (visitor, context) {\n return visitor.visitReturnStmt(this, context);\n };\n return ReturnStatement;\n}(Statement));\nfunction ReturnStatement_tsickle_Closure_declarations() {\n /** @type {?} */\n ReturnStatement.prototype.value;\n}\nexport var AbstractClassPart = (function () {\n /**\n * @param {?=} type\n * @param {?} modifiers\n */\n function AbstractClassPart(type, modifiers) {\n if (type === void 0) { type = null; }\n this.type = type;\n this.modifiers = modifiers;\n if (!modifiers) {\n this.modifiers = [];\n }\n }\n /**\n * @param {?} modifier\n * @return {?}\n */\n AbstractClassPart.prototype.hasModifier = function (modifier) { return this.modifiers.indexOf(modifier) !== -1; };\n return AbstractClassPart;\n}());\nfunction AbstractClassPart_tsickle_Closure_declarations() {\n /** @type {?} */\n AbstractClassPart.prototype.type;\n /** @type {?} */\n AbstractClassPart.prototype.modifiers;\n}\nexport var ClassField = (function (_super) {\n __extends(ClassField, _super);\n /**\n * @param {?} name\n * @param {?=} type\n * @param {?=} modifiers\n */\n function ClassField(name, type, modifiers) {\n if (type === void 0) { type = null; }\n if (modifiers === void 0) { modifiers = null; }\n _super.call(this, type, modifiers);\n this.name = name;\n }\n return ClassField;\n}(AbstractClassPart));\nfunction ClassField_tsickle_Closure_declarations() {\n /** @type {?} */\n ClassField.prototype.name;\n}\nexport var ClassMethod = (function (_super) {\n __extends(ClassMethod, _super);\n /**\n * @param {?} name\n * @param {?} params\n * @param {?} body\n * @param {?=} type\n * @param {?=} modifiers\n */\n function ClassMethod(name, params, body, type, modifiers) {\n if (type === void 0) { type = null; }\n if (modifiers === void 0) { modifiers = null; }\n _super.call(this, type, modifiers);\n this.name = name;\n this.params = params;\n this.body = body;\n }\n return ClassMethod;\n}(AbstractClassPart));\nfunction ClassMethod_tsickle_Closure_declarations() {\n /** @type {?} */\n ClassMethod.prototype.name;\n /** @type {?} */\n ClassMethod.prototype.params;\n /** @type {?} */\n ClassMethod.prototype.body;\n}\nexport var ClassGetter = (function (_super) {\n __extends(ClassGetter, _super);\n /**\n * @param {?} name\n * @param {?} body\n * @param {?=} type\n * @param {?=} modifiers\n */\n function ClassGetter(name, body, type, modifiers) {\n if (type === void 0) { type = null; }\n if (modifiers === void 0) { modifiers = null; }\n _super.call(this, type, modifiers);\n this.name = name;\n this.body = body;\n }\n return ClassGetter;\n}(AbstractClassPart));\nfunction ClassGetter_tsickle_Closure_declarations() {\n /** @type {?} */\n ClassGetter.prototype.name;\n /** @type {?} */\n ClassGetter.prototype.body;\n}\nexport var ClassStmt = (function (_super) {\n __extends(ClassStmt, _super);\n /**\n * @param {?} name\n * @param {?} parent\n * @param {?} fields\n * @param {?} getters\n * @param {?} constructorMethod\n * @param {?} methods\n * @param {?=} modifiers\n */\n function ClassStmt(name, parent, fields, getters, constructorMethod, methods, modifiers) {\n if (modifiers === void 0) { modifiers = null; }\n _super.call(this, modifiers);\n this.name = name;\n this.parent = parent;\n this.fields = fields;\n this.getters = getters;\n this.constructorMethod = constructorMethod;\n this.methods = methods;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ClassStmt.prototype.visitStatement = function (visitor, context) {\n return visitor.visitDeclareClassStmt(this, context);\n };\n return ClassStmt;\n}(Statement));\nfunction ClassStmt_tsickle_Closure_declarations() {\n /** @type {?} */\n ClassStmt.prototype.name;\n /** @type {?} */\n ClassStmt.prototype.parent;\n /** @type {?} */\n ClassStmt.prototype.fields;\n /** @type {?} */\n ClassStmt.prototype.getters;\n /** @type {?} */\n ClassStmt.prototype.constructorMethod;\n /** @type {?} */\n ClassStmt.prototype.methods;\n}\nexport var IfStmt = (function (_super) {\n __extends(IfStmt, _super);\n /**\n * @param {?} condition\n * @param {?} trueCase\n * @param {?=} falseCase\n */\n function IfStmt(condition, trueCase, falseCase) {\n if (falseCase === void 0) { falseCase = []; }\n _super.call(this);\n this.condition = condition;\n this.trueCase = trueCase;\n this.falseCase = falseCase;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n IfStmt.prototype.visitStatement = function (visitor, context) {\n return visitor.visitIfStmt(this, context);\n };\n return IfStmt;\n}(Statement));\nfunction IfStmt_tsickle_Closure_declarations() {\n /** @type {?} */\n IfStmt.prototype.condition;\n /** @type {?} */\n IfStmt.prototype.trueCase;\n /** @type {?} */\n IfStmt.prototype.falseCase;\n}\nexport var CommentStmt = (function (_super) {\n __extends(CommentStmt, _super);\n /**\n * @param {?} comment\n */\n function CommentStmt(comment) {\n _super.call(this);\n this.comment = comment;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n CommentStmt.prototype.visitStatement = function (visitor, context) {\n return visitor.visitCommentStmt(this, context);\n };\n return CommentStmt;\n}(Statement));\nfunction CommentStmt_tsickle_Closure_declarations() {\n /** @type {?} */\n CommentStmt.prototype.comment;\n}\nexport var TryCatchStmt = (function (_super) {\n __extends(TryCatchStmt, _super);\n /**\n * @param {?} bodyStmts\n * @param {?} catchStmts\n */\n function TryCatchStmt(bodyStmts, catchStmts) {\n _super.call(this);\n this.bodyStmts = bodyStmts;\n this.catchStmts = catchStmts;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n TryCatchStmt.prototype.visitStatement = function (visitor, context) {\n return visitor.visitTryCatchStmt(this, context);\n };\n return TryCatchStmt;\n}(Statement));\nfunction TryCatchStmt_tsickle_Closure_declarations() {\n /** @type {?} */\n TryCatchStmt.prototype.bodyStmts;\n /** @type {?} */\n TryCatchStmt.prototype.catchStmts;\n}\nexport var ThrowStmt = (function (_super) {\n __extends(ThrowStmt, _super);\n /**\n * @param {?} error\n */\n function ThrowStmt(error) {\n _super.call(this);\n this.error = error;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ThrowStmt.prototype.visitStatement = function (visitor, context) {\n return visitor.visitThrowStmt(this, context);\n };\n return ThrowStmt;\n}(Statement));\nfunction ThrowStmt_tsickle_Closure_declarations() {\n /** @type {?} */\n ThrowStmt.prototype.error;\n}\nexport var ExpressionTransformer = (function () {\n function ExpressionTransformer() {\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitReadVarExpr = function (ast, context) { return ast; };\n /**\n * @param {?} expr\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitWriteVarExpr = function (expr, context) {\n return new WriteVarExpr(expr.name, expr.value.visitExpression(this, context));\n };\n /**\n * @param {?} expr\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitWriteKeyExpr = function (expr, context) {\n return new WriteKeyExpr(expr.receiver.visitExpression(this, context), expr.index.visitExpression(this, context), expr.value.visitExpression(this, context));\n };\n /**\n * @param {?} expr\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitWritePropExpr = function (expr, context) {\n return new WritePropExpr(expr.receiver.visitExpression(this, context), expr.name, expr.value.visitExpression(this, context));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitInvokeMethodExpr = function (ast, context) {\n var /** @type {?} */ method = ast.builtin || ast.name;\n return new InvokeMethodExpr(ast.receiver.visitExpression(this, context), method, this.visitAllExpressions(ast.args, context), ast.type);\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitInvokeFunctionExpr = function (ast, context) {\n return new InvokeFunctionExpr(ast.fn.visitExpression(this, context), this.visitAllExpressions(ast.args, context), ast.type);\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitInstantiateExpr = function (ast, context) {\n return new InstantiateExpr(ast.classExpr.visitExpression(this, context), this.visitAllExpressions(ast.args, context), ast.type);\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitLiteralExpr = function (ast, context) { return ast; };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitExternalExpr = function (ast, context) { return ast; };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitConditionalExpr = function (ast, context) {\n return new ConditionalExpr(ast.condition.visitExpression(this, context), ast.trueCase.visitExpression(this, context), ast.falseCase.visitExpression(this, context));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitNotExpr = function (ast, context) {\n return new NotExpr(ast.condition.visitExpression(this, context));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitCastExpr = function (ast, context) {\n return new CastExpr(ast.value.visitExpression(this, context), context);\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitFunctionExpr = function (ast, context) {\n // Don't descend into nested functions\n return ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitBinaryOperatorExpr = function (ast, context) {\n return new BinaryOperatorExpr(ast.operator, ast.lhs.visitExpression(this, context), ast.rhs.visitExpression(this, context), ast.type);\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitReadPropExpr = function (ast, context) {\n return new ReadPropExpr(ast.receiver.visitExpression(this, context), ast.name, ast.type);\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitReadKeyExpr = function (ast, context) {\n return new ReadKeyExpr(ast.receiver.visitExpression(this, context), ast.index.visitExpression(this, context), ast.type);\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitLiteralArrayExpr = function (ast, context) {\n return new LiteralArrayExpr(this.visitAllExpressions(ast.entries, context));\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitLiteralMapExpr = function (ast, context) {\n var _this = this;\n var /** @type {?} */ entries = ast.entries.map(function (entry) { return new LiteralMapEntry(entry.key, entry.value.visitExpression(_this, context), entry.quoted); });\n return new LiteralMapExpr(entries);\n };\n /**\n * @param {?} exprs\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitAllExpressions = function (exprs, context) {\n var _this = this;\n return exprs.map(function (expr) { return expr.visitExpression(_this, context); });\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitDeclareVarStmt = function (stmt, context) {\n return new DeclareVarStmt(stmt.name, stmt.value.visitExpression(this, context), stmt.type, stmt.modifiers);\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitDeclareFunctionStmt = function (stmt, context) {\n // Don't descend into nested functions\n return stmt;\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitExpressionStmt = function (stmt, context) {\n return new ExpressionStatement(stmt.expr.visitExpression(this, context));\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitReturnStmt = function (stmt, context) {\n return new ReturnStatement(stmt.value.visitExpression(this, context));\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitDeclareClassStmt = function (stmt, context) {\n // Don't descend into nested functions\n return stmt;\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitIfStmt = function (stmt, context) {\n return new IfStmt(stmt.condition.visitExpression(this, context), this.visitAllStatements(stmt.trueCase, context), this.visitAllStatements(stmt.falseCase, context));\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitTryCatchStmt = function (stmt, context) {\n return new TryCatchStmt(this.visitAllStatements(stmt.bodyStmts, context), this.visitAllStatements(stmt.catchStmts, context));\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitThrowStmt = function (stmt, context) {\n return new ThrowStmt(stmt.error.visitExpression(this, context));\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitCommentStmt = function (stmt, context) { return stmt; };\n /**\n * @param {?} stmts\n * @param {?} context\n * @return {?}\n */\n ExpressionTransformer.prototype.visitAllStatements = function (stmts, context) {\n var _this = this;\n return stmts.map(function (stmt) { return stmt.visitStatement(_this, context); });\n };\n return ExpressionTransformer;\n}());\nexport var RecursiveExpressionVisitor = (function () {\n function RecursiveExpressionVisitor() {\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitReadVarExpr = function (ast, context) { return ast; };\n /**\n * @param {?} expr\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitWriteVarExpr = function (expr, context) {\n expr.value.visitExpression(this, context);\n return expr;\n };\n /**\n * @param {?} expr\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitWriteKeyExpr = function (expr, context) {\n expr.receiver.visitExpression(this, context);\n expr.index.visitExpression(this, context);\n expr.value.visitExpression(this, context);\n return expr;\n };\n /**\n * @param {?} expr\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitWritePropExpr = function (expr, context) {\n expr.receiver.visitExpression(this, context);\n expr.value.visitExpression(this, context);\n return expr;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitInvokeMethodExpr = function (ast, context) {\n ast.receiver.visitExpression(this, context);\n this.visitAllExpressions(ast.args, context);\n return ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitInvokeFunctionExpr = function (ast, context) {\n ast.fn.visitExpression(this, context);\n this.visitAllExpressions(ast.args, context);\n return ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitInstantiateExpr = function (ast, context) {\n ast.classExpr.visitExpression(this, context);\n this.visitAllExpressions(ast.args, context);\n return ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitLiteralExpr = function (ast, context) { return ast; };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitExternalExpr = function (ast, context) { return ast; };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitConditionalExpr = function (ast, context) {\n ast.condition.visitExpression(this, context);\n ast.trueCase.visitExpression(this, context);\n ast.falseCase.visitExpression(this, context);\n return ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitNotExpr = function (ast, context) {\n ast.condition.visitExpression(this, context);\n return ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitCastExpr = function (ast, context) {\n ast.value.visitExpression(this, context);\n return ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitFunctionExpr = function (ast, context) { return ast; };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitBinaryOperatorExpr = function (ast, context) {\n ast.lhs.visitExpression(this, context);\n ast.rhs.visitExpression(this, context);\n return ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitReadPropExpr = function (ast, context) {\n ast.receiver.visitExpression(this, context);\n return ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitReadKeyExpr = function (ast, context) {\n ast.receiver.visitExpression(this, context);\n ast.index.visitExpression(this, context);\n return ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitLiteralArrayExpr = function (ast, context) {\n this.visitAllExpressions(ast.entries, context);\n return ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitLiteralMapExpr = function (ast, context) {\n var _this = this;\n ast.entries.forEach(function (entry) { return entry.value.visitExpression(_this, context); });\n return ast;\n };\n /**\n * @param {?} exprs\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitAllExpressions = function (exprs, context) {\n var _this = this;\n exprs.forEach(function (expr) { return expr.visitExpression(_this, context); });\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitDeclareVarStmt = function (stmt, context) {\n stmt.value.visitExpression(this, context);\n return stmt;\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitDeclareFunctionStmt = function (stmt, context) {\n // Don't descend into nested functions\n return stmt;\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitExpressionStmt = function (stmt, context) {\n stmt.expr.visitExpression(this, context);\n return stmt;\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitReturnStmt = function (stmt, context) {\n stmt.value.visitExpression(this, context);\n return stmt;\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitDeclareClassStmt = function (stmt, context) {\n // Don't descend into nested functions\n return stmt;\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitIfStmt = function (stmt, context) {\n stmt.condition.visitExpression(this, context);\n this.visitAllStatements(stmt.trueCase, context);\n this.visitAllStatements(stmt.falseCase, context);\n return stmt;\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitTryCatchStmt = function (stmt, context) {\n this.visitAllStatements(stmt.bodyStmts, context);\n this.visitAllStatements(stmt.catchStmts, context);\n return stmt;\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitThrowStmt = function (stmt, context) {\n stmt.error.visitExpression(this, context);\n return stmt;\n };\n /**\n * @param {?} stmt\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitCommentStmt = function (stmt, context) { return stmt; };\n /**\n * @param {?} stmts\n * @param {?} context\n * @return {?}\n */\n RecursiveExpressionVisitor.prototype.visitAllStatements = function (stmts, context) {\n var _this = this;\n stmts.forEach(function (stmt) { return stmt.visitStatement(_this, context); });\n };\n return RecursiveExpressionVisitor;\n}());\n/**\n * @param {?} varName\n * @param {?} newValue\n * @param {?} expression\n * @return {?}\n */\nexport function replaceVarInExpression(varName, newValue, expression) {\n var /** @type {?} */ transformer = new _ReplaceVariableTransformer(varName, newValue);\n return expression.visitExpression(transformer, null);\n}\nvar _ReplaceVariableTransformer = (function (_super) {\n __extends(_ReplaceVariableTransformer, _super);\n /**\n * @param {?} _varName\n * @param {?} _newValue\n */\n function _ReplaceVariableTransformer(_varName, _newValue) {\n _super.call(this);\n this._varName = _varName;\n this._newValue = _newValue;\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n _ReplaceVariableTransformer.prototype.visitReadVarExpr = function (ast, context) {\n return ast.name == this._varName ? this._newValue : ast;\n };\n return _ReplaceVariableTransformer;\n}(ExpressionTransformer));\nfunction _ReplaceVariableTransformer_tsickle_Closure_declarations() {\n /** @type {?} */\n _ReplaceVariableTransformer.prototype._varName;\n /** @type {?} */\n _ReplaceVariableTransformer.prototype._newValue;\n}\n/**\n * @param {?} stmts\n * @return {?}\n */\nexport function findReadVarNames(stmts) {\n var /** @type {?} */ finder = new _VariableFinder();\n finder.visitAllStatements(stmts, null);\n return finder.varNames;\n}\nvar _VariableFinder = (function (_super) {\n __extends(_VariableFinder, _super);\n function _VariableFinder() {\n _super.apply(this, arguments);\n this.varNames = new Set();\n }\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n _VariableFinder.prototype.visitReadVarExpr = function (ast, context) {\n this.varNames.add(ast.name);\n return null;\n };\n return _VariableFinder;\n}(RecursiveExpressionVisitor));\nfunction _VariableFinder_tsickle_Closure_declarations() {\n /** @type {?} */\n _VariableFinder.prototype.varNames;\n}\n/**\n * @param {?} name\n * @param {?=} type\n * @return {?}\n */\nexport function variable(name, type) {\n if (type === void 0) { type = null; }\n return new ReadVarExpr(name, type);\n}\n/**\n * @param {?} id\n * @param {?=} typeParams\n * @return {?}\n */\nexport function importExpr(id, typeParams) {\n if (typeParams === void 0) { typeParams = null; }\n return new ExternalExpr(id, null, typeParams);\n}\n/**\n * @param {?} id\n * @param {?=} typeParams\n * @param {?=} typeModifiers\n * @return {?}\n */\nexport function importType(id, typeParams, typeModifiers) {\n if (typeParams === void 0) { typeParams = null; }\n if (typeModifiers === void 0) { typeModifiers = null; }\n return isPresent(id) ? expressionType(importExpr(id), typeParams, typeModifiers) : null;\n}\n/**\n * @param {?} expr\n * @param {?=} typeParams\n * @param {?=} typeModifiers\n * @return {?}\n */\nexport function expressionType(expr, typeParams, typeModifiers) {\n if (typeParams === void 0) { typeParams = null; }\n if (typeModifiers === void 0) { typeModifiers = null; }\n return isPresent(expr) ? new ExpressionType(expr, typeParams, typeModifiers) : null;\n}\n/**\n * @param {?} values\n * @param {?=} type\n * @return {?}\n */\nexport function literalArr(values, type) {\n if (type === void 0) { type = null; }\n return new LiteralArrayExpr(values, type);\n}\n/**\n * @param {?} values\n * @param {?=} type\n * @param {?=} quoted\n * @return {?}\n */\nexport function literalMap(values, type, quoted) {\n if (type === void 0) { type = null; }\n if (quoted === void 0) { quoted = false; }\n return new LiteralMapExpr(values.map(function (entry) { return new LiteralMapEntry(entry[0], entry[1], quoted); }), type);\n}\n/**\n * @param {?} expr\n * @return {?}\n */\nexport function not(expr) {\n return new NotExpr(expr);\n}\n/**\n * @param {?} params\n * @param {?} body\n * @param {?=} type\n * @return {?}\n */\nexport function fn(params, body, type) {\n if (type === void 0) { type = null; }\n return new FunctionExpr(params, body, type);\n}\n/**\n * @param {?} value\n * @param {?=} type\n * @return {?}\n */\nexport function literal(value, type) {\n if (type === void 0) { type = null; }\n return new LiteralExpr(value, type);\n}\n//# sourceMappingURL=output_ast.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/output/output_ast.js\n// module id = ./node_modules/@angular/compiler/src/output/output_ast.js\n// module chunks = 0","/**\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 */\nimport { isPresent } from '../facade/lang';\nimport * as o from './output_ast';\nimport { debugOutputAstAsTypeScript } from './ts_emitter';\n/**\n * @param {?} statements\n * @param {?} resultVar\n * @return {?}\n */\nexport function interpretStatements(statements, resultVar) {\n var /** @type {?} */ stmtsWithReturn = statements.concat([new o.ReturnStatement(o.variable(resultVar))]);\n var /** @type {?} */ ctx = new _ExecutionContext(null, null, null, new Map());\n var /** @type {?} */ visitor = new StatementInterpreter();\n var /** @type {?} */ result = visitor.visitAllStatements(stmtsWithReturn, ctx);\n return isPresent(result) ? result.value : null;\n}\n/**\n * @param {?} varNames\n * @param {?} varValues\n * @param {?} statements\n * @param {?} ctx\n * @param {?} visitor\n * @return {?}\n */\nfunction _executeFunctionStatements(varNames, varValues, statements, ctx, visitor) {\n var /** @type {?} */ childCtx = ctx.createChildWihtLocalVars();\n for (var /** @type {?} */ i = 0; i < varNames.length; i++) {\n childCtx.vars.set(varNames[i], varValues[i]);\n }\n var /** @type {?} */ result = visitor.visitAllStatements(statements, childCtx);\n return isPresent(result) ? result.value : null;\n}\nvar _ExecutionContext = (function () {\n /**\n * @param {?} parent\n * @param {?} instance\n * @param {?} className\n * @param {?} vars\n */\n function _ExecutionContext(parent, instance, className, vars) {\n this.parent = parent;\n this.instance = instance;\n this.className = className;\n this.vars = vars;\n }\n /**\n * @return {?}\n */\n _ExecutionContext.prototype.createChildWihtLocalVars = function () {\n return new _ExecutionContext(this, this.instance, this.className, new Map());\n };\n return _ExecutionContext;\n}());\nfunction _ExecutionContext_tsickle_Closure_declarations() {\n /** @type {?} */\n _ExecutionContext.prototype.parent;\n /** @type {?} */\n _ExecutionContext.prototype.instance;\n /** @type {?} */\n _ExecutionContext.prototype.className;\n /** @type {?} */\n _ExecutionContext.prototype.vars;\n}\nvar ReturnValue = (function () {\n /**\n * @param {?} value\n */\n function ReturnValue(value) {\n this.value = value;\n }\n return ReturnValue;\n}());\nfunction ReturnValue_tsickle_Closure_declarations() {\n /** @type {?} */\n ReturnValue.prototype.value;\n}\n/**\n * @param {?} _classStmt\n * @param {?} _ctx\n * @param {?} _visitor\n * @return {?}\n */\nfunction createDynamicClass(_classStmt, _ctx, _visitor) {\n var /** @type {?} */ propertyDescriptors = {};\n _classStmt.getters.forEach(function (getter) {\n // Note: use `function` instead of arrow function to capture `this`\n propertyDescriptors[getter.name] = {\n configurable: false,\n get: function () {\n var /** @type {?} */ instanceCtx = new _ExecutionContext(_ctx, this, _classStmt.name, _ctx.vars);\n return _executeFunctionStatements([], [], getter.body, instanceCtx, _visitor);\n }\n };\n });\n _classStmt.methods.forEach(function (method) {\n var /** @type {?} */ paramNames = method.params.map(function (param) { return param.name; });\n // Note: use `function` instead of arrow function to capture `this`\n propertyDescriptors[method.name] = {\n writable: false,\n configurable: false,\n value: function () {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i - 0] = arguments[_i];\n }\n var /** @type {?} */ instanceCtx = new _ExecutionContext(_ctx, this, _classStmt.name, _ctx.vars);\n return _executeFunctionStatements(paramNames, args, method.body, instanceCtx, _visitor);\n }\n };\n });\n var /** @type {?} */ ctorParamNames = _classStmt.constructorMethod.params.map(function (param) { return param.name; });\n // Note: use `function` instead of arrow function to capture `this`\n var /** @type {?} */ ctor = function () {\n var _this = this;\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i - 0] = arguments[_i];\n }\n var /** @type {?} */ instanceCtx = new _ExecutionContext(_ctx, this, _classStmt.name, _ctx.vars);\n _classStmt.fields.forEach(function (field) { _this[field.name] = undefined; });\n _executeFunctionStatements(ctorParamNames, args, _classStmt.constructorMethod.body, instanceCtx, _visitor);\n };\n var /** @type {?} */ superClass = _classStmt.parent ? _classStmt.parent.visitExpression(_visitor, _ctx) : Object;\n ctor.prototype = Object.create(superClass.prototype, propertyDescriptors);\n return ctor;\n}\nvar StatementInterpreter = (function () {\n function StatementInterpreter() {\n }\n /**\n * @param {?} ast\n * @return {?}\n */\n StatementInterpreter.prototype.debugAst = function (ast) { return debugOutputAstAsTypeScript(ast); };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitDeclareVarStmt = function (stmt, ctx) {\n ctx.vars.set(stmt.name, stmt.value.visitExpression(this, ctx));\n return null;\n };\n /**\n * @param {?} expr\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitWriteVarExpr = function (expr, ctx) {\n var /** @type {?} */ value = expr.value.visitExpression(this, ctx);\n var /** @type {?} */ currCtx = ctx;\n while (currCtx != null) {\n if (currCtx.vars.has(expr.name)) {\n currCtx.vars.set(expr.name, value);\n return value;\n }\n currCtx = currCtx.parent;\n }\n throw new Error(\"Not declared variable \" + expr.name);\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitReadVarExpr = function (ast, ctx) {\n var /** @type {?} */ varName = ast.name;\n if (isPresent(ast.builtin)) {\n switch (ast.builtin) {\n case o.BuiltinVar.Super:\n return ctx.instance.__proto__;\n case o.BuiltinVar.This:\n return ctx.instance;\n case o.BuiltinVar.CatchError:\n varName = CATCH_ERROR_VAR;\n break;\n case o.BuiltinVar.CatchStack:\n varName = CATCH_STACK_VAR;\n break;\n default:\n throw new Error(\"Unknown builtin variable \" + ast.builtin);\n }\n }\n var /** @type {?} */ currCtx = ctx;\n while (currCtx != null) {\n if (currCtx.vars.has(varName)) {\n return currCtx.vars.get(varName);\n }\n currCtx = currCtx.parent;\n }\n throw new Error(\"Not declared variable \" + varName);\n };\n /**\n * @param {?} expr\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitWriteKeyExpr = function (expr, ctx) {\n var /** @type {?} */ receiver = expr.receiver.visitExpression(this, ctx);\n var /** @type {?} */ index = expr.index.visitExpression(this, ctx);\n var /** @type {?} */ value = expr.value.visitExpression(this, ctx);\n receiver[index] = value;\n return value;\n };\n /**\n * @param {?} expr\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitWritePropExpr = function (expr, ctx) {\n var /** @type {?} */ receiver = expr.receiver.visitExpression(this, ctx);\n var /** @type {?} */ value = expr.value.visitExpression(this, ctx);\n receiver[expr.name] = value;\n return value;\n };\n /**\n * @param {?} expr\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitInvokeMethodExpr = function (expr, ctx) {\n var /** @type {?} */ receiver = expr.receiver.visitExpression(this, ctx);\n var /** @type {?} */ args = this.visitAllExpressions(expr.args, ctx);\n var /** @type {?} */ result;\n if (isPresent(expr.builtin)) {\n switch (expr.builtin) {\n case o.BuiltinMethod.ConcatArray:\n result = receiver.concat.apply(receiver, args);\n break;\n case o.BuiltinMethod.SubscribeObservable:\n result = receiver.subscribe({ next: args[0] });\n break;\n case o.BuiltinMethod.Bind:\n result = receiver.bind.apply(receiver, args);\n break;\n default:\n throw new Error(\"Unknown builtin method \" + expr.builtin);\n }\n }\n else {\n result = receiver[expr.name].apply(receiver, args);\n }\n return result;\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitInvokeFunctionExpr = function (stmt, ctx) {\n var /** @type {?} */ args = this.visitAllExpressions(stmt.args, ctx);\n var /** @type {?} */ fnExpr = stmt.fn;\n if (fnExpr instanceof o.ReadVarExpr && fnExpr.builtin === o.BuiltinVar.Super) {\n ctx.instance.constructor.prototype.constructor.apply(ctx.instance, args);\n return null;\n }\n else {\n var /** @type {?} */ fn = stmt.fn.visitExpression(this, ctx);\n return fn.apply(null, args);\n }\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitReturnStmt = function (stmt, ctx) {\n return new ReturnValue(stmt.value.visitExpression(this, ctx));\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitDeclareClassStmt = function (stmt, ctx) {\n var /** @type {?} */ clazz = createDynamicClass(stmt, ctx, this);\n ctx.vars.set(stmt.name, clazz);\n return null;\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitExpressionStmt = function (stmt, ctx) {\n return stmt.expr.visitExpression(this, ctx);\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitIfStmt = function (stmt, ctx) {\n var /** @type {?} */ condition = stmt.condition.visitExpression(this, ctx);\n if (condition) {\n return this.visitAllStatements(stmt.trueCase, ctx);\n }\n else if (isPresent(stmt.falseCase)) {\n return this.visitAllStatements(stmt.falseCase, ctx);\n }\n return null;\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitTryCatchStmt = function (stmt, ctx) {\n try {\n return this.visitAllStatements(stmt.bodyStmts, ctx);\n }\n catch (e) {\n var /** @type {?} */ childCtx = ctx.createChildWihtLocalVars();\n childCtx.vars.set(CATCH_ERROR_VAR, e);\n childCtx.vars.set(CATCH_STACK_VAR, e.stack);\n return this.visitAllStatements(stmt.catchStmts, childCtx);\n }\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitThrowStmt = function (stmt, ctx) {\n throw stmt.error.visitExpression(this, ctx);\n };\n /**\n * @param {?} stmt\n * @param {?=} context\n * @return {?}\n */\n StatementInterpreter.prototype.visitCommentStmt = function (stmt, context) { return null; };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitInstantiateExpr = function (ast, ctx) {\n var /** @type {?} */ args = this.visitAllExpressions(ast.args, ctx);\n var /** @type {?} */ clazz = ast.classExpr.visitExpression(this, ctx);\n return new (clazz.bind.apply(clazz, [void 0].concat(args)))();\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitLiteralExpr = function (ast, ctx) { return ast.value; };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitExternalExpr = function (ast, ctx) {\n return ast.value.reference;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitConditionalExpr = function (ast, ctx) {\n if (ast.condition.visitExpression(this, ctx)) {\n return ast.trueCase.visitExpression(this, ctx);\n }\n else if (isPresent(ast.falseCase)) {\n return ast.falseCase.visitExpression(this, ctx);\n }\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitNotExpr = function (ast, ctx) {\n return !ast.condition.visitExpression(this, ctx);\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitCastExpr = function (ast, ctx) {\n return ast.value.visitExpression(this, ctx);\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitFunctionExpr = function (ast, ctx) {\n var /** @type {?} */ paramNames = ast.params.map(function (param) { return param.name; });\n return _declareFn(paramNames, ast.statements, ctx, this);\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitDeclareFunctionStmt = function (stmt, ctx) {\n var /** @type {?} */ paramNames = stmt.params.map(function (param) { return param.name; });\n ctx.vars.set(stmt.name, _declareFn(paramNames, stmt.statements, ctx, this));\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitBinaryOperatorExpr = function (ast, ctx) {\n var _this = this;\n var /** @type {?} */ lhs = function () { return ast.lhs.visitExpression(_this, ctx); };\n var /** @type {?} */ rhs = function () { return ast.rhs.visitExpression(_this, ctx); };\n switch (ast.operator) {\n case o.BinaryOperator.Equals:\n return lhs() == rhs();\n case o.BinaryOperator.Identical:\n return lhs() === rhs();\n case o.BinaryOperator.NotEquals:\n return lhs() != rhs();\n case o.BinaryOperator.NotIdentical:\n return lhs() !== rhs();\n case o.BinaryOperator.And:\n return lhs() && rhs();\n case o.BinaryOperator.Or:\n return lhs() || rhs();\n case o.BinaryOperator.Plus:\n return lhs() + rhs();\n case o.BinaryOperator.Minus:\n return lhs() - rhs();\n case o.BinaryOperator.Divide:\n return lhs() / rhs();\n case o.BinaryOperator.Multiply:\n return lhs() * rhs();\n case o.BinaryOperator.Modulo:\n return lhs() % rhs();\n case o.BinaryOperator.Lower:\n return lhs() < rhs();\n case o.BinaryOperator.LowerEquals:\n return lhs() <= rhs();\n case o.BinaryOperator.Bigger:\n return lhs() > rhs();\n case o.BinaryOperator.BiggerEquals:\n return lhs() >= rhs();\n default:\n throw new Error(\"Unknown operator \" + ast.operator);\n }\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitReadPropExpr = function (ast, ctx) {\n var /** @type {?} */ result;\n var /** @type {?} */ receiver = ast.receiver.visitExpression(this, ctx);\n result = receiver[ast.name];\n return result;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitReadKeyExpr = function (ast, ctx) {\n var /** @type {?} */ receiver = ast.receiver.visitExpression(this, ctx);\n var /** @type {?} */ prop = ast.index.visitExpression(this, ctx);\n return receiver[prop];\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitLiteralArrayExpr = function (ast, ctx) {\n return this.visitAllExpressions(ast.entries, ctx);\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitLiteralMapExpr = function (ast, ctx) {\n var _this = this;\n var /** @type {?} */ result = {};\n ast.entries.forEach(function (entry) { return ((result))[entry.key] = entry.value.visitExpression(_this, ctx); });\n return result;\n };\n /**\n * @param {?} expressions\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitAllExpressions = function (expressions, ctx) {\n var _this = this;\n return expressions.map(function (expr) { return expr.visitExpression(_this, ctx); });\n };\n /**\n * @param {?} statements\n * @param {?} ctx\n * @return {?}\n */\n StatementInterpreter.prototype.visitAllStatements = function (statements, ctx) {\n for (var /** @type {?} */ i = 0; i < statements.length; i++) {\n var /** @type {?} */ stmt = statements[i];\n var /** @type {?} */ val = stmt.visitStatement(this, ctx);\n if (val instanceof ReturnValue) {\n return val;\n }\n }\n return null;\n };\n return StatementInterpreter;\n}());\n/**\n * @param {?} varNames\n * @param {?} statements\n * @param {?} ctx\n * @param {?} visitor\n * @return {?}\n */\nfunction _declareFn(varNames, statements, ctx, visitor) {\n return function () {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i - 0] = arguments[_i];\n }\n return _executeFunctionStatements(varNames, args, statements, ctx, visitor);\n };\n}\nvar /** @type {?} */ CATCH_ERROR_VAR = 'error';\nvar /** @type {?} */ CATCH_STACK_VAR = 'stack';\n//# sourceMappingURL=output_interpreter.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/output/output_interpreter.js\n// module id = ./node_modules/@angular/compiler/src/output/output_interpreter.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nimport { identifierName } from '../compile_metadata';\nimport { EmitterVisitorContext } from './abstract_emitter';\nimport { AbstractJsEmitterVisitor } from './abstract_js_emitter';\n/**\n * @param {?} sourceUrl\n * @param {?} expr\n * @param {?} declarations\n * @param {?} vars\n * @return {?}\n */\nfunction evalExpression(sourceUrl, expr, declarations, vars) {\n var /** @type {?} */ fnBody = declarations + \"\\nreturn \" + expr + \"\\n//# sourceURL=\" + sourceUrl;\n var /** @type {?} */ fnArgNames = [];\n var /** @type {?} */ fnArgValues = [];\n for (var argName in vars) {\n fnArgNames.push(argName);\n fnArgValues.push(vars[argName]);\n }\n return new (Function.bind.apply(Function, [void 0].concat(fnArgNames.concat(fnBody))))().apply(void 0, fnArgValues);\n}\n/**\n * @param {?} sourceUrl\n * @param {?} statements\n * @param {?} resultVar\n * @return {?}\n */\nexport function jitStatements(sourceUrl, statements, resultVar) {\n var /** @type {?} */ converter = new JitEmitterVisitor();\n var /** @type {?} */ ctx = EmitterVisitorContext.createRoot([resultVar]);\n converter.visitAllStatements(statements, ctx);\n return evalExpression(sourceUrl, resultVar, ctx.toSource(), converter.getArgs());\n}\nvar JitEmitterVisitor = (function (_super) {\n __extends(JitEmitterVisitor, _super);\n function JitEmitterVisitor() {\n _super.apply(this, arguments);\n this._evalArgNames = [];\n this._evalArgValues = [];\n }\n /**\n * @return {?}\n */\n JitEmitterVisitor.prototype.getArgs = function () {\n var /** @type {?} */ result = {};\n for (var /** @type {?} */ i = 0; i < this._evalArgNames.length; i++) {\n result[this._evalArgNames[i]] = this._evalArgValues[i];\n }\n return result;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n JitEmitterVisitor.prototype.visitExternalExpr = function (ast, ctx) {\n var /** @type {?} */ value = ast.value.reference;\n var /** @type {?} */ id = this._evalArgValues.indexOf(value);\n if (id === -1) {\n id = this._evalArgValues.length;\n this._evalArgValues.push(value);\n var /** @type {?} */ name_1 = identifierName(ast.value) || 'val';\n this._evalArgNames.push(\"jit_\" + name_1 + id);\n }\n ctx.print(this._evalArgNames[id]);\n return null;\n };\n return JitEmitterVisitor;\n}(AbstractJsEmitterVisitor));\nfunction JitEmitterVisitor_tsickle_Closure_declarations() {\n /** @type {?} */\n JitEmitterVisitor.prototype._evalArgNames;\n /** @type {?} */\n JitEmitterVisitor.prototype._evalArgValues;\n}\n//# sourceMappingURL=output_jit.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/output/output_jit.js\n// module id = ./node_modules/@angular/compiler/src/output/output_jit.js\n// module chunks = 0","/**\n * Interface that defines how import statements should be generated.\n * @abstract\n */\nexport var ImportResolver = (function () {\n function ImportResolver() {\n }\n /**\n * Converts a file path to a module name that can be used as an `import.\n * I.e. `path/to/importedFile.ts` should be imported by `path/to/containingFile.ts`.\n * @abstract\n * @param {?} importedFilePath\n * @param {?} containingFilePath\n * @return {?}\n */\n ImportResolver.prototype.fileNameToModuleName = function (importedFilePath, containingFilePath) { };\n return ImportResolver;\n}());\n//# sourceMappingURL=path_util.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/output/path_util.js\n// module id = ./node_modules/@angular/compiler/src/output/path_util.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nimport { identifierModuleUrl, identifierName } from '../compile_metadata';\nimport { isBlank, isPresent } from '../facade/lang';\nimport { AbstractEmitterVisitor, CATCH_ERROR_VAR, CATCH_STACK_VAR, EmitterVisitorContext } from './abstract_emitter';\nimport * as o from './output_ast';\nvar /** @type {?} */ _debugModuleUrl = '/debug/lib';\n/**\n * @param {?} ast\n * @return {?}\n */\nexport function debugOutputAstAsTypeScript(ast) {\n var /** @type {?} */ converter = new _TsEmitterVisitor(_debugModuleUrl);\n var /** @type {?} */ ctx = EmitterVisitorContext.createRoot([]);\n var /** @type {?} */ asts = Array.isArray(ast) ? ast : [ast];\n asts.forEach(function (ast) {\n if (ast instanceof o.Statement) {\n ast.visitStatement(converter, ctx);\n }\n else if (ast instanceof o.Expression) {\n ast.visitExpression(converter, ctx);\n }\n else if (ast instanceof o.Type) {\n ast.visitType(converter, ctx);\n }\n else {\n throw new Error(\"Don't know how to print debug info for \" + ast);\n }\n });\n return ctx.toSource();\n}\nexport var TypeScriptEmitter = (function () {\n /**\n * @param {?} _importGenerator\n */\n function TypeScriptEmitter(_importGenerator) {\n this._importGenerator = _importGenerator;\n }\n /**\n * @param {?} moduleUrl\n * @param {?} stmts\n * @param {?} exportedVars\n * @return {?}\n */\n TypeScriptEmitter.prototype.emitStatements = function (moduleUrl, stmts, exportedVars) {\n var _this = this;\n var /** @type {?} */ converter = new _TsEmitterVisitor(moduleUrl);\n var /** @type {?} */ ctx = EmitterVisitorContext.createRoot(exportedVars);\n converter.visitAllStatements(stmts, ctx);\n var /** @type {?} */ srcParts = [];\n converter.importsWithPrefixes.forEach(function (prefix, importedModuleUrl) {\n // Note: can't write the real word for import as it screws up system.js auto detection...\n srcParts.push(\"imp\" +\n (\"ort * as \" + prefix + \" from '\" + _this._importGenerator.fileNameToModuleName(importedModuleUrl, moduleUrl) + \"';\"));\n });\n srcParts.push(ctx.toSource());\n return srcParts.join('\\n');\n };\n return TypeScriptEmitter;\n}());\nfunction TypeScriptEmitter_tsickle_Closure_declarations() {\n /** @type {?} */\n TypeScriptEmitter.prototype._importGenerator;\n}\nvar _TsEmitterVisitor = (function (_super) {\n __extends(_TsEmitterVisitor, _super);\n /**\n * @param {?} _moduleUrl\n */\n function _TsEmitterVisitor(_moduleUrl) {\n _super.call(this, false);\n this._moduleUrl = _moduleUrl;\n this.importsWithPrefixes = new Map();\n }\n /**\n * @param {?} t\n * @param {?} ctx\n * @param {?=} defaultType\n * @return {?}\n */\n _TsEmitterVisitor.prototype.visitType = function (t, ctx, defaultType) {\n if (defaultType === void 0) { defaultType = 'any'; }\n if (isPresent(t)) {\n t.visitType(this, ctx);\n }\n else {\n ctx.print(defaultType);\n }\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype.visitLiteralExpr = function (ast, ctx) {\n var /** @type {?} */ value = ast.value;\n if (isBlank(value) && ast.type != o.NULL_TYPE) {\n ctx.print(\"(\" + value + \" as any)\");\n return null;\n }\n return _super.prototype.visitLiteralExpr.call(this, ast, ctx);\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype.visitLiteralArrayExpr = function (ast, ctx) {\n if (ast.entries.length === 0) {\n ctx.print('(');\n }\n var /** @type {?} */ result = _super.prototype.visitLiteralArrayExpr.call(this, ast, ctx);\n if (ast.entries.length === 0) {\n ctx.print(' as any[])');\n }\n return result;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype.visitExternalExpr = function (ast, ctx) {\n this._visitIdentifier(ast.value, ast.typeParams, ctx);\n return null;\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype.visitDeclareVarStmt = function (stmt, ctx) {\n if (ctx.isExportedVar(stmt.name)) {\n ctx.print(\"export \");\n }\n if (stmt.hasModifier(o.StmtModifier.Final)) {\n ctx.print(\"const\");\n }\n else {\n ctx.print(\"var\");\n }\n ctx.print(\" \" + stmt.name + \":\");\n this.visitType(stmt.type, ctx);\n ctx.print(\" = \");\n stmt.value.visitExpression(this, ctx);\n ctx.println(\";\");\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype.visitCastExpr = function (ast, ctx) {\n ctx.print(\"(<\");\n ast.type.visitType(this, ctx);\n ctx.print(\">\");\n ast.value.visitExpression(this, ctx);\n ctx.print(\")\");\n return null;\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype.visitDeclareClassStmt = function (stmt, ctx) {\n var _this = this;\n ctx.pushClass(stmt);\n if (ctx.isExportedVar(stmt.name)) {\n ctx.print(\"export \");\n }\n ctx.print(\"class \" + stmt.name);\n if (isPresent(stmt.parent)) {\n ctx.print(\" extends \");\n stmt.parent.visitExpression(this, ctx);\n }\n ctx.println(\" {\");\n ctx.incIndent();\n stmt.fields.forEach(function (field) { return _this._visitClassField(field, ctx); });\n if (isPresent(stmt.constructorMethod)) {\n this._visitClassConstructor(stmt, ctx);\n }\n stmt.getters.forEach(function (getter) { return _this._visitClassGetter(getter, ctx); });\n stmt.methods.forEach(function (method) { return _this._visitClassMethod(method, ctx); });\n ctx.decIndent();\n ctx.println(\"}\");\n ctx.popClass();\n return null;\n };\n /**\n * @param {?} field\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype._visitClassField = function (field, ctx) {\n if (field.hasModifier(o.StmtModifier.Private)) {\n // comment out as a workaround for #10967\n ctx.print(\"/*private*/ \");\n }\n ctx.print(field.name);\n ctx.print(':');\n this.visitType(field.type, ctx);\n ctx.println(\";\");\n };\n /**\n * @param {?} getter\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype._visitClassGetter = function (getter, ctx) {\n if (getter.hasModifier(o.StmtModifier.Private)) {\n ctx.print(\"private \");\n }\n ctx.print(\"get \" + getter.name + \"()\");\n ctx.print(':');\n this.visitType(getter.type, ctx);\n ctx.println(\" {\");\n ctx.incIndent();\n this.visitAllStatements(getter.body, ctx);\n ctx.decIndent();\n ctx.println(\"}\");\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype._visitClassConstructor = function (stmt, ctx) {\n ctx.print(\"constructor(\");\n this._visitParams(stmt.constructorMethod.params, ctx);\n ctx.println(\") {\");\n ctx.incIndent();\n this.visitAllStatements(stmt.constructorMethod.body, ctx);\n ctx.decIndent();\n ctx.println(\"}\");\n };\n /**\n * @param {?} method\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype._visitClassMethod = function (method, ctx) {\n if (method.hasModifier(o.StmtModifier.Private)) {\n ctx.print(\"private \");\n }\n ctx.print(method.name + \"(\");\n this._visitParams(method.params, ctx);\n ctx.print(\"):\");\n this.visitType(method.type, ctx, 'void');\n ctx.println(\" {\");\n ctx.incIndent();\n this.visitAllStatements(method.body, ctx);\n ctx.decIndent();\n ctx.println(\"}\");\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype.visitFunctionExpr = function (ast, ctx) {\n ctx.print(\"(\");\n this._visitParams(ast.params, ctx);\n ctx.print(\"):\");\n this.visitType(ast.type, ctx, 'void');\n ctx.println(\" => {\");\n ctx.incIndent();\n this.visitAllStatements(ast.statements, ctx);\n ctx.decIndent();\n ctx.print(\"}\");\n return null;\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype.visitDeclareFunctionStmt = function (stmt, ctx) {\n if (ctx.isExportedVar(stmt.name)) {\n ctx.print(\"export \");\n }\n ctx.print(\"function \" + stmt.name + \"(\");\n this._visitParams(stmt.params, ctx);\n ctx.print(\"):\");\n this.visitType(stmt.type, ctx, 'void');\n ctx.println(\" {\");\n ctx.incIndent();\n this.visitAllStatements(stmt.statements, ctx);\n ctx.decIndent();\n ctx.println(\"}\");\n return null;\n };\n /**\n * @param {?} stmt\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype.visitTryCatchStmt = function (stmt, ctx) {\n ctx.println(\"try {\");\n ctx.incIndent();\n this.visitAllStatements(stmt.bodyStmts, ctx);\n ctx.decIndent();\n ctx.println(\"} catch (\" + CATCH_ERROR_VAR.name + \") {\");\n ctx.incIndent();\n var /** @type {?} */ catchStmts = [(CATCH_STACK_VAR.set(CATCH_ERROR_VAR.prop('stack')).toDeclStmt(null, [\n o.StmtModifier.Final\n ]))].concat(stmt.catchStmts);\n this.visitAllStatements(catchStmts, ctx);\n ctx.decIndent();\n ctx.println(\"}\");\n return null;\n };\n /**\n * @param {?} type\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype.visitBuiltintType = function (type, ctx) {\n var /** @type {?} */ typeStr;\n switch (type.name) {\n case o.BuiltinTypeName.Bool:\n typeStr = 'boolean';\n break;\n case o.BuiltinTypeName.Dynamic:\n typeStr = 'any';\n break;\n case o.BuiltinTypeName.Function:\n typeStr = 'Function';\n break;\n case o.BuiltinTypeName.Number:\n typeStr = 'number';\n break;\n case o.BuiltinTypeName.Int:\n typeStr = 'number';\n break;\n case o.BuiltinTypeName.String:\n typeStr = 'string';\n break;\n default:\n throw new Error(\"Unsupported builtin type \" + type.name);\n }\n ctx.print(typeStr);\n return null;\n };\n /**\n * @param {?} ast\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype.visitExpressionType = function (ast, ctx) {\n var _this = this;\n ast.value.visitExpression(this, ctx);\n if (isPresent(ast.typeParams) && ast.typeParams.length > 0) {\n ctx.print(\"<\");\n this.visitAllObjects(function (type) { return type.visitType(_this, ctx); }, ast.typeParams, ctx, ',');\n ctx.print(\">\");\n }\n return null;\n };\n /**\n * @param {?} type\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype.visitArrayType = function (type, ctx) {\n this.visitType(type.of, ctx);\n ctx.print(\"[]\");\n return null;\n };\n /**\n * @param {?} type\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype.visitMapType = function (type, ctx) {\n ctx.print(\"{[key: string]:\");\n this.visitType(type.valueType, ctx);\n ctx.print(\"}\");\n return null;\n };\n /**\n * @param {?} method\n * @return {?}\n */\n _TsEmitterVisitor.prototype.getBuiltinMethodName = function (method) {\n var /** @type {?} */ name;\n switch (method) {\n case o.BuiltinMethod.ConcatArray:\n name = 'concat';\n break;\n case o.BuiltinMethod.SubscribeObservable:\n name = 'subscribe';\n break;\n case o.BuiltinMethod.Bind:\n name = 'bind';\n break;\n default:\n throw new Error(\"Unknown builtin method: \" + method);\n }\n return name;\n };\n /**\n * @param {?} params\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype._visitParams = function (params, ctx) {\n var _this = this;\n this.visitAllObjects(function (param) {\n ctx.print(param.name);\n ctx.print(':');\n _this.visitType(param.type, ctx);\n }, params, ctx, ',');\n };\n /**\n * @param {?} value\n * @param {?} typeParams\n * @param {?} ctx\n * @return {?}\n */\n _TsEmitterVisitor.prototype._visitIdentifier = function (value, typeParams, ctx) {\n var _this = this;\n var /** @type {?} */ name = identifierName(value);\n var /** @type {?} */ moduleUrl = identifierModuleUrl(value);\n if (isBlank(name)) {\n throw new Error(\"Internal error: unknown identifier \" + value);\n }\n if (isPresent(moduleUrl) && moduleUrl != this._moduleUrl) {\n var /** @type {?} */ prefix = this.importsWithPrefixes.get(moduleUrl);\n if (isBlank(prefix)) {\n prefix = \"import\" + this.importsWithPrefixes.size;\n this.importsWithPrefixes.set(moduleUrl, prefix);\n }\n ctx.print(prefix + \".\");\n }\n if (value.reference && value.reference.members && value.reference.members.length) {\n ctx.print(value.reference.name);\n ctx.print('.');\n ctx.print(value.reference.members.join('.'));\n }\n else {\n ctx.print(name);\n }\n if (isPresent(typeParams) && typeParams.length > 0) {\n ctx.print(\"<\");\n this.visitAllObjects(function (type) { return type.visitType(_this, ctx); }, typeParams, ctx, ',');\n ctx.print(\">\");\n }\n };\n return _TsEmitterVisitor;\n}(AbstractEmitterVisitor));\nfunction _TsEmitterVisitor_tsickle_Closure_declarations() {\n /** @type {?} */\n _TsEmitterVisitor.prototype.importsWithPrefixes;\n /** @type {?} */\n _TsEmitterVisitor.prototype._moduleUrl;\n}\n//# sourceMappingURL=ts_emitter.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/output/ts_emitter.js\n// module id = ./node_modules/@angular/compiler/src/output/ts_emitter.js\n// module chunks = 0","/**\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 */\nimport { visitValue } from '../util';\nimport * as o from './output_ast';\nexport var /** @type {?} */ QUOTED_KEYS = '$quoted$';\n/**\n * @param {?} value\n * @param {?=} type\n * @return {?}\n */\nexport function convertValueToOutputAst(value, type) {\n if (type === void 0) { type = null; }\n return visitValue(value, new _ValueOutputAstTransformer(), type);\n}\nvar _ValueOutputAstTransformer = (function () {\n function _ValueOutputAstTransformer() {\n }\n /**\n * @param {?} arr\n * @param {?} type\n * @return {?}\n */\n _ValueOutputAstTransformer.prototype.visitArray = function (arr, type) {\n var _this = this;\n return o.literalArr(arr.map(function (value) { return visitValue(value, _this, null); }), type);\n };\n /**\n * @param {?} map\n * @param {?} type\n * @return {?}\n */\n _ValueOutputAstTransformer.prototype.visitStringMap = function (map, type) {\n var _this = this;\n var /** @type {?} */ entries = [];\n var /** @type {?} */ quotedSet = new Set(map && map[QUOTED_KEYS]);\n Object.keys(map).forEach(function (key) {\n entries.push(new o.LiteralMapEntry(key, visitValue(map[key], _this, null), quotedSet.has(key)));\n });\n return new o.LiteralMapExpr(entries, type);\n };\n /**\n * @param {?} value\n * @param {?} type\n * @return {?}\n */\n _ValueOutputAstTransformer.prototype.visitPrimitive = function (value, type) { return o.literal(value, type); };\n /**\n * @param {?} value\n * @param {?} type\n * @return {?}\n */\n _ValueOutputAstTransformer.prototype.visitOther = function (value, type) {\n if (value instanceof o.Expression) {\n return value;\n }\n else {\n return o.importExpr({ reference: value });\n }\n };\n return _ValueOutputAstTransformer;\n}());\n//# sourceMappingURL=value_util.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/output/value_util.js\n// module id = ./node_modules/@angular/compiler/src/output/value_util.js\n// module chunks = 0","import * as chars from './chars';\nimport { isPresent } from './facade/lang';\nexport var ParseLocation = (function () {\n /**\n * @param {?} file\n * @param {?} offset\n * @param {?} line\n * @param {?} col\n */\n function ParseLocation(file, offset, line, col) {\n this.file = file;\n this.offset = offset;\n this.line = line;\n this.col = col;\n }\n /**\n * @return {?}\n */\n ParseLocation.prototype.toString = function () {\n return isPresent(this.offset) ? this.file.url + \"@\" + this.line + \":\" + this.col : this.file.url;\n };\n /**\n * @param {?} delta\n * @return {?}\n */\n ParseLocation.prototype.moveBy = function (delta) {\n var /** @type {?} */ source = this.file.content;\n var /** @type {?} */ len = source.length;\n var /** @type {?} */ offset = this.offset;\n var /** @type {?} */ line = this.line;\n var /** @type {?} */ col = this.col;\n while (offset > 0 && delta < 0) {\n offset--;\n delta++;\n var /** @type {?} */ ch = source.charCodeAt(offset);\n if (ch == chars.$LF) {\n line--;\n var /** @type {?} */ priorLine = source.substr(0, offset - 1).lastIndexOf(String.fromCharCode(chars.$LF));\n col = priorLine > 0 ? offset - priorLine : offset;\n }\n else {\n col--;\n }\n }\n while (offset < len && delta > 0) {\n var /** @type {?} */ ch = source.charCodeAt(offset);\n offset++;\n delta--;\n if (ch == chars.$LF) {\n line++;\n col = 0;\n }\n else {\n col++;\n }\n }\n return new ParseLocation(this.file, offset, line, col);\n };\n return ParseLocation;\n}());\nfunction ParseLocation_tsickle_Closure_declarations() {\n /** @type {?} */\n ParseLocation.prototype.file;\n /** @type {?} */\n ParseLocation.prototype.offset;\n /** @type {?} */\n ParseLocation.prototype.line;\n /** @type {?} */\n ParseLocation.prototype.col;\n}\nexport var ParseSourceFile = (function () {\n /**\n * @param {?} content\n * @param {?} url\n */\n function ParseSourceFile(content, url) {\n this.content = content;\n this.url = url;\n }\n return ParseSourceFile;\n}());\nfunction ParseSourceFile_tsickle_Closure_declarations() {\n /** @type {?} */\n ParseSourceFile.prototype.content;\n /** @type {?} */\n ParseSourceFile.prototype.url;\n}\nexport var ParseSourceSpan = (function () {\n /**\n * @param {?} start\n * @param {?} end\n * @param {?=} details\n */\n function ParseSourceSpan(start, end, details) {\n if (details === void 0) { details = null; }\n this.start = start;\n this.end = end;\n this.details = details;\n }\n /**\n * @return {?}\n */\n ParseSourceSpan.prototype.toString = function () {\n return this.start.file.content.substring(this.start.offset, this.end.offset);\n };\n return ParseSourceSpan;\n}());\nfunction ParseSourceSpan_tsickle_Closure_declarations() {\n /** @type {?} */\n ParseSourceSpan.prototype.start;\n /** @type {?} */\n ParseSourceSpan.prototype.end;\n /** @type {?} */\n ParseSourceSpan.prototype.details;\n}\nexport var ParseErrorLevel = {};\nParseErrorLevel.WARNING = 0;\nParseErrorLevel.FATAL = 1;\nParseErrorLevel[ParseErrorLevel.WARNING] = \"WARNING\";\nParseErrorLevel[ParseErrorLevel.FATAL] = \"FATAL\";\nexport var ParseError = (function () {\n /**\n * @param {?} span\n * @param {?} msg\n * @param {?=} level\n */\n function ParseError(span, msg, level) {\n if (level === void 0) { level = ParseErrorLevel.FATAL; }\n this.span = span;\n this.msg = msg;\n this.level = level;\n }\n /**\n * @return {?}\n */\n ParseError.prototype.toString = function () {\n var /** @type {?} */ source = this.span.start.file.content;\n var /** @type {?} */ ctxStart = this.span.start.offset;\n var /** @type {?} */ contextStr = '';\n var /** @type {?} */ details = '';\n if (isPresent(ctxStart)) {\n if (ctxStart > source.length - 1) {\n ctxStart = source.length - 1;\n }\n var /** @type {?} */ ctxEnd = ctxStart;\n var /** @type {?} */ ctxLen = 0;\n var /** @type {?} */ ctxLines = 0;\n while (ctxLen < 100 && ctxStart > 0) {\n ctxStart--;\n ctxLen++;\n if (source[ctxStart] == '\\n') {\n if (++ctxLines == 3) {\n break;\n }\n }\n }\n ctxLen = 0;\n ctxLines = 0;\n while (ctxLen < 100 && ctxEnd < source.length - 1) {\n ctxEnd++;\n ctxLen++;\n if (source[ctxEnd] == '\\n') {\n if (++ctxLines == 3) {\n break;\n }\n }\n }\n var /** @type {?} */ context = source.substring(ctxStart, this.span.start.offset) + '[ERROR ->]' +\n source.substring(this.span.start.offset, ctxEnd + 1);\n contextStr = \" (\\\"\" + context + \"\\\")\";\n }\n if (this.span.details) {\n details = \", \" + this.span.details;\n }\n return \"\" + this.msg + contextStr + \": \" + this.span.start + details;\n };\n return ParseError;\n}());\nfunction ParseError_tsickle_Closure_declarations() {\n /** @type {?} */\n ParseError.prototype.span;\n /** @type {?} */\n ParseError.prototype.msg;\n /** @type {?} */\n ParseError.prototype.level;\n}\n//# sourceMappingURL=parse_util.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/parse_util.js\n// module id = ./node_modules/@angular/compiler/src/parse_util.js\n// module chunks = 0","/**\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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { Pipe, resolveForwardRef } from '@angular/core';\nimport { ListWrapper } from './facade/collection';\nimport { isPresent, stringify } from './facade/lang';\nimport { CompilerInjectable } from './injectable';\nimport { ReflectorReader, reflector } from './private_import_core';\n/**\n * @param {?} type\n * @return {?}\n */\nfunction _isPipeMetadata(type) {\n return type instanceof Pipe;\n}\n/**\n * Resolve a `Type` for {@link Pipe}.\n * *\n * This interface can be overridden by the application developer to create custom behavior.\n * *\n * See {@link Compiler}\n */\nexport var PipeResolver = (function () {\n /**\n * @param {?=} _reflector\n */\n function PipeResolver(_reflector) {\n if (_reflector === void 0) { _reflector = reflector; }\n this._reflector = _reflector;\n }\n /**\n * @param {?} type\n * @return {?}\n */\n PipeResolver.prototype.isPipe = function (type) {\n var /** @type {?} */ typeMetadata = this._reflector.annotations(resolveForwardRef(type));\n return typeMetadata && typeMetadata.some(_isPipeMetadata);\n };\n /**\n * Return {@link Pipe} for a given `Type`.\n * @param {?} type\n * @param {?=} throwIfNotFound\n * @return {?}\n */\n PipeResolver.prototype.resolve = function (type, throwIfNotFound) {\n if (throwIfNotFound === void 0) { throwIfNotFound = true; }\n var /** @type {?} */ metas = this._reflector.annotations(resolveForwardRef(type));\n if (isPresent(metas)) {\n var /** @type {?} */ annotation = ListWrapper.findLast(metas, _isPipeMetadata);\n if (isPresent(annotation)) {\n return annotation;\n }\n }\n if (throwIfNotFound) {\n throw new Error(\"No Pipe decorator found on \" + stringify(type));\n }\n return null;\n };\n PipeResolver = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [ReflectorReader])\n ], PipeResolver);\n return PipeResolver;\n}());\nfunction PipeResolver_tsickle_Closure_declarations() {\n /** @type {?} */\n PipeResolver.prototype._reflector;\n}\n//# sourceMappingURL=pipe_resolver.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/pipe_resolver.js\n// module id = ./node_modules/@angular/compiler/src/pipe_resolver.js\n// module chunks = 0","/**\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 */\nimport { __core_private__ as r } from '@angular/core';\nexport var /** @type {?} */ isDefaultChangeDetectionStrategy = r.isDefaultChangeDetectionStrategy;\nexport var /** @type {?} */ ChangeDetectorStatus = r.ChangeDetectorStatus;\nexport var /** @type {?} */ LifecycleHooks = r.LifecycleHooks;\nexport var /** @type {?} */ LIFECYCLE_HOOKS_VALUES = r.LIFECYCLE_HOOKS_VALUES;\nexport var /** @type {?} */ ReflectorReader = r.ReflectorReader;\nexport var /** @type {?} */ ViewContainer = r.ViewContainer;\nexport var /** @type {?} */ CodegenComponentFactoryResolver = r.CodegenComponentFactoryResolver;\nexport var /** @type {?} */ ComponentRef_ = r.ComponentRef_;\nexport var /** @type {?} */ AppView = r.AppView;\nexport var /** @type {?} */ DebugAppView = r.DebugAppView;\nexport var /** @type {?} */ NgModuleInjector = r.NgModuleInjector;\nexport var /** @type {?} */ registerModuleFactory = r.registerModuleFactory;\nexport var /** @type {?} */ ViewType = r.ViewType;\nexport var /** @type {?} */ view_utils = r.view_utils;\nexport var /** @type {?} */ DebugContext = r.DebugContext;\nexport var /** @type {?} */ StaticNodeDebugInfo = r.StaticNodeDebugInfo;\nexport var /** @type {?} */ devModeEqual = r.devModeEqual;\nexport var /** @type {?} */ UNINITIALIZED = r.UNINITIALIZED;\nexport var /** @type {?} */ ValueUnwrapper = r.ValueUnwrapper;\nexport var /** @type {?} */ TemplateRef_ = r.TemplateRef_;\nexport var /** @type {?} */ RenderDebugInfo = r.RenderDebugInfo;\nexport var /** @type {?} */ Console = r.Console;\nexport var /** @type {?} */ reflector = r.reflector;\nexport var /** @type {?} */ Reflector = r.Reflector;\nexport var /** @type {?} */ ReflectionCapabilities = r.ReflectionCapabilities;\nexport var /** @type {?} */ NoOpAnimationPlayer = r.NoOpAnimationPlayer;\nexport var /** @type {?} */ AnimationPlayer = r.AnimationPlayer;\nexport var /** @type {?} */ AnimationSequencePlayer = r.AnimationSequencePlayer;\nexport var /** @type {?} */ AnimationGroupPlayer = r.AnimationGroupPlayer;\nexport var /** @type {?} */ AnimationKeyframe = r.AnimationKeyframe;\nexport var /** @type {?} */ AnimationStyles = r.AnimationStyles;\nexport var /** @type {?} */ ANY_STATE = r.ANY_STATE;\nexport var /** @type {?} */ DEFAULT_STATE = r.DEFAULT_STATE;\nexport var /** @type {?} */ EMPTY_STATE = r.EMPTY_STATE;\nexport var /** @type {?} */ FILL_STYLE_FLAG = r.FILL_STYLE_FLAG;\nexport var /** @type {?} */ prepareFinalAnimationStyles = r.prepareFinalAnimationStyles;\nexport var /** @type {?} */ balanceAnimationKeyframes = r.balanceAnimationKeyframes;\nexport var /** @type {?} */ clearStyles = r.clearStyles;\nexport var /** @type {?} */ collectAndResolveStyles = r.collectAndResolveStyles;\nexport var /** @type {?} */ renderStyles = r.renderStyles;\nexport var /** @type {?} */ ViewMetadata = r.ViewMetadata;\nexport var /** @type {?} */ ComponentStillLoadingError = r.ComponentStillLoadingError;\nexport var /** @type {?} */ AnimationTransition = r.AnimationTransition;\n//# sourceMappingURL=private_import_core.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/private_import_core.js\n// module id = ./node_modules/@angular/compiler/src/private_import_core.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nimport { tokenName, tokenReference } from './compile_metadata';\nimport { isBlank, isPresent } from './facade/lang';\nimport { Identifiers, resolveIdentifier } from './identifiers';\nimport { ParseError } from './parse_util';\nimport { ProviderAst, ProviderAstType } from './template_parser/template_ast';\nexport var ProviderError = (function (_super) {\n __extends(ProviderError, _super);\n /**\n * @param {?} message\n * @param {?} span\n */\n function ProviderError(message, span) {\n _super.call(this, span, message);\n }\n return ProviderError;\n}(ParseError));\nexport var ProviderViewContext = (function () {\n /**\n * @param {?} component\n * @param {?} sourceSpan\n */\n function ProviderViewContext(component, sourceSpan) {\n var _this = this;\n this.component = component;\n this.sourceSpan = sourceSpan;\n this.errors = [];\n this.viewQueries = _getViewQueries(component);\n this.viewProviders = new Map();\n component.viewProviders.forEach(function (provider) {\n if (isBlank(_this.viewProviders.get(tokenReference(provider.token)))) {\n _this.viewProviders.set(tokenReference(provider.token), true);\n }\n });\n }\n return ProviderViewContext;\n}());\nfunction ProviderViewContext_tsickle_Closure_declarations() {\n /** @type {?} */\n ProviderViewContext.prototype.viewQueries;\n /** @type {?} */\n ProviderViewContext.prototype.viewProviders;\n /** @type {?} */\n ProviderViewContext.prototype.errors;\n /** @type {?} */\n ProviderViewContext.prototype.component;\n /** @type {?} */\n ProviderViewContext.prototype.sourceSpan;\n}\nexport var ProviderElementContext = (function () {\n /**\n * @param {?} viewContext\n * @param {?} _parent\n * @param {?} _isViewRoot\n * @param {?} _directiveAsts\n * @param {?} attrs\n * @param {?} refs\n * @param {?} _sourceSpan\n */\n function ProviderElementContext(viewContext, _parent, _isViewRoot, _directiveAsts, attrs, refs, _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._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(directivesMeta);\n var queriedTokens = new Map();\n Array.from(this._allProviders.values()).forEach(function (provider) {\n _this._addQueryReadsTo(provider.token, queriedTokens);\n });\n refs.forEach(function (refAst) { _this._addQueryReadsTo({ value: refAst.name }, queriedTokens); });\n if (isPresent(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 || isPresent(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 /**\n * @param {?} token\n * @param {?} queryReadTokens\n * @return {?}\n */\n ProviderElementContext.prototype._addQueryReadsTo = function (token, queryReadTokens) {\n this._getQueriesFor(token).forEach(function (query) {\n var /** @type {?} */ queryReadToken = query.read || token;\n if (isBlank(queryReadTokens.get(tokenReference(queryReadToken)))) {\n queryReadTokens.set(tokenReference(queryReadToken), true);\n }\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 (isPresent(queries)) {\n result.push.apply(result, queries.filter(function (query) { return query.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 (isPresent(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 (isPresent(transformedProviderAst)) {\n return transformedProviderAst;\n }\n if (isPresent(this._seenProviders.get(tokenReference(token)))) {\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 (isPresent(provider.useExisting)) {\n var /** @type {?} */ existingDiDep = _this._getDependency(resolvedProvider.providerType, { token: provider.useExisting }, eager);\n if (isPresent(existingDiDep.token)) {\n transformedUseExisting = existingDiDep.token;\n }\n else {\n transformedUseExisting = null;\n transformedUseValue = existingDiDep.value;\n }\n }\n else if (isPresent(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 (isPresent(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 (isPresent(dep.token)) {\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 (isPresent(this._getOrCreateLocalProvider(requestingProviderType, dep.token, eager))) {\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 && isPresent(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 isPresent(this.viewContext.viewProviders.get(tokenReference(dep.token)))) {\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}());\nfunction ProviderElementContext_tsickle_Closure_declarations() {\n /** @type {?} */\n ProviderElementContext.prototype._contentQueries;\n /** @type {?} */\n ProviderElementContext.prototype._transformedProviders;\n /** @type {?} */\n ProviderElementContext.prototype._seenProviders;\n /** @type {?} */\n ProviderElementContext.prototype._allProviders;\n /** @type {?} */\n ProviderElementContext.prototype._attrs;\n /** @type {?} */\n ProviderElementContext.prototype._hasViewContainer;\n /** @type {?} */\n ProviderElementContext.prototype.viewContext;\n /** @type {?} */\n ProviderElementContext.prototype._parent;\n /** @type {?} */\n ProviderElementContext.prototype._isViewRoot;\n /** @type {?} */\n ProviderElementContext.prototype._directiveAsts;\n /** @type {?} */\n ProviderElementContext.prototype._sourceSpan;\n}\nexport var 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 (isPresent(transformedProviderAst)) {\n return transformedProviderAst;\n }\n if (isPresent(this._seenProviders.get(tokenReference(token)))) {\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 (isPresent(provider.useExisting)) {\n var /** @type {?} */ existingDiDep = _this._getDependency({ token: provider.useExisting }, eager, resolvedProvider.sourceSpan);\n if (isPresent(existingDiDep.token)) {\n transformedUseExisting = existingDiDep.token;\n }\n else {\n transformedUseExisting = null;\n transformedUseValue = existingDiDep.value;\n }\n }\n else if (isPresent(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 (isPresent(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 && isPresent(dep.token)) {\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 (isPresent(this._getOrCreateLocalProvider(dep.token, eager))) {\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}());\nfunction NgModuleProviderAnalyzer_tsickle_Closure_declarations() {\n /** @type {?} */\n NgModuleProviderAnalyzer.prototype._transformedProviders;\n /** @type {?} */\n NgModuleProviderAnalyzer.prototype._seenProviders;\n /** @type {?} */\n NgModuleProviderAnalyzer.prototype._allProviders;\n /** @type {?} */\n NgModuleProviderAnalyzer.prototype._errors;\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 (isPresent(resolvedProvider) && !!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 resolvedProvider = new ProviderAst(provider.token, provider.multi, eager || lifecycleHooks.length > 0, [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 var /** @type {?} */ viewQueries = new Map();\n if (isPresent(component.viewQueries)) {\n component.viewQueries.forEach(function (query) { return _addQueryToTokenMap(viewQueries, query); });\n }\n return viewQueries;\n}\n/**\n * @param {?} directives\n * @return {?}\n */\nfunction _getContentQueries(directives) {\n var /** @type {?} */ contentQueries = new Map();\n directives.forEach(function (directive) {\n if (isPresent(directive.queries)) {\n directive.queries.forEach(function (query) { return _addQueryToTokenMap(contentQueries, query); });\n }\n });\n return contentQueries;\n}\n/**\n * @param {?} map\n * @param {?} query\n * @return {?}\n */\nfunction _addQueryToTokenMap(map, query) {\n query.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//# sourceMappingURL=provider_analyzer.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/provider_analyzer.js\n// module id = ./node_modules/@angular/compiler/src/provider_analyzer.js\n// module chunks = 0","/**\n * An interface for retrieving documents by URL that the compiler uses\n * to load templates.\n */\nexport var ResourceLoader = (function () {\n function ResourceLoader() {\n }\n /**\n * @param {?} url\n * @return {?}\n */\n ResourceLoader.prototype.get = function (url) { return null; };\n return ResourceLoader;\n}());\n//# sourceMappingURL=resource_loader.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/resource_loader.js\n// module id = ./node_modules/@angular/compiler/src/resource_loader.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA, SecurityContext } from '@angular/core';\nimport { CompilerInjectable } from '../injectable';\nimport { dashCaseToCamelCase } from '../util';\nimport { SECURITY_SCHEMA } from './dom_security_schema';\nimport { ElementSchemaRegistry } from './element_schema_registry';\nvar /** @type {?} */ BOOLEAN = 'boolean';\nvar /** @type {?} */ NUMBER = 'number';\nvar /** @type {?} */ STRING = 'string';\nvar /** @type {?} */ OBJECT = 'object';\n/**\n * This array represents the DOM schema. It encodes inheritance, properties, and events.\n *\n * ## Overview\n *\n * Each line represents one kind of element. The `element_inheritance` and properties are joined\n * using `element_inheritance|properties` syntax.\n *\n * ## Element Inheritance\n *\n * The `element_inheritance` can be further subdivided as `element1,element2,...^parentElement`.\n * Here the individual elements are separated by `,` (commas). Every element in the list\n * has identical properties.\n *\n * An `element` may inherit additional properties from `parentElement` If no `^parentElement` is\n * specified then `\"\"` (blank) element is assumed.\n *\n * NOTE: The blank element inherits from root `[Element]` element, the super element of all\n * elements.\n *\n * NOTE an element prefix such as `:svg:` has no special meaning to the schema.\n *\n * ## Properties\n *\n * Each element has a set of properties separated by `,` (commas). Each property can be prefixed\n * by a special character designating its type:\n *\n * - (no prefix): property is a string.\n * - `*`: property represents an event.\n * - `!`: property is a boolean.\n * - `#`: property is a number.\n * - `%`: property is an object.\n *\n * ## Query\n *\n * The class creates an internal squas representation which allows to easily answer the query of\n * if a given property exist on a given element.\n *\n * NOTE: We don't yet support querying for types or events.\n * NOTE: This schema is auto extracted from `schema_extractor.ts` located in the test folder,\n * see dom_element_schema_registry_spec.ts\n */\n// =================================================================================================\n// =================================================================================================\n// =========== S T O P - S T O P - S T O P - S T O P - S T O P - S T O P ===========\n// =================================================================================================\n// =================================================================================================\n//\n// DO NOT EDIT THIS DOM SCHEMA WITHOUT A SECURITY REVIEW!\n//\n// Newly added properties must be security reviewed and assigned an appropriate SecurityContext in\n// dom_security_schema.ts. Reach out to mprobst & rjamet for details.\n//\n// =================================================================================================\nvar /** @type {?} */ SCHEMA = [\n '[Element]|textContent,%classList,className,id,innerHTML,*beforecopy,*beforecut,*beforepaste,*copy,*cut,*paste,*search,*selectstart,*webkitfullscreenchange,*webkitfullscreenerror,*wheel,outerHTML,#scrollLeft,#scrollTop',\n '[HTMLElement]^[Element]|accessKey,contentEditable,dir,!draggable,!hidden,innerText,lang,*abort,*beforecopy,*beforecut,*beforepaste,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*copy,*cuechange,*cut,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*message,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*mozfullscreenchange,*mozfullscreenerror,*mozpointerlockchange,*mozpointerlockerror,*paste,*pause,*play,*playing,*progress,*ratechange,*reset,*resize,*scroll,*search,*seeked,*seeking,*select,*selectstart,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,*webglcontextcreationerror,*webglcontextlost,*webglcontextrestored,*webkitfullscreenchange,*webkitfullscreenerror,*wheel,outerText,!spellcheck,%style,#tabIndex,title,!translate',\n 'abbr,address,article,aside,b,bdi,bdo,cite,code,dd,dfn,dt,em,figcaption,figure,footer,header,i,kbd,main,mark,nav,noscript,rb,rp,rt,rtc,ruby,s,samp,section,small,strong,sub,sup,u,var,wbr^[HTMLElement]|accessKey,contentEditable,dir,!draggable,!hidden,innerText,lang,*abort,*beforecopy,*beforecut,*beforepaste,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*copy,*cuechange,*cut,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*message,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*mozfullscreenchange,*mozfullscreenerror,*mozpointerlockchange,*mozpointerlockerror,*paste,*pause,*play,*playing,*progress,*ratechange,*reset,*resize,*scroll,*search,*seeked,*seeking,*select,*selectstart,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,*webglcontextcreationerror,*webglcontextlost,*webglcontextrestored,*webkitfullscreenchange,*webkitfullscreenerror,*wheel,outerText,!spellcheck,%style,#tabIndex,title,!translate',\n 'media^[HTMLElement]|!autoplay,!controls,%crossOrigin,#currentTime,!defaultMuted,#defaultPlaybackRate,!disableRemotePlayback,!loop,!muted,*encrypted,#playbackRate,preload,src,%srcObject,#volume',\n ':svg:^[HTMLElement]|*abort,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,%style,#tabIndex',\n ':svg:graphics^:svg:|',\n ':svg:animation^:svg:|*begin,*end,*repeat',\n ':svg:geometry^:svg:|',\n ':svg:componentTransferFunction^:svg:|',\n ':svg:gradient^:svg:|',\n ':svg:textContent^:svg:graphics|',\n ':svg:textPositioning^:svg:textContent|',\n 'a^[HTMLElement]|charset,coords,download,hash,host,hostname,href,hreflang,name,password,pathname,ping,port,protocol,referrerPolicy,rel,rev,search,shape,target,text,type,username',\n 'area^[HTMLElement]|alt,coords,hash,host,hostname,href,!noHref,password,pathname,ping,port,protocol,referrerPolicy,search,shape,target,username',\n 'audio^media|',\n 'br^[HTMLElement]|clear',\n 'base^[HTMLElement]|href,target',\n 'body^[HTMLElement]|aLink,background,bgColor,link,*beforeunload,*blur,*error,*focus,*hashchange,*languagechange,*load,*message,*offline,*online,*pagehide,*pageshow,*popstate,*rejectionhandled,*resize,*scroll,*storage,*unhandledrejection,*unload,text,vLink',\n 'button^[HTMLElement]|!autofocus,!disabled,formAction,formEnctype,formMethod,!formNoValidate,formTarget,name,type,value',\n 'canvas^[HTMLElement]|#height,#width',\n 'content^[HTMLElement]|select',\n 'dl^[HTMLElement]|!compact',\n 'datalist^[HTMLElement]|',\n 'details^[HTMLElement]|!open',\n 'dialog^[HTMLElement]|!open,returnValue',\n 'dir^[HTMLElement]|!compact',\n 'div^[HTMLElement]|align',\n 'embed^[HTMLElement]|align,height,name,src,type,width',\n 'fieldset^[HTMLElement]|!disabled,name',\n 'font^[HTMLElement]|color,face,size',\n 'form^[HTMLElement]|acceptCharset,action,autocomplete,encoding,enctype,method,name,!noValidate,target',\n 'frame^[HTMLElement]|frameBorder,longDesc,marginHeight,marginWidth,name,!noResize,scrolling,src',\n 'frameset^[HTMLElement]|cols,*beforeunload,*blur,*error,*focus,*hashchange,*languagechange,*load,*message,*offline,*online,*pagehide,*pageshow,*popstate,*rejectionhandled,*resize,*scroll,*storage,*unhandledrejection,*unload,rows',\n 'hr^[HTMLElement]|align,color,!noShade,size,width',\n 'head^[HTMLElement]|',\n 'h1,h2,h3,h4,h5,h6^[HTMLElement]|align',\n 'html^[HTMLElement]|version',\n 'iframe^[HTMLElement]|align,!allowFullscreen,frameBorder,height,longDesc,marginHeight,marginWidth,name,referrerPolicy,%sandbox,scrolling,src,srcdoc,width',\n 'img^[HTMLElement]|align,alt,border,%crossOrigin,#height,#hspace,!isMap,longDesc,lowsrc,name,referrerPolicy,sizes,src,srcset,useMap,#vspace,#width',\n 'input^[HTMLElement]|accept,align,alt,autocapitalize,autocomplete,!autofocus,!checked,!defaultChecked,defaultValue,dirName,!disabled,%files,formAction,formEnctype,formMethod,!formNoValidate,formTarget,#height,!incremental,!indeterminate,max,#maxLength,min,#minLength,!multiple,name,pattern,placeholder,!readOnly,!required,selectionDirection,#selectionEnd,#selectionStart,#size,src,step,type,useMap,value,%valueAsDate,#valueAsNumber,#width',\n 'keygen^[HTMLElement]|!autofocus,challenge,!disabled,keytype,name',\n 'li^[HTMLElement]|type,#value',\n 'label^[HTMLElement]|htmlFor',\n 'legend^[HTMLElement]|align',\n 'link^[HTMLElement]|as,charset,%crossOrigin,!disabled,href,hreflang,integrity,media,rel,%relList,rev,%sizes,target,type',\n 'map^[HTMLElement]|name',\n 'marquee^[HTMLElement]|behavior,bgColor,direction,height,#hspace,#loop,#scrollAmount,#scrollDelay,!trueSpeed,#vspace,width',\n 'menu^[HTMLElement]|!compact',\n 'meta^[HTMLElement]|content,httpEquiv,name,scheme',\n 'meter^[HTMLElement]|#high,#low,#max,#min,#optimum,#value',\n 'ins,del^[HTMLElement]|cite,dateTime',\n 'ol^[HTMLElement]|!compact,!reversed,#start,type',\n 'object^[HTMLElement]|align,archive,border,code,codeBase,codeType,data,!declare,height,#hspace,name,standby,type,useMap,#vspace,width',\n 'optgroup^[HTMLElement]|!disabled,label',\n 'option^[HTMLElement]|!defaultSelected,!disabled,label,!selected,text,value',\n 'output^[HTMLElement]|defaultValue,%htmlFor,name,value',\n 'p^[HTMLElement]|align',\n 'param^[HTMLElement]|name,type,value,valueType',\n 'picture^[HTMLElement]|',\n 'pre^[HTMLElement]|#width',\n 'progress^[HTMLElement]|#max,#value',\n 'q,blockquote,cite^[HTMLElement]|',\n 'script^[HTMLElement]|!async,charset,%crossOrigin,!defer,event,htmlFor,integrity,src,text,type',\n 'select^[HTMLElement]|!autofocus,!disabled,#length,!multiple,name,!required,#selectedIndex,#size,value',\n 'shadow^[HTMLElement]|',\n 'source^[HTMLElement]|media,sizes,src,srcset,type',\n 'span^[HTMLElement]|',\n 'style^[HTMLElement]|!disabled,media,type',\n 'caption^[HTMLElement]|align',\n 'th,td^[HTMLElement]|abbr,align,axis,bgColor,ch,chOff,#colSpan,headers,height,!noWrap,#rowSpan,scope,vAlign,width',\n 'col,colgroup^[HTMLElement]|align,ch,chOff,#span,vAlign,width',\n 'table^[HTMLElement]|align,bgColor,border,%caption,cellPadding,cellSpacing,frame,rules,summary,%tFoot,%tHead,width',\n 'tr^[HTMLElement]|align,bgColor,ch,chOff,vAlign',\n 'tfoot,thead,tbody^[HTMLElement]|align,ch,chOff,vAlign',\n 'template^[HTMLElement]|',\n 'textarea^[HTMLElement]|autocapitalize,!autofocus,#cols,defaultValue,dirName,!disabled,#maxLength,#minLength,name,placeholder,!readOnly,!required,#rows,selectionDirection,#selectionEnd,#selectionStart,value,wrap',\n 'title^[HTMLElement]|text',\n 'track^[HTMLElement]|!default,kind,label,src,srclang',\n 'ul^[HTMLElement]|!compact,type',\n 'unknown^[HTMLElement]|',\n 'video^media|#height,poster,#width',\n ':svg:a^:svg:graphics|',\n ':svg:animate^:svg:animation|',\n ':svg:animateMotion^:svg:animation|',\n ':svg:animateTransform^:svg:animation|',\n ':svg:circle^:svg:geometry|',\n ':svg:clipPath^:svg:graphics|',\n ':svg:cursor^:svg:|',\n ':svg:defs^:svg:graphics|',\n ':svg:desc^:svg:|',\n ':svg:discard^:svg:|',\n ':svg:ellipse^:svg:geometry|',\n ':svg:feBlend^:svg:|',\n ':svg:feColorMatrix^:svg:|',\n ':svg:feComponentTransfer^:svg:|',\n ':svg:feComposite^:svg:|',\n ':svg:feConvolveMatrix^:svg:|',\n ':svg:feDiffuseLighting^:svg:|',\n ':svg:feDisplacementMap^:svg:|',\n ':svg:feDistantLight^:svg:|',\n ':svg:feDropShadow^:svg:|',\n ':svg:feFlood^:svg:|',\n ':svg:feFuncA^:svg:componentTransferFunction|',\n ':svg:feFuncB^:svg:componentTransferFunction|',\n ':svg:feFuncG^:svg:componentTransferFunction|',\n ':svg:feFuncR^:svg:componentTransferFunction|',\n ':svg:feGaussianBlur^:svg:|',\n ':svg:feImage^:svg:|',\n ':svg:feMerge^:svg:|',\n ':svg:feMergeNode^:svg:|',\n ':svg:feMorphology^:svg:|',\n ':svg:feOffset^:svg:|',\n ':svg:fePointLight^:svg:|',\n ':svg:feSpecularLighting^:svg:|',\n ':svg:feSpotLight^:svg:|',\n ':svg:feTile^:svg:|',\n ':svg:feTurbulence^:svg:|',\n ':svg:filter^:svg:|',\n ':svg:foreignObject^:svg:graphics|',\n ':svg:g^:svg:graphics|',\n ':svg:image^:svg:graphics|',\n ':svg:line^:svg:geometry|',\n ':svg:linearGradient^:svg:gradient|',\n ':svg:mpath^:svg:|',\n ':svg:marker^:svg:|',\n ':svg:mask^:svg:|',\n ':svg:metadata^:svg:|',\n ':svg:path^:svg:geometry|',\n ':svg:pattern^:svg:|',\n ':svg:polygon^:svg:geometry|',\n ':svg:polyline^:svg:geometry|',\n ':svg:radialGradient^:svg:gradient|',\n ':svg:rect^:svg:geometry|',\n ':svg:svg^:svg:graphics|#currentScale,#zoomAndPan',\n ':svg:script^:svg:|type',\n ':svg:set^:svg:animation|',\n ':svg:stop^:svg:|',\n ':svg:style^:svg:|!disabled,media,title,type',\n ':svg:switch^:svg:graphics|',\n ':svg:symbol^:svg:|',\n ':svg:tspan^:svg:textPositioning|',\n ':svg:text^:svg:textPositioning|',\n ':svg:textPath^:svg:textContent|',\n ':svg:title^:svg:|',\n ':svg:use^:svg:graphics|',\n ':svg:view^:svg:|#zoomAndPan',\n 'data^[HTMLElement]|value',\n 'menuitem^[HTMLElement]|type,label,icon,!disabled,!checked,radiogroup,!default',\n 'summary^[HTMLElement]|',\n 'time^[HTMLElement]|dateTime',\n];\nvar /** @type {?} */ _ATTR_TO_PROP = {\n 'class': 'className',\n 'for': 'htmlFor',\n 'formaction': 'formAction',\n 'innerHtml': 'innerHTML',\n 'readonly': 'readOnly',\n 'tabindex': 'tabIndex',\n};\nexport var DomElementSchemaRegistry = (function (_super) {\n __extends(DomElementSchemaRegistry, _super);\n function DomElementSchemaRegistry() {\n var _this = this;\n _super.call(this);\n this._schema = {};\n SCHEMA.forEach(function (encodedType) {\n var type = {};\n var _a = encodedType.split('|'), strType = _a[0], strProperties = _a[1];\n var properties = strProperties.split(',');\n var _b = strType.split('^'), typeNames = _b[0], superName = _b[1];\n typeNames.split(',').forEach(function (tag) { return _this._schema[tag.toLowerCase()] = type; });\n var superType = superName && _this._schema[superName.toLowerCase()];\n if (superType) {\n Object.keys(superType).forEach(function (prop) { type[prop] = superType[prop]; });\n }\n properties.forEach(function (property) {\n if (property.length > 0) {\n switch (property[0]) {\n case '*':\n // We don't yet support events.\n // If ever allowing to bind to events, GO THROUGH A SECURITY REVIEW, allowing events\n // will\n // almost certainly introduce bad XSS vulnerabilities.\n // type[property.substring(1)] = EVENT;\n break;\n case '!':\n type[property.substring(1)] = BOOLEAN;\n break;\n case '#':\n type[property.substring(1)] = NUMBER;\n break;\n case '%':\n type[property.substring(1)] = OBJECT;\n break;\n default:\n type[property] = STRING;\n }\n }\n });\n });\n }\n /**\n * @param {?} tagName\n * @param {?} propName\n * @param {?} schemaMetas\n * @return {?}\n */\n DomElementSchemaRegistry.prototype.hasProperty = function (tagName, propName, schemaMetas) {\n if (schemaMetas.some(function (schema) { return schema.name === NO_ERRORS_SCHEMA.name; })) {\n return true;\n }\n if (tagName.indexOf('-') > -1) {\n if (tagName === 'ng-container' || tagName === 'ng-content') {\n return false;\n }\n if (schemaMetas.some(function (schema) { return schema.name === CUSTOM_ELEMENTS_SCHEMA.name; })) {\n // Can't tell now as we don't know which properties a custom element will get\n // once it is instantiated\n return true;\n }\n }\n var /** @type {?} */ elementProperties = this._schema[tagName.toLowerCase()] || this._schema['unknown'];\n return !!elementProperties[propName];\n };\n /**\n * @param {?} tagName\n * @param {?} schemaMetas\n * @return {?}\n */\n DomElementSchemaRegistry.prototype.hasElement = function (tagName, schemaMetas) {\n if (schemaMetas.some(function (schema) { return schema.name === NO_ERRORS_SCHEMA.name; })) {\n return true;\n }\n if (tagName.indexOf('-') > -1) {\n if (tagName === 'ng-container' || tagName === 'ng-content') {\n return true;\n }\n if (schemaMetas.some(function (schema) { return schema.name === CUSTOM_ELEMENTS_SCHEMA.name; })) {\n // Allow any custom elements\n return true;\n }\n }\n return !!this._schema[tagName.toLowerCase()];\n };\n /**\n * securityContext returns the security context for the given property on the given DOM tag.\n * *\n * Tag and property name are statically known and cannot change at runtime, i.e. it is not\n * possible to bind a value into a changing attribute or tag name.\n * *\n * The filtering is white list based. All attributes in the schema above are assumed to have the\n * 'NONE' security context, i.e. that they are safe inert string values. Only specific well known\n * attack vectors are assigned their appropriate context.\n * @param {?} tagName\n * @param {?} propName\n * @param {?} isAttribute\n * @return {?}\n */\n DomElementSchemaRegistry.prototype.securityContext = function (tagName, propName, isAttribute) {\n if (isAttribute) {\n // NB: For security purposes, use the mapped property name, not the attribute name.\n propName = this.getMappedPropName(propName);\n }\n // Make sure comparisons are case insensitive, so that case differences between attribute and\n // property names do not have a security impact.\n tagName = tagName.toLowerCase();\n propName = propName.toLowerCase();\n var /** @type {?} */ ctx = SECURITY_SCHEMA[tagName + '|' + propName];\n if (ctx) {\n return ctx;\n }\n ctx = SECURITY_SCHEMA['*|' + propName];\n return ctx ? ctx : SecurityContext.NONE;\n };\n /**\n * @param {?} propName\n * @return {?}\n */\n DomElementSchemaRegistry.prototype.getMappedPropName = function (propName) { return _ATTR_TO_PROP[propName] || propName; };\n /**\n * @return {?}\n */\n DomElementSchemaRegistry.prototype.getDefaultComponentElementName = function () { return 'ng-component'; };\n /**\n * @param {?} name\n * @return {?}\n */\n DomElementSchemaRegistry.prototype.validateProperty = function (name) {\n if (name.toLowerCase().startsWith('on')) {\n var /** @type {?} */ msg = (\"Binding to event property '\" + name + \"' is disallowed for security reasons, \") +\n (\"please use (\" + name.slice(2) + \")=...\") +\n (\"\\nIf '\" + name + \"' is a directive input, make sure the directive is imported by the\") +\n \" current module.\";\n return { error: true, msg: msg };\n }\n else {\n return { error: false };\n }\n };\n /**\n * @param {?} name\n * @return {?}\n */\n DomElementSchemaRegistry.prototype.validateAttribute = function (name) {\n if (name.toLowerCase().startsWith('on')) {\n var /** @type {?} */ msg = (\"Binding to event attribute '\" + name + \"' is disallowed for security reasons, \") +\n (\"please use (\" + name.slice(2) + \")=...\");\n return { error: true, msg: msg };\n }\n else {\n return { error: false };\n }\n };\n /**\n * @return {?}\n */\n DomElementSchemaRegistry.prototype.allKnownElementNames = function () { return Object.keys(this._schema); };\n /**\n * @param {?} propName\n * @return {?}\n */\n DomElementSchemaRegistry.prototype.normalizeAnimationStyleProperty = function (propName) {\n return dashCaseToCamelCase(propName);\n };\n /**\n * @param {?} camelCaseProp\n * @param {?} userProvidedProp\n * @param {?} val\n * @return {?}\n */\n DomElementSchemaRegistry.prototype.normalizeAnimationStyleValue = function (camelCaseProp, userProvidedProp, val) {\n var /** @type {?} */ unit = '';\n var /** @type {?} */ strVal = val.toString().trim();\n var /** @type {?} */ errorMsg = null;\n if (_isPixelDimensionStyle(camelCaseProp) && val !== 0 && val !== '0') {\n if (typeof val === 'number') {\n unit = 'px';\n }\n else {\n var /** @type {?} */ valAndSuffixMatch = val.match(/^[+-]?[\\d\\.]+([a-z]*)$/);\n if (valAndSuffixMatch && valAndSuffixMatch[1].length == 0) {\n errorMsg = \"Please provide a CSS unit value for \" + userProvidedProp + \":\" + val;\n }\n }\n }\n return { error: errorMsg, value: strVal + unit };\n };\n DomElementSchemaRegistry = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [])\n ], DomElementSchemaRegistry);\n return DomElementSchemaRegistry;\n}(ElementSchemaRegistry));\nfunction DomElementSchemaRegistry_tsickle_Closure_declarations() {\n /** @type {?} */\n DomElementSchemaRegistry.prototype._schema;\n}\n/**\n * @param {?} prop\n * @return {?}\n */\nfunction _isPixelDimensionStyle(prop) {\n switch (prop) {\n case 'width':\n case 'height':\n case 'minWidth':\n case 'minHeight':\n case 'maxWidth':\n case 'maxHeight':\n case 'left':\n case 'top':\n case 'bottom':\n case 'right':\n case 'fontSize':\n case 'outlineWidth':\n case 'outlineOffset':\n case 'paddingTop':\n case 'paddingLeft':\n case 'paddingBottom':\n case 'paddingRight':\n case 'marginTop':\n case 'marginLeft':\n case 'marginBottom':\n case 'marginRight':\n case 'borderRadius':\n case 'borderWidth':\n case 'borderTopWidth':\n case 'borderLeftWidth':\n case 'borderRightWidth':\n case 'borderBottomWidth':\n case 'textIndent':\n return true;\n default:\n return false;\n }\n}\n//# sourceMappingURL=dom_element_schema_registry.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/schema/dom_element_schema_registry.js\n// module id = ./node_modules/@angular/compiler/src/schema/dom_element_schema_registry.js\n// module chunks = 0","/**\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 */\nimport { SecurityContext } from '@angular/core';\n// =================================================================================================\n// =================================================================================================\n// =========== S T O P - S T O P - S T O P - S T O P - S T O P - S T O P ===========\n// =================================================================================================\n// =================================================================================================\n//\n// DO NOT EDIT THIS LIST OF SECURITY SENSITIVE PROPERTIES WITHOUT A SECURITY REVIEW!\n// Reach out to mprobst for details.\n//\n// =================================================================================================\n/** Map from tagName|propertyName SecurityContext. Properties applying to all tags use '*'. */\nexport var /** @type {?} */ SECURITY_SCHEMA = {};\n/**\n * @param {?} ctx\n * @param {?} specs\n * @return {?}\n */\nfunction registerContext(ctx, specs) {\n for (var _i = 0, specs_1 = specs; _i < specs_1.length; _i++) {\n var spec = specs_1[_i];\n SECURITY_SCHEMA[spec.toLowerCase()] = ctx;\n }\n}\n// Case is insignificant below, all element and attribute names are lower-cased for lookup.\nregisterContext(SecurityContext.HTML, [\n 'iframe|srcdoc',\n '*|innerHTML',\n '*|outerHTML',\n]);\nregisterContext(SecurityContext.STYLE, ['*|style']);\n// NB: no SCRIPT contexts here, they are never allowed due to the parser stripping them.\nregisterContext(SecurityContext.URL, [\n '*|formAction', 'area|href', 'area|ping', 'audio|src', 'a|href',\n 'a|ping', 'blockquote|cite', 'body|background', 'del|cite', 'form|action',\n 'img|src', 'img|srcset', 'input|src', 'ins|cite', 'q|cite',\n 'source|src', 'source|srcset', 'track|src', 'video|poster', 'video|src',\n]);\nregisterContext(SecurityContext.RESOURCE_URL, [\n 'applet|code',\n 'applet|codebase',\n 'base|href',\n 'embed|src',\n 'frame|src',\n 'head|profile',\n 'html|manifest',\n 'iframe|src',\n 'link|href',\n 'media|src',\n 'object|codebase',\n 'object|data',\n 'script|src',\n]);\n//# sourceMappingURL=dom_security_schema.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/schema/dom_security_schema.js\n// module id = ./node_modules/@angular/compiler/src/schema/dom_security_schema.js\n// module chunks = 0","/**\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 */\nexport var 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//# sourceMappingURL=element_schema_registry.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/schema/element_schema_registry.js\n// module id = ./node_modules/@angular/compiler/src/schema/element_schema_registry.js\n// module chunks = 0","/**\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 */\nimport { getHtmlTagDefinition } from './ml_parser/html_tags';\nvar /** @type {?} */ _SELECTOR_REGEXP = new RegExp('(\\\\:not\\\\()|' +\n '([-\\\\w]+)|' +\n '(?:\\\\.([-\\\\w]+))|' +\n '(?:\\\\[([-\\\\w*]+)(?:=([^\\\\]]*))?\\\\])|' +\n '(\\\\))|' +\n '(\\\\s*,\\\\s*)', // \",\"\n'g');\n/**\n * A css selector contains an element name,\n * css classes and attribute/value pairs with the purpose\n * of selecting subsets out of them.\n */\nexport var CssSelector = (function () {\n function CssSelector() {\n this.element = null;\n this.classNames = [];\n this.attrs = [];\n this.notSelectors = [];\n }\n /**\n * @param {?} selector\n * @return {?}\n */\n CssSelector.parse = function (selector) {\n var /** @type {?} */ results = [];\n var /** @type {?} */ _addResult = function (res, cssSel) {\n if (cssSel.notSelectors.length > 0 && !cssSel.element && cssSel.classNames.length == 0 &&\n cssSel.attrs.length == 0) {\n cssSel.element = '*';\n }\n res.push(cssSel);\n };\n var /** @type {?} */ cssSelector = new CssSelector();\n var /** @type {?} */ match;\n var /** @type {?} */ current = cssSelector;\n var /** @type {?} */ inNot = false;\n _SELECTOR_REGEXP.lastIndex = 0;\n while (match = _SELECTOR_REGEXP.exec(selector)) {\n if (match[1]) {\n if (inNot) {\n throw new Error('Nesting :not is not allowed in a selector');\n }\n inNot = true;\n current = new CssSelector();\n cssSelector.notSelectors.push(current);\n }\n if (match[2]) {\n current.setElement(match[2]);\n }\n if (match[3]) {\n current.addClassName(match[3]);\n }\n if (match[4]) {\n current.addAttribute(match[4], match[5]);\n }\n if (match[6]) {\n inNot = false;\n current = cssSelector;\n }\n if (match[7]) {\n if (inNot) {\n throw new Error('Multiple selectors in :not are not supported');\n }\n _addResult(results, cssSelector);\n cssSelector = current = new CssSelector();\n }\n }\n _addResult(results, cssSelector);\n return results;\n };\n /**\n * @return {?}\n */\n CssSelector.prototype.isElementSelector = function () {\n return this.hasElementSelector() && this.classNames.length == 0 && this.attrs.length == 0 &&\n this.notSelectors.length === 0;\n };\n /**\n * @return {?}\n */\n CssSelector.prototype.hasElementSelector = function () { return !!this.element; };\n /**\n * @param {?=} element\n * @return {?}\n */\n CssSelector.prototype.setElement = function (element) {\n if (element === void 0) { element = null; }\n this.element = element;\n };\n /**\n * Gets a template string for an element that matches the selector.\n * @return {?}\n */\n CssSelector.prototype.getMatchingElementTemplate = function () {\n var /** @type {?} */ tagName = this.element || 'div';\n var /** @type {?} */ classAttr = this.classNames.length > 0 ? \" class=\\\"\" + this.classNames.join(' ') + \"\\\"\" : '';\n var /** @type {?} */ attrs = '';\n for (var /** @type {?} */ i = 0; i < this.attrs.length; i += 2) {\n var /** @type {?} */ attrName = this.attrs[i];\n var /** @type {?} */ attrValue = this.attrs[i + 1] !== '' ? \"=\\\"\" + this.attrs[i + 1] + \"\\\"\" : '';\n attrs += \" \" + attrName + attrValue;\n }\n return getHtmlTagDefinition(tagName).isVoid ? \"<\" + tagName + classAttr + attrs + \"/>\" :\n \"<\" + tagName + classAttr + attrs + \">\";\n };\n /**\n * @param {?} name\n * @param {?=} value\n * @return {?}\n */\n CssSelector.prototype.addAttribute = function (name, value) {\n if (value === void 0) { value = ''; }\n this.attrs.push(name, value && value.toLowerCase() || '');\n };\n /**\n * @param {?} name\n * @return {?}\n */\n CssSelector.prototype.addClassName = function (name) { this.classNames.push(name.toLowerCase()); };\n /**\n * @return {?}\n */\n CssSelector.prototype.toString = function () {\n var /** @type {?} */ res = this.element || '';\n if (this.classNames) {\n this.classNames.forEach(function (klass) { return res += \".\" + klass; });\n }\n if (this.attrs) {\n for (var /** @type {?} */ i = 0; i < this.attrs.length; i += 2) {\n var /** @type {?} */ name_1 = this.attrs[i];\n var /** @type {?} */ value = this.attrs[i + 1];\n res += \"[\" + name_1 + (value ? '=' + value : '') + \"]\";\n }\n }\n this.notSelectors.forEach(function (notSelector) { return res += \":not(\" + notSelector + \")\"; });\n return res;\n };\n return CssSelector;\n}());\nfunction CssSelector_tsickle_Closure_declarations() {\n /** @type {?} */\n CssSelector.prototype.element;\n /** @type {?} */\n CssSelector.prototype.classNames;\n /** @type {?} */\n CssSelector.prototype.attrs;\n /** @type {?} */\n CssSelector.prototype.notSelectors;\n}\n/**\n * Reads a list of CssSelectors and allows to calculate which ones\n * are contained in a given CssSelector.\n */\nexport var SelectorMatcher = (function () {\n function SelectorMatcher() {\n this._elementMap = new Map();\n this._elementPartialMap = new Map();\n this._classMap = new Map();\n this._classPartialMap = new Map();\n this._attrValueMap = new Map();\n this._attrValuePartialMap = new Map();\n this._listContexts = [];\n }\n /**\n * @param {?} notSelectors\n * @return {?}\n */\n SelectorMatcher.createNotMatcher = function (notSelectors) {\n var /** @type {?} */ notMatcher = new SelectorMatcher();\n notMatcher.addSelectables(notSelectors, null);\n return notMatcher;\n };\n /**\n * @param {?} cssSelectors\n * @param {?=} callbackCtxt\n * @return {?}\n */\n SelectorMatcher.prototype.addSelectables = function (cssSelectors, callbackCtxt) {\n var /** @type {?} */ listContext = null;\n if (cssSelectors.length > 1) {\n listContext = new SelectorListContext(cssSelectors);\n this._listContexts.push(listContext);\n }\n for (var /** @type {?} */ i = 0; i < cssSelectors.length; i++) {\n this._addSelectable(cssSelectors[i], callbackCtxt, listContext);\n }\n };\n /**\n * Add an object that can be found later on by calling `match`.\n * @param {?} cssSelector A css selector\n * @param {?} callbackCtxt An opaque object that will be given to the callback of the `match` function\n * @param {?} listContext\n * @return {?}\n */\n SelectorMatcher.prototype._addSelectable = function (cssSelector, callbackCtxt, listContext) {\n var /** @type {?} */ matcher = this;\n var /** @type {?} */ element = cssSelector.element;\n var /** @type {?} */ classNames = cssSelector.classNames;\n var /** @type {?} */ attrs = cssSelector.attrs;\n var /** @type {?} */ selectable = new SelectorContext(cssSelector, callbackCtxt, listContext);\n if (element) {\n var /** @type {?} */ isTerminal = attrs.length === 0 && classNames.length === 0;\n if (isTerminal) {\n this._addTerminal(matcher._elementMap, element, selectable);\n }\n else {\n matcher = this._addPartial(matcher._elementPartialMap, element);\n }\n }\n if (classNames) {\n for (var /** @type {?} */ i = 0; i < classNames.length; i++) {\n var /** @type {?} */ isTerminal = attrs.length === 0 && i === classNames.length - 1;\n var /** @type {?} */ className = classNames[i];\n if (isTerminal) {\n this._addTerminal(matcher._classMap, className, selectable);\n }\n else {\n matcher = this._addPartial(matcher._classPartialMap, className);\n }\n }\n }\n if (attrs) {\n for (var /** @type {?} */ i = 0; i < attrs.length; i += 2) {\n var /** @type {?} */ isTerminal = i === attrs.length - 2;\n var /** @type {?} */ name_2 = attrs[i];\n var /** @type {?} */ value = attrs[i + 1];\n if (isTerminal) {\n var /** @type {?} */ terminalMap = matcher._attrValueMap;\n var /** @type {?} */ terminalValuesMap = terminalMap.get(name_2);\n if (!terminalValuesMap) {\n terminalValuesMap = new Map();\n terminalMap.set(name_2, terminalValuesMap);\n }\n this._addTerminal(terminalValuesMap, value, selectable);\n }\n else {\n var /** @type {?} */ partialMap = matcher._attrValuePartialMap;\n var /** @type {?} */ partialValuesMap = partialMap.get(name_2);\n if (!partialValuesMap) {\n partialValuesMap = new Map();\n partialMap.set(name_2, partialValuesMap);\n }\n matcher = this._addPartial(partialValuesMap, value);\n }\n }\n }\n };\n /**\n * @param {?} map\n * @param {?} name\n * @param {?} selectable\n * @return {?}\n */\n SelectorMatcher.prototype._addTerminal = function (map, name, selectable) {\n var /** @type {?} */ terminalList = map.get(name);\n if (!terminalList) {\n terminalList = [];\n map.set(name, terminalList);\n }\n terminalList.push(selectable);\n };\n /**\n * @param {?} map\n * @param {?} name\n * @return {?}\n */\n SelectorMatcher.prototype._addPartial = function (map, name) {\n var /** @type {?} */ matcher = map.get(name);\n if (!matcher) {\n matcher = new SelectorMatcher();\n map.set(name, matcher);\n }\n return matcher;\n };\n /**\n * Find the objects that have been added via `addSelectable`\n * whose css selector is contained in the given css selector.\n * @param {?} cssSelector A css selector\n * @param {?} matchedCallback This callback will be called with the object handed into `addSelectable`\n * @return {?} boolean true if a match was found\n */\n SelectorMatcher.prototype.match = function (cssSelector, matchedCallback) {\n var /** @type {?} */ result = false;\n var /** @type {?} */ element = cssSelector.element;\n var /** @type {?} */ classNames = cssSelector.classNames;\n var /** @type {?} */ attrs = cssSelector.attrs;\n for (var /** @type {?} */ i = 0; i < this._listContexts.length; i++) {\n this._listContexts[i].alreadyMatched = false;\n }\n result = this._matchTerminal(this._elementMap, element, cssSelector, matchedCallback) || result;\n result = this._matchPartial(this._elementPartialMap, element, cssSelector, matchedCallback) ||\n result;\n if (classNames) {\n for (var /** @type {?} */ i = 0; i < classNames.length; i++) {\n var /** @type {?} */ className = classNames[i];\n result =\n this._matchTerminal(this._classMap, className, cssSelector, matchedCallback) || result;\n result =\n this._matchPartial(this._classPartialMap, className, cssSelector, matchedCallback) ||\n result;\n }\n }\n if (attrs) {\n for (var /** @type {?} */ i = 0; i < attrs.length; i += 2) {\n var /** @type {?} */ name_3 = attrs[i];\n var /** @type {?} */ value = attrs[i + 1];\n var /** @type {?} */ terminalValuesMap = this._attrValueMap.get(name_3);\n if (value) {\n result =\n this._matchTerminal(terminalValuesMap, '', cssSelector, matchedCallback) || result;\n }\n result =\n this._matchTerminal(terminalValuesMap, value, cssSelector, matchedCallback) || result;\n var /** @type {?} */ partialValuesMap = this._attrValuePartialMap.get(name_3);\n if (value) {\n result = this._matchPartial(partialValuesMap, '', cssSelector, matchedCallback) || result;\n }\n result =\n this._matchPartial(partialValuesMap, value, cssSelector, matchedCallback) || result;\n }\n }\n return result;\n };\n /**\n * @param {?} map\n * @param {?} name\n * @param {?} cssSelector\n * @param {?} matchedCallback\n * @return {?}\n */\n SelectorMatcher.prototype._matchTerminal = function (map, name, cssSelector, matchedCallback) {\n if (!map || typeof name !== 'string') {\n return false;\n }\n var /** @type {?} */ selectables = map.get(name) || [];\n var /** @type {?} */ starSelectables = map.get('*');\n if (starSelectables) {\n selectables = selectables.concat(starSelectables);\n }\n if (selectables.length === 0) {\n return false;\n }\n var /** @type {?} */ selectable;\n var /** @type {?} */ result = false;\n for (var /** @type {?} */ i = 0; i < selectables.length; i++) {\n selectable = selectables[i];\n result = selectable.finalize(cssSelector, matchedCallback) || result;\n }\n return result;\n };\n /**\n * @param {?} map\n * @param {?} name\n * @param {?} cssSelector\n * @param {?} matchedCallback\n * @return {?}\n */\n SelectorMatcher.prototype._matchPartial = function (map, name, cssSelector, matchedCallback) {\n if (!map || typeof name !== 'string') {\n return false;\n }\n var /** @type {?} */ nestedSelector = map.get(name);\n if (!nestedSelector) {\n return false;\n }\n // TODO(perf): get rid of recursion and measure again\n // TODO(perf): don't pass the whole selector into the recursion,\n // but only the not processed parts\n return nestedSelector.match(cssSelector, matchedCallback);\n };\n return SelectorMatcher;\n}());\nfunction SelectorMatcher_tsickle_Closure_declarations() {\n /** @type {?} */\n SelectorMatcher.prototype._elementMap;\n /** @type {?} */\n SelectorMatcher.prototype._elementPartialMap;\n /** @type {?} */\n SelectorMatcher.prototype._classMap;\n /** @type {?} */\n SelectorMatcher.prototype._classPartialMap;\n /** @type {?} */\n SelectorMatcher.prototype._attrValueMap;\n /** @type {?} */\n SelectorMatcher.prototype._attrValuePartialMap;\n /** @type {?} */\n SelectorMatcher.prototype._listContexts;\n}\nexport var SelectorListContext = (function () {\n /**\n * @param {?} selectors\n */\n function SelectorListContext(selectors) {\n this.selectors = selectors;\n this.alreadyMatched = false;\n }\n return SelectorListContext;\n}());\nfunction SelectorListContext_tsickle_Closure_declarations() {\n /** @type {?} */\n SelectorListContext.prototype.alreadyMatched;\n /** @type {?} */\n SelectorListContext.prototype.selectors;\n}\n// Store context to pass back selector and context when a selector is matched\nexport var SelectorContext = (function () {\n /**\n * @param {?} selector\n * @param {?} cbContext\n * @param {?} listContext\n */\n function SelectorContext(selector, cbContext, listContext) {\n this.selector = selector;\n this.cbContext = cbContext;\n this.listContext = listContext;\n this.notSelectors = selector.notSelectors;\n }\n /**\n * @param {?} cssSelector\n * @param {?} callback\n * @return {?}\n */\n SelectorContext.prototype.finalize = function (cssSelector, callback) {\n var /** @type {?} */ result = true;\n if (this.notSelectors.length > 0 && (!this.listContext || !this.listContext.alreadyMatched)) {\n var /** @type {?} */ notMatcher = SelectorMatcher.createNotMatcher(this.notSelectors);\n result = !notMatcher.match(cssSelector, null);\n }\n if (result && callback && (!this.listContext || !this.listContext.alreadyMatched)) {\n if (this.listContext) {\n this.listContext.alreadyMatched = true;\n }\n callback(this.selector, this.cbContext);\n }\n return result;\n };\n return SelectorContext;\n}());\nfunction SelectorContext_tsickle_Closure_declarations() {\n /** @type {?} */\n SelectorContext.prototype.notSelectors;\n /** @type {?} */\n SelectorContext.prototype.selector;\n /** @type {?} */\n SelectorContext.prototype.cbContext;\n /** @type {?} */\n SelectorContext.prototype.listContext;\n}\n//# sourceMappingURL=selector.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/selector.js\n// module id = ./node_modules/@angular/compiler/src/selector.js\n// module chunks = 0","/**\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 * This file is a port of shadowCSS from webcomponents.js to TypeScript.\n *\n * Please make sure to keep to edits in sync with the source file.\n *\n * Source:\n * https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js\n *\n * The original file level comment is reproduced below\n */\n/*\n This is a limited shim for ShadowDOM css styling.\n https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#styles\n\n The intention here is to support only the styling features which can be\n relatively simply implemented. The goal is to allow users to avoid the\n most obvious pitfalls and do so without compromising performance significantly.\n For ShadowDOM styling that's not covered here, a set of best practices\n can be provided that should allow users to accomplish more complex styling.\n\n The following is a list of specific ShadowDOM styling features and a brief\n discussion of the approach used to shim.\n\n Shimmed features:\n\n * :host, :host-context: ShadowDOM allows styling of the shadowRoot's host\n element using the :host rule. To shim this feature, the :host styles are\n reformatted and prefixed with a given scope name and promoted to a\n document level stylesheet.\n For example, given a scope name of .foo, a rule like this:\n\n :host {\n background: red;\n }\n }\n\n becomes:\n\n .foo {\n background: red;\n }\n\n * encapsulation: Styles defined within ShadowDOM, apply only to\n dom inside the ShadowDOM. Polymer uses one of two techniques to implement\n this feature.\n\n By default, rules are prefixed with the host element tag name\n as a descendant selector. This ensures styling does not leak out of the 'top'\n of the element's ShadowDOM. For example,\n\n div {\n font-weight: bold;\n }\n\n becomes:\n\n x-foo div {\n font-weight: bold;\n }\n\n becomes:\n\n\n Alternatively, if WebComponents.ShadowCSS.strictStyling is set to true then\n selectors are scoped by adding an attribute selector suffix to each\n simple selector that contains the host element tag name. Each element\n in the element's ShadowDOM template is also given the scope attribute.\n Thus, these rules match only elements that have the scope attribute.\n For example, given a scope name of x-foo, a rule like this:\n\n div {\n font-weight: bold;\n }\n\n becomes:\n\n div[x-foo] {\n font-weight: bold;\n }\n\n Note that elements that are dynamically added to a scope must have the scope\n selector added to them manually.\n\n * upper/lower bound encapsulation: Styles which are defined outside a\n shadowRoot should not cross the ShadowDOM boundary and should not apply\n inside a shadowRoot.\n\n This styling behavior is not emulated. Some possible ways to do this that\n were rejected due to complexity and/or performance concerns include: (1) reset\n every possible property for every possible selector for a given scope name;\n (2) re-implement css in javascript.\n\n As an alternative, users should make sure to use selectors\n specific to the scope in which they are working.\n\n * ::distributed: This behavior is not emulated. It's often not necessary\n to style the contents of a specific insertion point and instead, descendants\n of the host element can be styled selectively. Users can also create an\n extra node around an insertion point and style that node's contents\n via descendent selectors. For example, with a shadowRoot like this:\n\n \n \n\n could become:\n\n \n \n \n
\n\n Note the use of @polyfill in the comment above a ShadowDOM specific style\n declaration. This is a directive to the styling shim to use the selector\n in comments in lieu of the next selector when running under polyfill.\n*/\nexport var ShadowCss = (function () {\n function ShadowCss() {\n this.strictStyling = true;\n }\n /**\n * @param {?} cssText\n * @param {?} selector\n * @param {?=} hostSelector\n * @return {?}\n */\n ShadowCss.prototype.shimCssText = function (cssText, selector, hostSelector) {\n if (hostSelector === void 0) { hostSelector = ''; }\n var /** @type {?} */ sourceMappingUrl = extractSourceMappingUrl(cssText);\n cssText = stripComments(cssText);\n cssText = this._insertDirectives(cssText);\n return this._scopeCssText(cssText, selector, hostSelector) + sourceMappingUrl;\n };\n /**\n * @param {?} cssText\n * @return {?}\n */\n ShadowCss.prototype._insertDirectives = function (cssText) {\n cssText = this._insertPolyfillDirectivesInCssText(cssText);\n return this._insertPolyfillRulesInCssText(cssText);\n };\n /**\n * @param {?} cssText\n * @return {?}\n */\n ShadowCss.prototype._insertPolyfillDirectivesInCssText = function (cssText) {\n // Difference with webcomponents.js: does not handle comments\n return cssText.replace(_cssContentNextSelectorRe, function () {\n var m = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n m[_i - 0] = arguments[_i];\n }\n return m[2] + '{';\n });\n };\n /**\n * @param {?} cssText\n * @return {?}\n */\n ShadowCss.prototype._insertPolyfillRulesInCssText = function (cssText) {\n // Difference with webcomponents.js: does not handle comments\n return cssText.replace(_cssContentRuleRe, function () {\n var m = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n m[_i - 0] = arguments[_i];\n }\n var /** @type {?} */ rule = m[0].replace(m[1], '').replace(m[2], '');\n return m[4] + rule;\n });\n };\n /**\n * @param {?} cssText\n * @param {?} scopeSelector\n * @param {?} hostSelector\n * @return {?}\n */\n ShadowCss.prototype._scopeCssText = function (cssText, scopeSelector, hostSelector) {\n var /** @type {?} */ unscopedRules = this._extractUnscopedRulesFromCssText(cssText);\n // replace :host and :host-context -shadowcsshost and -shadowcsshost respectively\n cssText = this._insertPolyfillHostInCssText(cssText);\n cssText = this._convertColonHost(cssText);\n cssText = this._convertColonHostContext(cssText);\n cssText = this._convertShadowDOMSelectors(cssText);\n if (scopeSelector) {\n cssText = this._scopeSelectors(cssText, scopeSelector, hostSelector);\n }\n cssText = cssText + '\\n' + unscopedRules;\n return cssText.trim();\n };\n /**\n * @param {?} cssText\n * @return {?}\n */\n ShadowCss.prototype._extractUnscopedRulesFromCssText = function (cssText) {\n // Difference with webcomponents.js: does not handle comments\n var /** @type {?} */ r = '';\n var /** @type {?} */ m;\n _cssContentUnscopedRuleRe.lastIndex = 0;\n while ((m = _cssContentUnscopedRuleRe.exec(cssText)) !== null) {\n var /** @type {?} */ rule = m[0].replace(m[2], '').replace(m[1], m[4]);\n r += rule + '\\n\\n';\n }\n return r;\n };\n /**\n * @param {?} cssText\n * @return {?}\n */\n ShadowCss.prototype._convertColonHost = function (cssText) {\n return this._convertColonRule(cssText, _cssColonHostRe, this._colonHostPartReplacer);\n };\n /**\n * @param {?} cssText\n * @return {?}\n */\n ShadowCss.prototype._convertColonHostContext = function (cssText) {\n return this._convertColonRule(cssText, _cssColonHostContextRe, this._colonHostContextPartReplacer);\n };\n /**\n * @param {?} cssText\n * @param {?} regExp\n * @param {?} partReplacer\n * @return {?}\n */\n ShadowCss.prototype._convertColonRule = function (cssText, regExp, partReplacer) {\n // m[1] = :host(-context), m[2] = contents of (), m[3] rest of rule\n return cssText.replace(regExp, function () {\n var m = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n m[_i - 0] = arguments[_i];\n }\n if (m[2]) {\n var /** @type {?} */ parts = m[2].split(',');\n var /** @type {?} */ r = [];\n for (var /** @type {?} */ i = 0; i < parts.length; i++) {\n var /** @type {?} */ p = parts[i].trim();\n if (!p)\n break;\n r.push(partReplacer(_polyfillHostNoCombinator, p, m[3]));\n }\n return r.join(',');\n }\n else {\n return _polyfillHostNoCombinator + m[3];\n }\n });\n };\n /**\n * @param {?} host\n * @param {?} part\n * @param {?} suffix\n * @return {?}\n */\n ShadowCss.prototype._colonHostContextPartReplacer = function (host, part, suffix) {\n if (part.indexOf(_polyfillHost) > -1) {\n return this._colonHostPartReplacer(host, part, suffix);\n }\n else {\n return host + part + suffix + ', ' + part + ' ' + host + suffix;\n }\n };\n /**\n * @param {?} host\n * @param {?} part\n * @param {?} suffix\n * @return {?}\n */\n ShadowCss.prototype._colonHostPartReplacer = function (host, part, suffix) {\n return host + part.replace(_polyfillHost, '') + suffix;\n };\n /**\n * @param {?} cssText\n * @return {?}\n */\n ShadowCss.prototype._convertShadowDOMSelectors = function (cssText) {\n return _shadowDOMSelectorsRe.reduce(function (result, pattern) { return result.replace(pattern, ' '); }, cssText);\n };\n /**\n * @param {?} cssText\n * @param {?} scopeSelector\n * @param {?} hostSelector\n * @return {?}\n */\n ShadowCss.prototype._scopeSelectors = function (cssText, scopeSelector, hostSelector) {\n var _this = this;\n return processRules(cssText, function (rule) {\n var /** @type {?} */ selector = rule.selector;\n var /** @type {?} */ content = rule.content;\n if (rule.selector[0] != '@') {\n selector =\n _this._scopeSelector(rule.selector, scopeSelector, hostSelector, _this.strictStyling);\n }\n else if (rule.selector.startsWith('@media') || rule.selector.startsWith('@supports') ||\n rule.selector.startsWith('@page') || rule.selector.startsWith('@document')) {\n content = _this._scopeSelectors(rule.content, scopeSelector, hostSelector);\n }\n return new CssRule(selector, content);\n });\n };\n /**\n * @param {?} selector\n * @param {?} scopeSelector\n * @param {?} hostSelector\n * @param {?} strict\n * @return {?}\n */\n ShadowCss.prototype._scopeSelector = function (selector, scopeSelector, hostSelector, strict) {\n var _this = this;\n return selector.split(',')\n .map(function (part) { return part.trim().split(_shadowDeepSelectors); })\n .map(function (deepParts) {\n var shallowPart = deepParts[0], otherParts = deepParts.slice(1);\n var /** @type {?} */ applyScope = function (shallowPart) {\n if (_this._selectorNeedsScoping(shallowPart, scopeSelector)) {\n return strict ?\n _this._applyStrictSelectorScope(shallowPart, scopeSelector, hostSelector) :\n _this._applySelectorScope(shallowPart, scopeSelector, hostSelector);\n }\n else {\n return shallowPart;\n }\n };\n return [applyScope(shallowPart)].concat(otherParts).join(' ');\n })\n .join(', ');\n };\n /**\n * @param {?} selector\n * @param {?} scopeSelector\n * @return {?}\n */\n ShadowCss.prototype._selectorNeedsScoping = function (selector, scopeSelector) {\n var /** @type {?} */ re = this._makeScopeMatcher(scopeSelector);\n return !re.test(selector);\n };\n /**\n * @param {?} scopeSelector\n * @return {?}\n */\n ShadowCss.prototype._makeScopeMatcher = function (scopeSelector) {\n var /** @type {?} */ lre = /\\[/g;\n var /** @type {?} */ rre = /\\]/g;\n scopeSelector = scopeSelector.replace(lre, '\\\\[').replace(rre, '\\\\]');\n return new RegExp('^(' + scopeSelector + ')' + _selectorReSuffix, 'm');\n };\n /**\n * @param {?} selector\n * @param {?} scopeSelector\n * @param {?} hostSelector\n * @return {?}\n */\n ShadowCss.prototype._applySelectorScope = function (selector, scopeSelector, hostSelector) {\n // Difference from webcomponents.js: scopeSelector could not be an array\n return this._applySimpleSelectorScope(selector, scopeSelector, hostSelector);\n };\n /**\n * @param {?} selector\n * @param {?} scopeSelector\n * @param {?} hostSelector\n * @return {?}\n */\n ShadowCss.prototype._applySimpleSelectorScope = function (selector, scopeSelector, hostSelector) {\n // In Android browser, the lastIndex is not reset when the regex is used in String.replace()\n _polyfillHostRe.lastIndex = 0;\n if (_polyfillHostRe.test(selector)) {\n var /** @type {?} */ replaceBy_1 = this.strictStyling ? \"[\" + hostSelector + \"]\" : scopeSelector;\n return selector\n .replace(_polyfillHostNoCombinatorRe, function (hnc, selector) {\n return selector.replace(/([^:]*)(:*)(.*)/, function (_, before, colon, after) {\n return before + replaceBy_1 + colon + after;\n });\n })\n .replace(_polyfillHostRe, replaceBy_1 + ' ');\n }\n return scopeSelector + ' ' + selector;\n };\n /**\n * @param {?} selector\n * @param {?} scopeSelector\n * @param {?} hostSelector\n * @return {?}\n */\n ShadowCss.prototype._applyStrictSelectorScope = function (selector, scopeSelector, hostSelector) {\n var _this = this;\n var /** @type {?} */ isRe = /\\[is=([^\\]]*)\\]/g;\n scopeSelector = scopeSelector.replace(isRe, function (_) {\n var parts = [];\n for (var _i = 1; _i < arguments.length; _i++) {\n parts[_i - 1] = arguments[_i];\n }\n return parts[0];\n });\n var /** @type {?} */ attrName = '[' + scopeSelector + ']';\n var /** @type {?} */ _scopeSelectorPart = function (p) {\n var /** @type {?} */ scopedP = p.trim();\n if (!scopedP) {\n return '';\n }\n if (p.indexOf(_polyfillHostNoCombinator) > -1) {\n scopedP = _this._applySimpleSelectorScope(p, scopeSelector, hostSelector);\n }\n else {\n // remove :host since it should be unnecessary\n var /** @type {?} */ t = p.replace(_polyfillHostRe, '');\n if (t.length > 0) {\n var /** @type {?} */ matches = t.match(/([^:]*)(:*)(.*)/);\n if (matches) {\n scopedP = matches[1] + attrName + matches[2] + matches[3];\n }\n }\n }\n return scopedP;\n };\n var /** @type {?} */ safeContent = new SafeSelector(selector);\n selector = safeContent.content();\n var /** @type {?} */ scopedSelector = '';\n var /** @type {?} */ startIndex = 0;\n var /** @type {?} */ res;\n var /** @type {?} */ sep = /( |>|\\+|~(?!=))\\s*/g;\n var /** @type {?} */ scopeAfter = selector.indexOf(_polyfillHostNoCombinator);\n while ((res = sep.exec(selector)) !== null) {\n var /** @type {?} */ separator = res[1];\n var /** @type {?} */ part = selector.slice(startIndex, res.index).trim();\n // if a selector appears before :host-context it should not be shimmed as it\n // matches on ancestor elements and not on elements in the host's shadow\n var /** @type {?} */ scopedPart = startIndex >= scopeAfter ? _scopeSelectorPart(part) : part;\n scopedSelector += scopedPart + \" \" + separator + \" \";\n startIndex = sep.lastIndex;\n }\n scopedSelector += _scopeSelectorPart(selector.substring(startIndex));\n // replace the placeholders with their original values\n return safeContent.restore(scopedSelector);\n };\n /**\n * @param {?} selector\n * @return {?}\n */\n ShadowCss.prototype._insertPolyfillHostInCssText = function (selector) {\n return selector.replace(_colonHostContextRe, _polyfillHostContext)\n .replace(_colonHostRe, _polyfillHost);\n };\n return ShadowCss;\n}());\nfunction ShadowCss_tsickle_Closure_declarations() {\n /** @type {?} */\n ShadowCss.prototype.strictStyling;\n}\nvar SafeSelector = (function () {\n /**\n * @param {?} selector\n */\n function SafeSelector(selector) {\n var _this = this;\n this.placeholders = [];\n this.index = 0;\n // Replaces attribute selectors with placeholders.\n // The WS in [attr=\"va lue\"] would otherwise be interpreted as a selector separator.\n selector = selector.replace(/(\\[[^\\]]*\\])/g, function (_, keep) {\n var replaceBy = \"__ph-\" + _this.index + \"__\";\n _this.placeholders.push(keep);\n _this.index++;\n return replaceBy;\n });\n // Replaces the expression in `:nth-child(2n + 1)` with a placeholder.\n // WS and \"+\" would otherwise be interpreted as selector separators.\n this._content = selector.replace(/(:nth-[-\\w]+)(\\([^)]+\\))/g, function (_, pseudo, exp) {\n var replaceBy = \"__ph-\" + _this.index + \"__\";\n _this.placeholders.push(exp);\n _this.index++;\n return pseudo + replaceBy;\n });\n }\n ;\n /**\n * @param {?} content\n * @return {?}\n */\n SafeSelector.prototype.restore = function (content) {\n var _this = this;\n return content.replace(/__ph-(\\d+)__/g, function (ph, index) { return _this.placeholders[+index]; });\n };\n /**\n * @return {?}\n */\n SafeSelector.prototype.content = function () { return this._content; };\n return SafeSelector;\n}());\nfunction SafeSelector_tsickle_Closure_declarations() {\n /** @type {?} */\n SafeSelector.prototype.placeholders;\n /** @type {?} */\n SafeSelector.prototype.index;\n /** @type {?} */\n SafeSelector.prototype._content;\n}\nvar /** @type {?} */ _cssContentNextSelectorRe = /polyfill-next-selector[^}]*content:[\\s]*?(['\"])(.*?)\\1[;\\s]*}([^{]*?){/gim;\nvar /** @type {?} */ _cssContentRuleRe = /(polyfill-rule)[^}]*(content:[\\s]*(['\"])(.*?)\\3)[;\\s]*[^}]*}/gim;\nvar /** @type {?} */ _cssContentUnscopedRuleRe = /(polyfill-unscoped-rule)[^}]*(content:[\\s]*(['\"])(.*?)\\3)[;\\s]*[^}]*}/gim;\nvar /** @type {?} */ _polyfillHost = '-shadowcsshost';\n// note: :host-context pre-processed to -shadowcsshostcontext.\nvar /** @type {?} */ _polyfillHostContext = '-shadowcsscontext';\nvar /** @type {?} */ _parenSuffix = ')(?:\\\\((' +\n '(?:\\\\([^)(]*\\\\)|[^)(]*)+?' +\n ')\\\\))?([^,{]*)';\nvar /** @type {?} */ _cssColonHostRe = new RegExp('(' + _polyfillHost + _parenSuffix, 'gim');\nvar /** @type {?} */ _cssColonHostContextRe = new RegExp('(' + _polyfillHostContext + _parenSuffix, 'gim');\nvar /** @type {?} */ _polyfillHostNoCombinator = _polyfillHost + '-no-combinator';\nvar /** @type {?} */ _polyfillHostNoCombinatorRe = /-shadowcsshost-no-combinator([^\\s]*)/;\nvar /** @type {?} */ _shadowDOMSelectorsRe = [\n /::shadow/g,\n /::content/g,\n // Deprecated selectors\n /\\/shadow-deep\\//g,\n /\\/shadow\\//g,\n];\nvar /** @type {?} */ _shadowDeepSelectors = /(?:>>>)|(?:\\/deep\\/)/g;\nvar /** @type {?} */ _selectorReSuffix = '([>\\\\s~+\\[.,{:][\\\\s\\\\S]*)?$';\nvar /** @type {?} */ _polyfillHostRe = /-shadowcsshost/gim;\nvar /** @type {?} */ _colonHostRe = /:host/gim;\nvar /** @type {?} */ _colonHostContextRe = /:host-context/gim;\nvar /** @type {?} */ _commentRe = /\\/\\*\\s*[\\s\\S]*?\\*\\//g;\n/**\n * @param {?} input\n * @return {?}\n */\nfunction stripComments(input) {\n return input.replace(_commentRe, '');\n}\n// all comments except inline source mapping\nvar /** @type {?} */ _sourceMappingUrlRe = /\\/\\*\\s*#\\s*sourceMappingURL=[\\s\\S]+?\\*\\//;\n/**\n * @param {?} input\n * @return {?}\n */\nfunction extractSourceMappingUrl(input) {\n var /** @type {?} */ matcher = input.match(_sourceMappingUrlRe);\n return matcher ? matcher[0] : '';\n}\nvar /** @type {?} */ _ruleRe = /(\\s*)([^;\\{\\}]+?)(\\s*)((?:{%BLOCK%}?\\s*;?)|(?:\\s*;))/g;\nvar /** @type {?} */ _curlyRe = /([{}])/g;\nvar /** @type {?} */ OPEN_CURLY = '{';\nvar /** @type {?} */ CLOSE_CURLY = '}';\nvar /** @type {?} */ BLOCK_PLACEHOLDER = '%BLOCK%';\nexport var CssRule = (function () {\n /**\n * @param {?} selector\n * @param {?} content\n */\n function CssRule(selector, content) {\n this.selector = selector;\n this.content = content;\n }\n return CssRule;\n}());\nfunction CssRule_tsickle_Closure_declarations() {\n /** @type {?} */\n CssRule.prototype.selector;\n /** @type {?} */\n CssRule.prototype.content;\n}\n/**\n * @param {?} input\n * @param {?} ruleCallback\n * @return {?}\n */\nexport function processRules(input, ruleCallback) {\n var /** @type {?} */ inputWithEscapedBlocks = escapeBlocks(input);\n var /** @type {?} */ nextBlockIndex = 0;\n return inputWithEscapedBlocks.escapedString.replace(_ruleRe, function () {\n var m = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n m[_i - 0] = arguments[_i];\n }\n var /** @type {?} */ selector = m[2];\n var /** @type {?} */ content = '';\n var /** @type {?} */ suffix = m[4];\n var /** @type {?} */ contentPrefix = '';\n if (suffix && suffix.startsWith('{' + BLOCK_PLACEHOLDER)) {\n content = inputWithEscapedBlocks.blocks[nextBlockIndex++];\n suffix = suffix.substring(BLOCK_PLACEHOLDER.length + 1);\n contentPrefix = '{';\n }\n var /** @type {?} */ rule = ruleCallback(new CssRule(selector, content));\n return \"\" + m[1] + rule.selector + m[3] + contentPrefix + rule.content + suffix;\n });\n}\nvar StringWithEscapedBlocks = (function () {\n /**\n * @param {?} escapedString\n * @param {?} blocks\n */\n function StringWithEscapedBlocks(escapedString, blocks) {\n this.escapedString = escapedString;\n this.blocks = blocks;\n }\n return StringWithEscapedBlocks;\n}());\nfunction StringWithEscapedBlocks_tsickle_Closure_declarations() {\n /** @type {?} */\n StringWithEscapedBlocks.prototype.escapedString;\n /** @type {?} */\n StringWithEscapedBlocks.prototype.blocks;\n}\n/**\n * @param {?} input\n * @return {?}\n */\nfunction escapeBlocks(input) {\n var /** @type {?} */ inputParts = input.split(_curlyRe);\n var /** @type {?} */ resultParts = [];\n var /** @type {?} */ escapedBlocks = [];\n var /** @type {?} */ bracketCount = 0;\n var /** @type {?} */ currentBlockParts = [];\n for (var /** @type {?} */ partIndex = 0; partIndex < inputParts.length; partIndex++) {\n var /** @type {?} */ part = inputParts[partIndex];\n if (part == CLOSE_CURLY) {\n bracketCount--;\n }\n if (bracketCount > 0) {\n currentBlockParts.push(part);\n }\n else {\n if (currentBlockParts.length > 0) {\n escapedBlocks.push(currentBlockParts.join(''));\n resultParts.push(BLOCK_PLACEHOLDER);\n currentBlockParts = [];\n }\n resultParts.push(part);\n }\n if (part == OPEN_CURLY) {\n bracketCount++;\n }\n }\n if (currentBlockParts.length > 0) {\n escapedBlocks.push(currentBlockParts.join(''));\n resultParts.push(BLOCK_PLACEHOLDER);\n }\n return new StringWithEscapedBlocks(resultParts.join(''), escapedBlocks);\n}\n//# sourceMappingURL=shadow_css.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/shadow_css.js\n// module id = ./node_modules/@angular/compiler/src/shadow_css.js\n// module chunks = 0","/**\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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { ViewEncapsulation } from '@angular/core';\nimport { CompileStylesheetMetadata, identifierModuleUrl, identifierName } from './compile_metadata';\nimport { CompilerInjectable } from './injectable';\nimport * as o from './output/output_ast';\nimport { ShadowCss } from './shadow_css';\nimport { UrlResolver } from './url_resolver';\nvar /** @type {?} */ COMPONENT_VARIABLE = '%COMP%';\nvar /** @type {?} */ HOST_ATTR = \"_nghost-\" + COMPONENT_VARIABLE;\nvar /** @type {?} */ CONTENT_ATTR = \"_ngcontent-\" + COMPONENT_VARIABLE;\nexport var StylesCompileDependency = (function () {\n /**\n * @param {?} name\n * @param {?} moduleUrl\n * @param {?} isShimmed\n * @param {?} valuePlaceholder\n */\n function StylesCompileDependency(name, moduleUrl, isShimmed, valuePlaceholder) {\n this.name = name;\n this.moduleUrl = moduleUrl;\n this.isShimmed = isShimmed;\n this.valuePlaceholder = valuePlaceholder;\n }\n return StylesCompileDependency;\n}());\nfunction StylesCompileDependency_tsickle_Closure_declarations() {\n /** @type {?} */\n StylesCompileDependency.prototype.name;\n /** @type {?} */\n StylesCompileDependency.prototype.moduleUrl;\n /** @type {?} */\n StylesCompileDependency.prototype.isShimmed;\n /** @type {?} */\n StylesCompileDependency.prototype.valuePlaceholder;\n}\nexport var StylesCompileResult = (function () {\n /**\n * @param {?} componentStylesheet\n * @param {?} externalStylesheets\n */\n function StylesCompileResult(componentStylesheet, externalStylesheets) {\n this.componentStylesheet = componentStylesheet;\n this.externalStylesheets = externalStylesheets;\n }\n return StylesCompileResult;\n}());\nfunction StylesCompileResult_tsickle_Closure_declarations() {\n /** @type {?} */\n StylesCompileResult.prototype.componentStylesheet;\n /** @type {?} */\n StylesCompileResult.prototype.externalStylesheets;\n}\nexport var CompiledStylesheet = (function () {\n /**\n * @param {?} statements\n * @param {?} stylesVar\n * @param {?} dependencies\n * @param {?} isShimmed\n * @param {?} meta\n */\n function CompiledStylesheet(statements, stylesVar, dependencies, isShimmed, meta) {\n this.statements = statements;\n this.stylesVar = stylesVar;\n this.dependencies = dependencies;\n this.isShimmed = isShimmed;\n this.meta = meta;\n }\n return CompiledStylesheet;\n}());\nfunction CompiledStylesheet_tsickle_Closure_declarations() {\n /** @type {?} */\n CompiledStylesheet.prototype.statements;\n /** @type {?} */\n CompiledStylesheet.prototype.stylesVar;\n /** @type {?} */\n CompiledStylesheet.prototype.dependencies;\n /** @type {?} */\n CompiledStylesheet.prototype.isShimmed;\n /** @type {?} */\n CompiledStylesheet.prototype.meta;\n}\nexport var StyleCompiler = (function () {\n /**\n * @param {?} _urlResolver\n */\n function StyleCompiler(_urlResolver) {\n this._urlResolver = _urlResolver;\n this._shadowCss = new ShadowCss();\n }\n /**\n * @param {?} comp\n * @return {?}\n */\n StyleCompiler.prototype.compileComponent = function (comp) {\n var _this = this;\n var /** @type {?} */ externalStylesheets = [];\n var /** @type {?} */ componentStylesheet = this._compileStyles(comp, new CompileStylesheetMetadata({\n styles: comp.template.styles,\n styleUrls: comp.template.styleUrls,\n moduleUrl: identifierModuleUrl(comp.type)\n }), true);\n comp.template.externalStylesheets.forEach(function (stylesheetMeta) {\n var /** @type {?} */ compiledStylesheet = _this._compileStyles(comp, stylesheetMeta, false);\n externalStylesheets.push(compiledStylesheet);\n });\n return new StylesCompileResult(componentStylesheet, externalStylesheets);\n };\n /**\n * @param {?} comp\n * @param {?} stylesheet\n * @param {?} isComponentStylesheet\n * @return {?}\n */\n StyleCompiler.prototype._compileStyles = function (comp, stylesheet, isComponentStylesheet) {\n var _this = this;\n var /** @type {?} */ shim = comp.template.encapsulation === ViewEncapsulation.Emulated;\n var /** @type {?} */ styleExpressions = stylesheet.styles.map(function (plainStyle) { return o.literal(_this._shimIfNeeded(plainStyle, shim)); });\n var /** @type {?} */ dependencies = [];\n for (var /** @type {?} */ i = 0; i < stylesheet.styleUrls.length; i++) {\n var /** @type {?} */ identifier = { reference: null };\n dependencies.push(new StylesCompileDependency(getStylesVarName(null), stylesheet.styleUrls[i], shim, identifier));\n styleExpressions.push(new o.ExternalExpr(identifier));\n }\n // styles variable contains plain strings and arrays of other styles arrays (recursive),\n // so we set its type to dynamic.\n var /** @type {?} */ stylesVar = getStylesVarName(isComponentStylesheet ? comp : null);\n var /** @type {?} */ stmt = o.variable(stylesVar)\n .set(o.literalArr(styleExpressions, new o.ArrayType(o.DYNAMIC_TYPE, [o.TypeModifier.Const])))\n .toDeclStmt(null, [o.StmtModifier.Final]);\n return new CompiledStylesheet([stmt], stylesVar, dependencies, shim, stylesheet);\n };\n /**\n * @param {?} style\n * @param {?} shim\n * @return {?}\n */\n StyleCompiler.prototype._shimIfNeeded = function (style, shim) {\n return shim ? this._shadowCss.shimCssText(style, CONTENT_ATTR, HOST_ATTR) : style;\n };\n StyleCompiler = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [UrlResolver])\n ], StyleCompiler);\n return StyleCompiler;\n}());\nfunction StyleCompiler_tsickle_Closure_declarations() {\n /** @type {?} */\n StyleCompiler.prototype._shadowCss;\n /** @type {?} */\n StyleCompiler.prototype._urlResolver;\n}\n/**\n * @param {?} component\n * @return {?}\n */\nfunction getStylesVarName(component) {\n var /** @type {?} */ result = \"styles\";\n if (component) {\n result += \"_\" + identifierName(component.type);\n }\n return result;\n}\n//# sourceMappingURL=style_compiler.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/style_compiler.js\n// module id = ./node_modules/@angular/compiler/src/style_compiler.js\n// module chunks = 0","/**\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 */\nexport var StyleWithImports = (function () {\n /**\n * @param {?} style\n * @param {?} styleUrls\n */\n function StyleWithImports(style, styleUrls) {\n this.style = style;\n this.styleUrls = styleUrls;\n }\n return StyleWithImports;\n}());\nfunction StyleWithImports_tsickle_Closure_declarations() {\n /** @type {?} */\n StyleWithImports.prototype.style;\n /** @type {?} */\n StyleWithImports.prototype.styleUrls;\n}\n/**\n * @param {?} url\n * @return {?}\n */\nexport function 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 */\nexport function 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 - 0] = 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 /** @type {?} */ CSS_IMPORT_REGEXP = /@import\\s+(?:url\\()?\\s*(?:(?:['\"]([^'\"]*))|([^;\\)\\s]*))[^;]*;?/g;\nvar /** @type {?} */ CSS_COMMENT_REGEXP = /\\/\\*.+?\\*\\//g;\nvar /** @type {?} */ URL_WITH_SCHEMA_REGEXP = /^([^:/?#]+):/;\n//# sourceMappingURL=style_url_resolver.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/style_url_resolver.js\n// module id = ./node_modules/@angular/compiler/src/style_url_resolver.js\n// module chunks = 0","var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { CompilerInjectable } from './injectable';\nexport var SummaryResolver = (function () {\n function SummaryResolver() {\n }\n /**\n * @param {?} reference\n * @return {?}\n */\n SummaryResolver.prototype.resolveSummary = function (reference) { return null; };\n ;\n /**\n * @param {?} filePath\n * @return {?}\n */\n SummaryResolver.prototype.getSymbolsOf = function (filePath) { return []; };\n SummaryResolver = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [])\n ], SummaryResolver);\n return SummaryResolver;\n}());\n//# sourceMappingURL=summary_resolver.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/summary_resolver.js\n// module id = ./node_modules/@angular/compiler/src/summary_resolver.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nimport { SecurityContext } from '@angular/core';\nimport { EmptyExpr, RecursiveAstVisitor } from '../expression_parser/ast';\nimport { isPresent } from '../facade/lang';\nimport { mergeNsAndName } from '../ml_parser/tags';\nimport { ParseError, ParseErrorLevel, ParseSourceSpan } from '../parse_util';\nimport { CssSelector } from '../selector';\nimport { splitAtColon, splitAtPeriod } from '../util';\nimport { BoundElementPropertyAst, BoundEventAst, PropertyBindingType, VariableAst } from './template_ast';\nvar /** @type {?} */ PROPERTY_PARTS_SEPARATOR = '.';\nvar /** @type {?} */ ATTRIBUTE_PREFIX = 'attr';\nvar /** @type {?} */ CLASS_PREFIX = 'class';\nvar /** @type {?} */ STYLE_PREFIX = 'style';\nvar /** @type {?} */ ANIMATE_PROP_PREFIX = 'animate-';\nexport var 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 */\nexport var 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}());\nfunction BoundProperty_tsickle_Closure_declarations() {\n /** @type {?} */\n BoundProperty.prototype.name;\n /** @type {?} */\n BoundProperty.prototype.expression;\n /** @type {?} */\n BoundProperty.prototype.type;\n /** @type {?} */\n BoundProperty.prototype.sourceSpan;\n}\n/**\n * Parses bindings in templates and in the directive host area.\n */\nexport var 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 pipes.forEach(function (pipe) { return _this.pipesByName.set(pipe.name, pipe); });\n }\n /**\n * @param {?} dirMeta\n * @param {?} sourceSpan\n * @return {?}\n */\n BindingParser.prototype.createDirectiveHostPropertyAsts = function (dirMeta, 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(dirMeta.selector, 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 {?} name\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 (name, 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 (isPresent(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 (isPresent(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.FATAL);\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 (isPresent(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, false, 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_1 = boundPropertyName.substring(nsSeparatorIdx + 1);\n boundPropertyName = mergeNsAndName(ns, name_1);\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.length === 1 ? securityContexts[0] : null, securityContexts.length > 1, 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.FATAL; }\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 (isPresent(ast)) {\n var /** @type {?} */ collector = new PipeCollector();\n ast.visit(collector);\n collector.pipes.forEach(function (ast, pipeName) {\n if (!_this.pipesByName.has(pipeName)) {\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 });\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.FATAL);\n }\n };\n return BindingParser;\n}());\nfunction BindingParser_tsickle_Closure_declarations() {\n /** @type {?} */\n BindingParser.prototype.pipesByName;\n /** @type {?} */\n BindingParser.prototype._exprParser;\n /** @type {?} */\n BindingParser.prototype._interpolationConfig;\n /** @type {?} */\n BindingParser.prototype._schemaRegistry;\n /** @type {?} */\n BindingParser.prototype._targetErrors;\n}\nexport var PipeCollector = (function (_super) {\n __extends(PipeCollector, _super);\n function PipeCollector() {\n _super.apply(this, arguments);\n this.pipes = new Map();\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));\nfunction PipeCollector_tsickle_Closure_declarations() {\n /** @type {?} */\n PipeCollector.prototype.pipes;\n}\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 */\nexport function 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//# sourceMappingURL=binding_parser.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/template_parser/binding_parser.js\n// module id = ./node_modules/@angular/compiler/src/template_parser/binding_parser.js\n// module chunks = 0","/**\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 segment of text within the template.\n */\nexport var TextAst = (function () {\n /**\n * @param {?} value\n * @param {?} ngContentIndex\n * @param {?} sourceSpan\n */\n function TextAst(value, ngContentIndex, sourceSpan) {\n this.value = value;\n this.ngContentIndex = ngContentIndex;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n TextAst.prototype.visit = function (visitor, context) { return visitor.visitText(this, context); };\n return TextAst;\n}());\nfunction TextAst_tsickle_Closure_declarations() {\n /** @type {?} */\n TextAst.prototype.value;\n /** @type {?} */\n TextAst.prototype.ngContentIndex;\n /** @type {?} */\n TextAst.prototype.sourceSpan;\n}\n/**\n * A bound expression within the text of a template.\n */\nexport var BoundTextAst = (function () {\n /**\n * @param {?} value\n * @param {?} ngContentIndex\n * @param {?} sourceSpan\n */\n function BoundTextAst(value, ngContentIndex, sourceSpan) {\n this.value = value;\n this.ngContentIndex = ngContentIndex;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n BoundTextAst.prototype.visit = function (visitor, context) {\n return visitor.visitBoundText(this, context);\n };\n return BoundTextAst;\n}());\nfunction BoundTextAst_tsickle_Closure_declarations() {\n /** @type {?} */\n BoundTextAst.prototype.value;\n /** @type {?} */\n BoundTextAst.prototype.ngContentIndex;\n /** @type {?} */\n BoundTextAst.prototype.sourceSpan;\n}\n/**\n * A plain attribute on an element.\n */\nexport var AttrAst = (function () {\n /**\n * @param {?} name\n * @param {?} value\n * @param {?} sourceSpan\n */\n function AttrAst(name, value, sourceSpan) {\n this.name = name;\n this.value = value;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n AttrAst.prototype.visit = function (visitor, context) { return visitor.visitAttr(this, context); };\n return AttrAst;\n}());\nfunction AttrAst_tsickle_Closure_declarations() {\n /** @type {?} */\n AttrAst.prototype.name;\n /** @type {?} */\n AttrAst.prototype.value;\n /** @type {?} */\n AttrAst.prototype.sourceSpan;\n}\n/**\n * A binding for an element property (e.g. `[property]=\"expression\"`) or an animation trigger (e.g.\n * `[@trigger]=\"stateExp\"`)\n */\nexport var BoundElementPropertyAst = (function () {\n /**\n * @param {?} name\n * @param {?} type\n * @param {?} securityContext\n * @param {?} needsRuntimeSecurityContext\n * @param {?} value\n * @param {?} unit\n * @param {?} sourceSpan\n */\n function BoundElementPropertyAst(name, type, securityContext, needsRuntimeSecurityContext, value, unit, sourceSpan) {\n this.name = name;\n this.type = type;\n this.securityContext = securityContext;\n this.needsRuntimeSecurityContext = needsRuntimeSecurityContext;\n this.value = value;\n this.unit = unit;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n BoundElementPropertyAst.prototype.visit = function (visitor, context) {\n return visitor.visitElementProperty(this, context);\n };\n Object.defineProperty(BoundElementPropertyAst.prototype, \"isAnimation\", {\n /**\n * @return {?}\n */\n get: function () { return this.type === PropertyBindingType.Animation; },\n enumerable: true,\n configurable: true\n });\n return BoundElementPropertyAst;\n}());\nfunction BoundElementPropertyAst_tsickle_Closure_declarations() {\n /** @type {?} */\n BoundElementPropertyAst.prototype.name;\n /** @type {?} */\n BoundElementPropertyAst.prototype.type;\n /** @type {?} */\n BoundElementPropertyAst.prototype.securityContext;\n /** @type {?} */\n BoundElementPropertyAst.prototype.needsRuntimeSecurityContext;\n /** @type {?} */\n BoundElementPropertyAst.prototype.value;\n /** @type {?} */\n BoundElementPropertyAst.prototype.unit;\n /** @type {?} */\n BoundElementPropertyAst.prototype.sourceSpan;\n}\n/**\n * A binding for an element event (e.g. `(event)=\"handler()\"`) or an animation trigger event (e.g.\n * `(@trigger.phase)=\"callback($event)\"`).\n */\nexport var BoundEventAst = (function () {\n /**\n * @param {?} name\n * @param {?} target\n * @param {?} phase\n * @param {?} handler\n * @param {?} sourceSpan\n */\n function BoundEventAst(name, target, phase, handler, sourceSpan) {\n this.name = name;\n this.target = target;\n this.phase = phase;\n this.handler = handler;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} name\n * @param {?} target\n * @param {?} phase\n * @return {?}\n */\n BoundEventAst.calcFullName = function (name, target, phase) {\n if (target) {\n return target + \":\" + name;\n }\n else if (phase) {\n return \"@\" + name + \".\" + phase;\n }\n else {\n return name;\n }\n };\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n BoundEventAst.prototype.visit = function (visitor, context) {\n return visitor.visitEvent(this, context);\n };\n Object.defineProperty(BoundEventAst.prototype, \"fullName\", {\n /**\n * @return {?}\n */\n get: function () { return BoundEventAst.calcFullName(this.name, this.target, this.phase); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(BoundEventAst.prototype, \"isAnimation\", {\n /**\n * @return {?}\n */\n get: function () { return !!this.phase; },\n enumerable: true,\n configurable: true\n });\n return BoundEventAst;\n}());\nfunction BoundEventAst_tsickle_Closure_declarations() {\n /** @type {?} */\n BoundEventAst.prototype.name;\n /** @type {?} */\n BoundEventAst.prototype.target;\n /** @type {?} */\n BoundEventAst.prototype.phase;\n /** @type {?} */\n BoundEventAst.prototype.handler;\n /** @type {?} */\n BoundEventAst.prototype.sourceSpan;\n}\n/**\n * A reference declaration on an element (e.g. `let someName=\"expression\"`).\n */\nexport var ReferenceAst = (function () {\n /**\n * @param {?} name\n * @param {?} value\n * @param {?} sourceSpan\n */\n function ReferenceAst(name, value, sourceSpan) {\n this.name = name;\n this.value = value;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ReferenceAst.prototype.visit = function (visitor, context) {\n return visitor.visitReference(this, context);\n };\n return ReferenceAst;\n}());\nfunction ReferenceAst_tsickle_Closure_declarations() {\n /** @type {?} */\n ReferenceAst.prototype.name;\n /** @type {?} */\n ReferenceAst.prototype.value;\n /** @type {?} */\n ReferenceAst.prototype.sourceSpan;\n}\n/**\n * A variable declaration on a (e.g. `var-someName=\"someLocalName\"`).\n */\nexport var VariableAst = (function () {\n /**\n * @param {?} name\n * @param {?} value\n * @param {?} sourceSpan\n */\n function VariableAst(name, value, sourceSpan) {\n this.name = name;\n this.value = value;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n VariableAst.prototype.visit = function (visitor, context) {\n return visitor.visitVariable(this, context);\n };\n return VariableAst;\n}());\nfunction VariableAst_tsickle_Closure_declarations() {\n /** @type {?} */\n VariableAst.prototype.name;\n /** @type {?} */\n VariableAst.prototype.value;\n /** @type {?} */\n VariableAst.prototype.sourceSpan;\n}\n/**\n * An element declaration in a template.\n */\nexport var ElementAst = (function () {\n /**\n * @param {?} name\n * @param {?} attrs\n * @param {?} inputs\n * @param {?} outputs\n * @param {?} references\n * @param {?} directives\n * @param {?} providers\n * @param {?} hasViewContainer\n * @param {?} children\n * @param {?} ngContentIndex\n * @param {?} sourceSpan\n * @param {?} endSourceSpan\n */\n function ElementAst(name, attrs, inputs, outputs, references, directives, providers, hasViewContainer, children, ngContentIndex, sourceSpan, endSourceSpan) {\n this.name = name;\n this.attrs = attrs;\n this.inputs = inputs;\n this.outputs = outputs;\n this.references = references;\n this.directives = directives;\n this.providers = providers;\n this.hasViewContainer = hasViewContainer;\n this.children = children;\n this.ngContentIndex = ngContentIndex;\n this.sourceSpan = sourceSpan;\n this.endSourceSpan = endSourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ElementAst.prototype.visit = function (visitor, context) {\n return visitor.visitElement(this, context);\n };\n return ElementAst;\n}());\nfunction ElementAst_tsickle_Closure_declarations() {\n /** @type {?} */\n ElementAst.prototype.name;\n /** @type {?} */\n ElementAst.prototype.attrs;\n /** @type {?} */\n ElementAst.prototype.inputs;\n /** @type {?} */\n ElementAst.prototype.outputs;\n /** @type {?} */\n ElementAst.prototype.references;\n /** @type {?} */\n ElementAst.prototype.directives;\n /** @type {?} */\n ElementAst.prototype.providers;\n /** @type {?} */\n ElementAst.prototype.hasViewContainer;\n /** @type {?} */\n ElementAst.prototype.children;\n /** @type {?} */\n ElementAst.prototype.ngContentIndex;\n /** @type {?} */\n ElementAst.prototype.sourceSpan;\n /** @type {?} */\n ElementAst.prototype.endSourceSpan;\n}\n/**\n * A `` element included in an Angular template.\n */\nexport var EmbeddedTemplateAst = (function () {\n /**\n * @param {?} attrs\n * @param {?} outputs\n * @param {?} references\n * @param {?} variables\n * @param {?} directives\n * @param {?} providers\n * @param {?} hasViewContainer\n * @param {?} children\n * @param {?} ngContentIndex\n * @param {?} sourceSpan\n */\n function EmbeddedTemplateAst(attrs, outputs, references, variables, directives, providers, hasViewContainer, children, ngContentIndex, sourceSpan) {\n this.attrs = attrs;\n this.outputs = outputs;\n this.references = references;\n this.variables = variables;\n this.directives = directives;\n this.providers = providers;\n this.hasViewContainer = hasViewContainer;\n this.children = children;\n this.ngContentIndex = ngContentIndex;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n EmbeddedTemplateAst.prototype.visit = function (visitor, context) {\n return visitor.visitEmbeddedTemplate(this, context);\n };\n return EmbeddedTemplateAst;\n}());\nfunction EmbeddedTemplateAst_tsickle_Closure_declarations() {\n /** @type {?} */\n EmbeddedTemplateAst.prototype.attrs;\n /** @type {?} */\n EmbeddedTemplateAst.prototype.outputs;\n /** @type {?} */\n EmbeddedTemplateAst.prototype.references;\n /** @type {?} */\n EmbeddedTemplateAst.prototype.variables;\n /** @type {?} */\n EmbeddedTemplateAst.prototype.directives;\n /** @type {?} */\n EmbeddedTemplateAst.prototype.providers;\n /** @type {?} */\n EmbeddedTemplateAst.prototype.hasViewContainer;\n /** @type {?} */\n EmbeddedTemplateAst.prototype.children;\n /** @type {?} */\n EmbeddedTemplateAst.prototype.ngContentIndex;\n /** @type {?} */\n EmbeddedTemplateAst.prototype.sourceSpan;\n}\n/**\n * A directive property with a bound value (e.g. `*ngIf=\"condition\").\n */\nexport var BoundDirectivePropertyAst = (function () {\n /**\n * @param {?} directiveName\n * @param {?} templateName\n * @param {?} value\n * @param {?} sourceSpan\n */\n function BoundDirectivePropertyAst(directiveName, templateName, value, sourceSpan) {\n this.directiveName = directiveName;\n this.templateName = templateName;\n this.value = value;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n BoundDirectivePropertyAst.prototype.visit = function (visitor, context) {\n return visitor.visitDirectiveProperty(this, context);\n };\n return BoundDirectivePropertyAst;\n}());\nfunction BoundDirectivePropertyAst_tsickle_Closure_declarations() {\n /** @type {?} */\n BoundDirectivePropertyAst.prototype.directiveName;\n /** @type {?} */\n BoundDirectivePropertyAst.prototype.templateName;\n /** @type {?} */\n BoundDirectivePropertyAst.prototype.value;\n /** @type {?} */\n BoundDirectivePropertyAst.prototype.sourceSpan;\n}\n/**\n * A directive declared on an element.\n */\nexport var DirectiveAst = (function () {\n /**\n * @param {?} directive\n * @param {?} inputs\n * @param {?} hostProperties\n * @param {?} hostEvents\n * @param {?} sourceSpan\n */\n function DirectiveAst(directive, inputs, hostProperties, hostEvents, sourceSpan) {\n this.directive = directive;\n this.inputs = inputs;\n this.hostProperties = hostProperties;\n this.hostEvents = hostEvents;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n DirectiveAst.prototype.visit = function (visitor, context) {\n return visitor.visitDirective(this, context);\n };\n return DirectiveAst;\n}());\nfunction DirectiveAst_tsickle_Closure_declarations() {\n /** @type {?} */\n DirectiveAst.prototype.directive;\n /** @type {?} */\n DirectiveAst.prototype.inputs;\n /** @type {?} */\n DirectiveAst.prototype.hostProperties;\n /** @type {?} */\n DirectiveAst.prototype.hostEvents;\n /** @type {?} */\n DirectiveAst.prototype.sourceSpan;\n}\n/**\n * A provider declared on an element\n */\nexport var ProviderAst = (function () {\n /**\n * @param {?} token\n * @param {?} multiProvider\n * @param {?} eager\n * @param {?} providers\n * @param {?} providerType\n * @param {?} lifecycleHooks\n * @param {?} sourceSpan\n */\n function ProviderAst(token, multiProvider, eager, providers, providerType, lifecycleHooks, sourceSpan) {\n this.token = token;\n this.multiProvider = multiProvider;\n this.eager = eager;\n this.providers = providers;\n this.providerType = providerType;\n this.lifecycleHooks = lifecycleHooks;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n ProviderAst.prototype.visit = function (visitor, context) {\n // No visit method in the visitor for now...\n return null;\n };\n return ProviderAst;\n}());\nfunction ProviderAst_tsickle_Closure_declarations() {\n /** @type {?} */\n ProviderAst.prototype.token;\n /** @type {?} */\n ProviderAst.prototype.multiProvider;\n /** @type {?} */\n ProviderAst.prototype.eager;\n /** @type {?} */\n ProviderAst.prototype.providers;\n /** @type {?} */\n ProviderAst.prototype.providerType;\n /** @type {?} */\n ProviderAst.prototype.lifecycleHooks;\n /** @type {?} */\n ProviderAst.prototype.sourceSpan;\n}\nexport var ProviderAstType = {};\nProviderAstType.PublicService = 0;\nProviderAstType.PrivateService = 1;\nProviderAstType.Component = 2;\nProviderAstType.Directive = 3;\nProviderAstType.Builtin = 4;\nProviderAstType[ProviderAstType.PublicService] = \"PublicService\";\nProviderAstType[ProviderAstType.PrivateService] = \"PrivateService\";\nProviderAstType[ProviderAstType.Component] = \"Component\";\nProviderAstType[ProviderAstType.Directive] = \"Directive\";\nProviderAstType[ProviderAstType.Builtin] = \"Builtin\";\n/**\n * Position where content is to be projected (instance of `` in a template).\n */\nexport var NgContentAst = (function () {\n /**\n * @param {?} index\n * @param {?} ngContentIndex\n * @param {?} sourceSpan\n */\n function NgContentAst(index, ngContentIndex, sourceSpan) {\n this.index = index;\n this.ngContentIndex = ngContentIndex;\n this.sourceSpan = sourceSpan;\n }\n /**\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\n NgContentAst.prototype.visit = function (visitor, context) {\n return visitor.visitNgContent(this, context);\n };\n return NgContentAst;\n}());\nfunction NgContentAst_tsickle_Closure_declarations() {\n /** @type {?} */\n NgContentAst.prototype.index;\n /** @type {?} */\n NgContentAst.prototype.ngContentIndex;\n /** @type {?} */\n NgContentAst.prototype.sourceSpan;\n}\nexport var PropertyBindingType = {};\nPropertyBindingType.Property = 0;\nPropertyBindingType.Attribute = 1;\nPropertyBindingType.Class = 2;\nPropertyBindingType.Style = 3;\nPropertyBindingType.Animation = 4;\nPropertyBindingType[PropertyBindingType.Property] = \"Property\";\nPropertyBindingType[PropertyBindingType.Attribute] = \"Attribute\";\nPropertyBindingType[PropertyBindingType.Class] = \"Class\";\nPropertyBindingType[PropertyBindingType.Style] = \"Style\";\nPropertyBindingType[PropertyBindingType.Animation] = \"Animation\";\n/**\n * Visit every node in a list of {@link TemplateAst}s with the given {@link TemplateAstVisitor}.\n * @param {?} visitor\n * @param {?} asts\n * @param {?=} context\n * @return {?}\n */\nexport function templateVisitAll(visitor, asts, context) {\n if (context === void 0) { context = null; }\n var /** @type {?} */ result = [];\n var /** @type {?} */ visit = visitor.visit ?\n function (ast) { return visitor.visit(ast, context) || ast.visit(visitor, context); } :\n function (ast) { return ast.visit(visitor, context); };\n asts.forEach(function (ast) {\n var /** @type {?} */ astResult = visit(ast);\n if (astResult) {\n result.push(astResult);\n }\n });\n return result;\n}\n//# sourceMappingURL=template_ast.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/template_parser/template_ast.js\n// module id = ./node_modules/@angular/compiler/src/template_parser/template_ast.js\n// module chunks = 0","/**\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 __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nimport { Inject, OpaqueToken, Optional } from '@angular/core';\nimport { identifierName } from '../compile_metadata';\nimport { Parser } from '../expression_parser/parser';\nimport { isPresent } from '../facade/lang';\nimport { I18NHtmlParser } from '../i18n/i18n_html_parser';\nimport { Identifiers, createIdentifierToken, identifierToken } from '../identifiers';\nimport { CompilerInjectable } from '../injectable';\nimport * as html from '../ml_parser/ast';\nimport { ParseTreeResult } from '../ml_parser/html_parser';\nimport { expandNodes } from '../ml_parser/icu_ast_expander';\nimport { InterpolationConfig } from '../ml_parser/interpolation_config';\nimport { splitNsName } from '../ml_parser/tags';\nimport { ParseError, ParseErrorLevel, ParseSourceSpan } from '../parse_util';\nimport { Console } from '../private_import_core';\nimport { ProviderElementContext, ProviderViewContext } from '../provider_analyzer';\nimport { ElementSchemaRegistry } from '../schema/element_schema_registry';\nimport { CssSelector, SelectorMatcher } from '../selector';\nimport { isStyleUrlResolvable } from '../style_url_resolver';\nimport { SyntaxError } from '../util';\nimport { BindingParser } from './binding_parser';\nimport { AttrAst, BoundDirectivePropertyAst, BoundTextAst, DirectiveAst, ElementAst, EmbeddedTemplateAst, NgContentAst, PropertyBindingType, ReferenceAst, TextAst, VariableAst, templateVisitAll } from './template_ast';\nimport { PreparsedElementType, preparseElement } from './template_preparser';\n// Group 1 = \"bind-\"\n// Group 2 = \"let-\"\n// Group 3 = \"ref-/#\"\n// Group 4 = \"on-\"\n// Group 5 = \"bindon-\"\n// Group 6 = \"@\"\n// Group 7 = the identifier after \"bind-\", \"let-\", \"ref-/#\", \"on-\", \"bindon-\" or \"@\"\n// Group 8 = identifier inside [()]\n// Group 9 = identifier inside []\n// Group 10 = identifier inside ()\nvar /** @type {?} */ BIND_NAME_REGEXP = /^(?:(?:(?:(bind-)|(let-)|(ref-|#)|(on-)|(bindon-)|(@))(.+))|\\[\\(([^\\)]+)\\)\\]|\\[([^\\]]+)\\]|\\(([^\\)]+)\\))$/;\nvar /** @type {?} */ KW_BIND_IDX = 1;\nvar /** @type {?} */ KW_LET_IDX = 2;\nvar /** @type {?} */ KW_REF_IDX = 3;\nvar /** @type {?} */ KW_ON_IDX = 4;\nvar /** @type {?} */ KW_BINDON_IDX = 5;\nvar /** @type {?} */ KW_AT_IDX = 6;\nvar /** @type {?} */ IDENT_KW_IDX = 7;\nvar /** @type {?} */ IDENT_BANANA_BOX_IDX = 8;\nvar /** @type {?} */ IDENT_PROPERTY_IDX = 9;\nvar /** @type {?} */ IDENT_EVENT_IDX = 10;\nvar /** @type {?} */ TEMPLATE_ELEMENT = 'template';\nvar /** @type {?} */ TEMPLATE_ATTR = 'template';\nvar /** @type {?} */ TEMPLATE_ATTR_PREFIX = '*';\nvar /** @type {?} */ CLASS_ATTR = 'class';\nvar /** @type {?} */ TEXT_CSS_SELECTOR = CssSelector.parse('*')[0];\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 */\nexport var /** @type {?} */ TEMPLATE_TRANSFORMS = new OpaqueToken('TemplateTransforms');\nexport var 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 _super.call(this, span, message, level);\n }\n return TemplateParseError;\n}(ParseError));\nexport var TemplateParseResult = (function () {\n /**\n * @param {?=} templateAst\n * @param {?=} errors\n */\n function TemplateParseResult(templateAst, errors) {\n this.templateAst = templateAst;\n this.errors = errors;\n }\n return TemplateParseResult;\n}());\nfunction TemplateParseResult_tsickle_Closure_declarations() {\n /** @type {?} */\n TemplateParseResult.prototype.templateAst;\n /** @type {?} */\n TemplateParseResult.prototype.errors;\n}\nexport var TemplateParser = (function () {\n /**\n * @param {?} _exprParser\n * @param {?} _schemaRegistry\n * @param {?} _htmlParser\n * @param {?} _console\n * @param {?} transforms\n */\n function TemplateParser(_exprParser, _schemaRegistry, _htmlParser, _console, transforms) {\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; });\n var /** @type {?} */ errors = result.errors.filter(function (error) { return error.level === ParseErrorLevel.FATAL; });\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 new SyntaxError(\"Template parse errors:\\n\" + errorString);\n }\n return result.templateAst;\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 if (htmlAstWithErrors.rootNodes.length > 0) {\n var /** @type {?} */ uniqDirectives = removeSummaryDuplicates(directives);\n var /** @type {?} */ uniqPipes = removeSummaryDuplicates(pipes);\n var /** @type {?} */ providerViewContext = new ProviderViewContext(component, htmlAstWithErrors.rootNodes[0].sourceSpan);\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(providerViewContext, uniqDirectives, bindingParser, this._schemaRegistry, schemas, errors);\n result = html.visitAll(parseVisitor, htmlAstWithErrors.rootNodes, EMPTY_ELEMENT_CONTEXT);\n errors.push.apply(errors, providerViewContext.errors);\n }\n else {\n result = [];\n }\n this._assertNoReferenceDuplicationOnTemplate(result, errors);\n if (errors.length > 0) {\n return new TemplateParseResult(result, errors);\n }\n if (isPresent(this.transforms)) {\n this.transforms.forEach(function (transform) { result = templateVisitAll(transform, result); });\n }\n return new TemplateParseResult(result, 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 * @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.FATAL);\n errors.push(error);\n }\n }); });\n };\n /** @nocollapse */\n TemplateParser.ctorParameters = function () { return [\n { type: Parser, },\n { type: ElementSchemaRegistry, },\n { type: I18NHtmlParser, },\n { type: Console, },\n { type: Array, decorators: [{ type: Optional }, { type: Inject, args: [TEMPLATE_TRANSFORMS,] },] },\n ]; };\n TemplateParser = __decorate([\n CompilerInjectable(), \n __metadata('design:paramtypes', [Parser, ElementSchemaRegistry, I18NHtmlParser, Console, Array])\n ], TemplateParser);\n return TemplateParser;\n}());\nfunction TemplateParser_tsickle_Closure_declarations() {\n /**\n * @nocollapse\n * @type {?}\n */\n TemplateParser.ctorParameters;\n /** @type {?} */\n TemplateParser.prototype._exprParser;\n /** @type {?} */\n TemplateParser.prototype._schemaRegistry;\n /** @type {?} */\n TemplateParser.prototype._htmlParser;\n /** @type {?} */\n TemplateParser.prototype._console;\n /** @type {?} */\n TemplateParser.prototype.transforms;\n}\nvar TemplateParseVisitor = (function () {\n /**\n * @param {?} providerViewContext\n * @param {?} directives\n * @param {?} _bindingParser\n * @param {?} _schemaRegistry\n * @param {?} _schemas\n * @param {?} _targetErrors\n */\n function TemplateParseVisitor(providerViewContext, directives, _bindingParser, _schemaRegistry, _schemas, _targetErrors) {\n var _this = this;\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 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 if (isPresent(expr)) {\n return new BoundTextAst(expr, ngContentIndex, text.sourceSpan);\n }\n else {\n return new TextAst(text.value, ngContentIndex, text.sourceSpan);\n }\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 {?} */ nodeName = element.name;\n var /** @type {?} */ preparsedElement = preparseElement(element);\n if (preparsedElement.type === PreparsedElementType.SCRIPT ||\n preparsedElement.type === PreparsedElementType.STYLE) {\n // Skipping