.\n * For example, matching the above expression to\n * \n * http://www.ics.uci.edu/pub/ietf/uri/#Related\n *
\n * results in the following subexpression matches:\n * \n * $1 = http:\n * $2 = http\n * $3 = //www.ics.uci.edu\n * $4 = www.ics.uci.edu\n * $5 = /pub/ietf/uri/\n * $6 = \n * $7 = \n * $8 = #Related\n * $9 = Related\n *
\n * where indicates that the component is not present, as is the\n * case for the query component in the above example. Therefore, we can\n * determine the value of the five components as\n * \n * scheme = $2\n * authority = $4\n * path = $5\n * query = $7\n * fragment = $9\n *
\n *\n * The regular expression has been modified slightly to expose the\n * userInfo, domain, and port separately from the authority.\n * The modified version yields\n * \n * $1 = http scheme\n * $2 = userInfo -\\\n * $3 = www.ics.uci.edu domain | authority\n * $4 = port -/\n * $5 = /pub/ietf/uri/ path\n * $6 = query without ?\n * $7 = Related fragment without #\n *
\n * @type {!RegExp}\n * @internal\n */\nvar /** @type {?} */ _splitRe = new RegExp('^' +\n '(?:' +\n '([^:/?#.]+)' +\n // used by other URL parts such as :,\n // ?, /, #, and .\n ':)?' +\n '(?://' +\n '(?:([^/?#]*)@)?' +\n '([\\\\w\\\\d\\\\-\\\\u0100-\\\\uffff.%]*)' +\n // digits, dashes, dots, percent\n // escapes, and unicode characters.\n '(?::([0-9]+))?' +\n ')?' +\n '([^?#]+)?' +\n '(?:\\\\?([^#]*))?' +\n '(?:#(.*))?' +\n '$');\nvar _ComponentIndex = {};\n_ComponentIndex.Scheme = 1;\n_ComponentIndex.UserInfo = 2;\n_ComponentIndex.Domain = 3;\n_ComponentIndex.Port = 4;\n_ComponentIndex.Path = 5;\n_ComponentIndex.QueryData = 6;\n_ComponentIndex.Fragment = 7;\n_ComponentIndex[_ComponentIndex.Scheme] = \"Scheme\";\n_ComponentIndex[_ComponentIndex.UserInfo] = \"UserInfo\";\n_ComponentIndex[_ComponentIndex.Domain] = \"Domain\";\n_ComponentIndex[_ComponentIndex.Port] = \"Port\";\n_ComponentIndex[_ComponentIndex.Path] = \"Path\";\n_ComponentIndex[_ComponentIndex.QueryData] = \"QueryData\";\n_ComponentIndex[_ComponentIndex.Fragment] = \"Fragment\";\n/**\n * Splits a URI into its component parts.\n *\n * Each component can be accessed via the component indices; for example:\n * \n * goog.uri.utils.split(someStr)[goog.uri.utils.CompontentIndex.QUERY_DATA];\n *
\n *\n * @param {?} uri The URI string to examine.\n * @return {?} Each component still URI-encoded.\n * Each component that is present will contain the encoded value, whereas\n * components that are not present will be undefined or empty, depending\n * on the browser's regular expression implementation. Never null, since\n * arbitrary strings may still look like path names.\n */\nfunction _split(uri) {\n return uri.match(_splitRe);\n}\n/**\n * Removes dot segments in given path component, as described in\n * RFC 3986, section 5.2.4.\n *\n * @param {?} path A non-empty path component.\n * @return {?} Path component with removed dot segments.\n */\nfunction _removeDotSegments(path) {\n if (path == '/')\n return '/';\n var /** @type {?} */ leadingSlash = path[0] == '/' ? '/' : '';\n var /** @type {?} */ trailingSlash = path[path.length - 1] === '/' ? '/' : '';\n var /** @type {?} */ segments = path.split('/');\n var /** @type {?} */ out = [];\n var /** @type {?} */ up = 0;\n for (var /** @type {?} */ pos = 0; pos < segments.length; pos++) {\n var /** @type {?} */ segment = segments[pos];\n switch (segment) {\n case '':\n case '.':\n break;\n case '..':\n if (out.length > 0) {\n out.pop();\n }\n else {\n up++;\n }\n break;\n default:\n out.push(segment);\n }\n }\n if (leadingSlash == '') {\n while (up-- > 0) {\n out.unshift('..');\n }\n if (out.length === 0)\n out.push('.');\n }\n return leadingSlash + out.join('/') + trailingSlash;\n}\n/**\n * Takes an array of the parts from split and canonicalizes the path part\n * and then joins all the parts.\n * @param {?} parts\n * @return {?}\n */\nfunction _joinAndCanonicalizePath(parts) {\n var /** @type {?} */ path = parts[_ComponentIndex.Path];\n path = isBlank(path) ? '' : _removeDotSegments(path);\n parts[_ComponentIndex.Path] = path;\n return _buildFromEncodedParts(parts[_ComponentIndex.Scheme], parts[_ComponentIndex.UserInfo], parts[_ComponentIndex.Domain], parts[_ComponentIndex.Port], path, parts[_ComponentIndex.QueryData], parts[_ComponentIndex.Fragment]);\n}\n/**\n * Resolves a URL.\n * @param {?} base The URL acting as the base URL.\n * @param {?} url\n * @return {?}\n */\nfunction _resolveUrl(base, url) {\n var /** @type {?} */ parts = _split(encodeURI(url));\n var /** @type {?} */ baseParts = _split(base);\n if (isPresent(parts[_ComponentIndex.Scheme])) {\n return _joinAndCanonicalizePath(parts);\n }\n else {\n parts[_ComponentIndex.Scheme] = baseParts[_ComponentIndex.Scheme];\n }\n for (var /** @type {?} */ i = _ComponentIndex.Scheme; i <= _ComponentIndex.Port; i++) {\n if (isBlank(parts[i])) {\n parts[i] = baseParts[i];\n }\n }\n if (parts[_ComponentIndex.Path][0] == '/') {\n return _joinAndCanonicalizePath(parts);\n }\n var /** @type {?} */ path = baseParts[_ComponentIndex.Path];\n if (isBlank(path))\n path = '/';\n var /** @type {?} */ index = path.lastIndexOf('/');\n path = path.substring(0, index + 1) + parts[_ComponentIndex.Path];\n parts[_ComponentIndex.Path] = path;\n return _joinAndCanonicalizePath(parts);\n}\n//# sourceMappingURL=url_resolver.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/url_resolver.js\n// module id = 61\n// module chunks = 3","/**\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 { createDiTokenExpression } from '../compiler_util/identifier_util';\nimport * as o from '../output/output_ast';\nimport { ViewType } from '../private_import_core';\n/**\n * @param {?} property\n * @param {?} callingView\n * @param {?} definedView\n * @return {?}\n */\nexport function getPropertyInView(property, callingView, definedView) {\n if (callingView === definedView) {\n return property;\n }\n else {\n var /** @type {?} */ viewProp = o.THIS_EXPR;\n var /** @type {?} */ currView = callingView;\n while (currView !== definedView && currView.declarationElement.view) {\n currView = currView.declarationElement.view;\n viewProp = viewProp.prop('parentView');\n }\n if (currView !== definedView) {\n throw new Error(\"Internal error: Could not calculate a property in a parent view: \" + property);\n }\n return property.visitExpression(new _ReplaceViewTransformer(viewProp, definedView), null);\n }\n}\nvar _ReplaceViewTransformer = (function (_super) {\n __extends(_ReplaceViewTransformer, _super);\n /**\n * @param {?} _viewExpr\n * @param {?} _view\n */\n function _ReplaceViewTransformer(_viewExpr, _view) {\n _super.call(this);\n this._viewExpr = _viewExpr;\n this._view = _view;\n }\n /**\n * @param {?} expr\n * @return {?}\n */\n _ReplaceViewTransformer.prototype._isThis = function (expr) {\n return expr instanceof o.ReadVarExpr && expr.builtin === o.BuiltinVar.This;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n _ReplaceViewTransformer.prototype.visitReadVarExpr = function (ast, context) {\n return this._isThis(ast) ? this._viewExpr : ast;\n };\n /**\n * @param {?} ast\n * @param {?} context\n * @return {?}\n */\n _ReplaceViewTransformer.prototype.visitReadPropExpr = function (ast, context) {\n if (this._isThis(ast.receiver)) {\n // Note: Don't cast for members of the AppView base class...\n if (this._view.fields.some(function (field) { return field.name == ast.name; }) ||\n this._view.getters.some(function (field) { return field.name == ast.name; })) {\n return this._viewExpr.cast(this._view.classType).prop(ast.name);\n }\n }\n return _super.prototype.visitReadPropExpr.call(this, ast, context);\n };\n return _ReplaceViewTransformer;\n}(o.ExpressionTransformer));\nfunction _ReplaceViewTransformer_tsickle_Closure_declarations() {\n /** @type {?} */\n _ReplaceViewTransformer.prototype._viewExpr;\n /** @type {?} */\n _ReplaceViewTransformer.prototype._view;\n}\n/**\n * @param {?} view\n * @param {?} token\n * @param {?} optional\n * @return {?}\n */\nexport function injectFromViewParentInjector(view, token, optional) {\n var /** @type {?} */ viewExpr;\n if (view.viewType === ViewType.HOST) {\n viewExpr = o.THIS_EXPR;\n }\n else {\n viewExpr = o.THIS_EXPR.prop('parentView');\n }\n var /** @type {?} */ args = [createDiTokenExpression(token), o.THIS_EXPR.prop('parentIndex')];\n if (optional) {\n args.push(o.NULL_EXPR);\n }\n return viewExpr.callMethod('injectorGet', args);\n}\n/**\n * @param {?} component\n * @param {?} embeddedTemplateIndex\n * @return {?}\n */\nexport function getViewClassName(component, embeddedTemplateIndex) {\n return \"View_\" + identifierName(component.type) + embeddedTemplateIndex;\n}\n/**\n * @param {?} elementIndex\n * @return {?}\n */\nexport function getHandleEventMethodName(elementIndex) {\n return \"handleEvent_\" + elementIndex;\n}\n//# sourceMappingURL=util.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/compiler/src/view_compiler/util.js\n// module id = 62\n// module chunks = 3","/**\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 { AbstractControlDirective } from './abstract_control_directive';\n/**\n * @return {?}\n */\nfunction unimplemented() {\n throw new Error('unimplemented');\n}\n/**\n * A base class that all control directive extend.\n * It binds a {\\@link FormControl} object to a DOM element.\n *\n * Used internally by Angular forms.\n *\n * \\@stable\n * @abstract\n */\nexport var NgControl = (function (_super) {\n __extends(NgControl, _super);\n function NgControl() {\n _super.apply(this, arguments);\n /** @internal */\n this._parent = null;\n this.name = null;\n this.valueAccessor = null;\n /** @internal */\n this._rawValidators = [];\n /** @internal */\n this._rawAsyncValidators = [];\n }\n Object.defineProperty(NgControl.prototype, \"validator\", {\n /**\n * @return {?}\n */\n get: function () { return (unimplemented()); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(NgControl.prototype, \"asyncValidator\", {\n /**\n * @return {?}\n */\n get: function () { return (unimplemented()); },\n enumerable: true,\n configurable: true\n });\n /**\n * @abstract\n * @param {?} newValue\n * @return {?}\n */\n NgControl.prototype.viewToModelUpdate = function (newValue) { };\n return NgControl;\n}(AbstractControlDirective));\nfunction NgControl_tsickle_Closure_declarations() {\n /**\n * \\@internal\n * @type {?}\n */\n NgControl.prototype._parent;\n /** @type {?} */\n NgControl.prototype.name;\n /** @type {?} */\n NgControl.prototype.valueAccessor;\n /**\n * \\@internal\n * @type {?}\n */\n NgControl.prototype._rawValidators;\n /**\n * \\@internal\n * @type {?}\n */\n NgControl.prototype._rawAsyncValidators;\n}\n//# sourceMappingURL=ng_control.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/forms/src/directives/ng_control.js\n// module id = 63\n// module chunks = 3","/**\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 { PRIMARY_OUTLET } from './shared';\nimport { forEach, shallowEqual } from './utils/collection';\n/**\n * @return {?}\n */\nexport function createEmptyUrlTree() {\n return new UrlTree(new UrlSegmentGroup([], {}), {}, null);\n}\n/**\n * @param {?} container\n * @param {?} containee\n * @param {?} exact\n * @return {?}\n */\nexport function containsTree(container, containee, exact) {\n if (exact) {\n return equalQueryParams(container.queryParams, containee.queryParams) &&\n equalSegmentGroups(container.root, containee.root);\n }\n return containsQueryParams(container.queryParams, containee.queryParams) &&\n containsSegmentGroup(container.root, containee.root);\n}\n/**\n * @param {?} container\n * @param {?} containee\n * @return {?}\n */\nfunction equalQueryParams(container, containee) {\n return shallowEqual(container, containee);\n}\n/**\n * @param {?} container\n * @param {?} containee\n * @return {?}\n */\nfunction equalSegmentGroups(container, containee) {\n if (!equalPath(container.segments, containee.segments))\n return false;\n if (container.numberOfChildren !== containee.numberOfChildren)\n return false;\n for (var c in containee.children) {\n if (!container.children[c])\n return false;\n if (!equalSegmentGroups(container.children[c], containee.children[c]))\n return false;\n }\n return true;\n}\n/**\n * @param {?} container\n * @param {?} containee\n * @return {?}\n */\nfunction containsQueryParams(container, containee) {\n return Object.keys(containee).length <= Object.keys(container).length &&\n Object.keys(containee).every(function (key) { return containee[key] === container[key]; });\n}\n/**\n * @param {?} container\n * @param {?} containee\n * @return {?}\n */\nfunction containsSegmentGroup(container, containee) {\n return containsSegmentGroupHelper(container, containee, containee.segments);\n}\n/**\n * @param {?} container\n * @param {?} containee\n * @param {?} containeePaths\n * @return {?}\n */\nfunction containsSegmentGroupHelper(container, containee, containeePaths) {\n if (container.segments.length > containeePaths.length) {\n var /** @type {?} */ current = container.segments.slice(0, containeePaths.length);\n if (!equalPath(current, containeePaths))\n return false;\n if (containee.hasChildren())\n return false;\n return true;\n }\n else if (container.segments.length === containeePaths.length) {\n if (!equalPath(container.segments, containeePaths))\n return false;\n for (var c in containee.children) {\n if (!container.children[c])\n return false;\n if (!containsSegmentGroup(container.children[c], containee.children[c]))\n return false;\n }\n return true;\n }\n else {\n var /** @type {?} */ current = containeePaths.slice(0, container.segments.length);\n var /** @type {?} */ next = containeePaths.slice(container.segments.length);\n if (!equalPath(container.segments, current))\n return false;\n if (!container.children[PRIMARY_OUTLET])\n return false;\n return containsSegmentGroupHelper(container.children[PRIMARY_OUTLET], containee, next);\n }\n}\n/**\n * \\@whatItDoes Represents the parsed URL.\n *\n * \\@howToUse\n *\n * ```\n * \\@Component({templateUrl:'template.html'})\n * class MyComponent {\n * constructor(router: Router) {\n * const tree: UrlTree =\n * router.parseUrl('/team/33/(user/victor//support:help)?debug=true#fragment');\n * const f = tree.fragment; // return 'fragment'\n * const q = tree.queryParams; // returns {debug: 'true'}\n * const g: UrlSegmentGroup = tree.root.children[PRIMARY_OUTLET];\n * const s: UrlSegment[] = g.segments; // returns 2 segments 'team' and '33'\n * g.children[PRIMARY_OUTLET].segments; // returns 2 segments 'user' and 'victor'\n * g.children['support'].segments; // return 1 segment 'help'\n * }\n * }\n * ```\n *\n * \\@description\n *\n * Since a router state is a tree, and the URL is nothing but a serialized state, the URL is a\n * serialized tree.\n * UrlTree is a data structure that provides a lot of affordances in dealing with URLs\n *\n * \\@stable\n */\nexport var UrlTree = (function () {\n /**\n * \\@internal\n * @param {?} root\n * @param {?} queryParams\n * @param {?} fragment\n */\n function UrlTree(root, queryParams, fragment) {\n this.root = root;\n this.queryParams = queryParams;\n this.fragment = fragment;\n }\n /**\n * \\@docsNotRequired\n * @return {?}\n */\n UrlTree.prototype.toString = function () { return new DefaultUrlSerializer().serialize(this); };\n return UrlTree;\n}());\nfunction UrlTree_tsickle_Closure_declarations() {\n /**\n * The root segment group of the URL tree\n * @type {?}\n */\n UrlTree.prototype.root;\n /**\n * The query params of the URL\n * @type {?}\n */\n UrlTree.prototype.queryParams;\n /**\n * The fragment of the URL\n * @type {?}\n */\n UrlTree.prototype.fragment;\n}\n/**\n * \\@whatItDoes Represents the parsed URL segment group.\n *\n * See {\\@link UrlTree} for more information.\n *\n * \\@stable\n */\nexport var UrlSegmentGroup = (function () {\n /**\n * @param {?} segments\n * @param {?} children\n */\n function UrlSegmentGroup(segments, children) {\n var _this = this;\n this.segments = segments;\n this.children = children;\n /** The parent node in the url tree */\n this.parent = null;\n forEach(children, function (v, k) { return v.parent = _this; });\n }\n /**\n * Wether the segment has child segments\n * @return {?}\n */\n UrlSegmentGroup.prototype.hasChildren = function () { return this.numberOfChildren > 0; };\n Object.defineProperty(UrlSegmentGroup.prototype, \"numberOfChildren\", {\n /**\n * Number of child segments\n * @return {?}\n */\n get: function () { return Object.keys(this.children).length; },\n enumerable: true,\n configurable: true\n });\n /**\n * \\@docsNotRequired\n * @return {?}\n */\n UrlSegmentGroup.prototype.toString = function () { return serializePaths(this); };\n return UrlSegmentGroup;\n}());\nfunction UrlSegmentGroup_tsickle_Closure_declarations() {\n /**\n * \\@internal\n * @type {?}\n */\n UrlSegmentGroup.prototype._sourceSegment;\n /**\n * \\@internal\n * @type {?}\n */\n UrlSegmentGroup.prototype._segmentIndexShift;\n /**\n * The parent node in the url tree\n * @type {?}\n */\n UrlSegmentGroup.prototype.parent;\n /**\n * The URL segments of this group. See {\\@link UrlSegment} for more information\n * @type {?}\n */\n UrlSegmentGroup.prototype.segments;\n /**\n * The list of children of this group\n * @type {?}\n */\n UrlSegmentGroup.prototype.children;\n}\n/**\n * \\@whatItDoes Represents a single URL segment.\n *\n * \\@howToUse\n *\n * ```\n * \\@Component({templateUrl:'template.html'})\n * class MyComponent {\n * constructor(router: Router) {\n * const tree: UrlTree = router.parseUrl('/team;id=33');\n * const g: UrlSegmentGroup = tree.root.children[PRIMARY_OUTLET];\n * const s: UrlSegment[] = g.segments;\n * s[0].path; // returns 'team'\n * s[0].parameters; // returns {id: 33}\n * }\n * }\n * ```\n *\n * \\@description\n *\n * A UrlSegment is a part of a URL between the two slashes. It contains a path and the matrix\n * parameters associated with the segment.\n *\n * \\@stable\n */\nexport var UrlSegment = (function () {\n /**\n * @param {?} path\n * @param {?} parameters\n */\n function UrlSegment(path, parameters) {\n this.path = path;\n this.parameters = parameters;\n }\n /**\n * \\@docsNotRequired\n * @return {?}\n */\n UrlSegment.prototype.toString = function () { return serializePath(this); };\n return UrlSegment;\n}());\nfunction UrlSegment_tsickle_Closure_declarations() {\n /**\n * The path part of a URL segment\n * @type {?}\n */\n UrlSegment.prototype.path;\n /**\n * The matrix parameters associated with a segment\n * @type {?}\n */\n UrlSegment.prototype.parameters;\n}\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nexport function equalSegments(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].path !== b[i].path)\n return false;\n if (!shallowEqual(a[i].parameters, b[i].parameters))\n return false;\n }\n return true;\n}\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nexport function equalPath(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].path !== b[i].path)\n return false;\n }\n return true;\n}\n/**\n * @param {?} segment\n * @param {?} fn\n * @return {?}\n */\nexport function mapChildrenIntoArray(segment, fn) {\n var /** @type {?} */ res = [];\n forEach(segment.children, function (child, childOutlet) {\n if (childOutlet === PRIMARY_OUTLET) {\n res = res.concat(fn(child, childOutlet));\n }\n });\n forEach(segment.children, function (child, childOutlet) {\n if (childOutlet !== PRIMARY_OUTLET) {\n res = res.concat(fn(child, childOutlet));\n }\n });\n return res;\n}\n/**\n * \\@whatItDoes Serializes and deserializes a URL string into a URL tree.\n *\n * \\@description The url serialization strategy is customizable. You can\n * make all URLs case insensitive by providing a custom UrlSerializer.\n *\n * See {\\@link DefaultUrlSerializer} for an example of a URL serializer.\n *\n * \\@stable\n * @abstract\n */\nexport var UrlSerializer = (function () {\n function UrlSerializer() {\n }\n /**\n * Parse a url into a {\\@link UrlTree}\n * @abstract\n * @param {?} url\n * @return {?}\n */\n UrlSerializer.prototype.parse = function (url) { };\n /**\n * Converts a {\\@link UrlTree} into a url\n * @abstract\n * @param {?} tree\n * @return {?}\n */\n UrlSerializer.prototype.serialize = function (tree) { };\n return UrlSerializer;\n}());\n/**\n * \\@whatItDoes A default implementation of the {\\@link UrlSerializer}.\n *\n * \\@description\n *\n * Example URLs:\n *\n * ```\n * /inbox/33(popup:compose)\n * /inbox/33;open=true/messages/44\n * ```\n *\n * DefaultUrlSerializer uses parentheses to serialize secondary segments (e.g., popup:compose), the\n * colon syntax to specify the outlet, and the ';parameter=value' syntax (e.g., open=true) to\n * specify route specific parameters.\n *\n * \\@stable\n */\nexport var DefaultUrlSerializer = (function () {\n function DefaultUrlSerializer() {\n }\n /**\n * Parses a url into a {\\@link UrlTree}\n * @param {?} url\n * @return {?}\n */\n DefaultUrlSerializer.prototype.parse = function (url) {\n var /** @type {?} */ p = new UrlParser(url);\n return new UrlTree(p.parseRootSegment(), p.parseQueryParams(), p.parseFragment());\n };\n /**\n * Converts a {\\@link UrlTree} into a url\n * @param {?} tree\n * @return {?}\n */\n DefaultUrlSerializer.prototype.serialize = function (tree) {\n var /** @type {?} */ segment = \"/\" + serializeSegment(tree.root, true);\n var /** @type {?} */ query = serializeQueryParams(tree.queryParams);\n var /** @type {?} */ fragment = tree.fragment !== null && tree.fragment !== undefined ? \"#\" + encodeURI(tree.fragment) : '';\n return \"\" + segment + query + fragment;\n };\n return DefaultUrlSerializer;\n}());\n/**\n * @param {?} segment\n * @return {?}\n */\nexport function serializePaths(segment) {\n return segment.segments.map(function (p) { return serializePath(p); }).join('/');\n}\n/**\n * @param {?} segment\n * @param {?} root\n * @return {?}\n */\nfunction serializeSegment(segment, root) {\n if (segment.hasChildren() && root) {\n var /** @type {?} */ primary = segment.children[PRIMARY_OUTLET] ?\n serializeSegment(segment.children[PRIMARY_OUTLET], false) :\n '';\n var /** @type {?} */ children_1 = [];\n forEach(segment.children, function (v, k) {\n if (k !== PRIMARY_OUTLET) {\n children_1.push(k + \":\" + serializeSegment(v, false));\n }\n });\n if (children_1.length > 0) {\n return primary + \"(\" + children_1.join('//') + \")\";\n }\n else {\n return \"\" + primary;\n }\n }\n else if (segment.hasChildren() && !root) {\n var /** @type {?} */ children = mapChildrenIntoArray(segment, function (v, k) {\n if (k === PRIMARY_OUTLET) {\n return [serializeSegment(segment.children[PRIMARY_OUTLET], false)];\n }\n else {\n return [(k + \":\" + serializeSegment(v, false))];\n }\n });\n return serializePaths(segment) + \"/(\" + children.join('//') + \")\";\n }\n else {\n return serializePaths(segment);\n }\n}\n/**\n * @param {?} s\n * @return {?}\n */\nexport function encode(s) {\n return encodeURIComponent(s);\n}\n/**\n * @param {?} s\n * @return {?}\n */\nexport function decode(s) {\n return decodeURIComponent(s);\n}\n/**\n * @param {?} path\n * @return {?}\n */\nexport function serializePath(path) {\n return \"\" + encode(path.path) + serializeParams(path.parameters);\n}\n/**\n * @param {?} params\n * @return {?}\n */\nfunction serializeParams(params) {\n return pairs(params).map(function (p) { return (\";\" + encode(p.first) + \"=\" + encode(p.second)); }).join('');\n}\n/**\n * @param {?} params\n * @return {?}\n */\nfunction serializeQueryParams(params) {\n var /** @type {?} */ strParams = Object.keys(params).map(function (name) {\n var /** @type {?} */ value = params[name];\n return Array.isArray(value) ? value.map(function (v) { return (encode(name) + \"=\" + encode(v)); }).join('&') :\n encode(name) + \"=\" + encode(value);\n });\n return strParams.length ? \"?\" + strParams.join(\"&\") : '';\n}\nvar Pair = (function () {\n /**\n * @param {?} first\n * @param {?} second\n */\n function Pair(first, second) {\n this.first = first;\n this.second = second;\n }\n return Pair;\n}());\nfunction Pair_tsickle_Closure_declarations() {\n /** @type {?} */\n Pair.prototype.first;\n /** @type {?} */\n Pair.prototype.second;\n}\n/**\n * @param {?} obj\n * @return {?}\n */\nfunction pairs(obj) {\n var /** @type {?} */ res = [];\n for (var prop in obj) {\n if (obj.hasOwnProperty(prop)) {\n res.push(new Pair(prop, obj[prop]));\n }\n }\n return res;\n}\nvar /** @type {?} */ SEGMENT_RE = /^[^\\/()?;=&#]+/;\n/**\n * @param {?} str\n * @return {?}\n */\nfunction matchSegments(str) {\n SEGMENT_RE.lastIndex = 0;\n var /** @type {?} */ match = str.match(SEGMENT_RE);\n return match ? match[0] : '';\n}\nvar /** @type {?} */ QUERY_PARAM_RE = /^[^=?&#]+/;\n/**\n * @param {?} str\n * @return {?}\n */\nfunction matchQueryParams(str) {\n QUERY_PARAM_RE.lastIndex = 0;\n var /** @type {?} */ match = str.match(SEGMENT_RE);\n return match ? match[0] : '';\n}\nvar /** @type {?} */ QUERY_PARAM_VALUE_RE = /^[^?&#]+/;\n/**\n * @param {?} str\n * @return {?}\n */\nfunction matchUrlQueryParamValue(str) {\n QUERY_PARAM_VALUE_RE.lastIndex = 0;\n var /** @type {?} */ match = str.match(QUERY_PARAM_VALUE_RE);\n return match ? match[0] : '';\n}\nvar UrlParser = (function () {\n /**\n * @param {?} url\n */\n function UrlParser(url) {\n this.url = url;\n this.remaining = url;\n }\n /**\n * @param {?} str\n * @return {?}\n */\n UrlParser.prototype.peekStartsWith = function (str) { return this.remaining.startsWith(str); };\n /**\n * @param {?} str\n * @return {?}\n */\n UrlParser.prototype.capture = function (str) {\n if (!this.remaining.startsWith(str)) {\n throw new Error(\"Expected \\\"\" + str + \"\\\".\");\n }\n this.remaining = this.remaining.substring(str.length);\n };\n /**\n * @return {?}\n */\n UrlParser.prototype.parseRootSegment = function () {\n if (this.remaining.startsWith('/')) {\n this.capture('/');\n }\n if (this.remaining === '' || this.remaining.startsWith('?') || this.remaining.startsWith('#')) {\n return new UrlSegmentGroup([], {});\n }\n return new UrlSegmentGroup([], this.parseChildren());\n };\n /**\n * @return {?}\n */\n UrlParser.prototype.parseChildren = function () {\n if (this.remaining.length == 0) {\n return {};\n }\n if (this.peekStartsWith('/')) {\n this.capture('/');\n }\n var /** @type {?} */ paths = [];\n if (!this.peekStartsWith('(')) {\n paths.push(this.parseSegments());\n }\n while (this.peekStartsWith('/') && !this.peekStartsWith('//') && !this.peekStartsWith('/(')) {\n this.capture('/');\n paths.push(this.parseSegments());\n }\n var /** @type {?} */ children = {};\n if (this.peekStartsWith('/(')) {\n this.capture('/');\n children = this.parseParens(true);\n }\n var /** @type {?} */ res = {};\n if (this.peekStartsWith('(')) {\n res = this.parseParens(false);\n }\n if (paths.length > 0 || Object.keys(children).length > 0) {\n res[PRIMARY_OUTLET] = new UrlSegmentGroup(paths, children);\n }\n return res;\n };\n /**\n * @return {?}\n */\n UrlParser.prototype.parseSegments = function () {\n var /** @type {?} */ path = matchSegments(this.remaining);\n if (path === '' && this.peekStartsWith(';')) {\n throw new Error(\"Empty path url segment cannot have parameters: '\" + this.remaining + \"'.\");\n }\n this.capture(path);\n var /** @type {?} */ matrixParams = {};\n if (this.peekStartsWith(';')) {\n matrixParams = this.parseMatrixParams();\n }\n return new UrlSegment(decode(path), matrixParams);\n };\n /**\n * @return {?}\n */\n UrlParser.prototype.parseQueryParams = function () {\n var /** @type {?} */ params = {};\n if (this.peekStartsWith('?')) {\n this.capture('?');\n this.parseQueryParam(params);\n while (this.remaining.length > 0 && this.peekStartsWith('&')) {\n this.capture('&');\n this.parseQueryParam(params);\n }\n }\n return params;\n };\n /**\n * @return {?}\n */\n UrlParser.prototype.parseFragment = function () {\n if (this.peekStartsWith('#')) {\n return decodeURI(this.remaining.substring(1));\n }\n return null;\n };\n /**\n * @return {?}\n */\n UrlParser.prototype.parseMatrixParams = function () {\n var /** @type {?} */ params = {};\n while (this.remaining.length > 0 && this.peekStartsWith(';')) {\n this.capture(';');\n this.parseParam(params);\n }\n return params;\n };\n /**\n * @param {?} params\n * @return {?}\n */\n UrlParser.prototype.parseParam = function (params) {\n var /** @type {?} */ key = matchSegments(this.remaining);\n if (!key) {\n return;\n }\n this.capture(key);\n var /** @type {?} */ value = '';\n if (this.peekStartsWith('=')) {\n this.capture('=');\n var /** @type {?} */ valueMatch = matchSegments(this.remaining);\n if (valueMatch) {\n value = valueMatch;\n this.capture(value);\n }\n }\n params[decode(key)] = decode(value);\n };\n /**\n * @param {?} params\n * @return {?}\n */\n UrlParser.prototype.parseQueryParam = function (params) {\n var /** @type {?} */ key = matchQueryParams(this.remaining);\n if (!key) {\n return;\n }\n this.capture(key);\n var /** @type {?} */ value = '';\n if (this.peekStartsWith('=')) {\n this.capture('=');\n var /** @type {?} */ valueMatch = matchUrlQueryParamValue(this.remaining);\n if (valueMatch) {\n value = valueMatch;\n this.capture(value);\n }\n }\n var /** @type {?} */ decodedKey = decode(key);\n var /** @type {?} */ decodedVal = decode(value);\n if (params.hasOwnProperty(decodedKey)) {\n // Append to existing values\n var /** @type {?} */ currentVal = params[decodedKey];\n if (!Array.isArray(currentVal)) {\n currentVal = [currentVal];\n params[decodedKey] = currentVal;\n }\n currentVal.push(decodedVal);\n }\n else {\n // Create a new value\n params[decodedKey] = decodedVal;\n }\n };\n /**\n * @param {?} allowPrimary\n * @return {?}\n */\n UrlParser.prototype.parseParens = function (allowPrimary) {\n var /** @type {?} */ segments = {};\n this.capture('(');\n while (!this.peekStartsWith(')') && this.remaining.length > 0) {\n var /** @type {?} */ path = matchSegments(this.remaining);\n var /** @type {?} */ next = this.remaining[path.length];\n // if is is not one of these characters, then the segment was unescaped\n // or the group was not closed\n if (next !== '/' && next !== ')' && next !== ';') {\n throw new Error(\"Cannot parse url '\" + this.url + \"'\");\n }\n var /** @type {?} */ outletName = void 0;\n if (path.indexOf(':') > -1) {\n outletName = path.substr(0, path.indexOf(':'));\n this.capture(outletName);\n this.capture(':');\n }\n else if (allowPrimary) {\n outletName = PRIMARY_OUTLET;\n }\n var /** @type {?} */ children = this.parseChildren();\n segments[outletName] = Object.keys(children).length === 1 ? children[PRIMARY_OUTLET] :\n new UrlSegmentGroup([], children);\n if (this.peekStartsWith('//')) {\n this.capture('//');\n }\n }\n this.capture(')');\n return segments;\n };\n return UrlParser;\n}());\nfunction UrlParser_tsickle_Closure_declarations() {\n /** @type {?} */\n UrlParser.prototype.remaining;\n /** @type {?} */\n UrlParser.prototype.url;\n}\n//# sourceMappingURL=url_tree.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/router/src/url_tree.js\n// module id = 64\n// module chunks = 3","\"use strict\";\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 Observable_1 = require('./Observable');\nvar Subscriber_1 = require('./Subscriber');\nvar Subscription_1 = require('./Subscription');\nvar ObjectUnsubscribedError_1 = require('./util/ObjectUnsubscribedError');\nvar SubjectSubscription_1 = require('./SubjectSubscription');\nvar rxSubscriber_1 = require('./symbol/rxSubscriber');\n/**\n * @class SubjectSubscriber\n */\nvar SubjectSubscriber = (function (_super) {\n __extends(SubjectSubscriber, _super);\n function SubjectSubscriber(destination) {\n _super.call(this, destination);\n this.destination = destination;\n }\n return SubjectSubscriber;\n}(Subscriber_1.Subscriber));\nexports.SubjectSubscriber = SubjectSubscriber;\n/**\n * @class Subject\n */\nvar Subject = (function (_super) {\n __extends(Subject, _super);\n function Subject() {\n _super.call(this);\n this.observers = [];\n this.closed = false;\n this.isStopped = false;\n this.hasError = false;\n this.thrownError = null;\n }\n Subject.prototype[rxSubscriber_1.$$rxSubscriber] = function () {\n return new SubjectSubscriber(this);\n };\n Subject.prototype.lift = function (operator) {\n var subject = new AnonymousSubject(this, this);\n subject.operator = operator;\n return subject;\n };\n Subject.prototype.next = function (value) {\n if (this.closed) {\n throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n }\n if (!this.isStopped) {\n var observers = this.observers;\n var len = observers.length;\n var copy = observers.slice();\n for (var i = 0; i < len; i++) {\n copy[i].next(value);\n }\n }\n };\n Subject.prototype.error = function (err) {\n if (this.closed) {\n throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n }\n this.hasError = true;\n this.thrownError = err;\n this.isStopped = true;\n var observers = this.observers;\n var len = observers.length;\n var copy = observers.slice();\n for (var i = 0; i < len; i++) {\n copy[i].error(err);\n }\n this.observers.length = 0;\n };\n Subject.prototype.complete = function () {\n if (this.closed) {\n throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n }\n this.isStopped = true;\n var observers = this.observers;\n var len = observers.length;\n var copy = observers.slice();\n for (var i = 0; i < len; i++) {\n copy[i].complete();\n }\n this.observers.length = 0;\n };\n Subject.prototype.unsubscribe = function () {\n this.isStopped = true;\n this.closed = true;\n this.observers = null;\n };\n Subject.prototype._trySubscribe = function (subscriber) {\n if (this.closed) {\n throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n }\n else {\n return _super.prototype._trySubscribe.call(this, subscriber);\n }\n };\n Subject.prototype._subscribe = function (subscriber) {\n if (this.closed) {\n throw new ObjectUnsubscribedError_1.ObjectUnsubscribedError();\n }\n else if (this.hasError) {\n subscriber.error(this.thrownError);\n return Subscription_1.Subscription.EMPTY;\n }\n else if (this.isStopped) {\n subscriber.complete();\n return Subscription_1.Subscription.EMPTY;\n }\n else {\n this.observers.push(subscriber);\n return new SubjectSubscription_1.SubjectSubscription(this, subscriber);\n }\n };\n Subject.prototype.asObservable = function () {\n var observable = new Observable_1.Observable();\n observable.source = this;\n return observable;\n };\n Subject.create = function (destination, source) {\n return new AnonymousSubject(destination, source);\n };\n return Subject;\n}(Observable_1.Observable));\nexports.Subject = Subject;\n/**\n * @class AnonymousSubject\n */\nvar AnonymousSubject = (function (_super) {\n __extends(AnonymousSubject, _super);\n function AnonymousSubject(destination, source) {\n _super.call(this);\n this.destination = destination;\n this.source = source;\n }\n AnonymousSubject.prototype.next = function (value) {\n var destination = this.destination;\n if (destination && destination.next) {\n destination.next(value);\n }\n };\n AnonymousSubject.prototype.error = function (err) {\n var destination = this.destination;\n if (destination && destination.error) {\n this.destination.error(err);\n }\n };\n AnonymousSubject.prototype.complete = function () {\n var destination = this.destination;\n if (destination && destination.complete) {\n this.destination.complete();\n }\n };\n AnonymousSubject.prototype._subscribe = function (subscriber) {\n var source = this.source;\n if (source) {\n return this.source.subscribe(subscriber);\n }\n else {\n return Subscription_1.Subscription.EMPTY;\n }\n };\n return AnonymousSubject;\n}(Subject));\nexports.AnonymousSubject = AnonymousSubject;\n//# sourceMappingURL=Subject.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/rxjs/Subject.js\n// module id = 69\n// module chunks = 3","\"use strict\";\nvar ArrayObservable_1 = require('./ArrayObservable');\nexports.of = ArrayObservable_1.ArrayObservable.of;\n//# sourceMappingURL=of.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/rxjs/observable/of.js\n// module id = 70\n// module chunks = 3","/**\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 = 71\n// module chunks = 3","/**\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 (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 * \\@internal\n * @param {?} parent\n * @param {?} container\n * @param {?} node\n * @return {?}\n */\n _TreeBuilder.prototype._insertBeforeContainer = function (parent, container, node) {\n if (!container) {\n this._addToParent(node);\n this._elementStack.push(node);\n }\n else {\n if (parent) {\n // replace the container with the new node in the children\n var /** @type {?} */ index = parent.children.indexOf(container);\n parent.children[index] = node;\n }\n else {\n this._rootNodes.push(node);\n }\n node.children.push(container);\n this._elementStack.splice(this._elementStack.indexOf(container), 0, node);\n }\n };\n /**\n * @param {?} prefix\n * @param {?} localName\n * @param {?} parentElement\n * @return {?}\n */\n _TreeBuilder.prototype._getElementFullName = function (prefix, localName, parentElement) {\n if (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 = 72\n// module chunks = 3","/**\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 { makeDecorator, makeParamDecorator } from '../util/decorators';\n/**\n * Inject decorator and metadata.\n *\n * @stable\n * @Annotation\n */\nexport var /** @type {?} */ Inject = makeParamDecorator('Inject', [['token', undefined]]);\n/**\n * Optional decorator and metadata.\n *\n * @stable\n * @Annotation\n */\nexport var /** @type {?} */ Optional = makeParamDecorator('Optional', []);\n/**\n * Injectable decorator and metadata.\n *\n * @stable\n * @Annotation\n */\nexport var /** @type {?} */ Injectable = (makeDecorator('Injectable', []));\n/**\n * Self decorator and metadata.\n *\n * @stable\n * @Annotation\n */\nexport var /** @type {?} */ Self = makeParamDecorator('Self', []);\n/**\n * SkipSelf decorator and metadata.\n *\n * @stable\n * @Annotation\n */\nexport var /** @type {?} */ SkipSelf = makeParamDecorator('SkipSelf', []);\n/**\n * Host decorator and metadata.\n *\n * @stable\n * @Annotation\n */\nexport var /** @type {?} */ Host = makeParamDecorator('Host', []);\n//# sourceMappingURL=metadata.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/core/src/di/metadata.js\n// module id = 73\n// module chunks = 3","/**\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 { global, stringify } from '../facade/lang';\nvar /** @type {?} */ _nextClassId = 0;\nvar /** @type {?} */ Reflect = global.Reflect;\n/**\n * @param {?} annotation\n * @return {?}\n */\nfunction extractAnnotation(annotation) {\n if (typeof annotation === 'function' && annotation.hasOwnProperty('annotation')) {\n // it is a decorator, extract annotation\n annotation = annotation.annotation;\n }\n return annotation;\n}\n/**\n * @param {?} fnOrArray\n * @param {?} key\n * @return {?}\n */\nfunction applyParams(fnOrArray, key) {\n if (fnOrArray === Object || fnOrArray === String || fnOrArray === Function ||\n fnOrArray === Number || fnOrArray === Array) {\n throw new Error(\"Can not use native \" + stringify(fnOrArray) + \" as constructor\");\n }\n if (typeof fnOrArray === 'function') {\n return fnOrArray;\n }\n if (Array.isArray(fnOrArray)) {\n var /** @type {?} */ annotations = fnOrArray;\n var /** @type {?} */ annoLength = annotations.length - 1;\n var /** @type {?} */ fn = fnOrArray[annoLength];\n if (typeof fn !== 'function') {\n throw new Error(\"Last position of Class method array must be Function in key \" + key + \" was '\" + stringify(fn) + \"'\");\n }\n if (annoLength != fn.length) {\n throw new Error(\"Number of annotations (\" + annoLength + \") does not match number of arguments (\" + fn.length + \") in the function: \" + stringify(fn));\n }\n var /** @type {?} */ paramsAnnotations = [];\n for (var /** @type {?} */ i = 0, /** @type {?} */ ii = annotations.length - 1; i < ii; i++) {\n var /** @type {?} */ paramAnnotations = [];\n paramsAnnotations.push(paramAnnotations);\n var /** @type {?} */ annotation = annotations[i];\n if (Array.isArray(annotation)) {\n for (var /** @type {?} */ j = 0; j < annotation.length; j++) {\n paramAnnotations.push(extractAnnotation(annotation[j]));\n }\n }\n else if (typeof annotation === 'function') {\n paramAnnotations.push(extractAnnotation(annotation));\n }\n else {\n paramAnnotations.push(annotation);\n }\n }\n Reflect.defineMetadata('parameters', paramsAnnotations, fn);\n return fn;\n }\n throw new Error(\"Only Function or Array is supported in Class definition for key '\" + key + \"' is '\" + stringify(fnOrArray) + \"'\");\n}\n/**\n * Provides a way for expressing ES6 classes with parameter annotations in ES5.\n *\n * ## Basic Example\n *\n * ```\n * var Greeter = ng.Class({\n * constructor: function(name) {\n * this.name = name;\n * },\n *\n * greet: function() {\n * alert('Hello ' + this.name + '!');\n * }\n * });\n * ```\n *\n * is equivalent to ES6:\n *\n * ```\n * class Greeter {\n * constructor(name) {\n * this.name = name;\n * }\n *\n * greet() {\n * alert('Hello ' + this.name + '!');\n * }\n * }\n * ```\n *\n * or equivalent to ES5:\n *\n * ```\n * var Greeter = function (name) {\n * this.name = name;\n * }\n *\n * Greeter.prototype.greet = function () {\n * alert('Hello ' + this.name + '!');\n * }\n * ```\n *\n * ### Example with parameter annotations\n *\n * ```\n * var MyService = ng.Class({\n * constructor: [String, [new Optional(), Service], function(name, myService) {\n * ...\n * }]\n * });\n * ```\n *\n * is equivalent to ES6:\n *\n * ```\n * class MyService {\n * constructor(name: string, \\@Optional() myService: Service) {\n * ...\n * }\n * }\n * ```\n *\n * ### Example with inheritance\n *\n * ```\n * var Shape = ng.Class({\n * constructor: (color) {\n * this.color = color;\n * }\n * });\n *\n * var Square = ng.Class({\n * extends: Shape,\n * constructor: function(color, size) {\n * Shape.call(this, color);\n * this.size = size;\n * }\n * });\n * ```\n * \\@stable\n * @param {?} clsDef\n * @return {?}\n */\nexport function Class(clsDef) {\n var /** @type {?} */ constructor = applyParams(clsDef.hasOwnProperty('constructor') ? clsDef.constructor : undefined, 'constructor');\n var /** @type {?} */ proto = constructor.prototype;\n if (clsDef.hasOwnProperty('extends')) {\n if (typeof clsDef.extends === 'function') {\n ((constructor)).prototype = proto =\n Object.create(((clsDef.extends)).prototype);\n }\n else {\n throw new Error(\"Class definition 'extends' property must be a constructor function was: \" + stringify(clsDef.extends));\n }\n }\n for (var key in clsDef) {\n if (key !== 'extends' && key !== 'prototype' && clsDef.hasOwnProperty(key)) {\n proto[key] = applyParams(clsDef[key], key);\n }\n }\n if (this && this.annotations instanceof Array) {\n Reflect.defineMetadata('annotations', this.annotations, constructor);\n }\n var /** @type {?} */ constructorName = constructor['name'];\n if (!constructorName || constructorName === 'constructor') {\n ((constructor))['overriddenName'] = \"class\" + _nextClassId++;\n }\n return (constructor);\n}\n/**\n * @param {?} name\n * @param {?} props\n * @param {?=} parentClass\n * @param {?=} chainFn\n * @return {?}\n */\nexport function makeDecorator(name, props, parentClass, chainFn) {\n if (chainFn === void 0) { chainFn = null; }\n var /** @type {?} */ metaCtor = makeMetadataCtor([props]);\n /**\n * @param {?} objOrType\n * @return {?}\n */\n function DecoratorFactory(objOrType) {\n if (!(Reflect && Reflect.getOwnMetadata)) {\n throw 'reflect-metadata shim is required when using class decorators';\n }\n if (this instanceof DecoratorFactory) {\n metaCtor.call(this, objOrType);\n return this;\n }\n var /** @type {?} */ annotationInstance = new ((DecoratorFactory))(objOrType);\n var /** @type {?} */ chainAnnotation = typeof this === 'function' && Array.isArray(this.annotations) ? this.annotations : [];\n chainAnnotation.push(annotationInstance);\n var /** @type {?} */ TypeDecorator = (function TypeDecorator(cls) {\n var /** @type {?} */ annotations = Reflect.getOwnMetadata('annotations', cls) || [];\n annotations.push(annotationInstance);\n Reflect.defineMetadata('annotations', annotations, cls);\n return cls;\n });\n TypeDecorator.annotations = chainAnnotation;\n TypeDecorator.Class = Class;\n if (chainFn)\n chainFn(TypeDecorator);\n return TypeDecorator;\n }\n if (parentClass) {\n DecoratorFactory.prototype = Object.create(parentClass.prototype);\n }\n DecoratorFactory.prototype.toString = function () { return (\"@\" + name); };\n ((DecoratorFactory)).annotationCls = DecoratorFactory;\n return DecoratorFactory;\n}\n/**\n * @param {?} props\n * @return {?}\n */\nfunction makeMetadataCtor(props) {\n return function ctor() {\n var _this = this;\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i - 0] = arguments[_i];\n }\n props.forEach(function (prop, i) {\n var /** @type {?} */ argVal = args[i];\n if (Array.isArray(prop)) {\n // plain parameter\n _this[prop[0]] = argVal === undefined ? prop[1] : argVal;\n }\n else {\n for (var propName in prop) {\n _this[propName] =\n argVal && argVal.hasOwnProperty(propName) ? argVal[propName] : prop[propName];\n }\n }\n });\n };\n}\n/**\n * @param {?} name\n * @param {?} props\n * @param {?=} parentClass\n * @return {?}\n */\nexport function makeParamDecorator(name, props, parentClass) {\n var /** @type {?} */ metaCtor = makeMetadataCtor(props);\n /**\n * @param {...?} args\n * @return {?}\n */\n function ParamDecoratorFactory() {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i - 0] = arguments[_i];\n }\n if (this instanceof ParamDecoratorFactory) {\n metaCtor.apply(this, args);\n return this;\n }\n var /** @type {?} */ annotationInstance = new ((_a = ((ParamDecoratorFactory))).bind.apply(_a, [void 0].concat(args)))();\n ((ParamDecorator)).annotation = annotationInstance;\n return ParamDecorator;\n /**\n * @param {?} cls\n * @param {?} unusedKey\n * @param {?} index\n * @return {?}\n */\n function ParamDecorator(cls, unusedKey, index) {\n var /** @type {?} */ parameters = Reflect.getOwnMetadata('parameters', cls) || [];\n // there might be gaps if some in between parameters do not have annotations.\n // we pad with nulls.\n while (parameters.length <= index) {\n parameters.push(null);\n }\n parameters[index] = parameters[index] || [];\n parameters[index].push(annotationInstance);\n Reflect.defineMetadata('parameters', parameters, cls);\n return cls;\n }\n var _a;\n }\n if (parentClass) {\n ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);\n }\n ParamDecoratorFactory.prototype.toString = function () { return (\"@\" + name); };\n ((ParamDecoratorFactory)).annotationCls = ParamDecoratorFactory;\n return ParamDecoratorFactory;\n}\n/**\n * @param {?} name\n * @param {?} props\n * @param {?=} parentClass\n * @return {?}\n */\nexport function makePropDecorator(name, props, parentClass) {\n var /** @type {?} */ metaCtor = makeMetadataCtor(props);\n /**\n * @param {...?} args\n * @return {?}\n */\n function PropDecoratorFactory() {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i - 0] = arguments[_i];\n }\n if (this instanceof PropDecoratorFactory) {\n metaCtor.apply(this, args);\n return this;\n }\n var /** @type {?} */ decoratorInstance = new ((_a = ((PropDecoratorFactory))).bind.apply(_a, [void 0].concat(args)))();\n return function PropDecorator(target, name) {\n var /** @type {?} */ meta = Reflect.getOwnMetadata('propMetadata', target.constructor) || {};\n meta[name] = meta.hasOwnProperty(name) && meta[name] || [];\n meta[name].unshift(decoratorInstance);\n Reflect.defineMetadata('propMetadata', meta, target.constructor);\n };\n var _a;\n }\n if (parentClass) {\n PropDecoratorFactory.prototype = Object.create(parentClass.prototype);\n }\n PropDecoratorFactory.prototype.toString = function () { return (\"@\" + name); };\n ((PropDecoratorFactory)).annotationCls = PropDecoratorFactory;\n return PropDecoratorFactory;\n}\n//# sourceMappingURL=decorators.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/@angular/core/src/util/decorators.js\n// module id = 74\n// module chunks = 3","/**\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 { Subject } from 'rxjs/Subject';\nexport { Observable } from 'rxjs/Observable';\nexport { Subject } from 'rxjs/Subject';\n/**\n * Use by directives and components to emit custom Events.\n *\n * ### Examples\n *\n * In the following example, `Zippy` alternatively emits `open` and `close` events when its\n * title gets clicked:\n *\n * ```\n * \\@Component({\n * selector: 'zippy',\n * template: `\n * \n *
Toggle
\n *
\n * \n *
\n *