{minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}\n * - `minIntegerDigits` is the minimum number of integer digits to use. Defaults to `1`.\n * - `minFractionDigits` is the minimum number of digits after fraction. Defaults to `0`.\n * - `maxFractionDigits` is the maximum number of digits after fraction. Defaults to `3`.\n *\n * For more information on the acceptable range for each of these numbers and other\n * details see your native internationalization library.\n *\n * WARNING: this pipe uses the Internationalization API which is not yet available in all browsers\n * and may require a polyfill. See [Browser Support](guide/browser-support) for details.\n *\n * \\@usageNotes\n *\n * ### Example\n *\n * {\\@example common/pipes/ts/number_pipe.ts region='DeprecatedNumberPipe'}\n *\n * \\@ngModule CommonModule\n */\nclass DeprecatedDecimalPipe {\n /**\n * @param {?} _locale\n */\n constructor(_locale) {\n this._locale = _locale;\n }\n /**\n * @param {?} value\n * @param {?=} digits\n * @return {?}\n */\n transform(value, digits) {\n return formatNumber$1(DeprecatedDecimalPipe, this._locale, value, NumberFormatStyle.Decimal, digits);\n }\n}\nDeprecatedDecimalPipe.decorators = [\n { type: Pipe, args: [{ name: 'number' },] }\n];\n/** @nocollapse */\nDeprecatedDecimalPipe.ctorParameters = () => [\n { type: String, decorators: [{ type: Inject, args: [LOCALE_ID,] }] }\n];\n/**\n * \\@ngModule CommonModule\n *\n * \\@description\n *\n * Formats a number as percentage according to locale rules.\n *\n * - `digitInfo` See {\\@link DecimalPipe} for detailed description.\n *\n * WARNING: this pipe uses the Internationalization API which is not yet available in all browsers\n * and may require a polyfill. See [Browser Support](guide/browser-support) for details.\n *\n * \\@usageNotes\n *\n * ### Example\n *\n * {\\@example common/pipes/ts/percent_pipe.ts region='DeprecatedPercentPipe'}\n *\n *\n */\nclass DeprecatedPercentPipe {\n /**\n * @param {?} _locale\n */\n constructor(_locale) {\n this._locale = _locale;\n }\n /**\n * @param {?} value\n * @param {?=} digits\n * @return {?}\n */\n transform(value, digits) {\n return formatNumber$1(DeprecatedPercentPipe, this._locale, value, NumberFormatStyle.Percent, digits);\n }\n}\nDeprecatedPercentPipe.decorators = [\n { type: Pipe, args: [{ name: 'percent' },] }\n];\n/** @nocollapse */\nDeprecatedPercentPipe.ctorParameters = () => [\n { type: String, decorators: [{ type: Inject, args: [LOCALE_ID,] }] }\n];\n/**\n * \\@ngModule CommonModule\n * \\@description\n *\n * Formats a number as currency using locale rules.\n *\n * Use `currency` to format a number as currency.\n *\n * - `currencyCode` is the [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code, such\n * as `USD` for the US dollar and `EUR` for the euro.\n * - `symbolDisplay` is a boolean indicating whether to use the currency symbol or code.\n * - `true`: use symbol (e.g. `$`).\n * - `false`(default): use code (e.g. `USD`).\n * - `digitInfo` See {\\@link DecimalPipe} for detailed description.\n *\n * WARNING: this pipe uses the Internationalization API which is not yet available in all browsers\n * and may require a polyfill. See [Browser Support](guide/browser-support) for details.\n *\n * \\@usageNotes\n *\n * ### Example\n *\n * {\\@example common/pipes/ts/currency_pipe.ts region='DeprecatedCurrencyPipe'}\n *\n *\n */\nclass DeprecatedCurrencyPipe {\n /**\n * @param {?} _locale\n */\n constructor(_locale) {\n this._locale = _locale;\n }\n /**\n * @param {?} value\n * @param {?=} currencyCode\n * @param {?=} symbolDisplay\n * @param {?=} digits\n * @return {?}\n */\n transform(value, currencyCode = 'USD', symbolDisplay = false, digits) {\n return formatNumber$1(DeprecatedCurrencyPipe, this._locale, value, NumberFormatStyle.Currency, digits, currencyCode, symbolDisplay);\n }\n}\nDeprecatedCurrencyPipe.decorators = [\n { type: Pipe, args: [{ name: 'currency' },] }\n];\n/** @nocollapse */\nDeprecatedCurrencyPipe.ctorParameters = () => [\n { type: String, decorators: [{ type: Inject, args: [LOCALE_ID,] }] }\n];\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc\n */\n/** *\n * A collection of deprecated i18n pipes that require intl api\n *\n * @deprecated from v5\n @type {?} */\nconst COMMON_DEPRECATED_I18N_PIPES = [DeprecatedDecimalPipe, DeprecatedPercentPipe, DeprecatedCurrencyPipe, DeprecatedDatePipe];\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc\n */\nclass ObservableStrategy {\n /**\n * @param {?} async\n * @param {?} updateLatestValue\n * @return {?}\n */\n createSubscription(async, updateLatestValue) {\n return async.subscribe({ next: updateLatestValue, error: (e) => { throw e; } });\n }\n /**\n * @param {?} subscription\n * @return {?}\n */\n dispose(subscription) { subscription.unsubscribe(); }\n /**\n * @param {?} subscription\n * @return {?}\n */\n onDestroy(subscription) { subscription.unsubscribe(); }\n}\nclass PromiseStrategy {\n /**\n * @param {?} async\n * @param {?} updateLatestValue\n * @return {?}\n */\n createSubscription(async, updateLatestValue) {\n return async.then(updateLatestValue, e => { throw e; });\n }\n /**\n * @param {?} subscription\n * @return {?}\n */\n dispose(subscription) { }\n /**\n * @param {?} subscription\n * @return {?}\n */\n onDestroy(subscription) { }\n}\n/** @type {?} */\nconst _promiseStrategy = new PromiseStrategy();\n/** @type {?} */\nconst _observableStrategy = new ObservableStrategy();\n/**\n * \\@ngModule CommonModule\n * \\@description\n *\n * Unwraps a value from an asynchronous primitive.\n *\n * The `async` pipe subscribes to an `Observable` or `Promise` and returns the latest value it has\n * emitted. When a new value is emitted, the `async` pipe marks the component to be checked for\n * changes. When the component gets destroyed, the `async` pipe unsubscribes automatically to avoid\n * potential memory leaks.\n *\n * \\@usageNotes\n *\n * ### Examples\n *\n * This example binds a `Promise` to the view. Clicking the `Resolve` button resolves the\n * promise.\n *\n * {\\@example common/pipes/ts/async_pipe.ts region='AsyncPipePromise'}\n *\n * It's also possible to use `async` with Observables. The example below binds the `time` Observable\n * to the view. The Observable continuously updates the view with the current time.\n *\n * {\\@example common/pipes/ts/async_pipe.ts region='AsyncPipeObservable'}\n *\n */\nclass AsyncPipe {\n /**\n * @param {?} _ref\n */\n constructor(_ref) {\n this._ref = _ref;\n this._latestValue = null;\n this._latestReturnedValue = null;\n this._subscription = null;\n this._obj = null;\n this._strategy = /** @type {?} */ ((null));\n }\n /**\n * @return {?}\n */\n ngOnDestroy() {\n if (this._subscription) {\n this._dispose();\n }\n }\n /**\n * @param {?} obj\n * @return {?}\n */\n transform(obj) {\n if (!this._obj) {\n if (obj) {\n this._subscribe(obj);\n }\n this._latestReturnedValue = this._latestValue;\n return this._latestValue;\n }\n if (obj !== this._obj) {\n this._dispose();\n return this.transform(/** @type {?} */ (obj));\n }\n if (this._latestValue === this._latestReturnedValue) {\n return this._latestReturnedValue;\n }\n this._latestReturnedValue = this._latestValue;\n return WrappedValue.wrap(this._latestValue);\n }\n /**\n * @param {?} obj\n * @return {?}\n */\n _subscribe(obj) {\n this._obj = obj;\n this._strategy = this._selectStrategy(obj);\n this._subscription = this._strategy.createSubscription(obj, (value) => this._updateLatestValue(obj, value));\n }\n /**\n * @param {?} obj\n * @return {?}\n */\n _selectStrategy(obj) {\n if (ɵisPromise(obj)) {\n return _promiseStrategy;\n }\n if (ɵisObservable(obj)) {\n return _observableStrategy;\n }\n throw invalidPipeArgumentError(AsyncPipe, obj);\n }\n /**\n * @return {?}\n */\n _dispose() {\n this._strategy.dispose(/** @type {?} */ ((this._subscription)));\n this._latestValue = null;\n this._latestReturnedValue = null;\n this._subscription = null;\n this._obj = null;\n }\n /**\n * @param {?} async\n * @param {?} value\n * @return {?}\n */\n _updateLatestValue(async, value) {\n if (async === this._obj) {\n this._latestValue = value;\n this._ref.markForCheck();\n }\n }\n}\nAsyncPipe.decorators = [\n { type: Pipe, args: [{ name: 'async', pure: false },] }\n];\n/** @nocollapse */\nAsyncPipe.ctorParameters = () => [\n { type: ChangeDetectorRef }\n];\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc\n */\n/**\n * Transforms text to all lower case.\n *\n * @see `UpperCasePipe`\n * @see `TitleCasePipe`\n * \\@usageNotes\n *\n * The following example defines a view that allows the user to enter\n * text, and then uses the pipe to convert the input text to all lower case.\n *\n * Today is {{today | date}}
\n *Or if you prefer, {{today | date:'fullDate'}}
\n *The time is {{today | date:'h:mm a z'}}
\n *{minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}.\n * - `minIntegerDigits`: The minimum number of integer digits before the decimal point.\n * Default is `1`.\n * - `minFractionDigits`: The minimum number of digits after the decimal point.\n * Default is `0`.\n * - `maxFractionDigits`: The maximum number of digits after the decimal point.\n * Default is `3`.\n * @param {?=} locale A locale code for the locale format rules to use.\n * When not supplied, uses the value of `LOCALE_ID`, which is `en-US` by default.\n * See [Setting your app locale](guide/i18n#setting-up-the-locale-of-your-app).\n * @return {?}\n */\n transform(value, digitsInfo, locale) {\n if (isEmpty(value))\n return null;\n locale = locale || this._locale;\n try {\n /** @type {?} */\n const num = strToNumber(value);\n return formatNumber(num, locale, digitsInfo);\n }\n catch (error) {\n throw invalidPipeArgumentError(DecimalPipe, error.message);\n }\n }\n}\nDecimalPipe.decorators = [\n { type: Pipe, args: [{ name: 'number' },] }\n];\n/** @nocollapse */\nDecimalPipe.ctorParameters = () => [\n { type: String, decorators: [{ type: Inject, args: [LOCALE_ID,] }] }\n];\n/**\n * \\@ngModule CommonModule\n * \\@description\n *\n * Transforms a number to a percentage\n * string, formatted according to locale rules that determine group sizing and\n * separator, decimal-point character, and other locale-specific\n * configurations.\n *\n * @see `formatPercent()`\n *\n * \\@usageNotes\n * The following code shows how the pipe transforms numbers\n * into text strings, according to various format specifications,\n * where the caller's default locale is `en-US`.\n *\n * {minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}.\n * - `minIntegerDigits`: The minimum number of integer digits before the decimal point.\n * Default is `1`.\n * - `minFractionDigits`: The minimum number of digits after the decimal point.\n * Default is `0`.\n * - `maxFractionDigits`: The maximum number of digits after the decimal point.\n * Default is `3`.\n * @param {?=} locale A locale code for the locale format rules to use.\n * When not supplied, uses the value of `LOCALE_ID`, which is `en-US` by default.\n * See [Setting your app locale](guide/i18n#setting-up-the-locale-of-your-app).\n * @return {?}\n */\n transform(value, digitsInfo, locale) {\n if (isEmpty(value))\n return null;\n locale = locale || this._locale;\n try {\n /** @type {?} */\n const num = strToNumber(value);\n return formatPercent(num, locale, digitsInfo);\n }\n catch (error) {\n throw invalidPipeArgumentError(PercentPipe, error.message);\n }\n }\n}\nPercentPipe.decorators = [\n { type: Pipe, args: [{ name: 'percent' },] }\n];\n/** @nocollapse */\nPercentPipe.ctorParameters = () => [\n { type: String, decorators: [{ type: Inject, args: [LOCALE_ID,] }] }\n];\n/**\n * \\@ngModule CommonModule\n * \\@description\n *\n * Transforms a number to a currency string, formatted according to locale rules\n * that determine group sizing and separator, decimal-point character,\n * and other locale-specific configurations.\n *\n * @see `getCurrencySymbol()`\n * @see `formatCurrency()`\n *\n * \\@usageNotes\n * The following code shows how the pipe transforms numbers\n * into text strings, according to various format specifications,\n * where the caller's default locale is `en-US`.\n *\n * {minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}.\n * - `minIntegerDigits`: The minimum number of integer digits before the decimal point.\n * Default is `1`.\n * - `minFractionDigits`: The minimum number of digits after the decimal point.\n * Default is `0`.\n * - `maxFractionDigits`: The maximum number of digits after the decimal point.\n * Default is `3`.\n * If not provided, the number will be formatted with the proper amount of digits,\n * depending on what the [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) specifies.\n * For example, the Canadian dollar has 2 digits, whereas the Chilean peso has none.\n * @param {?=} locale A locale code for the locale format rules to use.\n * When not supplied, uses the value of `LOCALE_ID`, which is `en-US` by default.\n * See [Setting your app locale](guide/i18n#setting-up-the-locale-of-your-app).\n * @return {?}\n */\n transform(value, currencyCode, display = 'symbol', digitsInfo, locale) {\n if (isEmpty(value))\n return null;\n locale = locale || this._locale;\n if (typeof display === 'boolean') {\n if (/** @type {?} */ (console) && /** @type {?} */ (console.warn)) {\n console.warn(`Warning: the currency pipe has been changed in Angular v5. The symbolDisplay option (third parameter) is now a string instead of a boolean. The accepted values are \"code\", \"symbol\" or \"symbol-narrow\".`);\n }\n display = display ? 'symbol' : 'code';\n }\n /** @type {?} */\n let currency = currencyCode || 'USD';\n if (display !== 'code') {\n if (display === 'symbol' || display === 'symbol-narrow') {\n currency = getCurrencySymbol(currency, display === 'symbol' ? 'wide' : 'narrow', locale);\n }\n else {\n currency = display;\n }\n }\n try {\n /** @type {?} */\n const num = strToNumber(value);\n return formatCurrency(num, locale, currency, currencyCode, digitsInfo);\n }\n catch (error) {\n throw invalidPipeArgumentError(CurrencyPipe, error.message);\n }\n }\n}\nCurrencyPipe.decorators = [\n { type: Pipe, args: [{ name: 'currency' },] }\n];\n/** @nocollapse */\nCurrencyPipe.ctorParameters = () => [\n { type: String, decorators: [{ type: Inject, args: [LOCALE_ID,] }] }\n];\n/**\n * @param {?} value\n * @return {?}\n */\nfunction isEmpty(value) {\n return value == null || value === '' || value !== value;\n}\n/**\n * Transforms a string into a number (if needed).\n * @param {?} value\n * @return {?}\n */\nfunction strToNumber(value) {\n // Convert strings to numbers\n if (typeof value === 'string' && !isNaN(Number(value) - parseFloat(value))) {\n return Number(value);\n }\n if (typeof value !== 'number') {\n throw new Error(`${value} is not a number`);\n }\n return value;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc\n */\n/**\n * \\@ngModule CommonModule\n * \\@description\n *\n * Creates a new `Array` or `String` containing a subset (slice) of the elements.\n *\n * \\@usageNotes\n *\n * All behavior is based on the expected behavior of the JavaScript API `Array.prototype.slice()`\n * and `String.prototype.slice()`.\n *\n * When operating on an `Array`, the returned `Array` is always a copy even when all\n * the elements are being returned.\n *\n * When operating on a blank value, the pipe returns the blank value.\n *\n * ### List Example\n *\n * This `ngFor` example:\n *\n * {\\@example common/pipes/ts/slice_pipe.ts region='SlicePipe_list'}\n *\n * produces the following:\n *\n * ```html\n * {ICU message}
` would produce two messages:\n * - one for the content with meaning and description,\n * - another one for the ICU message.\n *\n * In this case the last message is discarded as it contains less information (the AST is\n * otherwise identical).\n *\n * Note that we should still keep messages extracted from attributes inside the section (ie in the\n * ICU message here)\n */\n _closeTranslatableSection(node, directChildren) {\n if (!this._isInTranslatableSection) {\n this._reportError(node, 'Unexpected section end');\n return;\n }\n const startIndex = this._msgCountAtSectionStart;\n const significantChildren = directChildren.reduce((count, node) => count + (node instanceof Comment ? 0 : 1), 0);\n if (significantChildren == 1) {\n for (let i = this._messages.length - 1; i >= startIndex; i--) {\n const ast = this._messages[i].nodes;\n if (!(ast.length == 1 && ast[0] instanceof Text$1)) {\n this._messages.splice(i, 1);\n break;\n }\n }\n }\n this._msgCountAtSectionStart = undefined;\n }\n _reportError(node, msg) {\n this._errors.push(new I18nError(node.sourceSpan, msg));\n }\n}\nfunction _isOpeningComment(n) {\n return !!(n instanceof Comment && n.value && n.value.startsWith('i18n'));\n}\nfunction _isClosingComment(n) {\n return !!(n instanceof Comment && n.value && n.value === '/i18n');\n}\nfunction _getI18nAttr(p) {\n return p.attrs.find(attr => attr.name === _I18N_ATTR) || null;\n}\nfunction _parseMessageMeta(i18n) {\n if (!i18n)\n return { meaning: '', description: '', id: '' };\n const idIndex = i18n.indexOf(ID_SEPARATOR);\n const descIndex = i18n.indexOf(MEANING_SEPARATOR);\n const [meaningAndDesc, id] = (idIndex > -1) ? [i18n.slice(0, idIndex), i18n.slice(idIndex + 2)] : [i18n, ''];\n const [meaning, description] = (descIndex > -1) ?\n [meaningAndDesc.slice(0, descIndex), meaningAndDesc.slice(descIndex + 1)] :\n ['', meaningAndDesc];\n return { meaning, description, id };\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass XmlTagDefinition {\n constructor() {\n this.closedByParent = false;\n this.contentType = TagContentType.PARSABLE_DATA;\n this.isVoid = false;\n this.ignoreFirstLf = false;\n this.canSelfClose = true;\n }\n requireExtraParent(currentParent) { return false; }\n isClosedByChild(name) { return false; }\n}\nconst _TAG_DEFINITION = new XmlTagDefinition();\nfunction getXmlTagDefinition(tagName) {\n return _TAG_DEFINITION;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass XmlParser extends Parser$1 {\n constructor() { super(getXmlTagDefinition); }\n parse(source, url, parseExpansionForms = false) {\n return super.parse(source, url, parseExpansionForms);\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass Serializer {\n // Creates a name mapper, see `PlaceholderMapper`\n // Returning `null` means that no name mapping is used.\n createNameMapper(message) { return null; }\n}\n/**\n * A simple mapper that take a function to transform an internal name to a public name\n */\nclass SimplePlaceholderMapper extends RecurseVisitor {\n // create a mapping from the message\n constructor(message, mapName) {\n super();\n this.mapName = mapName;\n this.internalToPublic = {};\n this.publicToNextId = {};\n this.publicToInternal = {};\n message.nodes.forEach(node => node.visit(this));\n }\n toPublicName(internalName) {\n return this.internalToPublic.hasOwnProperty(internalName) ?\n this.internalToPublic[internalName] :\n null;\n }\n toInternalName(publicName) {\n return this.publicToInternal.hasOwnProperty(publicName) ? this.publicToInternal[publicName] :\n null;\n }\n visitText(text, context) { return null; }\n visitTagPlaceholder(ph, context) {\n this.visitPlaceholderName(ph.startName);\n super.visitTagPlaceholder(ph, context);\n this.visitPlaceholderName(ph.closeName);\n }\n visitPlaceholder(ph, context) { this.visitPlaceholderName(ph.name); }\n visitIcuPlaceholder(ph, context) {\n this.visitPlaceholderName(ph.name);\n }\n // XMB placeholders could only contains A-Z, 0-9 and _\n visitPlaceholderName(internalName) {\n if (!internalName || this.internalToPublic.hasOwnProperty(internalName)) {\n return;\n }\n let publicName = this.mapName(internalName);\n if (this.publicToInternal.hasOwnProperty(publicName)) {\n // Create a new XMB when it has already been used\n const nextId = this.publicToNextId[publicName];\n this.publicToNextId[publicName] = nextId + 1;\n publicName = `${publicName}_${nextId}`;\n }\n else {\n this.publicToNextId[publicName] = 1;\n }\n this.internalToPublic[internalName] = publicName;\n this.publicToInternal[publicName] = internalName;\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass _Visitor$1 {\n visitTag(tag) {\n const strAttrs = this._serializeAttributes(tag.attrs);\n if (tag.children.length == 0) {\n return `<${tag.name}${strAttrs}/>`;\n }\n const strChildren = tag.children.map(node => node.visit(this));\n return `<${tag.name}${strAttrs}>${strChildren.join('')}`;\n }\n visitText(text) { return text.value; }\n visitDeclaration(decl) {\n return ``;\n }\n _serializeAttributes(attrs) {\n const strAttrs = Object.keys(attrs).map((name) => `${name}=\"${attrs[name]}\"`).join(' ');\n return strAttrs.length > 0 ? ' ' + strAttrs : '';\n }\n visitDoctype(doctype) {\n return ``;\n }\n}\nconst _visitor = new _Visitor$1();\nfunction serialize(nodes) {\n return nodes.map((node) => node.visit(_visitor)).join('');\n}\nclass Declaration {\n constructor(unescapedAttrs) {\n this.attrs = {};\n Object.keys(unescapedAttrs).forEach((k) => {\n this.attrs[k] = escapeXml(unescapedAttrs[k]);\n });\n }\n visit(visitor) { return visitor.visitDeclaration(this); }\n}\nclass Doctype {\n constructor(rootTag, dtd) {\n this.rootTag = rootTag;\n this.dtd = dtd;\n }\n visit(visitor) { return visitor.visitDoctype(this); }\n}\nclass Tag {\n constructor(name, unescapedAttrs = {}, children = []) {\n this.name = name;\n this.children = children;\n this.attrs = {};\n Object.keys(unescapedAttrs).forEach((k) => {\n this.attrs[k] = escapeXml(unescapedAttrs[k]);\n });\n }\n visit(visitor) { return visitor.visitTag(this); }\n}\nclass Text$2 {\n constructor(unescapedValue) { this.value = escapeXml(unescapedValue); }\n visit(visitor) { return visitor.visitText(this); }\n}\nclass CR extends Text$2 {\n constructor(ws = 0) { super(`\\n${new Array(ws + 1).join(' ')}`); }\n}\nconst _ESCAPED_CHARS = [\n [/&/g, '&'],\n [/\"/g, '"'],\n [/'/g, '''],\n [//g, '>'],\n];\n// Escape `_ESCAPED_CHARS` characters in the given text with encoded entities\nfunction escapeXml(text) {\n return _ESCAPED_CHARS.reduce((text, entry) => text.replace(entry[0], entry[1]), text);\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst _VERSION = '1.2';\nconst _XMLNS = 'urn:oasis:names:tc:xliff:document:1.2';\n// TODO(vicb): make this a param (s/_/-/)\nconst _DEFAULT_SOURCE_LANG = 'en';\nconst _PLACEHOLDER_TAG = 'x';\nconst _MARKER_TAG = 'mrk';\nconst _FILE_TAG = 'file';\nconst _SOURCE_TAG = 'source';\nconst _SEGMENT_SOURCE_TAG = 'seg-source';\nconst _TARGET_TAG = 'target';\nconst _UNIT_TAG = 'trans-unit';\nconst _CONTEXT_GROUP_TAG = 'context-group';\nconst _CONTEXT_TAG = 'context';\n// http://docs.oasis-open.org/xliff/v1.2/os/xliff-core.html\n// http://docs.oasis-open.org/xliff/v1.2/xliff-profile-html/xliff-profile-html-1.2.html\nclass Xliff extends Serializer {\n write(messages, locale) {\n const visitor = new _WriteVisitor();\n const transUnits = [];\n messages.forEach(message => {\n let contextTags = [];\n message.sources.forEach((source) => {\n let contextGroupTag = new Tag(_CONTEXT_GROUP_TAG, { purpose: 'location' });\n contextGroupTag.children.push(new CR(10), new Tag(_CONTEXT_TAG, { 'context-type': 'sourcefile' }, [new Text$2(source.filePath)]), new CR(10), new Tag(_CONTEXT_TAG, { 'context-type': 'linenumber' }, [new Text$2(`${source.startLine}`)]), new CR(8));\n contextTags.push(new CR(8), contextGroupTag);\n });\n const transUnit = new Tag(_UNIT_TAG, { id: message.id, datatype: 'html' });\n transUnit.children.push(new CR(8), new Tag(_SOURCE_TAG, {}, visitor.serialize(message.nodes)), ...contextTags);\n if (message.description) {\n transUnit.children.push(new CR(8), new Tag('note', { priority: '1', from: 'description' }, [new Text$2(message.description)]));\n }\n if (message.meaning) {\n transUnit.children.push(new CR(8), new Tag('note', { priority: '1', from: 'meaning' }, [new Text$2(message.meaning)]));\n }\n transUnit.children.push(new CR(6));\n transUnits.push(new CR(6), transUnit);\n });\n const body = new Tag('body', {}, [...transUnits, new CR(4)]);\n const file = new Tag('file', {\n 'source-language': locale || _DEFAULT_SOURCE_LANG,\n datatype: 'plaintext',\n original: 'ng2.template',\n }, [new CR(4), body, new CR(2)]);\n const xliff = new Tag('xliff', { version: _VERSION, xmlns: _XMLNS }, [new CR(2), file, new CR()]);\n return serialize([\n new Declaration({ version: '1.0', encoding: 'UTF-8' }), new CR(), xliff, new CR()\n ]);\n }\n load(content, url) {\n // xliff to xml nodes\n const xliffParser = new XliffParser();\n const { locale, msgIdToHtml, errors } = xliffParser.parse(content, url);\n // xml nodes to i18n nodes\n const i18nNodesByMsgId = {};\n const converter = new XmlToI18n();\n Object.keys(msgIdToHtml).forEach(msgId => {\n const { i18nNodes, errors: e } = converter.convert(msgIdToHtml[msgId], url);\n errors.push(...e);\n i18nNodesByMsgId[msgId] = i18nNodes;\n });\n if (errors.length) {\n throw new Error(`xliff parse errors:\\n${errors.join('\\n')}`);\n }\n return { locale: locale, i18nNodesByMsgId };\n }\n digest(message) { return digest(message); }\n}\nclass _WriteVisitor {\n visitText(text, context) { return [new Text$2(text.value)]; }\n visitContainer(container, context) {\n const nodes = [];\n container.children.forEach((node) => nodes.push(...node.visit(this)));\n return nodes;\n }\n visitIcu(icu, context) {\n const nodes = [new Text$2(`{${icu.expressionPlaceholder}, ${icu.type}, `)];\n Object.keys(icu.cases).forEach((c) => {\n nodes.push(new Text$2(`${c} {`), ...icu.cases[c].visit(this), new Text$2(`} `));\n });\n nodes.push(new Text$2(`}`));\n return nodes;\n }\n visitTagPlaceholder(ph, context) {\n const ctype = getCtypeForTag(ph.tag);\n if (ph.isVoid) {\n // void tags have no children nor closing tags\n return [new Tag(_PLACEHOLDER_TAG, { id: ph.startName, ctype, 'equiv-text': `<${ph.tag}/>` })];\n }\n const startTagPh = new Tag(_PLACEHOLDER_TAG, { id: ph.startName, ctype, 'equiv-text': `<${ph.tag}>` });\n const closeTagPh = new Tag(_PLACEHOLDER_TAG, { id: ph.closeName, ctype, 'equiv-text': `` });\n return [startTagPh, ...this.serialize(ph.children), closeTagPh];\n }\n visitPlaceholder(ph, context) {\n return [new Tag(_PLACEHOLDER_TAG, { id: ph.name, 'equiv-text': `{{${ph.value}}}` })];\n }\n visitIcuPlaceholder(ph, context) {\n const equivText = `{${ph.value.expression}, ${ph.value.type}, ${Object.keys(ph.value.cases).map((value) => value + ' {...}').join(' ')}}`;\n return [new Tag(_PLACEHOLDER_TAG, { id: ph.name, 'equiv-text': equivText })];\n }\n serialize(nodes) {\n return [].concat(...nodes.map(node => node.visit(this)));\n }\n}\n// TODO(vicb): add error management (structure)\n// Extract messages as xml nodes from the xliff file\nclass XliffParser {\n constructor() {\n this._locale = null;\n }\n parse(xliff, url) {\n this._unitMlString = null;\n this._msgIdToHtml = {};\n const xml = new XmlParser().parse(xliff, url, false);\n this._errors = xml.errors;\n visitAll(this, xml.rootNodes, null);\n return {\n msgIdToHtml: this._msgIdToHtml,\n errors: this._errors,\n locale: this._locale,\n };\n }\n visitElement(element, context) {\n switch (element.name) {\n case _UNIT_TAG:\n this._unitMlString = null;\n const idAttr = element.attrs.find((attr) => attr.name === 'id');\n if (!idAttr) {\n this._addError(element, `<${_UNIT_TAG}> misses the \"id\" attribute`);\n }\n else {\n const id = idAttr.value;\n if (this._msgIdToHtml.hasOwnProperty(id)) {\n this._addError(element, `Duplicated translations for msg ${id}`);\n }\n else {\n visitAll(this, element.children, null);\n if (typeof this._unitMlString === 'string') {\n this._msgIdToHtml[id] = this._unitMlString;\n }\n else {\n this._addError(element, `Message ${id} misses a translation`);\n }\n }\n }\n break;\n // ignore those tags\n case _SOURCE_TAG:\n case _SEGMENT_SOURCE_TAG:\n break;\n case _TARGET_TAG:\n const innerTextStart = element.startSourceSpan.end.offset;\n const innerTextEnd = element.endSourceSpan.start.offset;\n const content = element.startSourceSpan.start.file.content;\n const innerText = content.slice(innerTextStart, innerTextEnd);\n this._unitMlString = innerText;\n break;\n case _FILE_TAG:\n const localeAttr = element.attrs.find((attr) => attr.name === 'target-language');\n if (localeAttr) {\n this._locale = localeAttr.value;\n }\n visitAll(this, element.children, null);\n break;\n default:\n // TODO(vicb): assert file structure, xliff version\n // For now only recurse on unhandled nodes\n visitAll(this, element.children, null);\n }\n }\n visitAttribute(attribute, context) { }\n visitText(text, context) { }\n visitComment(comment, context) { }\n visitExpansion(expansion, context) { }\n visitExpansionCase(expansionCase, context) { }\n _addError(node, message) {\n this._errors.push(new I18nError(node.sourceSpan, message));\n }\n}\n// Convert ml nodes (xliff syntax) to i18n nodes\nclass XmlToI18n {\n convert(message, url) {\n const xmlIcu = new XmlParser().parse(message, url, true);\n this._errors = xmlIcu.errors;\n const i18nNodes = this._errors.length > 0 || xmlIcu.rootNodes.length == 0 ?\n [] :\n [].concat(...visitAll(this, xmlIcu.rootNodes));\n return {\n i18nNodes: i18nNodes,\n errors: this._errors,\n };\n }\n visitText(text, context) { return new Text$1(text.value, text.sourceSpan); }\n visitElement(el, context) {\n if (el.name === _PLACEHOLDER_TAG) {\n const nameAttr = el.attrs.find((attr) => attr.name === 'id');\n if (nameAttr) {\n return new Placeholder('', nameAttr.value, el.sourceSpan);\n }\n this._addError(el, `<${_PLACEHOLDER_TAG}> misses the \"id\" attribute`);\n return null;\n }\n if (el.name === _MARKER_TAG) {\n return [].concat(...visitAll(this, el.children));\n }\n this._addError(el, `Unexpected tag`);\n return null;\n }\n visitExpansion(icu, context) {\n const caseMap = {};\n visitAll(this, icu.cases).forEach((c) => {\n caseMap[c.value] = new Container(c.nodes, icu.sourceSpan);\n });\n return new Icu(icu.switchValue, icu.type, caseMap, icu.sourceSpan);\n }\n visitExpansionCase(icuCase, context) {\n return {\n value: icuCase.value,\n nodes: visitAll(this, icuCase.expression),\n };\n }\n visitComment(comment, context) { }\n visitAttribute(attribute, context) { }\n _addError(node, message) {\n this._errors.push(new I18nError(node.sourceSpan, message));\n }\n}\nfunction getCtypeForTag(tag) {\n switch (tag.toLowerCase()) {\n case 'br':\n return 'lb';\n case 'img':\n return 'image';\n default:\n return `x-${tag}`;\n }\n}\n\n/**\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 */\nconst _VERSION$1 = '2.0';\nconst _XMLNS$1 = 'urn:oasis:names:tc:xliff:document:2.0';\n// TODO(vicb): make this a param (s/_/-/)\nconst _DEFAULT_SOURCE_LANG$1 = 'en';\nconst _PLACEHOLDER_TAG$1 = 'ph';\nconst _PLACEHOLDER_SPANNING_TAG = 'pc';\nconst _MARKER_TAG$1 = 'mrk';\nconst _XLIFF_TAG = 'xliff';\nconst _SOURCE_TAG$1 = 'source';\nconst _TARGET_TAG$1 = 'target';\nconst _UNIT_TAG$1 = 'unit';\n// http://docs.oasis-open.org/xliff/xliff-core/v2.0/os/xliff-core-v2.0-os.html\nclass Xliff2 extends Serializer {\n write(messages, locale) {\n const visitor = new _WriteVisitor$1();\n const units = [];\n messages.forEach(message => {\n const unit = new Tag(_UNIT_TAG$1, { id: message.id });\n const notes = new Tag('notes');\n if (message.description || message.meaning) {\n if (message.description) {\n notes.children.push(new CR(8), new Tag('note', { category: 'description' }, [new Text$2(message.description)]));\n }\n if (message.meaning) {\n notes.children.push(new CR(8), new Tag('note', { category: 'meaning' }, [new Text$2(message.meaning)]));\n }\n }\n message.sources.forEach((source) => {\n notes.children.push(new CR(8), new Tag('note', { category: 'location' }, [\n new Text$2(`${source.filePath}:${source.startLine}${source.endLine !== source.startLine ? ',' + source.endLine : ''}`)\n ]));\n });\n notes.children.push(new CR(6));\n unit.children.push(new CR(6), notes);\n const segment = new Tag('segment');\n segment.children.push(new CR(8), new Tag(_SOURCE_TAG$1, {}, visitor.serialize(message.nodes)), new CR(6));\n unit.children.push(new CR(6), segment, new CR(4));\n units.push(new CR(4), unit);\n });\n const file = new Tag('file', { 'original': 'ng.template', id: 'ngi18n' }, [...units, new CR(2)]);\n const xliff = new Tag(_XLIFF_TAG, { version: _VERSION$1, xmlns: _XMLNS$1, srcLang: locale || _DEFAULT_SOURCE_LANG$1 }, [new CR(2), file, new CR()]);\n return serialize([\n new Declaration({ version: '1.0', encoding: 'UTF-8' }), new CR(), xliff, new CR()\n ]);\n }\n load(content, url) {\n // xliff to xml nodes\n const xliff2Parser = new Xliff2Parser();\n const { locale, msgIdToHtml, errors } = xliff2Parser.parse(content, url);\n // xml nodes to i18n nodes\n const i18nNodesByMsgId = {};\n const converter = new XmlToI18n$1();\n Object.keys(msgIdToHtml).forEach(msgId => {\n const { i18nNodes, errors: e } = converter.convert(msgIdToHtml[msgId], url);\n errors.push(...e);\n i18nNodesByMsgId[msgId] = i18nNodes;\n });\n if (errors.length) {\n throw new Error(`xliff2 parse errors:\\n${errors.join('\\n')}`);\n }\n return { locale: locale, i18nNodesByMsgId };\n }\n digest(message) { return decimalDigest(message); }\n}\nclass _WriteVisitor$1 {\n visitText(text, context) { return [new Text$2(text.value)]; }\n visitContainer(container, context) {\n const nodes = [];\n container.children.forEach((node) => nodes.push(...node.visit(this)));\n return nodes;\n }\n visitIcu(icu, context) {\n const nodes = [new Text$2(`{${icu.expressionPlaceholder}, ${icu.type}, `)];\n Object.keys(icu.cases).forEach((c) => {\n nodes.push(new Text$2(`${c} {`), ...icu.cases[c].visit(this), new Text$2(`} `));\n });\n nodes.push(new Text$2(`}`));\n return nodes;\n }\n visitTagPlaceholder(ph, context) {\n const type = getTypeForTag(ph.tag);\n if (ph.isVoid) {\n const tagPh = new Tag(_PLACEHOLDER_TAG$1, {\n id: (this._nextPlaceholderId++).toString(),\n equiv: ph.startName,\n type: type,\n disp: `<${ph.tag}/>`,\n });\n return [tagPh];\n }\n const tagPc = new Tag(_PLACEHOLDER_SPANNING_TAG, {\n id: (this._nextPlaceholderId++).toString(),\n equivStart: ph.startName,\n equivEnd: ph.closeName,\n type: type,\n dispStart: `<${ph.tag}>`,\n dispEnd: ``,\n });\n const nodes = [].concat(...ph.children.map(node => node.visit(this)));\n if (nodes.length) {\n nodes.forEach((node) => tagPc.children.push(node));\n }\n else {\n tagPc.children.push(new Text$2(''));\n }\n return [tagPc];\n }\n visitPlaceholder(ph, context) {\n const idStr = (this._nextPlaceholderId++).toString();\n return [new Tag(_PLACEHOLDER_TAG$1, {\n id: idStr,\n equiv: ph.name,\n disp: `{{${ph.value}}}`,\n })];\n }\n visitIcuPlaceholder(ph, context) {\n const cases = Object.keys(ph.value.cases).map((value) => value + ' {...}').join(' ');\n const idStr = (this._nextPlaceholderId++).toString();\n return [new Tag(_PLACEHOLDER_TAG$1, { id: idStr, equiv: ph.name, disp: `{${ph.value.expression}, ${ph.value.type}, ${cases}}` })];\n }\n serialize(nodes) {\n this._nextPlaceholderId = 0;\n return [].concat(...nodes.map(node => node.visit(this)));\n }\n}\n// Extract messages as xml nodes from the xliff file\nclass Xliff2Parser {\n constructor() {\n this._locale = null;\n }\n parse(xliff, url) {\n this._unitMlString = null;\n this._msgIdToHtml = {};\n const xml = new XmlParser().parse(xliff, url, false);\n this._errors = xml.errors;\n visitAll(this, xml.rootNodes, null);\n return {\n msgIdToHtml: this._msgIdToHtml,\n errors: this._errors,\n locale: this._locale,\n };\n }\n visitElement(element, context) {\n switch (element.name) {\n case _UNIT_TAG$1:\n this._unitMlString = null;\n const idAttr = element.attrs.find((attr) => attr.name === 'id');\n if (!idAttr) {\n this._addError(element, `<${_UNIT_TAG$1}> misses the \"id\" attribute`);\n }\n else {\n const id = idAttr.value;\n if (this._msgIdToHtml.hasOwnProperty(id)) {\n this._addError(element, `Duplicated translations for msg ${id}`);\n }\n else {\n visitAll(this, element.children, null);\n if (typeof this._unitMlString === 'string') {\n this._msgIdToHtml[id] = this._unitMlString;\n }\n else {\n this._addError(element, `Message ${id} misses a translation`);\n }\n }\n }\n break;\n case _SOURCE_TAG$1:\n // ignore source message\n break;\n case _TARGET_TAG$1:\n const innerTextStart = element.startSourceSpan.end.offset;\n const innerTextEnd = element.endSourceSpan.start.offset;\n const content = element.startSourceSpan.start.file.content;\n const innerText = content.slice(innerTextStart, innerTextEnd);\n this._unitMlString = innerText;\n break;\n case _XLIFF_TAG:\n const localeAttr = element.attrs.find((attr) => attr.name === 'trgLang');\n if (localeAttr) {\n this._locale = localeAttr.value;\n }\n const versionAttr = element.attrs.find((attr) => attr.name === 'version');\n if (versionAttr) {\n const version = versionAttr.value;\n if (version !== '2.0') {\n this._addError(element, `The XLIFF file version ${version} is not compatible with XLIFF 2.0 serializer`);\n }\n else {\n visitAll(this, element.children, null);\n }\n }\n break;\n default:\n visitAll(this, element.children, null);\n }\n }\n visitAttribute(attribute, context) { }\n visitText(text, context) { }\n visitComment(comment, context) { }\n visitExpansion(expansion, context) { }\n visitExpansionCase(expansionCase, context) { }\n _addError(node, message) {\n this._errors.push(new I18nError(node.sourceSpan, message));\n }\n}\n// Convert ml nodes (xliff syntax) to i18n nodes\nclass XmlToI18n$1 {\n convert(message, url) {\n const xmlIcu = new XmlParser().parse(message, url, true);\n this._errors = xmlIcu.errors;\n const i18nNodes = this._errors.length > 0 || xmlIcu.rootNodes.length == 0 ?\n [] :\n [].concat(...visitAll(this, xmlIcu.rootNodes));\n return {\n i18nNodes,\n errors: this._errors,\n };\n }\n visitText(text, context) { return new Text$1(text.value, text.sourceSpan); }\n visitElement(el, context) {\n switch (el.name) {\n case _PLACEHOLDER_TAG$1:\n const nameAttr = el.attrs.find((attr) => attr.name === 'equiv');\n if (nameAttr) {\n return [new Placeholder('', nameAttr.value, el.sourceSpan)];\n }\n this._addError(el, `<${_PLACEHOLDER_TAG$1}> misses the \"equiv\" attribute`);\n break;\n case _PLACEHOLDER_SPANNING_TAG:\n const startAttr = el.attrs.find((attr) => attr.name === 'equivStart');\n const endAttr = el.attrs.find((attr) => attr.name === 'equivEnd');\n if (!startAttr) {\n this._addError(el, `<${_PLACEHOLDER_TAG$1}> misses the \"equivStart\" attribute`);\n }\n else if (!endAttr) {\n this._addError(el, `<${_PLACEHOLDER_TAG$1}> misses the \"equivEnd\" attribute`);\n }\n else {\n const startId = startAttr.value;\n const endId = endAttr.value;\n const nodes = [];\n return nodes.concat(new Placeholder('', startId, el.sourceSpan), ...el.children.map(node => node.visit(this, null)), new Placeholder('', endId, el.sourceSpan));\n }\n break;\n case _MARKER_TAG$1:\n return [].concat(...visitAll(this, el.children));\n default:\n this._addError(el, `Unexpected tag`);\n }\n return null;\n }\n visitExpansion(icu, context) {\n const caseMap = {};\n visitAll(this, icu.cases).forEach((c) => {\n caseMap[c.value] = new Container(c.nodes, icu.sourceSpan);\n });\n return new Icu(icu.switchValue, icu.type, caseMap, icu.sourceSpan);\n }\n visitExpansionCase(icuCase, context) {\n return {\n value: icuCase.value,\n nodes: [].concat(...visitAll(this, icuCase.expression)),\n };\n }\n visitComment(comment, context) { }\n visitAttribute(attribute, context) { }\n _addError(node, message) {\n this._errors.push(new I18nError(node.sourceSpan, message));\n }\n}\nfunction getTypeForTag(tag) {\n switch (tag.toLowerCase()) {\n case 'br':\n case 'b':\n case 'i':\n case 'u':\n return 'fmt';\n case 'img':\n return 'image';\n case 'a':\n return 'link';\n default:\n return 'other';\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst _MESSAGES_TAG = 'messagebundle';\nconst _MESSAGE_TAG = 'msg';\nconst _PLACEHOLDER_TAG$2 = 'ph';\nconst _EXEMPLE_TAG = 'ex';\nconst _SOURCE_TAG$2 = 'source';\nconst _DOCTYPE = `\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n`;\nclass Xmb extends Serializer {\n write(messages, locale) {\n const exampleVisitor = new ExampleVisitor();\n const visitor = new _Visitor$2();\n let rootNode = new Tag(_MESSAGES_TAG);\n messages.forEach(message => {\n const attrs = { id: message.id };\n if (message.description) {\n attrs['desc'] = message.description;\n }\n if (message.meaning) {\n attrs['meaning'] = message.meaning;\n }\n let sourceTags = [];\n message.sources.forEach((source) => {\n sourceTags.push(new Tag(_SOURCE_TAG$2, {}, [\n new Text$2(`${source.filePath}:${source.startLine}${source.endLine !== source.startLine ? ',' + source.endLine : ''}`)\n ]));\n });\n rootNode.children.push(new CR(2), new Tag(_MESSAGE_TAG, attrs, [...sourceTags, ...visitor.serialize(message.nodes)]));\n });\n rootNode.children.push(new CR());\n return serialize([\n new Declaration({ version: '1.0', encoding: 'UTF-8' }),\n new CR(),\n new Doctype(_MESSAGES_TAG, _DOCTYPE),\n new CR(),\n exampleVisitor.addDefaultExamples(rootNode),\n new CR(),\n ]);\n }\n load(content, url) {\n throw new Error('Unsupported');\n }\n digest(message) { return digest$1(message); }\n createNameMapper(message) {\n return new SimplePlaceholderMapper(message, toPublicName);\n }\n}\nclass _Visitor$2 {\n visitText(text, context) { return [new Text$2(text.value)]; }\n visitContainer(container, context) {\n const nodes = [];\n container.children.forEach((node) => nodes.push(...node.visit(this)));\n return nodes;\n }\n visitIcu(icu, context) {\n const nodes = [new Text$2(`{${icu.expressionPlaceholder}, ${icu.type}, `)];\n Object.keys(icu.cases).forEach((c) => {\n nodes.push(new Text$2(`${c} {`), ...icu.cases[c].visit(this), new Text$2(`} `));\n });\n nodes.push(new Text$2(`}`));\n return nodes;\n }\n visitTagPlaceholder(ph, context) {\n const startEx = new Tag(_EXEMPLE_TAG, {}, [new Text$2(`<${ph.tag}>`)]);\n const startTagPh = new Tag(_PLACEHOLDER_TAG$2, { name: ph.startName }, [startEx]);\n if (ph.isVoid) {\n // void tags have no children nor closing tags\n return [startTagPh];\n }\n const closeEx = new Tag(_EXEMPLE_TAG, {}, [new Text$2(``)]);\n const closeTagPh = new Tag(_PLACEHOLDER_TAG$2, { name: ph.closeName }, [closeEx]);\n return [startTagPh, ...this.serialize(ph.children), closeTagPh];\n }\n visitPlaceholder(ph, context) {\n const exTag = new Tag(_EXEMPLE_TAG, {}, [new Text$2(`{{${ph.value}}}`)]);\n return [new Tag(_PLACEHOLDER_TAG$2, { name: ph.name }, [exTag])];\n }\n visitIcuPlaceholder(ph, context) {\n const exTag = new Tag(_EXEMPLE_TAG, {}, [\n new Text$2(`{${ph.value.expression}, ${ph.value.type}, ${Object.keys(ph.value.cases).map((value) => value + ' {...}').join(' ')}}`)\n ]);\n return [new Tag(_PLACEHOLDER_TAG$2, { name: ph.name }, [exTag])];\n }\n serialize(nodes) {\n return [].concat(...nodes.map(node => node.visit(this)));\n }\n}\nfunction digest$1(message) {\n return decimalDigest(message);\n}\n// TC requires at least one non-empty example on placeholders\nclass ExampleVisitor {\n addDefaultExamples(node) {\n node.visit(this);\n return node;\n }\n visitTag(tag) {\n if (tag.name === _PLACEHOLDER_TAG$2) {\n if (!tag.children || tag.children.length == 0) {\n const exText = new Text$2(tag.attrs['name'] || '...');\n tag.children = [new Tag(_EXEMPLE_TAG, {}, [exText])];\n }\n }\n else if (tag.children) {\n tag.children.forEach(node => node.visit(this));\n }\n }\n visitText(text) { }\n visitDeclaration(decl) { }\n visitDoctype(doctype) { }\n}\n// XMB/XTB placeholders can only contain A-Z, 0-9 and _\nfunction toPublicName(internalName) {\n return internalName.toUpperCase().replace(/[^A-Z0-9_]/g, '_');\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst _TRANSLATIONS_TAG = 'translationbundle';\nconst _TRANSLATION_TAG = 'translation';\nconst _PLACEHOLDER_TAG$3 = 'ph';\nclass Xtb extends Serializer {\n write(messages, locale) { throw new Error('Unsupported'); }\n load(content, url) {\n // xtb to xml nodes\n const xtbParser = new XtbParser();\n const { locale, msgIdToHtml, errors } = xtbParser.parse(content, url);\n // xml nodes to i18n nodes\n const i18nNodesByMsgId = {};\n const converter = new XmlToI18n$2();\n // Because we should be able to load xtb files that rely on features not supported by angular,\n // we need to delay the conversion of html to i18n nodes so that non angular messages are not\n // converted\n Object.keys(msgIdToHtml).forEach(msgId => {\n const valueFn = function () {\n const { i18nNodes, errors } = converter.convert(msgIdToHtml[msgId], url);\n if (errors.length) {\n throw new Error(`xtb parse errors:\\n${errors.join('\\n')}`);\n }\n return i18nNodes;\n };\n createLazyProperty(i18nNodesByMsgId, msgId, valueFn);\n });\n if (errors.length) {\n throw new Error(`xtb parse errors:\\n${errors.join('\\n')}`);\n }\n return { locale: locale, i18nNodesByMsgId };\n }\n digest(message) { return digest$1(message); }\n createNameMapper(message) {\n return new SimplePlaceholderMapper(message, toPublicName);\n }\n}\nfunction createLazyProperty(messages, id, valueFn) {\n Object.defineProperty(messages, id, {\n configurable: true,\n enumerable: true,\n get: function () {\n const value = valueFn();\n Object.defineProperty(messages, id, { enumerable: true, value });\n return value;\n },\n set: _ => { throw new Error('Could not overwrite an XTB translation'); },\n });\n}\n// Extract messages as xml nodes from the xtb file\nclass XtbParser {\n constructor() {\n this._locale = null;\n }\n parse(xtb, url) {\n this._bundleDepth = 0;\n this._msgIdToHtml = {};\n // We can not parse the ICU messages at this point as some messages might not originate\n // from Angular that could not be lex'd.\n const xml = new XmlParser().parse(xtb, url, false);\n this._errors = xml.errors;\n visitAll(this, xml.rootNodes);\n return {\n msgIdToHtml: this._msgIdToHtml,\n errors: this._errors,\n locale: this._locale,\n };\n }\n visitElement(element, context) {\n switch (element.name) {\n case _TRANSLATIONS_TAG:\n this._bundleDepth++;\n if (this._bundleDepth > 1) {\n this._addError(element, `<${_TRANSLATIONS_TAG}> elements can not be nested`);\n }\n const langAttr = element.attrs.find((attr) => attr.name === 'lang');\n if (langAttr) {\n this._locale = langAttr.value;\n }\n visitAll(this, element.children, null);\n this._bundleDepth--;\n break;\n case _TRANSLATION_TAG:\n const idAttr = element.attrs.find((attr) => attr.name === 'id');\n if (!idAttr) {\n this._addError(element, `<${_TRANSLATION_TAG}> misses the \"id\" attribute`);\n }\n else {\n const id = idAttr.value;\n if (this._msgIdToHtml.hasOwnProperty(id)) {\n this._addError(element, `Duplicated translations for msg ${id}`);\n }\n else {\n const innerTextStart = element.startSourceSpan.end.offset;\n const innerTextEnd = element.endSourceSpan.start.offset;\n const content = element.startSourceSpan.start.file.content;\n const innerText = content.slice(innerTextStart, innerTextEnd);\n this._msgIdToHtml[id] = innerText;\n }\n }\n break;\n default:\n this._addError(element, 'Unexpected tag');\n }\n }\n visitAttribute(attribute, context) { }\n visitText(text, context) { }\n visitComment(comment, context) { }\n visitExpansion(expansion, context) { }\n visitExpansionCase(expansionCase, context) { }\n _addError(node, message) {\n this._errors.push(new I18nError(node.sourceSpan, message));\n }\n}\n// Convert ml nodes (xtb syntax) to i18n nodes\nclass XmlToI18n$2 {\n convert(message, url) {\n const xmlIcu = new XmlParser().parse(message, url, true);\n this._errors = xmlIcu.errors;\n const i18nNodes = this._errors.length > 0 || xmlIcu.rootNodes.length == 0 ?\n [] :\n visitAll(this, xmlIcu.rootNodes);\n return {\n i18nNodes,\n errors: this._errors,\n };\n }\n visitText(text, context) { return new Text$1(text.value, text.sourceSpan); }\n visitExpansion(icu, context) {\n const caseMap = {};\n visitAll(this, icu.cases).forEach(c => {\n caseMap[c.value] = new Container(c.nodes, icu.sourceSpan);\n });\n return new Icu(icu.switchValue, icu.type, caseMap, icu.sourceSpan);\n }\n visitExpansionCase(icuCase, context) {\n return {\n value: icuCase.value,\n nodes: visitAll(this, icuCase.expression),\n };\n }\n visitElement(el, context) {\n if (el.name === _PLACEHOLDER_TAG$3) {\n const nameAttr = el.attrs.find((attr) => attr.name === 'name');\n if (nameAttr) {\n return new Placeholder('', nameAttr.value, el.sourceSpan);\n }\n this._addError(el, `<${_PLACEHOLDER_TAG$3}> misses the \"name\" attribute`);\n }\n else {\n this._addError(el, `Unexpected tag`);\n }\n return null;\n }\n visitComment(comment, context) { }\n visitAttribute(attribute, context) { }\n _addError(node, message) {\n this._errors.push(new I18nError(node.sourceSpan, message));\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass HtmlParser extends Parser$1 {\n constructor() { super(getHtmlTagDefinition); }\n parse(source, url, parseExpansionForms = false, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {\n return super.parse(source, url, parseExpansionForms, interpolationConfig);\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A container for translated messages\n */\nclass TranslationBundle {\n constructor(_i18nNodesByMsgId = {}, locale, digest, mapperFactory, missingTranslationStrategy = MissingTranslationStrategy.Warning, console) {\n this._i18nNodesByMsgId = _i18nNodesByMsgId;\n this.digest = digest;\n this.mapperFactory = mapperFactory;\n this._i18nToHtml = new I18nToHtmlVisitor(_i18nNodesByMsgId, locale, digest, mapperFactory, missingTranslationStrategy, console);\n }\n // Creates a `TranslationBundle` by parsing the given `content` with the `serializer`.\n static load(content, url, serializer, missingTranslationStrategy, console) {\n const { locale, i18nNodesByMsgId } = serializer.load(content, url);\n const digestFn = (m) => serializer.digest(m);\n const mapperFactory = (m) => serializer.createNameMapper(m);\n return new TranslationBundle(i18nNodesByMsgId, locale, digestFn, mapperFactory, missingTranslationStrategy, console);\n }\n // Returns the translation as HTML nodes from the given source message.\n get(srcMsg) {\n const html = this._i18nToHtml.convert(srcMsg);\n if (html.errors.length) {\n throw new Error(html.errors.join('\\n'));\n }\n return html.nodes;\n }\n has(srcMsg) { return this.digest(srcMsg) in this._i18nNodesByMsgId; }\n}\nclass I18nToHtmlVisitor {\n constructor(_i18nNodesByMsgId = {}, _locale, _digest, _mapperFactory, _missingTranslationStrategy, _console) {\n this._i18nNodesByMsgId = _i18nNodesByMsgId;\n this._locale = _locale;\n this._digest = _digest;\n this._mapperFactory = _mapperFactory;\n this._missingTranslationStrategy = _missingTranslationStrategy;\n this._console = _console;\n this._contextStack = [];\n this._errors = [];\n }\n convert(srcMsg) {\n this._contextStack.length = 0;\n this._errors.length = 0;\n // i18n to text\n const text = this._convertToText(srcMsg);\n // text to html\n const url = srcMsg.nodes[0].sourceSpan.start.file.url;\n const html = new HtmlParser().parse(text, url, true);\n return {\n nodes: html.rootNodes,\n errors: [...this._errors, ...html.errors],\n };\n }\n visitText(text, context) {\n // `convert()` uses an `HtmlParser` to return `html.Node`s\n // we should then make sure that any special characters are escaped\n return escapeXml(text.value);\n }\n visitContainer(container, context) {\n return container.children.map(n => n.visit(this)).join('');\n }\n visitIcu(icu, context) {\n const cases = Object.keys(icu.cases).map(k => `${k} {${icu.cases[k].visit(this)}}`);\n // TODO(vicb): Once all format switch to using expression placeholders\n // we should throw when the placeholder is not in the source message\n const exp = this._srcMsg.placeholders.hasOwnProperty(icu.expression) ?\n this._srcMsg.placeholders[icu.expression] :\n icu.expression;\n return `{${exp}, ${icu.type}, ${cases.join(' ')}}`;\n }\n visitPlaceholder(ph, context) {\n const phName = this._mapper(ph.name);\n if (this._srcMsg.placeholders.hasOwnProperty(phName)) {\n return this._srcMsg.placeholders[phName];\n }\n if (this._srcMsg.placeholderToMessage.hasOwnProperty(phName)) {\n return this._convertToText(this._srcMsg.placeholderToMessage[phName]);\n }\n this._addError(ph, `Unknown placeholder \"${ph.name}\"`);\n return '';\n }\n // Loaded message contains only placeholders (vs tag and icu placeholders).\n // However when a translation can not be found, we need to serialize the source message\n // which can contain tag placeholders\n visitTagPlaceholder(ph, context) {\n const tag = `${ph.tag}`;\n const attrs = Object.keys(ph.attrs).map(name => `${name}=\"${ph.attrs[name]}\"`).join(' ');\n if (ph.isVoid) {\n return `<${tag} ${attrs}/>`;\n }\n const children = ph.children.map((c) => c.visit(this)).join('');\n return `<${tag} ${attrs}>${children}`;\n }\n // Loaded message contains only placeholders (vs tag and icu placeholders).\n // However when a translation can not be found, we need to serialize the source message\n // which can contain tag placeholders\n visitIcuPlaceholder(ph, context) {\n // An ICU placeholder references the source message to be serialized\n return this._convertToText(this._srcMsg.placeholderToMessage[ph.name]);\n }\n /**\n * Convert a source message to a translated text string:\n * - text nodes are replaced with their translation,\n * - placeholders are replaced with their content,\n * - ICU nodes are converted to ICU expressions.\n */\n _convertToText(srcMsg) {\n const id = this._digest(srcMsg);\n const mapper = this._mapperFactory ? this._mapperFactory(srcMsg) : null;\n let nodes;\n this._contextStack.push({ msg: this._srcMsg, mapper: this._mapper });\n this._srcMsg = srcMsg;\n if (this._i18nNodesByMsgId.hasOwnProperty(id)) {\n // When there is a translation use its nodes as the source\n // And create a mapper to convert serialized placeholder names to internal names\n nodes = this._i18nNodesByMsgId[id];\n this._mapper = (name) => mapper ? mapper.toInternalName(name) : name;\n }\n else {\n // When no translation has been found\n // - report an error / a warning / nothing,\n // - use the nodes from the original message\n // - placeholders are already internal and need no mapper\n if (this._missingTranslationStrategy === MissingTranslationStrategy.Error) {\n const ctx = this._locale ? ` for locale \"${this._locale}\"` : '';\n this._addError(srcMsg.nodes[0], `Missing translation for message \"${id}\"${ctx}`);\n }\n else if (this._console &&\n this._missingTranslationStrategy === MissingTranslationStrategy.Warning) {\n const ctx = this._locale ? ` for locale \"${this._locale}\"` : '';\n this._console.warn(`Missing translation for message \"${id}\"${ctx}`);\n }\n nodes = srcMsg.nodes;\n this._mapper = (name) => name;\n }\n const text = nodes.map(node => node.visit(this)).join('');\n const context = this._contextStack.pop();\n this._srcMsg = context.msg;\n this._mapper = context.mapper;\n return text;\n }\n _addError(el, msg) {\n this._errors.push(new I18nError(el.sourceSpan, msg));\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass I18NHtmlParser {\n constructor(_htmlParser, translations, translationsFormat, missingTranslation = MissingTranslationStrategy.Warning, console) {\n this._htmlParser = _htmlParser;\n if (translations) {\n const serializer = createSerializer(translationsFormat);\n this._translationBundle =\n TranslationBundle.load(translations, 'i18n', serializer, missingTranslation, console);\n }\n else {\n this._translationBundle =\n new TranslationBundle({}, null, digest, undefined, missingTranslation, console);\n }\n }\n parse(source, url, parseExpansionForms = false, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {\n const parseResult = this._htmlParser.parse(source, url, parseExpansionForms, interpolationConfig);\n if (parseResult.errors.length) {\n return new ParseTreeResult(parseResult.rootNodes, parseResult.errors);\n }\n return mergeTranslations(parseResult.rootNodes, this._translationBundle, interpolationConfig, [], {});\n }\n}\nfunction createSerializer(format) {\n format = (format || 'xlf').toLowerCase();\n switch (format) {\n case 'xmb':\n return new Xmb();\n case 'xtb':\n return new Xtb();\n case 'xliff2':\n case 'xlf2':\n return new Xliff2();\n case 'xliff':\n case 'xlf':\n default:\n return new Xliff();\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst CORE = '@angular/core';\nclass Identifiers {\n}\nIdentifiers.ANALYZE_FOR_ENTRY_COMPONENTS = {\n name: 'ANALYZE_FOR_ENTRY_COMPONENTS',\n moduleName: CORE,\n};\nIdentifiers.ElementRef = { name: 'ElementRef', moduleName: CORE };\nIdentifiers.NgModuleRef = { name: 'NgModuleRef', moduleName: CORE };\nIdentifiers.ViewContainerRef = { name: 'ViewContainerRef', moduleName: CORE };\nIdentifiers.ChangeDetectorRef = {\n name: 'ChangeDetectorRef',\n moduleName: CORE,\n};\nIdentifiers.QueryList = { name: 'QueryList', moduleName: CORE };\nIdentifiers.TemplateRef = { name: 'TemplateRef', moduleName: CORE };\nIdentifiers.CodegenComponentFactoryResolver = {\n name: 'ɵCodegenComponentFactoryResolver',\n moduleName: CORE,\n};\nIdentifiers.ComponentFactoryResolver = {\n name: 'ComponentFactoryResolver',\n moduleName: CORE,\n};\nIdentifiers.ComponentFactory = { name: 'ComponentFactory', moduleName: CORE };\nIdentifiers.ComponentRef = { name: 'ComponentRef', moduleName: CORE };\nIdentifiers.NgModuleFactory = { name: 'NgModuleFactory', moduleName: CORE };\nIdentifiers.createModuleFactory = {\n name: 'ɵcmf',\n moduleName: CORE,\n};\nIdentifiers.moduleDef = {\n name: 'ɵmod',\n moduleName: CORE,\n};\nIdentifiers.moduleProviderDef = {\n name: 'ɵmpd',\n moduleName: CORE,\n};\nIdentifiers.RegisterModuleFactoryFn = {\n name: 'ɵregisterModuleFactory',\n moduleName: CORE,\n};\nIdentifiers.inject = { name: 'inject', moduleName: CORE };\nIdentifiers.INJECTOR = { name: 'INJECTOR', moduleName: CORE };\nIdentifiers.Injector = { name: 'Injector', moduleName: CORE };\nIdentifiers.defineInjectable = { name: 'defineInjectable', moduleName: CORE };\nIdentifiers.InjectableDef = { name: 'ɵInjectableDef', moduleName: CORE };\nIdentifiers.ViewEncapsulation = {\n name: 'ViewEncapsulation',\n moduleName: CORE,\n};\nIdentifiers.ChangeDetectionStrategy = {\n name: 'ChangeDetectionStrategy',\n moduleName: CORE,\n};\nIdentifiers.SecurityContext = {\n name: 'SecurityContext',\n moduleName: CORE,\n};\nIdentifiers.LOCALE_ID = { name: 'LOCALE_ID', moduleName: CORE };\nIdentifiers.TRANSLATIONS_FORMAT = {\n name: 'TRANSLATIONS_FORMAT',\n moduleName: CORE,\n};\nIdentifiers.inlineInterpolate = {\n name: 'ɵinlineInterpolate',\n moduleName: CORE,\n};\nIdentifiers.interpolate = { name: 'ɵinterpolate', moduleName: CORE };\nIdentifiers.EMPTY_ARRAY = { name: 'ɵEMPTY_ARRAY', moduleName: CORE };\nIdentifiers.EMPTY_MAP = { name: 'ɵEMPTY_MAP', moduleName: CORE };\nIdentifiers.Renderer = { name: 'Renderer', moduleName: CORE };\nIdentifiers.viewDef = { name: 'ɵvid', moduleName: CORE };\nIdentifiers.elementDef = { name: 'ɵeld', moduleName: CORE };\nIdentifiers.anchorDef = { name: 'ɵand', moduleName: CORE };\nIdentifiers.textDef = { name: 'ɵted', moduleName: CORE };\nIdentifiers.directiveDef = { name: 'ɵdid', moduleName: CORE };\nIdentifiers.providerDef = { name: 'ɵprd', moduleName: CORE };\nIdentifiers.queryDef = { name: 'ɵqud', moduleName: CORE };\nIdentifiers.pureArrayDef = { name: 'ɵpad', moduleName: CORE };\nIdentifiers.pureObjectDef = { name: 'ɵpod', moduleName: CORE };\nIdentifiers.purePipeDef = { name: 'ɵppd', moduleName: CORE };\nIdentifiers.pipeDef = { name: 'ɵpid', moduleName: CORE };\nIdentifiers.nodeValue = { name: 'ɵnov', moduleName: CORE };\nIdentifiers.ngContentDef = { name: 'ɵncd', moduleName: CORE };\nIdentifiers.unwrapValue = { name: 'ɵunv', moduleName: CORE };\nIdentifiers.createRendererType2 = { name: 'ɵcrt', moduleName: CORE };\n// type only\nIdentifiers.RendererType2 = {\n name: 'RendererType2',\n moduleName: CORE,\n};\n// type only\nIdentifiers.ViewDefinition = {\n name: 'ɵViewDefinition',\n moduleName: CORE,\n};\nIdentifiers.createComponentFactory = { name: 'ɵccf', moduleName: CORE };\nfunction createTokenForReference(reference) {\n return { identifier: { reference: reference } };\n}\nfunction createTokenForExternalReference(reflector, reference) {\n return createTokenForReference(reflector.resolveExternalReference(reference));\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n//// Types\nvar TypeModifier;\n(function (TypeModifier) {\n TypeModifier[TypeModifier[\"Const\"] = 0] = \"Const\";\n})(TypeModifier || (TypeModifier = {}));\nclass Type$1 {\n constructor(modifiers = null) {\n this.modifiers = modifiers;\n if (!modifiers) {\n this.modifiers = [];\n }\n }\n hasModifier(modifier) { return this.modifiers.indexOf(modifier) !== -1; }\n}\nvar BuiltinTypeName;\n(function (BuiltinTypeName) {\n BuiltinTypeName[BuiltinTypeName[\"Dynamic\"] = 0] = \"Dynamic\";\n BuiltinTypeName[BuiltinTypeName[\"Bool\"] = 1] = \"Bool\";\n BuiltinTypeName[BuiltinTypeName[\"String\"] = 2] = \"String\";\n BuiltinTypeName[BuiltinTypeName[\"Int\"] = 3] = \"Int\";\n BuiltinTypeName[BuiltinTypeName[\"Number\"] = 4] = \"Number\";\n BuiltinTypeName[BuiltinTypeName[\"Function\"] = 5] = \"Function\";\n BuiltinTypeName[BuiltinTypeName[\"Inferred\"] = 6] = \"Inferred\";\n BuiltinTypeName[BuiltinTypeName[\"None\"] = 7] = \"None\";\n})(BuiltinTypeName || (BuiltinTypeName = {}));\nclass BuiltinType extends Type$1 {\n constructor(name, modifiers = null) {\n super(modifiers);\n this.name = name;\n }\n visitType(visitor, context) {\n return visitor.visitBuiltinType(this, context);\n }\n}\nclass ExpressionType extends Type$1 {\n constructor(value, modifiers = null, typeParams = null) {\n super(modifiers);\n this.value = value;\n this.typeParams = typeParams;\n }\n visitType(visitor, context) {\n return visitor.visitExpressionType(this, context);\n }\n}\nclass ArrayType extends Type$1 {\n constructor(of, modifiers = null) {\n super(modifiers);\n this.of = of;\n }\n visitType(visitor, context) {\n return visitor.visitArrayType(this, context);\n }\n}\nclass MapType extends Type$1 {\n constructor(valueType, modifiers = null) {\n super(modifiers);\n this.valueType = valueType || null;\n }\n visitType(visitor, context) { return visitor.visitMapType(this, context); }\n}\nconst DYNAMIC_TYPE = new BuiltinType(BuiltinTypeName.Dynamic);\nconst INFERRED_TYPE = new BuiltinType(BuiltinTypeName.Inferred);\nconst BOOL_TYPE = new BuiltinType(BuiltinTypeName.Bool);\nconst INT_TYPE = new BuiltinType(BuiltinTypeName.Int);\nconst NUMBER_TYPE = new BuiltinType(BuiltinTypeName.Number);\nconst STRING_TYPE = new BuiltinType(BuiltinTypeName.String);\nconst FUNCTION_TYPE = new BuiltinType(BuiltinTypeName.Function);\nconst NONE_TYPE = new BuiltinType(BuiltinTypeName.None);\n///// Expressions\nvar BinaryOperator;\n(function (BinaryOperator) {\n BinaryOperator[BinaryOperator[\"Equals\"] = 0] = \"Equals\";\n BinaryOperator[BinaryOperator[\"NotEquals\"] = 1] = \"NotEquals\";\n BinaryOperator[BinaryOperator[\"Identical\"] = 2] = \"Identical\";\n BinaryOperator[BinaryOperator[\"NotIdentical\"] = 3] = \"NotIdentical\";\n BinaryOperator[BinaryOperator[\"Minus\"] = 4] = \"Minus\";\n BinaryOperator[BinaryOperator[\"Plus\"] = 5] = \"Plus\";\n BinaryOperator[BinaryOperator[\"Divide\"] = 6] = \"Divide\";\n BinaryOperator[BinaryOperator[\"Multiply\"] = 7] = \"Multiply\";\n BinaryOperator[BinaryOperator[\"Modulo\"] = 8] = \"Modulo\";\n BinaryOperator[BinaryOperator[\"And\"] = 9] = \"And\";\n BinaryOperator[BinaryOperator[\"Or\"] = 10] = \"Or\";\n BinaryOperator[BinaryOperator[\"BitwiseAnd\"] = 11] = \"BitwiseAnd\";\n BinaryOperator[BinaryOperator[\"Lower\"] = 12] = \"Lower\";\n BinaryOperator[BinaryOperator[\"LowerEquals\"] = 13] = \"LowerEquals\";\n BinaryOperator[BinaryOperator[\"Bigger\"] = 14] = \"Bigger\";\n BinaryOperator[BinaryOperator[\"BiggerEquals\"] = 15] = \"BiggerEquals\";\n})(BinaryOperator || (BinaryOperator = {}));\nfunction nullSafeIsEquivalent(base, other) {\n if (base == null || other == null) {\n return base == other;\n }\n return base.isEquivalent(other);\n}\nfunction areAllEquivalent(base, other) {\n const len = base.length;\n if (len !== other.length) {\n return false;\n }\n for (let i = 0; i < len; i++) {\n if (!base[i].isEquivalent(other[i])) {\n return false;\n }\n }\n return true;\n}\nclass Expression {\n constructor(type, sourceSpan) {\n this.type = type || null;\n this.sourceSpan = sourceSpan || null;\n }\n prop(name, sourceSpan) {\n return new ReadPropExpr(this, name, null, sourceSpan);\n }\n key(index, type, sourceSpan) {\n return new ReadKeyExpr(this, index, type, sourceSpan);\n }\n callMethod(name, params, sourceSpan) {\n return new InvokeMethodExpr(this, name, params, null, sourceSpan);\n }\n callFn(params, sourceSpan) {\n return new InvokeFunctionExpr(this, params, null, sourceSpan);\n }\n instantiate(params, type, sourceSpan) {\n return new InstantiateExpr(this, params, type, sourceSpan);\n }\n conditional(trueCase, falseCase = null, sourceSpan) {\n return new ConditionalExpr(this, trueCase, falseCase, null, sourceSpan);\n }\n equals(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Equals, this, rhs, null, sourceSpan);\n }\n notEquals(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.NotEquals, this, rhs, null, sourceSpan);\n }\n identical(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Identical, this, rhs, null, sourceSpan);\n }\n notIdentical(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.NotIdentical, this, rhs, null, sourceSpan);\n }\n minus(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Minus, this, rhs, null, sourceSpan);\n }\n plus(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Plus, this, rhs, null, sourceSpan);\n }\n divide(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Divide, this, rhs, null, sourceSpan);\n }\n multiply(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Multiply, this, rhs, null, sourceSpan);\n }\n modulo(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Modulo, this, rhs, null, sourceSpan);\n }\n and(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.And, this, rhs, null, sourceSpan);\n }\n bitwiseAnd(rhs, sourceSpan, parens = true) {\n return new BinaryOperatorExpr(BinaryOperator.BitwiseAnd, this, rhs, null, sourceSpan, parens);\n }\n or(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Or, this, rhs, null, sourceSpan);\n }\n lower(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Lower, this, rhs, null, sourceSpan);\n }\n lowerEquals(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.LowerEquals, this, rhs, null, sourceSpan);\n }\n bigger(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.Bigger, this, rhs, null, sourceSpan);\n }\n biggerEquals(rhs, sourceSpan) {\n return new BinaryOperatorExpr(BinaryOperator.BiggerEquals, this, rhs, null, sourceSpan);\n }\n isBlank(sourceSpan) {\n // Note: We use equals by purpose here to compare to null and undefined in JS.\n // We use the typed null to allow strictNullChecks to narrow types.\n return this.equals(TYPED_NULL_EXPR, sourceSpan);\n }\n cast(type, sourceSpan) {\n return new CastExpr(this, type, sourceSpan);\n }\n toStmt() { return new ExpressionStatement(this, null); }\n}\nvar BuiltinVar;\n(function (BuiltinVar) {\n BuiltinVar[BuiltinVar[\"This\"] = 0] = \"This\";\n BuiltinVar[BuiltinVar[\"Super\"] = 1] = \"Super\";\n BuiltinVar[BuiltinVar[\"CatchError\"] = 2] = \"CatchError\";\n BuiltinVar[BuiltinVar[\"CatchStack\"] = 3] = \"CatchStack\";\n})(BuiltinVar || (BuiltinVar = {}));\nclass ReadVarExpr extends Expression {\n constructor(name, type, sourceSpan) {\n super(type, sourceSpan);\n if (typeof name === 'string') {\n this.name = name;\n this.builtin = null;\n }\n else {\n this.name = null;\n this.builtin = name;\n }\n }\n isEquivalent(e) {\n return e instanceof ReadVarExpr && this.name === e.name && this.builtin === e.builtin;\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitReadVarExpr(this, context);\n }\n set(value) {\n if (!this.name) {\n throw new Error(`Built in variable ${this.builtin} can not be assigned to.`);\n }\n return new WriteVarExpr(this.name, value, null, this.sourceSpan);\n }\n}\nclass TypeofExpr extends Expression {\n constructor(expr, type, sourceSpan) {\n super(type, sourceSpan);\n this.expr = expr;\n }\n visitExpression(visitor, context) {\n return visitor.visitTypeofExpr(this, context);\n }\n isEquivalent(e) {\n return e instanceof TypeofExpr && e.expr.isEquivalent(this.expr);\n }\n isConstant() { return this.expr.isConstant(); }\n}\nclass WrappedNodeExpr extends Expression {\n constructor(node, type, sourceSpan) {\n super(type, sourceSpan);\n this.node = node;\n }\n isEquivalent(e) {\n return e instanceof WrappedNodeExpr && this.node === e.node;\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitWrappedNodeExpr(this, context);\n }\n}\nclass WriteVarExpr extends Expression {\n constructor(name, value, type, sourceSpan) {\n super(type || value.type, sourceSpan);\n this.name = name;\n this.value = value;\n }\n isEquivalent(e) {\n return e instanceof WriteVarExpr && this.name === e.name && this.value.isEquivalent(e.value);\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitWriteVarExpr(this, context);\n }\n toDeclStmt(type, modifiers) {\n return new DeclareVarStmt(this.name, this.value, type, modifiers, this.sourceSpan);\n }\n}\nclass WriteKeyExpr extends Expression {\n constructor(receiver, index, value, type, sourceSpan) {\n super(type || value.type, sourceSpan);\n this.receiver = receiver;\n this.index = index;\n this.value = value;\n }\n isEquivalent(e) {\n return e instanceof WriteKeyExpr && this.receiver.isEquivalent(e.receiver) &&\n this.index.isEquivalent(e.index) && this.value.isEquivalent(e.value);\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitWriteKeyExpr(this, context);\n }\n}\nclass WritePropExpr extends Expression {\n constructor(receiver, name, value, type, sourceSpan) {\n super(type || value.type, sourceSpan);\n this.receiver = receiver;\n this.name = name;\n this.value = value;\n }\n isEquivalent(e) {\n return e instanceof WritePropExpr && this.receiver.isEquivalent(e.receiver) &&\n this.name === e.name && this.value.isEquivalent(e.value);\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitWritePropExpr(this, context);\n }\n}\nvar BuiltinMethod;\n(function (BuiltinMethod) {\n BuiltinMethod[BuiltinMethod[\"ConcatArray\"] = 0] = \"ConcatArray\";\n BuiltinMethod[BuiltinMethod[\"SubscribeObservable\"] = 1] = \"SubscribeObservable\";\n BuiltinMethod[BuiltinMethod[\"Bind\"] = 2] = \"Bind\";\n})(BuiltinMethod || (BuiltinMethod = {}));\nclass InvokeMethodExpr extends Expression {\n constructor(receiver, method, args, type, sourceSpan) {\n super(type, sourceSpan);\n this.receiver = receiver;\n this.args = args;\n if (typeof method === 'string') {\n this.name = method;\n this.builtin = null;\n }\n else {\n this.name = null;\n this.builtin = method;\n }\n }\n isEquivalent(e) {\n return e instanceof InvokeMethodExpr && this.receiver.isEquivalent(e.receiver) &&\n this.name === e.name && this.builtin === e.builtin && areAllEquivalent(this.args, e.args);\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitInvokeMethodExpr(this, context);\n }\n}\nclass InvokeFunctionExpr extends Expression {\n constructor(fn, args, type, sourceSpan) {\n super(type, sourceSpan);\n this.fn = fn;\n this.args = args;\n }\n isEquivalent(e) {\n return e instanceof InvokeFunctionExpr && this.fn.isEquivalent(e.fn) &&\n areAllEquivalent(this.args, e.args);\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitInvokeFunctionExpr(this, context);\n }\n}\nclass InstantiateExpr extends Expression {\n constructor(classExpr, args, type, sourceSpan) {\n super(type, sourceSpan);\n this.classExpr = classExpr;\n this.args = args;\n }\n isEquivalent(e) {\n return e instanceof InstantiateExpr && this.classExpr.isEquivalent(e.classExpr) &&\n areAllEquivalent(this.args, e.args);\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitInstantiateExpr(this, context);\n }\n}\nclass LiteralExpr extends Expression {\n constructor(value, type, sourceSpan) {\n super(type, sourceSpan);\n this.value = value;\n }\n isEquivalent(e) {\n return e instanceof LiteralExpr && this.value === e.value;\n }\n isConstant() { return true; }\n visitExpression(visitor, context) {\n return visitor.visitLiteralExpr(this, context);\n }\n}\nclass ExternalExpr extends Expression {\n constructor(value, type, typeParams = null, sourceSpan) {\n super(type, sourceSpan);\n this.value = value;\n this.typeParams = typeParams;\n }\n isEquivalent(e) {\n return e instanceof ExternalExpr && this.value.name === e.value.name &&\n this.value.moduleName === e.value.moduleName && this.value.runtime === e.value.runtime;\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitExternalExpr(this, context);\n }\n}\nclass ExternalReference {\n constructor(moduleName, name, runtime) {\n this.moduleName = moduleName;\n this.name = name;\n this.runtime = runtime;\n }\n}\nclass ConditionalExpr extends Expression {\n constructor(condition, trueCase, falseCase = null, type, sourceSpan) {\n super(type || trueCase.type, sourceSpan);\n this.condition = condition;\n this.falseCase = falseCase;\n this.trueCase = trueCase;\n }\n isEquivalent(e) {\n return e instanceof ConditionalExpr && this.condition.isEquivalent(e.condition) &&\n this.trueCase.isEquivalent(e.trueCase) && nullSafeIsEquivalent(this.falseCase, e.falseCase);\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitConditionalExpr(this, context);\n }\n}\nclass NotExpr extends Expression {\n constructor(condition, sourceSpan) {\n super(BOOL_TYPE, sourceSpan);\n this.condition = condition;\n }\n isEquivalent(e) {\n return e instanceof NotExpr && this.condition.isEquivalent(e.condition);\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitNotExpr(this, context);\n }\n}\nclass AssertNotNull extends Expression {\n constructor(condition, sourceSpan) {\n super(condition.type, sourceSpan);\n this.condition = condition;\n }\n isEquivalent(e) {\n return e instanceof AssertNotNull && this.condition.isEquivalent(e.condition);\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitAssertNotNullExpr(this, context);\n }\n}\nclass CastExpr extends Expression {\n constructor(value, type, sourceSpan) {\n super(type, sourceSpan);\n this.value = value;\n }\n isEquivalent(e) {\n return e instanceof CastExpr && this.value.isEquivalent(e.value);\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitCastExpr(this, context);\n }\n}\nclass FnParam {\n constructor(name, type = null) {\n this.name = name;\n this.type = type;\n }\n isEquivalent(param) { return this.name === param.name; }\n}\nclass FunctionExpr extends Expression {\n constructor(params, statements, type, sourceSpan, name) {\n super(type, sourceSpan);\n this.params = params;\n this.statements = statements;\n this.name = name;\n }\n isEquivalent(e) {\n return e instanceof FunctionExpr && areAllEquivalent(this.params, e.params) &&\n areAllEquivalent(this.statements, e.statements);\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitFunctionExpr(this, context);\n }\n toDeclStmt(name, modifiers = null) {\n return new DeclareFunctionStmt(name, this.params, this.statements, this.type, modifiers, this.sourceSpan);\n }\n}\nclass BinaryOperatorExpr extends Expression {\n constructor(operator, lhs, rhs, type, sourceSpan, parens = true) {\n super(type || lhs.type, sourceSpan);\n this.operator = operator;\n this.rhs = rhs;\n this.parens = parens;\n this.lhs = lhs;\n }\n isEquivalent(e) {\n return e instanceof BinaryOperatorExpr && this.operator === e.operator &&\n this.lhs.isEquivalent(e.lhs) && this.rhs.isEquivalent(e.rhs);\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitBinaryOperatorExpr(this, context);\n }\n}\nclass ReadPropExpr extends Expression {\n constructor(receiver, name, type, sourceSpan) {\n super(type, sourceSpan);\n this.receiver = receiver;\n this.name = name;\n }\n isEquivalent(e) {\n return e instanceof ReadPropExpr && this.receiver.isEquivalent(e.receiver) &&\n this.name === e.name;\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitReadPropExpr(this, context);\n }\n set(value) {\n return new WritePropExpr(this.receiver, this.name, value, null, this.sourceSpan);\n }\n}\nclass ReadKeyExpr extends Expression {\n constructor(receiver, index, type, sourceSpan) {\n super(type, sourceSpan);\n this.receiver = receiver;\n this.index = index;\n }\n isEquivalent(e) {\n return e instanceof ReadKeyExpr && this.receiver.isEquivalent(e.receiver) &&\n this.index.isEquivalent(e.index);\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitReadKeyExpr(this, context);\n }\n set(value) {\n return new WriteKeyExpr(this.receiver, this.index, value, null, this.sourceSpan);\n }\n}\nclass LiteralArrayExpr extends Expression {\n constructor(entries, type, sourceSpan) {\n super(type, sourceSpan);\n this.entries = entries;\n }\n isConstant() { return this.entries.every(e => e.isConstant()); }\n isEquivalent(e) {\n return e instanceof LiteralArrayExpr && areAllEquivalent(this.entries, e.entries);\n }\n visitExpression(visitor, context) {\n return visitor.visitLiteralArrayExpr(this, context);\n }\n}\nclass LiteralMapEntry {\n constructor(key, value, quoted) {\n this.key = key;\n this.value = value;\n this.quoted = quoted;\n }\n isEquivalent(e) {\n return this.key === e.key && this.value.isEquivalent(e.value);\n }\n}\nclass LiteralMapExpr extends Expression {\n constructor(entries, type, sourceSpan) {\n super(type, sourceSpan);\n this.entries = entries;\n this.valueType = null;\n if (type) {\n this.valueType = type.valueType;\n }\n }\n isEquivalent(e) {\n return e instanceof LiteralMapExpr && areAllEquivalent(this.entries, e.entries);\n }\n isConstant() { return this.entries.every(e => e.value.isConstant()); }\n visitExpression(visitor, context) {\n return visitor.visitLiteralMapExpr(this, context);\n }\n}\nclass CommaExpr extends Expression {\n constructor(parts, sourceSpan) {\n super(parts[parts.length - 1].type, sourceSpan);\n this.parts = parts;\n }\n isEquivalent(e) {\n return e instanceof CommaExpr && areAllEquivalent(this.parts, e.parts);\n }\n isConstant() { return false; }\n visitExpression(visitor, context) {\n return visitor.visitCommaExpr(this, context);\n }\n}\nconst THIS_EXPR = new ReadVarExpr(BuiltinVar.This, null, null);\nconst SUPER_EXPR = new ReadVarExpr(BuiltinVar.Super, null, null);\nconst CATCH_ERROR_VAR = new ReadVarExpr(BuiltinVar.CatchError, null, null);\nconst CATCH_STACK_VAR = new ReadVarExpr(BuiltinVar.CatchStack, null, null);\nconst NULL_EXPR = new LiteralExpr(null, null, null);\nconst TYPED_NULL_EXPR = new LiteralExpr(null, INFERRED_TYPE, null);\n//// Statements\nvar StmtModifier;\n(function (StmtModifier) {\n StmtModifier[StmtModifier[\"Final\"] = 0] = \"Final\";\n StmtModifier[StmtModifier[\"Private\"] = 1] = \"Private\";\n StmtModifier[StmtModifier[\"Exported\"] = 2] = \"Exported\";\n StmtModifier[StmtModifier[\"Static\"] = 3] = \"Static\";\n})(StmtModifier || (StmtModifier = {}));\nclass Statement {\n constructor(modifiers, sourceSpan) {\n this.modifiers = modifiers || [];\n this.sourceSpan = sourceSpan || null;\n }\n hasModifier(modifier) { return this.modifiers.indexOf(modifier) !== -1; }\n}\nclass DeclareVarStmt extends Statement {\n constructor(name, value, type, modifiers = null, sourceSpan) {\n super(modifiers, sourceSpan);\n this.name = name;\n this.value = value;\n this.type = type || (value && value.type) || null;\n }\n isEquivalent(stmt) {\n return stmt instanceof DeclareVarStmt && this.name === stmt.name &&\n (this.value ? !!stmt.value && this.value.isEquivalent(stmt.value) : !stmt.value);\n }\n visitStatement(visitor, context) {\n return visitor.visitDeclareVarStmt(this, context);\n }\n}\nclass DeclareFunctionStmt extends Statement {\n constructor(name, params, statements, type, modifiers = null, sourceSpan) {\n super(modifiers, sourceSpan);\n this.name = name;\n this.params = params;\n this.statements = statements;\n this.type = type || null;\n }\n isEquivalent(stmt) {\n return stmt instanceof DeclareFunctionStmt && areAllEquivalent(this.params, stmt.params) &&\n areAllEquivalent(this.statements, stmt.statements);\n }\n visitStatement(visitor, context) {\n return visitor.visitDeclareFunctionStmt(this, context);\n }\n}\nclass ExpressionStatement extends Statement {\n constructor(expr, sourceSpan) {\n super(null, sourceSpan);\n this.expr = expr;\n }\n isEquivalent(stmt) {\n return stmt instanceof ExpressionStatement && this.expr.isEquivalent(stmt.expr);\n }\n visitStatement(visitor, context) {\n return visitor.visitExpressionStmt(this, context);\n }\n}\nclass ReturnStatement extends Statement {\n constructor(value, sourceSpan) {\n super(null, sourceSpan);\n this.value = value;\n }\n isEquivalent(stmt) {\n return stmt instanceof ReturnStatement && this.value.isEquivalent(stmt.value);\n }\n visitStatement(visitor, context) {\n return visitor.visitReturnStmt(this, context);\n }\n}\nclass AbstractClassPart {\n constructor(type, modifiers) {\n this.modifiers = modifiers;\n if (!modifiers) {\n this.modifiers = [];\n }\n this.type = type || null;\n }\n hasModifier(modifier) { return this.modifiers.indexOf(modifier) !== -1; }\n}\nclass ClassField extends AbstractClassPart {\n constructor(name, type, modifiers = null, initializer) {\n super(type, modifiers);\n this.name = name;\n this.initializer = initializer;\n }\n isEquivalent(f) { return this.name === f.name; }\n}\nclass ClassMethod extends AbstractClassPart {\n constructor(name, params, body, type, modifiers = null) {\n super(type, modifiers);\n this.name = name;\n this.params = params;\n this.body = body;\n }\n isEquivalent(m) {\n return this.name === m.name && areAllEquivalent(this.body, m.body);\n }\n}\nclass ClassGetter extends AbstractClassPart {\n constructor(name, body, type, modifiers = null) {\n super(type, modifiers);\n this.name = name;\n this.body = body;\n }\n isEquivalent(m) {\n return this.name === m.name && areAllEquivalent(this.body, m.body);\n }\n}\nclass ClassStmt extends Statement {\n constructor(name, parent, fields, getters, constructorMethod, methods, modifiers = null, sourceSpan) {\n super(modifiers, sourceSpan);\n this.name = name;\n this.parent = parent;\n this.fields = fields;\n this.getters = getters;\n this.constructorMethod = constructorMethod;\n this.methods = methods;\n }\n isEquivalent(stmt) {\n return stmt instanceof ClassStmt && this.name === stmt.name &&\n nullSafeIsEquivalent(this.parent, stmt.parent) &&\n areAllEquivalent(this.fields, stmt.fields) &&\n areAllEquivalent(this.getters, stmt.getters) &&\n this.constructorMethod.isEquivalent(stmt.constructorMethod) &&\n areAllEquivalent(this.methods, stmt.methods);\n }\n visitStatement(visitor, context) {\n return visitor.visitDeclareClassStmt(this, context);\n }\n}\nclass IfStmt extends Statement {\n constructor(condition, trueCase, falseCase = [], sourceSpan) {\n super(null, sourceSpan);\n this.condition = condition;\n this.trueCase = trueCase;\n this.falseCase = falseCase;\n }\n isEquivalent(stmt) {\n return stmt instanceof IfStmt && this.condition.isEquivalent(stmt.condition) &&\n areAllEquivalent(this.trueCase, stmt.trueCase) &&\n areAllEquivalent(this.falseCase, stmt.falseCase);\n }\n visitStatement(visitor, context) {\n return visitor.visitIfStmt(this, context);\n }\n}\nclass CommentStmt extends Statement {\n constructor(comment, multiline = false, sourceSpan) {\n super(null, sourceSpan);\n this.comment = comment;\n this.multiline = multiline;\n }\n isEquivalent(stmt) { return stmt instanceof CommentStmt; }\n visitStatement(visitor, context) {\n return visitor.visitCommentStmt(this, context);\n }\n}\nclass JSDocCommentStmt extends Statement {\n constructor(tags = [], sourceSpan) {\n super(null, sourceSpan);\n this.tags = tags;\n }\n isEquivalent(stmt) {\n return stmt instanceof JSDocCommentStmt && this.toString() === stmt.toString();\n }\n visitStatement(visitor, context) {\n return visitor.visitJSDocCommentStmt(this, context);\n }\n toString() { return serializeTags(this.tags); }\n}\nclass TryCatchStmt extends Statement {\n constructor(bodyStmts, catchStmts, sourceSpan) {\n super(null, sourceSpan);\n this.bodyStmts = bodyStmts;\n this.catchStmts = catchStmts;\n }\n isEquivalent(stmt) {\n return stmt instanceof TryCatchStmt && areAllEquivalent(this.bodyStmts, stmt.bodyStmts) &&\n areAllEquivalent(this.catchStmts, stmt.catchStmts);\n }\n visitStatement(visitor, context) {\n return visitor.visitTryCatchStmt(this, context);\n }\n}\nclass ThrowStmt extends Statement {\n constructor(error, sourceSpan) {\n super(null, sourceSpan);\n this.error = error;\n }\n isEquivalent(stmt) {\n return stmt instanceof TryCatchStmt && this.error.isEquivalent(stmt.error);\n }\n visitStatement(visitor, context) {\n return visitor.visitThrowStmt(this, context);\n }\n}\nclass AstTransformer$1 {\n transformExpr(expr, context) { return expr; }\n transformStmt(stmt, context) { return stmt; }\n visitReadVarExpr(ast, context) { return this.transformExpr(ast, context); }\n visitWrappedNodeExpr(ast, context) {\n return this.transformExpr(ast, context);\n }\n visitTypeofExpr(expr, context) {\n return this.transformExpr(new TypeofExpr(expr.expr.visitExpression(this, context), expr.type, expr.sourceSpan), context);\n }\n visitWriteVarExpr(expr, context) {\n return this.transformExpr(new WriteVarExpr(expr.name, expr.value.visitExpression(this, context), expr.type, expr.sourceSpan), context);\n }\n visitWriteKeyExpr(expr, context) {\n return this.transformExpr(new WriteKeyExpr(expr.receiver.visitExpression(this, context), expr.index.visitExpression(this, context), expr.value.visitExpression(this, context), expr.type, expr.sourceSpan), context);\n }\n visitWritePropExpr(expr, context) {\n return this.transformExpr(new WritePropExpr(expr.receiver.visitExpression(this, context), expr.name, expr.value.visitExpression(this, context), expr.type, expr.sourceSpan), context);\n }\n visitInvokeMethodExpr(ast, context) {\n const method = ast.builtin || ast.name;\n return this.transformExpr(new InvokeMethodExpr(ast.receiver.visitExpression(this, context), method, this.visitAllExpressions(ast.args, context), ast.type, ast.sourceSpan), context);\n }\n visitInvokeFunctionExpr(ast, context) {\n return this.transformExpr(new InvokeFunctionExpr(ast.fn.visitExpression(this, context), this.visitAllExpressions(ast.args, context), ast.type, ast.sourceSpan), context);\n }\n visitInstantiateExpr(ast, context) {\n return this.transformExpr(new InstantiateExpr(ast.classExpr.visitExpression(this, context), this.visitAllExpressions(ast.args, context), ast.type, ast.sourceSpan), context);\n }\n visitLiteralExpr(ast, context) { return this.transformExpr(ast, context); }\n visitExternalExpr(ast, context) {\n return this.transformExpr(ast, context);\n }\n visitConditionalExpr(ast, context) {\n return this.transformExpr(new ConditionalExpr(ast.condition.visitExpression(this, context), ast.trueCase.visitExpression(this, context), ast.falseCase.visitExpression(this, context), ast.type, ast.sourceSpan), context);\n }\n visitNotExpr(ast, context) {\n return this.transformExpr(new NotExpr(ast.condition.visitExpression(this, context), ast.sourceSpan), context);\n }\n visitAssertNotNullExpr(ast, context) {\n return this.transformExpr(new AssertNotNull(ast.condition.visitExpression(this, context), ast.sourceSpan), context);\n }\n visitCastExpr(ast, context) {\n return this.transformExpr(new CastExpr(ast.value.visitExpression(this, context), ast.type, ast.sourceSpan), context);\n }\n visitFunctionExpr(ast, context) {\n return this.transformExpr(new FunctionExpr(ast.params, this.visitAllStatements(ast.statements, context), ast.type, ast.sourceSpan), context);\n }\n visitBinaryOperatorExpr(ast, context) {\n return this.transformExpr(new BinaryOperatorExpr(ast.operator, ast.lhs.visitExpression(this, context), ast.rhs.visitExpression(this, context), ast.type, ast.sourceSpan), context);\n }\n visitReadPropExpr(ast, context) {\n return this.transformExpr(new ReadPropExpr(ast.receiver.visitExpression(this, context), ast.name, ast.type, ast.sourceSpan), context);\n }\n visitReadKeyExpr(ast, context) {\n return this.transformExpr(new ReadKeyExpr(ast.receiver.visitExpression(this, context), ast.index.visitExpression(this, context), ast.type, ast.sourceSpan), context);\n }\n visitLiteralArrayExpr(ast, context) {\n return this.transformExpr(new LiteralArrayExpr(this.visitAllExpressions(ast.entries, context), ast.type, ast.sourceSpan), context);\n }\n visitLiteralMapExpr(ast, context) {\n const entries = ast.entries.map((entry) => new LiteralMapEntry(entry.key, entry.value.visitExpression(this, context), entry.quoted));\n const mapType = new MapType(ast.valueType, null);\n return this.transformExpr(new LiteralMapExpr(entries, mapType, ast.sourceSpan), context);\n }\n visitCommaExpr(ast, context) {\n return this.transformExpr(new CommaExpr(this.visitAllExpressions(ast.parts, context), ast.sourceSpan), context);\n }\n visitAllExpressions(exprs, context) {\n return exprs.map(expr => expr.visitExpression(this, context));\n }\n visitDeclareVarStmt(stmt, context) {\n const value = stmt.value && stmt.value.visitExpression(this, context);\n return this.transformStmt(new DeclareVarStmt(stmt.name, value, stmt.type, stmt.modifiers, stmt.sourceSpan), context);\n }\n visitDeclareFunctionStmt(stmt, context) {\n return this.transformStmt(new DeclareFunctionStmt(stmt.name, stmt.params, this.visitAllStatements(stmt.statements, context), stmt.type, stmt.modifiers, stmt.sourceSpan), context);\n }\n visitExpressionStmt(stmt, context) {\n return this.transformStmt(new ExpressionStatement(stmt.expr.visitExpression(this, context), stmt.sourceSpan), context);\n }\n visitReturnStmt(stmt, context) {\n return this.transformStmt(new ReturnStatement(stmt.value.visitExpression(this, context), stmt.sourceSpan), context);\n }\n visitDeclareClassStmt(stmt, context) {\n const parent = stmt.parent.visitExpression(this, context);\n const getters = stmt.getters.map(getter => new ClassGetter(getter.name, this.visitAllStatements(getter.body, context), getter.type, getter.modifiers));\n const ctorMethod = stmt.constructorMethod &&\n new ClassMethod(stmt.constructorMethod.name, stmt.constructorMethod.params, this.visitAllStatements(stmt.constructorMethod.body, context), stmt.constructorMethod.type, stmt.constructorMethod.modifiers);\n const methods = stmt.methods.map(method => new ClassMethod(method.name, method.params, this.visitAllStatements(method.body, context), method.type, method.modifiers));\n return this.transformStmt(new ClassStmt(stmt.name, parent, stmt.fields, getters, ctorMethod, methods, stmt.modifiers, stmt.sourceSpan), context);\n }\n visitIfStmt(stmt, context) {\n return this.transformStmt(new IfStmt(stmt.condition.visitExpression(this, context), this.visitAllStatements(stmt.trueCase, context), this.visitAllStatements(stmt.falseCase, context), stmt.sourceSpan), context);\n }\n visitTryCatchStmt(stmt, context) {\n return this.transformStmt(new TryCatchStmt(this.visitAllStatements(stmt.bodyStmts, context), this.visitAllStatements(stmt.catchStmts, context), stmt.sourceSpan), context);\n }\n visitThrowStmt(stmt, context) {\n return this.transformStmt(new ThrowStmt(stmt.error.visitExpression(this, context), stmt.sourceSpan), context);\n }\n visitCommentStmt(stmt, context) {\n return this.transformStmt(stmt, context);\n }\n visitJSDocCommentStmt(stmt, context) {\n return this.transformStmt(stmt, context);\n }\n visitAllStatements(stmts, context) {\n return stmts.map(stmt => stmt.visitStatement(this, context));\n }\n}\nclass RecursiveAstVisitor$1 {\n visitType(ast, context) { return ast; }\n visitExpression(ast, context) {\n if (ast.type) {\n ast.type.visitType(this, context);\n }\n return ast;\n }\n visitBuiltinType(type, context) { return this.visitType(type, context); }\n visitExpressionType(type, context) {\n type.value.visitExpression(this, context);\n if (type.typeParams !== null) {\n type.typeParams.forEach(param => this.visitType(param, context));\n }\n return this.visitType(type, context);\n }\n visitArrayType(type, context) { return this.visitType(type, context); }\n visitMapType(type, context) { return this.visitType(type, context); }\n visitWrappedNodeExpr(ast, context) { return ast; }\n visitTypeofExpr(ast, context) { return this.visitExpression(ast, context); }\n visitReadVarExpr(ast, context) {\n return this.visitExpression(ast, context);\n }\n visitWriteVarExpr(ast, context) {\n ast.value.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitWriteKeyExpr(ast, context) {\n ast.receiver.visitExpression(this, context);\n ast.index.visitExpression(this, context);\n ast.value.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitWritePropExpr(ast, context) {\n ast.receiver.visitExpression(this, context);\n ast.value.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitInvokeMethodExpr(ast, context) {\n ast.receiver.visitExpression(this, context);\n this.visitAllExpressions(ast.args, context);\n return this.visitExpression(ast, context);\n }\n visitInvokeFunctionExpr(ast, context) {\n ast.fn.visitExpression(this, context);\n this.visitAllExpressions(ast.args, context);\n return this.visitExpression(ast, context);\n }\n visitInstantiateExpr(ast, context) {\n ast.classExpr.visitExpression(this, context);\n this.visitAllExpressions(ast.args, context);\n return this.visitExpression(ast, context);\n }\n visitLiteralExpr(ast, context) {\n return this.visitExpression(ast, context);\n }\n visitExternalExpr(ast, context) {\n if (ast.typeParams) {\n ast.typeParams.forEach(type => type.visitType(this, context));\n }\n return this.visitExpression(ast, context);\n }\n visitConditionalExpr(ast, context) {\n ast.condition.visitExpression(this, context);\n ast.trueCase.visitExpression(this, context);\n ast.falseCase.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitNotExpr(ast, context) {\n ast.condition.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitAssertNotNullExpr(ast, context) {\n ast.condition.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitCastExpr(ast, context) {\n ast.value.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitFunctionExpr(ast, context) {\n this.visitAllStatements(ast.statements, context);\n return this.visitExpression(ast, context);\n }\n visitBinaryOperatorExpr(ast, context) {\n ast.lhs.visitExpression(this, context);\n ast.rhs.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitReadPropExpr(ast, context) {\n ast.receiver.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitReadKeyExpr(ast, context) {\n ast.receiver.visitExpression(this, context);\n ast.index.visitExpression(this, context);\n return this.visitExpression(ast, context);\n }\n visitLiteralArrayExpr(ast, context) {\n this.visitAllExpressions(ast.entries, context);\n return this.visitExpression(ast, context);\n }\n visitLiteralMapExpr(ast, context) {\n ast.entries.forEach((entry) => entry.value.visitExpression(this, context));\n return this.visitExpression(ast, context);\n }\n visitCommaExpr(ast, context) {\n this.visitAllExpressions(ast.parts, context);\n return this.visitExpression(ast, context);\n }\n visitAllExpressions(exprs, context) {\n exprs.forEach(expr => expr.visitExpression(this, context));\n }\n visitDeclareVarStmt(stmt, context) {\n if (stmt.value) {\n stmt.value.visitExpression(this, context);\n }\n if (stmt.type) {\n stmt.type.visitType(this, context);\n }\n return stmt;\n }\n visitDeclareFunctionStmt(stmt, context) {\n this.visitAllStatements(stmt.statements, context);\n if (stmt.type) {\n stmt.type.visitType(this, context);\n }\n return stmt;\n }\n visitExpressionStmt(stmt, context) {\n stmt.expr.visitExpression(this, context);\n return stmt;\n }\n visitReturnStmt(stmt, context) {\n stmt.value.visitExpression(this, context);\n return stmt;\n }\n visitDeclareClassStmt(stmt, context) {\n stmt.parent.visitExpression(this, context);\n stmt.getters.forEach(getter => this.visitAllStatements(getter.body, context));\n if (stmt.constructorMethod) {\n this.visitAllStatements(stmt.constructorMethod.body, context);\n }\n stmt.methods.forEach(method => this.visitAllStatements(method.body, context));\n return stmt;\n }\n visitIfStmt(stmt, context) {\n stmt.condition.visitExpression(this, context);\n this.visitAllStatements(stmt.trueCase, context);\n this.visitAllStatements(stmt.falseCase, context);\n return stmt;\n }\n visitTryCatchStmt(stmt, context) {\n this.visitAllStatements(stmt.bodyStmts, context);\n this.visitAllStatements(stmt.catchStmts, context);\n return stmt;\n }\n visitThrowStmt(stmt, context) {\n stmt.error.visitExpression(this, context);\n return stmt;\n }\n visitCommentStmt(stmt, context) { return stmt; }\n visitJSDocCommentStmt(stmt, context) { return stmt; }\n visitAllStatements(stmts, context) {\n stmts.forEach(stmt => stmt.visitStatement(this, context));\n }\n}\nfunction findReadVarNames(stmts) {\n const visitor = new _ReadVarVisitor();\n visitor.visitAllStatements(stmts, null);\n return visitor.varNames;\n}\nclass _ReadVarVisitor extends RecursiveAstVisitor$1 {\n constructor() {\n super(...arguments);\n this.varNames = new Set();\n }\n visitDeclareFunctionStmt(stmt, context) {\n // Don't descend into nested functions\n return stmt;\n }\n visitDeclareClassStmt(stmt, context) {\n // Don't descend into nested classes\n return stmt;\n }\n visitReadVarExpr(ast, context) {\n if (ast.name) {\n this.varNames.add(ast.name);\n }\n return null;\n }\n}\nfunction collectExternalReferences(stmts) {\n const visitor = new _FindExternalReferencesVisitor();\n visitor.visitAllStatements(stmts, null);\n return visitor.externalReferences;\n}\nclass _FindExternalReferencesVisitor extends RecursiveAstVisitor$1 {\n constructor() {\n super(...arguments);\n this.externalReferences = [];\n }\n visitExternalExpr(e, context) {\n this.externalReferences.push(e.value);\n return super.visitExternalExpr(e, context);\n }\n}\nfunction applySourceSpanToStatementIfNeeded(stmt, sourceSpan) {\n if (!sourceSpan) {\n return stmt;\n }\n const transformer = new _ApplySourceSpanTransformer(sourceSpan);\n return stmt.visitStatement(transformer, null);\n}\nfunction applySourceSpanToExpressionIfNeeded(expr, sourceSpan) {\n if (!sourceSpan) {\n return expr;\n }\n const transformer = new _ApplySourceSpanTransformer(sourceSpan);\n return expr.visitExpression(transformer, null);\n}\nclass _ApplySourceSpanTransformer extends AstTransformer$1 {\n constructor(sourceSpan) {\n super();\n this.sourceSpan = sourceSpan;\n }\n _clone(obj) {\n const clone = Object.create(obj.constructor.prototype);\n for (let prop in obj) {\n clone[prop] = obj[prop];\n }\n return clone;\n }\n transformExpr(expr, context) {\n if (!expr.sourceSpan) {\n expr = this._clone(expr);\n expr.sourceSpan = this.sourceSpan;\n }\n return expr;\n }\n transformStmt(stmt, context) {\n if (!stmt.sourceSpan) {\n stmt = this._clone(stmt);\n stmt.sourceSpan = this.sourceSpan;\n }\n return stmt;\n }\n}\nfunction variable(name, type, sourceSpan) {\n return new ReadVarExpr(name, type, sourceSpan);\n}\nfunction importExpr(id, typeParams = null, sourceSpan) {\n return new ExternalExpr(id, null, typeParams, sourceSpan);\n}\nfunction importType(id, typeParams = null, typeModifiers = null) {\n return id != null ? expressionType(importExpr(id, typeParams, null), typeModifiers) : null;\n}\nfunction expressionType(expr, typeModifiers = null, typeParams = null) {\n return new ExpressionType(expr, typeModifiers, typeParams);\n}\nfunction typeofExpr(expr) {\n return new TypeofExpr(expr);\n}\nfunction literalArr(values, type, sourceSpan) {\n return new LiteralArrayExpr(values, type, sourceSpan);\n}\nfunction literalMap(values, type = null) {\n return new LiteralMapExpr(values.map(e => new LiteralMapEntry(e.key, e.value, e.quoted)), type, null);\n}\nfunction not(expr, sourceSpan) {\n return new NotExpr(expr, sourceSpan);\n}\nfunction assertNotNull(expr, sourceSpan) {\n return new AssertNotNull(expr, sourceSpan);\n}\nfunction fn(params, body, type, sourceSpan, name) {\n return new FunctionExpr(params, body, type, sourceSpan, name);\n}\nfunction ifStmt(condition, thenClause, elseClause) {\n return new IfStmt(condition, thenClause, elseClause);\n}\nfunction literal(value, type, sourceSpan) {\n return new LiteralExpr(value, type, sourceSpan);\n}\nfunction isNull(exp) {\n return exp instanceof LiteralExpr && exp.value === null;\n}\n/*\n * Serializes a `Tag` into a string.\n * Returns a string like \" @foo {bar} baz\" (note the leading whitespace before `@foo`).\n */\nfunction tagToString(tag) {\n let out = '';\n if (tag.tagName) {\n out += ` @${tag.tagName}`;\n }\n if (tag.text) {\n if (tag.text.match(/\\/\\*|\\*\\//)) {\n throw new Error('JSDoc text cannot contain \"/*\" and \"*/\"');\n }\n out += ' ' + tag.text.replace(/@/g, '\\\\@');\n }\n return out;\n}\nfunction serializeTags(tags) {\n if (tags.length === 0)\n return '';\n let out = '*\\n';\n for (const tag of tags) {\n out += ' *';\n // If the tagToString is multi-line, insert \" * \" prefixes on subsequent lines.\n out += tagToString(tag).replace(/\\n/g, '\\n * ');\n out += '\\n';\n }\n out += ' ';\n return out;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst QUOTED_KEYS = '$quoted$';\nfunction convertValueToOutputAst(ctx, value, type = null) {\n return visitValue(value, new _ValueOutputAstTransformer(ctx), type);\n}\nclass _ValueOutputAstTransformer {\n constructor(ctx) {\n this.ctx = ctx;\n }\n visitArray(arr, type) {\n return literalArr(arr.map(value => visitValue(value, this, null)), type);\n }\n visitStringMap(map, type) {\n const entries = [];\n const quotedSet = new Set(map && map[QUOTED_KEYS]);\n Object.keys(map).forEach(key => {\n entries.push(new LiteralMapEntry(key, visitValue(map[key], this, null), quotedSet.has(key)));\n });\n return new LiteralMapExpr(entries, type);\n }\n visitPrimitive(value, type) { return literal(value, type); }\n visitOther(value, type) {\n if (value instanceof Expression) {\n return value;\n }\n else {\n return this.ctx.importExpr(value);\n }\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction mapEntry(key, value) {\n return { key, value, quoted: false };\n}\nclass InjectableCompiler {\n constructor(reflector, alwaysGenerateDef) {\n this.reflector = reflector;\n this.alwaysGenerateDef = alwaysGenerateDef;\n this.tokenInjector = reflector.resolveExternalReference(Identifiers.Injector);\n }\n depsArray(deps, ctx) {\n return deps.map(dep => {\n let token = dep;\n let args = [token];\n let flags = 0 /* Default */;\n if (Array.isArray(dep)) {\n for (let i = 0; i < dep.length; i++) {\n const v = dep[i];\n if (v) {\n if (v.ngMetadataName === 'Optional') {\n flags |= 8 /* Optional */;\n }\n else if (v.ngMetadataName === 'SkipSelf') {\n flags |= 4 /* SkipSelf */;\n }\n else if (v.ngMetadataName === 'Self') {\n flags |= 2 /* Self */;\n }\n else if (v.ngMetadataName === 'Inject') {\n token = v.token;\n }\n else {\n token = v;\n }\n }\n }\n }\n let tokenExpr;\n if (typeof token === 'string') {\n tokenExpr = literal(token);\n }\n else if (token === this.tokenInjector) {\n tokenExpr = importExpr(Identifiers.INJECTOR);\n }\n else {\n tokenExpr = ctx.importExpr(token);\n }\n if (flags !== 0 /* Default */) {\n args = [tokenExpr, literal(flags)];\n }\n else {\n args = [tokenExpr];\n }\n return importExpr(Identifiers.inject).callFn(args);\n });\n }\n factoryFor(injectable, ctx) {\n let retValue;\n if (injectable.useExisting) {\n retValue = importExpr(Identifiers.inject).callFn([ctx.importExpr(injectable.useExisting)]);\n }\n else if (injectable.useFactory) {\n const deps = injectable.deps || [];\n if (deps.length > 0) {\n retValue = ctx.importExpr(injectable.useFactory).callFn(this.depsArray(deps, ctx));\n }\n else {\n return ctx.importExpr(injectable.useFactory);\n }\n }\n else if (injectable.useValue) {\n retValue = convertValueToOutputAst(ctx, injectable.useValue);\n }\n else {\n const clazz = injectable.useClass || injectable.symbol;\n const depArgs = this.depsArray(this.reflector.parameters(clazz), ctx);\n retValue = new InstantiateExpr(ctx.importExpr(clazz), depArgs);\n }\n return fn([], [new ReturnStatement(retValue)], undefined, undefined, injectable.symbol.name + '_Factory');\n }\n injectableDef(injectable, ctx) {\n let providedIn = NULL_EXPR;\n if (injectable.providedIn !== undefined) {\n if (injectable.providedIn === null) {\n providedIn = NULL_EXPR;\n }\n else if (typeof injectable.providedIn === 'string') {\n providedIn = literal(injectable.providedIn);\n }\n else {\n providedIn = ctx.importExpr(injectable.providedIn);\n }\n }\n const def = [\n mapEntry('factory', this.factoryFor(injectable, ctx)),\n mapEntry('token', ctx.importExpr(injectable.type.reference)),\n mapEntry('providedIn', providedIn),\n ];\n return importExpr(Identifiers.defineInjectable).callFn([literalMap(def)]);\n }\n compile(injectable, ctx) {\n if (this.alwaysGenerateDef || injectable.providedIn !== undefined) {\n const className = identifierName(injectable.type);\n const clazz = new ClassStmt(className, null, [\n new ClassField('ngInjectableDef', INFERRED_TYPE, [StmtModifier.Static], this.injectableDef(injectable, ctx)),\n ], [], new ClassMethod(null, [], []), []);\n ctx.statements.push(clazz);\n }\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst STRIP_SRC_FILE_SUFFIXES = /(\\.ts|\\.d\\.ts|\\.js|\\.jsx|\\.tsx)$/;\nconst GENERATED_FILE = /\\.ngfactory\\.|\\.ngsummary\\./;\nconst JIT_SUMMARY_FILE = /\\.ngsummary\\./;\nconst JIT_SUMMARY_NAME = /NgSummary$/;\nfunction ngfactoryFilePath(filePath, forceSourceFile = false) {\n const urlWithSuffix = splitTypescriptSuffix(filePath, forceSourceFile);\n return `${urlWithSuffix[0]}.ngfactory${normalizeGenFileSuffix(urlWithSuffix[1])}`;\n}\nfunction stripGeneratedFileSuffix(filePath) {\n return filePath.replace(GENERATED_FILE, '.');\n}\nfunction isGeneratedFile(filePath) {\n return GENERATED_FILE.test(filePath);\n}\nfunction splitTypescriptSuffix(path, forceSourceFile = false) {\n if (path.endsWith('.d.ts')) {\n return [path.slice(0, -5), forceSourceFile ? '.ts' : '.d.ts'];\n }\n const lastDot = path.lastIndexOf('.');\n if (lastDot !== -1) {\n return [path.substring(0, lastDot), path.substring(lastDot)];\n }\n return [path, ''];\n}\nfunction normalizeGenFileSuffix(srcFileSuffix) {\n return srcFileSuffix === '.tsx' ? '.ts' : srcFileSuffix;\n}\nfunction summaryFileName(fileName) {\n const fileNameWithoutSuffix = fileName.replace(STRIP_SRC_FILE_SUFFIXES, '');\n return `${fileNameWithoutSuffix}.ngsummary.json`;\n}\nfunction summaryForJitFileName(fileName, forceSourceFile = false) {\n const urlWithSuffix = splitTypescriptSuffix(stripGeneratedFileSuffix(fileName), forceSourceFile);\n return `${urlWithSuffix[0]}.ngsummary${urlWithSuffix[1]}`;\n}\nfunction stripSummaryForJitFileSuffix(filePath) {\n return filePath.replace(JIT_SUMMARY_FILE, '.');\n}\nfunction summaryForJitName(symbolName) {\n return `${symbolName}NgSummary`;\n}\nfunction stripSummaryForJitNameSuffix(symbolName) {\n return symbolName.replace(JIT_SUMMARY_NAME, '');\n}\nconst LOWERED_SYMBOL = /\\u0275\\d+/;\nfunction isLoweredSymbol(name) {\n return LOWERED_SYMBOL.test(name);\n}\nfunction createLoweredSymbol(id) {\n return `\\u0275${id}`;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar LifecycleHooks;\n(function (LifecycleHooks) {\n LifecycleHooks[LifecycleHooks[\"OnInit\"] = 0] = \"OnInit\";\n LifecycleHooks[LifecycleHooks[\"OnDestroy\"] = 1] = \"OnDestroy\";\n LifecycleHooks[LifecycleHooks[\"DoCheck\"] = 2] = \"DoCheck\";\n LifecycleHooks[LifecycleHooks[\"OnChanges\"] = 3] = \"OnChanges\";\n LifecycleHooks[LifecycleHooks[\"AfterContentInit\"] = 4] = \"AfterContentInit\";\n LifecycleHooks[LifecycleHooks[\"AfterContentChecked\"] = 5] = \"AfterContentChecked\";\n LifecycleHooks[LifecycleHooks[\"AfterViewInit\"] = 6] = \"AfterViewInit\";\n LifecycleHooks[LifecycleHooks[\"AfterViewChecked\"] = 7] = \"AfterViewChecked\";\n})(LifecycleHooks || (LifecycleHooks = {}));\nconst LIFECYCLE_HOOKS_VALUES = [\n LifecycleHooks.OnInit, LifecycleHooks.OnDestroy, LifecycleHooks.DoCheck, LifecycleHooks.OnChanges,\n LifecycleHooks.AfterContentInit, LifecycleHooks.AfterContentChecked, LifecycleHooks.AfterViewInit,\n LifecycleHooks.AfterViewChecked\n];\nfunction hasLifecycleHook(reflector, hook, token) {\n return reflector.hasLifecycleHook(token, getHookName(hook));\n}\nfunction getAllLifecycleHooks(reflector, token) {\n return LIFECYCLE_HOOKS_VALUES.filter(hook => hasLifecycleHook(reflector, hook, token));\n}\nfunction getHookName(hook) {\n switch (hook) {\n case LifecycleHooks.OnInit:\n return 'ngOnInit';\n case LifecycleHooks.OnDestroy:\n return 'ngOnDestroy';\n case LifecycleHooks.DoCheck:\n return 'ngDoCheck';\n case LifecycleHooks.OnChanges:\n return 'ngOnChanges';\n case LifecycleHooks.AfterContentInit:\n return 'ngAfterContentInit';\n case LifecycleHooks.AfterContentChecked:\n return 'ngAfterContentChecked';\n case LifecycleHooks.AfterViewInit:\n return 'ngAfterViewInit';\n case LifecycleHooks.AfterViewChecked:\n return 'ngAfterViewChecked';\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst ERROR_COMPONENT_TYPE = 'ngComponentType';\n// Design notes:\n// - don't lazily create metadata:\n// For some metadata, we need to do async work sometimes,\n// so the user has to kick off this loading.\n// But we want to report errors even when the async work is\n// not required to check that the user would have been able\n// to wait correctly.\nclass CompileMetadataResolver {\n constructor(_config, _htmlParser, _ngModuleResolver, _directiveResolver, _pipeResolver, _summaryResolver, _schemaRegistry, _directiveNormalizer, _console, _staticSymbolCache, _reflector, _errorCollector) {\n this._config = _config;\n this._htmlParser = _htmlParser;\n this._ngModuleResolver = _ngModuleResolver;\n this._directiveResolver = _directiveResolver;\n this._pipeResolver = _pipeResolver;\n this._summaryResolver = _summaryResolver;\n this._schemaRegistry = _schemaRegistry;\n this._directiveNormalizer = _directiveNormalizer;\n this._console = _console;\n this._staticSymbolCache = _staticSymbolCache;\n this._reflector = _reflector;\n this._errorCollector = _errorCollector;\n this._nonNormalizedDirectiveCache = new Map();\n this._directiveCache = new Map();\n this._summaryCache = new Map();\n this._pipeCache = new Map();\n this._ngModuleCache = new Map();\n this._ngModuleOfTypes = new Map();\n this._shallowModuleCache = new Map();\n }\n getReflector() { return this._reflector; }\n clearCacheFor(type) {\n const dirMeta = this._directiveCache.get(type);\n this._directiveCache.delete(type);\n this._nonNormalizedDirectiveCache.delete(type);\n this._summaryCache.delete(type);\n this._pipeCache.delete(type);\n this._ngModuleOfTypes.delete(type);\n // Clear all of the NgModule as they contain transitive information!\n this._ngModuleCache.clear();\n if (dirMeta) {\n this._directiveNormalizer.clearCacheFor(dirMeta);\n }\n }\n clearCache() {\n this._directiveCache.clear();\n this._nonNormalizedDirectiveCache.clear();\n this._summaryCache.clear();\n this._pipeCache.clear();\n this._ngModuleCache.clear();\n this._ngModuleOfTypes.clear();\n this._directiveNormalizer.clearCache();\n }\n _createProxyClass(baseType, name) {\n let delegate = null;\n const proxyClass = function () {\n if (!delegate) {\n throw new Error(`Illegal state: Class ${name} for type ${stringify(baseType)} is not compiled yet!`);\n }\n return delegate.apply(this, arguments);\n };\n proxyClass.setDelegate = (d) => {\n delegate = d;\n proxyClass.prototype = d.prototype;\n };\n // Make stringify work correctly\n proxyClass.overriddenName = name;\n return proxyClass;\n }\n getGeneratedClass(dirType, name) {\n if (dirType instanceof StaticSymbol) {\n return this._staticSymbolCache.get(ngfactoryFilePath(dirType.filePath), name);\n }\n else {\n return this._createProxyClass(dirType, name);\n }\n }\n getComponentViewClass(dirType) {\n return this.getGeneratedClass(dirType, viewClassName(dirType, 0));\n }\n getHostComponentViewClass(dirType) {\n return this.getGeneratedClass(dirType, hostViewClassName(dirType));\n }\n getHostComponentType(dirType) {\n const name = `${identifierName({ reference: dirType })}_Host`;\n if (dirType instanceof StaticSymbol) {\n return this._staticSymbolCache.get(dirType.filePath, name);\n }\n else {\n const HostClass = function HostClass() { };\n HostClass.overriddenName = name;\n return HostClass;\n }\n }\n getRendererType(dirType) {\n if (dirType instanceof StaticSymbol) {\n return this._staticSymbolCache.get(ngfactoryFilePath(dirType.filePath), rendererTypeName(dirType));\n }\n else {\n // returning an object as proxy,\n // that we fill later during runtime compilation.\n return {};\n }\n }\n getComponentFactory(selector, dirType, inputs, outputs) {\n if (dirType instanceof StaticSymbol) {\n return this._staticSymbolCache.get(ngfactoryFilePath(dirType.filePath), componentFactoryName(dirType));\n }\n else {\n const hostView = this.getHostComponentViewClass(dirType);\n // Note: ngContentSelectors will be filled later once the template is\n // loaded.\n const createComponentFactory = this._reflector.resolveExternalReference(Identifiers.createComponentFactory);\n return createComponentFactory(selector, dirType, hostView, inputs, outputs, []);\n }\n }\n initComponentFactory(factory, ngContentSelectors) {\n if (!(factory instanceof StaticSymbol)) {\n factory.ngContentSelectors.push(...ngContentSelectors);\n }\n }\n _loadSummary(type, kind) {\n let typeSummary = this._summaryCache.get(type);\n if (!typeSummary) {\n const summary = this._summaryResolver.resolveSummary(type);\n typeSummary = summary ? summary.type : null;\n this._summaryCache.set(type, typeSummary || null);\n }\n return typeSummary && typeSummary.summaryKind === kind ? typeSummary : null;\n }\n getHostComponentMetadata(compMeta, hostViewType) {\n const hostType = this.getHostComponentType(compMeta.type.reference);\n if (!hostViewType) {\n hostViewType = this.getHostComponentViewClass(hostType);\n }\n // Note: ! is ok here as this method should only be called with normalized directive\n // metadata, which always fills in the selector.\n const template = CssSelector.parse(compMeta.selector)[0].getMatchingElementTemplate();\n const templateUrl = '';\n const htmlAst = this._htmlParser.parse(template, templateUrl);\n return CompileDirectiveMetadata.create({\n isHost: true,\n type: { reference: hostType, diDeps: [], lifecycleHooks: [] },\n template: new CompileTemplateMetadata({\n encapsulation: ViewEncapsulation.None,\n template,\n templateUrl,\n htmlAst,\n styles: [],\n styleUrls: [],\n ngContentSelectors: [],\n animations: [],\n isInline: true,\n externalStylesheets: [],\n interpolation: null,\n preserveWhitespaces: false,\n }),\n exportAs: null,\n changeDetection: ChangeDetectionStrategy.Default,\n inputs: [],\n outputs: [],\n host: {},\n isComponent: true,\n selector: '*',\n providers: [],\n viewProviders: [],\n queries: [],\n guards: {},\n viewQueries: [],\n componentViewType: hostViewType,\n rendererType: { id: '__Host__', encapsulation: ViewEncapsulation.None, styles: [], data: {} },\n entryComponents: [],\n componentFactory: null\n });\n }\n loadDirectiveMetadata(ngModuleType, directiveType, isSync) {\n if (this._directiveCache.has(directiveType)) {\n return null;\n }\n directiveType = resolveForwardRef(directiveType);\n const { annotation, metadata } = this.getNonNormalizedDirectiveMetadata(directiveType);\n const createDirectiveMetadata = (templateMetadata) => {\n const normalizedDirMeta = new CompileDirectiveMetadata({\n isHost: false,\n type: metadata.type,\n isComponent: metadata.isComponent,\n selector: metadata.selector,\n exportAs: metadata.exportAs,\n changeDetection: metadata.changeDetection,\n inputs: metadata.inputs,\n outputs: metadata.outputs,\n hostListeners: metadata.hostListeners,\n hostProperties: metadata.hostProperties,\n hostAttributes: metadata.hostAttributes,\n providers: metadata.providers,\n viewProviders: metadata.viewProviders,\n queries: metadata.queries,\n guards: metadata.guards,\n viewQueries: metadata.viewQueries,\n entryComponents: metadata.entryComponents,\n componentViewType: metadata.componentViewType,\n rendererType: metadata.rendererType,\n componentFactory: metadata.componentFactory,\n template: templateMetadata\n });\n if (templateMetadata) {\n this.initComponentFactory(metadata.componentFactory, templateMetadata.ngContentSelectors);\n }\n this._directiveCache.set(directiveType, normalizedDirMeta);\n this._summaryCache.set(directiveType, normalizedDirMeta.toSummary());\n return null;\n };\n if (metadata.isComponent) {\n const template = metadata.template;\n const templateMeta = this._directiveNormalizer.normalizeTemplate({\n ngModuleType,\n componentType: directiveType,\n moduleUrl: this._reflector.componentModuleUrl(directiveType, annotation),\n encapsulation: template.encapsulation,\n template: template.template,\n templateUrl: template.templateUrl,\n styles: template.styles,\n styleUrls: template.styleUrls,\n animations: template.animations,\n interpolation: template.interpolation,\n preserveWhitespaces: template.preserveWhitespaces\n });\n if (isPromise(templateMeta) && isSync) {\n this._reportError(componentStillLoadingError(directiveType), directiveType);\n return null;\n }\n return SyncAsync.then(templateMeta, createDirectiveMetadata);\n }\n else {\n // directive\n createDirectiveMetadata(null);\n return null;\n }\n }\n getNonNormalizedDirectiveMetadata(directiveType) {\n directiveType = resolveForwardRef(directiveType);\n if (!directiveType) {\n return null;\n }\n let cacheEntry = this._nonNormalizedDirectiveCache.get(directiveType);\n if (cacheEntry) {\n return cacheEntry;\n }\n const dirMeta = this._directiveResolver.resolve(directiveType, false);\n if (!dirMeta) {\n return null;\n }\n let nonNormalizedTemplateMetadata = undefined;\n if (createComponent.isTypeOf(dirMeta)) {\n // component\n const compMeta = dirMeta;\n assertArrayOfStrings('styles', compMeta.styles);\n assertArrayOfStrings('styleUrls', compMeta.styleUrls);\n assertInterpolationSymbols('interpolation', compMeta.interpolation);\n const animations = compMeta.animations;\n nonNormalizedTemplateMetadata = new CompileTemplateMetadata({\n encapsulation: noUndefined(compMeta.encapsulation),\n template: noUndefined(compMeta.template),\n templateUrl: noUndefined(compMeta.templateUrl),\n htmlAst: null,\n styles: compMeta.styles || [],\n styleUrls: compMeta.styleUrls || [],\n animations: animations || [],\n interpolation: noUndefined(compMeta.interpolation),\n isInline: !!compMeta.template,\n externalStylesheets: [],\n ngContentSelectors: [],\n preserveWhitespaces: noUndefined(dirMeta.preserveWhitespaces),\n });\n }\n let changeDetectionStrategy = null;\n let viewProviders = [];\n let entryComponentMetadata = [];\n let selector = dirMeta.selector;\n if (createComponent.isTypeOf(dirMeta)) {\n // Component\n const compMeta = dirMeta;\n changeDetectionStrategy = compMeta.changeDetection;\n if (compMeta.viewProviders) {\n viewProviders = this._getProvidersMetadata(compMeta.viewProviders, entryComponentMetadata, `viewProviders for \"${stringifyType(directiveType)}\"`, [], directiveType);\n }\n if (compMeta.entryComponents) {\n entryComponentMetadata = flattenAndDedupeArray(compMeta.entryComponents)\n .map((type) => this._getEntryComponentMetadata(type))\n .concat(entryComponentMetadata);\n }\n if (!selector) {\n selector = this._schemaRegistry.getDefaultComponentElementName();\n }\n }\n else {\n // Directive\n if (!selector) {\n this._reportError(syntaxError(`Directive ${stringifyType(directiveType)} has no selector, please add it!`), directiveType);\n selector = 'error';\n }\n }\n let providers = [];\n if (dirMeta.providers != null) {\n providers = this._getProvidersMetadata(dirMeta.providers, entryComponentMetadata, `providers for \"${stringifyType(directiveType)}\"`, [], directiveType);\n }\n let queries = [];\n let viewQueries = [];\n if (dirMeta.queries != null) {\n queries = this._getQueriesMetadata(dirMeta.queries, false, directiveType);\n viewQueries = this._getQueriesMetadata(dirMeta.queries, true, directiveType);\n }\n const metadata = CompileDirectiveMetadata.create({\n isHost: false,\n selector: selector,\n exportAs: noUndefined(dirMeta.exportAs),\n isComponent: !!nonNormalizedTemplateMetadata,\n type: this._getTypeMetadata(directiveType),\n template: nonNormalizedTemplateMetadata,\n changeDetection: changeDetectionStrategy,\n inputs: dirMeta.inputs || [],\n outputs: dirMeta.outputs || [],\n host: dirMeta.host || {},\n providers: providers || [],\n viewProviders: viewProviders || [],\n queries: queries || [],\n guards: dirMeta.guards || {},\n viewQueries: viewQueries || [],\n entryComponents: entryComponentMetadata,\n componentViewType: nonNormalizedTemplateMetadata ? this.getComponentViewClass(directiveType) :\n null,\n rendererType: nonNormalizedTemplateMetadata ? this.getRendererType(directiveType) : null,\n componentFactory: null\n });\n if (nonNormalizedTemplateMetadata) {\n metadata.componentFactory =\n this.getComponentFactory(selector, directiveType, metadata.inputs, metadata.outputs);\n }\n cacheEntry = { metadata, annotation: dirMeta };\n this._nonNormalizedDirectiveCache.set(directiveType, cacheEntry);\n return cacheEntry;\n }\n /**\n * Gets the metadata for the given directive.\n * This assumes `loadNgModuleDirectiveAndPipeMetadata` has been called first.\n */\n getDirectiveMetadata(directiveType) {\n const dirMeta = this._directiveCache.get(directiveType);\n if (!dirMeta) {\n this._reportError(syntaxError(`Illegal state: getDirectiveMetadata can only be called after loadNgModuleDirectiveAndPipeMetadata for a module that declares it. Directive ${stringifyType(directiveType)}.`), directiveType);\n }\n return dirMeta;\n }\n getDirectiveSummary(dirType) {\n const dirSummary = this._loadSummary(dirType, CompileSummaryKind.Directive);\n if (!dirSummary) {\n this._reportError(syntaxError(`Illegal state: Could not load the summary for directive ${stringifyType(dirType)}.`), dirType);\n }\n return dirSummary;\n }\n isDirective(type) {\n return !!this._loadSummary(type, CompileSummaryKind.Directive) ||\n this._directiveResolver.isDirective(type);\n }\n isPipe(type) {\n return !!this._loadSummary(type, CompileSummaryKind.Pipe) ||\n this._pipeResolver.isPipe(type);\n }\n isNgModule(type) {\n return !!this._loadSummary(type, CompileSummaryKind.NgModule) ||\n this._ngModuleResolver.isNgModule(type);\n }\n getNgModuleSummary(moduleType, alreadyCollecting = null) {\n let moduleSummary = this._loadSummary(moduleType, CompileSummaryKind.NgModule);\n if (!moduleSummary) {\n const moduleMeta = this.getNgModuleMetadata(moduleType, false, alreadyCollecting);\n moduleSummary = moduleMeta ? moduleMeta.toSummary() : null;\n if (moduleSummary) {\n this._summaryCache.set(moduleType, moduleSummary);\n }\n }\n return moduleSummary;\n }\n /**\n * Loads the declared directives and pipes of an NgModule.\n */\n loadNgModuleDirectiveAndPipeMetadata(moduleType, isSync, throwIfNotFound = true) {\n const ngModule = this.getNgModuleMetadata(moduleType, throwIfNotFound);\n const loading = [];\n if (ngModule) {\n ngModule.declaredDirectives.forEach((id) => {\n const promise = this.loadDirectiveMetadata(moduleType, id.reference, isSync);\n if (promise) {\n loading.push(promise);\n }\n });\n ngModule.declaredPipes.forEach((id) => this._loadPipeMetadata(id.reference));\n }\n return Promise.all(loading);\n }\n getShallowModuleMetadata(moduleType) {\n let compileMeta = this._shallowModuleCache.get(moduleType);\n if (compileMeta) {\n return compileMeta;\n }\n const ngModuleMeta = findLast(this._reflector.shallowAnnotations(moduleType), createNgModule.isTypeOf);\n compileMeta = {\n type: this._getTypeMetadata(moduleType),\n rawExports: ngModuleMeta.exports,\n rawImports: ngModuleMeta.imports,\n rawProviders: ngModuleMeta.providers,\n };\n this._shallowModuleCache.set(moduleType, compileMeta);\n return compileMeta;\n }\n getNgModuleMetadata(moduleType, throwIfNotFound = true, alreadyCollecting = null) {\n moduleType = resolveForwardRef(moduleType);\n let compileMeta = this._ngModuleCache.get(moduleType);\n if (compileMeta) {\n return compileMeta;\n }\n const meta = this._ngModuleResolver.resolve(moduleType, throwIfNotFound);\n if (!meta) {\n return null;\n }\n const declaredDirectives = [];\n const exportedNonModuleIdentifiers = [];\n const declaredPipes = [];\n const importedModules = [];\n const exportedModules = [];\n const providers = [];\n const entryComponents = [];\n const bootstrapComponents = [];\n const schemas = [];\n if (meta.imports) {\n flattenAndDedupeArray(meta.imports).forEach((importedType) => {\n let importedModuleType = undefined;\n if (isValidType(importedType)) {\n importedModuleType = importedType;\n }\n else if (importedType && importedType.ngModule) {\n const moduleWithProviders = importedType;\n importedModuleType = moduleWithProviders.ngModule;\n if (moduleWithProviders.providers) {\n providers.push(...this._getProvidersMetadata(moduleWithProviders.providers, entryComponents, `provider for the NgModule '${stringifyType(importedModuleType)}'`, [], importedType));\n }\n }\n if (importedModuleType) {\n if (this._checkSelfImport(moduleType, importedModuleType))\n return;\n if (!alreadyCollecting)\n alreadyCollecting = new Set();\n if (alreadyCollecting.has(importedModuleType)) {\n this._reportError(syntaxError(`${this._getTypeDescriptor(importedModuleType)} '${stringifyType(importedType)}' is imported recursively by the module '${stringifyType(moduleType)}'.`), moduleType);\n return;\n }\n alreadyCollecting.add(importedModuleType);\n const importedModuleSummary = this.getNgModuleSummary(importedModuleType, alreadyCollecting);\n alreadyCollecting.delete(importedModuleType);\n if (!importedModuleSummary) {\n this._reportError(syntaxError(`Unexpected ${this._getTypeDescriptor(importedType)} '${stringifyType(importedType)}' imported by the module '${stringifyType(moduleType)}'. Please add a @NgModule annotation.`), moduleType);\n return;\n }\n importedModules.push(importedModuleSummary);\n }\n else {\n this._reportError(syntaxError(`Unexpected value '${stringifyType(importedType)}' imported by the module '${stringifyType(moduleType)}'`), moduleType);\n return;\n }\n });\n }\n if (meta.exports) {\n flattenAndDedupeArray(meta.exports).forEach((exportedType) => {\n if (!isValidType(exportedType)) {\n this._reportError(syntaxError(`Unexpected value '${stringifyType(exportedType)}' exported by the module '${stringifyType(moduleType)}'`), moduleType);\n return;\n }\n if (!alreadyCollecting)\n alreadyCollecting = new Set();\n if (alreadyCollecting.has(exportedType)) {\n this._reportError(syntaxError(`${this._getTypeDescriptor(exportedType)} '${stringify(exportedType)}' is exported recursively by the module '${stringifyType(moduleType)}'`), moduleType);\n return;\n }\n alreadyCollecting.add(exportedType);\n const exportedModuleSummary = this.getNgModuleSummary(exportedType, alreadyCollecting);\n alreadyCollecting.delete(exportedType);\n if (exportedModuleSummary) {\n exportedModules.push(exportedModuleSummary);\n }\n else {\n exportedNonModuleIdentifiers.push(this._getIdentifierMetadata(exportedType));\n }\n });\n }\n // Note: This will be modified later, so we rely on\n // getting a new instance every time!\n const transitiveModule = this._getTransitiveNgModuleMetadata(importedModules, exportedModules);\n if (meta.declarations) {\n flattenAndDedupeArray(meta.declarations).forEach((declaredType) => {\n if (!isValidType(declaredType)) {\n this._reportError(syntaxError(`Unexpected value '${stringifyType(declaredType)}' declared by the module '${stringifyType(moduleType)}'`), moduleType);\n return;\n }\n const declaredIdentifier = this._getIdentifierMetadata(declaredType);\n if (this.isDirective(declaredType)) {\n transitiveModule.addDirective(declaredIdentifier);\n declaredDirectives.push(declaredIdentifier);\n this._addTypeToModule(declaredType, moduleType);\n }\n else if (this.isPipe(declaredType)) {\n transitiveModule.addPipe(declaredIdentifier);\n transitiveModule.pipes.push(declaredIdentifier);\n declaredPipes.push(declaredIdentifier);\n this._addTypeToModule(declaredType, moduleType);\n }\n else {\n this._reportError(syntaxError(`Unexpected ${this._getTypeDescriptor(declaredType)} '${stringifyType(declaredType)}' declared by the module '${stringifyType(moduleType)}'. Please add a @Pipe/@Directive/@Component annotation.`), moduleType);\n return;\n }\n });\n }\n const exportedDirectives = [];\n const exportedPipes = [];\n exportedNonModuleIdentifiers.forEach((exportedId) => {\n if (transitiveModule.directivesSet.has(exportedId.reference)) {\n exportedDirectives.push(exportedId);\n transitiveModule.addExportedDirective(exportedId);\n }\n else if (transitiveModule.pipesSet.has(exportedId.reference)) {\n exportedPipes.push(exportedId);\n transitiveModule.addExportedPipe(exportedId);\n }\n else {\n this._reportError(syntaxError(`Can't export ${this._getTypeDescriptor(exportedId.reference)} ${stringifyType(exportedId.reference)} from ${stringifyType(moduleType)} as it was neither declared nor imported!`), moduleType);\n return;\n }\n });\n // The providers of the module have to go last\n // so that they overwrite any other provider we already added.\n if (meta.providers) {\n providers.push(...this._getProvidersMetadata(meta.providers, entryComponents, `provider for the NgModule '${stringifyType(moduleType)}'`, [], moduleType));\n }\n if (meta.entryComponents) {\n entryComponents.push(...flattenAndDedupeArray(meta.entryComponents)\n .map(type => this._getEntryComponentMetadata(type)));\n }\n if (meta.bootstrap) {\n flattenAndDedupeArray(meta.bootstrap).forEach(type => {\n if (!isValidType(type)) {\n this._reportError(syntaxError(`Unexpected value '${stringifyType(type)}' used in the bootstrap property of module '${stringifyType(moduleType)}'`), moduleType);\n return;\n }\n bootstrapComponents.push(this._getIdentifierMetadata(type));\n });\n }\n entryComponents.push(...bootstrapComponents.map(type => this._getEntryComponentMetadata(type.reference)));\n if (meta.schemas) {\n schemas.push(...flattenAndDedupeArray(meta.schemas));\n }\n compileMeta = new CompileNgModuleMetadata({\n type: this._getTypeMetadata(moduleType),\n providers,\n entryComponents,\n bootstrapComponents,\n schemas,\n declaredDirectives,\n exportedDirectives,\n declaredPipes,\n exportedPipes,\n importedModules,\n exportedModules,\n transitiveModule,\n id: meta.id || null,\n });\n entryComponents.forEach((id) => transitiveModule.addEntryComponent(id));\n providers.forEach((provider) => transitiveModule.addProvider(provider, compileMeta.type));\n transitiveModule.addModule(compileMeta.type);\n this._ngModuleCache.set(moduleType, compileMeta);\n return compileMeta;\n }\n _checkSelfImport(moduleType, importedModuleType) {\n if (moduleType === importedModuleType) {\n this._reportError(syntaxError(`'${stringifyType(moduleType)}' module can't import itself`), moduleType);\n return true;\n }\n return false;\n }\n _getTypeDescriptor(type) {\n if (isValidType(type)) {\n if (this.isDirective(type)) {\n return 'directive';\n }\n if (this.isPipe(type)) {\n return 'pipe';\n }\n if (this.isNgModule(type)) {\n return 'module';\n }\n }\n if (type.provide) {\n return 'provider';\n }\n return 'value';\n }\n _addTypeToModule(type, moduleType) {\n const oldModule = this._ngModuleOfTypes.get(type);\n if (oldModule && oldModule !== moduleType) {\n this._reportError(syntaxError(`Type ${stringifyType(type)} is part of the declarations of 2 modules: ${stringifyType(oldModule)} and ${stringifyType(moduleType)}! ` +\n `Please consider moving ${stringifyType(type)} to a higher module that imports ${stringifyType(oldModule)} and ${stringifyType(moduleType)}. ` +\n `You can also create a new NgModule that exports and includes ${stringifyType(type)} then import that NgModule in ${stringifyType(oldModule)} and ${stringifyType(moduleType)}.`), moduleType);\n return;\n }\n this._ngModuleOfTypes.set(type, moduleType);\n }\n _getTransitiveNgModuleMetadata(importedModules, exportedModules) {\n // collect `providers` / `entryComponents` from all imported and all exported modules\n const result = new TransitiveCompileNgModuleMetadata();\n const modulesByToken = new Map();\n importedModules.concat(exportedModules).forEach((modSummary) => {\n modSummary.modules.forEach((mod) => result.addModule(mod));\n modSummary.entryComponents.forEach((comp) => result.addEntryComponent(comp));\n const addedTokens = new Set();\n modSummary.providers.forEach((entry) => {\n const tokenRef = tokenReference(entry.provider.token);\n let prevModules = modulesByToken.get(tokenRef);\n if (!prevModules) {\n prevModules = new Set();\n modulesByToken.set(tokenRef, prevModules);\n }\n const moduleRef = entry.module.reference;\n // Note: the providers of one module may still contain multiple providers\n // per token (e.g. for multi providers), and we need to preserve these.\n if (addedTokens.has(tokenRef) || !prevModules.has(moduleRef)) {\n prevModules.add(moduleRef);\n addedTokens.add(tokenRef);\n result.addProvider(entry.provider, entry.module);\n }\n });\n });\n exportedModules.forEach((modSummary) => {\n modSummary.exportedDirectives.forEach((id) => result.addExportedDirective(id));\n modSummary.exportedPipes.forEach((id) => result.addExportedPipe(id));\n });\n importedModules.forEach((modSummary) => {\n modSummary.exportedDirectives.forEach((id) => result.addDirective(id));\n modSummary.exportedPipes.forEach((id) => result.addPipe(id));\n });\n return result;\n }\n _getIdentifierMetadata(type) {\n type = resolveForwardRef(type);\n return { reference: type };\n }\n isInjectable(type) {\n const annotations = this._reflector.tryAnnotations(type);\n return annotations.some(ann => createInjectable.isTypeOf(ann));\n }\n getInjectableSummary(type) {\n return {\n summaryKind: CompileSummaryKind.Injectable,\n type: this._getTypeMetadata(type, null, false)\n };\n }\n getInjectableMetadata(type, dependencies = null, throwOnUnknownDeps = true) {\n const typeSummary = this._loadSummary(type, CompileSummaryKind.Injectable);\n const typeMetadata = typeSummary ?\n typeSummary.type :\n this._getTypeMetadata(type, dependencies, throwOnUnknownDeps);\n const annotations = this._reflector.annotations(type).filter(ann => createInjectable.isTypeOf(ann));\n if (annotations.length === 0) {\n return null;\n }\n const meta = annotations[annotations.length - 1];\n return {\n symbol: type,\n type: typeMetadata,\n providedIn: meta.providedIn,\n useValue: meta.useValue,\n useClass: meta.useClass,\n useExisting: meta.useExisting,\n useFactory: meta.useFactory,\n deps: meta.deps,\n };\n }\n _getTypeMetadata(type, dependencies = null, throwOnUnknownDeps = true) {\n const identifier = this._getIdentifierMetadata(type);\n return {\n reference: identifier.reference,\n diDeps: this._getDependenciesMetadata(identifier.reference, dependencies, throwOnUnknownDeps),\n lifecycleHooks: getAllLifecycleHooks(this._reflector, identifier.reference),\n };\n }\n _getFactoryMetadata(factory, dependencies = null) {\n factory = resolveForwardRef(factory);\n return { reference: factory, diDeps: this._getDependenciesMetadata(factory, dependencies) };\n }\n /**\n * Gets the metadata for the given pipe.\n * This assumes `loadNgModuleDirectiveAndPipeMetadata` has been called first.\n */\n getPipeMetadata(pipeType) {\n const pipeMeta = this._pipeCache.get(pipeType);\n if (!pipeMeta) {\n this._reportError(syntaxError(`Illegal state: getPipeMetadata can only be called after loadNgModuleDirectiveAndPipeMetadata for a module that declares it. Pipe ${stringifyType(pipeType)}.`), pipeType);\n }\n return pipeMeta || null;\n }\n getPipeSummary(pipeType) {\n const pipeSummary = this._loadSummary(pipeType, CompileSummaryKind.Pipe);\n if (!pipeSummary) {\n this._reportError(syntaxError(`Illegal state: Could not load the summary for pipe ${stringifyType(pipeType)}.`), pipeType);\n }\n return pipeSummary;\n }\n getOrLoadPipeMetadata(pipeType) {\n let pipeMeta = this._pipeCache.get(pipeType);\n if (!pipeMeta) {\n pipeMeta = this._loadPipeMetadata(pipeType);\n }\n return pipeMeta;\n }\n _loadPipeMetadata(pipeType) {\n pipeType = resolveForwardRef(pipeType);\n const pipeAnnotation = this._pipeResolver.resolve(pipeType);\n const pipeMeta = new CompilePipeMetadata({\n type: this._getTypeMetadata(pipeType),\n name: pipeAnnotation.name,\n pure: !!pipeAnnotation.pure\n });\n this._pipeCache.set(pipeType, pipeMeta);\n this._summaryCache.set(pipeType, pipeMeta.toSummary());\n return pipeMeta;\n }\n _getDependenciesMetadata(typeOrFunc, dependencies, throwOnUnknownDeps = true) {\n let hasUnknownDeps = false;\n const params = dependencies || this._reflector.parameters(typeOrFunc) || [];\n const dependenciesMetadata = params.map((param) => {\n let isAttribute = false;\n let isHost = false;\n let isSelf = false;\n let isSkipSelf = false;\n let isOptional = false;\n let token = null;\n if (Array.isArray(param)) {\n param.forEach((paramEntry) => {\n if (createHost.isTypeOf(paramEntry)) {\n isHost = true;\n }\n else if (createSelf.isTypeOf(paramEntry)) {\n isSelf = true;\n }\n else if (createSkipSelf.isTypeOf(paramEntry)) {\n isSkipSelf = true;\n }\n else if (createOptional.isTypeOf(paramEntry)) {\n isOptional = true;\n }\n else if (createAttribute.isTypeOf(paramEntry)) {\n isAttribute = true;\n token = paramEntry.attributeName;\n }\n else if (createInject.isTypeOf(paramEntry)) {\n token = paramEntry.token;\n }\n else if (createInjectionToken.isTypeOf(paramEntry) || paramEntry instanceof StaticSymbol) {\n token = paramEntry;\n }\n else if (isValidType(paramEntry) && token == null) {\n token = paramEntry;\n }\n });\n }\n else {\n token = param;\n }\n if (token == null) {\n hasUnknownDeps = true;\n return null;\n }\n return {\n isAttribute,\n isHost,\n isSelf,\n isSkipSelf,\n isOptional,\n token: this._getTokenMetadata(token)\n };\n });\n if (hasUnknownDeps) {\n const depsTokens = dependenciesMetadata.map((dep) => dep ? stringifyType(dep.token) : '?').join(', ');\n const message = `Can't resolve all parameters for ${stringifyType(typeOrFunc)}: (${depsTokens}).`;\n if (throwOnUnknownDeps || this._config.strictInjectionParameters) {\n this._reportError(syntaxError(message), typeOrFunc);\n }\n else {\n this._console.warn(`Warning: ${message} This will become an error in Angular v6.x`);\n }\n }\n return dependenciesMetadata;\n }\n _getTokenMetadata(token) {\n token = resolveForwardRef(token);\n let compileToken;\n if (typeof token === 'string') {\n compileToken = { value: token };\n }\n else {\n compileToken = { identifier: { reference: token } };\n }\n return compileToken;\n }\n _getProvidersMetadata(providers, targetEntryComponents, debugInfo, compileProviders = [], type) {\n providers.forEach((provider, providerIdx) => {\n if (Array.isArray(provider)) {\n this._getProvidersMetadata(provider, targetEntryComponents, debugInfo, compileProviders);\n }\n else {\n provider = resolveForwardRef(provider);\n let providerMeta = undefined;\n if (provider && typeof provider === 'object' && provider.hasOwnProperty('provide')) {\n this._validateProvider(provider);\n providerMeta = new ProviderMeta(provider.provide, provider);\n }\n else if (isValidType(provider)) {\n providerMeta = new ProviderMeta(provider, { useClass: provider });\n }\n else if (provider === void 0) {\n this._reportError(syntaxError(`Encountered undefined provider! Usually this means you have a circular dependencies. This might be caused by using 'barrel' index.ts files.`));\n return;\n }\n else {\n const providersInfo = providers.reduce((soFar, seenProvider, seenProviderIdx) => {\n if (seenProviderIdx < providerIdx) {\n soFar.push(`${stringifyType(seenProvider)}`);\n }\n else if (seenProviderIdx == providerIdx) {\n soFar.push(`?${stringifyType(seenProvider)}?`);\n }\n else if (seenProviderIdx == providerIdx + 1) {\n soFar.push('...');\n }\n return soFar;\n }, [])\n .join(', ');\n this._reportError(syntaxError(`Invalid ${debugInfo ? debugInfo : 'provider'} - only instances of Provider and Type are allowed, got: [${providersInfo}]`), type);\n return;\n }\n if (providerMeta.token ===\n this._reflector.resolveExternalReference(Identifiers.ANALYZE_FOR_ENTRY_COMPONENTS)) {\n targetEntryComponents.push(...this._getEntryComponentsFromProvider(providerMeta, type));\n }\n else {\n compileProviders.push(this.getProviderMetadata(providerMeta));\n }\n }\n });\n return compileProviders;\n }\n _validateProvider(provider) {\n if (provider.hasOwnProperty('useClass') && provider.useClass == null) {\n this._reportError(syntaxError(`Invalid provider for ${stringifyType(provider.provide)}. useClass cannot be ${provider.useClass}.\n Usually it happens when:\n 1. There's a circular dependency (might be caused by using index.ts (barrel) files).\n 2. Class was used before it was declared. Use forwardRef in this case.`));\n }\n }\n _getEntryComponentsFromProvider(provider, type) {\n const components = [];\n const collectedIdentifiers = [];\n if (provider.useFactory || provider.useExisting || provider.useClass) {\n this._reportError(syntaxError(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports useValue!`), type);\n return [];\n }\n if (!provider.multi) {\n this._reportError(syntaxError(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports 'multi = true'!`), type);\n return [];\n }\n extractIdentifiers(provider.useValue, collectedIdentifiers);\n collectedIdentifiers.forEach((identifier) => {\n const entry = this._getEntryComponentMetadata(identifier.reference, false);\n if (entry) {\n components.push(entry);\n }\n });\n return components;\n }\n _getEntryComponentMetadata(dirType, throwIfNotFound = true) {\n const dirMeta = this.getNonNormalizedDirectiveMetadata(dirType);\n if (dirMeta && dirMeta.metadata.isComponent) {\n return { componentType: dirType, componentFactory: dirMeta.metadata.componentFactory };\n }\n const dirSummary = this._loadSummary(dirType, CompileSummaryKind.Directive);\n if (dirSummary && dirSummary.isComponent) {\n return { componentType: dirType, componentFactory: dirSummary.componentFactory };\n }\n if (throwIfNotFound) {\n throw syntaxError(`${dirType.name} cannot be used as an entry component.`);\n }\n return null;\n }\n _getInjectableTypeMetadata(type, dependencies = null) {\n const typeSummary = this._loadSummary(type, CompileSummaryKind.Injectable);\n if (typeSummary) {\n return typeSummary.type;\n }\n return this._getTypeMetadata(type, dependencies);\n }\n getProviderMetadata(provider) {\n let compileDeps = undefined;\n let compileTypeMetadata = null;\n let compileFactoryMetadata = null;\n let token = this._getTokenMetadata(provider.token);\n if (provider.useClass) {\n compileTypeMetadata =\n this._getInjectableTypeMetadata(provider.useClass, provider.dependencies);\n compileDeps = compileTypeMetadata.diDeps;\n if (provider.token === provider.useClass) {\n // use the compileTypeMetadata as it contains information about lifecycleHooks...\n token = { identifier: compileTypeMetadata };\n }\n }\n else if (provider.useFactory) {\n compileFactoryMetadata = this._getFactoryMetadata(provider.useFactory, provider.dependencies);\n compileDeps = compileFactoryMetadata.diDeps;\n }\n return {\n token: token,\n useClass: compileTypeMetadata,\n useValue: provider.useValue,\n useFactory: compileFactoryMetadata,\n useExisting: provider.useExisting ? this._getTokenMetadata(provider.useExisting) : undefined,\n deps: compileDeps,\n multi: provider.multi\n };\n }\n _getQueriesMetadata(queries, isViewQuery, directiveType) {\n const res = [];\n Object.keys(queries).forEach((propertyName) => {\n const query = queries[propertyName];\n if (query.isViewQuery === isViewQuery) {\n res.push(this._getQueryMetadata(query, propertyName, directiveType));\n }\n });\n return res;\n }\n _queryVarBindings(selector) { return selector.split(/\\s*,\\s*/); }\n _getQueryMetadata(q, propertyName, typeOrFunc) {\n let selectors;\n if (typeof q.selector === 'string') {\n selectors =\n this._queryVarBindings(q.selector).map(varName => this._getTokenMetadata(varName));\n }\n else {\n if (!q.selector) {\n this._reportError(syntaxError(`Can't construct a query for the property \"${propertyName}\" of \"${stringifyType(typeOrFunc)}\" since the query selector wasn't defined.`), typeOrFunc);\n selectors = [];\n }\n else {\n selectors = [this._getTokenMetadata(q.selector)];\n }\n }\n return {\n selectors,\n first: q.first,\n descendants: q.descendants, propertyName,\n read: q.read ? this._getTokenMetadata(q.read) : null\n };\n }\n _reportError(error$$1, type, otherType) {\n if (this._errorCollector) {\n this._errorCollector(error$$1, type);\n if (otherType) {\n this._errorCollector(error$$1, otherType);\n }\n }\n else {\n throw error$$1;\n }\n }\n}\nfunction flattenArray(tree, out = []) {\n if (tree) {\n for (let i = 0; i < tree.length; i++) {\n const item = resolveForwardRef(tree[i]);\n if (Array.isArray(item)) {\n flattenArray(item, out);\n }\n else {\n out.push(item);\n }\n }\n }\n return out;\n}\nfunction dedupeArray(array) {\n if (array) {\n return Array.from(new Set(array));\n }\n return [];\n}\nfunction flattenAndDedupeArray(tree) {\n return dedupeArray(flattenArray(tree));\n}\nfunction isValidType(value) {\n return (value instanceof StaticSymbol) || (value instanceof Type);\n}\nfunction extractIdentifiers(value, targetIdentifiers) {\n visitValue(value, new _CompileValueConverter(), targetIdentifiers);\n}\nclass _CompileValueConverter extends ValueTransformer {\n visitOther(value, targetIdentifiers) {\n targetIdentifiers.push({ reference: value });\n }\n}\nfunction stringifyType(type) {\n if (type instanceof StaticSymbol) {\n return `${type.name} in ${type.filePath}`;\n }\n else {\n return stringify(type);\n }\n}\n/**\n * Indicates that a component is still being loaded in a synchronous compile.\n */\nfunction componentStillLoadingError(compType) {\n const error$$1 = Error(`Can't compile synchronously as ${stringify(compType)} is still being loaded!`);\n error$$1[ERROR_COMPONENT_TYPE] = compType;\n return error$$1;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass ProviderError extends ParseError {\n constructor(message, span) { super(span, message); }\n}\nclass ProviderViewContext {\n constructor(reflector, component) {\n this.reflector = reflector;\n this.component = component;\n this.errors = [];\n this.viewQueries = _getViewQueries(component);\n this.viewProviders = new Map();\n component.viewProviders.forEach((provider) => {\n if (this.viewProviders.get(tokenReference(provider.token)) == null) {\n this.viewProviders.set(tokenReference(provider.token), true);\n }\n });\n }\n}\nclass ProviderElementContext {\n constructor(viewContext, _parent, _isViewRoot, _directiveAsts, attrs, refs, isTemplate, contentQueryStartId, _sourceSpan) {\n this.viewContext = viewContext;\n this._parent = _parent;\n this._isViewRoot = _isViewRoot;\n this._directiveAsts = _directiveAsts;\n this._sourceSpan = _sourceSpan;\n this._transformedProviders = new Map();\n this._seenProviders = new Map();\n this._queriedTokens = new Map();\n this.transformedHasViewContainer = false;\n this._attrs = {};\n attrs.forEach((attrAst) => this._attrs[attrAst.name] = attrAst.value);\n const directivesMeta = _directiveAsts.map(directiveAst => directiveAst.directive);\n this._allProviders =\n _resolveProvidersFromDirectives(directivesMeta, _sourceSpan, viewContext.errors);\n this._contentQueries = _getContentQueries(contentQueryStartId, directivesMeta);\n Array.from(this._allProviders.values()).forEach((provider) => {\n this._addQueryReadsTo(provider.token, provider.token, this._queriedTokens);\n });\n if (isTemplate) {\n const templateRefId = createTokenForExternalReference(this.viewContext.reflector, Identifiers.TemplateRef);\n this._addQueryReadsTo(templateRefId, templateRefId, this._queriedTokens);\n }\n refs.forEach((refAst) => {\n let defaultQueryValue = refAst.value ||\n createTokenForExternalReference(this.viewContext.reflector, Identifiers.ElementRef);\n this._addQueryReadsTo({ value: refAst.name }, defaultQueryValue, this._queriedTokens);\n });\n if (this._queriedTokens.get(this.viewContext.reflector.resolveExternalReference(Identifiers.ViewContainerRef))) {\n this.transformedHasViewContainer = true;\n }\n // create the providers that we know are eager first\n Array.from(this._allProviders.values()).forEach((provider) => {\n const eager = provider.eager || this._queriedTokens.get(tokenReference(provider.token));\n if (eager) {\n this._getOrCreateLocalProvider(provider.providerType, provider.token, true);\n }\n });\n }\n afterElement() {\n // collect lazy providers\n Array.from(this._allProviders.values()).forEach((provider) => {\n this._getOrCreateLocalProvider(provider.providerType, provider.token, false);\n });\n }\n get transformProviders() {\n // Note: Maps keep their insertion order.\n const lazyProviders = [];\n const eagerProviders = [];\n this._transformedProviders.forEach(provider => {\n if (provider.eager) {\n eagerProviders.push(provider);\n }\n else {\n lazyProviders.push(provider);\n }\n });\n return lazyProviders.concat(eagerProviders);\n }\n get transformedDirectiveAsts() {\n const sortedProviderTypes = this.transformProviders.map(provider => provider.token.identifier);\n const sortedDirectives = this._directiveAsts.slice();\n sortedDirectives.sort((dir1, dir2) => sortedProviderTypes.indexOf(dir1.directive.type) -\n sortedProviderTypes.indexOf(dir2.directive.type));\n return sortedDirectives;\n }\n get queryMatches() {\n const allMatches = [];\n this._queriedTokens.forEach((matches) => { allMatches.push(...matches); });\n return allMatches;\n }\n _addQueryReadsTo(token, defaultValue, queryReadTokens) {\n this._getQueriesFor(token).forEach((query) => {\n const queryValue = query.meta.read || defaultValue;\n const tokenRef = tokenReference(queryValue);\n let queryMatches = queryReadTokens.get(tokenRef);\n if (!queryMatches) {\n queryMatches = [];\n queryReadTokens.set(tokenRef, queryMatches);\n }\n queryMatches.push({ queryId: query.queryId, value: queryValue });\n });\n }\n _getQueriesFor(token) {\n const result = [];\n let currentEl = this;\n let distance = 0;\n let queries;\n while (currentEl !== null) {\n queries = currentEl._contentQueries.get(tokenReference(token));\n if (queries) {\n result.push(...queries.filter((query) => query.meta.descendants || distance <= 1));\n }\n if (currentEl._directiveAsts.length > 0) {\n distance++;\n }\n currentEl = currentEl._parent;\n }\n queries = this.viewContext.viewQueries.get(tokenReference(token));\n if (queries) {\n result.push(...queries);\n }\n return result;\n }\n _getOrCreateLocalProvider(requestingProviderType, token, eager) {\n const resolvedProvider = this._allProviders.get(tokenReference(token));\n if (!resolvedProvider || ((requestingProviderType === ProviderAstType.Directive ||\n requestingProviderType === ProviderAstType.PublicService) &&\n resolvedProvider.providerType === ProviderAstType.PrivateService) ||\n ((requestingProviderType === ProviderAstType.PrivateService ||\n requestingProviderType === ProviderAstType.PublicService) &&\n resolvedProvider.providerType === ProviderAstType.Builtin)) {\n return null;\n }\n let transformedProviderAst = this._transformedProviders.get(tokenReference(token));\n if (transformedProviderAst) {\n return transformedProviderAst;\n }\n if (this._seenProviders.get(tokenReference(token)) != null) {\n this.viewContext.errors.push(new ProviderError(`Cannot instantiate cyclic dependency! ${tokenName(token)}`, this._sourceSpan));\n return null;\n }\n this._seenProviders.set(tokenReference(token), true);\n const transformedProviders = resolvedProvider.providers.map((provider) => {\n let transformedUseValue = provider.useValue;\n let transformedUseExisting = provider.useExisting;\n let transformedDeps = undefined;\n if (provider.useExisting != null) {\n const existingDiDep = this._getDependency(resolvedProvider.providerType, { token: provider.useExisting }, eager);\n if (existingDiDep.token != null) {\n transformedUseExisting = existingDiDep.token;\n }\n else {\n transformedUseExisting = null;\n transformedUseValue = existingDiDep.value;\n }\n }\n else if (provider.useFactory) {\n const deps = provider.deps || provider.useFactory.diDeps;\n transformedDeps =\n deps.map((dep) => this._getDependency(resolvedProvider.providerType, dep, eager));\n }\n else if (provider.useClass) {\n const deps = provider.deps || provider.useClass.diDeps;\n transformedDeps =\n deps.map((dep) => this._getDependency(resolvedProvider.providerType, dep, eager));\n }\n return _transformProvider(provider, {\n useExisting: transformedUseExisting,\n useValue: transformedUseValue,\n deps: transformedDeps\n });\n });\n transformedProviderAst =\n _transformProviderAst(resolvedProvider, { eager: eager, providers: transformedProviders });\n this._transformedProviders.set(tokenReference(token), transformedProviderAst);\n return transformedProviderAst;\n }\n _getLocalDependency(requestingProviderType, dep, eager = false) {\n if (dep.isAttribute) {\n const attrValue = this._attrs[dep.token.value];\n return { isValue: true, value: attrValue == null ? null : attrValue };\n }\n if (dep.token != null) {\n // access builtints\n if ((requestingProviderType === ProviderAstType.Directive ||\n requestingProviderType === ProviderAstType.Component)) {\n if (tokenReference(dep.token) ===\n this.viewContext.reflector.resolveExternalReference(Identifiers.Renderer) ||\n tokenReference(dep.token) ===\n this.viewContext.reflector.resolveExternalReference(Identifiers.ElementRef) ||\n tokenReference(dep.token) ===\n this.viewContext.reflector.resolveExternalReference(Identifiers.ChangeDetectorRef) ||\n tokenReference(dep.token) ===\n this.viewContext.reflector.resolveExternalReference(Identifiers.TemplateRef)) {\n return dep;\n }\n if (tokenReference(dep.token) ===\n this.viewContext.reflector.resolveExternalReference(Identifiers.ViewContainerRef)) {\n this.transformedHasViewContainer = true;\n }\n }\n // access the injector\n if (tokenReference(dep.token) ===\n this.viewContext.reflector.resolveExternalReference(Identifiers.Injector)) {\n return dep;\n }\n // access providers\n if (this._getOrCreateLocalProvider(requestingProviderType, dep.token, eager) != null) {\n return dep;\n }\n }\n return null;\n }\n _getDependency(requestingProviderType, dep, eager = false) {\n let currElement = this;\n let currEager = eager;\n let result = null;\n if (!dep.isSkipSelf) {\n result = this._getLocalDependency(requestingProviderType, dep, eager);\n }\n if (dep.isSelf) {\n if (!result && dep.isOptional) {\n result = { isValue: true, value: null };\n }\n }\n else {\n // check parent elements\n while (!result && currElement._parent) {\n const prevElement = currElement;\n currElement = currElement._parent;\n if (prevElement._isViewRoot) {\n currEager = false;\n }\n result = currElement._getLocalDependency(ProviderAstType.PublicService, dep, currEager);\n }\n // check @Host restriction\n if (!result) {\n if (!dep.isHost || this.viewContext.component.isHost ||\n this.viewContext.component.type.reference === tokenReference(dep.token) ||\n this.viewContext.viewProviders.get(tokenReference(dep.token)) != null) {\n result = dep;\n }\n else {\n result = dep.isOptional ? { isValue: true, value: null } : null;\n }\n }\n }\n if (!result) {\n this.viewContext.errors.push(new ProviderError(`No provider for ${tokenName(dep.token)}`, this._sourceSpan));\n }\n return result;\n }\n}\nclass NgModuleProviderAnalyzer {\n constructor(reflector, ngModule, extraProviders, sourceSpan) {\n this.reflector = reflector;\n this._transformedProviders = new Map();\n this._seenProviders = new Map();\n this._errors = [];\n this._allProviders = new Map();\n ngModule.transitiveModule.modules.forEach((ngModuleType) => {\n const ngModuleProvider = { token: { identifier: ngModuleType }, useClass: ngModuleType };\n _resolveProviders([ngModuleProvider], ProviderAstType.PublicService, true, sourceSpan, this._errors, this._allProviders, /* isModule */ true);\n });\n _resolveProviders(ngModule.transitiveModule.providers.map(entry => entry.provider).concat(extraProviders), ProviderAstType.PublicService, false, sourceSpan, this._errors, this._allProviders, \n /* isModule */ false);\n }\n parse() {\n Array.from(this._allProviders.values()).forEach((provider) => {\n this._getOrCreateLocalProvider(provider.token, provider.eager);\n });\n if (this._errors.length > 0) {\n const errorString = this._errors.join('\\n');\n throw new Error(`Provider parse errors:\\n${errorString}`);\n }\n // Note: Maps keep their insertion order.\n const lazyProviders = [];\n const eagerProviders = [];\n this._transformedProviders.forEach(provider => {\n if (provider.eager) {\n eagerProviders.push(provider);\n }\n else {\n lazyProviders.push(provider);\n }\n });\n return lazyProviders.concat(eagerProviders);\n }\n _getOrCreateLocalProvider(token, eager) {\n const resolvedProvider = this._allProviders.get(tokenReference(token));\n if (!resolvedProvider) {\n return null;\n }\n let transformedProviderAst = this._transformedProviders.get(tokenReference(token));\n if (transformedProviderAst) {\n return transformedProviderAst;\n }\n if (this._seenProviders.get(tokenReference(token)) != null) {\n this._errors.push(new ProviderError(`Cannot instantiate cyclic dependency! ${tokenName(token)}`, resolvedProvider.sourceSpan));\n return null;\n }\n this._seenProviders.set(tokenReference(token), true);\n const transformedProviders = resolvedProvider.providers.map((provider) => {\n let transformedUseValue = provider.useValue;\n let transformedUseExisting = provider.useExisting;\n let transformedDeps = undefined;\n if (provider.useExisting != null) {\n const existingDiDep = this._getDependency({ token: provider.useExisting }, eager, resolvedProvider.sourceSpan);\n if (existingDiDep.token != null) {\n transformedUseExisting = existingDiDep.token;\n }\n else {\n transformedUseExisting = null;\n transformedUseValue = existingDiDep.value;\n }\n }\n else if (provider.useFactory) {\n const deps = provider.deps || provider.useFactory.diDeps;\n transformedDeps =\n deps.map((dep) => this._getDependency(dep, eager, resolvedProvider.sourceSpan));\n }\n else if (provider.useClass) {\n const deps = provider.deps || provider.useClass.diDeps;\n transformedDeps =\n deps.map((dep) => this._getDependency(dep, eager, resolvedProvider.sourceSpan));\n }\n return _transformProvider(provider, {\n useExisting: transformedUseExisting,\n useValue: transformedUseValue,\n deps: transformedDeps\n });\n });\n transformedProviderAst =\n _transformProviderAst(resolvedProvider, { eager: eager, providers: transformedProviders });\n this._transformedProviders.set(tokenReference(token), transformedProviderAst);\n return transformedProviderAst;\n }\n _getDependency(dep, eager = false, requestorSourceSpan) {\n if (!dep.isSkipSelf && dep.token != null) {\n // access the injector\n if (tokenReference(dep.token) ===\n this.reflector.resolveExternalReference(Identifiers.Injector) ||\n tokenReference(dep.token) ===\n this.reflector.resolveExternalReference(Identifiers.ComponentFactoryResolver)) ;\n else if (this._getOrCreateLocalProvider(dep.token, eager) != null) ;\n }\n return dep;\n }\n}\nfunction _transformProvider(provider, { useExisting, useValue, deps }) {\n return {\n token: provider.token,\n useClass: provider.useClass,\n useExisting: useExisting,\n useFactory: provider.useFactory,\n useValue: useValue,\n deps: deps,\n multi: provider.multi\n };\n}\nfunction _transformProviderAst(provider, { eager, providers }) {\n return new ProviderAst(provider.token, provider.multiProvider, provider.eager || eager, providers, provider.providerType, provider.lifecycleHooks, provider.sourceSpan, provider.isModule);\n}\nfunction _resolveProvidersFromDirectives(directives, sourceSpan, targetErrors) {\n const providersByToken = new Map();\n directives.forEach((directive) => {\n const dirProvider = { token: { identifier: directive.type }, useClass: directive.type };\n _resolveProviders([dirProvider], directive.isComponent ? ProviderAstType.Component : ProviderAstType.Directive, true, sourceSpan, targetErrors, providersByToken, /* isModule */ false);\n });\n // Note: directives need to be able to overwrite providers of a component!\n const directivesWithComponentFirst = directives.filter(dir => dir.isComponent).concat(directives.filter(dir => !dir.isComponent));\n directivesWithComponentFirst.forEach((directive) => {\n _resolveProviders(directive.providers, ProviderAstType.PublicService, false, sourceSpan, targetErrors, providersByToken, /* isModule */ false);\n _resolveProviders(directive.viewProviders, ProviderAstType.PrivateService, false, sourceSpan, targetErrors, providersByToken, /* isModule */ false);\n });\n return providersByToken;\n}\nfunction _resolveProviders(providers, providerType, eager, sourceSpan, targetErrors, targetProvidersByToken, isModule) {\n providers.forEach((provider) => {\n let resolvedProvider = targetProvidersByToken.get(tokenReference(provider.token));\n if (resolvedProvider != null && !!resolvedProvider.multiProvider !== !!provider.multi) {\n targetErrors.push(new ProviderError(`Mixing multi and non multi provider is not possible for token ${tokenName(resolvedProvider.token)}`, sourceSpan));\n }\n if (!resolvedProvider) {\n const lifecycleHooks = provider.token.identifier &&\n provider.token.identifier.lifecycleHooks ?\n provider.token.identifier.lifecycleHooks :\n [];\n const isUseValue = !(provider.useClass || provider.useExisting || provider.useFactory);\n resolvedProvider = new ProviderAst(provider.token, !!provider.multi, eager || isUseValue, [provider], providerType, lifecycleHooks, sourceSpan, isModule);\n targetProvidersByToken.set(tokenReference(provider.token), resolvedProvider);\n }\n else {\n if (!provider.multi) {\n resolvedProvider.providers.length = 0;\n }\n resolvedProvider.providers.push(provider);\n }\n });\n}\nfunction _getViewQueries(component) {\n // Note: queries start with id 1 so we can use the number in a Bloom filter!\n let viewQueryId = 1;\n const viewQueries = new Map();\n if (component.viewQueries) {\n component.viewQueries.forEach((query) => _addQueryToTokenMap(viewQueries, { meta: query, queryId: viewQueryId++ }));\n }\n return viewQueries;\n}\nfunction _getContentQueries(contentQueryStartId, directives) {\n let contentQueryId = contentQueryStartId;\n const contentQueries = new Map();\n directives.forEach((directive, directiveIndex) => {\n if (directive.queries) {\n directive.queries.forEach((query) => _addQueryToTokenMap(contentQueries, { meta: query, queryId: contentQueryId++ }));\n }\n });\n return contentQueries;\n}\nfunction _addQueryToTokenMap(map, query) {\n query.meta.selectors.forEach((token) => {\n let entry = map.get(tokenReference(token));\n if (!entry) {\n entry = [];\n map.set(tokenReference(token), entry);\n }\n entry.push(query);\n });\n}\n\n/**\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 */\nfunction providerDef(ctx, providerAst) {\n let flags = 0 /* None */;\n if (!providerAst.eager) {\n flags |= 4096 /* LazyProvider */;\n }\n if (providerAst.providerType === ProviderAstType.PrivateService) {\n flags |= 8192 /* PrivateProvider */;\n }\n if (providerAst.isModule) {\n flags |= 1073741824 /* TypeModuleProvider */;\n }\n providerAst.lifecycleHooks.forEach((lifecycleHook) => {\n // for regular providers, we only support ngOnDestroy\n if (lifecycleHook === LifecycleHooks.OnDestroy ||\n providerAst.providerType === ProviderAstType.Directive ||\n providerAst.providerType === ProviderAstType.Component) {\n flags |= lifecycleHookToNodeFlag(lifecycleHook);\n }\n });\n const { providerExpr, flags: providerFlags, depsExpr } = providerAst.multiProvider ?\n multiProviderDef(ctx, flags, providerAst.providers) :\n singleProviderDef(ctx, flags, providerAst.providerType, providerAst.providers[0]);\n return {\n providerExpr,\n flags: providerFlags, depsExpr,\n tokenExpr: tokenExpr(ctx, providerAst.token),\n };\n}\nfunction multiProviderDef(ctx, flags, providers) {\n const allDepDefs = [];\n const allParams = [];\n const exprs = providers.map((provider, providerIndex) => {\n let expr;\n if (provider.useClass) {\n const depExprs = convertDeps(providerIndex, provider.deps || provider.useClass.diDeps);\n expr = ctx.importExpr(provider.useClass.reference).instantiate(depExprs);\n }\n else if (provider.useFactory) {\n const depExprs = convertDeps(providerIndex, provider.deps || provider.useFactory.diDeps);\n expr = ctx.importExpr(provider.useFactory.reference).callFn(depExprs);\n }\n else if (provider.useExisting) {\n const depExprs = convertDeps(providerIndex, [{ token: provider.useExisting }]);\n expr = depExprs[0];\n }\n else {\n expr = convertValueToOutputAst(ctx, provider.useValue);\n }\n return expr;\n });\n const providerExpr = fn(allParams, [new ReturnStatement(literalArr(exprs))], INFERRED_TYPE);\n return {\n providerExpr,\n flags: flags | 1024 /* TypeFactoryProvider */,\n depsExpr: literalArr(allDepDefs)\n };\n function convertDeps(providerIndex, deps) {\n return deps.map((dep, depIndex) => {\n const paramName = `p${providerIndex}_${depIndex}`;\n allParams.push(new FnParam(paramName, DYNAMIC_TYPE));\n allDepDefs.push(depDef(ctx, dep));\n return variable(paramName);\n });\n }\n}\nfunction singleProviderDef(ctx, flags, providerType, providerMeta) {\n let providerExpr;\n let deps;\n if (providerType === ProviderAstType.Directive || providerType === ProviderAstType.Component) {\n providerExpr = ctx.importExpr(providerMeta.useClass.reference);\n flags |= 16384 /* TypeDirective */;\n deps = providerMeta.deps || providerMeta.useClass.diDeps;\n }\n else {\n if (providerMeta.useClass) {\n providerExpr = ctx.importExpr(providerMeta.useClass.reference);\n flags |= 512 /* TypeClassProvider */;\n deps = providerMeta.deps || providerMeta.useClass.diDeps;\n }\n else if (providerMeta.useFactory) {\n providerExpr = ctx.importExpr(providerMeta.useFactory.reference);\n flags |= 1024 /* TypeFactoryProvider */;\n deps = providerMeta.deps || providerMeta.useFactory.diDeps;\n }\n else if (providerMeta.useExisting) {\n providerExpr = NULL_EXPR;\n flags |= 2048 /* TypeUseExistingProvider */;\n deps = [{ token: providerMeta.useExisting }];\n }\n else {\n providerExpr = convertValueToOutputAst(ctx, providerMeta.useValue);\n flags |= 256 /* TypeValueProvider */;\n deps = [];\n }\n }\n const depsExpr = literalArr(deps.map(dep => depDef(ctx, dep)));\n return { providerExpr, flags, depsExpr };\n}\nfunction tokenExpr(ctx, tokenMeta) {\n return tokenMeta.identifier ? ctx.importExpr(tokenMeta.identifier.reference) :\n literal(tokenMeta.value);\n}\nfunction depDef(ctx, dep) {\n // Note: the following fields have already been normalized out by provider_analyzer:\n // - isAttribute, isHost\n const expr = dep.isValue ? convertValueToOutputAst(ctx, dep.value) : tokenExpr(ctx, dep.token);\n let flags = 0 /* None */;\n if (dep.isSkipSelf) {\n flags |= 1 /* SkipSelf */;\n }\n if (dep.isOptional) {\n flags |= 2 /* Optional */;\n }\n if (dep.isSelf) {\n flags |= 4 /* Self */;\n }\n if (dep.isValue) {\n flags |= 8 /* Value */;\n }\n return flags === 0 /* None */ ? expr : literalArr([literal(flags), expr]);\n}\nfunction lifecycleHookToNodeFlag(lifecycleHook) {\n let nodeFlag = 0 /* None */;\n switch (lifecycleHook) {\n case LifecycleHooks.AfterContentChecked:\n nodeFlag = 2097152 /* AfterContentChecked */;\n break;\n case LifecycleHooks.AfterContentInit:\n nodeFlag = 1048576 /* AfterContentInit */;\n break;\n case LifecycleHooks.AfterViewChecked:\n nodeFlag = 8388608 /* AfterViewChecked */;\n break;\n case LifecycleHooks.AfterViewInit:\n nodeFlag = 4194304 /* AfterViewInit */;\n break;\n case LifecycleHooks.DoCheck:\n nodeFlag = 262144 /* DoCheck */;\n break;\n case LifecycleHooks.OnChanges:\n nodeFlag = 524288 /* OnChanges */;\n break;\n case LifecycleHooks.OnDestroy:\n nodeFlag = 131072 /* OnDestroy */;\n break;\n case LifecycleHooks.OnInit:\n nodeFlag = 65536 /* OnInit */;\n break;\n }\n return nodeFlag;\n}\nfunction componentFactoryResolverProviderDef(reflector, ctx, flags, entryComponents) {\n const entryComponentFactories = entryComponents.map((entryComponent) => ctx.importExpr(entryComponent.componentFactory));\n const token = createTokenForExternalReference(reflector, Identifiers.ComponentFactoryResolver);\n const classMeta = {\n diDeps: [\n { isValue: true, value: literalArr(entryComponentFactories) },\n { token: token, isSkipSelf: true, isOptional: true },\n { token: createTokenForExternalReference(reflector, Identifiers.NgModuleRef) },\n ],\n lifecycleHooks: [],\n reference: reflector.resolveExternalReference(Identifiers.CodegenComponentFactoryResolver)\n };\n const { providerExpr, flags: providerFlags, depsExpr } = singleProviderDef(ctx, flags, ProviderAstType.PrivateService, {\n token,\n multi: false,\n useClass: classMeta,\n });\n return { providerExpr, flags: providerFlags, depsExpr, tokenExpr: tokenExpr(ctx, token) };\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass NgModuleCompileResult {\n constructor(ngModuleFactoryVar) {\n this.ngModuleFactoryVar = ngModuleFactoryVar;\n }\n}\nconst LOG_VAR = variable('_l');\nclass NgModuleCompiler {\n constructor(reflector) {\n this.reflector = reflector;\n }\n compile(ctx, ngModuleMeta, extraProviders) {\n const sourceSpan = typeSourceSpan('NgModule', ngModuleMeta.type);\n const entryComponentFactories = ngModuleMeta.transitiveModule.entryComponents;\n const bootstrapComponents = ngModuleMeta.bootstrapComponents;\n const providerParser = new NgModuleProviderAnalyzer(this.reflector, ngModuleMeta, extraProviders, sourceSpan);\n const providerDefs = [componentFactoryResolverProviderDef(this.reflector, ctx, 0 /* None */, entryComponentFactories)]\n .concat(providerParser.parse().map((provider) => providerDef(ctx, provider)))\n .map(({ providerExpr, depsExpr, flags, tokenExpr }) => {\n return importExpr(Identifiers.moduleProviderDef).callFn([\n literal(flags), tokenExpr, providerExpr, depsExpr\n ]);\n });\n const ngModuleDef = importExpr(Identifiers.moduleDef).callFn([literalArr(providerDefs)]);\n const ngModuleDefFactory = fn([new FnParam(LOG_VAR.name)], [new ReturnStatement(ngModuleDef)], INFERRED_TYPE);\n const ngModuleFactoryVar = `${identifierName(ngModuleMeta.type)}NgFactory`;\n this._createNgModuleFactory(ctx, ngModuleMeta.type.reference, importExpr(Identifiers.createModuleFactory).callFn([\n ctx.importExpr(ngModuleMeta.type.reference),\n literalArr(bootstrapComponents.map(id => ctx.importExpr(id.reference))),\n ngModuleDefFactory\n ]));\n if (ngModuleMeta.id) {\n const id = typeof ngModuleMeta.id === 'string' ? literal(ngModuleMeta.id) :\n ctx.importExpr(ngModuleMeta.id);\n const registerFactoryStmt = importExpr(Identifiers.RegisterModuleFactoryFn)\n .callFn([id, variable(ngModuleFactoryVar)])\n .toStmt();\n ctx.statements.push(registerFactoryStmt);\n }\n return new NgModuleCompileResult(ngModuleFactoryVar);\n }\n createStub(ctx, ngModuleReference) {\n this._createNgModuleFactory(ctx, ngModuleReference, NULL_EXPR);\n }\n _createNgModuleFactory(ctx, reference, value) {\n const ngModuleFactoryVar = `${identifierName({ reference: reference })}NgFactory`;\n const ngModuleFactoryStmt = variable(ngModuleFactoryVar)\n .set(value)\n .toDeclStmt(importType(Identifiers.NgModuleFactory, [expressionType(ctx.importExpr(reference))], [TypeModifier.Const]), [StmtModifier.Final, StmtModifier.Exported]);\n ctx.statements.push(ngModuleFactoryStmt);\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Resolves types to {@link NgModule}.\n */\nclass NgModuleResolver {\n constructor(_reflector) {\n this._reflector = _reflector;\n }\n isNgModule(type) { return this._reflector.annotations(type).some(createNgModule.isTypeOf); }\n resolve(type, throwIfNotFound = true) {\n const ngModuleMeta = findLast(this._reflector.annotations(type), createNgModule.isTypeOf);\n if (ngModuleMeta) {\n return ngModuleMeta;\n }\n else {\n if (throwIfNotFound) {\n throw new Error(`No NgModule metadata found for '${stringify(type)}'.`);\n }\n return null;\n }\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit\nconst VERSION$1 = 3;\nconst JS_B64_PREFIX = '# sourceMappingURL=data:application/json;base64,';\nclass SourceMapGenerator {\n constructor(file = null) {\n this.file = file;\n this.sourcesContent = new Map();\n this.lines = [];\n this.lastCol0 = 0;\n this.hasMappings = false;\n }\n // The content is `null` when the content is expected to be loaded using the URL\n addSource(url, content = null) {\n if (!this.sourcesContent.has(url)) {\n this.sourcesContent.set(url, content);\n }\n return this;\n }\n addLine() {\n this.lines.push([]);\n this.lastCol0 = 0;\n return this;\n }\n addMapping(col0, sourceUrl, sourceLine0, sourceCol0) {\n if (!this.currentLine) {\n throw new Error(`A line must be added before mappings can be added`);\n }\n if (sourceUrl != null && !this.sourcesContent.has(sourceUrl)) {\n throw new Error(`Unknown source file \"${sourceUrl}\"`);\n }\n if (col0 == null) {\n throw new Error(`The column in the generated code must be provided`);\n }\n if (col0 < this.lastCol0) {\n throw new Error(`Mapping should be added in output order`);\n }\n if (sourceUrl && (sourceLine0 == null || sourceCol0 == null)) {\n throw new Error(`The source location must be provided when a source url is provided`);\n }\n this.hasMappings = true;\n this.lastCol0 = col0;\n this.currentLine.push({ col0, sourceUrl, sourceLine0, sourceCol0 });\n return this;\n }\n get currentLine() { return this.lines.slice(-1)[0]; }\n toJSON() {\n if (!this.hasMappings) {\n return null;\n }\n const sourcesIndex = new Map();\n const sources = [];\n const sourcesContent = [];\n Array.from(this.sourcesContent.keys()).forEach((url, i) => {\n sourcesIndex.set(url, i);\n sources.push(url);\n sourcesContent.push(this.sourcesContent.get(url) || null);\n });\n let mappings = '';\n let lastCol0 = 0;\n let lastSourceIndex = 0;\n let lastSourceLine0 = 0;\n let lastSourceCol0 = 0;\n this.lines.forEach(segments => {\n lastCol0 = 0;\n mappings += segments\n .map(segment => {\n // zero-based starting column of the line in the generated code\n let segAsStr = toBase64VLQ(segment.col0 - lastCol0);\n lastCol0 = segment.col0;\n if (segment.sourceUrl != null) {\n // zero-based index into the “sources” list\n segAsStr +=\n toBase64VLQ(sourcesIndex.get(segment.sourceUrl) - lastSourceIndex);\n lastSourceIndex = sourcesIndex.get(segment.sourceUrl);\n // the zero-based starting line in the original source\n segAsStr += toBase64VLQ(segment.sourceLine0 - lastSourceLine0);\n lastSourceLine0 = segment.sourceLine0;\n // the zero-based starting column in the original source\n segAsStr += toBase64VLQ(segment.sourceCol0 - lastSourceCol0);\n lastSourceCol0 = segment.sourceCol0;\n }\n return segAsStr;\n })\n .join(',');\n mappings += ';';\n });\n mappings = mappings.slice(0, -1);\n return {\n 'file': this.file || '',\n 'version': VERSION$1,\n 'sourceRoot': '',\n 'sources': sources,\n 'sourcesContent': sourcesContent,\n 'mappings': mappings,\n };\n }\n toJsComment() {\n return this.hasMappings ? '//' + JS_B64_PREFIX + toBase64String(JSON.stringify(this, null, 0)) :\n '';\n }\n}\nfunction toBase64String(value) {\n let b64 = '';\n value = utf8Encode(value);\n for (let i = 0; i < value.length;) {\n const i1 = value.charCodeAt(i++);\n const i2 = value.charCodeAt(i++);\n const i3 = value.charCodeAt(i++);\n b64 += toBase64Digit(i1 >> 2);\n b64 += toBase64Digit(((i1 & 3) << 4) | (isNaN(i2) ? 0 : i2 >> 4));\n b64 += isNaN(i2) ? '=' : toBase64Digit(((i2 & 15) << 2) | (i3 >> 6));\n b64 += isNaN(i2) || isNaN(i3) ? '=' : toBase64Digit(i3 & 63);\n }\n return b64;\n}\nfunction toBase64VLQ(value) {\n value = value < 0 ? ((-value) << 1) + 1 : value << 1;\n let out = '';\n do {\n let digit = value & 31;\n value = value >> 5;\n if (value > 0) {\n digit = digit | 32;\n }\n out += toBase64Digit(digit);\n } while (value > 0);\n return out;\n}\nconst B64_DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\nfunction toBase64Digit(value) {\n if (value < 0 || value >= 64) {\n throw new Error(`Can only encode value in the range [0, 63]`);\n }\n return B64_DIGITS[value];\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst _SINGLE_QUOTE_ESCAPE_STRING_RE = /'|\\\\|\\n|\\r|\\$/g;\nconst _LEGAL_IDENTIFIER_RE = /^[$A-Z_][0-9A-Z_$]*$/i;\nconst _INDENT_WITH = ' ';\nconst CATCH_ERROR_VAR$1 = variable('error', null, null);\nconst CATCH_STACK_VAR$1 = variable('stack', null, null);\nclass _EmittedLine {\n constructor(indent) {\n this.indent = indent;\n this.partsLength = 0;\n this.parts = [];\n this.srcSpans = [];\n }\n}\nclass EmitterVisitorContext {\n constructor(_indent) {\n this._indent = _indent;\n this._classes = [];\n this._preambleLineCount = 0;\n this._lines = [new _EmittedLine(_indent)];\n }\n static createRoot() { return new EmitterVisitorContext(0); }\n get _currentLine() { return this._lines[this._lines.length - 1]; }\n println(from, lastPart = '') {\n this.print(from || null, lastPart, true);\n }\n lineIsEmpty() { return this._currentLine.parts.length === 0; }\n lineLength() {\n return this._currentLine.indent * _INDENT_WITH.length + this._currentLine.partsLength;\n }\n print(from, part, newLine = false) {\n if (part.length > 0) {\n this._currentLine.parts.push(part);\n this._currentLine.partsLength += part.length;\n this._currentLine.srcSpans.push(from && from.sourceSpan || null);\n }\n if (newLine) {\n this._lines.push(new _EmittedLine(this._indent));\n }\n }\n removeEmptyLastLine() {\n if (this.lineIsEmpty()) {\n this._lines.pop();\n }\n }\n incIndent() {\n this._indent++;\n if (this.lineIsEmpty()) {\n this._currentLine.indent = this._indent;\n }\n }\n decIndent() {\n this._indent--;\n if (this.lineIsEmpty()) {\n this._currentLine.indent = this._indent;\n }\n }\n pushClass(clazz) { this._classes.push(clazz); }\n popClass() { return this._classes.pop(); }\n get currentClass() {\n return this._classes.length > 0 ? this._classes[this._classes.length - 1] : null;\n }\n toSource() {\n return this.sourceLines\n .map(l => l.parts.length > 0 ? _createIndent(l.indent) + l.parts.join('') : '')\n .join('\\n');\n }\n toSourceMapGenerator(genFilePath, startsAtLine = 0) {\n const map = new SourceMapGenerator(genFilePath);\n let firstOffsetMapped = false;\n const mapFirstOffsetIfNeeded = () => {\n if (!firstOffsetMapped) {\n // Add a single space so that tools won't try to load the file from disk.\n // Note: We are using virtual urls like `ng:///`, so we have to\n // provide a content here.\n map.addSource(genFilePath, ' ').addMapping(0, genFilePath, 0, 0);\n firstOffsetMapped = true;\n }\n };\n for (let i = 0; i < startsAtLine; i++) {\n map.addLine();\n mapFirstOffsetIfNeeded();\n }\n this.sourceLines.forEach((line, lineIdx) => {\n map.addLine();\n const spans = line.srcSpans;\n const parts = line.parts;\n let col0 = line.indent * _INDENT_WITH.length;\n let spanIdx = 0;\n // skip leading parts without source spans\n while (spanIdx < spans.length && !spans[spanIdx]) {\n col0 += parts[spanIdx].length;\n spanIdx++;\n }\n if (spanIdx < spans.length && lineIdx === 0 && col0 === 0) {\n firstOffsetMapped = true;\n }\n else {\n mapFirstOffsetIfNeeded();\n }\n while (spanIdx < spans.length) {\n const span = spans[spanIdx];\n const source = span.start.file;\n const sourceLine = span.start.line;\n const sourceCol = span.start.col;\n map.addSource(source.url, source.content)\n .addMapping(col0, source.url, sourceLine, sourceCol);\n col0 += parts[spanIdx].length;\n spanIdx++;\n // assign parts without span or the same span to the previous segment\n while (spanIdx < spans.length && (span === spans[spanIdx] || !spans[spanIdx])) {\n col0 += parts[spanIdx].length;\n spanIdx++;\n }\n }\n });\n return map;\n }\n setPreambleLineCount(count) { return this._preambleLineCount = count; }\n spanOf(line, column) {\n const emittedLine = this._lines[line - this._preambleLineCount];\n if (emittedLine) {\n let columnsLeft = column - _createIndent(emittedLine.indent).length;\n for (let partIndex = 0; partIndex < emittedLine.parts.length; partIndex++) {\n const part = emittedLine.parts[partIndex];\n if (part.length > columnsLeft) {\n return emittedLine.srcSpans[partIndex];\n }\n columnsLeft -= part.length;\n }\n }\n return null;\n }\n get sourceLines() {\n if (this._lines.length && this._lines[this._lines.length - 1].parts.length === 0) {\n return this._lines.slice(0, -1);\n }\n return this._lines;\n }\n}\nclass AbstractEmitterVisitor {\n constructor(_escapeDollarInStrings) {\n this._escapeDollarInStrings = _escapeDollarInStrings;\n }\n visitExpressionStmt(stmt, ctx) {\n stmt.expr.visitExpression(this, ctx);\n ctx.println(stmt, ';');\n return null;\n }\n visitReturnStmt(stmt, ctx) {\n ctx.print(stmt, `return `);\n stmt.value.visitExpression(this, ctx);\n ctx.println(stmt, ';');\n return null;\n }\n visitIfStmt(stmt, ctx) {\n ctx.print(stmt, `if (`);\n stmt.condition.visitExpression(this, ctx);\n ctx.print(stmt, `) {`);\n const hasElseCase = stmt.falseCase != null && stmt.falseCase.length > 0;\n if (stmt.trueCase.length <= 1 && !hasElseCase) {\n ctx.print(stmt, ` `);\n this.visitAllStatements(stmt.trueCase, ctx);\n ctx.removeEmptyLastLine();\n ctx.print(stmt, ` `);\n }\n else {\n ctx.println();\n ctx.incIndent();\n this.visitAllStatements(stmt.trueCase, ctx);\n ctx.decIndent();\n if (hasElseCase) {\n ctx.println(stmt, `} else {`);\n ctx.incIndent();\n this.visitAllStatements(stmt.falseCase, ctx);\n ctx.decIndent();\n }\n }\n ctx.println(stmt, `}`);\n return null;\n }\n visitThrowStmt(stmt, ctx) {\n ctx.print(stmt, `throw `);\n stmt.error.visitExpression(this, ctx);\n ctx.println(stmt, `;`);\n return null;\n }\n visitCommentStmt(stmt, ctx) {\n if (stmt.multiline) {\n ctx.println(stmt, `/* ${stmt.comment} */`);\n }\n else {\n stmt.comment.split('\\n').forEach((line) => { ctx.println(stmt, `// ${line}`); });\n }\n return null;\n }\n visitJSDocCommentStmt(stmt, ctx) {\n ctx.println(stmt, `/*${stmt.toString()}*/`);\n return null;\n }\n visitWriteVarExpr(expr, ctx) {\n const lineWasEmpty = ctx.lineIsEmpty();\n if (!lineWasEmpty) {\n ctx.print(expr, '(');\n }\n ctx.print(expr, `${expr.name} = `);\n expr.value.visitExpression(this, ctx);\n if (!lineWasEmpty) {\n ctx.print(expr, ')');\n }\n return null;\n }\n visitWriteKeyExpr(expr, ctx) {\n const lineWasEmpty = ctx.lineIsEmpty();\n if (!lineWasEmpty) {\n ctx.print(expr, '(');\n }\n expr.receiver.visitExpression(this, ctx);\n ctx.print(expr, `[`);\n expr.index.visitExpression(this, ctx);\n ctx.print(expr, `] = `);\n expr.value.visitExpression(this, ctx);\n if (!lineWasEmpty) {\n ctx.print(expr, ')');\n }\n return null;\n }\n visitWritePropExpr(expr, ctx) {\n const lineWasEmpty = ctx.lineIsEmpty();\n if (!lineWasEmpty) {\n ctx.print(expr, '(');\n }\n expr.receiver.visitExpression(this, ctx);\n ctx.print(expr, `.${expr.name} = `);\n expr.value.visitExpression(this, ctx);\n if (!lineWasEmpty) {\n ctx.print(expr, ')');\n }\n return null;\n }\n visitInvokeMethodExpr(expr, ctx) {\n expr.receiver.visitExpression(this, ctx);\n let name = expr.name;\n if (expr.builtin != null) {\n name = this.getBuiltinMethodName(expr.builtin);\n if (name == null) {\n // some builtins just mean to skip the call.\n return null;\n }\n }\n ctx.print(expr, `.${name}(`);\n this.visitAllExpressions(expr.args, ctx, `,`);\n ctx.print(expr, `)`);\n return null;\n }\n visitInvokeFunctionExpr(expr, ctx) {\n expr.fn.visitExpression(this, ctx);\n ctx.print(expr, `(`);\n this.visitAllExpressions(expr.args, ctx, ',');\n ctx.print(expr, `)`);\n return null;\n }\n visitWrappedNodeExpr(ast, ctx) {\n throw new Error('Abstract emitter cannot visit WrappedNodeExpr.');\n }\n visitTypeofExpr(expr, ctx) {\n ctx.print(expr, 'typeof ');\n expr.expr.visitExpression(this, ctx);\n }\n visitReadVarExpr(ast, ctx) {\n let varName = ast.name;\n if (ast.builtin != null) {\n switch (ast.builtin) {\n case BuiltinVar.Super:\n varName = 'super';\n break;\n case BuiltinVar.This:\n varName = 'this';\n break;\n case BuiltinVar.CatchError:\n varName = CATCH_ERROR_VAR$1.name;\n break;\n case BuiltinVar.CatchStack:\n varName = CATCH_STACK_VAR$1.name;\n break;\n default:\n throw new Error(`Unknown builtin variable ${ast.builtin}`);\n }\n }\n ctx.print(ast, varName);\n return null;\n }\n visitInstantiateExpr(ast, ctx) {\n ctx.print(ast, `new `);\n ast.classExpr.visitExpression(this, ctx);\n ctx.print(ast, `(`);\n this.visitAllExpressions(ast.args, ctx, ',');\n ctx.print(ast, `)`);\n return null;\n }\n visitLiteralExpr(ast, ctx) {\n const value = ast.value;\n if (typeof value === 'string') {\n ctx.print(ast, escapeIdentifier(value, this._escapeDollarInStrings));\n }\n else {\n ctx.print(ast, `${value}`);\n }\n return null;\n }\n visitConditionalExpr(ast, ctx) {\n ctx.print(ast, `(`);\n ast.condition.visitExpression(this, ctx);\n ctx.print(ast, '? ');\n ast.trueCase.visitExpression(this, ctx);\n ctx.print(ast, ': ');\n ast.falseCase.visitExpression(this, ctx);\n ctx.print(ast, `)`);\n return null;\n }\n visitNotExpr(ast, ctx) {\n ctx.print(ast, '!');\n ast.condition.visitExpression(this, ctx);\n return null;\n }\n visitAssertNotNullExpr(ast, ctx) {\n ast.condition.visitExpression(this, ctx);\n return null;\n }\n visitBinaryOperatorExpr(ast, ctx) {\n let opStr;\n switch (ast.operator) {\n case BinaryOperator.Equals:\n opStr = '==';\n break;\n case BinaryOperator.Identical:\n opStr = '===';\n break;\n case BinaryOperator.NotEquals:\n opStr = '!=';\n break;\n case BinaryOperator.NotIdentical:\n opStr = '!==';\n break;\n case BinaryOperator.And:\n opStr = '&&';\n break;\n case BinaryOperator.BitwiseAnd:\n opStr = '&';\n break;\n case BinaryOperator.Or:\n opStr = '||';\n break;\n case BinaryOperator.Plus:\n opStr = '+';\n break;\n case BinaryOperator.Minus:\n opStr = '-';\n break;\n case BinaryOperator.Divide:\n opStr = '/';\n break;\n case BinaryOperator.Multiply:\n opStr = '*';\n break;\n case BinaryOperator.Modulo:\n opStr = '%';\n break;\n case BinaryOperator.Lower:\n opStr = '<';\n break;\n case BinaryOperator.LowerEquals:\n opStr = '<=';\n break;\n case BinaryOperator.Bigger:\n opStr = '>';\n break;\n case BinaryOperator.BiggerEquals:\n opStr = '>=';\n break;\n default:\n throw new Error(`Unknown operator ${ast.operator}`);\n }\n if (ast.parens)\n ctx.print(ast, `(`);\n ast.lhs.visitExpression(this, ctx);\n ctx.print(ast, ` ${opStr} `);\n ast.rhs.visitExpression(this, ctx);\n if (ast.parens)\n ctx.print(ast, `)`);\n return null;\n }\n visitReadPropExpr(ast, ctx) {\n ast.receiver.visitExpression(this, ctx);\n ctx.print(ast, `.`);\n ctx.print(ast, ast.name);\n return null;\n }\n visitReadKeyExpr(ast, ctx) {\n ast.receiver.visitExpression(this, ctx);\n ctx.print(ast, `[`);\n ast.index.visitExpression(this, ctx);\n ctx.print(ast, `]`);\n return null;\n }\n visitLiteralArrayExpr(ast, ctx) {\n ctx.print(ast, `[`);\n this.visitAllExpressions(ast.entries, ctx, ',');\n ctx.print(ast, `]`);\n return null;\n }\n visitLiteralMapExpr(ast, ctx) {\n ctx.print(ast, `{`);\n this.visitAllObjects(entry => {\n ctx.print(ast, `${escapeIdentifier(entry.key, this._escapeDollarInStrings, entry.quoted)}:`);\n entry.value.visitExpression(this, ctx);\n }, ast.entries, ctx, ',');\n ctx.print(ast, `}`);\n return null;\n }\n visitCommaExpr(ast, ctx) {\n ctx.print(ast, '(');\n this.visitAllExpressions(ast.parts, ctx, ',');\n ctx.print(ast, ')');\n return null;\n }\n visitAllExpressions(expressions, ctx, separator) {\n this.visitAllObjects(expr => expr.visitExpression(this, ctx), expressions, ctx, separator);\n }\n visitAllObjects(handler, expressions, ctx, separator) {\n let incrementedIndent = false;\n for (let i = 0; i < expressions.length; i++) {\n if (i > 0) {\n if (ctx.lineLength() > 80) {\n ctx.print(null, separator, true);\n if (!incrementedIndent) {\n // continuation are marked with double indent.\n ctx.incIndent();\n ctx.incIndent();\n incrementedIndent = true;\n }\n }\n else {\n ctx.print(null, separator, false);\n }\n }\n handler(expressions[i]);\n }\n if (incrementedIndent) {\n // continuation are marked with double indent.\n ctx.decIndent();\n ctx.decIndent();\n }\n }\n visitAllStatements(statements, ctx) {\n statements.forEach((stmt) => stmt.visitStatement(this, ctx));\n }\n}\nfunction escapeIdentifier(input, escapeDollar, alwaysQuote = true) {\n if (input == null) {\n return null;\n }\n const body = input.replace(_SINGLE_QUOTE_ESCAPE_STRING_RE, (...match) => {\n if (match[0] == '$') {\n return escapeDollar ? '\\\\$' : '$';\n }\n else if (match[0] == '\\n') {\n return '\\\\n';\n }\n else if (match[0] == '\\r') {\n return '\\\\r';\n }\n else {\n return `\\\\${match[0]}`;\n }\n });\n const requiresQuotes = alwaysQuote || !_LEGAL_IDENTIFIER_RE.test(body);\n return requiresQuotes ? `'${body}'` : body;\n}\nfunction _createIndent(count) {\n let res = '';\n for (let i = 0; i < count; i++) {\n res += _INDENT_WITH;\n }\n return res;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction debugOutputAstAsTypeScript(ast) {\n const converter = new _TsEmitterVisitor();\n const ctx = EmitterVisitorContext.createRoot();\n const asts = Array.isArray(ast) ? ast : [ast];\n asts.forEach((ast) => {\n if (ast instanceof Statement) {\n ast.visitStatement(converter, ctx);\n }\n else if (ast instanceof Expression) {\n ast.visitExpression(converter, ctx);\n }\n else if (ast instanceof Type$1) {\n ast.visitType(converter, ctx);\n }\n else {\n throw new Error(`Don't know how to print debug info for ${ast}`);\n }\n });\n return ctx.toSource();\n}\nclass TypeScriptEmitter {\n emitStatementsAndContext(genFilePath, stmts, preamble = '', emitSourceMaps = true, referenceFilter, importFilter) {\n const converter = new _TsEmitterVisitor(referenceFilter, importFilter);\n const ctx = EmitterVisitorContext.createRoot();\n converter.visitAllStatements(stmts, ctx);\n const preambleLines = preamble ? preamble.split('\\n') : [];\n converter.reexports.forEach((reexports, exportedModuleName) => {\n const reexportsCode = reexports.map(reexport => `${reexport.name} as ${reexport.as}`).join(',');\n preambleLines.push(`export {${reexportsCode}} from '${exportedModuleName}';`);\n });\n converter.importsWithPrefixes.forEach((prefix, importedModuleName) => {\n // Note: can't write the real word for import as it screws up system.js auto detection...\n preambleLines.push(`imp` +\n `ort * as ${prefix} from '${importedModuleName}';`);\n });\n const sm = emitSourceMaps ?\n ctx.toSourceMapGenerator(genFilePath, preambleLines.length).toJsComment() :\n '';\n const lines = [...preambleLines, ctx.toSource(), sm];\n if (sm) {\n // always add a newline at the end, as some tools have bugs without it.\n lines.push('');\n }\n ctx.setPreambleLineCount(preambleLines.length);\n return { sourceText: lines.join('\\n'), context: ctx };\n }\n emitStatements(genFilePath, stmts, preamble = '') {\n return this.emitStatementsAndContext(genFilePath, stmts, preamble).sourceText;\n }\n}\nclass _TsEmitterVisitor extends AbstractEmitterVisitor {\n constructor(referenceFilter, importFilter) {\n super(false);\n this.referenceFilter = referenceFilter;\n this.importFilter = importFilter;\n this.typeExpression = 0;\n this.importsWithPrefixes = new Map();\n this.reexports = new Map();\n }\n visitType(t, ctx, defaultType = 'any') {\n if (t) {\n this.typeExpression++;\n t.visitType(this, ctx);\n this.typeExpression--;\n }\n else {\n ctx.print(null, defaultType);\n }\n }\n visitLiteralExpr(ast, ctx) {\n const value = ast.value;\n if (value == null && ast.type != INFERRED_TYPE) {\n ctx.print(ast, `(${value} as any)`);\n return null;\n }\n return super.visitLiteralExpr(ast, ctx);\n }\n // Temporary workaround to support strictNullCheck enabled consumers of ngc emit.\n // In SNC mode, [] have the type never[], so we cast here to any[].\n // TODO: narrow the cast to a more explicit type, or use a pattern that does not\n // start with [].concat. see https://github.com/angular/angular/pull/11846\n visitLiteralArrayExpr(ast, ctx) {\n if (ast.entries.length === 0) {\n ctx.print(ast, '(');\n }\n const result = super.visitLiteralArrayExpr(ast, ctx);\n if (ast.entries.length === 0) {\n ctx.print(ast, ' as any[])');\n }\n return result;\n }\n visitExternalExpr(ast, ctx) {\n this._visitIdentifier(ast.value, ast.typeParams, ctx);\n return null;\n }\n visitAssertNotNullExpr(ast, ctx) {\n const result = super.visitAssertNotNullExpr(ast, ctx);\n ctx.print(ast, '!');\n return result;\n }\n visitDeclareVarStmt(stmt, ctx) {\n if (stmt.hasModifier(StmtModifier.Exported) && stmt.value instanceof ExternalExpr &&\n !stmt.type) {\n // check for a reexport\n const { name, moduleName } = stmt.value.value;\n if (moduleName) {\n let reexports = this.reexports.get(moduleName);\n if (!reexports) {\n reexports = [];\n this.reexports.set(moduleName, reexports);\n }\n reexports.push({ name: name, as: stmt.name });\n return null;\n }\n }\n if (stmt.hasModifier(StmtModifier.Exported)) {\n ctx.print(stmt, `export `);\n }\n if (stmt.hasModifier(StmtModifier.Final)) {\n ctx.print(stmt, `const`);\n }\n else {\n ctx.print(stmt, `var`);\n }\n ctx.print(stmt, ` ${stmt.name}`);\n this._printColonType(stmt.type, ctx);\n if (stmt.value) {\n ctx.print(stmt, ` = `);\n stmt.value.visitExpression(this, ctx);\n }\n ctx.println(stmt, `;`);\n return null;\n }\n visitWrappedNodeExpr(ast, ctx) {\n throw new Error('Cannot visit a WrappedNodeExpr when outputting Typescript.');\n }\n visitCastExpr(ast, ctx) {\n ctx.print(ast, `(<`);\n ast.type.visitType(this, ctx);\n ctx.print(ast, `>`);\n ast.value.visitExpression(this, ctx);\n ctx.print(ast, `)`);\n return null;\n }\n visitInstantiateExpr(ast, ctx) {\n ctx.print(ast, `new `);\n this.typeExpression++;\n ast.classExpr.visitExpression(this, ctx);\n this.typeExpression--;\n ctx.print(ast, `(`);\n this.visitAllExpressions(ast.args, ctx, ',');\n ctx.print(ast, `)`);\n return null;\n }\n visitDeclareClassStmt(stmt, ctx) {\n ctx.pushClass(stmt);\n if (stmt.hasModifier(StmtModifier.Exported)) {\n ctx.print(stmt, `export `);\n }\n ctx.print(stmt, `class ${stmt.name}`);\n if (stmt.parent != null) {\n ctx.print(stmt, ` extends `);\n this.typeExpression++;\n stmt.parent.visitExpression(this, ctx);\n this.typeExpression--;\n }\n ctx.println(stmt, ` {`);\n ctx.incIndent();\n stmt.fields.forEach((field) => this._visitClassField(field, ctx));\n if (stmt.constructorMethod != null) {\n this._visitClassConstructor(stmt, ctx);\n }\n stmt.getters.forEach((getter) => this._visitClassGetter(getter, ctx));\n stmt.methods.forEach((method) => this._visitClassMethod(method, ctx));\n ctx.decIndent();\n ctx.println(stmt, `}`);\n ctx.popClass();\n return null;\n }\n _visitClassField(field, ctx) {\n if (field.hasModifier(StmtModifier.Private)) {\n // comment out as a workaround for #10967\n ctx.print(null, `/*private*/ `);\n }\n if (field.hasModifier(StmtModifier.Static)) {\n ctx.print(null, 'static ');\n }\n ctx.print(null, field.name);\n this._printColonType(field.type, ctx);\n if (field.initializer) {\n ctx.print(null, ' = ');\n field.initializer.visitExpression(this, ctx);\n }\n ctx.println(null, `;`);\n }\n _visitClassGetter(getter, ctx) {\n if (getter.hasModifier(StmtModifier.Private)) {\n ctx.print(null, `private `);\n }\n ctx.print(null, `get ${getter.name}()`);\n this._printColonType(getter.type, ctx);\n ctx.println(null, ` {`);\n ctx.incIndent();\n this.visitAllStatements(getter.body, ctx);\n ctx.decIndent();\n ctx.println(null, `}`);\n }\n _visitClassConstructor(stmt, ctx) {\n ctx.print(stmt, `constructor(`);\n this._visitParams(stmt.constructorMethod.params, ctx);\n ctx.println(stmt, `) {`);\n ctx.incIndent();\n this.visitAllStatements(stmt.constructorMethod.body, ctx);\n ctx.decIndent();\n ctx.println(stmt, `}`);\n }\n _visitClassMethod(method, ctx) {\n if (method.hasModifier(StmtModifier.Private)) {\n ctx.print(null, `private `);\n }\n ctx.print(null, `${method.name}(`);\n this._visitParams(method.params, ctx);\n ctx.print(null, `)`);\n this._printColonType(method.type, ctx, 'void');\n ctx.println(null, ` {`);\n ctx.incIndent();\n this.visitAllStatements(method.body, ctx);\n ctx.decIndent();\n ctx.println(null, `}`);\n }\n visitFunctionExpr(ast, ctx) {\n if (ast.name) {\n ctx.print(ast, 'function ');\n ctx.print(ast, ast.name);\n }\n ctx.print(ast, `(`);\n this._visitParams(ast.params, ctx);\n ctx.print(ast, `)`);\n this._printColonType(ast.type, ctx, 'void');\n if (!ast.name) {\n ctx.print(ast, ` => `);\n }\n ctx.println(ast, '{');\n ctx.incIndent();\n this.visitAllStatements(ast.statements, ctx);\n ctx.decIndent();\n ctx.print(ast, `}`);\n return null;\n }\n visitDeclareFunctionStmt(stmt, ctx) {\n if (stmt.hasModifier(StmtModifier.Exported)) {\n ctx.print(stmt, `export `);\n }\n ctx.print(stmt, `function ${stmt.name}(`);\n this._visitParams(stmt.params, ctx);\n ctx.print(stmt, `)`);\n this._printColonType(stmt.type, ctx, 'void');\n ctx.println(stmt, ` {`);\n ctx.incIndent();\n this.visitAllStatements(stmt.statements, ctx);\n ctx.decIndent();\n ctx.println(stmt, `}`);\n return null;\n }\n visitTryCatchStmt(stmt, ctx) {\n ctx.println(stmt, `try {`);\n ctx.incIndent();\n this.visitAllStatements(stmt.bodyStmts, ctx);\n ctx.decIndent();\n ctx.println(stmt, `} catch (${CATCH_ERROR_VAR$1.name}) {`);\n ctx.incIndent();\n const catchStmts = [CATCH_STACK_VAR$1.set(CATCH_ERROR_VAR$1.prop('stack', null)).toDeclStmt(null, [\n StmtModifier.Final\n ])].concat(stmt.catchStmts);\n this.visitAllStatements(catchStmts, ctx);\n ctx.decIndent();\n ctx.println(stmt, `}`);\n return null;\n }\n visitBuiltinType(type, ctx) {\n let typeStr;\n switch (type.name) {\n case BuiltinTypeName.Bool:\n typeStr = 'boolean';\n break;\n case BuiltinTypeName.Dynamic:\n typeStr = 'any';\n break;\n case BuiltinTypeName.Function:\n typeStr = 'Function';\n break;\n case BuiltinTypeName.Number:\n typeStr = 'number';\n break;\n case BuiltinTypeName.Int:\n typeStr = 'number';\n break;\n case BuiltinTypeName.String:\n typeStr = 'string';\n break;\n case BuiltinTypeName.None:\n typeStr = 'never';\n break;\n default:\n throw new Error(`Unsupported builtin type ${type.name}`);\n }\n ctx.print(null, typeStr);\n return null;\n }\n visitExpressionType(ast, ctx) {\n ast.value.visitExpression(this, ctx);\n if (ast.typeParams !== null) {\n ctx.print(null, '<');\n this.visitAllObjects(type => this.visitType(type, ctx), ast.typeParams, ctx, ',');\n ctx.print(null, '>');\n }\n return null;\n }\n visitArrayType(type, ctx) {\n this.visitType(type.of, ctx);\n ctx.print(null, `[]`);\n return null;\n }\n visitMapType(type, ctx) {\n ctx.print(null, `{[key: string]:`);\n this.visitType(type.valueType, ctx);\n ctx.print(null, `}`);\n return null;\n }\n getBuiltinMethodName(method) {\n let name;\n switch (method) {\n case BuiltinMethod.ConcatArray:\n name = 'concat';\n break;\n case BuiltinMethod.SubscribeObservable:\n name = 'subscribe';\n break;\n case BuiltinMethod.Bind:\n name = 'bind';\n break;\n default:\n throw new Error(`Unknown builtin method: ${method}`);\n }\n return name;\n }\n _visitParams(params, ctx) {\n this.visitAllObjects(param => {\n ctx.print(null, param.name);\n this._printColonType(param.type, ctx);\n }, params, ctx, ',');\n }\n _visitIdentifier(value, typeParams, ctx) {\n const { name, moduleName } = value;\n if (this.referenceFilter && this.referenceFilter(value)) {\n ctx.print(null, '(null as any)');\n return;\n }\n if (moduleName && (!this.importFilter || !this.importFilter(value))) {\n let prefix = this.importsWithPrefixes.get(moduleName);\n if (prefix == null) {\n prefix = `i${this.importsWithPrefixes.size}`;\n this.importsWithPrefixes.set(moduleName, prefix);\n }\n ctx.print(null, `${prefix}.`);\n }\n ctx.print(null, name);\n if (this.typeExpression > 0) {\n // If we are in a type expression that refers to a generic type then supply\n // the required type parameters. If there were not enough type parameters\n // supplied, supply any as the type. Outside a type expression the reference\n // should not supply type parameters and be treated as a simple value reference\n // to the constructor function itself.\n const suppliedParameters = typeParams || [];\n if (suppliedParameters.length > 0) {\n ctx.print(null, `<`);\n this.visitAllObjects(type => type.visitType(this, ctx), typeParams, ctx, ',');\n ctx.print(null, `>`);\n }\n }\n }\n _printColonType(type, ctx, defaultType) {\n if (type !== INFERRED_TYPE) {\n ctx.print(null, ':');\n this.visitType(type, ctx, defaultType);\n }\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Resolve a `Type` for {@link Pipe}.\n *\n * This interface can be overridden by the application developer to create custom behavior.\n *\n * See {@link Compiler}\n */\nclass PipeResolver {\n constructor(_reflector) {\n this._reflector = _reflector;\n }\n isPipe(type) {\n const typeMetadata = this._reflector.annotations(resolveForwardRef(type));\n return typeMetadata && typeMetadata.some(createPipe.isTypeOf);\n }\n /**\n * Return {@link Pipe} for a given `Type`.\n */\n resolve(type, throwIfNotFound = true) {\n const metas = this._reflector.annotations(resolveForwardRef(type));\n if (metas) {\n const annotation = findLast(metas, createPipe.isTypeOf);\n if (annotation) {\n return annotation;\n }\n }\n if (throwIfNotFound) {\n throw new Error(`No Pipe decorator found on ${stringify(type)}`);\n }\n return null;\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// =================================================================================================\n// =================================================================================================\n// =========== S T O P - S T O P - S T O P - S T O P - S T O P - S T O P ===========\n// =================================================================================================\n// =================================================================================================\n//\n// DO NOT EDIT THIS LIST OF SECURITY SENSITIVE PROPERTIES WITHOUT A SECURITY REVIEW!\n// Reach out to mprobst for details.\n//\n// =================================================================================================\n/** Map from tagName|propertyName SecurityContext. Properties applying to all tags use '*'. */\nlet _SECURITY_SCHEMA;\nfunction SECURITY_SCHEMA() {\n if (!_SECURITY_SCHEMA) {\n _SECURITY_SCHEMA = {};\n // Case is insignificant below, all element and attribute names are lower-cased for lookup.\n registerContext(SecurityContext.HTML, [\n 'iframe|srcdoc',\n '*|innerHTML',\n '*|outerHTML',\n ]);\n registerContext(SecurityContext.STYLE, ['*|style']);\n // NB: no SCRIPT contexts here, they are never allowed due to the parser stripping them.\n registerContext(SecurityContext.URL, [\n '*|formAction', 'area|href', 'area|ping', 'audio|src', 'a|href',\n 'a|ping', 'blockquote|cite', 'body|background', 'del|cite', 'form|action',\n 'img|src', 'img|srcset', 'input|src', 'ins|cite', 'q|cite',\n 'source|src', 'source|srcset', 'track|src', 'video|poster', 'video|src',\n ]);\n registerContext(SecurityContext.RESOURCE_URL, [\n 'applet|code',\n 'applet|codebase',\n 'base|href',\n 'embed|src',\n 'frame|src',\n 'head|profile',\n 'html|manifest',\n 'iframe|src',\n 'link|href',\n 'media|src',\n 'object|codebase',\n 'object|data',\n 'script|src',\n ]);\n }\n return _SECURITY_SCHEMA;\n}\nfunction registerContext(ctx, specs) {\n for (const spec of specs)\n _SECURITY_SCHEMA[spec.toLowerCase()] = ctx;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nclass ElementSchemaRegistry {\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nconst BOOLEAN = 'boolean';\nconst NUMBER = 'number';\nconst STRING = 'string';\nconst OBJECT = 'object';\n/**\n * This array represents the DOM schema. It encodes inheritance, properties, and events.\n *\n * ## Overview\n *\n * Each line represents one kind of element. The `element_inheritance` and properties are joined\n * using `element_inheritance|properties` syntax.\n *\n * ## Element Inheritance\n *\n * The `element_inheritance` can be further subdivided as `element1,element2,...^parentElement`.\n * Here the individual elements are separated by `,` (commas). Every element in the list\n * has identical properties.\n *\n * An `element` may inherit additional properties from `parentElement` If no `^parentElement` is\n * specified then `\"\"` (blank) element is assumed.\n *\n * NOTE: The blank element inherits from root `[Element]` element, the super element of all\n * elements.\n *\n * NOTE an element prefix such as `:svg:` has no special meaning to the schema.\n *\n * ## Properties\n *\n * Each element has a set of properties separated by `,` (commas). Each property can be prefixed\n * by a special character designating its type:\n *\n * - (no prefix): property is a string.\n * - `*`: property represents an event.\n * - `!`: property is a boolean.\n * - `#`: property is a number.\n * - `%`: property is an object.\n *\n * ## Query\n *\n * The class creates an internal squas representation which allows to easily answer the query of\n * if a given property exist on a given element.\n *\n * NOTE: We don't yet support querying for types or events.\n * NOTE: This schema is auto extracted from `schema_extractor.ts` located in the test folder,\n * see dom_element_schema_registry_spec.ts\n */\n// =================================================================================================\n// =================================================================================================\n// =========== S T O P - S T O P - S T O P - S T O P - S T O P - S T O P ===========\n// =================================================================================================\n// =================================================================================================\n//\n// DO NOT EDIT THIS DOM SCHEMA WITHOUT A SECURITY REVIEW!\n//\n// Newly added properties must be security reviewed and assigned an appropriate SecurityContext in\n// dom_security_schema.ts. Reach out to mprobst & rjamet for details.\n//\n// =================================================================================================\nconst SCHEMA = [\n '[Element]|textContent,%classList,className,id,innerHTML,*beforecopy,*beforecut,*beforepaste,*copy,*cut,*paste,*search,*selectstart,*webkitfullscreenchange,*webkitfullscreenerror,*wheel,outerHTML,#scrollLeft,#scrollTop,slot' +\n /* added manually to avoid breaking changes */\n ',*message,*mozfullscreenchange,*mozfullscreenerror,*mozpointerlockchange,*mozpointerlockerror,*webglcontextcreationerror,*webglcontextlost,*webglcontextrestored',\n '[HTMLElement]^[Element]|accessKey,contentEditable,dir,!draggable,!hidden,innerText,lang,*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,outerText,!spellcheck,%style,#tabIndex,title,!translate',\n 'abbr,address,article,aside,b,bdi,bdo,cite,code,dd,dfn,dt,em,figcaption,figure,footer,header,i,kbd,main,mark,nav,noscript,rb,rp,rt,rtc,ruby,s,samp,section,small,strong,sub,sup,u,var,wbr^[HTMLElement]|accessKey,contentEditable,dir,!draggable,!hidden,innerText,lang,*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,outerText,!spellcheck,%style,#tabIndex,title,!translate',\n 'media^[HTMLElement]|!autoplay,!controls,%controlsList,%crossOrigin,#currentTime,!defaultMuted,#defaultPlaybackRate,!disableRemotePlayback,!loop,!muted,*encrypted,*waitingforkey,#playbackRate,preload,src,%srcObject,#volume',\n ':svg:^[HTMLElement]|*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,%style,#tabIndex',\n ':svg:graphics^:svg:|',\n ':svg:animation^:svg:|*begin,*end,*repeat',\n ':svg:geometry^:svg:|',\n ':svg:componentTransferFunction^:svg:|',\n ':svg:gradient^:svg:|',\n ':svg:textContent^:svg:graphics|',\n ':svg:textPositioning^:svg:textContent|',\n 'a^[HTMLElement]|charset,coords,download,hash,host,hostname,href,hreflang,name,password,pathname,ping,port,protocol,referrerPolicy,rel,rev,search,shape,target,text,type,username',\n 'area^[HTMLElement]|alt,coords,download,hash,host,hostname,href,!noHref,password,pathname,ping,port,protocol,referrerPolicy,rel,search,shape,target,username',\n 'audio^media|',\n 'br^[HTMLElement]|clear',\n 'base^[HTMLElement]|href,target',\n 'body^[HTMLElement]|aLink,background,bgColor,link,*beforeunload,*blur,*error,*focus,*hashchange,*languagechange,*load,*message,*offline,*online,*pagehide,*pageshow,*popstate,*rejectionhandled,*resize,*scroll,*storage,*unhandledrejection,*unload,text,vLink',\n 'button^[HTMLElement]|!autofocus,!disabled,formAction,formEnctype,formMethod,!formNoValidate,formTarget,name,type,value',\n 'canvas^[HTMLElement]|#height,#width',\n 'content^[HTMLElement]|select',\n 'dl^[HTMLElement]|!compact',\n 'datalist^[HTMLElement]|',\n 'details^[HTMLElement]|!open',\n 'dialog^[HTMLElement]|!open,returnValue',\n 'dir^[HTMLElement]|!compact',\n 'div^[HTMLElement]|align',\n 'embed^[HTMLElement]|align,height,name,src,type,width',\n 'fieldset^[HTMLElement]|!disabled,name',\n 'font^[HTMLElement]|color,face,size',\n 'form^[HTMLElement]|acceptCharset,action,autocomplete,encoding,enctype,method,name,!noValidate,target',\n 'frame^[HTMLElement]|frameBorder,longDesc,marginHeight,marginWidth,name,!noResize,scrolling,src',\n 'frameset^[HTMLElement]|cols,*beforeunload,*blur,*error,*focus,*hashchange,*languagechange,*load,*message,*offline,*online,*pagehide,*pageshow,*popstate,*rejectionhandled,*resize,*scroll,*storage,*unhandledrejection,*unload,rows',\n 'hr^[HTMLElement]|align,color,!noShade,size,width',\n 'head^[HTMLElement]|',\n 'h1,h2,h3,h4,h5,h6^[HTMLElement]|align',\n 'html^[HTMLElement]|version',\n 'iframe^[HTMLElement]|align,!allowFullscreen,frameBorder,height,longDesc,marginHeight,marginWidth,name,referrerPolicy,%sandbox,scrolling,src,srcdoc,width',\n 'img^[HTMLElement]|align,alt,border,%crossOrigin,#height,#hspace,!isMap,longDesc,lowsrc,name,referrerPolicy,sizes,src,srcset,useMap,#vspace,#width',\n 'input^[HTMLElement]|accept,align,alt,autocapitalize,autocomplete,!autofocus,!checked,!defaultChecked,defaultValue,dirName,!disabled,%files,formAction,formEnctype,formMethod,!formNoValidate,formTarget,#height,!incremental,!indeterminate,max,#maxLength,min,#minLength,!multiple,name,pattern,placeholder,!readOnly,!required,selectionDirection,#selectionEnd,#selectionStart,#size,src,step,type,useMap,value,%valueAsDate,#valueAsNumber,#width',\n 'li^[HTMLElement]|type,#value',\n 'label^[HTMLElement]|htmlFor',\n 'legend^[HTMLElement]|align',\n 'link^[HTMLElement]|as,charset,%crossOrigin,!disabled,href,hreflang,integrity,media,referrerPolicy,rel,%relList,rev,%sizes,target,type',\n 'map^[HTMLElement]|name',\n 'marquee^[HTMLElement]|behavior,bgColor,direction,height,#hspace,#loop,#scrollAmount,#scrollDelay,!trueSpeed,#vspace,width',\n 'menu^[HTMLElement]|!compact',\n 'meta^[HTMLElement]|content,httpEquiv,name,scheme',\n 'meter^[HTMLElement]|#high,#low,#max,#min,#optimum,#value',\n 'ins,del^[HTMLElement]|cite,dateTime',\n 'ol^[HTMLElement]|!compact,!reversed,#start,type',\n 'object^[HTMLElement]|align,archive,border,code,codeBase,codeType,data,!declare,height,#hspace,name,standby,type,useMap,#vspace,width',\n 'optgroup^[HTMLElement]|!disabled,label',\n 'option^[HTMLElement]|!defaultSelected,!disabled,label,!selected,text,value',\n 'output^[HTMLElement]|defaultValue,%htmlFor,name,value',\n 'p^[HTMLElement]|align',\n 'param^[HTMLElement]|name,type,value,valueType',\n 'picture^[HTMLElement]|',\n 'pre^[HTMLElement]|#width',\n 'progress^[HTMLElement]|#max,#value',\n 'q,blockquote,cite^[HTMLElement]|',\n 'script^[HTMLElement]|!async,charset,%crossOrigin,!defer,event,htmlFor,integrity,src,text,type',\n 'select^[HTMLElement]|!autofocus,!disabled,#length,!multiple,name,!required,#selectedIndex,#size,value',\n 'shadow^[HTMLElement]|',\n 'slot^[HTMLElement]|name',\n 'source^[HTMLElement]|media,sizes,src,srcset,type',\n 'span^[HTMLElement]|',\n 'style^[HTMLElement]|!disabled,media,type',\n 'caption^[HTMLElement]|align',\n 'th,td^[HTMLElement]|abbr,align,axis,bgColor,ch,chOff,#colSpan,headers,height,!noWrap,#rowSpan,scope,vAlign,width',\n 'col,colgroup^[HTMLElement]|align,ch,chOff,#span,vAlign,width',\n 'table^[HTMLElement]|align,bgColor,border,%caption,cellPadding,cellSpacing,frame,rules,summary,%tFoot,%tHead,width',\n 'tr^[HTMLElement]|align,bgColor,ch,chOff,vAlign',\n 'tfoot,thead,tbody^[HTMLElement]|align,ch,chOff,vAlign',\n 'template^[HTMLElement]|',\n 'textarea^[HTMLElement]|autocapitalize,!autofocus,#cols,defaultValue,dirName,!disabled,#maxLength,#minLength,name,placeholder,!readOnly,!required,#rows,selectionDirection,#selectionEnd,#selectionStart,value,wrap',\n 'title^[HTMLElement]|text',\n 'track^[HTMLElement]|!default,kind,label,src,srclang',\n 'ul^[HTMLElement]|!compact,type',\n 'unknown^[HTMLElement]|',\n 'video^media|#height,poster,#width',\n ':svg:a^:svg:graphics|',\n ':svg:animate^:svg:animation|',\n ':svg:animateMotion^:svg:animation|',\n ':svg:animateTransform^:svg:animation|',\n ':svg:circle^:svg:geometry|',\n ':svg:clipPath^:svg:graphics|',\n ':svg:defs^:svg:graphics|',\n ':svg:desc^:svg:|',\n ':svg:discard^:svg:|',\n ':svg:ellipse^:svg:geometry|',\n ':svg:feBlend^:svg:|',\n ':svg:feColorMatrix^:svg:|',\n ':svg:feComponentTransfer^:svg:|',\n ':svg:feComposite^:svg:|',\n ':svg:feConvolveMatrix^:svg:|',\n ':svg:feDiffuseLighting^:svg:|',\n ':svg:feDisplacementMap^:svg:|',\n ':svg:feDistantLight^:svg:|',\n ':svg:feDropShadow^:svg:|',\n ':svg:feFlood^:svg:|',\n ':svg:feFuncA^:svg:componentTransferFunction|',\n ':svg:feFuncB^:svg:componentTransferFunction|',\n ':svg:feFuncG^:svg:componentTransferFunction|',\n ':svg:feFuncR^:svg:componentTransferFunction|',\n ':svg:feGaussianBlur^:svg:|',\n ':svg:feImage^:svg:|',\n ':svg:feMerge^:svg:|',\n ':svg:feMergeNode^:svg:|',\n ':svg:feMorphology^:svg:|',\n ':svg:feOffset^:svg:|',\n ':svg:fePointLight^:svg:|',\n ':svg:feSpecularLighting^:svg:|',\n ':svg:feSpotLight^:svg:|',\n ':svg:feTile^:svg:|',\n ':svg:feTurbulence^:svg:|',\n ':svg:filter^:svg:|',\n ':svg:foreignObject^:svg:graphics|',\n ':svg:g^:svg:graphics|',\n ':svg:image^:svg:graphics|',\n ':svg:line^:svg:geometry|',\n ':svg:linearGradient^:svg:gradient|',\n ':svg:mpath^:svg:|',\n ':svg:marker^:svg:|',\n ':svg:mask^:svg:|',\n ':svg:metadata^:svg:|',\n ':svg:path^:svg:geometry|',\n ':svg:pattern^:svg:|',\n ':svg:polygon^:svg:geometry|',\n ':svg:polyline^:svg:geometry|',\n ':svg:radialGradient^:svg:gradient|',\n ':svg:rect^:svg:geometry|',\n ':svg:svg^:svg:graphics|#currentScale,#zoomAndPan',\n ':svg:script^:svg:|type',\n ':svg:set^:svg:animation|',\n ':svg:stop^:svg:|',\n ':svg:style^:svg:|!disabled,media,title,type',\n ':svg:switch^:svg:graphics|',\n ':svg:symbol^:svg:|',\n ':svg:tspan^:svg:textPositioning|',\n ':svg:text^:svg:textPositioning|',\n ':svg:textPath^:svg:textContent|',\n ':svg:title^:svg:|',\n ':svg:use^:svg:graphics|',\n ':svg:view^:svg:|#zoomAndPan',\n 'data^[HTMLElement]|value',\n 'keygen^[HTMLElement]|!autofocus,challenge,!disabled,form,keytype,name',\n 'menuitem^[HTMLElement]|type,label,icon,!disabled,!checked,radiogroup,!default',\n 'summary^[HTMLElement]|',\n 'time^[HTMLElement]|dateTime',\n ':svg:cursor^:svg:|',\n];\nconst _ATTR_TO_PROP = {\n 'class': 'className',\n 'for': 'htmlFor',\n 'formaction': 'formAction',\n 'innerHtml': 'innerHTML',\n 'readonly': 'readOnly',\n 'tabindex': 'tabIndex',\n};\nclass DomElementSchemaRegistry extends ElementSchemaRegistry {\n constructor() {\n super();\n this._schema = {};\n SCHEMA.forEach(encodedType => {\n const type = {};\n const [strType, strProperties] = encodedType.split('|');\n const properties = strProperties.split(',');\n const [typeNames, superName] = strType.split('^');\n typeNames.split(',').forEach(tag => this._schema[tag.toLowerCase()] = type);\n const superType = superName && this._schema[superName.toLowerCase()];\n if (superType) {\n Object.keys(superType).forEach((prop) => { type[prop] = superType[prop]; });\n }\n properties.forEach((property) => {\n if (property.length > 0) {\n switch (property[0]) {\n case '*':\n // We don't yet support events.\n // If ever allowing to bind to events, GO THROUGH A SECURITY REVIEW, allowing events\n // will\n // almost certainly introduce bad XSS vulnerabilities.\n // type[property.substring(1)] = EVENT;\n break;\n case '!':\n type[property.substring(1)] = BOOLEAN;\n break;\n case '#':\n type[property.substring(1)] = NUMBER;\n break;\n case '%':\n type[property.substring(1)] = OBJECT;\n break;\n default:\n type[property] = STRING;\n }\n }\n });\n });\n }\n hasProperty(tagName, propName, schemaMetas) {\n if (schemaMetas.some((schema) => schema.name === NO_ERRORS_SCHEMA.name)) {\n return true;\n }\n if (tagName.indexOf('-') > -1) {\n if (isNgContainer(tagName) || isNgContent(tagName)) {\n return false;\n }\n if (schemaMetas.some((schema) => schema.name === CUSTOM_ELEMENTS_SCHEMA.name)) {\n // Can't tell now as we don't know which properties a custom element will get\n // once it is instantiated\n return true;\n }\n }\n const elementProperties = this._schema[tagName.toLowerCase()] || this._schema['unknown'];\n return !!elementProperties[propName];\n }\n hasElement(tagName, schemaMetas) {\n if (schemaMetas.some((schema) => schema.name === NO_ERRORS_SCHEMA.name)) {\n return true;\n }\n if (tagName.indexOf('-') > -1) {\n if (isNgContainer(tagName) || isNgContent(tagName)) {\n return true;\n }\n if (schemaMetas.some((schema) => schema.name === CUSTOM_ELEMENTS_SCHEMA.name)) {\n // Allow any custom elements\n return true;\n }\n }\n return !!this._schema[tagName.toLowerCase()];\n }\n /**\n * securityContext returns the security context for the given property on the given DOM tag.\n *\n * Tag and property name are statically known and cannot change at runtime, i.e. it is not\n * possible to bind a value into a changing attribute or tag name.\n *\n * The filtering is white list based. All attributes in the schema above are assumed to have the\n * 'NONE' security context, i.e. that they are safe inert string values. Only specific well known\n * attack vectors are assigned their appropriate context.\n */\n securityContext(tagName, propName, isAttribute) {\n if (isAttribute) {\n // NB: For security purposes, use the mapped property name, not the attribute name.\n propName = this.getMappedPropName(propName);\n }\n // Make sure comparisons are case insensitive, so that case differences between attribute and\n // property names do not have a security impact.\n tagName = tagName.toLowerCase();\n propName = propName.toLowerCase();\n let ctx = SECURITY_SCHEMA()[tagName + '|' + propName];\n if (ctx) {\n return ctx;\n }\n ctx = SECURITY_SCHEMA()['*|' + propName];\n return ctx ? ctx : SecurityContext.NONE;\n }\n getMappedPropName(propName) { return _ATTR_TO_PROP[propName] || propName; }\n getDefaultComponentElementName() { return 'ng-component'; }\n validateProperty(name) {\n if (name.toLowerCase().startsWith('on')) {\n const msg = `Binding to event property '${name}' is disallowed for security reasons, ` +\n `please use (${name.slice(2)})=...` +\n `\\nIf '${name}' is a directive input, make sure the directive is imported by the` +\n ` current module.`;\n return { error: true, msg: msg };\n }\n else {\n return { error: false };\n }\n }\n validateAttribute(name) {\n if (name.toLowerCase().startsWith('on')) {\n const msg = `Binding to event attribute '${name}' is disallowed for security reasons, ` +\n `please use (${name.slice(2)})=...`;\n return { error: true, msg: msg };\n }\n else {\n return { error: false };\n }\n }\n allKnownElementNames() { return Object.keys(this._schema); }\n normalizeAnimationStyleProperty(propName) {\n return dashCaseToCamelCase(propName);\n }\n normalizeAnimationStyleValue(camelCaseProp, userProvidedProp, val) {\n let unit = '';\n const strVal = val.toString().trim();\n let errorMsg = null;\n if (_isPixelDimensionStyle(camelCaseProp) && val !== 0 && val !== '0') {\n if (typeof val === 'number') {\n unit = 'px';\n }\n else {\n const valAndSuffixMatch = val.match(/^[+-]?[\\d\\.]+([a-z]*)$/);\n if (valAndSuffixMatch && valAndSuffixMatch[1].length == 0) {\n errorMsg = `Please provide a CSS unit value for ${userProvidedProp}:${val}`;\n }\n }\n }\n return { error: errorMsg, value: strVal + unit };\n }\n}\nfunction _isPixelDimensionStyle(prop) {\n switch (prop) {\n case 'width':\n case 'height':\n case 'minWidth':\n case 'minHeight':\n case 'maxWidth':\n case 'maxHeight':\n case 'left':\n case 'top':\n case 'bottom':\n case 'right':\n case 'fontSize':\n case 'outlineWidth':\n case 'outlineOffset':\n case 'paddingTop':\n case 'paddingLeft':\n case 'paddingBottom':\n case 'paddingRight':\n case 'marginTop':\n case 'marginLeft':\n case 'marginBottom':\n case 'marginRight':\n case 'borderRadius':\n case 'borderWidth':\n case 'borderTopWidth':\n case 'borderLeftWidth':\n case 'borderRightWidth':\n case 'borderBottomWidth':\n case 'textIndent':\n return true;\n default:\n return false;\n }\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * This file is a port of shadowCSS from webcomponents.js to TypeScript.\n *\n * Please make sure to keep to edits in sync with the source file.\n *\n * Source:\n * https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js\n *\n * The original file level comment is reproduced below\n */\n/*\n This is a limited shim for ShadowDOM css styling.\n https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#styles\n\n The intention here is to support only the styling features which can be\n relatively simply implemented. The goal is to allow users to avoid the\n most obvious pitfalls and do so without compromising performance significantly.\n For ShadowDOM styling that's not covered here, a set of best practices\n can be provided that should allow users to accomplish more complex styling.\n\n The following is a list of specific ShadowDOM styling features and a brief\n discussion of the approach used to shim.\n\n Shimmed features:\n\n * :host, :host-context: ShadowDOM allows styling of the shadowRoot's host\n element using the :host rule. To shim this feature, the :host styles are\n reformatted and prefixed with a given scope name and promoted to a\n document level stylesheet.\n For example, given a scope name of .foo, a rule like this:\n\n :host {\n background: red;\n }\n }\n\n becomes:\n\n .foo {\n background: red;\n }\n\n * encapsulation: Styles defined within ShadowDOM, apply only to\n dom inside the ShadowDOM. Polymer uses one of two techniques to implement\n this feature.\n\n By default, rules are prefixed with the host element tag name\n as a descendant selector. This ensures styling does not leak out of the 'top'\n of the element's ShadowDOM. For example,\n\n div {\n font-weight: bold;\n }\n\n becomes:\n\n x-foo div {\n font-weight: bold;\n }\n\n becomes:\n\n\n Alternatively, if WebComponents.ShadowCSS.strictStyling is set to true then\n selectors are scoped by adding an attribute selector suffix to each\n simple selector that contains the host element tag name. Each element\n in the element's ShadowDOM template is also given the scope attribute.\n Thus, these rules match only elements that have the scope attribute.\n For example, given a scope name of x-foo, a rule like this:\n\n div {\n font-weight: bold;\n }\n\n becomes:\n\n div[x-foo] {\n font-weight: bold;\n }\n\n Note that elements that are dynamically added to a scope must have the scope\n selector added to them manually.\n\n * upper/lower bound encapsulation: Styles which are defined outside a\n shadowRoot should not cross the ShadowDOM boundary and should not apply\n inside a shadowRoot.\n\n This styling behavior is not emulated. Some possible ways to do this that\n were rejected due to complexity and/or performance concerns include: (1) reset\n every possible property for every possible selector for a given scope name;\n (2) re-implement css in javascript.\n\n As an alternative, users should make sure to use selectors\n specific to the scope in which they are working.\n\n * ::distributed: This behavior is not emulated. It's often not necessary\n to style the contents of a specific insertion point and instead, descendants\n of the host element can be styled selectively. Users can also create an\n extra node around an insertion point and style that node's contents\n via descendent selectors. For example, with a shadowRoot like this:\n\n \n