/** * @license Angular v12.2.17 * (c) 2010-2021 Google LLC. https://angular.io/ * License: MIT */ (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define('@angular/compiler', ['exports'], factory) : (global = global || self, factory((global.ng = global.ng || {}, global.ng.compiler = {}))); }(this, (function (exports) { 'use strict'; /*! ***************************************************************************** Copyright (c) Microsoft Corporation. Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ***************************************************************************** */ /* global Reflect, Promise */ var extendStatics = function (d, b) { extendStatics = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; return extendStatics(d, b); }; function __extends(d, b) { if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); extendStatics(d, b); function __() { this.constructor = d; } d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); } var __assign = function () { __assign = Object.assign || function __assign(t) { for (var s, i = 1, n = arguments.length; i < n; i++) { s = arguments[i]; for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; } return t; }; return __assign.apply(this, arguments); }; function __rest(s, e) { var t = {}; for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p]; if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]]; } return t; } function __decorate(decorators, target, key, desc) { var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; return c > 3 && r && Object.defineProperty(target, key, r), r; } function __param(paramIndex, decorator) { return function (target, key) { decorator(target, key, paramIndex); }; } function __metadata(metadataKey, metadataValue) { if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue); } function __awaiter(thisArg, _arguments, P, generator) { function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } return new (P || (P = Promise))(function (resolve, reject) { function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } step((generator = generator.apply(thisArg, _arguments || [])).next()); }); } function __generator(thisArg, body) { var _ = { label: 0, sent: function () { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g; function verb(n) { return function (v) { return step([n, v]); }; } function step(op) { if (f) throw new TypeError("Generator is already executing."); while (_) try { if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; if (y = 0, t) op = [op[0] & 2, t.value]; switch (op[0]) { case 0: case 1: t = op; break; case 4: _.label++; return { value: op[1], done: false }; case 5: _.label++; y = op[1]; op = [0]; continue; case 7: op = _.ops.pop(); _.trys.pop(); continue; default: if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } if (t[2]) _.ops.pop(); _.trys.pop(); continue; } op = body.call(thisArg, _); } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; } } var __createBinding = Object.create ? (function (o, m, k, k2) { if (k2 === undefined) k2 = k; Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } }); }) : (function (o, m, k, k2) { if (k2 === undefined) k2 = k; o[k2] = m[k]; }); function __exportStar(m, o) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p); } function __values(o) { var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; if (m) return m.call(o); if (o && typeof o.length === "number") return { next: function () { if (o && i >= o.length) o = void 0; return { value: o && o[i++], done: !o }; } }; throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); } function __read(o, n) { var m = typeof Symbol === "function" && o[Symbol.iterator]; if (!m) return o; var i = m.call(o), r, ar = [], e; try { while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); } catch (error) { e = { error: error }; } finally { try { if (r && !r.done && (m = i["return"])) m.call(i); } finally { if (e) throw e.error; } } return ar; } /** @deprecated */ function __spread() { for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i])); return ar; } /** @deprecated */ function __spreadArrays() { for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) r[k] = a[j]; return r; } function __spreadArray(to, from, pack) { if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { if (ar || !(i in from)) { if (!ar) ar = Array.prototype.slice.call(from, 0, i); ar[i] = from[i]; } } return to.concat(ar || Array.prototype.slice.call(from)); } function __await(v) { return this instanceof __await ? (this.v = v, this) : new __await(v); } function __asyncGenerator(thisArg, _arguments, generator) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var g = generator.apply(thisArg, _arguments || []), i, q = []; return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } function fulfill(value) { resume("next", value); } function reject(value) { resume("throw", value); } function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } } function __asyncDelegator(o) { var i, p; return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; } } function __asyncValues(o) { if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); var m = o[Symbol.asyncIterator], i; return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); } } function __makeTemplateObject(cooked, raw) { if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; } return cooked; } ; var __setModuleDefault = Object.create ? (function (o, v) { Object.defineProperty(o, "default", { enumerable: true, value: v }); }) : function (o, v) { o["default"] = v; }; function __importStar(mod) { if (mod && mod.__esModule) return mod; var result = {}; if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); __setModuleDefault(result, mod); return result; } function __importDefault(mod) { return (mod && mod.__esModule) ? mod : { default: mod }; } function __classPrivateFieldGet(receiver, state, kind, f) { if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); } function __classPrivateFieldSet(receiver, state, value, kind, f) { if (kind === "m") throw new TypeError("Private method is not writable"); if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ (function (TagContentType) { TagContentType[TagContentType["RAW_TEXT"] = 0] = "RAW_TEXT"; TagContentType[TagContentType["ESCAPABLE_RAW_TEXT"] = 1] = "ESCAPABLE_RAW_TEXT"; TagContentType[TagContentType["PARSABLE_DATA"] = 2] = "PARSABLE_DATA"; })(exports.TagContentType || (exports.TagContentType = {})); function splitNsName(elementName) { if (elementName[0] != ':') { return [null, elementName]; } var colonIndex = elementName.indexOf(':', 1); if (colonIndex === -1) { throw new Error("Unsupported format \"" + elementName + "\" expecting \":namespace:name\""); } return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)]; } // `` tags work the same regardless the namespace function isNgContainer(tagName) { return splitNsName(tagName)[1] === 'ng-container'; } // `` tags work the same regardless the namespace function isNgContent(tagName) { return splitNsName(tagName)[1] === 'ng-content'; } // `` tags work the same regardless the namespace function isNgTemplate(tagName) { return splitNsName(tagName)[1] === 'ng-template'; } function getNsPrefix(fullName) { return fullName === null ? null : splitNsName(fullName)[0]; } function mergeNsAndName(prefix, localName) { return prefix ? ":" + prefix + ":" + localName : localName; } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ var HtmlTagDefinition = /** @class */ (function () { function HtmlTagDefinition(_c) { var _this = this; var _d = _c === void 0 ? {} : _c, closedByChildren = _d.closedByChildren, implicitNamespacePrefix = _d.implicitNamespacePrefix, _e = _d.contentType, contentType = _e === void 0 ? exports.TagContentType.PARSABLE_DATA : _e, _f = _d.closedByParent, closedByParent = _f === void 0 ? false : _f, _g = _d.isVoid, isVoid = _g === void 0 ? false : _g, _h = _d.ignoreFirstLf, ignoreFirstLf = _h === void 0 ? false : _h, _j = _d.preventNamespaceInheritance, preventNamespaceInheritance = _j === void 0 ? false : _j; this.closedByChildren = {}; this.closedByParent = false; this.canSelfClose = false; if (closedByChildren && closedByChildren.length > 0) { closedByChildren.forEach(function (tagName) { return _this.closedByChildren[tagName] = true; }); } this.isVoid = isVoid; this.closedByParent = closedByParent || isVoid; this.implicitNamespacePrefix = implicitNamespacePrefix || null; this.contentType = contentType; this.ignoreFirstLf = ignoreFirstLf; this.preventNamespaceInheritance = preventNamespaceInheritance; } HtmlTagDefinition.prototype.isClosedByChild = function (name) { return this.isVoid || name.toLowerCase() in this.closedByChildren; }; HtmlTagDefinition.prototype.getContentType = function (prefix) { if (typeof this.contentType === 'object') { var overrideType = prefix === undefined ? undefined : this.contentType[prefix]; return overrideType !== null && overrideType !== void 0 ? overrideType : this.contentType.default; } return this.contentType; }; return HtmlTagDefinition; }()); var _DEFAULT_TAG_DEFINITION; // see https://www.w3.org/TR/html51/syntax.html#optional-tags // This implementation does not fully conform to the HTML5 spec. var TAG_DEFINITIONS; function getHtmlTagDefinition(tagName) { var _a, _b; if (!TAG_DEFINITIONS) { _DEFAULT_TAG_DEFINITION = new HtmlTagDefinition(); TAG_DEFINITIONS = { 'base': new HtmlTagDefinition({ isVoid: true }), 'meta': new HtmlTagDefinition({ isVoid: true }), 'area': new HtmlTagDefinition({ isVoid: true }), 'embed': new HtmlTagDefinition({ isVoid: true }), 'link': new HtmlTagDefinition({ isVoid: true }), 'img': new HtmlTagDefinition({ isVoid: true }), 'input': new HtmlTagDefinition({ isVoid: true }), 'param': new HtmlTagDefinition({ isVoid: true }), 'hr': new HtmlTagDefinition({ isVoid: true }), 'br': new HtmlTagDefinition({ isVoid: true }), 'source': new HtmlTagDefinition({ isVoid: true }), 'track': new HtmlTagDefinition({ isVoid: true }), 'wbr': new HtmlTagDefinition({ isVoid: true }), 'p': new HtmlTagDefinition({ closedByChildren: [ 'address', 'article', 'aside', 'blockquote', 'div', 'dl', 'fieldset', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'hr', 'main', 'nav', 'ol', 'p', 'pre', 'section', 'table', 'ul' ], closedByParent: true }), 'thead': new HtmlTagDefinition({ closedByChildren: ['tbody', 'tfoot'] }), 'tbody': new HtmlTagDefinition({ closedByChildren: ['tbody', 'tfoot'], closedByParent: true }), 'tfoot': new HtmlTagDefinition({ closedByChildren: ['tbody'], closedByParent: true }), 'tr': new HtmlTagDefinition({ closedByChildren: ['tr'], closedByParent: true }), 'td': new HtmlTagDefinition({ closedByChildren: ['td', 'th'], closedByParent: true }), 'th': new HtmlTagDefinition({ closedByChildren: ['td', 'th'], closedByParent: true }), 'col': new HtmlTagDefinition({ isVoid: true }), 'svg': new HtmlTagDefinition({ implicitNamespacePrefix: 'svg' }), 'foreignObject': new HtmlTagDefinition({ // Usually the implicit namespace here would be redundant since it will be inherited from // the parent `svg`, but we have to do it for `foreignObject`, because the way the parser // works is that the parent node of an end tag is its own start tag which means that // the `preventNamespaceInheritance` on `foreignObject` would have it default to the // implicit namespace which is `html`, unless specified otherwise. implicitNamespacePrefix: 'svg', // We want to prevent children of foreignObject from inheriting its namespace, because // the point of the element is to allow nodes from other namespaces to be inserted. preventNamespaceInheritance: true, }), 'math': new HtmlTagDefinition({ implicitNamespacePrefix: 'math' }), 'li': new HtmlTagDefinition({ closedByChildren: ['li'], closedByParent: true }), 'dt': new HtmlTagDefinition({ closedByChildren: ['dt', 'dd'] }), 'dd': new HtmlTagDefinition({ closedByChildren: ['dt', 'dd'], closedByParent: true }), 'rb': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }), 'rt': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }), 'rtc': new HtmlTagDefinition({ closedByChildren: ['rb', 'rtc', 'rp'], closedByParent: true }), 'rp': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }), 'optgroup': new HtmlTagDefinition({ closedByChildren: ['optgroup'], closedByParent: true }), 'option': new HtmlTagDefinition({ closedByChildren: ['option', 'optgroup'], closedByParent: true }), 'pre': new HtmlTagDefinition({ ignoreFirstLf: true }), 'listing': new HtmlTagDefinition({ ignoreFirstLf: true }), 'style': new HtmlTagDefinition({ contentType: exports.TagContentType.RAW_TEXT }), 'script': new HtmlTagDefinition({ contentType: exports.TagContentType.RAW_TEXT }), 'title': new HtmlTagDefinition({ // The browser supports two separate `title` tags which have to use // a different content type: `HTMLTitleElement` and `SVGTitleElement` contentType: { default: exports.TagContentType.ESCAPABLE_RAW_TEXT, svg: exports.TagContentType.PARSABLE_DATA } }), 'textarea': new HtmlTagDefinition({ contentType: exports.TagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true }), }; } // We have to make both a case-sensitive and a case-insesitive lookup, because // HTML tag names are case insensitive, whereas some SVG tags are case sensitive. return (_b = (_a = TAG_DEFINITIONS[tagName]) !== null && _a !== void 0 ? _a : TAG_DEFINITIONS[tagName.toLowerCase()]) !== null && _b !== void 0 ? _b : _DEFAULT_TAG_DEFINITION; } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ var _SELECTOR_REGEXP = new RegExp('(\\:not\\()|' + // 1: ":not(" '(([\\.\\#]?)[-\\w]+)|' + // 2: "tag"; 3: "."/"#"; // "-" should appear first in the regexp below as FF31 parses "[.-\w]" as a range // 4: attribute; 5: attribute_string; 6: attribute_value '(?:\\[([-.\\w*\\\\$]+)(?:=([\"\']?)([^\\]\"\']*)\\5)?\\])|' + // "[name]", "[name=value]", // "[name="value"]", // "[name='value']" '(\\))|' + // 7: ")" '(\\s*,\\s*)', // 8: "," 'g'); /** * A css selector contains an element name, * css classes and attribute/value pairs with the purpose * of selecting subsets out of them. */ var CssSelector = /** @class */ (function () { function CssSelector() { this.element = null; this.classNames = []; /** * The selectors are encoded in pairs where: * - even locations are attribute names * - odd locations are attribute values. * * Example: * Selector: `[key1=value1][key2]` would parse to: * ``` * ['key1', 'value1', 'key2', ''] * ``` */ this.attrs = []; this.notSelectors = []; } CssSelector.parse = function (selector) { var results = []; var _addResult = function (res, cssSel) { if (cssSel.notSelectors.length > 0 && !cssSel.element && cssSel.classNames.length == 0 && cssSel.attrs.length == 0) { cssSel.element = '*'; } res.push(cssSel); }; var cssSelector = new CssSelector(); var match; var current = cssSelector; var inNot = false; _SELECTOR_REGEXP.lastIndex = 0; while (match = _SELECTOR_REGEXP.exec(selector)) { if (match[1 /* NOT */]) { if (inNot) { throw new Error('Nesting :not in a selector is not allowed'); } inNot = true; current = new CssSelector(); cssSelector.notSelectors.push(current); } var tag = match[2 /* TAG */]; if (tag) { var prefix = match[3 /* PREFIX */]; if (prefix === '#') { // #hash current.addAttribute('id', tag.substr(1)); } else if (prefix === '.') { // Class current.addClassName(tag.substr(1)); } else { // Element current.setElement(tag); } } var attribute = match[4 /* ATTRIBUTE */]; if (attribute) { current.addAttribute(current.unescapeAttribute(attribute), match[6 /* ATTRIBUTE_VALUE */]); } if (match[7 /* NOT_END */]) { inNot = false; current = cssSelector; } if (match[8 /* SEPARATOR */]) { if (inNot) { throw new Error('Multiple selectors in :not are not supported'); } _addResult(results, cssSelector); cssSelector = current = new CssSelector(); } } _addResult(results, cssSelector); return results; }; /** * Unescape `\$` sequences from the CSS attribute selector. * * This is needed because `$` can have a special meaning in CSS selectors, * but we might want to match an attribute that contains `$`. * [MDN web link for more * info](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors). * @param attr the attribute to unescape. * @returns the unescaped string. */ CssSelector.prototype.unescapeAttribute = function (attr) { var result = ''; var escaping = false; for (var i = 0; i < attr.length; i++) { var char = attr.charAt(i); if (char === '\\') { escaping = true; continue; } if (char === '$' && !escaping) { throw new Error("Error in attribute selector \"" + attr + "\". " + "Unescaped \"$\" is not supported. Please escape with \"\\$\"."); } escaping = false; result += char; } return result; }; /** * Escape `$` sequences from the CSS attribute selector. * * This is needed because `$` can have a special meaning in CSS selectors, * with this method we are escaping `$` with `\$'. * [MDN web link for more * info](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors). * @param attr the attribute to escape. * @returns the escaped string. */ CssSelector.prototype.escapeAttribute = function (attr) { return attr.replace(/\\/g, '\\\\').replace(/\$/g, '\\$'); }; CssSelector.prototype.isElementSelector = function () { return this.hasElementSelector() && this.classNames.length == 0 && this.attrs.length == 0 && this.notSelectors.length === 0; }; CssSelector.prototype.hasElementSelector = function () { return !!this.element; }; CssSelector.prototype.setElement = function (element) { if (element === void 0) { element = null; } this.element = element; }; /** Gets a template string for an element that matches the selector. */ CssSelector.prototype.getMatchingElementTemplate = function () { var tagName = this.element || 'div'; var classAttr = this.classNames.length > 0 ? " class=\"" + this.classNames.join(' ') + "\"" : ''; var attrs = ''; for (var i = 0; i < this.attrs.length; i += 2) { var attrName = this.attrs[i]; var attrValue = this.attrs[i + 1] !== '' ? "=\"" + this.attrs[i + 1] + "\"" : ''; attrs += " " + attrName + attrValue; } return getHtmlTagDefinition(tagName).isVoid ? "<" + tagName + classAttr + attrs + "/>" : "<" + tagName + classAttr + attrs + ">"; }; CssSelector.prototype.getAttrs = function () { var result = []; if (this.classNames.length > 0) { result.push('class', this.classNames.join(' ')); } return result.concat(this.attrs); }; CssSelector.prototype.addAttribute = function (name, value) { if (value === void 0) { value = ''; } this.attrs.push(name, value && value.toLowerCase() || ''); }; CssSelector.prototype.addClassName = function (name) { this.classNames.push(name.toLowerCase()); }; CssSelector.prototype.toString = function () { var res = this.element || ''; if (this.classNames) { this.classNames.forEach(function (klass) { return res += "." + klass; }); } if (this.attrs) { for (var i = 0; i < this.attrs.length; i += 2) { var name = this.escapeAttribute(this.attrs[i]); var value = this.attrs[i + 1]; res += "[" + name + (value ? '=' + value : '') + "]"; } } this.notSelectors.forEach(function (notSelector) { return res += ":not(" + notSelector + ")"; }); return res; }; return CssSelector; }()); /** * Reads a list of CssSelectors and allows to calculate which ones * are contained in a given CssSelector. */ var SelectorMatcher = /** @class */ (function () { function SelectorMatcher() { this._elementMap = new Map(); this._elementPartialMap = new Map(); this._classMap = new Map(); this._classPartialMap = new Map(); this._attrValueMap = new Map(); this._attrValuePartialMap = new Map(); this._listContexts = []; } SelectorMatcher.createNotMatcher = function (notSelectors) { var notMatcher = new SelectorMatcher(); notMatcher.addSelectables(notSelectors, null); return notMatcher; }; SelectorMatcher.prototype.addSelectables = function (cssSelectors, callbackCtxt) { var listContext = null; if (cssSelectors.length > 1) { listContext = new SelectorListContext(cssSelectors); this._listContexts.push(listContext); } for (var i = 0; i < cssSelectors.length; i++) { this._addSelectable(cssSelectors[i], callbackCtxt, listContext); } }; /** * Add an object that can be found later on by calling `match`. * @param cssSelector A css selector * @param callbackCtxt An opaque object that will be given to the callback of the `match` function */ SelectorMatcher.prototype._addSelectable = function (cssSelector, callbackCtxt, listContext) { var matcher = this; var element = cssSelector.element; var classNames = cssSelector.classNames; var attrs = cssSelector.attrs; var selectable = new SelectorContext(cssSelector, callbackCtxt, listContext); if (element) { var isTerminal = attrs.length === 0 && classNames.length === 0; if (isTerminal) { this._addTerminal(matcher._elementMap, element, selectable); } else { matcher = this._addPartial(matcher._elementPartialMap, element); } } if (classNames) { for (var i = 0; i < classNames.length; i++) { var isTerminal = attrs.length === 0 && i === classNames.length - 1; var className = classNames[i]; if (isTerminal) { this._addTerminal(matcher._classMap, className, selectable); } else { matcher = this._addPartial(matcher._classPartialMap, className); } } } if (attrs) { for (var i = 0; i < attrs.length; i += 2) { var isTerminal = i === attrs.length - 2; var name = attrs[i]; var value = attrs[i + 1]; if (isTerminal) { var terminalMap = matcher._attrValueMap; var terminalValuesMap = terminalMap.get(name); if (!terminalValuesMap) { terminalValuesMap = new Map(); terminalMap.set(name, terminalValuesMap); } this._addTerminal(terminalValuesMap, value, selectable); } else { var partialMap = matcher._attrValuePartialMap; var partialValuesMap = partialMap.get(name); if (!partialValuesMap) { partialValuesMap = new Map(); partialMap.set(name, partialValuesMap); } matcher = this._addPartial(partialValuesMap, value); } } } }; SelectorMatcher.prototype._addTerminal = function (map, name, selectable) { var terminalList = map.get(name); if (!terminalList) { terminalList = []; map.set(name, terminalList); } terminalList.push(selectable); }; SelectorMatcher.prototype._addPartial = function (map, name) { var matcher = map.get(name); if (!matcher) { matcher = new SelectorMatcher(); map.set(name, matcher); } return matcher; }; /** * Find the objects that have been added via `addSelectable` * whose css selector is contained in the given css selector. * @param cssSelector A css selector * @param matchedCallback This callback will be called with the object handed into `addSelectable` * @return boolean true if a match was found */ SelectorMatcher.prototype.match = function (cssSelector, matchedCallback) { var result = false; var element = cssSelector.element; var classNames = cssSelector.classNames; var attrs = cssSelector.attrs; for (var i = 0; i < this._listContexts.length; i++) { this._listContexts[i].alreadyMatched = false; } result = this._matchTerminal(this._elementMap, element, cssSelector, matchedCallback) || result; result = this._matchPartial(this._elementPartialMap, element, cssSelector, matchedCallback) || result; if (classNames) { for (var i = 0; i < classNames.length; i++) { var className = classNames[i]; result = this._matchTerminal(this._classMap, className, cssSelector, matchedCallback) || result; result = this._matchPartial(this._classPartialMap, className, cssSelector, matchedCallback) || result; } } if (attrs) { for (var i = 0; i < attrs.length; i += 2) { var name = attrs[i]; var value = attrs[i + 1]; var terminalValuesMap = this._attrValueMap.get(name); if (value) { result = this._matchTerminal(terminalValuesMap, '', cssSelector, matchedCallback) || result; } result = this._matchTerminal(terminalValuesMap, value, cssSelector, matchedCallback) || result; var partialValuesMap = this._attrValuePartialMap.get(name); if (value) { result = this._matchPartial(partialValuesMap, '', cssSelector, matchedCallback) || result; } result = this._matchPartial(partialValuesMap, value, cssSelector, matchedCallback) || result; } } return result; }; /** @internal */ SelectorMatcher.prototype._matchTerminal = function (map, name, cssSelector, matchedCallback) { if (!map || typeof name !== 'string') { return false; } var selectables = map.get(name) || []; var starSelectables = map.get('*'); if (starSelectables) { selectables = selectables.concat(starSelectables); } if (selectables.length === 0) { return false; } var selectable; var result = false; for (var i = 0; i < selectables.length; i++) { selectable = selectables[i]; result = selectable.finalize(cssSelector, matchedCallback) || result; } return result; }; /** @internal */ SelectorMatcher.prototype._matchPartial = function (map, name, cssSelector, matchedCallback) { if (!map || typeof name !== 'string') { return false; } var nestedSelector = map.get(name); if (!nestedSelector) { return false; } // TODO(perf): get rid of recursion and measure again // TODO(perf): don't pass the whole selector into the recursion, // but only the not processed parts return nestedSelector.match(cssSelector, matchedCallback); }; return SelectorMatcher; }()); var SelectorListContext = /** @class */ (function () { function SelectorListContext(selectors) { this.selectors = selectors; this.alreadyMatched = false; } return SelectorListContext; }()); // Store context to pass back selector and context when a selector is matched var SelectorContext = /** @class */ (function () { function SelectorContext(selector, cbContext, listContext) { this.selector = selector; this.cbContext = cbContext; this.listContext = listContext; this.notSelectors = selector.notSelectors; } SelectorContext.prototype.finalize = function (cssSelector, callback) { var result = true; if (this.notSelectors.length > 0 && (!this.listContext || !this.listContext.alreadyMatched)) { var notMatcher = SelectorMatcher.createNotMatcher(this.notSelectors); result = !notMatcher.match(cssSelector, null); } if (result && callback && (!this.listContext || !this.listContext.alreadyMatched)) { if (this.listContext) { this.listContext.alreadyMatched = true; } callback(this.selector, this.cbContext); } return result; }; return SelectorContext; }()); var createInject = makeMetadataFactory('Inject', function (token) { return ({ token: token }); }); var createInjectionToken = makeMetadataFactory('InjectionToken', function (desc) { return ({ _desc: desc, ɵprov: undefined }); }); var createAttribute = makeMetadataFactory('Attribute', function (attributeName) { return ({ attributeName: attributeName }); }); // Stores the default value of `emitDistinctChangesOnly` when the `emitDistinctChangesOnly` is not // explicitly set. var emitDistinctChangesOnlyDefaultValue = true; var createContentChildren = makeMetadataFactory('ContentChildren', function (selector, data) { if (data === void 0) { data = {}; } return (Object.assign({ selector: selector, first: false, isViewQuery: false, descendants: false, emitDistinctChangesOnly: emitDistinctChangesOnlyDefaultValue }, data)); }); var createContentChild = makeMetadataFactory('ContentChild', function (selector, data) { if (data === void 0) { data = {}; } return (Object.assign({ selector: selector, first: true, isViewQuery: false, descendants: true }, data)); }); var createViewChildren = makeMetadataFactory('ViewChildren', function (selector, data) { if (data === void 0) { data = {}; } return (Object.assign({ selector: selector, first: false, isViewQuery: true, descendants: true, emitDistinctChangesOnly: emitDistinctChangesOnlyDefaultValue }, data)); }); var createViewChild = makeMetadataFactory('ViewChild', function (selector, data) { return (Object.assign({ selector: selector, first: true, isViewQuery: true, descendants: true }, data)); }); var createDirective = makeMetadataFactory('Directive', function (dir) { if (dir === void 0) { dir = {}; } return dir; }); var ViewEncapsulation; (function (ViewEncapsulation) { ViewEncapsulation[ViewEncapsulation["Emulated"] = 0] = "Emulated"; // Historically the 1 value was for `Native` encapsulation which has been removed as of v11. ViewEncapsulation[ViewEncapsulation["None"] = 2] = "None"; ViewEncapsulation[ViewEncapsulation["ShadowDom"] = 3] = "ShadowDom"; })(ViewEncapsulation || (ViewEncapsulation = {})); var ChangeDetectionStrategy; (function (ChangeDetectionStrategy) { ChangeDetectionStrategy[ChangeDetectionStrategy["OnPush"] = 0] = "OnPush"; ChangeDetectionStrategy[ChangeDetectionStrategy["Default"] = 1] = "Default"; })(ChangeDetectionStrategy || (ChangeDetectionStrategy = {})); var createComponent = makeMetadataFactory('Component', function (c) { if (c === void 0) { c = {}; } return (Object.assign({ changeDetection: ChangeDetectionStrategy.Default }, c)); }); var createPipe = makeMetadataFactory('Pipe', function (p) { return (Object.assign({ pure: true }, p)); }); var createInput = makeMetadataFactory('Input', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); }); var createOutput = makeMetadataFactory('Output', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); }); var createHostBinding = makeMetadataFactory('HostBinding', function (hostPropertyName) { return ({ hostPropertyName: hostPropertyName }); }); var createHostListener = makeMetadataFactory('HostListener', function (eventName, args) { return ({ eventName: eventName, args: args }); }); var createNgModule = makeMetadataFactory('NgModule', function (ngModule) { return ngModule; }); var createInjectable = makeMetadataFactory('Injectable', function (injectable) { if (injectable === void 0) { injectable = {}; } return injectable; }); var CUSTOM_ELEMENTS_SCHEMA = { name: 'custom-elements' }; var NO_ERRORS_SCHEMA = { name: 'no-errors-schema' }; var createOptional = makeMetadataFactory('Optional'); var createSelf = makeMetadataFactory('Self'); var createSkipSelf = makeMetadataFactory('SkipSelf'); var createHost = makeMetadataFactory('Host'); var Type = Function; var SecurityContext; (function (SecurityContext) { SecurityContext[SecurityContext["NONE"] = 0] = "NONE"; SecurityContext[SecurityContext["HTML"] = 1] = "HTML"; SecurityContext[SecurityContext["STYLE"] = 2] = "STYLE"; SecurityContext[SecurityContext["SCRIPT"] = 3] = "SCRIPT"; SecurityContext[SecurityContext["URL"] = 4] = "URL"; SecurityContext[SecurityContext["RESOURCE_URL"] = 5] = "RESOURCE_URL"; })(SecurityContext || (SecurityContext = {})); var MissingTranslationStrategy; (function (MissingTranslationStrategy) { MissingTranslationStrategy[MissingTranslationStrategy["Error"] = 0] = "Error"; MissingTranslationStrategy[MissingTranslationStrategy["Warning"] = 1] = "Warning"; MissingTranslationStrategy[MissingTranslationStrategy["Ignore"] = 2] = "Ignore"; })(MissingTranslationStrategy || (MissingTranslationStrategy = {})); function makeMetadataFactory(name, props) { // This must be declared as a function, not a fat arrow, so that ES2015 devmode produces code // that works with the static_reflector.ts in the ViewEngine compiler. // In particular, `_registerDecoratorOrConstructor` assumes that the value returned here can be // new'ed. function factory() { var args = []; for (var _i = 0; _i < arguments.length; _i++) { args[_i] = arguments[_i]; } var values = props ? props.apply(void 0, __spreadArray([], __read(args))) : {}; return Object.assign({ ngMetadataName: name }, values); } factory.isTypeOf = function (obj) { return obj && obj.ngMetadataName === name; }; factory.ngMetadataName = name; return factory; } function parserSelectorToSimpleSelector(selector) { var classes = selector.classNames && selector.classNames.length ? __spreadArray([8 /* CLASS */], __read(selector.classNames)) : []; var elementName = selector.element && selector.element !== '*' ? selector.element : ''; return __spreadArray(__spreadArray([elementName], __read(selector.attrs)), __read(classes)); } function parserSelectorToNegativeSelector(selector) { var classes = selector.classNames && selector.classNames.length ? __spreadArray([8 /* CLASS */], __read(selector.classNames)) : []; if (selector.element) { return __spreadArray(__spreadArray([ 1 /* NOT */ | 4 /* ELEMENT */, selector.element ], __read(selector.attrs)), __read(classes)); } else if (selector.attrs.length) { return __spreadArray(__spreadArray([1 /* NOT */ | 2 /* ATTRIBUTE */], __read(selector.attrs)), __read(classes)); } else { return selector.classNames && selector.classNames.length ? __spreadArray([1 /* NOT */ | 8 /* CLASS */], __read(selector.classNames)) : []; } } function parserSelectorToR3Selector(selector) { var positive = parserSelectorToSimpleSelector(selector); var negative = selector.notSelectors && selector.notSelectors.length ? selector.notSelectors.map(function (notSelector) { return parserSelectorToNegativeSelector(notSelector); }) : []; return positive.concat.apply(positive, __spreadArray([], __read(negative))); } function parseSelectorToR3Selector(selector) { return selector ? CssSelector.parse(selector).map(parserSelectorToR3Selector) : []; } var core = /*#__PURE__*/Object.freeze({ __proto__: null, createInject: createInject, createInjectionToken: createInjectionToken, createAttribute: createAttribute, emitDistinctChangesOnlyDefaultValue: emitDistinctChangesOnlyDefaultValue, createContentChildren: createContentChildren, createContentChild: createContentChild, createViewChildren: createViewChildren, createViewChild: createViewChild, createDirective: createDirective, get ViewEncapsulation () { return ViewEncapsulation; }, get ChangeDetectionStrategy () { return ChangeDetectionStrategy; }, createComponent: createComponent, createPipe: createPipe, createInput: createInput, createOutput: createOutput, createHostBinding: createHostBinding, createHostListener: createHostListener, createNgModule: createNgModule, createInjectable: createInjectable, CUSTOM_ELEMENTS_SCHEMA: CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA: NO_ERRORS_SCHEMA, createOptional: createOptional, createSelf: createSelf, createSkipSelf: createSkipSelf, createHost: createHost, Type: Type, get SecurityContext () { return SecurityContext; }, get MissingTranslationStrategy () { return MissingTranslationStrategy; }, parseSelectorToR3Selector: parseSelectorToR3Selector }); /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ //// Types var TypeModifier; (function (TypeModifier) { TypeModifier[TypeModifier["Const"] = 0] = "Const"; })(TypeModifier || (TypeModifier = {})); var Type$1 = /** @class */ (function () { function Type(modifiers) { if (modifiers === void 0) { modifiers = []; } this.modifiers = modifiers; } Type.prototype.hasModifier = function (modifier) { return this.modifiers.indexOf(modifier) !== -1; }; return Type; }()); (function (BuiltinTypeName) { BuiltinTypeName[BuiltinTypeName["Dynamic"] = 0] = "Dynamic"; BuiltinTypeName[BuiltinTypeName["Bool"] = 1] = "Bool"; BuiltinTypeName[BuiltinTypeName["String"] = 2] = "String"; BuiltinTypeName[BuiltinTypeName["Int"] = 3] = "Int"; BuiltinTypeName[BuiltinTypeName["Number"] = 4] = "Number"; BuiltinTypeName[BuiltinTypeName["Function"] = 5] = "Function"; BuiltinTypeName[BuiltinTypeName["Inferred"] = 6] = "Inferred"; BuiltinTypeName[BuiltinTypeName["None"] = 7] = "None"; })(exports.BuiltinTypeName || (exports.BuiltinTypeName = {})); var BuiltinType = /** @class */ (function (_super) { __extends(BuiltinType, _super); function BuiltinType(name, modifiers) { var _this = _super.call(this, modifiers) || this; _this.name = name; return _this; } BuiltinType.prototype.visitType = function (visitor, context) { return visitor.visitBuiltinType(this, context); }; return BuiltinType; }(Type$1)); var ExpressionType = /** @class */ (function (_super) { __extends(ExpressionType, _super); function ExpressionType(value, modifiers, typeParams) { if (typeParams === void 0) { typeParams = null; } var _this = _super.call(this, modifiers) || this; _this.value = value; _this.typeParams = typeParams; return _this; } ExpressionType.prototype.visitType = function (visitor, context) { return visitor.visitExpressionType(this, context); }; return ExpressionType; }(Type$1)); var ArrayType = /** @class */ (function (_super) { __extends(ArrayType, _super); function ArrayType(of, modifiers) { var _this = _super.call(this, modifiers) || this; _this.of = of; return _this; } ArrayType.prototype.visitType = function (visitor, context) { return visitor.visitArrayType(this, context); }; return ArrayType; }(Type$1)); var MapType = /** @class */ (function (_super) { __extends(MapType, _super); function MapType(valueType, modifiers) { var _this = _super.call(this, modifiers) || this; _this.valueType = valueType || null; return _this; } MapType.prototype.visitType = function (visitor, context) { return visitor.visitMapType(this, context); }; return MapType; }(Type$1)); var DYNAMIC_TYPE = new BuiltinType(exports.BuiltinTypeName.Dynamic); var INFERRED_TYPE = new BuiltinType(exports.BuiltinTypeName.Inferred); var BOOL_TYPE = new BuiltinType(exports.BuiltinTypeName.Bool); var INT_TYPE = new BuiltinType(exports.BuiltinTypeName.Int); var NUMBER_TYPE = new BuiltinType(exports.BuiltinTypeName.Number); var STRING_TYPE = new BuiltinType(exports.BuiltinTypeName.String); var FUNCTION_TYPE = new BuiltinType(exports.BuiltinTypeName.Function); var NONE_TYPE = new BuiltinType(exports.BuiltinTypeName.None); (function (UnaryOperator) { UnaryOperator[UnaryOperator["Minus"] = 0] = "Minus"; UnaryOperator[UnaryOperator["Plus"] = 1] = "Plus"; })(exports.UnaryOperator || (exports.UnaryOperator = {})); (function (BinaryOperator) { BinaryOperator[BinaryOperator["Equals"] = 0] = "Equals"; BinaryOperator[BinaryOperator["NotEquals"] = 1] = "NotEquals"; BinaryOperator[BinaryOperator["Identical"] = 2] = "Identical"; BinaryOperator[BinaryOperator["NotIdentical"] = 3] = "NotIdentical"; BinaryOperator[BinaryOperator["Minus"] = 4] = "Minus"; BinaryOperator[BinaryOperator["Plus"] = 5] = "Plus"; BinaryOperator[BinaryOperator["Divide"] = 6] = "Divide"; BinaryOperator[BinaryOperator["Multiply"] = 7] = "Multiply"; BinaryOperator[BinaryOperator["Modulo"] = 8] = "Modulo"; BinaryOperator[BinaryOperator["And"] = 9] = "And"; BinaryOperator[BinaryOperator["Or"] = 10] = "Or"; BinaryOperator[BinaryOperator["BitwiseAnd"] = 11] = "BitwiseAnd"; BinaryOperator[BinaryOperator["Lower"] = 12] = "Lower"; BinaryOperator[BinaryOperator["LowerEquals"] = 13] = "LowerEquals"; BinaryOperator[BinaryOperator["Bigger"] = 14] = "Bigger"; BinaryOperator[BinaryOperator["BiggerEquals"] = 15] = "BiggerEquals"; BinaryOperator[BinaryOperator["NullishCoalesce"] = 16] = "NullishCoalesce"; })(exports.BinaryOperator || (exports.BinaryOperator = {})); function nullSafeIsEquivalent(base, other) { if (base == null || other == null) { return base == other; } return base.isEquivalent(other); } function areAllEquivalentPredicate(base, other, equivalentPredicate) { var len = base.length; if (len !== other.length) { return false; } for (var i = 0; i < len; i++) { if (!equivalentPredicate(base[i], other[i])) { return false; } } return true; } function areAllEquivalent(base, other) { return areAllEquivalentPredicate(base, other, function (baseElement, otherElement) { return baseElement.isEquivalent(otherElement); }); } var Expression = /** @class */ (function () { function Expression(type, sourceSpan) { this.type = type || null; this.sourceSpan = sourceSpan || null; } Expression.prototype.prop = function (name, sourceSpan) { return new ReadPropExpr(this, name, null, sourceSpan); }; Expression.prototype.key = function (index, type, sourceSpan) { return new ReadKeyExpr(this, index, type, sourceSpan); }; Expression.prototype.callMethod = function (name, params, sourceSpan) { return new InvokeMethodExpr(this, name, params, null, sourceSpan); }; Expression.prototype.callFn = function (params, sourceSpan, pure) { return new InvokeFunctionExpr(this, params, null, sourceSpan, pure); }; Expression.prototype.instantiate = function (params, type, sourceSpan) { return new InstantiateExpr(this, params, type, sourceSpan); }; Expression.prototype.conditional = function (trueCase, falseCase, sourceSpan) { if (falseCase === void 0) { falseCase = null; } return new ConditionalExpr(this, trueCase, falseCase, null, sourceSpan); }; Expression.prototype.equals = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.Equals, this, rhs, null, sourceSpan); }; Expression.prototype.notEquals = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.NotEquals, this, rhs, null, sourceSpan); }; Expression.prototype.identical = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.Identical, this, rhs, null, sourceSpan); }; Expression.prototype.notIdentical = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.NotIdentical, this, rhs, null, sourceSpan); }; Expression.prototype.minus = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.Minus, this, rhs, null, sourceSpan); }; Expression.prototype.plus = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.Plus, this, rhs, null, sourceSpan); }; Expression.prototype.divide = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.Divide, this, rhs, null, sourceSpan); }; Expression.prototype.multiply = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.Multiply, this, rhs, null, sourceSpan); }; Expression.prototype.modulo = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.Modulo, this, rhs, null, sourceSpan); }; Expression.prototype.and = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.And, this, rhs, null, sourceSpan); }; Expression.prototype.bitwiseAnd = function (rhs, sourceSpan, parens) { if (parens === void 0) { parens = true; } return new BinaryOperatorExpr(exports.BinaryOperator.BitwiseAnd, this, rhs, null, sourceSpan, parens); }; Expression.prototype.or = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.Or, this, rhs, null, sourceSpan); }; Expression.prototype.lower = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.Lower, this, rhs, null, sourceSpan); }; Expression.prototype.lowerEquals = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.LowerEquals, this, rhs, null, sourceSpan); }; Expression.prototype.bigger = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.Bigger, this, rhs, null, sourceSpan); }; Expression.prototype.biggerEquals = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.BiggerEquals, this, rhs, null, sourceSpan); }; Expression.prototype.isBlank = function (sourceSpan) { // Note: We use equals by purpose here to compare to null and undefined in JS. // We use the typed null to allow strictNullChecks to narrow types. return this.equals(TYPED_NULL_EXPR, sourceSpan); }; Expression.prototype.cast = function (type, sourceSpan) { return new CastExpr(this, type, sourceSpan); }; Expression.prototype.nullishCoalesce = function (rhs, sourceSpan) { return new BinaryOperatorExpr(exports.BinaryOperator.NullishCoalesce, this, rhs, null, sourceSpan); }; Expression.prototype.toStmt = function () { return new ExpressionStatement(this, null); }; return Expression; }()); (function (BuiltinVar) { BuiltinVar[BuiltinVar["This"] = 0] = "This"; BuiltinVar[BuiltinVar["Super"] = 1] = "Super"; BuiltinVar[BuiltinVar["CatchError"] = 2] = "CatchError"; BuiltinVar[BuiltinVar["CatchStack"] = 3] = "CatchStack"; })(exports.BuiltinVar || (exports.BuiltinVar = {})); var ReadVarExpr = /** @class */ (function (_super) { __extends(ReadVarExpr, _super); function ReadVarExpr(name, type, sourceSpan) { var _this = _super.call(this, type, sourceSpan) || this; if (typeof name === 'string') { _this.name = name; _this.builtin = null; } else { _this.name = null; _this.builtin = name; } return _this; } ReadVarExpr.prototype.isEquivalent = function (e) { return e instanceof ReadVarExpr && this.name === e.name && this.builtin === e.builtin; }; ReadVarExpr.prototype.isConstant = function () { return false; }; ReadVarExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitReadVarExpr(this, context); }; ReadVarExpr.prototype.set = function (value) { if (!this.name) { throw new Error("Built in variable " + this.builtin + " can not be assigned to."); } return new WriteVarExpr(this.name, value, null, this.sourceSpan); }; return ReadVarExpr; }(Expression)); var TypeofExpr = /** @class */ (function (_super) { __extends(TypeofExpr, _super); function TypeofExpr(expr, type, sourceSpan) { var _this = _super.call(this, type, sourceSpan) || this; _this.expr = expr; return _this; } TypeofExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitTypeofExpr(this, context); }; TypeofExpr.prototype.isEquivalent = function (e) { return e instanceof TypeofExpr && e.expr.isEquivalent(this.expr); }; TypeofExpr.prototype.isConstant = function () { return this.expr.isConstant(); }; return TypeofExpr; }(Expression)); var WrappedNodeExpr = /** @class */ (function (_super) { __extends(WrappedNodeExpr, _super); function WrappedNodeExpr(node, type, sourceSpan) { var _this = _super.call(this, type, sourceSpan) || this; _this.node = node; return _this; } WrappedNodeExpr.prototype.isEquivalent = function (e) { return e instanceof WrappedNodeExpr && this.node === e.node; }; WrappedNodeExpr.prototype.isConstant = function () { return false; }; WrappedNodeExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitWrappedNodeExpr(this, context); }; return WrappedNodeExpr; }(Expression)); var WriteVarExpr = /** @class */ (function (_super) { __extends(WriteVarExpr, _super); function WriteVarExpr(name, value, type, sourceSpan) { var _this = _super.call(this, type || value.type, sourceSpan) || this; _this.name = name; _this.value = value; return _this; } WriteVarExpr.prototype.isEquivalent = function (e) { return e instanceof WriteVarExpr && this.name === e.name && this.value.isEquivalent(e.value); }; WriteVarExpr.prototype.isConstant = function () { return false; }; WriteVarExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitWriteVarExpr(this, context); }; WriteVarExpr.prototype.toDeclStmt = function (type, modifiers) { return new DeclareVarStmt(this.name, this.value, type, modifiers, this.sourceSpan); }; WriteVarExpr.prototype.toConstDecl = function () { return this.toDeclStmt(INFERRED_TYPE, [exports.StmtModifier.Final]); }; return WriteVarExpr; }(Expression)); var WriteKeyExpr = /** @class */ (function (_super) { __extends(WriteKeyExpr, _super); function WriteKeyExpr(receiver, index, value, type, sourceSpan) { var _this = _super.call(this, type || value.type, sourceSpan) || this; _this.receiver = receiver; _this.index = index; _this.value = value; return _this; } WriteKeyExpr.prototype.isEquivalent = function (e) { return e instanceof WriteKeyExpr && this.receiver.isEquivalent(e.receiver) && this.index.isEquivalent(e.index) && this.value.isEquivalent(e.value); }; WriteKeyExpr.prototype.isConstant = function () { return false; }; WriteKeyExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitWriteKeyExpr(this, context); }; return WriteKeyExpr; }(Expression)); var WritePropExpr = /** @class */ (function (_super) { __extends(WritePropExpr, _super); function WritePropExpr(receiver, name, value, type, sourceSpan) { var _this = _super.call(this, type || value.type, sourceSpan) || this; _this.receiver = receiver; _this.name = name; _this.value = value; return _this; } WritePropExpr.prototype.isEquivalent = function (e) { return e instanceof WritePropExpr && this.receiver.isEquivalent(e.receiver) && this.name === e.name && this.value.isEquivalent(e.value); }; WritePropExpr.prototype.isConstant = function () { return false; }; WritePropExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitWritePropExpr(this, context); }; return WritePropExpr; }(Expression)); (function (BuiltinMethod) { BuiltinMethod[BuiltinMethod["ConcatArray"] = 0] = "ConcatArray"; BuiltinMethod[BuiltinMethod["SubscribeObservable"] = 1] = "SubscribeObservable"; BuiltinMethod[BuiltinMethod["Bind"] = 2] = "Bind"; })(exports.BuiltinMethod || (exports.BuiltinMethod = {})); var InvokeMethodExpr = /** @class */ (function (_super) { __extends(InvokeMethodExpr, _super); function InvokeMethodExpr(receiver, method, args, type, sourceSpan) { var _this = _super.call(this, type, sourceSpan) || this; _this.receiver = receiver; _this.args = args; if (typeof method === 'string') { _this.name = method; _this.builtin = null; } else { _this.name = null; _this.builtin = method; } return _this; } InvokeMethodExpr.prototype.isEquivalent = function (e) { return e instanceof InvokeMethodExpr && this.receiver.isEquivalent(e.receiver) && this.name === e.name && this.builtin === e.builtin && areAllEquivalent(this.args, e.args); }; InvokeMethodExpr.prototype.isConstant = function () { return false; }; InvokeMethodExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitInvokeMethodExpr(this, context); }; return InvokeMethodExpr; }(Expression)); var InvokeFunctionExpr = /** @class */ (function (_super) { __extends(InvokeFunctionExpr, _super); function InvokeFunctionExpr(fn, args, type, sourceSpan, pure) { if (pure === void 0) { pure = false; } var _this = _super.call(this, type, sourceSpan) || this; _this.fn = fn; _this.args = args; _this.pure = pure; return _this; } InvokeFunctionExpr.prototype.isEquivalent = function (e) { return e instanceof InvokeFunctionExpr && this.fn.isEquivalent(e.fn) && areAllEquivalent(this.args, e.args) && this.pure === e.pure; }; InvokeFunctionExpr.prototype.isConstant = function () { return false; }; InvokeFunctionExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitInvokeFunctionExpr(this, context); }; return InvokeFunctionExpr; }(Expression)); var TaggedTemplateExpr = /** @class */ (function (_super) { __extends(TaggedTemplateExpr, _super); function TaggedTemplateExpr(tag, template, type, sourceSpan) { var _this = _super.call(this, type, sourceSpan) || this; _this.tag = tag; _this.template = template; return _this; } TaggedTemplateExpr.prototype.isEquivalent = function (e) { return e instanceof TaggedTemplateExpr && this.tag.isEquivalent(e.tag) && areAllEquivalentPredicate(this.template.elements, e.template.elements, function (a, b) { return a.text === b.text; }) && areAllEquivalent(this.template.expressions, e.template.expressions); }; TaggedTemplateExpr.prototype.isConstant = function () { return false; }; TaggedTemplateExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitTaggedTemplateExpr(this, context); }; return TaggedTemplateExpr; }(Expression)); var InstantiateExpr = /** @class */ (function (_super) { __extends(InstantiateExpr, _super); function InstantiateExpr(classExpr, args, type, sourceSpan) { var _this = _super.call(this, type, sourceSpan) || this; _this.classExpr = classExpr; _this.args = args; return _this; } InstantiateExpr.prototype.isEquivalent = function (e) { return e instanceof InstantiateExpr && this.classExpr.isEquivalent(e.classExpr) && areAllEquivalent(this.args, e.args); }; InstantiateExpr.prototype.isConstant = function () { return false; }; InstantiateExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitInstantiateExpr(this, context); }; return InstantiateExpr; }(Expression)); var LiteralExpr = /** @class */ (function (_super) { __extends(LiteralExpr, _super); function LiteralExpr(value, type, sourceSpan) { var _this = _super.call(this, type, sourceSpan) || this; _this.value = value; return _this; } LiteralExpr.prototype.isEquivalent = function (e) { return e instanceof LiteralExpr && this.value === e.value; }; LiteralExpr.prototype.isConstant = function () { return true; }; LiteralExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitLiteralExpr(this, context); }; return LiteralExpr; }(Expression)); var TemplateLiteral = /** @class */ (function () { function TemplateLiteral(elements, expressions) { this.elements = elements; this.expressions = expressions; } return TemplateLiteral; }()); var TemplateLiteralElement = /** @class */ (function () { function TemplateLiteralElement(text, sourceSpan, rawText) { var _a; this.text = text; this.sourceSpan = sourceSpan; // If `rawText` is not provided, try to extract the raw string from its // associated `sourceSpan`. If that is also not available, "fake" the raw // string instead by escaping the following control sequences: // - "\" would otherwise indicate that the next character is a control character. // - "`" and "${" are template string control sequences that would otherwise prematurely // indicate the end of the template literal element. this.rawText = (_a = rawText !== null && rawText !== void 0 ? rawText : sourceSpan === null || sourceSpan === void 0 ? void 0 : sourceSpan.toString()) !== null && _a !== void 0 ? _a : escapeForTemplateLiteral(escapeSlashes(text)); } return TemplateLiteralElement; }()); var MessagePiece = /** @class */ (function () { function MessagePiece(text, sourceSpan) { this.text = text; this.sourceSpan = sourceSpan; } return MessagePiece; }()); var LiteralPiece = /** @class */ (function (_super) { __extends(LiteralPiece, _super); function LiteralPiece() { return _super !== null && _super.apply(this, arguments) || this; } return LiteralPiece; }(MessagePiece)); var PlaceholderPiece = /** @class */ (function (_super) { __extends(PlaceholderPiece, _super); function PlaceholderPiece() { return _super !== null && _super.apply(this, arguments) || this; } return PlaceholderPiece; }(MessagePiece)); var LocalizedString = /** @class */ (function (_super) { __extends(LocalizedString, _super); function LocalizedString(metaBlock, messageParts, placeHolderNames, expressions, sourceSpan) { var _this = _super.call(this, STRING_TYPE, sourceSpan) || this; _this.metaBlock = metaBlock; _this.messageParts = messageParts; _this.placeHolderNames = placeHolderNames; _this.expressions = expressions; return _this; } LocalizedString.prototype.isEquivalent = function (e) { // return e instanceof LocalizedString && this.message === e.message; return false; }; LocalizedString.prototype.isConstant = function () { return false; }; LocalizedString.prototype.visitExpression = function (visitor, context) { return visitor.visitLocalizedString(this, context); }; /** * Serialize the given `meta` and `messagePart` into "cooked" and "raw" strings that can be used * in a `$localize` tagged string. The format of the metadata is the same as that parsed by * `parseI18nMeta()`. * * @param meta The metadata to serialize * @param messagePart The first part of the tagged string */ LocalizedString.prototype.serializeI18nHead = function () { var MEANING_SEPARATOR = '|'; var ID_SEPARATOR = '@@'; var LEGACY_ID_INDICATOR = '␟'; var metaBlock = this.metaBlock.description || ''; if (this.metaBlock.meaning) { metaBlock = "" + this.metaBlock.meaning + MEANING_SEPARATOR + metaBlock; } if (this.metaBlock.customId) { metaBlock = "" + metaBlock + ID_SEPARATOR + this.metaBlock.customId; } if (this.metaBlock.legacyIds) { this.metaBlock.legacyIds.forEach(function (legacyId) { metaBlock = "" + metaBlock + LEGACY_ID_INDICATOR + legacyId; }); } return createCookedRawString(metaBlock, this.messageParts[0].text, this.getMessagePartSourceSpan(0)); }; LocalizedString.prototype.getMessagePartSourceSpan = function (i) { var _a, _b; return (_b = (_a = this.messageParts[i]) === null || _a === void 0 ? void 0 : _a.sourceSpan) !== null && _b !== void 0 ? _b : this.sourceSpan; }; LocalizedString.prototype.getPlaceholderSourceSpan = function (i) { var _a, _b, _c, _d; return (_d = (_b = (_a = this.placeHolderNames[i]) === null || _a === void 0 ? void 0 : _a.sourceSpan) !== null && _b !== void 0 ? _b : (_c = this.expressions[i]) === null || _c === void 0 ? void 0 : _c.sourceSpan) !== null && _d !== void 0 ? _d : this.sourceSpan; }; /** * Serialize the given `placeholderName` and `messagePart` into "cooked" and "raw" strings that * can be used in a `$localize` tagged string. * * @param placeholderName The placeholder name to serialize * @param messagePart The following message string after this placeholder */ LocalizedString.prototype.serializeI18nTemplatePart = function (partIndex) { var placeholderName = this.placeHolderNames[partIndex - 1].text; var messagePart = this.messageParts[partIndex]; return createCookedRawString(placeholderName, messagePart.text, this.getMessagePartSourceSpan(partIndex)); }; return LocalizedString; }(Expression)); var escapeSlashes = function (str) { return str.replace(/\\/g, '\\\\'); }; var escapeStartingColon = function (str) { return str.replace(/^:/, '\\:'); }; var escapeColons = function (str) { return str.replace(/:/g, '\\:'); }; var escapeForTemplateLiteral = function (str) { return str.replace(/`/g, '\\`').replace(/\${/g, '$\\{'); }; /** * Creates a `{cooked, raw}` object from the `metaBlock` and `messagePart`. * * The `raw` text must have various character sequences escaped: * * "\" would otherwise indicate that the next character is a control character. * * "`" and "${" are template string control sequences that would otherwise prematurely indicate * the end of a message part. * * ":" inside a metablock would prematurely indicate the end of the metablock. * * ":" at the start of a messagePart with no metablock would erroneously indicate the start of a * metablock. * * @param metaBlock Any metadata that should be prepended to the string * @param messagePart The message part of the string */ function createCookedRawString(metaBlock, messagePart, range) { if (metaBlock === '') { return { cooked: messagePart, raw: escapeForTemplateLiteral(escapeStartingColon(escapeSlashes(messagePart))), range: range, }; } else { return { cooked: ":" + metaBlock + ":" + messagePart, raw: escapeForTemplateLiteral(":" + escapeColons(escapeSlashes(metaBlock)) + ":" + escapeSlashes(messagePart)), range: range, }; } } var ExternalExpr = /** @class */ (function (_super) { __extends(ExternalExpr, _super); function ExternalExpr(value, type, typeParams, sourceSpan) { if (typeParams === void 0) { typeParams = null; } var _this = _super.call(this, type, sourceSpan) || this; _this.value = value; _this.typeParams = typeParams; return _this; } ExternalExpr.prototype.isEquivalent = function (e) { return e instanceof ExternalExpr && this.value.name === e.value.name && this.value.moduleName === e.value.moduleName && this.value.runtime === e.value.runtime; }; ExternalExpr.prototype.isConstant = function () { return false; }; ExternalExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitExternalExpr(this, context); }; return ExternalExpr; }(Expression)); var ExternalReference = /** @class */ (function () { function ExternalReference(moduleName, name, runtime) { this.moduleName = moduleName; this.name = name; this.runtime = runtime; } return ExternalReference; }()); var ConditionalExpr = /** @class */ (function (_super) { __extends(ConditionalExpr, _super); function ConditionalExpr(condition, trueCase, falseCase, type, sourceSpan) { if (falseCase === void 0) { falseCase = null; } var _this = _super.call(this, type || trueCase.type, sourceSpan) || this; _this.condition = condition; _this.falseCase = falseCase; _this.trueCase = trueCase; return _this; } ConditionalExpr.prototype.isEquivalent = function (e) { return e instanceof ConditionalExpr && this.condition.isEquivalent(e.condition) && this.trueCase.isEquivalent(e.trueCase) && nullSafeIsEquivalent(this.falseCase, e.falseCase); }; ConditionalExpr.prototype.isConstant = function () { return false; }; ConditionalExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitConditionalExpr(this, context); }; return ConditionalExpr; }(Expression)); var NotExpr = /** @class */ (function (_super) { __extends(NotExpr, _super); function NotExpr(condition, sourceSpan) { var _this = _super.call(this, BOOL_TYPE, sourceSpan) || this; _this.condition = condition; return _this; } NotExpr.prototype.isEquivalent = function (e) { return e instanceof NotExpr && this.condition.isEquivalent(e.condition); }; NotExpr.prototype.isConstant = function () { return false; }; NotExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitNotExpr(this, context); }; return NotExpr; }(Expression)); var AssertNotNull = /** @class */ (function (_super) { __extends(AssertNotNull, _super); function AssertNotNull(condition, sourceSpan) { var _this = _super.call(this, condition.type, sourceSpan) || this; _this.condition = condition; return _this; } AssertNotNull.prototype.isEquivalent = function (e) { return e instanceof AssertNotNull && this.condition.isEquivalent(e.condition); }; AssertNotNull.prototype.isConstant = function () { return false; }; AssertNotNull.prototype.visitExpression = function (visitor, context) { return visitor.visitAssertNotNullExpr(this, context); }; return AssertNotNull; }(Expression)); var CastExpr = /** @class */ (function (_super) { __extends(CastExpr, _super); function CastExpr(value, type, sourceSpan) { var _this = _super.call(this, type, sourceSpan) || this; _this.value = value; return _this; } CastExpr.prototype.isEquivalent = function (e) { return e instanceof CastExpr && this.value.isEquivalent(e.value); }; CastExpr.prototype.isConstant = function () { return false; }; CastExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitCastExpr(this, context); }; return CastExpr; }(Expression)); var FnParam = /** @class */ (function () { function FnParam(name, type) { if (type === void 0) { type = null; } this.name = name; this.type = type; } FnParam.prototype.isEquivalent = function (param) { return this.name === param.name; }; return FnParam; }()); var FunctionExpr = /** @class */ (function (_super) { __extends(FunctionExpr, _super); function FunctionExpr(params, statements, type, sourceSpan, name) { var _this = _super.call(this, type, sourceSpan) || this; _this.params = params; _this.statements = statements; _this.name = name; return _this; } FunctionExpr.prototype.isEquivalent = function (e) { return e instanceof FunctionExpr && areAllEquivalent(this.params, e.params) && areAllEquivalent(this.statements, e.statements); }; FunctionExpr.prototype.isConstant = function () { return false; }; FunctionExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitFunctionExpr(this, context); }; FunctionExpr.prototype.toDeclStmt = function (name, modifiers) { return new DeclareFunctionStmt(name, this.params, this.statements, this.type, modifiers, this.sourceSpan); }; return FunctionExpr; }(Expression)); var UnaryOperatorExpr = /** @class */ (function (_super) { __extends(UnaryOperatorExpr, _super); function UnaryOperatorExpr(operator, expr, type, sourceSpan, parens) { if (parens === void 0) { parens = true; } var _this = _super.call(this, type || NUMBER_TYPE, sourceSpan) || this; _this.operator = operator; _this.expr = expr; _this.parens = parens; return _this; } UnaryOperatorExpr.prototype.isEquivalent = function (e) { return e instanceof UnaryOperatorExpr && this.operator === e.operator && this.expr.isEquivalent(e.expr); }; UnaryOperatorExpr.prototype.isConstant = function () { return false; }; UnaryOperatorExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitUnaryOperatorExpr(this, context); }; return UnaryOperatorExpr; }(Expression)); var BinaryOperatorExpr = /** @class */ (function (_super) { __extends(BinaryOperatorExpr, _super); function BinaryOperatorExpr(operator, lhs, rhs, type, sourceSpan, parens) { if (parens === void 0) { parens = true; } var _this = _super.call(this, type || lhs.type, sourceSpan) || this; _this.operator = operator; _this.rhs = rhs; _this.parens = parens; _this.lhs = lhs; return _this; } BinaryOperatorExpr.prototype.isEquivalent = function (e) { return e instanceof BinaryOperatorExpr && this.operator === e.operator && this.lhs.isEquivalent(e.lhs) && this.rhs.isEquivalent(e.rhs); }; BinaryOperatorExpr.prototype.isConstant = function () { return false; }; BinaryOperatorExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitBinaryOperatorExpr(this, context); }; return BinaryOperatorExpr; }(Expression)); var ReadPropExpr = /** @class */ (function (_super) { __extends(ReadPropExpr, _super); function ReadPropExpr(receiver, name, type, sourceSpan) { var _this = _super.call(this, type, sourceSpan) || this; _this.receiver = receiver; _this.name = name; return _this; } ReadPropExpr.prototype.isEquivalent = function (e) { return e instanceof ReadPropExpr && this.receiver.isEquivalent(e.receiver) && this.name === e.name; }; ReadPropExpr.prototype.isConstant = function () { return false; }; ReadPropExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitReadPropExpr(this, context); }; ReadPropExpr.prototype.set = function (value) { return new WritePropExpr(this.receiver, this.name, value, null, this.sourceSpan); }; return ReadPropExpr; }(Expression)); var ReadKeyExpr = /** @class */ (function (_super) { __extends(ReadKeyExpr, _super); function ReadKeyExpr(receiver, index, type, sourceSpan) { var _this = _super.call(this, type, sourceSpan) || this; _this.receiver = receiver; _this.index = index; return _this; } ReadKeyExpr.prototype.isEquivalent = function (e) { return e instanceof ReadKeyExpr && this.receiver.isEquivalent(e.receiver) && this.index.isEquivalent(e.index); }; ReadKeyExpr.prototype.isConstant = function () { return false; }; ReadKeyExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitReadKeyExpr(this, context); }; ReadKeyExpr.prototype.set = function (value) { return new WriteKeyExpr(this.receiver, this.index, value, null, this.sourceSpan); }; return ReadKeyExpr; }(Expression)); var LiteralArrayExpr = /** @class */ (function (_super) { __extends(LiteralArrayExpr, _super); function LiteralArrayExpr(entries, type, sourceSpan) { var _this = _super.call(this, type, sourceSpan) || this; _this.entries = entries; return _this; } LiteralArrayExpr.prototype.isConstant = function () { return this.entries.every(function (e) { return e.isConstant(); }); }; LiteralArrayExpr.prototype.isEquivalent = function (e) { return e instanceof LiteralArrayExpr && areAllEquivalent(this.entries, e.entries); }; LiteralArrayExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitLiteralArrayExpr(this, context); }; return LiteralArrayExpr; }(Expression)); var LiteralMapEntry = /** @class */ (function () { function LiteralMapEntry(key, value, quoted) { this.key = key; this.value = value; this.quoted = quoted; } LiteralMapEntry.prototype.isEquivalent = function (e) { return this.key === e.key && this.value.isEquivalent(e.value); }; return LiteralMapEntry; }()); var LiteralMapExpr = /** @class */ (function (_super) { __extends(LiteralMapExpr, _super); function LiteralMapExpr(entries, type, sourceSpan) { var _this = _super.call(this, type, sourceSpan) || this; _this.entries = entries; _this.valueType = null; if (type) { _this.valueType = type.valueType; } return _this; } LiteralMapExpr.prototype.isEquivalent = function (e) { return e instanceof LiteralMapExpr && areAllEquivalent(this.entries, e.entries); }; LiteralMapExpr.prototype.isConstant = function () { return this.entries.every(function (e) { return e.value.isConstant(); }); }; LiteralMapExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitLiteralMapExpr(this, context); }; return LiteralMapExpr; }(Expression)); var CommaExpr = /** @class */ (function (_super) { __extends(CommaExpr, _super); function CommaExpr(parts, sourceSpan) { var _this = _super.call(this, parts[parts.length - 1].type, sourceSpan) || this; _this.parts = parts; return _this; } CommaExpr.prototype.isEquivalent = function (e) { return e instanceof CommaExpr && areAllEquivalent(this.parts, e.parts); }; CommaExpr.prototype.isConstant = function () { return false; }; CommaExpr.prototype.visitExpression = function (visitor, context) { return visitor.visitCommaExpr(this, context); }; return CommaExpr; }(Expression)); var THIS_EXPR = new ReadVarExpr(exports.BuiltinVar.This, null, null); var SUPER_EXPR = new ReadVarExpr(exports.BuiltinVar.Super, null, null); var CATCH_ERROR_VAR = new ReadVarExpr(exports.BuiltinVar.CatchError, null, null); var CATCH_STACK_VAR = new ReadVarExpr(exports.BuiltinVar.CatchStack, null, null); var NULL_EXPR = new LiteralExpr(null, null, null); var TYPED_NULL_EXPR = new LiteralExpr(null, INFERRED_TYPE, null); (function (StmtModifier) { StmtModifier[StmtModifier["Final"] = 0] = "Final"; StmtModifier[StmtModifier["Private"] = 1] = "Private"; StmtModifier[StmtModifier["Exported"] = 2] = "Exported"; StmtModifier[StmtModifier["Static"] = 3] = "Static"; })(exports.StmtModifier || (exports.StmtModifier = {})); var LeadingComment = /** @class */ (function () { function LeadingComment(text, multiline, trailingNewline) { this.text = text; this.multiline = multiline; this.trailingNewline = trailingNewline; } LeadingComment.prototype.toString = function () { return this.multiline ? " " + this.text + " " : this.text; }; return LeadingComment; }()); var JSDocComment = /** @class */ (function (_super) { __extends(JSDocComment, _super); function JSDocComment(tags) { var _this = _super.call(this, '', /* multiline */ true, /* trailingNewline */ true) || this; _this.tags = tags; return _this; } JSDocComment.prototype.toString = function () { return serializeTags(this.tags); }; return JSDocComment; }(LeadingComment)); var Statement = /** @class */ (function () { function Statement(modifiers, sourceSpan, leadingComments) { if (modifiers === void 0) { modifiers = []; } if (sourceSpan === void 0) { sourceSpan = null; } this.modifiers = modifiers; this.sourceSpan = sourceSpan; this.leadingComments = leadingComments; } Statement.prototype.hasModifier = function (modifier) { return this.modifiers.indexOf(modifier) !== -1; }; Statement.prototype.addLeadingComment = function (leadingComment) { var _a; this.leadingComments = (_a = this.leadingComments) !== null && _a !== void 0 ? _a : []; this.leadingComments.push(leadingComment); }; return Statement; }()); var DeclareVarStmt = /** @class */ (function (_super) { __extends(DeclareVarStmt, _super); function DeclareVarStmt(name, value, type, modifiers, sourceSpan, leadingComments) { var _this = _super.call(this, modifiers, sourceSpan, leadingComments) || this; _this.name = name; _this.value = value; _this.type = type || (value && value.type) || null; return _this; } DeclareVarStmt.prototype.isEquivalent = function (stmt) { return stmt instanceof DeclareVarStmt && this.name === stmt.name && (this.value ? !!stmt.value && this.value.isEquivalent(stmt.value) : !stmt.value); }; DeclareVarStmt.prototype.visitStatement = function (visitor, context) { return visitor.visitDeclareVarStmt(this, context); }; return DeclareVarStmt; }(Statement)); var DeclareFunctionStmt = /** @class */ (function (_super) { __extends(DeclareFunctionStmt, _super); function DeclareFunctionStmt(name, params, statements, type, modifiers, sourceSpan, leadingComments) { var _this = _super.call(this, modifiers, sourceSpan, leadingComments) || this; _this.name = name; _this.params = params; _this.statements = statements; _this.type = type || null; return _this; } DeclareFunctionStmt.prototype.isEquivalent = function (stmt) { return stmt instanceof DeclareFunctionStmt && areAllEquivalent(this.params, stmt.params) && areAllEquivalent(this.statements, stmt.statements); }; DeclareFunctionStmt.prototype.visitStatement = function (visitor, context) { return visitor.visitDeclareFunctionStmt(this, context); }; return DeclareFunctionStmt; }(Statement)); var ExpressionStatement = /** @class */ (function (_super) { __extends(ExpressionStatement, _super); function ExpressionStatement(expr, sourceSpan, leadingComments) { var _this = _super.call(this, [], sourceSpan, leadingComments) || this; _this.expr = expr; return _this; } ExpressionStatement.prototype.isEquivalent = function (stmt) { return stmt instanceof ExpressionStatement && this.expr.isEquivalent(stmt.expr); }; ExpressionStatement.prototype.visitStatement = function (visitor, context) { return visitor.visitExpressionStmt(this, context); }; return ExpressionStatement; }(Statement)); var ReturnStatement = /** @class */ (function (_super) { __extends(ReturnStatement, _super); function ReturnStatement(value, sourceSpan, leadingComments) { if (sourceSpan === void 0) { sourceSpan = null; } var _this = _super.call(this, [], sourceSpan, leadingComments) || this; _this.value = value; return _this; } ReturnStatement.prototype.isEquivalent = function (stmt) { return stmt instanceof ReturnStatement && this.value.isEquivalent(stmt.value); }; ReturnStatement.prototype.visitStatement = function (visitor, context) { return visitor.visitReturnStmt(this, context); }; return ReturnStatement; }(Statement)); var AbstractClassPart = /** @class */ (function () { function AbstractClassPart(type, modifiers) { if (type === void 0) { type = null; } if (modifiers === void 0) { modifiers = []; } this.type = type; this.modifiers = modifiers; } AbstractClassPart.prototype.hasModifier = function (modifier) { return this.modifiers.indexOf(modifier) !== -1; }; return AbstractClassPart; }()); var ClassField = /** @class */ (function (_super) { __extends(ClassField, _super); function ClassField(name, type, modifiers, initializer) { var _this = _super.call(this, type, modifiers) || this; _this.name = name; _this.initializer = initializer; return _this; } ClassField.prototype.isEquivalent = function (f) { return this.name === f.name; }; return ClassField; }(AbstractClassPart)); var ClassMethod = /** @class */ (function (_super) { __extends(ClassMethod, _super); function ClassMethod(name, params, body, type, modifiers) { var _this = _super.call(this, type, modifiers) || this; _this.name = name; _this.params = params; _this.body = body; return _this; } ClassMethod.prototype.isEquivalent = function (m) { return this.name === m.name && areAllEquivalent(this.body, m.body); }; return ClassMethod; }(AbstractClassPart)); var ClassGetter = /** @class */ (function (_super) { __extends(ClassGetter, _super); function ClassGetter(name, body, type, modifiers) { var _this = _super.call(this, type, modifiers) || this; _this.name = name; _this.body = body; return _this; } ClassGetter.prototype.isEquivalent = function (m) { return this.name === m.name && areAllEquivalent(this.body, m.body); }; return ClassGetter; }(AbstractClassPart)); var ClassStmt = /** @class */ (function (_super) { __extends(ClassStmt, _super); function ClassStmt(name, parent, fields, getters, constructorMethod, methods, modifiers, sourceSpan, leadingComments) { var _this = _super.call(this, modifiers, sourceSpan, leadingComments) || this; _this.name = name; _this.parent = parent; _this.fields = fields; _this.getters = getters; _this.constructorMethod = constructorMethod; _this.methods = methods; return _this; } ClassStmt.prototype.isEquivalent = function (stmt) { return stmt instanceof ClassStmt && this.name === stmt.name && nullSafeIsEquivalent(this.parent, stmt.parent) && areAllEquivalent(this.fields, stmt.fields) && areAllEquivalent(this.getters, stmt.getters) && this.constructorMethod.isEquivalent(stmt.constructorMethod) && areAllEquivalent(this.methods, stmt.methods); }; ClassStmt.prototype.visitStatement = function (visitor, context) { return visitor.visitDeclareClassStmt(this, context); }; return ClassStmt; }(Statement)); var IfStmt = /** @class */ (function (_super) { __extends(IfStmt, _super); function IfStmt(condition, trueCase, falseCase, sourceSpan, leadingComments) { if (falseCase === void 0) { falseCase = []; } var _this = _super.call(this, [], sourceSpan, leadingComments) || this; _this.condition = condition; _this.trueCase = trueCase; _this.falseCase = falseCase; return _this; } IfStmt.prototype.isEquivalent = function (stmt) { return stmt instanceof IfStmt && this.condition.isEquivalent(stmt.condition) && areAllEquivalent(this.trueCase, stmt.trueCase) && areAllEquivalent(this.falseCase, stmt.falseCase); }; IfStmt.prototype.visitStatement = function (visitor, context) { return visitor.visitIfStmt(this, context); }; return IfStmt; }(Statement)); var TryCatchStmt = /** @class */ (function (_super) { __extends(TryCatchStmt, _super); function TryCatchStmt(bodyStmts, catchStmts, sourceSpan, leadingComments) { if (sourceSpan === void 0) { sourceSpan = null; } var _this = _super.call(this, [], sourceSpan, leadingComments) || this; _this.bodyStmts = bodyStmts; _this.catchStmts = catchStmts; return _this; } TryCatchStmt.prototype.isEquivalent = function (stmt) { return stmt instanceof TryCatchStmt && areAllEquivalent(this.bodyStmts, stmt.bodyStmts) && areAllEquivalent(this.catchStmts, stmt.catchStmts); }; TryCatchStmt.prototype.visitStatement = function (visitor, context) { return visitor.visitTryCatchStmt(this, context); }; return TryCatchStmt; }(Statement)); var ThrowStmt = /** @class */ (function (_super) { __extends(ThrowStmt, _super); function ThrowStmt(error, sourceSpan, leadingComments) { if (sourceSpan === void 0) { sourceSpan = null; } var _this = _super.call(this, [], sourceSpan, leadingComments) || this; _this.error = error; return _this; } ThrowStmt.prototype.isEquivalent = function (stmt) { return stmt instanceof TryCatchStmt && this.error.isEquivalent(stmt.error); }; ThrowStmt.prototype.visitStatement = function (visitor, context) { return visitor.visitThrowStmt(this, context); }; return ThrowStmt; }(Statement)); var AstTransformer = /** @class */ (function () { function AstTransformer() { } AstTransformer.prototype.transformExpr = function (expr, context) { return expr; }; AstTransformer.prototype.transformStmt = function (stmt, context) { return stmt; }; AstTransformer.prototype.visitReadVarExpr = function (ast, context) { return this.transformExpr(ast, context); }; AstTransformer.prototype.visitWrappedNodeExpr = function (ast, context) { return this.transformExpr(ast, context); }; AstTransformer.prototype.visitTypeofExpr = function (expr, context) { return this.transformExpr(new TypeofExpr(expr.expr.visitExpression(this, context), expr.type, expr.sourceSpan), context); }; AstTransformer.prototype.visitWriteVarExpr = function (expr, context) { return this.transformExpr(new WriteVarExpr(expr.name, expr.value.visitExpression(this, context), expr.type, expr.sourceSpan), context); }; AstTransformer.prototype.visitWriteKeyExpr = function (expr, context) { 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); }; AstTransformer.prototype.visitWritePropExpr = function (expr, context) { return this.transformExpr(new WritePropExpr(expr.receiver.visitExpression(this, context), expr.name, expr.value.visitExpression(this, context), expr.type, expr.sourceSpan), context); }; AstTransformer.prototype.visitInvokeMethodExpr = function (ast, context) { var method = ast.builtin || ast.name; return this.transformExpr(new InvokeMethodExpr(ast.receiver.visitExpression(this, context), method, this.visitAllExpressions(ast.args, context), ast.type, ast.sourceSpan), context); }; AstTransformer.prototype.visitInvokeFunctionExpr = function (ast, context) { return this.transformExpr(new InvokeFunctionExpr(ast.fn.visitExpression(this, context), this.visitAllExpressions(ast.args, context), ast.type, ast.sourceSpan), context); }; AstTransformer.prototype.visitTaggedTemplateExpr = function (ast, context) { var _this = this; return this.transformExpr(new TaggedTemplateExpr(ast.tag.visitExpression(this, context), new TemplateLiteral(ast.template.elements, ast.template.expressions.map(function (e) { return e.visitExpression(_this, context); })), ast.type, ast.sourceSpan), context); }; AstTransformer.prototype.visitInstantiateExpr = function (ast, context) { return this.transformExpr(new InstantiateExpr(ast.classExpr.visitExpression(this, context), this.visitAllExpressions(ast.args, context), ast.type, ast.sourceSpan), context); }; AstTransformer.prototype.visitLiteralExpr = function (ast, context) { return this.transformExpr(ast, context); }; AstTransformer.prototype.visitLocalizedString = function (ast, context) { return this.transformExpr(new LocalizedString(ast.metaBlock, ast.messageParts, ast.placeHolderNames, this.visitAllExpressions(ast.expressions, context), ast.sourceSpan), context); }; AstTransformer.prototype.visitExternalExpr = function (ast, context) { return this.transformExpr(ast, context); }; AstTransformer.prototype.visitConditionalExpr = function (ast, context) { 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); }; AstTransformer.prototype.visitNotExpr = function (ast, context) { return this.transformExpr(new NotExpr(ast.condition.visitExpression(this, context), ast.sourceSpan), context); }; AstTransformer.prototype.visitAssertNotNullExpr = function (ast, context) { return this.transformExpr(new AssertNotNull(ast.condition.visitExpression(this, context), ast.sourceSpan), context); }; AstTransformer.prototype.visitCastExpr = function (ast, context) { return this.transformExpr(new CastExpr(ast.value.visitExpression(this, context), ast.type, ast.sourceSpan), context); }; AstTransformer.prototype.visitFunctionExpr = function (ast, context) { return this.transformExpr(new FunctionExpr(ast.params, this.visitAllStatements(ast.statements, context), ast.type, ast.sourceSpan), context); }; AstTransformer.prototype.visitUnaryOperatorExpr = function (ast, context) { return this.transformExpr(new UnaryOperatorExpr(ast.operator, ast.expr.visitExpression(this, context), ast.type, ast.sourceSpan), context); }; AstTransformer.prototype.visitBinaryOperatorExpr = function (ast, context) { return this.transformExpr(new BinaryOperatorExpr(ast.operator, ast.lhs.visitExpression(this, context), ast.rhs.visitExpression(this, context), ast.type, ast.sourceSpan), context); }; AstTransformer.prototype.visitReadPropExpr = function (ast, context) { return this.transformExpr(new ReadPropExpr(ast.receiver.visitExpression(this, context), ast.name, ast.type, ast.sourceSpan), context); }; AstTransformer.prototype.visitReadKeyExpr = function (ast, context) { return this.transformExpr(new ReadKeyExpr(ast.receiver.visitExpression(this, context), ast.index.visitExpression(this, context), ast.type, ast.sourceSpan), context); }; AstTransformer.prototype.visitLiteralArrayExpr = function (ast, context) { return this.transformExpr(new LiteralArrayExpr(this.visitAllExpressions(ast.entries, context), ast.type, ast.sourceSpan), context); }; AstTransformer.prototype.visitLiteralMapExpr = function (ast, context) { var _this = this; var entries = ast.entries.map(function (entry) { return new LiteralMapEntry(entry.key, entry.value.visitExpression(_this, context), entry.quoted); }); var mapType = new MapType(ast.valueType); return this.transformExpr(new LiteralMapExpr(entries, mapType, ast.sourceSpan), context); }; AstTransformer.prototype.visitCommaExpr = function (ast, context) { return this.transformExpr(new CommaExpr(this.visitAllExpressions(ast.parts, context), ast.sourceSpan), context); }; AstTransformer.prototype.visitAllExpressions = function (exprs, context) { var _this = this; return exprs.map(function (expr) { return expr.visitExpression(_this, context); }); }; AstTransformer.prototype.visitDeclareVarStmt = function (stmt, context) { var value = stmt.value && stmt.value.visitExpression(this, context); return this.transformStmt(new DeclareVarStmt(stmt.name, value, stmt.type, stmt.modifiers, stmt.sourceSpan, stmt.leadingComments), context); }; AstTransformer.prototype.visitDeclareFunctionStmt = function (stmt, context) { return this.transformStmt(new DeclareFunctionStmt(stmt.name, stmt.params, this.visitAllStatements(stmt.statements, context), stmt.type, stmt.modifiers, stmt.sourceSpan, stmt.leadingComments), context); }; AstTransformer.prototype.visitExpressionStmt = function (stmt, context) { return this.transformStmt(new ExpressionStatement(stmt.expr.visitExpression(this, context), stmt.sourceSpan, stmt.leadingComments), context); }; AstTransformer.prototype.visitReturnStmt = function (stmt, context) { return this.transformStmt(new ReturnStatement(stmt.value.visitExpression(this, context), stmt.sourceSpan, stmt.leadingComments), context); }; AstTransformer.prototype.visitDeclareClassStmt = function (stmt, context) { var _this = this; var parent = stmt.parent.visitExpression(this, context); var getters = stmt.getters.map(function (getter) { return new ClassGetter(getter.name, _this.visitAllStatements(getter.body, context), getter.type, getter.modifiers); }); var ctorMethod = stmt.constructorMethod && new ClassMethod(stmt.constructorMethod.name, stmt.constructorMethod.params, this.visitAllStatements(stmt.constructorMethod.body, context), stmt.constructorMethod.type, stmt.constructorMethod.modifiers); var methods = stmt.methods.map(function (method) { return new ClassMethod(method.name, method.params, _this.visitAllStatements(method.body, context), method.type, method.modifiers); }); return this.transformStmt(new ClassStmt(stmt.name, parent, stmt.fields, getters, ctorMethod, methods, stmt.modifiers, stmt.sourceSpan), context); }; AstTransformer.prototype.visitIfStmt = function (stmt, context) { return this.transformStmt(new IfStmt(stmt.condition.visitExpression(this, context), this.visitAllStatements(stmt.trueCase, context), this.visitAllStatements(stmt.falseCase, context), stmt.sourceSpan, stmt.leadingComments), context); }; AstTransformer.prototype.visitTryCatchStmt = function (stmt, context) { return this.transformStmt(new TryCatchStmt(this.visitAllStatements(stmt.bodyStmts, context), this.visitAllStatements(stmt.catchStmts, context), stmt.sourceSpan, stmt.leadingComments), context); }; AstTransformer.prototype.visitThrowStmt = function (stmt, context) { return this.transformStmt(new ThrowStmt(stmt.error.visitExpression(this, context), stmt.sourceSpan, stmt.leadingComments), context); }; AstTransformer.prototype.visitAllStatements = function (stmts, context) { var _this = this; return stmts.map(function (stmt) { return stmt.visitStatement(_this, context); }); }; return AstTransformer; }()); var RecursiveAstVisitor = /** @class */ (function () { function RecursiveAstVisitor() { } RecursiveAstVisitor.prototype.visitType = function (ast, context) { return ast; }; RecursiveAstVisitor.prototype.visitExpression = function (ast, context) { if (ast.type) { ast.type.visitType(this, context); } return ast; }; RecursiveAstVisitor.prototype.visitBuiltinType = function (type, context) { return this.visitType(type, context); }; RecursiveAstVisitor.prototype.visitExpressionType = function (type, context) { var _this = this; type.value.visitExpression(this, context); if (type.typeParams !== null) { type.typeParams.forEach(function (param) { return _this.visitType(param, context); }); } return this.visitType(type, context); }; RecursiveAstVisitor.prototype.visitArrayType = function (type, context) { return this.visitType(type, context); }; RecursiveAstVisitor.prototype.visitMapType = function (type, context) { return this.visitType(type, context); }; RecursiveAstVisitor.prototype.visitWrappedNodeExpr = function (ast, context) { return ast; }; RecursiveAstVisitor.prototype.visitTypeofExpr = function (ast, context) { return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitReadVarExpr = function (ast, context) { return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitWriteVarExpr = function (ast, context) { ast.value.visitExpression(this, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitWriteKeyExpr = function (ast, context) { ast.receiver.visitExpression(this, context); ast.index.visitExpression(this, context); ast.value.visitExpression(this, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitWritePropExpr = function (ast, context) { ast.receiver.visitExpression(this, context); ast.value.visitExpression(this, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitInvokeMethodExpr = function (ast, context) { ast.receiver.visitExpression(this, context); this.visitAllExpressions(ast.args, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitInvokeFunctionExpr = function (ast, context) { ast.fn.visitExpression(this, context); this.visitAllExpressions(ast.args, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitTaggedTemplateExpr = function (ast, context) { ast.tag.visitExpression(this, context); this.visitAllExpressions(ast.template.expressions, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitInstantiateExpr = function (ast, context) { ast.classExpr.visitExpression(this, context); this.visitAllExpressions(ast.args, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitLiteralExpr = function (ast, context) { return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitLocalizedString = function (ast, context) { return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitExternalExpr = function (ast, context) { var _this = this; if (ast.typeParams) { ast.typeParams.forEach(function (type) { return type.visitType(_this, context); }); } return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitConditionalExpr = function (ast, context) { ast.condition.visitExpression(this, context); ast.trueCase.visitExpression(this, context); ast.falseCase.visitExpression(this, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitNotExpr = function (ast, context) { ast.condition.visitExpression(this, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitAssertNotNullExpr = function (ast, context) { ast.condition.visitExpression(this, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitCastExpr = function (ast, context) { ast.value.visitExpression(this, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitFunctionExpr = function (ast, context) { this.visitAllStatements(ast.statements, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitUnaryOperatorExpr = function (ast, context) { ast.expr.visitExpression(this, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitBinaryOperatorExpr = function (ast, context) { ast.lhs.visitExpression(this, context); ast.rhs.visitExpression(this, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitReadPropExpr = function (ast, context) { ast.receiver.visitExpression(this, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitReadKeyExpr = function (ast, context) { ast.receiver.visitExpression(this, context); ast.index.visitExpression(this, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitLiteralArrayExpr = function (ast, context) { this.visitAllExpressions(ast.entries, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitLiteralMapExpr = function (ast, context) { var _this = this; ast.entries.forEach(function (entry) { return entry.value.visitExpression(_this, context); }); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitCommaExpr = function (ast, context) { this.visitAllExpressions(ast.parts, context); return this.visitExpression(ast, context); }; RecursiveAstVisitor.prototype.visitAllExpressions = function (exprs, context) { var _this = this; exprs.forEach(function (expr) { return expr.visitExpression(_this, context); }); }; RecursiveAstVisitor.prototype.visitDeclareVarStmt = function (stmt, context) { if (stmt.value) { stmt.value.visitExpression(this, context); } if (stmt.type) { stmt.type.visitType(this, context); } return stmt; }; RecursiveAstVisitor.prototype.visitDeclareFunctionStmt = function (stmt, context) { this.visitAllStatements(stmt.statements, context); if (stmt.type) { stmt.type.visitType(this, context); } return stmt; }; RecursiveAstVisitor.prototype.visitExpressionStmt = function (stmt, context) { stmt.expr.visitExpression(this, context); return stmt; }; RecursiveAstVisitor.prototype.visitReturnStmt = function (stmt, context) { stmt.value.visitExpression(this, context); return stmt; }; RecursiveAstVisitor.prototype.visitDeclareClassStmt = function (stmt, context) { var _this = this; stmt.parent.visitExpression(this, context); stmt.getters.forEach(function (getter) { return _this.visitAllStatements(getter.body, context); }); if (stmt.constructorMethod) { this.visitAllStatements(stmt.constructorMethod.body, context); } stmt.methods.forEach(function (method) { return _this.visitAllStatements(method.body, context); }); return stmt; }; RecursiveAstVisitor.prototype.visitIfStmt = function (stmt, context) { stmt.condition.visitExpression(this, context); this.visitAllStatements(stmt.trueCase, context); this.visitAllStatements(stmt.falseCase, context); return stmt; }; RecursiveAstVisitor.prototype.visitTryCatchStmt = function (stmt, context) { this.visitAllStatements(stmt.bodyStmts, context); this.visitAllStatements(stmt.catchStmts, context); return stmt; }; RecursiveAstVisitor.prototype.visitThrowStmt = function (stmt, context) { stmt.error.visitExpression(this, context); return stmt; }; RecursiveAstVisitor.prototype.visitAllStatements = function (stmts, context) { var _this = this; stmts.forEach(function (stmt) { return stmt.visitStatement(_this, context); }); }; return RecursiveAstVisitor; }()); function findReadVarNames(stmts) { var visitor = new _ReadVarVisitor(); visitor.visitAllStatements(stmts, null); return visitor.varNames; } var _ReadVarVisitor = /** @class */ (function (_super) { __extends(_ReadVarVisitor, _super); function _ReadVarVisitor() { var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this; _this.varNames = new Set(); return _this; } _ReadVarVisitor.prototype.visitDeclareFunctionStmt = function (stmt, context) { // Don't descend into nested functions return stmt; }; _ReadVarVisitor.prototype.visitDeclareClassStmt = function (stmt, context) { // Don't descend into nested classes return stmt; }; _ReadVarVisitor.prototype.visitReadVarExpr = function (ast, context) { if (ast.name) { this.varNames.add(ast.name); } return null; }; return _ReadVarVisitor; }(RecursiveAstVisitor)); function collectExternalReferences(stmts) { var visitor = new _FindExternalReferencesVisitor(); visitor.visitAllStatements(stmts, null); return visitor.externalReferences; } var _FindExternalReferencesVisitor = /** @class */ (function (_super) { __extends(_FindExternalReferencesVisitor, _super); function _FindExternalReferencesVisitor() { var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this; _this.externalReferences = []; return _this; } _FindExternalReferencesVisitor.prototype.visitExternalExpr = function (e, context) { this.externalReferences.push(e.value); return _super.prototype.visitExternalExpr.call(this, e, context); }; return _FindExternalReferencesVisitor; }(RecursiveAstVisitor)); function applySourceSpanToStatementIfNeeded(stmt, sourceSpan) { if (!sourceSpan) { return stmt; } var transformer = new _ApplySourceSpanTransformer(sourceSpan); return stmt.visitStatement(transformer, null); } function applySourceSpanToExpressionIfNeeded(expr, sourceSpan) { if (!sourceSpan) { return expr; } var transformer = new _ApplySourceSpanTransformer(sourceSpan); return expr.visitExpression(transformer, null); } var _ApplySourceSpanTransformer = /** @class */ (function (_super) { __extends(_ApplySourceSpanTransformer, _super); function _ApplySourceSpanTransformer(sourceSpan) { var _this = _super.call(this) || this; _this.sourceSpan = sourceSpan; return _this; } _ApplySourceSpanTransformer.prototype._clone = function (obj) { var e_1, _e; var clone = Object.create(obj.constructor.prototype); try { for (var _f = __values(Object.keys(obj)), _g = _f.next(); !_g.done; _g = _f.next()) { var prop = _g.value; clone[prop] = obj[prop]; } } catch (e_1_1) { e_1 = { error: e_1_1 }; } finally { try { if (_g && !_g.done && (_e = _f.return)) _e.call(_f); } finally { if (e_1) throw e_1.error; } } return clone; }; _ApplySourceSpanTransformer.prototype.transformExpr = function (expr, context) { if (!expr.sourceSpan) { expr = this._clone(expr); expr.sourceSpan = this.sourceSpan; } return expr; }; _ApplySourceSpanTransformer.prototype.transformStmt = function (stmt, context) { if (!stmt.sourceSpan) { stmt = this._clone(stmt); stmt.sourceSpan = this.sourceSpan; } return stmt; }; return _ApplySourceSpanTransformer; }(AstTransformer)); function leadingComment(text, multiline, trailingNewline) { if (multiline === void 0) { multiline = false; } if (trailingNewline === void 0) { trailingNewline = true; } return new LeadingComment(text, multiline, trailingNewline); } function jsDocComment(tags) { if (tags === void 0) { tags = []; } return new JSDocComment(tags); } function variable(name, type, sourceSpan) { return new ReadVarExpr(name, type, sourceSpan); } function importExpr(id, typeParams, sourceSpan) { if (typeParams === void 0) { typeParams = null; } return new ExternalExpr(id, null, typeParams, sourceSpan); } function importType(id, typeParams, typeModifiers) { return id != null ? expressionType(importExpr(id, typeParams, null), typeModifiers) : null; } function expressionType(expr, typeModifiers, typeParams) { return new ExpressionType(expr, typeModifiers, typeParams); } function typeofExpr(expr) { return new TypeofExpr(expr); } function literalArr(values, type, sourceSpan) { return new LiteralArrayExpr(values, type, sourceSpan); } function literalMap(values, type) { if (type === void 0) { type = null; } return new LiteralMapExpr(values.map(function (e) { return new LiteralMapEntry(e.key, e.value, e.quoted); }), type, null); } function unary(operator, expr, type, sourceSpan) { return new UnaryOperatorExpr(operator, expr, type, sourceSpan); } function not(expr, sourceSpan) { return new NotExpr(expr, sourceSpan); } function assertNotNull(expr, sourceSpan) { return new AssertNotNull(expr, sourceSpan); } function fn(params, body, type, sourceSpan, name) { return new FunctionExpr(params, body, type, sourceSpan, name); } function ifStmt(condition, thenClause, elseClause, sourceSpan, leadingComments) { return new IfStmt(condition, thenClause, elseClause, sourceSpan, leadingComments); } function taggedTemplate(tag, template, type, sourceSpan) { return new TaggedTemplateExpr(tag, template, type, sourceSpan); } function literal(value, type, sourceSpan) { return new LiteralExpr(value, type, sourceSpan); } function localizedString(metaBlock, messageParts, placeholderNames, expressions, sourceSpan) { return new LocalizedString(metaBlock, messageParts, placeholderNames, expressions, sourceSpan); } function isNull(exp) { return exp instanceof LiteralExpr && exp.value === null; } /* * Serializes a `Tag` into a string. * Returns a string like " @foo {bar} baz" (note the leading whitespace before `@foo`). */ function tagToString(tag) { var out = ''; if (tag.tagName) { out += " @" + tag.tagName; } if (tag.text) { if (tag.text.match(/\/\*|\*\//)) { throw new Error('JSDoc text cannot contain "/*" and "*/"'); } out += ' ' + tag.text.replace(/@/g, '\\@'); } return out; } function serializeTags(tags) { var e_2, _e; if (tags.length === 0) return ''; if (tags.length === 1 && tags[0].tagName && !tags[0].text) { // The JSDOC comment is a single simple tag: e.g `/** @tagname */`. return "*" + tagToString(tags[0]) + " "; } var out = '*\n'; try { for (var tags_1 = __values(tags), tags_1_1 = tags_1.next(); !tags_1_1.done; tags_1_1 = tags_1.next()) { var tag = tags_1_1.value; out += ' *'; // If the tagToString is multi-line, insert " * " prefixes on lines. out += tagToString(tag).replace(/\n/g, '\n * '); out += '\n'; } } catch (e_2_1) { e_2 = { error: e_2_1 }; } finally { try { if (tags_1_1 && !tags_1_1.done && (_e = tags_1.return)) _e.call(tags_1); } finally { if (e_2) throw e_2.error; } } out += ' '; return out; } var CONSTANT_PREFIX = '_c'; /** * `ConstantPool` tries to reuse literal factories when two or more literals are identical. * We determine whether literals are identical by creating a key out of their AST using the * `KeyVisitor`. This constant is used to replace dynamic expressions which can't be safely * converted into a key. E.g. given an expression `{foo: bar()}`, since we don't know what * the result of `bar` will be, we create a key that looks like `{foo: }`. Note * that we use a variable, rather than something like `null` in order to avoid collisions. */ var UNKNOWN_VALUE_KEY = variable(''); /** * Context to use when producing a key. * * This ensures we see the constant not the reference variable when producing * a key. */ var KEY_CONTEXT = {}; /** * Generally all primitive values are excluded from the `ConstantPool`, but there is an exclusion * for strings that reach a certain length threshold. This constant defines the length threshold for * strings. */ var POOL_INCLUSION_LENGTH_THRESHOLD_FOR_STRINGS = 50; /** * A node that is a place-holder that allows the node to be replaced when the actual * node is known. * * This allows the constant pool to change an expression from a direct reference to * a constant to a shared constant. It returns a fix-up node that is later allowed to * change the referenced expression. */ var FixupExpression = /** @class */ (function (_super) { __extends(FixupExpression, _super); function FixupExpression(resolved) { var _this = _super.call(this, resolved.type) || this; _this.resolved = resolved; _this.original = resolved; return _this; } FixupExpression.prototype.visitExpression = function (visitor, context) { if (context === KEY_CONTEXT) { // When producing a key we want to traverse the constant not the // variable used to refer to it. return this.original.visitExpression(visitor, context); } else { return this.resolved.visitExpression(visitor, context); } }; FixupExpression.prototype.isEquivalent = function (e) { return e instanceof FixupExpression && this.resolved.isEquivalent(e.resolved); }; FixupExpression.prototype.isConstant = function () { return true; }; FixupExpression.prototype.fixup = function (expression) { this.resolved = expression; this.shared = true; }; return FixupExpression; }(Expression)); /** * A constant pool allows a code emitter to share constant in an output context. * * The constant pool also supports sharing access to ivy definitions references. */ var ConstantPool = /** @class */ (function () { function ConstantPool(isClosureCompilerEnabled) { if (isClosureCompilerEnabled === void 0) { isClosureCompilerEnabled = false; } this.isClosureCompilerEnabled = isClosureCompilerEnabled; this.statements = []; this.literals = new Map(); this.literalFactories = new Map(); this.injectorDefinitions = new Map(); this.directiveDefinitions = new Map(); this.componentDefinitions = new Map(); this.pipeDefinitions = new Map(); this.nextNameIndex = 0; } ConstantPool.prototype.getConstLiteral = function (literal, forceShared) { if ((literal instanceof LiteralExpr && !isLongStringLiteral(literal)) || literal instanceof FixupExpression) { // Do no put simple literals into the constant pool or try to produce a constant for a // reference to a constant. return literal; } var key = this.keyOf(literal); var fixup = this.literals.get(key); var newValue = false; if (!fixup) { fixup = new FixupExpression(literal); this.literals.set(key, fixup); newValue = true; } if ((!newValue && !fixup.shared) || (newValue && forceShared)) { // Replace the expression with a variable var name = this.freshName(); var definition = void 0; var usage = void 0; if (this.isClosureCompilerEnabled && isLongStringLiteral(literal)) { // For string literals, Closure will **always** inline the string at // **all** usages, duplicating it each time. For large strings, this // unnecessarily bloats bundle size. To work around this restriction, we // wrap the string in a function, and call that function for each usage. // This tricks Closure into using inline logic for functions instead of // string literals. Function calls are only inlined if the body is small // enough to be worth it. By doing this, very large strings will be // shared across multiple usages, rather than duplicating the string at // each usage site. // // const myStr = function() { return "very very very long string"; }; // const usage1 = myStr(); // const usage2 = myStr(); definition = variable(name).set(new FunctionExpr([], // Params. [ // Statements. new ReturnStatement(literal), ])); usage = variable(name).callFn([]); } else { // Just declare and use the variable directly, without a function call // indirection. This saves a few bytes and avoids an unncessary call. definition = variable(name).set(literal); usage = variable(name); } this.statements.push(definition.toDeclStmt(INFERRED_TYPE, [exports.StmtModifier.Final])); fixup.fixup(usage); } return fixup; }; ConstantPool.prototype.getDefinition = function (type, kind, ctx, forceShared) { if (forceShared === void 0) { forceShared = false; } var definitions = this.definitionsOf(kind); var fixup = definitions.get(type); var newValue = false; if (!fixup) { var property = this.propertyNameOf(kind); fixup = new FixupExpression(ctx.importExpr(type).prop(property)); definitions.set(type, fixup); newValue = true; } if ((!newValue && !fixup.shared) || (newValue && forceShared)) { var name = this.freshName(); this.statements.push(variable(name).set(fixup.resolved).toDeclStmt(INFERRED_TYPE, [exports.StmtModifier.Final])); fixup.fixup(variable(name)); } return fixup; }; ConstantPool.prototype.getLiteralFactory = function (literal) { // Create a pure function that builds an array of a mix of constant and variable expressions if (literal instanceof LiteralArrayExpr) { var argumentsForKey = literal.entries.map(function (e) { return e.isConstant() ? e : UNKNOWN_VALUE_KEY; }); var key = this.keyOf(literalArr(argumentsForKey)); return this._getLiteralFactory(key, literal.entries, function (entries) { return literalArr(entries); }); } else { var expressionForKey = literalMap(literal.entries.map(function (e) { return ({ key: e.key, value: e.value.isConstant() ? e.value : UNKNOWN_VALUE_KEY, quoted: e.quoted }); })); var key = this.keyOf(expressionForKey); return this._getLiteralFactory(key, literal.entries.map(function (e) { return e.value; }), function (entries) { return literalMap(entries.map(function (value, index) { return ({ key: literal.entries[index].key, value: value, quoted: literal.entries[index].quoted }); })); }); } }; ConstantPool.prototype._getLiteralFactory = function (key, values, resultMap) { var _this = this; var literalFactory = this.literalFactories.get(key); var literalFactoryArguments = values.filter((function (e) { return !e.isConstant(); })); if (!literalFactory) { var resultExpressions = values.map(function (e, index) { return e.isConstant() ? _this.getConstLiteral(e, true) : variable("a" + index); }); var parameters = resultExpressions.filter(isVariable).map(function (e) { return new FnParam(e.name, DYNAMIC_TYPE); }); var pureFunctionDeclaration = fn(parameters, [new ReturnStatement(resultMap(resultExpressions))], INFERRED_TYPE); var name = this.freshName(); this.statements.push(variable(name).set(pureFunctionDeclaration).toDeclStmt(INFERRED_TYPE, [ exports.StmtModifier.Final ])); literalFactory = variable(name); this.literalFactories.set(key, literalFactory); } return { literalFactory: literalFactory, literalFactoryArguments: literalFactoryArguments }; }; /** * Produce a unique name. * * The name might be unique among different prefixes if any of the prefixes end in * a digit so the prefix should be a constant string (not based on user input) and * must not end in a digit. */ ConstantPool.prototype.uniqueName = function (prefix) { return "" + prefix + this.nextNameIndex++; }; ConstantPool.prototype.definitionsOf = function (kind) { switch (kind) { case 2 /* Component */: return this.componentDefinitions; case 1 /* Directive */: return this.directiveDefinitions; case 0 /* Injector */: return this.injectorDefinitions; case 3 /* Pipe */: return this.pipeDefinitions; } }; ConstantPool.prototype.propertyNameOf = function (kind) { switch (kind) { case 2 /* Component */: return 'ɵcmp'; case 1 /* Directive */: return 'ɵdir'; case 0 /* Injector */: return 'ɵinj'; case 3 /* Pipe */: return 'ɵpipe'; } }; ConstantPool.prototype.freshName = function () { return this.uniqueName(CONSTANT_PREFIX); }; ConstantPool.prototype.keyOf = function (expression) { return expression.visitExpression(new KeyVisitor(), KEY_CONTEXT); }; return ConstantPool; }()); /** * Visitor used to determine if 2 expressions are equivalent and can be shared in the * `ConstantPool`. * * When the id (string) generated by the visitor is equal, expressions are considered equivalent. */ var KeyVisitor = /** @class */ (function () { function KeyVisitor() { this.visitWrappedNodeExpr = invalid; this.visitWriteVarExpr = invalid; this.visitWriteKeyExpr = invalid; this.visitWritePropExpr = invalid; this.visitInvokeMethodExpr = invalid; this.visitInvokeFunctionExpr = invalid; this.visitTaggedTemplateExpr = invalid; this.visitInstantiateExpr = invalid; this.visitConditionalExpr = invalid; this.visitNotExpr = invalid; this.visitAssertNotNullExpr = invalid; this.visitCastExpr = invalid; this.visitFunctionExpr = invalid; this.visitUnaryOperatorExpr = invalid; this.visitBinaryOperatorExpr = invalid; this.visitReadPropExpr = invalid; this.visitReadKeyExpr = invalid; this.visitCommaExpr = invalid; this.visitLocalizedString = invalid; } KeyVisitor.prototype.visitLiteralExpr = function (ast) { return "" + (typeof ast.value === 'string' ? '"' + ast.value + '"' : ast.value); }; KeyVisitor.prototype.visitLiteralArrayExpr = function (ast, context) { var _this = this; return "[" + ast.entries.map(function (entry) { return entry.visitExpression(_this, context); }).join(',') + "]"; }; KeyVisitor.prototype.visitLiteralMapExpr = function (ast, context) { var _this = this; var mapKey = function (entry) { var quote = entry.quoted ? '"' : ''; return "" + quote + entry.key + quote; }; var mapEntry = function (entry) { return mapKey(entry) + ":" + entry.value.visitExpression(_this, context); }; return "{" + ast.entries.map(mapEntry).join(','); }; KeyVisitor.prototype.visitExternalExpr = function (ast) { return ast.value.moduleName ? "EX:" + ast.value.moduleName + ":" + ast.value.name : "EX:" + ast.value.runtime.name; }; KeyVisitor.prototype.visitReadVarExpr = function (node) { return "VAR:" + node.name; }; KeyVisitor.prototype.visitTypeofExpr = function (node, context) { return "TYPEOF:" + node.expr.visitExpression(this, context); }; return KeyVisitor; }()); function invalid(arg) { throw new Error("Invalid state: Visitor " + this.constructor.name + " doesn't handle " + arg.constructor.name); } function isVariable(e) { return e instanceof ReadVarExpr; } function isLongStringLiteral(expr) { return expr instanceof LiteralExpr && typeof expr.value === 'string' && expr.value.length >= POOL_INCLUSION_LENGTH_THRESHOLD_FOR_STRINGS; } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ var CORE = '@angular/core'; var Identifiers = /** @class */ (function () { function Identifiers() { } return Identifiers; }()); /* Methods */ Identifiers.NEW_METHOD = 'factory'; Identifiers.TRANSFORM_METHOD = 'transform'; Identifiers.PATCH_DEPS = 'patchedDeps'; Identifiers.core = { name: null, moduleName: CORE }; /* Instructions */ Identifiers.namespaceHTML = { name: 'ɵɵnamespaceHTML', moduleName: CORE }; Identifiers.namespaceMathML = { name: 'ɵɵnamespaceMathML', moduleName: CORE }; Identifiers.namespaceSVG = { name: 'ɵɵnamespaceSVG', moduleName: CORE }; Identifiers.element = { name: 'ɵɵelement', moduleName: CORE }; Identifiers.elementStart = { name: 'ɵɵelementStart', moduleName: CORE }; Identifiers.elementEnd = { name: 'ɵɵelementEnd', moduleName: CORE }; Identifiers.advance = { name: 'ɵɵadvance', moduleName: CORE }; Identifiers.syntheticHostProperty = { name: 'ɵɵsyntheticHostProperty', moduleName: CORE }; Identifiers.syntheticHostListener = { name: 'ɵɵsyntheticHostListener', moduleName: CORE }; Identifiers.attribute = { name: 'ɵɵattribute', moduleName: CORE }; Identifiers.attributeInterpolate1 = { name: 'ɵɵattributeInterpolate1', moduleName: CORE }; Identifiers.attributeInterpolate2 = { name: 'ɵɵattributeInterpolate2', moduleName: CORE }; Identifiers.attributeInterpolate3 = { name: 'ɵɵattributeInterpolate3', moduleName: CORE }; Identifiers.attributeInterpolate4 = { name: 'ɵɵattributeInterpolate4', moduleName: CORE }; Identifiers.attributeInterpolate5 = { name: 'ɵɵattributeInterpolate5', moduleName: CORE }; Identifiers.attributeInterpolate6 = { name: 'ɵɵattributeInterpolate6', moduleName: CORE }; Identifiers.attributeInterpolate7 = { name: 'ɵɵattributeInterpolate7', moduleName: CORE }; Identifiers.attributeInterpolate8 = { name: 'ɵɵattributeInterpolate8', moduleName: CORE }; Identifiers.attributeInterpolateV = { name: 'ɵɵattributeInterpolateV', moduleName: CORE }; Identifiers.classProp = { name: 'ɵɵclassProp', moduleName: CORE }; Identifiers.elementContainerStart = { name: 'ɵɵelementContainerStart', moduleName: CORE }; Identifiers.elementContainerEnd = { name: 'ɵɵelementContainerEnd', moduleName: CORE }; Identifiers.elementContainer = { name: 'ɵɵelementContainer', moduleName: CORE }; Identifiers.styleMap = { name: 'ɵɵstyleMap', moduleName: CORE }; Identifiers.styleMapInterpolate1 = { name: 'ɵɵstyleMapInterpolate1', moduleName: CORE }; Identifiers.styleMapInterpolate2 = { name: 'ɵɵstyleMapInterpolate2', moduleName: CORE }; Identifiers.styleMapInterpolate3 = { name: 'ɵɵstyleMapInterpolate3', moduleName: CORE }; Identifiers.styleMapInterpolate4 = { name: 'ɵɵstyleMapInterpolate4', moduleName: CORE }; Identifiers.styleMapInterpolate5 = { name: 'ɵɵstyleMapInterpolate5', moduleName: CORE }; Identifiers.styleMapInterpolate6 = { name: 'ɵɵstyleMapInterpolate6', moduleName: CORE }; Identifiers.styleMapInterpolate7 = { name: 'ɵɵstyleMapInterpolate7', moduleName: CORE }; Identifiers.styleMapInterpolate8 = { name: 'ɵɵstyleMapInterpolate8', moduleName: CORE }; Identifiers.styleMapInterpolateV = { name: 'ɵɵstyleMapInterpolateV', moduleName: CORE }; Identifiers.classMap = { name: 'ɵɵclassMap', moduleName: CORE }; Identifiers.classMapInterpolate1 = { name: 'ɵɵclassMapInterpolate1', moduleName: CORE }; Identifiers.classMapInterpolate2 = { name: 'ɵɵclassMapInterpolate2', moduleName: CORE }; Identifiers.classMapInterpolate3 = { name: 'ɵɵclassMapInterpolate3', moduleName: CORE }; Identifiers.classMapInterpolate4 = { name: 'ɵɵclassMapInterpolate4', moduleName: CORE }; Identifiers.classMapInterpolate5 = { name: 'ɵɵclassMapInterpolate5', moduleName: CORE }; Identifiers.classMapInterpolate6 = { name: 'ɵɵclassMapInterpolate6', moduleName: CORE }; Identifiers.classMapInterpolate7 = { name: 'ɵɵclassMapInterpolate7', moduleName: CORE }; Identifiers.classMapInterpolate8 = { name: 'ɵɵclassMapInterpolate8', moduleName: CORE }; Identifiers.classMapInterpolateV = { name: 'ɵɵclassMapInterpolateV', moduleName: CORE }; Identifiers.styleProp = { name: 'ɵɵstyleProp', moduleName: CORE }; Identifiers.stylePropInterpolate1 = { name: 'ɵɵstylePropInterpolate1', moduleName: CORE }; Identifiers.stylePropInterpolate2 = { name: 'ɵɵstylePropInterpolate2', moduleName: CORE }; Identifiers.stylePropInterpolate3 = { name: 'ɵɵstylePropInterpolate3', moduleName: CORE }; Identifiers.stylePropInterpolate4 = { name: 'ɵɵstylePropInterpolate4', moduleName: CORE }; Identifiers.stylePropInterpolate5 = { name: 'ɵɵstylePropInterpolate5', moduleName: CORE }; Identifiers.stylePropInterpolate6 = { name: 'ɵɵstylePropInterpolate6', moduleName: CORE }; Identifiers.stylePropInterpolate7 = { name: 'ɵɵstylePropInterpolate7', moduleName: CORE }; Identifiers.stylePropInterpolate8 = { name: 'ɵɵstylePropInterpolate8', moduleName: CORE }; Identifiers.stylePropInterpolateV = { name: 'ɵɵstylePropInterpolateV', moduleName: CORE }; Identifiers.nextContext = { name: 'ɵɵnextContext', moduleName: CORE }; Identifiers.templateCreate = { name: 'ɵɵtemplate', moduleName: CORE }; Identifiers.text = { name: 'ɵɵtext', moduleName: CORE }; Identifiers.enableBindings = { name: 'ɵɵenableBindings', moduleName: CORE }; Identifiers.disableBindings = { name: 'ɵɵdisableBindings', moduleName: CORE }; Identifiers.getCurrentView = { name: 'ɵɵgetCurrentView', moduleName: CORE }; Identifiers.textInterpolate = { name: 'ɵɵtextInterpolate', moduleName: CORE }; Identifiers.textInterpolate1 = { name: 'ɵɵtextInterpolate1', moduleName: CORE }; Identifiers.textInterpolate2 = { name: 'ɵɵtextInterpolate2', moduleName: CORE }; Identifiers.textInterpolate3 = { name: 'ɵɵtextInterpolate3', moduleName: CORE }; Identifiers.textInterpolate4 = { name: 'ɵɵtextInterpolate4', moduleName: CORE }; Identifiers.textInterpolate5 = { name: 'ɵɵtextInterpolate5', moduleName: CORE }; Identifiers.textInterpolate6 = { name: 'ɵɵtextInterpolate6', moduleName: CORE }; Identifiers.textInterpolate7 = { name: 'ɵɵtextInterpolate7', moduleName: CORE }; Identifiers.textInterpolate8 = { name: 'ɵɵtextInterpolate8', moduleName: CORE }; Identifiers.textInterpolateV = { name: 'ɵɵtextInterpolateV', moduleName: CORE }; Identifiers.restoreView = { name: 'ɵɵrestoreView', moduleName: CORE }; Identifiers.pureFunction0 = { name: 'ɵɵpureFunction0', moduleName: CORE }; Identifiers.pureFunction1 = { name: 'ɵɵpureFunction1', moduleName: CORE }; Identifiers.pureFunction2 = { name: 'ɵɵpureFunction2', moduleName: CORE }; Identifiers.pureFunction3 = { name: 'ɵɵpureFunction3', moduleName: CORE }; Identifiers.pureFunction4 = { name: 'ɵɵpureFunction4', moduleName: CORE }; Identifiers.pureFunction5 = { name: 'ɵɵpureFunction5', moduleName: CORE }; Identifiers.pureFunction6 = { name: 'ɵɵpureFunction6', moduleName: CORE }; Identifiers.pureFunction7 = { name: 'ɵɵpureFunction7', moduleName: CORE }; Identifiers.pureFunction8 = { name: 'ɵɵpureFunction8', moduleName: CORE }; Identifiers.pureFunctionV = { name: 'ɵɵpureFunctionV', moduleName: CORE }; Identifiers.pipeBind1 = { name: 'ɵɵpipeBind1', moduleName: CORE }; Identifiers.pipeBind2 = { name: 'ɵɵpipeBind2', moduleName: CORE }; Identifiers.pipeBind3 = { name: 'ɵɵpipeBind3', moduleName: CORE }; Identifiers.pipeBind4 = { name: 'ɵɵpipeBind4', moduleName: CORE }; Identifiers.pipeBindV = { name: 'ɵɵpipeBindV', moduleName: CORE }; Identifiers.hostProperty = { name: 'ɵɵhostProperty', moduleName: CORE }; Identifiers.property = { name: 'ɵɵproperty', moduleName: CORE }; Identifiers.propertyInterpolate = { name: 'ɵɵpropertyInterpolate', moduleName: CORE }; Identifiers.propertyInterpolate1 = { name: 'ɵɵpropertyInterpolate1', moduleName: CORE }; Identifiers.propertyInterpolate2 = { name: 'ɵɵpropertyInterpolate2', moduleName: CORE }; Identifiers.propertyInterpolate3 = { name: 'ɵɵpropertyInterpolate3', moduleName: CORE }; Identifiers.propertyInterpolate4 = { name: 'ɵɵpropertyInterpolate4', moduleName: CORE }; Identifiers.propertyInterpolate5 = { name: 'ɵɵpropertyInterpolate5', moduleName: CORE }; Identifiers.propertyInterpolate6 = { name: 'ɵɵpropertyInterpolate6', moduleName: CORE }; Identifiers.propertyInterpolate7 = { name: 'ɵɵpropertyInterpolate7', moduleName: CORE }; Identifiers.propertyInterpolate8 = { name: 'ɵɵpropertyInterpolate8', moduleName: CORE }; Identifiers.propertyInterpolateV = { name: 'ɵɵpropertyInterpolateV', moduleName: CORE }; Identifiers.i18n = { name: 'ɵɵi18n', moduleName: CORE }; Identifiers.i18nAttributes = { name: 'ɵɵi18nAttributes', moduleName: CORE }; Identifiers.i18nExp = { name: 'ɵɵi18nExp', moduleName: CORE }; Identifiers.i18nStart = { name: 'ɵɵi18nStart', moduleName: CORE }; Identifiers.i18nEnd = { name: 'ɵɵi18nEnd', moduleName: CORE }; Identifiers.i18nApply = { name: 'ɵɵi18nApply', moduleName: CORE }; Identifiers.i18nPostprocess = { name: 'ɵɵi18nPostprocess', moduleName: CORE }; Identifiers.pipe = { name: 'ɵɵpipe', moduleName: CORE }; Identifiers.projection = { name: 'ɵɵprojection', moduleName: CORE }; Identifiers.projectionDef = { name: 'ɵɵprojectionDef', moduleName: CORE }; Identifiers.reference = { name: 'ɵɵreference', moduleName: CORE }; Identifiers.inject = { name: 'ɵɵinject', moduleName: CORE }; Identifiers.injectAttribute = { name: 'ɵɵinjectAttribute', moduleName: CORE }; Identifiers.directiveInject = { name: 'ɵɵdirectiveInject', moduleName: CORE }; Identifiers.invalidFactory = { name: 'ɵɵinvalidFactory', moduleName: CORE }; Identifiers.invalidFactoryDep = { name: 'ɵɵinvalidFactoryDep', moduleName: CORE }; Identifiers.templateRefExtractor = { name: 'ɵɵtemplateRefExtractor', moduleName: CORE }; Identifiers.forwardRef = { name: 'forwardRef', moduleName: CORE }; Identifiers.resolveForwardRef = { name: 'resolveForwardRef', moduleName: CORE }; Identifiers.ɵɵdefineInjectable = { name: 'ɵɵdefineInjectable', moduleName: CORE }; Identifiers.declareInjectable = { name: 'ɵɵngDeclareInjectable', moduleName: CORE }; Identifiers.InjectableDeclaration = { name: 'ɵɵInjectableDeclaration', moduleName: CORE }; Identifiers.resolveWindow = { name: 'ɵɵresolveWindow', moduleName: CORE }; Identifiers.resolveDocument = { name: 'ɵɵresolveDocument', moduleName: CORE }; Identifiers.resolveBody = { name: 'ɵɵresolveBody', moduleName: CORE }; Identifiers.defineComponent = { name: 'ɵɵdefineComponent', moduleName: CORE }; Identifiers.declareComponent = { name: 'ɵɵngDeclareComponent', moduleName: CORE }; Identifiers.setComponentScope = { name: 'ɵɵsetComponentScope', moduleName: CORE }; Identifiers.ChangeDetectionStrategy = { name: 'ChangeDetectionStrategy', moduleName: CORE, }; Identifiers.ViewEncapsulation = { name: 'ViewEncapsulation', moduleName: CORE, }; Identifiers.ComponentDeclaration = { name: 'ɵɵComponentDeclaration', moduleName: CORE, }; Identifiers.FactoryDeclaration = { name: 'ɵɵFactoryDeclaration', moduleName: CORE, }; Identifiers.declareFactory = { name: 'ɵɵngDeclareFactory', moduleName: CORE }; Identifiers.FactoryTarget = { name: 'ɵɵFactoryTarget', moduleName: CORE }; Identifiers.defineDirective = { name: 'ɵɵdefineDirective', moduleName: CORE }; Identifiers.declareDirective = { name: 'ɵɵngDeclareDirective', moduleName: CORE }; Identifiers.DirectiveDeclaration = { name: 'ɵɵDirectiveDeclaration', moduleName: CORE, }; Identifiers.InjectorDef = { name: 'ɵɵInjectorDef', moduleName: CORE }; Identifiers.InjectorDeclaration = { name: 'ɵɵInjectorDeclaration', moduleName: CORE }; Identifiers.defineInjector = { name: 'ɵɵdefineInjector', moduleName: CORE }; Identifiers.declareInjector = { name: 'ɵɵngDeclareInjector', moduleName: CORE }; Identifiers.NgModuleDeclaration = { name: 'ɵɵNgModuleDeclaration', moduleName: CORE, }; Identifiers.ModuleWithProviders = { name: 'ModuleWithProviders', moduleName: CORE, }; Identifiers.defineNgModule = { name: 'ɵɵdefineNgModule', moduleName: CORE }; Identifiers.declareNgModule = { name: 'ɵɵngDeclareNgModule', moduleName: CORE }; Identifiers.setNgModuleScope = { name: 'ɵɵsetNgModuleScope', moduleName: CORE }; Identifiers.PipeDeclaration = { name: 'ɵɵPipeDeclaration', moduleName: CORE }; Identifiers.definePipe = { name: 'ɵɵdefinePipe', moduleName: CORE }; Identifiers.declarePipe = { name: 'ɵɵngDeclarePipe', moduleName: CORE }; Identifiers.declareClassMetadata = { name: 'ɵɵngDeclareClassMetadata', moduleName: CORE }; Identifiers.setClassMetadata = { name: 'ɵsetClassMetadata', moduleName: CORE }; Identifiers.queryRefresh = { name: 'ɵɵqueryRefresh', moduleName: CORE }; Identifiers.viewQuery = { name: 'ɵɵviewQuery', moduleName: CORE }; Identifiers.loadQuery = { name: 'ɵɵloadQuery', moduleName: CORE }; Identifiers.contentQuery = { name: 'ɵɵcontentQuery', moduleName: CORE }; Identifiers.NgOnChangesFeature = { name: 'ɵɵNgOnChangesFeature', moduleName: CORE }; Identifiers.InheritDefinitionFeature = { name: 'ɵɵInheritDefinitionFeature', moduleName: CORE }; Identifiers.CopyDefinitionFeature = { name: 'ɵɵCopyDefinitionFeature', moduleName: CORE }; Identifiers.ProvidersFeature = { name: 'ɵɵProvidersFeature', moduleName: CORE }; Identifiers.listener = { name: 'ɵɵlistener', moduleName: CORE }; Identifiers.getInheritedFactory = { name: 'ɵɵgetInheritedFactory', moduleName: CORE, }; // sanitization-related functions Identifiers.sanitizeHtml = { name: 'ɵɵsanitizeHtml', moduleName: CORE }; Identifiers.sanitizeStyle = { name: 'ɵɵsanitizeStyle', moduleName: CORE }; Identifiers.sanitizeResourceUrl = { name: 'ɵɵsanitizeResourceUrl', moduleName: CORE }; Identifiers.sanitizeScript = { name: 'ɵɵsanitizeScript', moduleName: CORE }; Identifiers.sanitizeUrl = { name: 'ɵɵsanitizeUrl', moduleName: CORE }; Identifiers.sanitizeUrlOrResourceUrl = { name: 'ɵɵsanitizeUrlOrResourceUrl', moduleName: CORE }; Identifiers.trustConstantHtml = { name: 'ɵɵtrustConstantHtml', moduleName: CORE }; Identifiers.trustConstantResourceUrl = { name: 'ɵɵtrustConstantResourceUrl', moduleName: CORE }; Identifiers.validateIframeAttribute = { name: 'ɵɵvalidateIframeAttribute', moduleName: CORE }; /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ var DASH_CASE_REGEXP = /-+([a-z0-9])/g; function dashCaseToCamelCase(input) { return input.replace(DASH_CASE_REGEXP, function () { var m = []; for (var _i = 0; _i < arguments.length; _i++) { m[_i] = arguments[_i]; } return m[1].toUpperCase(); }); } function splitAtColon(input, defaultValues) { return _splitAt(input, ':', defaultValues); } function splitAtPeriod(input, defaultValues) { return _splitAt(input, '.', defaultValues); } function _splitAt(input, character, defaultValues) { var characterIndex = input.indexOf(character); if (characterIndex == -1) return defaultValues; return [input.slice(0, characterIndex).trim(), input.slice(characterIndex + 1).trim()]; } function visitValue(value, visitor, context) { if (Array.isArray(value)) { return visitor.visitArray(value, context); } if (isStrictStringMap(value)) { return visitor.visitStringMap(value, context); } if (value == null || typeof value == 'string' || typeof value == 'number' || typeof value == 'boolean') { return visitor.visitPrimitive(value, context); } return visitor.visitOther(value, context); } function isDefined(val) { return val !== null && val !== undefined; } function noUndefined(val) { return val === undefined ? null : val; } var ValueTransformer = /** @class */ (function () { function ValueTransformer() { } ValueTransformer.prototype.visitArray = function (arr, context) { var _this = this; return arr.map(function (value) { return visitValue(value, _this, context); }); }; ValueTransformer.prototype.visitStringMap = function (map, context) { var _this = this; var result = {}; Object.keys(map).forEach(function (key) { result[key] = visitValue(map[key], _this, context); }); return result; }; ValueTransformer.prototype.visitPrimitive = function (value, context) { return value; }; ValueTransformer.prototype.visitOther = function (value, context) { return value; }; return ValueTransformer; }()); var SyncAsync = { assertSync: function (value) { if (isPromise(value)) { throw new Error("Illegal state: value cannot be a promise"); } return value; }, then: function (value, cb) { return isPromise(value) ? value.then(cb) : cb(value); }, all: function (syncAsyncValues) { return syncAsyncValues.some(isPromise) ? Promise.all(syncAsyncValues) : syncAsyncValues; } }; function error(msg) { throw new Error("Internal Error: " + msg); } // Escape characters that have a special meaning in Regular Expressions function escapeRegExp(s) { return s.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1'); } var STRING_MAP_PROTO = Object.getPrototypeOf({}); function isStrictStringMap(obj) { return typeof obj === 'object' && obj !== null && Object.getPrototypeOf(obj) === STRING_MAP_PROTO; } function utf8Encode(str) { var encoded = []; for (var index = 0; index < str.length; index++) { var codePoint = str.charCodeAt(index); // decode surrogate // see https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae if (codePoint >= 0xd800 && codePoint <= 0xdbff && str.length > (index + 1)) { var low = str.charCodeAt(index + 1); if (low >= 0xdc00 && low <= 0xdfff) { index++; codePoint = ((codePoint - 0xd800) << 10) + low - 0xdc00 + 0x10000; } } if (codePoint <= 0x7f) { encoded.push(codePoint); } else if (codePoint <= 0x7ff) { encoded.push(((codePoint >> 6) & 0x1F) | 0xc0, (codePoint & 0x3f) | 0x80); } else if (codePoint <= 0xffff) { encoded.push((codePoint >> 12) | 0xe0, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80); } else if (codePoint <= 0x1fffff) { encoded.push(((codePoint >> 18) & 0x07) | 0xf0, ((codePoint >> 12) & 0x3f) | 0x80, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80); } } return encoded; } function stringify(token) { if (typeof token === 'string') { return token; } if (Array.isArray(token)) { return '[' + token.map(stringify).join(', ') + ']'; } if (token == null) { return '' + token; } if (token.overriddenName) { return "" + token.overriddenName; } if (token.name) { return "" + token.name; } if (!token.toString) { return 'object'; } // WARNING: do not try to `JSON.stringify(token)` here // see https://github.com/angular/angular/issues/23440 var res = token.toString(); if (res == null) { return '' + res; } var newLineIndex = res.indexOf('\n'); return newLineIndex === -1 ? res : res.substring(0, newLineIndex); } /** * Lazily retrieves the reference value from a forwardRef. */ function resolveForwardRef(type) { if (typeof type === 'function' && type.hasOwnProperty('__forward_ref__')) { return type(); } else { return type; } } /** * Determine if the argument is shaped like a Promise */ function isPromise(obj) { // allow any Promise/A+ compliant thenable. // It's up to the caller to ensure that obj.then conforms to the spec return !!obj && typeof obj.then === 'function'; } var Version = /** @class */ (function () { function Version(full) { this.full = full; var splits = full.split('.'); this.major = splits[0]; this.minor = splits[1]; this.patch = splits.slice(2).join('.'); } return Version; }()); var __window = typeof window !== 'undefined' && window; var __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope && self; var __global = typeof global !== 'undefined' && global; // Check __global first, because in Node tests both __global and __window may be defined and _global // should be __global in that case. var _global = __global || __window || __self; function newArray(size, value) { var list = []; for (var i = 0; i < size; i++) { list.push(value); } return list; } /** * Partitions a given array into 2 arrays, based on a boolean value returned by the condition * function. * * @param arr Input array that should be partitioned * @param conditionFn Condition function that is called for each item in a given array and returns a * boolean value. */ function partitionArray(arr, conditionFn) { var e_1, _a; var truthy = []; var falsy = []; try { for (var arr_1 = __values(arr), arr_1_1 = arr_1.next(); !arr_1_1.done; arr_1_1 = arr_1.next()) { var item = arr_1_1.value; (conditionFn(item) ? truthy : falsy).push(item); } } catch (e_1_1) { e_1 = { error: e_1_1 }; } finally { try { if (arr_1_1 && !arr_1_1.done && (_a = arr_1.return)) _a.call(arr_1); } finally { if (e_1) throw e_1.error; } } return [truthy, falsy]; } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ // https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit var VERSION = 3; var JS_B64_PREFIX = '# sourceMappingURL=data:application/json;base64,'; var SourceMapGenerator = /** @class */ (function () { function SourceMapGenerator(file) { if (file === void 0) { file = null; } this.file = file; this.sourcesContent = new Map(); this.lines = []; this.lastCol0 = 0; this.hasMappings = false; } // The content is `null` when the content is expected to be loaded using the URL SourceMapGenerator.prototype.addSource = function (url, content) { if (content === void 0) { content = null; } if (!this.sourcesContent.has(url)) { this.sourcesContent.set(url, content); } return this; }; SourceMapGenerator.prototype.addLine = function () { this.lines.push([]); this.lastCol0 = 0; return this; }; SourceMapGenerator.prototype.addMapping = function (col0, sourceUrl, sourceLine0, sourceCol0) { if (!this.currentLine) { throw new Error("A line must be added before mappings can be added"); } if (sourceUrl != null && !this.sourcesContent.has(sourceUrl)) { throw new Error("Unknown source file \"" + sourceUrl + "\""); } if (col0 == null) { throw new Error("The column in the generated code must be provided"); } if (col0 < this.lastCol0) { throw new Error("Mapping should be added in output order"); } if (sourceUrl && (sourceLine0 == null || sourceCol0 == null)) { throw new Error("The source location must be provided when a source url is provided"); } this.hasMappings = true; this.lastCol0 = col0; this.currentLine.push({ col0: col0, sourceUrl: sourceUrl, sourceLine0: sourceLine0, sourceCol0: sourceCol0 }); return this; }; Object.defineProperty(SourceMapGenerator.prototype, "currentLine", { /** * @internal strip this from published d.ts files due to * https://github.com/microsoft/TypeScript/issues/36216 */ get: function () { return this.lines.slice(-1)[0]; }, enumerable: false, configurable: true }); SourceMapGenerator.prototype.toJSON = function () { var _this = this; if (!this.hasMappings) { return null; } var sourcesIndex = new Map(); var sources = []; var sourcesContent = []; Array.from(this.sourcesContent.keys()).forEach(function (url, i) { sourcesIndex.set(url, i); sources.push(url); sourcesContent.push(_this.sourcesContent.get(url) || null); }); var mappings = ''; var lastCol0 = 0; var lastSourceIndex = 0; var lastSourceLine0 = 0; var lastSourceCol0 = 0; this.lines.forEach(function (segments) { lastCol0 = 0; mappings += segments .map(function (segment) { // zero-based starting column of the line in the generated code var segAsStr = toBase64VLQ(segment.col0 - lastCol0); lastCol0 = segment.col0; if (segment.sourceUrl != null) { // zero-based index into the “sources” list segAsStr += toBase64VLQ(sourcesIndex.get(segment.sourceUrl) - lastSourceIndex); lastSourceIndex = sourcesIndex.get(segment.sourceUrl); // the zero-based starting line in the original source segAsStr += toBase64VLQ(segment.sourceLine0 - lastSourceLine0); lastSourceLine0 = segment.sourceLine0; // the zero-based starting column in the original source segAsStr += toBase64VLQ(segment.sourceCol0 - lastSourceCol0); lastSourceCol0 = segment.sourceCol0; } return segAsStr; }) .join(','); mappings += ';'; }); mappings = mappings.slice(0, -1); return { 'file': this.file || '', 'version': VERSION, 'sourceRoot': '', 'sources': sources, 'sourcesContent': sourcesContent, 'mappings': mappings, }; }; SourceMapGenerator.prototype.toJsComment = function () { return this.hasMappings ? '//' + JS_B64_PREFIX + toBase64String(JSON.stringify(this, null, 0)) : ''; }; return SourceMapGenerator; }()); function toBase64String(value) { var b64 = ''; var encoded = utf8Encode(value); for (var i = 0; i < encoded.length;) { var i1 = encoded[i++]; var i2 = i < encoded.length ? encoded[i++] : null; var i3 = i < encoded.length ? encoded[i++] : null; b64 += toBase64Digit(i1 >> 2); b64 += toBase64Digit(((i1 & 3) << 4) | (i2 === null ? 0 : i2 >> 4)); b64 += i2 === null ? '=' : toBase64Digit(((i2 & 15) << 2) | (i3 === null ? 0 : i3 >> 6)); b64 += i2 === null || i3 === null ? '=' : toBase64Digit(i3 & 63); } return b64; } function toBase64VLQ(value) { value = value < 0 ? ((-value) << 1) + 1 : value << 1; var out = ''; do { var digit = value & 31; value = value >> 5; if (value > 0) { digit = digit | 32; } out += toBase64Digit(digit); } while (value > 0); return out; } var B64_DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; function toBase64Digit(value) { if (value < 0 || value >= 64) { throw new Error("Can only encode value in the range [0, 63]"); } return B64_DIGITS[value]; } var _SINGLE_QUOTE_ESCAPE_STRING_RE = /'|\\|\n|\r|\$/g; var _LEGAL_IDENTIFIER_RE = /^[$A-Z_][0-9A-Z_$]*$/i; var _INDENT_WITH = ' '; var CATCH_ERROR_VAR$1 = variable('error', null, null); var CATCH_STACK_VAR$1 = variable('stack', null, null); var _EmittedLine = /** @class */ (function () { function _EmittedLine(indent) { this.indent = indent; this.partsLength = 0; this.parts = []; this.srcSpans = []; } return _EmittedLine; }()); var EmitterVisitorContext = /** @class */ (function () { function EmitterVisitorContext(_indent) { this._indent = _indent; this._classes = []; this._preambleLineCount = 0; this._lines = [new _EmittedLine(_indent)]; } EmitterVisitorContext.createRoot = function () { return new EmitterVisitorContext(0); }; Object.defineProperty(EmitterVisitorContext.prototype, "_currentLine", { /** * @internal strip this from published d.ts files due to * https://github.com/microsoft/TypeScript/issues/36216 */ get: function () { return this._lines[this._lines.length - 1]; }, enumerable: false, configurable: true }); EmitterVisitorContext.prototype.println = function (from, lastPart) { if (lastPart === void 0) { lastPart = ''; } this.print(from || null, lastPart, true); }; EmitterVisitorContext.prototype.lineIsEmpty = function () { return this._currentLine.parts.length === 0; }; EmitterVisitorContext.prototype.lineLength = function () { return this._currentLine.indent * _INDENT_WITH.length + this._currentLine.partsLength; }; EmitterVisitorContext.prototype.print = function (from, part, newLine) { if (newLine === void 0) { newLine = false; } if (part.length > 0) { this._currentLine.parts.push(part); this._currentLine.partsLength += part.length; this._currentLine.srcSpans.push(from && from.sourceSpan || null); } if (newLine) { this._lines.push(new _EmittedLine(this._indent)); } }; EmitterVisitorContext.prototype.removeEmptyLastLine = function () { if (this.lineIsEmpty()) { this._lines.pop(); } }; EmitterVisitorContext.prototype.incIndent = function () { this._indent++; if (this.lineIsEmpty()) { this._currentLine.indent = this._indent; } }; EmitterVisitorContext.prototype.decIndent = function () { this._indent--; if (this.lineIsEmpty()) { this._currentLine.indent = this._indent; } }; EmitterVisitorContext.prototype.pushClass = function (clazz) { this._classes.push(clazz); }; EmitterVisitorContext.prototype.popClass = function () { return this._classes.pop(); }; Object.defineProperty(EmitterVisitorContext.prototype, "currentClass", { get: function () { return this._classes.length > 0 ? this._classes[this._classes.length - 1] : null; }, enumerable: false, configurable: true }); EmitterVisitorContext.prototype.toSource = function () { return this.sourceLines .map(function (l) { return l.parts.length > 0 ? _createIndent(l.indent) + l.parts.join('') : ''; }) .join('\n'); }; EmitterVisitorContext.prototype.toSourceMapGenerator = function (genFilePath, startsAtLine) { if (startsAtLine === void 0) { startsAtLine = 0; } var map = new SourceMapGenerator(genFilePath); var firstOffsetMapped = false; var mapFirstOffsetIfNeeded = function () { if (!firstOffsetMapped) { // Add a single space so that tools won't try to load the file from disk. // Note: We are using virtual urls like `ng:///`, so we have to // provide a content here. map.addSource(genFilePath, ' ').addMapping(0, genFilePath, 0, 0); firstOffsetMapped = true; } }; for (var i = 0; i < startsAtLine; i++) { map.addLine(); mapFirstOffsetIfNeeded(); } this.sourceLines.forEach(function (line, lineIdx) { map.addLine(); var spans = line.srcSpans; var parts = line.parts; var col0 = line.indent * _INDENT_WITH.length; var spanIdx = 0; // skip leading parts without source spans while (spanIdx < spans.length && !spans[spanIdx]) { col0 += parts[spanIdx].length; spanIdx++; } if (spanIdx < spans.length && lineIdx === 0 && col0 === 0) { firstOffsetMapped = true; } else { mapFirstOffsetIfNeeded(); } while (spanIdx < spans.length) { var span = spans[spanIdx]; var source = span.start.file; var sourceLine = span.start.line; var sourceCol = span.start.col; map.addSource(source.url, source.content) .addMapping(col0, source.url, sourceLine, sourceCol); col0 += parts[spanIdx].length; spanIdx++; // assign parts without span or the same span to the previous segment while (spanIdx < spans.length && (span === spans[spanIdx] || !spans[spanIdx])) { col0 += parts[spanIdx].length; spanIdx++; } } }); return map; }; EmitterVisitorContext.prototype.setPreambleLineCount = function (count) { return this._preambleLineCount = count; }; EmitterVisitorContext.prototype.spanOf = function (line, column) { var emittedLine = this._lines[line - this._preambleLineCount]; if (emittedLine) { var columnsLeft = column - _createIndent(emittedLine.indent).length; for (var partIndex = 0; partIndex < emittedLine.parts.length; partIndex++) { var part = emittedLine.parts[partIndex]; if (part.length > columnsLeft) { return emittedLine.srcSpans[partIndex]; } columnsLeft -= part.length; } } return null; }; Object.defineProperty(EmitterVisitorContext.prototype, "sourceLines", { /** * @internal strip this from published d.ts files due to * https://github.com/microsoft/TypeScript/issues/36216 */ get: function () { if (this._lines.length && this._lines[this._lines.length - 1].parts.length === 0) { return this._lines.slice(0, -1); } return this._lines; }, enumerable: false, configurable: true }); return EmitterVisitorContext; }()); var AbstractEmitterVisitor = /** @class */ (function () { function AbstractEmitterVisitor(_escapeDollarInStrings) { this._escapeDollarInStrings = _escapeDollarInStrings; } AbstractEmitterVisitor.prototype.printLeadingComments = function (stmt, ctx) { var e_1, _a; if (stmt.leadingComments === undefined) { return; } try { for (var _b = __values(stmt.leadingComments), _c = _b.next(); !_c.done; _c = _b.next()) { var comment = _c.value; if (comment instanceof JSDocComment) { ctx.print(stmt, "/*" + comment.toString() + "*/", comment.trailingNewline); } else { if (comment.multiline) { ctx.print(stmt, "/* " + comment.text + " */", comment.trailingNewline); } else { comment.text.split('\n').forEach(function (line) { ctx.println(stmt, "// " + line); }); } } } } catch (e_1_1) { e_1 = { error: e_1_1 }; } finally { try { if (_c && !_c.done && (_a = _b.return)) _a.call(_b); } finally { if (e_1) throw e_1.error; } } }; AbstractEmitterVisitor.prototype.visitExpressionStmt = function (stmt, ctx) { this.printLeadingComments(stmt, ctx); stmt.expr.visitExpression(this, ctx); ctx.println(stmt, ';'); return null; }; AbstractEmitterVisitor.prototype.visitReturnStmt = function (stmt, ctx) { this.printLeadingComments(stmt, ctx); ctx.print(stmt, "return "); stmt.value.visitExpression(this, ctx); ctx.println(stmt, ';'); return null; }; AbstractEmitterVisitor.prototype.visitIfStmt = function (stmt, ctx) { this.printLeadingComments(stmt, ctx); ctx.print(stmt, "if ("); stmt.condition.visitExpression(this, ctx); ctx.print(stmt, ") {"); var hasElseCase = stmt.falseCase != null && stmt.falseCase.length > 0; if (stmt.trueCase.length <= 1 && !hasElseCase) { ctx.print(stmt, " "); this.visitAllStatements(stmt.trueCase, ctx); ctx.removeEmptyLastLine(); ctx.print(stmt, " "); } else { ctx.println(); ctx.incIndent(); this.visitAllStatements(stmt.trueCase, ctx); ctx.decIndent(); if (hasElseCase) { ctx.println(stmt, "} else {"); ctx.incIndent(); this.visitAllStatements(stmt.falseCase, ctx); ctx.decIndent(); } } ctx.println(stmt, "}"); return null; }; AbstractEmitterVisitor.prototype.visitThrowStmt = function (stmt, ctx) { this.printLeadingComments(stmt, ctx); ctx.print(stmt, "throw "); stmt.error.visitExpression(this, ctx); ctx.println(stmt, ";"); return null; }; AbstractEmitterVisitor.prototype.visitWriteVarExpr = function (expr, ctx) { var lineWasEmpty = ctx.lineIsEmpty(); if (!lineWasEmpty) { ctx.print(expr, '('); } ctx.print(expr, expr.name + " = "); expr.value.visitExpression(this, ctx); if (!lineWasEmpty) { ctx.print(expr, ')'); } return null; }; AbstractEmitterVisitor.prototype.visitWriteKeyExpr = function (expr, ctx) { var lineWasEmpty = ctx.lineIsEmpty(); if (!lineWasEmpty) { ctx.print(expr, '('); } expr.receiver.visitExpression(this, ctx); ctx.print(expr, "["); expr.index.visitExpression(this, ctx); ctx.print(expr, "] = "); expr.value.visitExpression(this, ctx); if (!lineWasEmpty) { ctx.print(expr, ')'); } return null; }; AbstractEmitterVisitor.prototype.visitWritePropExpr = function (expr, ctx) { var lineWasEmpty = ctx.lineIsEmpty(); if (!lineWasEmpty) { ctx.print(expr, '('); } expr.receiver.visitExpression(this, ctx); ctx.print(expr, "." + expr.name + " = "); expr.value.visitExpression(this, ctx); if (!lineWasEmpty) { ctx.print(expr, ')'); } return null; }; AbstractEmitterVisitor.prototype.visitInvokeMethodExpr = function (expr, ctx) { expr.receiver.visitExpression(this, ctx); var name = expr.name; if (expr.builtin != null) { name = this.getBuiltinMethodName(expr.builtin); if (name == null) { // some builtins just mean to skip the call. return null; } } ctx.print(expr, "." + name + "("); this.visitAllExpressions(expr.args, ctx, ","); ctx.print(expr, ")"); return null; }; AbstractEmitterVisitor.prototype.visitInvokeFunctionExpr = function (expr, ctx) { expr.fn.visitExpression(this, ctx); ctx.print(expr, "("); this.visitAllExpressions(expr.args, ctx, ','); ctx.print(expr, ")"); return null; }; AbstractEmitterVisitor.prototype.visitTaggedTemplateExpr = function (expr, ctx) { expr.tag.visitExpression(this, ctx); ctx.print(expr, '`' + expr.template.elements[0].rawText); for (var i = 1; i < expr.template.elements.length; i++) { ctx.print(expr, '${'); expr.template.expressions[i - 1].visitExpression(this, ctx); ctx.print(expr, "}" + expr.template.elements[i].rawText); } ctx.print(expr, '`'); return null; }; AbstractEmitterVisitor.prototype.visitWrappedNodeExpr = function (ast, ctx) { throw new Error('Abstract emitter cannot visit WrappedNodeExpr.'); }; AbstractEmitterVisitor.prototype.visitTypeofExpr = function (expr, ctx) { ctx.print(expr, 'typeof '); expr.expr.visitExpression(this, ctx); }; AbstractEmitterVisitor.prototype.visitReadVarExpr = function (ast, ctx) { var varName = ast.name; if (ast.builtin != null) { switch (ast.builtin) { case exports.BuiltinVar.Super: varName = 'super'; break; case exports.BuiltinVar.This: varName = 'this'; break; case exports.BuiltinVar.CatchError: varName = CATCH_ERROR_VAR$1.name; break; case exports.BuiltinVar.CatchStack: varName = CATCH_STACK_VAR$1.name; break; default: throw new Error("Unknown builtin variable " + ast.builtin); } } ctx.print(ast, varName); return null; }; AbstractEmitterVisitor.prototype.visitInstantiateExpr = function (ast, ctx) { ctx.print(ast, "new "); ast.classExpr.visitExpression(this, ctx); ctx.print(ast, "("); this.visitAllExpressions(ast.args, ctx, ','); ctx.print(ast, ")"); return null; }; AbstractEmitterVisitor.prototype.visitLiteralExpr = function (ast, ctx) { var value = ast.value; if (typeof value === 'string') { ctx.print(ast, escapeIdentifier(value, this._escapeDollarInStrings)); } else { ctx.print(ast, "" + value); } return null; }; AbstractEmitterVisitor.prototype.visitLocalizedString = function (ast, ctx) { var head = ast.serializeI18nHead(); ctx.print(ast, '$localize `' + head.raw); for (var i = 1; i < ast.messageParts.length; i++) { ctx.print(ast, '${'); ast.expressions[i - 1].visitExpression(this, ctx); ctx.print(ast, "}" + ast.serializeI18nTemplatePart(i).raw); } ctx.print(ast, '`'); return null; }; AbstractEmitterVisitor.prototype.visitConditionalExpr = function (ast, ctx) { ctx.print(ast, "("); ast.condition.visitExpression(this, ctx); ctx.print(ast, '? '); ast.trueCase.visitExpression(this, ctx); ctx.print(ast, ': '); ast.falseCase.visitExpression(this, ctx); ctx.print(ast, ")"); return null; }; AbstractEmitterVisitor.prototype.visitNotExpr = function (ast, ctx) { ctx.print(ast, '!'); ast.condition.visitExpression(this, ctx); return null; }; AbstractEmitterVisitor.prototype.visitAssertNotNullExpr = function (ast, ctx) { ast.condition.visitExpression(this, ctx); return null; }; AbstractEmitterVisitor.prototype.visitUnaryOperatorExpr = function (ast, ctx) { var opStr; switch (ast.operator) { case exports.UnaryOperator.Plus: opStr = '+'; break; case exports.UnaryOperator.Minus: opStr = '-'; break; default: throw new Error("Unknown operator " + ast.operator); } if (ast.parens) ctx.print(ast, "("); ctx.print(ast, opStr); ast.expr.visitExpression(this, ctx); if (ast.parens) ctx.print(ast, ")"); return null; }; AbstractEmitterVisitor.prototype.visitBinaryOperatorExpr = function (ast, ctx) { var opStr; switch (ast.operator) { case exports.BinaryOperator.Equals: opStr = '=='; break; case exports.BinaryOperator.Identical: opStr = '==='; break; case exports.BinaryOperator.NotEquals: opStr = '!='; break; case exports.BinaryOperator.NotIdentical: opStr = '!=='; break; case exports.BinaryOperator.And: opStr = '&&'; break; case exports.BinaryOperator.BitwiseAnd: opStr = '&'; break; case exports.BinaryOperator.Or: opStr = '||'; break; case exports.BinaryOperator.Plus: opStr = '+'; break; case exports.BinaryOperator.Minus: opStr = '-'; break; case exports.BinaryOperator.Divide: opStr = '/'; break; case exports.BinaryOperator.Multiply: opStr = '*'; break; case exports.BinaryOperator.Modulo: opStr = '%'; break; case exports.BinaryOperator.Lower: opStr = '<'; break; case exports.BinaryOperator.LowerEquals: opStr = '<='; break; case exports.BinaryOperator.Bigger: opStr = '>'; break; case exports.BinaryOperator.BiggerEquals: opStr = '>='; break; case exports.BinaryOperator.NullishCoalesce: opStr = '??'; break; default: throw new Error("Unknown operator " + ast.operator); } if (ast.parens) ctx.print(ast, "("); ast.lhs.visitExpression(this, ctx); ctx.print(ast, " " + opStr + " "); ast.rhs.visitExpression(this, ctx); if (ast.parens) ctx.print(ast, ")"); return null; }; AbstractEmitterVisitor.prototype.visitReadPropExpr = function (ast, ctx) { ast.receiver.visitExpression(this, ctx); ctx.print(ast, "."); ctx.print(ast, ast.name); return null; }; AbstractEmitterVisitor.prototype.visitReadKeyExpr = function (ast, ctx) { ast.receiver.visitExpression(this, ctx); ctx.print(ast, "["); ast.index.visitExpression(this, ctx); ctx.print(ast, "]"); return null; }; AbstractEmitterVisitor.prototype.visitLiteralArrayExpr = function (ast, ctx) { ctx.print(ast, "["); this.visitAllExpressions(ast.entries, ctx, ','); ctx.print(ast, "]"); return null; }; AbstractEmitterVisitor.prototype.visitLiteralMapExpr = function (ast, ctx) { var _this = this; ctx.print(ast, "{"); this.visitAllObjects(function (entry) { ctx.print(ast, escapeIdentifier(entry.key, _this._escapeDollarInStrings, entry.quoted) + ":"); entry.value.visitExpression(_this, ctx); }, ast.entries, ctx, ','); ctx.print(ast, "}"); return null; }; AbstractEmitterVisitor.prototype.visitCommaExpr = function (ast, ctx) { ctx.print(ast, '('); this.visitAllExpressions(ast.parts, ctx, ','); ctx.print(ast, ')'); return null; }; AbstractEmitterVisitor.prototype.visitAllExpressions = function (expressions, ctx, separator) { var _this = this; this.visitAllObjects(function (expr) { return expr.visitExpression(_this, ctx); }, expressions, ctx, separator); }; AbstractEmitterVisitor.prototype.visitAllObjects = function (handler, expressions, ctx, separator) { var incrementedIndent = false; for (var i = 0; i < expressions.length; i++) { if (i > 0) { if (ctx.lineLength() > 80) { ctx.print(null, separator, true); if (!incrementedIndent) { // continuation are marked with double indent. ctx.incIndent(); ctx.incIndent(); incrementedIndent = true; } } else { ctx.print(null, separator, false); } } handler(expressions[i]); } if (incrementedIndent) { // continuation are marked with double indent. ctx.decIndent(); ctx.decIndent(); } }; AbstractEmitterVisitor.prototype.visitAllStatements = function (statements, ctx) { var _this = this; statements.forEach(function (stmt) { return stmt.visitStatement(_this, ctx); }); }; return AbstractEmitterVisitor; }()); function escapeIdentifier(input, escapeDollar, alwaysQuote) { if (alwaysQuote === void 0) { alwaysQuote = true; } if (input == null) { return null; } var body = input.replace(_SINGLE_QUOTE_ESCAPE_STRING_RE, function () { var match = []; for (var _i = 0; _i < arguments.length; _i++) { match[_i] = arguments[_i]; } if (match[0] == '$') { return escapeDollar ? '\\$' : '$'; } else if (match[0] == '\n') { return '\\n'; } else if (match[0] == '\r') { return '\\r'; } else { return "\\" + match[0]; } }); var requiresQuotes = alwaysQuote || !_LEGAL_IDENTIFIER_RE.test(body); return requiresQuotes ? "'" + body + "'" : body; } function _createIndent(count) { var res = ''; for (var i = 0; i < count; i++) { res += _INDENT_WITH; } return res; } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ function typeWithParameters(type, numParams) { if (numParams === 0) { return expressionType(type); } var params = []; for (var i = 0; i < numParams; i++) { params.push(DYNAMIC_TYPE); } return expressionType(type, undefined, params); } var ANIMATE_SYMBOL_PREFIX = '@'; function prepareSyntheticPropertyName(name) { return "" + ANIMATE_SYMBOL_PREFIX + name; } function prepareSyntheticListenerName(name, phase) { return "" + ANIMATE_SYMBOL_PREFIX + name + "." + phase; } function getSafePropertyAccessString(accessor, name) { var escapedName = escapeIdentifier(name, false, false); return escapedName !== name ? accessor + "[" + escapedName + "]" : accessor + "." + name; } function prepareSyntheticListenerFunctionName(name, phase) { return "animation_" + name + "_" + phase; } function jitOnlyGuardedExpression(expr) { return guardedExpression('ngJitMode', expr); } function devOnlyGuardedExpression(expr) { return guardedExpression('ngDevMode', expr); } function guardedExpression(guard, expr) { var guardExpr = new ExternalExpr({ name: guard, moduleName: null }); var guardNotDefined = new BinaryOperatorExpr(exports.BinaryOperator.Identical, new TypeofExpr(guardExpr), literal('undefined')); var guardUndefinedOrTrue = new BinaryOperatorExpr(exports.BinaryOperator.Or, guardNotDefined, guardExpr, /* type */ undefined, /* sourceSpan */ undefined, true); return new BinaryOperatorExpr(exports.BinaryOperator.And, guardUndefinedOrTrue, expr); } function wrapReference(value) { var wrapped = new WrappedNodeExpr(value); return { value: wrapped, type: wrapped }; } function refsToArray(refs, shouldForwardDeclare) { var values = literalArr(refs.map(function (ref) { return ref.value; })); return shouldForwardDeclare ? fn([], [new ReturnStatement(values)]) : values; } function createMayBeForwardRefExpression(expression, forwardRef) { return { expression: expression, forwardRef: forwardRef }; } /** * Convert a `MaybeForwardRefExpression` to an `Expression`, possibly wrapping its expression in a * `forwardRef()` call. * * If `MaybeForwardRefExpression.forwardRef` is `ForwardRefHandling.Unwrapped` then the expression * was originally wrapped in a `forwardRef()` call to prevent the value from being eagerly evaluated * in the code. * * See `packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts` and * `packages/compiler/src/jit_compiler_facade.ts` for more information. */ function convertFromMaybeForwardRefExpression(_a) { var expression = _a.expression, forwardRef = _a.forwardRef; switch (forwardRef) { case 0 /* None */: case 1 /* Wrapped */: return expression; case 2 /* Unwrapped */: return generateForwardRef(expression); } } /** * Generate an expression that has the given `expr` wrapped in the following form: * * ``` * forwardRef(() => expr) * ``` */ function generateForwardRef(expr) { return importExpr(Identifiers.forwardRef).callFn([fn([], [new ReturnStatement(expr)])]); } var R3FactoryDelegateType; (function (R3FactoryDelegateType) { R3FactoryDelegateType[R3FactoryDelegateType["Class"] = 0] = "Class"; R3FactoryDelegateType[R3FactoryDelegateType["Function"] = 1] = "Function"; })(R3FactoryDelegateType || (R3FactoryDelegateType = {})); (function (FactoryTarget) { FactoryTarget[FactoryTarget["Directive"] = 0] = "Directive"; FactoryTarget[FactoryTarget["Component"] = 1] = "Component"; FactoryTarget[FactoryTarget["Injectable"] = 2] = "Injectable"; FactoryTarget[FactoryTarget["Pipe"] = 3] = "Pipe"; FactoryTarget[FactoryTarget["NgModule"] = 4] = "NgModule"; })(exports.FactoryTarget || (exports.FactoryTarget = {})); /** * Construct a factory function expression for the given `R3FactoryMetadata`. */ function compileFactoryFunction(meta) { var t = variable('t'); var baseFactoryVar = null; // The type to instantiate via constructor invocation. If there is no delegated factory, meaning // this type is always created by constructor invocation, then this is the type-to-create // parameter provided by the user (t) if specified, or the current type if not. If there is a // delegated factory (which is used to create the current type) then this is only the type-to- // create parameter (t). var typeForCtor = !isDelegatedFactoryMetadata(meta) ? new BinaryOperatorExpr(exports.BinaryOperator.Or, t, meta.internalType) : t; var ctorExpr = null; if (meta.deps !== null) { // There is a constructor (either explicitly or implicitly defined). if (meta.deps !== 'invalid') { ctorExpr = new InstantiateExpr(typeForCtor, injectDependencies(meta.deps, meta.target)); } } else { // There is no constructor, use the base class' factory to construct typeForCtor. baseFactoryVar = variable("\u0275" + meta.name + "_BaseFactory"); ctorExpr = baseFactoryVar.callFn([typeForCtor]); } var body = []; var retExpr = null; function makeConditionalFactory(nonCtorExpr) { var r = variable('r'); body.push(r.set(NULL_EXPR).toDeclStmt()); var ctorStmt = ctorExpr !== null ? r.set(ctorExpr).toStmt() : importExpr(Identifiers.invalidFactory).callFn([]).toStmt(); body.push(ifStmt(t, [ctorStmt], [r.set(nonCtorExpr).toStmt()])); return r; } if (isDelegatedFactoryMetadata(meta)) { // This type is created with a delegated factory. If a type parameter is not specified, call // the factory instead. var delegateArgs = injectDependencies(meta.delegateDeps, meta.target); // Either call `new delegate(...)` or `delegate(...)` depending on meta.delegateType. var factoryExpr = new (meta.delegateType === R3FactoryDelegateType.Class ? InstantiateExpr : InvokeFunctionExpr)(meta.delegate, delegateArgs); retExpr = makeConditionalFactory(factoryExpr); } else if (isExpressionFactoryMetadata(meta)) { // TODO(alxhub): decide whether to lower the value here or in the caller retExpr = makeConditionalFactory(meta.expression); } else { retExpr = ctorExpr; } if (retExpr === null) { // The expression cannot be formed so render an `ɵɵinvalidFactory()` call. body.push(importExpr(Identifiers.invalidFactory).callFn([]).toStmt()); } else if (baseFactoryVar !== null) { // This factory uses a base factory, so call `ɵɵgetInheritedFactory()` to compute it. var getInheritedFactoryCall = importExpr(Identifiers.getInheritedFactory).callFn([meta.internalType]); // Memoize the base factoryFn: `baseFactory || (baseFactory = ɵɵgetInheritedFactory(...))` var baseFactory = new BinaryOperatorExpr(exports.BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall)); body.push(new ReturnStatement(baseFactory.callFn([typeForCtor]))); } else { // This is straightforward factory, just return it. body.push(new ReturnStatement(retExpr)); } var factoryFn = fn([new FnParam('t', DYNAMIC_TYPE)], body, INFERRED_TYPE, undefined, meta.name + "_Factory"); if (baseFactoryVar !== null) { // There is a base factory variable so wrap its declaration along with the factory function into // an IIFE. factoryFn = fn([], [ new DeclareVarStmt(baseFactoryVar.name), new ReturnStatement(factoryFn) ]).callFn([], /* sourceSpan */ undefined, /* pure */ true); } return { expression: factoryFn, statements: [], type: createFactoryType(meta), }; } function createFactoryType(meta) { var ctorDepsType = meta.deps !== null && meta.deps !== 'invalid' ? createCtorDepsType(meta.deps) : NONE_TYPE; return expressionType(importExpr(Identifiers.FactoryDeclaration, [typeWithParameters(meta.type.type, meta.typeArgumentCount), ctorDepsType])); } function injectDependencies(deps, target) { return deps.map(function (dep, index) { return compileInjectDependency(dep, target, index); }); } function compileInjectDependency(dep, target, index) { // Interpret the dependency according to its resolved type. if (dep.token === null) { return importExpr(Identifiers.invalidFactoryDep).callFn([literal(index)]); } else if (dep.attributeNameType === null) { // Build up the injection flags according to the metadata. var flags = 0 /* Default */ | (dep.self ? 2 /* Self */ : 0) | (dep.skipSelf ? 4 /* SkipSelf */ : 0) | (dep.host ? 1 /* Host */ : 0) | (dep.optional ? 8 /* Optional */ : 0) | (target === exports.FactoryTarget.Pipe ? 16 /* ForPipe */ : 0); // If this dependency is optional or otherwise has non-default flags, then additional // parameters describing how to inject the dependency must be passed to the inject function // that's being used. var flagsParam = (flags !== 0 /* Default */ || dep.optional) ? literal(flags) : null; // Build up the arguments to the injectFn call. var injectArgs = [dep.token]; if (flagsParam) { injectArgs.push(flagsParam); } var injectFn = getInjectFn(target); return importExpr(injectFn).callFn(injectArgs); } else { // The `dep.attributeTypeName` value is defined, which indicates that this is an `@Attribute()` // type dependency. For the generated JS we still want to use the `dep.token` value in case the // name given for the attribute is not a string literal. For example given `@Attribute(foo())`, // we want to generate `ɵɵinjectAttribute(foo())`. // // The `dep.attributeTypeName` is only actually used (in `createCtorDepType()`) to generate // typings. return importExpr(Identifiers.injectAttribute).callFn([dep.token]); } } function createCtorDepsType(deps) { var hasTypes = false; var attributeTypes = deps.map(function (dep) { var type = createCtorDepType(dep); if (type !== null) { hasTypes = true; return type; } else { return literal(null); } }); if (hasTypes) { return expressionType(literalArr(attributeTypes)); } else { return NONE_TYPE; } } function createCtorDepType(dep) { var entries = []; if (dep.attributeNameType !== null) { entries.push({ key: 'attribute', value: dep.attributeNameType, quoted: false }); } if (dep.optional) { entries.push({ key: 'optional', value: literal(true), quoted: false }); } if (dep.host) { entries.push({ key: 'host', value: literal(true), quoted: false }); } if (dep.self) { entries.push({ key: 'self', value: literal(true), quoted: false }); } if (dep.skipSelf) { entries.push({ key: 'skipSelf', value: literal(true), quoted: false }); } return entries.length > 0 ? literalMap(entries) : null; } function isDelegatedFactoryMetadata(meta) { return meta.delegateType !== undefined; } function isExpressionFactoryMetadata(meta) { return meta.expression !== undefined; } function getInjectFn(target) { switch (target) { case exports.FactoryTarget.Component: case exports.FactoryTarget.Directive: case exports.FactoryTarget.Pipe: return Identifiers.directiveInject; case exports.FactoryTarget.NgModule: case exports.FactoryTarget.Injectable: default: return Identifiers.inject; } } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ /** * This is an R3 `Node`-like wrapper for a raw `html.Comment` node. We do not currently * require the implementation of a visitor for Comments as they are only collected at * the top-level of the R3 AST, and only if `Render3ParseOptions['collectCommentNodes']` * is true. */ var Comment = /** @class */ (function () { function Comment(value, sourceSpan) { this.value = value; this.sourceSpan = sourceSpan; } Comment.prototype.visit = function (_visitor) { throw new Error('visit() not implemented for Comment'); }; return Comment; }()); var Text = /** @class */ (function () { function Text(value, sourceSpan) { this.value = value; this.sourceSpan = sourceSpan; } Text.prototype.visit = function (visitor) { return visitor.visitText(this); }; return Text; }()); var BoundText = /** @class */ (function () { function BoundText(value, sourceSpan, i18n) { this.value = value; this.sourceSpan = sourceSpan; this.i18n = i18n; } BoundText.prototype.visit = function (visitor) { return visitor.visitBoundText(this); }; return BoundText; }()); /** * Represents a text attribute in the template. * * `valueSpan` may not be present in cases where there is no value `
`. * `keySpan` may also not be present for synthetic attributes from ICU expansions. */ var TextAttribute = /** @class */ (function () { function TextAttribute(name, value, sourceSpan, keySpan, valueSpan, i18n) { this.name = name; this.value = value; this.sourceSpan = sourceSpan; this.keySpan = keySpan; this.valueSpan = valueSpan; this.i18n = i18n; } TextAttribute.prototype.visit = function (visitor) { return visitor.visitTextAttribute(this); }; return TextAttribute; }()); var BoundAttribute = /** @class */ (function () { function BoundAttribute(name, type, securityContext, value, unit, sourceSpan, keySpan, valueSpan, i18n) { this.name = name; this.type = type; this.securityContext = securityContext; this.value = value; this.unit = unit; this.sourceSpan = sourceSpan; this.keySpan = keySpan; this.valueSpan = valueSpan; this.i18n = i18n; } BoundAttribute.fromBoundElementProperty = function (prop, i18n) { if (prop.keySpan === undefined) { throw new Error("Unexpected state: keySpan must be defined for bound attributes but was not for " + prop.name + ": " + prop.sourceSpan); } return new BoundAttribute(prop.name, prop.type, prop.securityContext, prop.value, prop.unit, prop.sourceSpan, prop.keySpan, prop.valueSpan, i18n); }; BoundAttribute.prototype.visit = function (visitor) { return visitor.visitBoundAttribute(this); }; return BoundAttribute; }()); var BoundEvent = /** @class */ (function () { function BoundEvent(name, type, handler, target, phase, sourceSpan, handlerSpan, keySpan) { this.name = name; this.type = type; this.handler = handler; this.target = target; this.phase = phase; this.sourceSpan = sourceSpan; this.handlerSpan = handlerSpan; this.keySpan = keySpan; } BoundEvent.fromParsedEvent = function (event) { var target = event.type === 0 /* Regular */ ? event.targetOrPhase : null; var phase = event.type === 1 /* Animation */ ? event.targetOrPhase : null; if (event.keySpan === undefined) { throw new Error("Unexpected state: keySpan must be defined for bound event but was not for " + event.name + ": " + event.sourceSpan); } return new BoundEvent(event.name, event.type, event.handler, target, phase, event.sourceSpan, event.handlerSpan, event.keySpan); }; BoundEvent.prototype.visit = function (visitor) { return visitor.visitBoundEvent(this); }; return BoundEvent; }()); var Element = /** @class */ (function () { function Element(name, attributes, inputs, outputs, children, references, sourceSpan, startSourceSpan, endSourceSpan, i18n) { this.name = name; this.attributes = attributes; this.inputs = inputs; this.outputs = outputs; this.children = children; this.references = references; this.sourceSpan = sourceSpan; this.startSourceSpan = startSourceSpan; this.endSourceSpan = endSourceSpan; this.i18n = i18n; } Element.prototype.visit = function (visitor) { return visitor.visitElement(this); }; return Element; }()); var Template = /** @class */ (function () { function Template(tagName, attributes, inputs, outputs, templateAttrs, children, references, variables, sourceSpan, startSourceSpan, endSourceSpan, i18n) { this.tagName = tagName; this.attributes = attributes; this.inputs = inputs; this.outputs = outputs; this.templateAttrs = templateAttrs; this.children = children; this.references = references; this.variables = variables; this.sourceSpan = sourceSpan; this.startSourceSpan = startSourceSpan; this.endSourceSpan = endSourceSpan; this.i18n = i18n; } Template.prototype.visit = function (visitor) { return visitor.visitTemplate(this); }; return Template; }()); var Content = /** @class */ (function () { function Content(selector, attributes, sourceSpan, i18n) { this.selector = selector; this.attributes = attributes; this.sourceSpan = sourceSpan; this.i18n = i18n; this.name = 'ng-content'; } Content.prototype.visit = function (visitor) { return visitor.visitContent(this); }; return Content; }()); var Variable = /** @class */ (function () { function Variable(name, value, sourceSpan, keySpan, valueSpan) { this.name = name; this.value = value; this.sourceSpan = sourceSpan; this.keySpan = keySpan; this.valueSpan = valueSpan; } Variable.prototype.visit = function (visitor) { return visitor.visitVariable(this); }; return Variable; }()); var Reference = /** @class */ (function () { function Reference(name, value, sourceSpan, keySpan, valueSpan) { this.name = name; this.value = value; this.sourceSpan = sourceSpan; this.keySpan = keySpan; this.valueSpan = valueSpan; } Reference.prototype.visit = function (visitor) { return visitor.visitReference(this); }; return Reference; }()); var Icu = /** @class */ (function () { function Icu(vars, placeholders, sourceSpan, i18n) { this.vars = vars; this.placeholders = placeholders; this.sourceSpan = sourceSpan; this.i18n = i18n; } Icu.prototype.visit = function (visitor) { return visitor.visitIcu(this); }; return Icu; }()); var NullVisitor = /** @class */ (function () { function NullVisitor() { } NullVisitor.prototype.visitElement = function (element) { }; NullVisitor.prototype.visitTemplate = function (template) { }; NullVisitor.prototype.visitContent = function (content) { }; NullVisitor.prototype.visitVariable = function (variable) { }; NullVisitor.prototype.visitReference = function (reference) { }; NullVisitor.prototype.visitTextAttribute = function (attribute) { }; NullVisitor.prototype.visitBoundAttribute = function (attribute) { }; NullVisitor.prototype.visitBoundEvent = function (attribute) { }; NullVisitor.prototype.visitText = function (text) { }; NullVisitor.prototype.visitBoundText = function (text) { }; NullVisitor.prototype.visitIcu = function (icu) { }; return NullVisitor; }()); var RecursiveVisitor = /** @class */ (function () { function RecursiveVisitor() { } RecursiveVisitor.prototype.visitElement = function (element) { visitAll(this, element.attributes); visitAll(this, element.inputs); visitAll(this, element.outputs); visitAll(this, element.children); visitAll(this, element.references); }; RecursiveVisitor.prototype.visitTemplate = function (template) { visitAll(this, template.attributes); visitAll(this, template.inputs); visitAll(this, template.outputs); visitAll(this, template.children); visitAll(this, template.references); visitAll(this, template.variables); }; RecursiveVisitor.prototype.visitContent = function (content) { }; RecursiveVisitor.prototype.visitVariable = function (variable) { }; RecursiveVisitor.prototype.visitReference = function (reference) { }; RecursiveVisitor.prototype.visitTextAttribute = function (attribute) { }; RecursiveVisitor.prototype.visitBoundAttribute = function (attribute) { }; RecursiveVisitor.prototype.visitBoundEvent = function (attribute) { }; RecursiveVisitor.prototype.visitText = function (text) { }; RecursiveVisitor.prototype.visitBoundText = function (text) { }; RecursiveVisitor.prototype.visitIcu = function (icu) { }; return RecursiveVisitor; }()); var TransformVisitor = /** @class */ (function () { function TransformVisitor() { } TransformVisitor.prototype.visitElement = function (element) { var newAttributes = transformAll(this, element.attributes); var newInputs = transformAll(this, element.inputs); var newOutputs = transformAll(this, element.outputs); var newChildren = transformAll(this, element.children); var newReferences = transformAll(this, element.references); if (newAttributes != element.attributes || newInputs != element.inputs || newOutputs != element.outputs || newChildren != element.children || newReferences != element.references) { return new Element(element.name, newAttributes, newInputs, newOutputs, newChildren, newReferences, element.sourceSpan, element.startSourceSpan, element.endSourceSpan); } return element; }; TransformVisitor.prototype.visitTemplate = function (template) { var newAttributes = transformAll(this, template.attributes); var newInputs = transformAll(this, template.inputs); var newOutputs = transformAll(this, template.outputs); var newTemplateAttrs = transformAll(this, template.templateAttrs); var newChildren = transformAll(this, template.children); var newReferences = transformAll(this, template.references); var newVariables = transformAll(this, template.variables); if (newAttributes != template.attributes || newInputs != template.inputs || newOutputs != template.outputs || newTemplateAttrs != template.templateAttrs || newChildren != template.children || newReferences != template.references || newVariables != template.variables) { return new Template(template.tagName, newAttributes, newInputs, newOutputs, newTemplateAttrs, newChildren, newReferences, newVariables, template.sourceSpan, template.startSourceSpan, template.endSourceSpan); } return template; }; TransformVisitor.prototype.visitContent = function (content) { return content; }; TransformVisitor.prototype.visitVariable = function (variable) { return variable; }; TransformVisitor.prototype.visitReference = function (reference) { return reference; }; TransformVisitor.prototype.visitTextAttribute = function (attribute) { return attribute; }; TransformVisitor.prototype.visitBoundAttribute = function (attribute) { return attribute; }; TransformVisitor.prototype.visitBoundEvent = function (attribute) { return attribute; }; TransformVisitor.prototype.visitText = function (text) { return text; }; TransformVisitor.prototype.visitBoundText = function (text) { return text; }; TransformVisitor.prototype.visitIcu = function (icu) { return icu; }; return TransformVisitor; }()); function visitAll(visitor, nodes) { var e_1, _a, e_2, _b; var result = []; if (visitor.visit) { try { for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) { var node = nodes_1_1.value; var newNode = visitor.visit(node) || node.visit(visitor); } } catch (e_1_1) { e_1 = { error: e_1_1 }; } finally { try { if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1); } finally { if (e_1) throw e_1.error; } } } else { try { for (var nodes_2 = __values(nodes), nodes_2_1 = nodes_2.next(); !nodes_2_1.done; nodes_2_1 = nodes_2.next()) { var node = nodes_2_1.value; var newNode = node.visit(visitor); if (newNode) { result.push(newNode); } } } catch (e_2_1) { e_2 = { error: e_2_1 }; } finally { try { if (nodes_2_1 && !nodes_2_1.done && (_b = nodes_2.return)) _b.call(nodes_2); } finally { if (e_2) throw e_2.error; } } } return result; } function transformAll(visitor, nodes) { var e_3, _a; var result = []; var changed = false; try { for (var nodes_3 = __values(nodes), nodes_3_1 = nodes_3.next(); !nodes_3_1.done; nodes_3_1 = nodes_3.next()) { var node = nodes_3_1.value; var newNode = node.visit(visitor); if (newNode) { result.push(newNode); } changed = changed || newNode != node; } } catch (e_3_1) { e_3 = { error: e_3_1 }; } finally { try { if (nodes_3_1 && !nodes_3_1.done && (_a = nodes_3.return)) _a.call(nodes_3); } finally { if (e_3) throw e_3.error; } } return changed ? result : nodes; } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ var Message = /** @class */ (function () { /** * @param nodes message AST * @param placeholders maps placeholder names to static content and their source spans * @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages) * @param meaning * @param description * @param customId */ function Message(nodes, placeholders, placeholderToMessage, meaning, description, customId) { this.nodes = nodes; this.placeholders = placeholders; this.placeholderToMessage = placeholderToMessage; this.meaning = meaning; this.description = description; this.customId = customId; this.id = this.customId; /** The ids to use if there are no custom id and if `i18nLegacyMessageIdFormat` is not empty */ this.legacyIds = []; if (nodes.length) { this.sources = [{ filePath: nodes[0].sourceSpan.start.file.url, startLine: nodes[0].sourceSpan.start.line + 1, startCol: nodes[0].sourceSpan.start.col + 1, endLine: nodes[nodes.length - 1].sourceSpan.end.line + 1, endCol: nodes[0].sourceSpan.start.col + 1 }]; } else { this.sources = []; } } return Message; }()); var Text$1 = /** @class */ (function () { function Text(value, sourceSpan) { this.value = value; this.sourceSpan = sourceSpan; } Text.prototype.visit = function (visitor, context) { return visitor.visitText(this, context); }; return Text; }()); // TODO(vicb): do we really need this node (vs an array) ? var Container = /** @class */ (function () { function Container(children, sourceSpan) { this.children = children; this.sourceSpan = sourceSpan; } Container.prototype.visit = function (visitor, context) { return visitor.visitContainer(this, context); }; return Container; }()); var Icu$1 = /** @class */ (function () { function Icu(expression, type, cases, sourceSpan) { this.expression = expression; this.type = type; this.cases = cases; this.sourceSpan = sourceSpan; } Icu.prototype.visit = function (visitor, context) { return visitor.visitIcu(this, context); }; return Icu; }()); var TagPlaceholder = /** @class */ (function () { function TagPlaceholder(tag, attrs, startName, closeName, children, isVoid, // TODO sourceSpan should cover all (we need a startSourceSpan and endSourceSpan) sourceSpan, startSourceSpan, endSourceSpan) { this.tag = tag; this.attrs = attrs; this.startName = startName; this.closeName = closeName; this.children = children; this.isVoid = isVoid; this.sourceSpan = sourceSpan; this.startSourceSpan = startSourceSpan; this.endSourceSpan = endSourceSpan; } TagPlaceholder.prototype.visit = function (visitor, context) { return visitor.visitTagPlaceholder(this, context); }; return TagPlaceholder; }()); var Placeholder = /** @class */ (function () { function Placeholder(value, name, sourceSpan) { this.value = value; this.name = name; this.sourceSpan = sourceSpan; } Placeholder.prototype.visit = function (visitor, context) { return visitor.visitPlaceholder(this, context); }; return Placeholder; }()); var IcuPlaceholder = /** @class */ (function () { function IcuPlaceholder(value, name, sourceSpan) { this.value = value; this.name = name; this.sourceSpan = sourceSpan; } IcuPlaceholder.prototype.visit = function (visitor, context) { return visitor.visitIcuPlaceholder(this, context); }; return IcuPlaceholder; }()); // Clone the AST var CloneVisitor = /** @class */ (function () { function CloneVisitor() { } CloneVisitor.prototype.visitText = function (text, context) { return new Text$1(text.value, text.sourceSpan); }; CloneVisitor.prototype.visitContainer = function (container, context) { var _this = this; var children = container.children.map(function (n) { return n.visit(_this, context); }); return new Container(children, container.sourceSpan); }; CloneVisitor.prototype.visitIcu = function (icu, context) { var _this = this; var cases = {}; Object.keys(icu.cases).forEach(function (key) { return cases[key] = icu.cases[key].visit(_this, context); }); var msg = new Icu$1(icu.expression, icu.type, cases, icu.sourceSpan); msg.expressionPlaceholder = icu.expressionPlaceholder; return msg; }; CloneVisitor.prototype.visitTagPlaceholder = function (ph, context) { var _this = this; var children = ph.children.map(function (n) { return n.visit(_this, context); }); return new TagPlaceholder(ph.tag, ph.attrs, ph.startName, ph.closeName, children, ph.isVoid, ph.sourceSpan, ph.startSourceSpan, ph.endSourceSpan); }; CloneVisitor.prototype.visitPlaceholder = function (ph, context) { return new Placeholder(ph.value, ph.name, ph.sourceSpan); }; CloneVisitor.prototype.visitIcuPlaceholder = function (ph, context) { return new IcuPlaceholder(ph.value, ph.name, ph.sourceSpan); }; return CloneVisitor; }()); // Visit all the nodes recursively var RecurseVisitor = /** @class */ (function () { function RecurseVisitor() { } RecurseVisitor.prototype.visitText = function (text, context) { }; RecurseVisitor.prototype.visitContainer = function (container, context) { var _this = this; container.children.forEach(function (child) { return child.visit(_this); }); }; RecurseVisitor.prototype.visitIcu = function (icu, context) { var _this = this; Object.keys(icu.cases).forEach(function (k) { icu.cases[k].visit(_this); }); }; RecurseVisitor.prototype.visitTagPlaceholder = function (ph, context) { var _this = this; ph.children.forEach(function (child) { return child.visit(_this); }); }; RecurseVisitor.prototype.visitPlaceholder = function (ph, context) { }; RecurseVisitor.prototype.visitIcuPlaceholder = function (ph, context) { }; return RecurseVisitor; }()); /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ /** * Represents a big integer using a buffer of its individual digits, with the least significant * digit stored at the beginning of the array (little endian). * * For performance reasons, each instance is mutable. The addition operation can be done in-place * to reduce memory pressure of allocation for the digits array. */ var BigInteger = /** @class */ (function () { /** * Creates a big integer using its individual digits in little endian storage. */ function BigInteger(digits) { this.digits = digits; } BigInteger.zero = function () { return new BigInteger([0]); }; BigInteger.one = function () { return new BigInteger([1]); }; /** * Creates a clone of this instance. */ BigInteger.prototype.clone = function () { return new BigInteger(this.digits.slice()); }; /** * Returns a new big integer with the sum of `this` and `other` as its value. This does not mutate * `this` but instead returns a new instance, unlike `addToSelf`. */ BigInteger.prototype.add = function (other) { var result = this.clone(); result.addToSelf(other); return result; }; /** * Adds `other` to the instance itself, thereby mutating its value. */ BigInteger.prototype.addToSelf = function (other) { var maxNrOfDigits = Math.max(this.digits.length, other.digits.length); var carry = 0; for (var i = 0; i < maxNrOfDigits; i++) { var digitSum = carry; if (i < this.digits.length) { digitSum += this.digits[i]; } if (i < other.digits.length) { digitSum += other.digits[i]; } if (digitSum >= 10) { this.digits[i] = digitSum - 10; carry = 1; } else { this.digits[i] = digitSum; carry = 0; } } // Apply a remaining carry if needed. if (carry > 0) { this.digits[maxNrOfDigits] = 1; } }; /** * Builds the decimal string representation of the big integer. As this is stored in * little endian, the digits are concatenated in reverse order. */ BigInteger.prototype.toString = function () { var res = ''; for (var i = this.digits.length - 1; i >= 0; i--) { res += this.digits[i]; } return res; }; return BigInteger; }()); /** * Represents a big integer which is optimized for multiplication operations, as its power-of-twos * are memoized. See `multiplyBy()` for details on the multiplication algorithm. */ var BigIntForMultiplication = /** @class */ (function () { function BigIntForMultiplication(value) { this.powerOfTwos = [value]; } /** * Returns the big integer itself. */ BigIntForMultiplication.prototype.getValue = function () { return this.powerOfTwos[0]; }; /** * Computes the value for `num * b`, where `num` is a JS number and `b` is a big integer. The * value for `b` is represented by a storage model that is optimized for this computation. * * This operation is implemented in N(log2(num)) by continuous halving of the number, where the * least-significant bit (LSB) is tested in each iteration. If the bit is set, the bit's index is * used as exponent into the power-of-two multiplication of `b`. * * As an example, consider the multiplication num=42, b=1337. In binary 42 is 0b00101010 and the * algorithm unrolls into the following iterations: * * Iteration | num | LSB | b * 2^iter | Add? | product * -----------|------------|------|------------|------|-------- * 0 | 0b00101010 | 0 | 1337 | No | 0 * 1 | 0b00010101 | 1 | 2674 | Yes | 2674 * 2 | 0b00001010 | 0 | 5348 | No | 2674 * 3 | 0b00000101 | 1 | 10696 | Yes | 13370 * 4 | 0b00000010 | 0 | 21392 | No | 13370 * 5 | 0b00000001 | 1 | 42784 | Yes | 56154 * 6 | 0b00000000 | 0 | 85568 | No | 56154 * * The computed product of 56154 is indeed the correct result. * * The `BigIntForMultiplication` representation for a big integer provides memoized access to the * power-of-two values to reduce the workload in computing those values. */ BigIntForMultiplication.prototype.multiplyBy = function (num) { var product = BigInteger.zero(); this.multiplyByAndAddTo(num, product); return product; }; /** * See `multiplyBy()` for details. This function allows for the computed product to be added * directly to the provided result big integer. */ BigIntForMultiplication.prototype.multiplyByAndAddTo = function (num, result) { for (var exponent = 0; num !== 0; num = num >>> 1, exponent++) { if (num & 1) { var value = this.getMultipliedByPowerOfTwo(exponent); result.addToSelf(value); } } }; /** * Computes and memoizes the big integer value for `this.number * 2^exponent`. */ BigIntForMultiplication.prototype.getMultipliedByPowerOfTwo = function (exponent) { // Compute the powers up until the requested exponent, where each value is computed from its // predecessor. This is simple as `this.number * 2^(exponent - 1)` only has to be doubled (i.e. // added to itself) to reach `this.number * 2^exponent`. for (var i = this.powerOfTwos.length; i <= exponent; i++) { var previousPower = this.powerOfTwos[i - 1]; this.powerOfTwos[i] = previousPower.add(previousPower); } return this.powerOfTwos[exponent]; }; return BigIntForMultiplication; }()); /** * Represents an exponentiation operation for the provided base, of which exponents are computed and * memoized. The results are represented by a `BigIntForMultiplication` which is tailored for * multiplication operations by memoizing the power-of-twos. This effectively results in a matrix * representation that is lazily computed upon request. */ var BigIntExponentiation = /** @class */ (function () { function BigIntExponentiation(base) { this.base = base; this.exponents = [new BigIntForMultiplication(BigInteger.one())]; } /** * Compute the value for `this.base^exponent`, resulting in a big integer that is optimized for * further multiplication operations. */ BigIntExponentiation.prototype.toThePowerOf = function (exponent) { // Compute the results up until the requested exponent, where every value is computed from its // predecessor. This is because `this.base^(exponent - 1)` only has to be multiplied by `base` // to reach `this.base^exponent`. for (var i = this.exponents.length; i <= exponent; i++) { var value = this.exponents[i - 1].multiplyBy(this.base); this.exponents[i] = new BigIntForMultiplication(value); } return this.exponents[exponent]; }; return BigIntExponentiation; }()); /** * Return the message id or compute it using the XLIFF1 digest. */ function digest(message) { return message.id || computeDigest(message); } /** * Compute the message id using the XLIFF1 digest. */ function computeDigest(message) { return sha1(serializeNodes(message.nodes).join('') + ("[" + message.meaning + "]")); } /** * Return the message id or compute it using the XLIFF2/XMB/$localize digest. */ function decimalDigest(message) { return message.id || computeDecimalDigest(message); } /** * Compute the message id using the XLIFF2/XMB/$localize digest. */ function computeDecimalDigest(message) { var visitor = new _SerializerIgnoreIcuExpVisitor(); var parts = message.nodes.map(function (a) { return a.visit(visitor, null); }); return computeMsgId(parts.join(''), message.meaning); } /** * Serialize the i18n ast to something xml-like in order to generate an UID. * * The visitor is also used in the i18n parser tests * * @internal */ var _SerializerVisitor = /** @class */ (function () { function _SerializerVisitor() { } _SerializerVisitor.prototype.visitText = function (text, context) { return text.value; }; _SerializerVisitor.prototype.visitContainer = function (container, context) { var _this = this; return "[" + container.children.map(function (child) { return child.visit(_this); }).join(', ') + "]"; }; _SerializerVisitor.prototype.visitIcu = function (icu, context) { var _this = this; var strCases = Object.keys(icu.cases).map(function (k) { return k + " {" + icu.cases[k].visit(_this) + "}"; }); return "{" + icu.expression + ", " + icu.type + ", " + strCases.join(', ') + "}"; }; _SerializerVisitor.prototype.visitTagPlaceholder = function (ph, context) { var _this = this; return ph.isVoid ? "" : "" + ph.children.map(function (child) { return child.visit(_this); }).join(', ') + ""; }; _SerializerVisitor.prototype.visitPlaceholder = function (ph, context) { return ph.value ? "" + ph.value + "" : ""; }; _SerializerVisitor.prototype.visitIcuPlaceholder = function (ph, context) { return "" + ph.value.visit(this) + ""; }; return _SerializerVisitor; }()); var serializerVisitor = new _SerializerVisitor(); function serializeNodes(nodes) { return nodes.map(function (a) { return a.visit(serializerVisitor, null); }); } /** * Serialize the i18n ast to something xml-like in order to generate an UID. * * Ignore the ICU expressions so that message IDs stays identical if only the expression changes. * * @internal */ var _SerializerIgnoreIcuExpVisitor = /** @class */ (function (_super) { __extends(_SerializerIgnoreIcuExpVisitor, _super); function _SerializerIgnoreIcuExpVisitor() { return _super !== null && _super.apply(this, arguments) || this; } _SerializerIgnoreIcuExpVisitor.prototype.visitIcu = function (icu, context) { var _this = this; var strCases = Object.keys(icu.cases).map(function (k) { return k + " {" + icu.cases[k].visit(_this) + "}"; }); // Do not take the expression into account return "{" + icu.type + ", " + strCases.join(', ') + "}"; }; return _SerializerIgnoreIcuExpVisitor; }(_SerializerVisitor)); /** * Compute the SHA1 of the given string * * see https://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf * * WARNING: this function has not been designed not tested with security in mind. * DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT. */ function sha1(str) { var utf8 = utf8Encode(str); var words32 = bytesToWords32(utf8, Endian.Big); var len = utf8.length * 8; var w = newArray(80); var a = 0x67452301, b = 0xefcdab89, c = 0x98badcfe, d = 0x10325476, e = 0xc3d2e1f0; words32[len >> 5] |= 0x80 << (24 - len % 32); words32[((len + 64 >> 9) << 4) + 15] = len; for (var i = 0; i < words32.length; i += 16) { var h0 = a, h1 = b, h2 = c, h3 = d, h4 = e; for (var j = 0; j < 80; j++) { if (j < 16) { w[j] = words32[i + j]; } else { w[j] = rol32(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1); } var fkVal = fk(j, b, c, d); var f = fkVal[0]; var k = fkVal[1]; var temp = [rol32(a, 5), f, e, k, w[j]].reduce(add32); e = d; d = c; c = rol32(b, 30); b = a; a = temp; } a = add32(a, h0); b = add32(b, h1); c = add32(c, h2); d = add32(d, h3); e = add32(e, h4); } return bytesToHexString(words32ToByteString([a, b, c, d, e])); } function fk(index, b, c, d) { if (index < 20) { return [(b & c) | (~b & d), 0x5a827999]; } if (index < 40) { return [b ^ c ^ d, 0x6ed9eba1]; } if (index < 60) { return [(b & c) | (b & d) | (c & d), 0x8f1bbcdc]; } return [b ^ c ^ d, 0xca62c1d6]; } /** * Compute the fingerprint of the given string * * The output is 64 bit number encoded as a decimal string * * based on: * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java */ function fingerprint(str) { var utf8 = utf8Encode(str); var hi = hash32(utf8, 0); var lo = hash32(utf8, 102072); if (hi == 0 && (lo == 0 || lo == 1)) { hi = hi ^ 0x130f9bef; lo = lo ^ -0x6b5f56d8; } return [hi, lo]; } function computeMsgId(msg, meaning) { if (meaning === void 0) { meaning = ''; } var msgFingerprint = fingerprint(msg); if (meaning) { var meaningFingerprint = fingerprint(meaning); msgFingerprint = add64(rol64(msgFingerprint, 1), meaningFingerprint); } var hi = msgFingerprint[0]; var lo = msgFingerprint[1]; return wordsToDecimalString(hi & 0x7fffffff, lo); } function hash32(bytes, c) { var a = 0x9e3779b9, b = 0x9e3779b9; var i; var len = bytes.length; for (i = 0; i + 12 <= len; i += 12) { a = add32(a, wordAt(bytes, i, Endian.Little)); b = add32(b, wordAt(bytes, i + 4, Endian.Little)); c = add32(c, wordAt(bytes, i + 8, Endian.Little)); var res = mix(a, b, c); a = res[0], b = res[1], c = res[2]; } a = add32(a, wordAt(bytes, i, Endian.Little)); b = add32(b, wordAt(bytes, i + 4, Endian.Little)); // the first byte of c is reserved for the length c = add32(c, len); c = add32(c, wordAt(bytes, i + 8, Endian.Little) << 8); return mix(a, b, c)[2]; } // clang-format off function mix(a, b, c) { a = sub32(a, b); a = sub32(a, c); a ^= c >>> 13; b = sub32(b, c); b = sub32(b, a); b ^= a << 8; c = sub32(c, a); c = sub32(c, b); c ^= b >>> 13; a = sub32(a, b); a = sub32(a, c); a ^= c >>> 12; b = sub32(b, c); b = sub32(b, a); b ^= a << 16; c = sub32(c, a); c = sub32(c, b); c ^= b >>> 5; a = sub32(a, b); a = sub32(a, c); a ^= c >>> 3; b = sub32(b, c); b = sub32(b, a); b ^= a << 10; c = sub32(c, a); c = sub32(c, b); c ^= b >>> 15; return [a, b, c]; } // clang-format on // Utils var Endian; (function (Endian) { Endian[Endian["Little"] = 0] = "Little"; Endian[Endian["Big"] = 1] = "Big"; })(Endian || (Endian = {})); function add32(a, b) { return add32to64(a, b)[1]; } function add32to64(a, b) { var low = (a & 0xffff) + (b & 0xffff); var high = (a >>> 16) + (b >>> 16) + (low >>> 16); return [high >>> 16, (high << 16) | (low & 0xffff)]; } function add64(a, b) { var ah = a[0], al = a[1]; var bh = b[0], bl = b[1]; var result = add32to64(al, bl); var carry = result[0]; var l = result[1]; var h = add32(add32(ah, bh), carry); return [h, l]; } function sub32(a, b) { var low = (a & 0xffff) - (b & 0xffff); var high = (a >> 16) - (b >> 16) + (low >> 16); return (high << 16) | (low & 0xffff); } // Rotate a 32b number left `count` position function rol32(a, count) { return (a << count) | (a >>> (32 - count)); } // Rotate a 64b number left `count` position function rol64(num, count) { var hi = num[0], lo = num[1]; var h = (hi << count) | (lo >>> (32 - count)); var l = (lo << count) | (hi >>> (32 - count)); return [h, l]; } function bytesToWords32(bytes, endian) { var size = (bytes.length + 3) >>> 2; var words32 = []; for (var i = 0; i < size; i++) { words32[i] = wordAt(bytes, i * 4, endian); } return words32; } function byteAt(bytes, index) { return index >= bytes.length ? 0 : bytes[index]; } function wordAt(bytes, index, endian) { var word = 0; if (endian === Endian.Big) { for (var i = 0; i < 4; i++) { word += byteAt(bytes, index + i) << (24 - 8 * i); } } else { for (var i = 0; i < 4; i++) { word += byteAt(bytes, index + i) << 8 * i; } } return word; } function words32ToByteString(words32) { return words32.reduce(function (bytes, word) { return bytes.concat(word32ToByteString(word)); }, []); } function word32ToByteString(word) { var bytes = []; for (var i = 0; i < 4; i++) { bytes.push((word >>> 8 * (3 - i)) & 0xff); } return bytes; } function bytesToHexString(bytes) { var hex = ''; for (var i = 0; i < bytes.length; i++) { var b = byteAt(bytes, i); hex += (b >>> 4).toString(16) + (b & 0x0f).toString(16); } return hex.toLowerCase(); } /** * Create a shared exponentiation pool for base-256 computations. This shared pool provides memoized * power-of-256 results with memoized power-of-two computations for efficient multiplication. * * For our purposes, this can be safely stored as a global without memory concerns. The reason is * that we encode two words, so only need the 0th (for the low word) and 4th (for the high word) * exponent. */ var base256 = new BigIntExponentiation(256); /** * Represents two 32-bit words as a single decimal number. This requires a big integer storage * model as JS numbers are not accurate enough to represent the 64-bit number. * * Based on https://www.danvk.org/hex2dec.html */ function wordsToDecimalString(hi, lo) { // Encode the four bytes in lo in the lower digits of the decimal number. // Note: the multiplication results in lo itself but represented by a big integer using its // decimal digits. var decimal = base256.toThePowerOf(0).multiplyBy(lo); // Encode the four bytes in hi above the four lo bytes. lo is a maximum of (2^8)^4, which is why // this multiplication factor is applied. base256.toThePowerOf(4).multiplyByAndAddTo(hi, decimal); return decimal.toString(); } var Serializer = /** @class */ (function () { function Serializer() { } // Creates a name mapper, see `PlaceholderMapper` // Returning `null` means that no name mapping is used. Serializer.prototype.createNameMapper = function (message) { return null; }; return Serializer; }()); /** * A simple mapper that take a function to transform an internal name to a public name */ var SimplePlaceholderMapper = /** @class */ (function (_super) { __extends(SimplePlaceholderMapper, _super); // create a mapping from the message function SimplePlaceholderMapper(message, mapName) { var _this = _super.call(this) || this; _this.mapName = mapName; _this.internalToPublic = {}; _this.publicToNextId = {}; _this.publicToInternal = {}; message.nodes.forEach(function (node) { return node.visit(_this); }); return _this; } SimplePlaceholderMapper.prototype.toPublicName = function (internalName) { return this.internalToPublic.hasOwnProperty(internalName) ? this.internalToPublic[internalName] : null; }; SimplePlaceholderMapper.prototype.toInternalName = function (publicName) { return this.publicToInternal.hasOwnProperty(publicName) ? this.publicToInternal[publicName] : null; }; SimplePlaceholderMapper.prototype.visitText = function (text, context) { return null; }; SimplePlaceholderMapper.prototype.visitTagPlaceholder = function (ph, context) { this.visitPlaceholderName(ph.startName); _super.prototype.visitTagPlaceholder.call(this, ph, context); this.visitPlaceholderName(ph.closeName); }; SimplePlaceholderMapper.prototype.visitPlaceholder = function (ph, context) { this.visitPlaceholderName(ph.name); }; SimplePlaceholderMapper.prototype.visitIcuPlaceholder = function (ph, context) { this.visitPlaceholderName(ph.name); }; // XMB placeholders could only contains A-Z, 0-9 and _ SimplePlaceholderMapper.prototype.visitPlaceholderName = function (internalName) { if (!internalName || this.internalToPublic.hasOwnProperty(internalName)) { return; } var publicName = this.mapName(internalName); if (this.publicToInternal.hasOwnProperty(publicName)) { // Create a new XMB when it has already been used var nextId = this.publicToNextId[publicName]; this.publicToNextId[publicName] = nextId + 1; publicName = publicName + "_" + nextId; } else { this.publicToNextId[publicName] = 1; } this.internalToPublic[internalName] = publicName; this.publicToInternal[publicName] = internalName; }; return SimplePlaceholderMapper; }(RecurseVisitor)); /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ var _Visitor = /** @class */ (function () { function _Visitor() { } _Visitor.prototype.visitTag = function (tag) { var _this = this; var strAttrs = this._serializeAttributes(tag.attrs); if (tag.children.length == 0) { return "<" + tag.name + strAttrs + "/>"; } var strChildren = tag.children.map(function (node) { return node.visit(_this); }); return "<" + tag.name + strAttrs + ">" + strChildren.join('') + ""; }; _Visitor.prototype.visitText = function (text) { return text.value; }; _Visitor.prototype.visitDeclaration = function (decl) { return ""; }; _Visitor.prototype._serializeAttributes = function (attrs) { var strAttrs = Object.keys(attrs).map(function (name) { return name + "=\"" + attrs[name] + "\""; }).join(' '); return strAttrs.length > 0 ? ' ' + strAttrs : ''; }; _Visitor.prototype.visitDoctype = function (doctype) { return ""; }; return _Visitor; }()); var _visitor = new _Visitor(); function serialize(nodes) { return nodes.map(function (node) { return node.visit(_visitor); }).join(''); } var Declaration = /** @class */ (function () { function Declaration(unescapedAttrs) { var _this = this; this.attrs = {}; Object.keys(unescapedAttrs).forEach(function (k) { _this.attrs[k] = escapeXml(unescapedAttrs[k]); }); } Declaration.prototype.visit = function (visitor) { return visitor.visitDeclaration(this); }; return Declaration; }()); var Doctype = /** @class */ (function () { function Doctype(rootTag, dtd) { this.rootTag = rootTag; this.dtd = dtd; } Doctype.prototype.visit = function (visitor) { return visitor.visitDoctype(this); }; return Doctype; }()); var Tag = /** @class */ (function () { function Tag(name, unescapedAttrs, children) { var _this = this; if (unescapedAttrs === void 0) { unescapedAttrs = {}; } if (children === void 0) { children = []; } this.name = name; this.children = children; this.attrs = {}; Object.keys(unescapedAttrs).forEach(function (k) { _this.attrs[k] = escapeXml(unescapedAttrs[k]); }); } Tag.prototype.visit = function (visitor) { return visitor.visitTag(this); }; return Tag; }()); var Text$2 = /** @class */ (function () { function Text(unescapedValue) { this.value = escapeXml(unescapedValue); } Text.prototype.visit = function (visitor) { return visitor.visitText(this); }; return Text; }()); var CR = /** @class */ (function (_super) { __extends(CR, _super); function CR(ws) { if (ws === void 0) { ws = 0; } return _super.call(this, "\n" + new Array(ws + 1).join(' ')) || this; } return CR; }(Text$2)); var _ESCAPED_CHARS = [ [/&/g, '&'], [/"/g, '"'], [/'/g, '''], [//g, '>'], ]; // Escape `_ESCAPED_CHARS` characters in the given text with encoded entities function escapeXml(text) { return _ESCAPED_CHARS.reduce(function (text, entry) { return text.replace(entry[0], entry[1]); }, text); } var _MESSAGES_TAG = 'messagebundle'; var _MESSAGE_TAG = 'msg'; var _PLACEHOLDER_TAG = 'ph'; var _EXAMPLE_TAG = 'ex'; var _SOURCE_TAG = 'source'; var _DOCTYPE = "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"; var Xmb = /** @class */ (function (_super) { __extends(Xmb, _super); function Xmb() { return _super !== null && _super.apply(this, arguments) || this; } Xmb.prototype.write = function (messages, locale) { var exampleVisitor = new ExampleVisitor(); var visitor = new _Visitor$1(); var rootNode = new Tag(_MESSAGES_TAG); messages.forEach(function (message) { var attrs = { id: message.id }; if (message.description) { attrs['desc'] = message.description; } if (message.meaning) { attrs['meaning'] = message.meaning; } var sourceTags = []; message.sources.forEach(function (source) { sourceTags.push(new Tag(_SOURCE_TAG, {}, [new Text$2(source.filePath + ":" + source.startLine + (source.endLine !== source.startLine ? ',' + source.endLine : ''))])); }); rootNode.children.push(new CR(2), new Tag(_MESSAGE_TAG, attrs, __spreadArray(__spreadArray([], __read(sourceTags)), __read(visitor.serialize(message.nodes))))); }); rootNode.children.push(new CR()); return serialize([ new Declaration({ version: '1.0', encoding: 'UTF-8' }), new CR(), new Doctype(_MESSAGES_TAG, _DOCTYPE), new CR(), exampleVisitor.addDefaultExamples(rootNode), new CR(), ]); }; Xmb.prototype.load = function (content, url) { throw new Error('Unsupported'); }; Xmb.prototype.digest = function (message) { return digest$1(message); }; Xmb.prototype.createNameMapper = function (message) { return new SimplePlaceholderMapper(message, toPublicName); }; return Xmb; }(Serializer)); var _Visitor$1 = /** @class */ (function () { function _Visitor() { } _Visitor.prototype.visitText = function (text, context) { return [new Text$2(text.value)]; }; _Visitor.prototype.visitContainer = function (container, context) { var _this = this; var nodes = []; container.children.forEach(function (node) { return nodes.push.apply(nodes, __spreadArray([], __read(node.visit(_this)))); }); return nodes; }; _Visitor.prototype.visitIcu = function (icu, context) { var _this = this; var nodes = [new Text$2("{" + icu.expressionPlaceholder + ", " + icu.type + ", ")]; Object.keys(icu.cases).forEach(function (c) { nodes.push.apply(nodes, __spreadArray(__spreadArray([new Text$2(c + " {")], __read(icu.cases[c].visit(_this))), [new Text$2("} ")])); }); nodes.push(new Text$2("}")); return nodes; }; _Visitor.prototype.visitTagPlaceholder = function (ph, context) { var startTagAsText = new Text$2("<" + ph.tag + ">"); var startEx = new Tag(_EXAMPLE_TAG, {}, [startTagAsText]); // TC requires PH to have a non empty EX, and uses the text node to show the "original" value. var startTagPh = new Tag(_PLACEHOLDER_TAG, { name: ph.startName }, [startEx, startTagAsText]); if (ph.isVoid) { // void tags have no children nor closing tags return [startTagPh]; } var closeTagAsText = new Text$2(""); var closeEx = new Tag(_EXAMPLE_TAG, {}, [closeTagAsText]); // TC requires PH to have a non empty EX, and uses the text node to show the "original" value. var closeTagPh = new Tag(_PLACEHOLDER_TAG, { name: ph.closeName }, [closeEx, closeTagAsText]); return __spreadArray(__spreadArray([startTagPh], __read(this.serialize(ph.children))), [closeTagPh]); }; _Visitor.prototype.visitPlaceholder = function (ph, context) { var interpolationAsText = new Text$2("{{" + ph.value + "}}"); // Example tag needs to be not-empty for TC. var exTag = new Tag(_EXAMPLE_TAG, {}, [interpolationAsText]); return [ // TC requires PH to have a non empty EX, and uses the text node to show the "original" value. new Tag(_PLACEHOLDER_TAG, { name: ph.name }, [exTag, interpolationAsText]) ]; }; _Visitor.prototype.visitIcuPlaceholder = function (ph, context) { var icuExpression = ph.value.expression; var icuType = ph.value.type; var icuCases = Object.keys(ph.value.cases).map(function (value) { return value + ' {...}'; }).join(' '); var icuAsText = new Text$2("{" + icuExpression + ", " + icuType + ", " + icuCases + "}"); var exTag = new Tag(_EXAMPLE_TAG, {}, [icuAsText]); return [ // TC requires PH to have a non empty EX, and uses the text node to show the "original" value. new Tag(_PLACEHOLDER_TAG, { name: ph.name }, [exTag, icuAsText]) ]; }; _Visitor.prototype.serialize = function (nodes) { var _this = this; return [].concat.apply([], __spreadArray([], __read(nodes.map(function (node) { return node.visit(_this); })))); }; return _Visitor; }()); function digest$1(message) { return decimalDigest(message); } // TC requires at least one non-empty example on placeholders var ExampleVisitor = /** @class */ (function () { function ExampleVisitor() { } ExampleVisitor.prototype.addDefaultExamples = function (node) { node.visit(this); return node; }; ExampleVisitor.prototype.visitTag = function (tag) { var _this = this; if (tag.name === _PLACEHOLDER_TAG) { if (!tag.children || tag.children.length == 0) { var exText = new Text$2(tag.attrs['name'] || '...'); tag.children = [new Tag(_EXAMPLE_TAG, {}, [exText])]; } } else if (tag.children) { tag.children.forEach(function (node) { return node.visit(_this); }); } }; ExampleVisitor.prototype.visitText = function (text) { }; ExampleVisitor.prototype.visitDeclaration = function (decl) { }; ExampleVisitor.prototype.visitDoctype = function (doctype) { }; return ExampleVisitor; }()); // XMB/XTB placeholders can only contain A-Z, 0-9 and _ function toPublicName(internalName) { return internalName.toUpperCase().replace(/[^A-Z0-9_]/g, '_'); } /* Closure variables holding messages must be named `MSG_[A-Z0-9]+` */ var CLOSURE_TRANSLATION_VAR_PREFIX = 'MSG_'; /** * Prefix for non-`goog.getMsg` i18n-related vars. * Note: the prefix uses lowercase characters intentionally due to a Closure behavior that * considers variables like `I18N_0` as constants and throws an error when their value changes. */ var TRANSLATION_VAR_PREFIX = 'i18n_'; /** Name of the i18n attributes **/ var I18N_ATTR = 'i18n'; var I18N_ATTR_PREFIX = 'i18n-'; /** Prefix of var expressions used in ICUs */ var I18N_ICU_VAR_PREFIX = 'VAR_'; /** Prefix of ICU expressions for post processing */ var I18N_ICU_MAPPING_PREFIX = 'I18N_EXP_'; /** Placeholder wrapper for i18n expressions **/ var I18N_PLACEHOLDER_SYMBOL = '�'; function isI18nAttribute(name) { return name === I18N_ATTR || name.startsWith(I18N_ATTR_PREFIX); } function isI18nRootNode(meta) { return meta instanceof Message; } function isSingleI18nIcu(meta) { return isI18nRootNode(meta) && meta.nodes.length === 1 && meta.nodes[0] instanceof Icu$1; } function hasI18nMeta(node) { return !!node.i18n; } function hasI18nAttrs(element) { return element.attrs.some(function (attr) { return isI18nAttribute(attr.name); }); } function icuFromI18nMessage(message) { return message.nodes[0]; } function wrapI18nPlaceholder(content, contextId) { if (contextId === void 0) { contextId = 0; } var blockId = contextId > 0 ? ":" + contextId : ''; return "" + I18N_PLACEHOLDER_SYMBOL + content + blockId + I18N_PLACEHOLDER_SYMBOL; } function assembleI18nBoundString(strings, bindingStartIndex, contextId) { if (bindingStartIndex === void 0) { bindingStartIndex = 0; } if (contextId === void 0) { contextId = 0; } if (!strings.length) return ''; var acc = ''; var lastIdx = strings.length - 1; for (var i = 0; i < lastIdx; i++) { acc += "" + strings[i] + wrapI18nPlaceholder(bindingStartIndex + i, contextId); } acc += strings[lastIdx]; return acc; } function getSeqNumberGenerator(startsAt) { if (startsAt === void 0) { startsAt = 0; } var current = startsAt; return function () { return current++; }; } function placeholdersToParams(placeholders) { var params = {}; placeholders.forEach(function (values, key) { params[key] = literal(values.length > 1 ? "[" + values.join('|') + "]" : values[0]); }); return params; } function updatePlaceholderMap(map, name) { var values = []; for (var _i = 2; _i < arguments.length; _i++) { values[_i - 2] = arguments[_i]; } var current = map.get(name) || []; current.push.apply(current, __spreadArray([], __read(values))); map.set(name, current); } function assembleBoundTextPlaceholders(meta, bindingStartIndex, contextId) { if (bindingStartIndex === void 0) { bindingStartIndex = 0; } if (contextId === void 0) { contextId = 0; } var startIdx = bindingStartIndex; var placeholders = new Map(); var node = meta instanceof Message ? meta.nodes.find(function (node) { return node instanceof Container; }) : meta; if (node) { node .children .filter(function (child) { return child instanceof Placeholder; }) .forEach(function (child, idx) { var content = wrapI18nPlaceholder(startIdx + idx, contextId); updatePlaceholderMap(placeholders, child.name, content); }); } return placeholders; } /** * Format the placeholder names in a map of placeholders to expressions. * * The placeholder names are converted from "internal" format (e.g. `START_TAG_DIV_1`) to "external" * format (e.g. `startTagDiv_1`). * * @param params A map of placeholder names to expressions. * @param useCamelCase whether to camelCase the placeholder name when formatting. * @returns A new map of formatted placeholder names to expressions. */ function i18nFormatPlaceholderNames(params, useCamelCase) { if (params === void 0) { params = {}; } var _params = {}; if (params && Object.keys(params).length) { Object.keys(params).forEach(function (key) { return _params[formatI18nPlaceholderName(key, useCamelCase)] = params[key]; }); } return _params; } /** * Converts internal placeholder names to public-facing format * (for example to use in goog.getMsg call). * Example: `START_TAG_DIV_1` is converted to `startTagDiv_1`. * * @param name The placeholder name that should be formatted * @returns Formatted placeholder name */ function formatI18nPlaceholderName(name, useCamelCase) { if (useCamelCase === void 0) { useCamelCase = true; } var publicName = toPublicName(name); if (!useCamelCase) { return publicName; } var chunks = publicName.split('_'); if (chunks.length === 1) { // if no "_" found - just lowercase the value return name.toLowerCase(); } var postfix; // eject last element if it's a number if (/^\d+$/.test(chunks[chunks.length - 1])) { postfix = chunks.pop(); } var raw = chunks.shift().toLowerCase(); if (chunks.length) { raw += chunks.map(function (c) { return c.charAt(0).toUpperCase() + c.slice(1).toLowerCase(); }).join(''); } return postfix ? raw + "_" + postfix : raw; } /** * Generates a prefix for translation const name. * * @param extra Additional local prefix that should be injected into translation var name * @returns Complete translation const prefix */ function getTranslationConstPrefix(extra) { return ("" + CLOSURE_TRANSLATION_VAR_PREFIX + extra).toUpperCase(); } /** * Generate AST to declare a variable. E.g. `var I18N_1;`. * @param variable the name of the variable to declare. */ function declareI18nVariable(variable) { return new DeclareVarStmt(variable.name, undefined, INFERRED_TYPE, undefined, variable.sourceSpan); } /** * Checks whether an object key contains potentially unsafe chars, thus the key should be wrapped in * quotes. Note: we do not wrap all keys into quotes, as it may have impact on minification and may * bot work in some cases when object keys are mangled by minifier. * * TODO(FW-1136): this is a temporary solution, we need to come up with a better way of working with * inputs that contain potentially unsafe chars. */ var UNSAFE_OBJECT_KEY_NAME_REGEXP = /[-.]/; /** Name of the temporary to use during data binding */ var TEMPORARY_NAME = '_t'; /** Name of the context parameter passed into a template function */ var CONTEXT_NAME = 'ctx'; /** Name of the RenderFlag passed into a template function */ var RENDER_FLAGS = 'rf'; /** The prefix reference variables */ var REFERENCE_PREFIX = '_r'; /** The name of the implicit context reference */ var IMPLICIT_REFERENCE = '$implicit'; /** Non bindable attribute name **/ var NON_BINDABLE_ATTR = 'ngNonBindable'; /** Name for the variable keeping track of the context returned by `ɵɵrestoreView`. */ var RESTORED_VIEW_CONTEXT_NAME = 'restoredCtx'; /** * Creates an allocator for a temporary variable. * * A variable declaration is added to the statements the first time the allocator is invoked. */ function temporaryAllocator(statements, name) { var temp = null; return function () { if (!temp) { statements.push(new DeclareVarStmt(TEMPORARY_NAME, undefined, DYNAMIC_TYPE)); temp = variable(name); } return temp; }; } function unsupported(feature) { if (this) { throw new Error("Builder " + this.constructor.name + " doesn't support " + feature + " yet"); } throw new Error("Feature " + feature + " is not supported yet"); } function invalid$1(arg) { throw new Error("Invalid state: Visitor " + this.constructor.name + " doesn't handle " + arg.constructor.name); } function asLiteral(value) { if (Array.isArray(value)) { return literalArr(value.map(asLiteral)); } return literal(value, INFERRED_TYPE); } function conditionallyCreateMapObjectLiteral(keys, keepDeclared) { if (Object.getOwnPropertyNames(keys).length > 0) { return mapToExpression(keys, keepDeclared); } return null; } function mapToExpression(map, keepDeclared) { return literalMap(Object.getOwnPropertyNames(map).map(function (key) { var _a, _b; // canonical syntax: `dirProp: publicProp` // if there is no `:`, use dirProp = elProp var value = map[key]; var declaredName; var publicName; var minifiedName; var needsDeclaredName; if (Array.isArray(value)) { _a = __read(value, 2), publicName = _a[0], declaredName = _a[1]; minifiedName = key; needsDeclaredName = publicName !== declaredName; } else { _b = __read(splitAtColon(key, [key, value]), 2), declaredName = _b[0], publicName = _b[1]; minifiedName = declaredName; // Only include the declared name if extracted from the key, i.e. the key contains a colon. // Otherwise the declared name should be omitted even if it is different from the public name, // as it may have already been minified. needsDeclaredName = publicName !== declaredName && key.includes(':'); } return { key: minifiedName, // put quotes around keys that contain potentially unsafe characters quoted: UNSAFE_OBJECT_KEY_NAME_REGEXP.test(minifiedName), value: (keepDeclared && needsDeclaredName) ? literalArr([asLiteral(publicName), asLiteral(declaredName)]) : asLiteral(publicName) }; })); } /** * Remove trailing null nodes as they are implied. */ function trimTrailingNulls(parameters) { while (isNull(parameters[parameters.length - 1])) { parameters.pop(); } return parameters; } function getQueryPredicate(query, constantPool) { if (Array.isArray(query.predicate)) { var predicate_1 = []; query.predicate.forEach(function (selector) { // Each item in predicates array may contain strings with comma-separated refs // (for ex. 'ref, ref1, ..., refN'), thus we extract individual refs and store them // as separate array entities var selectors = selector.split(',').map(function (token) { return literal(token.trim()); }); predicate_1.push.apply(predicate_1, __spreadArray([], __read(selectors))); }); return constantPool.getConstLiteral(literalArr(predicate_1), true); } else { // The original predicate may have been wrapped in a `forwardRef()` call. switch (query.predicate.forwardRef) { case 0 /* None */: case 2 /* Unwrapped */: return query.predicate.expression; case 1 /* Wrapped */: return importExpr(Identifiers.resolveForwardRef).callFn([query.predicate.expression]); } } } /** * A representation for an object literal used during codegen of definition objects. The generic * type `T` allows to reference a documented type of the generated structure, such that the * property names that are set can be resolved to their documented declaration. */ var DefinitionMap = /** @class */ (function () { function DefinitionMap() { this.values = []; } DefinitionMap.prototype.set = function (key, value) { if (value) { this.values.push({ key: key, value: value, quoted: false }); } }; DefinitionMap.prototype.toLiteralMap = function () { return literalMap(this.values); }; return DefinitionMap; }()); /** * Extract a map of properties to values for a given element or template node, which can be used * by the directive matching machinery. * * @param elOrTpl the element or template in question * @return an object set up for directive matching. For attributes on the element/template, this * object maps a property name to its (static) value. For any bindings, this map simply maps the * property name to an empty string. */ function getAttrsForDirectiveMatching(elOrTpl) { var attributesMap = {}; if (elOrTpl instanceof Template && elOrTpl.tagName !== 'ng-template') { elOrTpl.templateAttrs.forEach(function (a) { return attributesMap[a.name] = ''; }); } else { elOrTpl.attributes.forEach(function (a) { if (!isI18nAttribute(a.name)) { attributesMap[a.name] = a.value; } }); elOrTpl.inputs.forEach(function (i) { attributesMap[i.name] = ''; }); elOrTpl.outputs.forEach(function (o) { attributesMap[o.name] = ''; }); } return attributesMap; } /** Returns a call expression to a chained instruction, e.g. `property(params[0])(params[1])`. */ function chainedInstruction(reference, calls, span) { var expression = importExpr(reference, null, span); if (calls.length > 0) { for (var i = 0; i < calls.length; i++) { expression = expression.callFn(calls[i], span); } } else { // Add a blank invocation, in case the `calls` array is empty. expression = expression.callFn([], span); } return expression; } /** * Gets the number of arguments expected to be passed to a generated instruction in the case of * interpolation instructions. * @param interpolation An interpolation ast */ function getInterpolationArgsLength(interpolation) { var expressions = interpolation.expressions, strings = interpolation.strings; if (expressions.length === 1 && strings.length === 2 && strings[0] === '' && strings[1] === '') { // If the interpolation has one interpolated value, but the prefix and suffix are both empty // strings, we only pass one argument, to a special instruction like `propertyInterpolate` or // `textInterpolate`. return 1; } else { return expressions.length + strings.length; } } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ function compileInjectable(meta, resolveForwardRefs) { var result = null; var factoryMeta = { name: meta.name, type: meta.type, internalType: meta.internalType, typeArgumentCount: meta.typeArgumentCount, deps: [], target: exports.FactoryTarget.Injectable, }; if (meta.useClass !== undefined) { // meta.useClass has two modes of operation. Either deps are specified, in which case `new` is // used to instantiate the class with dependencies injected, or deps are not specified and // the factory of the class is used to instantiate it. // // A special case exists for useClass: Type where Type is the injectable type itself and no // deps are specified, in which case 'useClass' is effectively ignored. var useClassOnSelf = meta.useClass.expression.isEquivalent(meta.internalType); var deps = undefined; if (meta.deps !== undefined) { deps = meta.deps; } if (deps !== undefined) { // factory: () => new meta.useClass(...deps) result = compileFactoryFunction(Object.assign(Object.assign({}, factoryMeta), { delegate: meta.useClass.expression, delegateDeps: deps, delegateType: R3FactoryDelegateType.Class })); } else if (useClassOnSelf) { result = compileFactoryFunction(factoryMeta); } else { result = { statements: [], expression: delegateToFactory(meta.type.value, meta.useClass.expression, resolveForwardRefs) }; } } else if (meta.useFactory !== undefined) { if (meta.deps !== undefined) { result = compileFactoryFunction(Object.assign(Object.assign({}, factoryMeta), { delegate: meta.useFactory, delegateDeps: meta.deps || [], delegateType: R3FactoryDelegateType.Function })); } else { result = { statements: [], expression: fn([], [new ReturnStatement(meta.useFactory.callFn([]))]) }; } } else if (meta.useValue !== undefined) { // Note: it's safe to use `meta.useValue` instead of the `USE_VALUE in meta` check used for // client code because meta.useValue is an Expression which will be defined even if the actual // value is undefined. result = compileFactoryFunction(Object.assign(Object.assign({}, factoryMeta), { expression: meta.useValue.expression })); } else if (meta.useExisting !== undefined) { // useExisting is an `inject` call on the existing token. result = compileFactoryFunction(Object.assign(Object.assign({}, factoryMeta), { expression: importExpr(Identifiers.inject).callFn([meta.useExisting.expression]) })); } else { result = { statements: [], expression: delegateToFactory(meta.type.value, meta.internalType, resolveForwardRefs) }; } var token = meta.internalType; var injectableProps = new DefinitionMap(); injectableProps.set('token', token); injectableProps.set('factory', result.expression); // Only generate providedIn property if it has a non-null value if (meta.providedIn.expression.value !== null) { injectableProps.set('providedIn', convertFromMaybeForwardRefExpression(meta.providedIn)); } var expression = importExpr(Identifiers.ɵɵdefineInjectable) .callFn([injectableProps.toLiteralMap()], undefined, true); return { expression: expression, type: createInjectableType(meta), statements: result.statements, }; } function createInjectableType(meta) { return new ExpressionType(importExpr(Identifiers.InjectableDeclaration, [typeWithParameters(meta.type.type, meta.typeArgumentCount)])); } function delegateToFactory(type, internalType, unwrapForwardRefs) { if (type.node === internalType.node) { // The types are the same, so we can simply delegate directly to the type's factory. // ``` // factory: type.ɵfac // ``` return internalType.prop('ɵfac'); } if (!unwrapForwardRefs) { // The type is not wrapped in a `forwardRef()`, so we create a simple factory function that // accepts a sub-type as an argument. // ``` // factory: function(t) { return internalType.ɵfac(t); } // ``` return createFactoryFunction(internalType); } // The internalType is actually wrapped in a `forwardRef()` so we need to resolve that before // calling its factory. // ``` // factory: function(t) { return core.resolveForwardRef(type).ɵfac(t); } // ``` var unwrappedType = importExpr(Identifiers.resolveForwardRef).callFn([internalType]); return createFactoryFunction(unwrappedType); } function createFactoryFunction(type) { return fn([new FnParam('t', DYNAMIC_TYPE)], [new ReturnStatement(type.callMethod('ɵfac', [variable('t')]))]); } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ function assertArrayOfStrings(identifier, value) { if (value == null) { return; } if (!Array.isArray(value)) { throw new Error("Expected '" + identifier + "' to be an array of strings."); } for (var i = 0; i < value.length; i += 1) { if (typeof value[i] !== 'string') { throw new Error("Expected '" + identifier + "' to be an array of strings."); } } } var UNUSABLE_INTERPOLATION_REGEXPS = [ /^\s*$/, /[<>]/, /^[{}]$/, /&(#|[a-z])/i, /^\/\//, // comment ]; function assertInterpolationSymbols(identifier, value) { if (value != null && !(Array.isArray(value) && value.length == 2)) { throw new Error("Expected '" + identifier + "' to be an array, [start, end]."); } else if (value != null) { var start_1 = value[0]; var end_1 = value[1]; // Check for unusable interpolation symbols UNUSABLE_INTERPOLATION_REGEXPS.forEach(function (regexp) { if (regexp.test(start_1) || regexp.test(end_1)) { throw new Error("['" + start_1 + "', '" + end_1 + "'] contains unusable interpolation symbol."); } }); } } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ var InterpolationConfig = /** @class */ (function () { function InterpolationConfig(start, end) { this.start = start; this.end = end; } InterpolationConfig.fromArray = function (markers) { if (!markers) { return DEFAULT_INTERPOLATION_CONFIG; } assertInterpolationSymbols('interpolation', markers); return new InterpolationConfig(markers[0], markers[1]); }; return InterpolationConfig; }()); var DEFAULT_INTERPOLATION_CONFIG = new InterpolationConfig('{{', '}}'); /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ /** * A token representing the a reference to a static type. * * This token is unique for a filePath and name and can be used as a hash table key. */ var StaticSymbol = /** @class */ (function () { function StaticSymbol(filePath, name, members) { this.filePath = filePath; this.name = name; this.members = members; } StaticSymbol.prototype.assertNoMembers = function () { if (this.members.length) { throw new Error("Illegal state: symbol without members expected, but got " + JSON.stringify(this) + "."); } }; return StaticSymbol; }()); /** * A cache of static symbol used by the StaticReflector to return the same symbol for the * same symbol values. */ var StaticSymbolCache = /** @class */ (function () { function StaticSymbolCache() { this.cache = new Map(); } StaticSymbolCache.prototype.get = function (declarationFile, name, members) { members = members || []; var memberSuffix = members.length ? "." + members.join('.') : ''; var key = "\"" + declarationFile + "\"." + name + memberSuffix; var result = this.cache.get(key); if (!result) { result = new StaticSymbol(declarationFile, name, members); this.cache.set(key, result); } return result; }; return StaticSymbolCache; }()); /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ var $EOF = 0; var $BSPACE = 8; var $TAB = 9; var $LF = 10; var $VTAB = 11; var $FF = 12; var $CR = 13; var $SPACE = 32; var $BANG = 33; var $DQ = 34; var $HASH = 35; var $$ = 36; var $PERCENT = 37; var $AMPERSAND = 38; var $SQ = 39; var $LPAREN = 40; var $RPAREN = 41; var $STAR = 42; var $PLUS = 43; var $COMMA = 44; var $MINUS = 45; var $PERIOD = 46; var $SLASH = 47; var $COLON = 58; var $SEMICOLON = 59; var $LT = 60; var $EQ = 61; var $GT = 62; var $QUESTION = 63; var $0 = 48; var $7 = 55; var $9 = 57; var $A = 65; var $E = 69; var $F = 70; var $X = 88; var $Z = 90; var $LBRACKET = 91; var $BACKSLASH = 92; var $RBRACKET = 93; var $CARET = 94; var $_ = 95; var $a = 97; var $b = 98; var $e = 101; var $f = 102; var $n = 110; var $r = 114; var $t = 116; var $u = 117; var $v = 118; var $x = 120; var $z = 122; var $LBRACE = 123; var $BAR = 124; var $RBRACE = 125; var $NBSP = 160; var $PIPE = 124; var $TILDA = 126; var $AT = 64; var $BT = 96; function isWhitespace(code) { return (code >= $TAB && code <= $SPACE) || (code == $NBSP); } function isDigit(code) { return $0 <= code && code <= $9; } function isAsciiLetter(code) { return code >= $a && code <= $z || code >= $A && code <= $Z; } function isAsciiHexDigit(code) { return code >= $a && code <= $f || code >= $A && code <= $F || isDigit(code); } function isNewLine(code) { return code === $LF || code === $CR; } function isOctalDigit(code) { return $0 <= code && code <= $7; } function isQuote(code) { return code === $SQ || code === $DQ || code === $BT; } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ var ParseLocation = /** @class */ (function () { function ParseLocation(file, offset, line, col) { this.file = file; this.offset = offset; this.line = line; this.col = col; } ParseLocation.prototype.toString = function () { return this.offset != null ? this.file.url + "@" + this.line + ":" + this.col : this.file.url; }; ParseLocation.prototype.moveBy = function (delta) { var source = this.file.content; var len = source.length; var offset = this.offset; var line = this.line; var col = this.col; while (offset > 0 && delta < 0) { offset--; delta++; var ch = source.charCodeAt(offset); if (ch == $LF) { line--; var priorLine = source.substr(0, offset - 1).lastIndexOf(String.fromCharCode($LF)); col = priorLine > 0 ? offset - priorLine : offset; } else { col--; } } while (offset < len && delta > 0) { var ch = source.charCodeAt(offset); offset++; delta--; if (ch == $LF) { line++; col = 0; } else { col++; } } return new ParseLocation(this.file, offset, line, col); }; // Return the source around the location // Up to `maxChars` or `maxLines` on each side of the location ParseLocation.prototype.getContext = function (maxChars, maxLines) { var content = this.file.content; var startOffset = this.offset; if (startOffset != null) { if (startOffset > content.length - 1) { startOffset = content.length - 1; } var endOffset = startOffset; var ctxChars = 0; var ctxLines = 0; while (ctxChars < maxChars && startOffset > 0) { startOffset--; ctxChars++; if (content[startOffset] == '\n') { if (++ctxLines == maxLines) { break; } } } ctxChars = 0; ctxLines = 0; while (ctxChars < maxChars && endOffset < content.length - 1) { endOffset++; ctxChars++; if (content[endOffset] == '\n') { if (++ctxLines == maxLines) { break; } } } return { before: content.substring(startOffset, this.offset), after: content.substring(this.offset, endOffset + 1), }; } return null; }; return ParseLocation; }()); var ParseSourceFile = /** @class */ (function () { function ParseSourceFile(content, url) { this.content = content; this.url = url; } return ParseSourceFile; }()); var ParseSourceSpan = /** @class */ (function () { /** * Create an object that holds information about spans of tokens/nodes captured during * lexing/parsing of text. * * @param start * The location of the start of the span (having skipped leading trivia). * Skipping leading trivia makes source-spans more "user friendly", since things like HTML * elements will appear to begin at the start of the opening tag, rather than at the start of any * leading trivia, which could include newlines. * * @param end * The location of the end of the span. * * @param fullStart * The start of the token without skipping the leading trivia. * This is used by tooling that splits tokens further, such as extracting Angular interpolations * from text tokens. Such tooling creates new source-spans relative to the original token's * source-span. If leading trivia characters have been skipped then the new source-spans may be * incorrectly offset. * * @param details * Additional information (such as identifier names) that should be associated with the span. */ function ParseSourceSpan(start, end, fullStart, details) { if (fullStart === void 0) { fullStart = start; } if (details === void 0) { details = null; } this.start = start; this.end = end; this.fullStart = fullStart; this.details = details; } ParseSourceSpan.prototype.toString = function () { return this.start.file.content.substring(this.start.offset, this.end.offset); }; return ParseSourceSpan; }()); (function (ParseErrorLevel) { ParseErrorLevel[ParseErrorLevel["WARNING"] = 0] = "WARNING"; ParseErrorLevel[ParseErrorLevel["ERROR"] = 1] = "ERROR"; })(exports.ParseErrorLevel || (exports.ParseErrorLevel = {})); var ParseError = /** @class */ (function () { function ParseError(span, msg, level) { if (level === void 0) { level = exports.ParseErrorLevel.ERROR; } this.span = span; this.msg = msg; this.level = level; } ParseError.prototype.contextualMessage = function () { var ctx = this.span.start.getContext(100, 3); return ctx ? this.msg + " (\"" + ctx.before + "[" + exports.ParseErrorLevel[this.level] + " ->]" + ctx.after + "\")" : this.msg; }; ParseError.prototype.toString = function () { var details = this.span.details ? ", " + this.span.details : ''; return this.contextualMessage() + ": " + this.span.start + details; }; return ParseError; }()); function typeSourceSpan(kind, type) { var moduleUrl = identifierModuleUrl(type); var sourceFileName = moduleUrl != null ? "in " + kind + " " + identifierName(type) + " in " + moduleUrl : "in " + kind + " " + identifierName(type); var sourceFile = new ParseSourceFile('', sourceFileName); return new ParseSourceSpan(new ParseLocation(sourceFile, -1, -1, -1), new ParseLocation(sourceFile, -1, -1, -1)); } /** * Generates Source Span object for a given R3 Type for JIT mode. * * @param kind Component or Directive. * @param typeName name of the Component or Directive. * @param sourceUrl reference to Component or Directive source. * @returns instance of ParseSourceSpan that represent a given Component or Directive. */ function r3JitTypeSourceSpan(kind, typeName, sourceUrl) { var sourceFileName = "in " + kind + " " + typeName + " in " + sourceUrl; var sourceFile = new ParseSourceFile('', sourceFileName); return new ParseSourceSpan(new ParseLocation(sourceFile, -1, -1, -1), new ParseLocation(sourceFile, -1, -1, -1)); } function syntaxError(msg, parseErrors) { var error = Error(msg); error[ERROR_SYNTAX_ERROR] = true; if (parseErrors) error[ERROR_PARSE_ERRORS] = parseErrors; return error; } var ERROR_SYNTAX_ERROR = 'ngSyntaxError'; var ERROR_PARSE_ERRORS = 'ngParseErrors'; function isSyntaxError(error) { return error[ERROR_SYNTAX_ERROR]; } function getParseErrors(error) { return error[ERROR_PARSE_ERRORS] || []; } var _anonymousTypeIndex = 0; function identifierName(compileIdentifier) { if (!compileIdentifier || !compileIdentifier.reference) { return null; } var ref = compileIdentifier.reference; if (ref instanceof StaticSymbol) { return ref.name; } if (ref['__anonymousType']) { return ref['__anonymousType']; } if (ref['__forward_ref__']) { // We do not want to try to stringify a `forwardRef()` function because that would cause the // inner function to be evaluated too early, defeating the whole point of the `forwardRef`. return '__forward_ref__'; } var identifier = stringify(ref); if (identifier.indexOf('(') >= 0) { // case: anonymous functions! identifier = "anonymous_" + _anonymousTypeIndex++; ref['__anonymousType'] = identifier; } else { identifier = sanitizeIdentifier(identifier); } return identifier; } function identifierModuleUrl(compileIdentifier) { var ref = compileIdentifier.reference; if (ref instanceof StaticSymbol) { return ref.filePath; } // Runtime type return "./" + stringify(ref); } function sanitizeIdentifier(name) { return name.replace(/\W/g, '_'); } /** * In TypeScript, tagged template functions expect a "template object", which is an array of * "cooked" strings plus a `raw` property that contains an array of "raw" strings. This is * typically constructed with a function called `__makeTemplateObject(cooked, raw)`, but it may not * be available in all environments. * * This is a JavaScript polyfill that uses __makeTemplateObject when it's available, but otherwise * creates an inline helper with the same functionality. * * In the inline function, if `Object.defineProperty` is available we use that to attach the `raw` * array. */ var makeTemplateObjectPolyfill = '(this&&this.__makeTemplateObject||function(e,t){return Object.defineProperty?Object.defineProperty(e,"raw",{value:t}):e.raw=t,e})'; var AbstractJsEmitterVisitor = /** @class */ (function (_super) { __extends(AbstractJsEmitterVisitor, _super); function AbstractJsEmitterVisitor() { return _super.call(this, false) || this; } AbstractJsEmitterVisitor.prototype.visitDeclareClassStmt = function (stmt, ctx) { var _this = this; ctx.pushClass(stmt); this._visitClassConstructor(stmt, ctx); if (stmt.parent != null) { ctx.print(stmt, stmt.name + ".prototype = Object.create("); stmt.parent.visitExpression(this, ctx); ctx.println(stmt, ".prototype);"); } stmt.getters.forEach(function (getter) { return _this._visitClassGetter(stmt, getter, ctx); }); stmt.methods.forEach(function (method) { return _this._visitClassMethod(stmt, method, ctx); }); ctx.popClass(); return null; }; AbstractJsEmitterVisitor.prototype._visitClassConstructor = function (stmt, ctx) { ctx.print(stmt, "function " + stmt.name + "("); if (stmt.constructorMethod != null) { this._visitParams(stmt.constructorMethod.params, ctx); } ctx.println(stmt, ") {"); ctx.incIndent(); if (stmt.constructorMethod != null) { if (stmt.constructorMethod.body.length > 0) { ctx.println(stmt, "var self = this;"); this.visitAllStatements(stmt.constructorMethod.body, ctx); } } ctx.decIndent(); ctx.println(stmt, "}"); }; AbstractJsEmitterVisitor.prototype._visitClassGetter = function (stmt, getter, ctx) { ctx.println(stmt, "Object.defineProperty(" + stmt.name + ".prototype, '" + getter.name + "', { get: function() {"); ctx.incIndent(); if (getter.body.length > 0) { ctx.println(stmt, "var self = this;"); this.visitAllStatements(getter.body, ctx); } ctx.decIndent(); ctx.println(stmt, "}});"); }; AbstractJsEmitterVisitor.prototype._visitClassMethod = function (stmt, method, ctx) { ctx.print(stmt, stmt.name + ".prototype." + method.name + " = function("); this._visitParams(method.params, ctx); ctx.println(stmt, ") {"); ctx.incIndent(); if (method.body.length > 0) { ctx.println(stmt, "var self = this;"); this.visitAllStatements(method.body, ctx); } ctx.decIndent(); ctx.println(stmt, "};"); }; AbstractJsEmitterVisitor.prototype.visitWrappedNodeExpr = function (ast, ctx) { throw new Error('Cannot emit a WrappedNodeExpr in Javascript.'); }; AbstractJsEmitterVisitor.prototype.visitReadVarExpr = function (ast, ctx) { if (ast.builtin === exports.BuiltinVar.This) { ctx.print(ast, 'self'); } else if (ast.builtin === exports.BuiltinVar.Super) { throw new Error("'super' needs to be handled at a parent ast node, not at the variable level!"); } else { _super.prototype.visitReadVarExpr.call(this, ast, ctx); } return null; }; AbstractJsEmitterVisitor.prototype.visitDeclareVarStmt = function (stmt, ctx) { ctx.print(stmt, "var " + stmt.name); if (stmt.value) { ctx.print(stmt, ' = '); stmt.value.visitExpression(this, ctx); } ctx.println(stmt, ";"); return null; }; AbstractJsEmitterVisitor.prototype.visitCastExpr = function (ast, ctx) { ast.value.visitExpression(this, ctx); return null; }; AbstractJsEmitterVisitor.prototype.visitInvokeFunctionExpr = function (expr, ctx) { var fnExpr = expr.fn; if (fnExpr instanceof ReadVarExpr && fnExpr.builtin === exports.BuiltinVar.Super) { ctx.currentClass.parent.visitExpression(this, ctx); ctx.print(expr, ".call(this"); if (expr.args.length > 0) { ctx.print(expr, ", "); this.visitAllExpressions(expr.args, ctx, ','); } ctx.print(expr, ")"); } else { _super.prototype.visitInvokeFunctionExpr.call(this, expr, ctx); } return null; }; AbstractJsEmitterVisitor.prototype.visitTaggedTemplateExpr = function (ast, ctx) { var _this = this; // The following convoluted piece of code is effectively the downlevelled equivalent of // ``` // tag`...` // ``` // which is effectively like: // ``` // tag(__makeTemplateObject(cooked, raw), expression1, expression2, ...); // ``` var elements = ast.template.elements; ast.tag.visitExpression(this, ctx); ctx.print(ast, "(" + makeTemplateObjectPolyfill + "("); ctx.print(ast, "[" + elements.map(function (part) { return escapeIdentifier(part.text, false); }).join(', ') + "], "); ctx.print(ast, "[" + elements.map(function (part) { return escapeIdentifier(part.rawText, false); }).join(', ') + "])"); ast.template.expressions.forEach(function (expression) { ctx.print(ast, ', '); expression.visitExpression(_this, ctx); }); ctx.print(ast, ')'); return null; }; AbstractJsEmitterVisitor.prototype.visitFunctionExpr = function (ast, ctx) { ctx.print(ast, "function" + (ast.name ? ' ' + ast.name : '') + "("); this._visitParams(ast.params, ctx); ctx.println(ast, ") {"); ctx.incIndent(); this.visitAllStatements(ast.statements, ctx); ctx.decIndent(); ctx.print(ast, "}"); return null; }; AbstractJsEmitterVisitor.prototype.visitDeclareFunctionStmt = function (stmt, ctx) { ctx.print(stmt, "function " + stmt.name + "("); this._visitParams(stmt.params, ctx); ctx.println(stmt, ") {"); ctx.incIndent(); this.visitAllStatements(stmt.statements, ctx); ctx.decIndent(); ctx.println(stmt, "}"); return null; }; AbstractJsEmitterVisitor.prototype.visitTryCatchStmt = function (stmt, ctx) { ctx.println(stmt, "try {"); ctx.incIndent(); this.visitAllStatements(stmt.bodyStmts, ctx); ctx.decIndent(); ctx.println(stmt, "} catch (" + CATCH_ERROR_VAR$1.name + ") {"); ctx.incIndent(); var catchStmts = [CATCH_STACK_VAR$1.set(CATCH_ERROR_VAR$1.prop('stack')).toDeclStmt(null, [ exports.StmtModifier.Final ])].concat(stmt.catchStmts); this.visitAllStatements(catchStmts, ctx); ctx.decIndent(); ctx.println(stmt, "}"); return null; }; AbstractJsEmitterVisitor.prototype.visitLocalizedString = function (ast, ctx) { var _this = this; // The following convoluted piece of code is effectively the downlevelled equivalent of // ``` // $localize `...` // ``` // which is effectively like: // ``` // $localize(__makeTemplateObject(cooked, raw), expression1, expression2, ...); // ``` ctx.print(ast, "$localize(" + makeTemplateObjectPolyfill + "("); var parts = [ast.serializeI18nHead()]; for (var i = 1; i < ast.messageParts.length; i++) { parts.push(ast.serializeI18nTemplatePart(i)); } ctx.print(ast, "[" + parts.map(function (part) { return escapeIdentifier(part.cooked, false); }).join(', ') + "], "); ctx.print(ast, "[" + parts.map(function (part) { return escapeIdentifier(part.raw, false); }).join(', ') + "])"); ast.expressions.forEach(function (expression) { ctx.print(ast, ', '); expression.visitExpression(_this, ctx); }); ctx.print(ast, ')'); return null; }; AbstractJsEmitterVisitor.prototype._visitParams = function (params, ctx) { this.visitAllObjects(function (param) { return ctx.print(null, param.name); }, params, ctx, ','); }; AbstractJsEmitterVisitor.prototype.getBuiltinMethodName = function (method) { var name; switch (method) { case exports.BuiltinMethod.ConcatArray: name = 'concat'; break; case exports.BuiltinMethod.SubscribeObservable: name = 'subscribe'; break; case exports.BuiltinMethod.Bind: name = 'bind'; break; default: throw new Error("Unknown builtin method: " + method); } return name; }; return AbstractJsEmitterVisitor; }(AbstractEmitterVisitor)); /** * The Trusted Types policy, or null if Trusted Types are not * enabled/supported, or undefined if the policy has not been created yet. */ var policy; /** * Returns the Trusted Types policy, or null if Trusted Types are not * enabled/supported. The first call to this function will create the policy. */ function getPolicy() { if (policy === undefined) { policy = null; if (_global.trustedTypes) { try { policy = _global.trustedTypes.createPolicy('angular#unsafe-jit', { createScript: function (s) { return s; }, }); } catch (_a) { // trustedTypes.createPolicy throws if called with a name that is // already registered, even in report-only mode. Until the API changes, // catch the error not to break the applications functionally. In such // cases, the code will fall back to using strings. } } } return policy; } /** * Unsafely promote a string to a TrustedScript, falling back to strings when * Trusted Types are not available. * @security In particular, it must be assured that the provided string will * never cause an XSS vulnerability if used in a context that will be * interpreted and executed as a script by a browser, e.g. when calling eval. */ function trustedScriptFromString(script) { var _a; return ((_a = getPolicy()) === null || _a === void 0 ? void 0 : _a.createScript(script)) || script; } /** * Unsafely call the Function constructor with the given string arguments. * @security This is a security-sensitive function; any use of this function * must go through security review. In particular, it must be assured that it * is only called from the JIT compiler, as use in other code can lead to XSS * vulnerabilities. */ function newTrustedFunctionForJIT() { var args = []; for (var _i = 0; _i < arguments.length; _i++) { args[_i] = arguments[_i]; } if (!_global.trustedTypes) { // In environments that don't support Trusted Types, fall back to the most // straightforward implementation: return new (Function.bind.apply(Function, __spreadArray([void 0], __read(args))))(); } // Chrome currently does not support passing TrustedScript to the Function // constructor. The following implements the workaround proposed on the page // below, where the Chromium bug is also referenced: // https://github.com/w3c/webappsec-trusted-types/wiki/Trusted-Types-for-function-constructor var fnArgs = args.slice(0, -1).join(','); var fnBody = args[args.length - 1]; var body = "(function anonymous(" + fnArgs + "\n) { " + fnBody + "\n})"; // Using eval directly confuses the compiler and prevents this module from // being stripped out of JS binaries even if not used. The global['eval'] // indirection fixes that. var fn = _global['eval'](trustedScriptFromString(body)); if (fn.bind === undefined) { // Workaround for a browser bug that only exists in Chrome 83, where passing // a TrustedScript to eval just returns the TrustedScript back without // evaluating it. In that case, fall back to the most straightforward // implementation: return new (Function.bind.apply(Function, __spreadArray([void 0], __read(args))))(); } // To completely mimic the behavior of calling "new Function", two more // things need to happen: // 1. Stringifying the resulting function should return its source code fn.toString = function () { return body; }; // 2. When calling the resulting function, `this` should refer to `global` return fn.bind(_global); // When Trusted Types support in Function constructors is widely available, // the implementation of this function can be simplified to: // return new Function(...args.map(a => trustedScriptFromString(a))); } /** * A helper class to manage the evaluation of JIT generated code. */ var JitEvaluator = /** @class */ (function () { function JitEvaluator() { } /** * * @param sourceUrl The URL of the generated code. * @param statements An array of Angular statement AST nodes to be evaluated. * @param reflector A helper used when converting the statements to executable code. * @param createSourceMaps If true then create a source-map for the generated code and include it * inline as a source-map comment. * @returns A map of all the variables in the generated code. */ JitEvaluator.prototype.evaluateStatements = function (sourceUrl, statements, reflector, createSourceMaps) { var converter = new JitEmitterVisitor(reflector); var ctx = EmitterVisitorContext.createRoot(); // Ensure generated code is in strict mode if (statements.length > 0 && !isUseStrictStatement(statements[0])) { statements = __spreadArray([ literal('use strict').toStmt() ], __read(statements)); } converter.visitAllStatements(statements, ctx); converter.createReturnStmt(ctx); return this.evaluateCode(sourceUrl, ctx, converter.getArgs(), createSourceMaps); }; /** * Evaluate a piece of JIT generated code. * @param sourceUrl The URL of this generated code. * @param ctx A context object that contains an AST of the code to be evaluated. * @param vars A map containing the names and values of variables that the evaluated code might * reference. * @param createSourceMap If true then create a source-map for the generated code and include it * inline as a source-map comment. * @returns The result of evaluating the code. */ JitEvaluator.prototype.evaluateCode = function (sourceUrl, ctx, vars, createSourceMap) { var fnBody = "\"use strict\";" + ctx.toSource() + "\n//# sourceURL=" + sourceUrl; var fnArgNames = []; var fnArgValues = []; for (var argName in vars) { fnArgValues.push(vars[argName]); fnArgNames.push(argName); } if (createSourceMap) { // using `new Function(...)` generates a header, 1 line of no arguments, 2 lines otherwise // E.g. ``` // function anonymous(a,b,c // /**/) { ... }``` // We don't want to hard code this fact, so we auto detect it via an empty function first. var emptyFn = newTrustedFunctionForJIT.apply(void 0, __spreadArray([], __read(fnArgNames.concat('return null;')))).toString(); var headerLines = emptyFn.slice(0, emptyFn.indexOf('return null;')).split('\n').length - 1; fnBody += "\n" + ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment(); } var fn = newTrustedFunctionForJIT.apply(void 0, __spreadArray([], __read(fnArgNames.concat(fnBody)))); return this.executeFunction(fn, fnArgValues); }; /** * Execute a JIT generated function by calling it. * * This method can be overridden in tests to capture the functions that are generated * by this `JitEvaluator` class. * * @param fn A function to execute. * @param args The arguments to pass to the function being executed. * @returns The return value of the executed function. */ JitEvaluator.prototype.executeFunction = function (fn, args) { return fn.apply(void 0, __spreadArray([], __read(args))); }; return JitEvaluator; }()); /** * An Angular AST visitor that converts AST nodes into executable JavaScript code. */ var JitEmitterVisitor = /** @class */ (function (_super) { __extends(JitEmitterVisitor, _super); function JitEmitterVisitor(reflector) { var _this = _super.call(this) || this; _this.reflector = reflector; _this._evalArgNames = []; _this._evalArgValues = []; _this._evalExportedVars = []; return _this; } JitEmitterVisitor.prototype.createReturnStmt = function (ctx) { var stmt = new ReturnStatement(new LiteralMapExpr(this._evalExportedVars.map(function (resultVar) { return new LiteralMapEntry(resultVar, variable(resultVar), false); }))); stmt.visitStatement(this, ctx); }; JitEmitterVisitor.prototype.getArgs = function () { var result = {}; for (var i = 0; i < this._evalArgNames.length; i++) { result[this._evalArgNames[i]] = this._evalArgValues[i]; } return result; }; JitEmitterVisitor.prototype.visitExternalExpr = function (ast, ctx) { this._emitReferenceToExternal(ast, this.reflector.resolveExternalReference(ast.value), ctx); return null; }; JitEmitterVisitor.prototype.visitWrappedNodeExpr = function (ast, ctx) { this._emitReferenceToExternal(ast, ast.node, ctx); return null; }; JitEmitterVisitor.prototype.visitDeclareVarStmt = function (stmt, ctx) { if (stmt.hasModifier(exports.StmtModifier.Exported)) { this._evalExportedVars.push(stmt.name); } return _super.prototype.visitDeclareVarStmt.call(this, stmt, ctx); }; JitEmitterVisitor.prototype.visitDeclareFunctionStmt = function (stmt, ctx) { if (stmt.hasModifier(exports.StmtModifier.Exported)) { this._evalExportedVars.push(stmt.name); } return _super.prototype.visitDeclareFunctionStmt.call(this, stmt, ctx); }; JitEmitterVisitor.prototype.visitDeclareClassStmt = function (stmt, ctx) { if (stmt.hasModifier(exports.StmtModifier.Exported)) { this._evalExportedVars.push(stmt.name); } return _super.prototype.visitDeclareClassStmt.call(this, stmt, ctx); }; JitEmitterVisitor.prototype._emitReferenceToExternal = function (ast, value, ctx) { var id = this._evalArgValues.indexOf(value); if (id === -1) { id = this._evalArgValues.length; this._evalArgValues.push(value); var name = identifierName({ reference: value }) || 'val'; this._evalArgNames.push("jit_" + name + "_" + id); } ctx.print(ast, this._evalArgNames[id]); }; return JitEmitterVisitor; }(AbstractJsEmitterVisitor)); function isUseStrictStatement(statement) { return statement.isEquivalent(literal('use strict').toStmt()); } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ function compileInjector(meta) { var definitionMap = new DefinitionMap(); if (meta.providers !== null) { definitionMap.set('providers', meta.providers); } if (meta.imports.length > 0) { definitionMap.set('imports', literalArr(meta.imports)); } var expression = importExpr(Identifiers.defineInjector).callFn([definitionMap.toLiteralMap()], undefined, true); var type = createInjectorType(meta); return { expression: expression, type: type, statements: [] }; } function createInjectorType(meta) { return new ExpressionType(importExpr(Identifiers.InjectorDeclaration, [new ExpressionType(meta.type.type)])); } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ /** * Implementation of `CompileReflector` which resolves references to @angular/core * symbols at runtime, according to a consumer-provided mapping. * * Only supports `resolveExternalReference`, all other methods throw. */ var R3JitReflector = /** @class */ (function () { function R3JitReflector(context) { this.context = context; } R3JitReflector.prototype.resolveExternalReference = function (ref) { // This reflector only handles @angular/core imports. if (ref.moduleName !== '@angular/core') { throw new Error("Cannot resolve external reference to " + ref.moduleName + ", only references to @angular/core are supported."); } if (!this.context.hasOwnProperty(ref.name)) { throw new Error("No value provided for @angular/core symbol '" + ref.name + "'."); } return this.context[ref.name]; }; R3JitReflector.prototype.parameters = function (typeOrFunc) { throw new Error('Not implemented.'); }; R3JitReflector.prototype.annotations = function (typeOrFunc) { throw new Error('Not implemented.'); }; R3JitReflector.prototype.shallowAnnotations = function (typeOrFunc) { throw new Error('Not implemented.'); }; R3JitReflector.prototype.tryAnnotations = function (typeOrFunc) { throw new Error('Not implemented.'); }; R3JitReflector.prototype.propMetadata = function (typeOrFunc) { throw new Error('Not implemented.'); }; R3JitReflector.prototype.hasLifecycleHook = function (type, lcProperty) { throw new Error('Not implemented.'); }; R3JitReflector.prototype.guards = function (typeOrFunc) { throw new Error('Not implemented.'); }; R3JitReflector.prototype.componentModuleUrl = function (type, cmpMetadata) { throw new Error('Not implemented.'); }; return R3JitReflector; }()); /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ /** * Construct an `R3NgModuleDef` for the given `R3NgModuleMetadata`. */ function compileNgModule(meta) { var internalType = meta.internalType, bootstrap = meta.bootstrap, declarations = meta.declarations, imports = meta.imports, exports = meta.exports, schemas = meta.schemas, containsForwardDecls = meta.containsForwardDecls, emitInline = meta.emitInline, id = meta.id; var statements = []; var definitionMap = new DefinitionMap(); definitionMap.set('type', internalType); if (bootstrap.length > 0) { definitionMap.set('bootstrap', refsToArray(bootstrap, containsForwardDecls)); } // If requested to emit scope information inline, pass the `declarations`, `imports` and `exports` // to the `ɵɵdefineNgModule()` call. The JIT compilation uses this. if (emitInline) { if (declarations.length > 0) { definitionMap.set('declarations', refsToArray(declarations, containsForwardDecls)); } if (imports.length > 0) { definitionMap.set('imports', refsToArray(imports, containsForwardDecls)); } if (exports.length > 0) { definitionMap.set('exports', refsToArray(exports, containsForwardDecls)); } } // If not emitting inline, the scope information is not passed into `ɵɵdefineNgModule` as it would // prevent tree-shaking of the declarations, imports and exports references. else { var setNgModuleScopeCall = generateSetNgModuleScopeCall(meta); if (setNgModuleScopeCall !== null) { statements.push(setNgModuleScopeCall); } } if (schemas !== null && schemas.length > 0) { definitionMap.set('schemas', literalArr(schemas.map(function (ref) { return ref.value; }))); } if (id !== null) { definitionMap.set('id', id); } var expression = importExpr(Identifiers.defineNgModule).callFn([definitionMap.toLiteralMap()], undefined, true); var type = createNgModuleType(meta); return { expression: expression, type: type, statements: statements }; } /** * This function is used in JIT mode to generate the call to `ɵɵdefineNgModule()` from a call to * `ɵɵngDeclareNgModule()`. */ function compileNgModuleDeclarationExpression(meta) { var definitionMap = new DefinitionMap(); definitionMap.set('type', new WrappedNodeExpr(meta.type)); if (meta.bootstrap !== undefined) { definitionMap.set('bootstrap', new WrappedNodeExpr(meta.bootstrap)); } if (meta.declarations !== undefined) { definitionMap.set('declarations', new WrappedNodeExpr(meta.declarations)); } if (meta.imports !== undefined) { definitionMap.set('imports', new WrappedNodeExpr(meta.imports)); } if (meta.exports !== undefined) { definitionMap.set('exports', new WrappedNodeExpr(meta.exports)); } if (meta.schemas !== undefined) { definitionMap.set('schemas', new WrappedNodeExpr(meta.schemas)); } if (meta.id !== undefined) { definitionMap.set('id', new WrappedNodeExpr(meta.id)); } return importExpr(Identifiers.defineNgModule).callFn([definitionMap.toLiteralMap()]); } function createNgModuleType(_a) { var moduleType = _a.type, declarations = _a.declarations, imports = _a.imports, exports = _a.exports; return new ExpressionType(importExpr(Identifiers.NgModuleDeclaration, [ new ExpressionType(moduleType.type), tupleTypeOf(declarations), tupleTypeOf(imports), tupleTypeOf(exports) ])); } /** * Generates a function call to `ɵɵsetNgModuleScope` with all necessary information so that the * transitive module scope can be computed during runtime in JIT mode. This call is marked pure * such that the references to declarations, imports and exports may be elided causing these * symbols to become tree-shakeable. */ function generateSetNgModuleScopeCall(meta) { var moduleType = meta.adjacentType, declarations = meta.declarations, imports = meta.imports, exports = meta.exports, containsForwardDecls = meta.containsForwardDecls; var scopeMap = new DefinitionMap(); if (declarations.length > 0) { scopeMap.set('declarations', refsToArray(declarations, containsForwardDecls)); } if (imports.length > 0) { scopeMap.set('imports', refsToArray(imports, containsForwardDecls)); } if (exports.length > 0) { scopeMap.set('exports', refsToArray(exports, containsForwardDecls)); } if (Object.keys(scopeMap.values).length === 0) { return null; } // setNgModuleScope(...) var fnCall = new InvokeFunctionExpr( /* fn */ importExpr(Identifiers.setNgModuleScope), /* args */ [moduleType, scopeMap.toLiteralMap()]); // (ngJitMode guard) && setNgModuleScope(...) var guardedCall = jitOnlyGuardedExpression(fnCall); // function() { (ngJitMode guard) && setNgModuleScope(...); } var iife = new FunctionExpr( /* params */ [], /* statements */ [guardedCall.toStmt()]); // (function() { (ngJitMode guard) && setNgModuleScope(...); })() var iifeCall = new InvokeFunctionExpr( /* fn */ iife, /* args */ []); return iifeCall.toStmt(); } function tupleTypeOf(exp) { var types = exp.map(function (ref) { return typeofExpr(ref.type); }); return exp.length > 0 ? expressionType(literalArr(types)) : NONE_TYPE; } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ function compilePipeFromMetadata(metadata) { var definitionMapValues = []; // e.g. `name: 'myPipe'` definitionMapValues.push({ key: 'name', value: literal(metadata.pipeName), quoted: false }); // e.g. `type: MyPipe` definitionMapValues.push({ key: 'type', value: metadata.type.value, quoted: false }); // e.g. `pure: true` definitionMapValues.push({ key: 'pure', value: literal(metadata.pure), quoted: false }); var expression = importExpr(Identifiers.definePipe).callFn([literalMap(definitionMapValues)], undefined, true); var type = createPipeType(metadata); return { expression: expression, type: type, statements: [] }; } function createPipeType(metadata) { return new ExpressionType(importExpr(Identifiers.PipeDeclaration, [ typeWithParameters(metadata.type.type, metadata.typeArgumentCount), new ExpressionType(new LiteralExpr(metadata.pipeName)), ])); } /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ var ParserError = /** @class */ (function () { function ParserError(message, input, errLocation, ctxLocation) { this.input = input; this.errLocation = errLocation; this.ctxLocation = ctxLocation; this.message = "Parser Error: " + message + " " + errLocation + " [" + input + "] in " + ctxLocation; } return ParserError; }()); var ParseSpan = /** @class */ (function () { function ParseSpan(start, end) { this.start = start; this.end = end; } ParseSpan.prototype.toAbsolute = function (absoluteOffset) { return new AbsoluteSourceSpan(absoluteOffset + this.start, absoluteOffset + this.end); }; return ParseSpan; }()); var AST = /** @class */ (function () { function AST(span, /** * Absolute location of the expression AST in a source code file. */ sourceSpan) { this.span = span; this.sourceSpan = sourceSpan; } AST.prototype.toString = function () { return 'AST'; }; return AST; }()); var ASTWithName = /** @class */ (function (_super) { __extends(ASTWithName, _super); function ASTWithName(span, sourceSpan, nameSpan) { var _this = _super.call(this, span, sourceSpan) || this; _this.nameSpan = nameSpan; return _this; } return ASTWithName; }(AST)); /** * Represents a quoted expression of the form: * * quote = prefix `:` uninterpretedExpression * prefix = identifier * uninterpretedExpression = arbitrary string * * A quoted expression is meant to be pre-processed by an AST transformer that * converts it into another AST that no longer contains quoted expressions. * It is meant to allow third-party developers to extend Angular template * expression language. The `uninterpretedExpression` part of the quote is * therefore not interpreted by the Angular's own expression parser. */ var Quote = /** @class */ (function (_super) { __extends(Quote, _super); function Quote(span, sourceSpan, prefix, uninterpretedExpression, location) { var _this = _super.call(this, span, sourceSpan) || this; _this.prefix = prefix; _this.uninterpretedExpression = uninterpretedExpression; _this.location = location; return _this; } Quote.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitQuote(this, context); }; Quote.prototype.toString = function () { return 'Quote'; }; return Quote; }(AST)); var EmptyExpr = /** @class */ (function (_super) { __extends(EmptyExpr, _super); function EmptyExpr() { return _super !== null && _super.apply(this, arguments) || this; } EmptyExpr.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } // do nothing }; return EmptyExpr; }(AST)); var ImplicitReceiver = /** @class */ (function (_super) { __extends(ImplicitReceiver, _super); function ImplicitReceiver() { return _super !== null && _super.apply(this, arguments) || this; } ImplicitReceiver.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitImplicitReceiver(this, context); }; return ImplicitReceiver; }(AST)); /** * Receiver when something is accessed through `this` (e.g. `this.foo`). Note that this class * inherits from `ImplicitReceiver`, because accessing something through `this` is treated the * same as accessing it implicitly inside of an Angular template (e.g. `[attr.title]="this.title"` * is the same as `[attr.title]="title"`.). Inheriting allows for the `this` accesses to be treated * the same as implicit ones, except for a couple of exceptions like `$event` and `$any`. * TODO: we should find a way for this class not to extend from `ImplicitReceiver` in the future. */ var ThisReceiver = /** @class */ (function (_super) { __extends(ThisReceiver, _super); function ThisReceiver() { return _super !== null && _super.apply(this, arguments) || this; } ThisReceiver.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } var _a; return (_a = visitor.visitThisReceiver) === null || _a === void 0 ? void 0 : _a.call(visitor, this, context); }; return ThisReceiver; }(ImplicitReceiver)); /** * Multiple expressions separated by a semicolon. */ var Chain = /** @class */ (function (_super) { __extends(Chain, _super); function Chain(span, sourceSpan, expressions) { var _this = _super.call(this, span, sourceSpan) || this; _this.expressions = expressions; return _this; } Chain.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitChain(this, context); }; return Chain; }(AST)); var Conditional = /** @class */ (function (_super) { __extends(Conditional, _super); function Conditional(span, sourceSpan, condition, trueExp, falseExp) { var _this = _super.call(this, span, sourceSpan) || this; _this.condition = condition; _this.trueExp = trueExp; _this.falseExp = falseExp; return _this; } Conditional.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitConditional(this, context); }; return Conditional; }(AST)); var PropertyRead = /** @class */ (function (_super) { __extends(PropertyRead, _super); function PropertyRead(span, sourceSpan, nameSpan, receiver, name) { var _this = _super.call(this, span, sourceSpan, nameSpan) || this; _this.receiver = receiver; _this.name = name; return _this; } PropertyRead.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitPropertyRead(this, context); }; return PropertyRead; }(ASTWithName)); var PropertyWrite = /** @class */ (function (_super) { __extends(PropertyWrite, _super); function PropertyWrite(span, sourceSpan, nameSpan, receiver, name, value) { var _this = _super.call(this, span, sourceSpan, nameSpan) || this; _this.receiver = receiver; _this.name = name; _this.value = value; return _this; } PropertyWrite.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitPropertyWrite(this, context); }; return PropertyWrite; }(ASTWithName)); var SafePropertyRead = /** @class */ (function (_super) { __extends(SafePropertyRead, _super); function SafePropertyRead(span, sourceSpan, nameSpan, receiver, name) { var _this = _super.call(this, span, sourceSpan, nameSpan) || this; _this.receiver = receiver; _this.name = name; return _this; } SafePropertyRead.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitSafePropertyRead(this, context); }; return SafePropertyRead; }(ASTWithName)); var KeyedRead = /** @class */ (function (_super) { __extends(KeyedRead, _super); function KeyedRead(span, sourceSpan, receiver, key) { var _this = _super.call(this, span, sourceSpan) || this; _this.receiver = receiver; _this.key = key; return _this; } KeyedRead.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitKeyedRead(this, context); }; return KeyedRead; }(AST)); var SafeKeyedRead = /** @class */ (function (_super) { __extends(SafeKeyedRead, _super); function SafeKeyedRead(span, sourceSpan, receiver, key) { var _this = _super.call(this, span, sourceSpan) || this; _this.receiver = receiver; _this.key = key; return _this; } SafeKeyedRead.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitSafeKeyedRead(this, context); }; return SafeKeyedRead; }(AST)); var KeyedWrite = /** @class */ (function (_super) { __extends(KeyedWrite, _super); function KeyedWrite(span, sourceSpan, receiver, key, value) { var _this = _super.call(this, span, sourceSpan) || this; _this.receiver = receiver; _this.key = key; _this.value = value; return _this; } KeyedWrite.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitKeyedWrite(this, context); }; return KeyedWrite; }(AST)); var BindingPipe = /** @class */ (function (_super) { __extends(BindingPipe, _super); function BindingPipe(span, sourceSpan, exp, name, args, nameSpan) { var _this = _super.call(this, span, sourceSpan, nameSpan) || this; _this.exp = exp; _this.name = name; _this.args = args; return _this; } BindingPipe.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitPipe(this, context); }; return BindingPipe; }(ASTWithName)); var LiteralPrimitive = /** @class */ (function (_super) { __extends(LiteralPrimitive, _super); function LiteralPrimitive(span, sourceSpan, value) { var _this = _super.call(this, span, sourceSpan) || this; _this.value = value; return _this; } LiteralPrimitive.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitLiteralPrimitive(this, context); }; return LiteralPrimitive; }(AST)); var LiteralArray = /** @class */ (function (_super) { __extends(LiteralArray, _super); function LiteralArray(span, sourceSpan, expressions) { var _this = _super.call(this, span, sourceSpan) || this; _this.expressions = expressions; return _this; } LiteralArray.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitLiteralArray(this, context); }; return LiteralArray; }(AST)); var LiteralMap = /** @class */ (function (_super) { __extends(LiteralMap, _super); function LiteralMap(span, sourceSpan, keys, values) { var _this = _super.call(this, span, sourceSpan) || this; _this.keys = keys; _this.values = values; return _this; } LiteralMap.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitLiteralMap(this, context); }; return LiteralMap; }(AST)); var Interpolation = /** @class */ (function (_super) { __extends(Interpolation, _super); function Interpolation(span, sourceSpan, strings, expressions) { var _this = _super.call(this, span, sourceSpan) || this; _this.strings = strings; _this.expressions = expressions; return _this; } Interpolation.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitInterpolation(this, context); }; return Interpolation; }(AST)); var Binary = /** @class */ (function (_super) { __extends(Binary, _super); function Binary(span, sourceSpan, operation, left, right) { var _this = _super.call(this, span, sourceSpan) || this; _this.operation = operation; _this.left = left; _this.right = right; return _this; } Binary.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitBinary(this, context); }; return Binary; }(AST)); /** * For backwards compatibility reasons, `Unary` inherits from `Binary` and mimics the binary AST * node that was originally used. This inheritance relation can be deleted in some future major, * after consumers have been given a chance to fully support Unary. */ var Unary = /** @class */ (function (_super) { __extends(Unary, _super); /** * During the deprecation period this constructor is private, to avoid consumers from creating * a `Unary` with the fallback properties for `Binary`. */ function Unary(span, sourceSpan, operator, expr, binaryOp, binaryLeft, binaryRight) { var _this = _super.call(this, span, sourceSpan, binaryOp, binaryLeft, binaryRight) || this; _this.operator = operator; _this.expr = expr; return _this; } /** * Creates a unary minus expression "-x", represented as `Binary` using "0 - x". */ Unary.createMinus = function (span, sourceSpan, expr) { return new Unary(span, sourceSpan, '-', expr, '-', new LiteralPrimitive(span, sourceSpan, 0), expr); }; /** * Creates a unary plus expression "+x", represented as `Binary` using "x - 0". */ Unary.createPlus = function (span, sourceSpan, expr) { return new Unary(span, sourceSpan, '+', expr, '-', expr, new LiteralPrimitive(span, sourceSpan, 0)); }; Unary.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } if (visitor.visitUnary !== undefined) { return visitor.visitUnary(this, context); } return visitor.visitBinary(this, context); }; return Unary; }(Binary)); var PrefixNot = /** @class */ (function (_super) { __extends(PrefixNot, _super); function PrefixNot(span, sourceSpan, expression) { var _this = _super.call(this, span, sourceSpan) || this; _this.expression = expression; return _this; } PrefixNot.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitPrefixNot(this, context); }; return PrefixNot; }(AST)); var NonNullAssert = /** @class */ (function (_super) { __extends(NonNullAssert, _super); function NonNullAssert(span, sourceSpan, expression) { var _this = _super.call(this, span, sourceSpan) || this; _this.expression = expression; return _this; } NonNullAssert.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitNonNullAssert(this, context); }; return NonNullAssert; }(AST)); var MethodCall = /** @class */ (function (_super) { __extends(MethodCall, _super); function MethodCall(span, sourceSpan, nameSpan, receiver, name, args, argumentSpan) { var _this = _super.call(this, span, sourceSpan, nameSpan) || this; _this.receiver = receiver; _this.name = name; _this.args = args; _this.argumentSpan = argumentSpan; return _this; } MethodCall.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitMethodCall(this, context); }; return MethodCall; }(ASTWithName)); var SafeMethodCall = /** @class */ (function (_super) { __extends(SafeMethodCall, _super); function SafeMethodCall(span, sourceSpan, nameSpan, receiver, name, args, argumentSpan) { var _this = _super.call(this, span, sourceSpan, nameSpan) || this; _this.receiver = receiver; _this.name = name; _this.args = args; _this.argumentSpan = argumentSpan; return _this; } SafeMethodCall.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitSafeMethodCall(this, context); }; return SafeMethodCall; }(ASTWithName)); var FunctionCall = /** @class */ (function (_super) { __extends(FunctionCall, _super); function FunctionCall(span, sourceSpan, target, args) { var _this = _super.call(this, span, sourceSpan) || this; _this.target = target; _this.args = args; return _this; } FunctionCall.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } return visitor.visitFunctionCall(this, context); }; return FunctionCall; }(AST)); /** * Records the absolute position of a text span in a source file, where `start` and `end` are the * starting and ending byte offsets, respectively, of the text span in a source file. */ var AbsoluteSourceSpan = /** @class */ (function () { function AbsoluteSourceSpan(start, end) { this.start = start; this.end = end; } return AbsoluteSourceSpan; }()); var ASTWithSource = /** @class */ (function (_super) { __extends(ASTWithSource, _super); function ASTWithSource(ast, source, location, absoluteOffset, errors) { var _this = _super.call(this, new ParseSpan(0, source === null ? 0 : source.length), new AbsoluteSourceSpan(absoluteOffset, source === null ? absoluteOffset : absoluteOffset + source.length)) || this; _this.ast = ast; _this.source = source; _this.location = location; _this.errors = errors; return _this; } ASTWithSource.prototype.visit = function (visitor, context) { if (context === void 0) { context = null; } if (visitor.visitASTWithSource) { return visitor.visitASTWithSource(this, context); } return this.ast.visit(visitor, context); }; ASTWithSource.prototype.toString = function () { return this.source + " in " + this.location; }; return ASTWithSource; }(AST)); var VariableBinding = /** @class */ (function () { /** * @param sourceSpan entire span of the binding. * @param key name of the LHS along with its span. * @param value optional value for the RHS along with its span. */ function VariableBinding(sourceSpan, key, value) { this.sourceSpan = sourceSpan; this.key = key; this.value = value; } return VariableBinding; }()); var ExpressionBinding = /** @class */ (function () { /** * @param sourceSpan entire span of the binding. * @param key binding name, like ngForOf, ngForTrackBy, ngIf, along with its * span. Note that the length of the span may not be the same as * `key.source.length`. For example, * 1. key.source = ngFor, key.span is for "ngFor" * 2. key.source = ngForOf, key.span is for "of" * 3. key.source = ngForTrackBy, key.span is for "trackBy" * @param value optional expression for the RHS. */ function ExpressionBinding(sourceSpan, key, value) { this.sourceSpan = sourceSpan; this.key = key; this.value = value; } return ExpressionBinding; }()); var RecursiveAstVisitor$1 = /** @class */ (function () { function RecursiveAstVisitor() { } RecursiveAstVisitor.prototype.visit = function (ast, context) { // The default implementation just visits every node. // Classes that extend RecursiveAstVisitor should override this function // to selectively visit the specified node. ast.visit(this, context); }; RecursiveAstVisitor.prototype.visitUnary = function (ast, context) { this.visit(ast.expr, context); }; RecursiveAstVisitor.prototype.visitBinary = function (ast, context) { this.visit(ast.left, context); this.visit(ast.right, context); }; RecursiveAstVisitor.prototype.visitChain = function (ast, context) { this.visitAll(ast.expressions, context); }; RecursiveAstVisitor.prototype.visitConditional = function (ast, context) { this.visit(ast.condition, context); this.visit(ast.trueExp, context); this.visit(ast.falseExp, context); }; RecursiveAstVisitor.prototype.visitPipe = function (ast, context) { this.visit(ast.exp, context); this.visitAll(ast.args, context); }; RecursiveAstVisitor.prototype.visitFunctionCall = function (ast, context) { if (ast.target) { this.visit(ast.target, context); } this.visitAll(ast.args, context); }; RecursiveAstVisitor.prototype.visitImplicitReceiver = function (ast, context) { }; RecursiveAstVisitor.prototype.visitThisReceiver = function (ast, context) { }; RecursiveAstVisitor.prototype.visitInterpolation = function (ast, context) { this.visitAll(ast.expressions, context); }; RecursiveAstVisitor.prototype.visitKeyedRead = function (ast, context) { this.visit(ast.receiver, context); this.visit(ast.key, context); }; RecursiveAstVisitor.prototype.visitKeyedWrite = function (ast, context) { this.visit(ast.receiver, context); this.visit(ast.key, context); this.visit(ast.value, context); }; RecursiveAstVisitor.prototype.visitLiteralArray = function (ast, context) { this.visitAll(ast.expressions, context); }; RecursiveAstVisitor.prototype.visitLiteralMap = function (ast, context) { this.visitAll(ast.values, context); }; RecursiveAstVisitor.prototype.visitLiteralPrimitive = function (ast, context) { }; RecursiveAstVisitor.prototype.visitMethodCall = function (ast, context) { this.visit(ast.receiver, context); this.visitAll(ast.args, context); }; RecursiveAstVisitor.prototype.visitPrefixNot = function (ast, context) { this.visit(ast.expression, context); }; RecursiveAstVisitor.prototype.visitNonNullAssert = function (ast, context) { this.visit(ast.expression, context); }; RecursiveAstVisitor.prototype.visitPropertyRead = function (ast, context) { this.visit(ast.receiver, context); }; RecursiveAstVisitor.prototype.visitPropertyWrite = function (ast, context) { this.visit(ast.receiver, context); this.visit(ast.value, context); }; RecursiveAstVisitor.prototype.visitSafePropertyRead = function (ast, context) { this.visit(ast.receiver, context); }; RecursiveAstVisitor.prototype.visitSafeMethodCall = function (ast, context) { this.visit(ast.receiver, context); this.visitAll(ast.args, context); }; RecursiveAstVisitor.prototype.visitSafeKeyedRead = function (ast, context) { this.visit(ast.receiver, context); this.visit(ast.key, context); }; RecursiveAstVisitor.prototype.visitQuote = function (ast, context) { }; // This is not part of the AstVisitor interface, just a helper method RecursiveAstVisitor.prototype.visitAll = function (asts, context) { var e_1, _b; try { for (var asts_1 = __values(asts), asts_1_1 = asts_1.next(); !asts_1_1.done; asts_1_1 = asts_1.next()) { var ast = asts_1_1.value; this.visit(ast, context); } } catch (e_1_1) { e_1 = { error: e_1_1 }; } finally { try { if (asts_1_1 && !asts_1_1.done && (_b = asts_1.return)) _b.call(asts_1); } finally { if (e_1) throw e_1.error; } } }; return RecursiveAstVisitor; }()); var AstTransformer$1 = /** @class */ (function () { function AstTransformer() { } AstTransformer.prototype.visitImplicitReceiver = function (ast, context) { return ast; }; AstTransformer.prototype.visitThisReceiver = function (ast, context) { return ast; }; AstTransformer.prototype.visitInterpolation = function (ast, context) { return new Interpolation(ast.span, ast.sourceSpan, ast.strings, this.visitAll(ast.expressions)); }; AstTransformer.prototype.visitLiteralPrimitive = function (ast, context) { return new LiteralPrimitive(ast.span, ast.sourceSpan, ast.value); }; AstTransformer.prototype.visitPropertyRead = function (ast, context) { return new PropertyRead(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name); }; AstTransformer.prototype.visitPropertyWrite = function (ast, context) { return new PropertyWrite(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name, ast.value.visit(this)); }; AstTransformer.prototype.visitSafePropertyRead = function (ast, context) { return new SafePropertyRead(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name); }; AstTransformer.prototype.visitMethodCall = function (ast, context) { return new MethodCall(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name, this.visitAll(ast.args), ast.argumentSpan); }; AstTransformer.prototype.visitSafeMethodCall = function (ast, context) { return new SafeMethodCall(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name, this.visitAll(ast.args), ast.argumentSpan); }; AstTransformer.prototype.visitFunctionCall = function (ast, context) { return new FunctionCall(ast.span, ast.sourceSpan, ast.target.visit(this), this.visitAll(ast.args)); }; AstTransformer.prototype.visitLiteralArray = function (ast, context) { return new LiteralArray(ast.span, ast.sourceSpan, this.visitAll(ast.expressions)); }; AstTransformer.prototype.visitLiteralMap = function (ast, context) { return new LiteralMap(ast.span, ast.sourceSpan, ast.keys, this.visitAll(ast.values)); }; AstTransformer.prototype.visitUnary = function (ast, context) { switch (ast.operator) { case '+': return Unary.createPlus(ast.span, ast.sourceSpan, ast.expr.visit(this)); case '-': return Unary.createMinus(ast.span, ast.sourceSpan, ast.expr.visit(this)); default: throw new Error("Unknown unary operator " + ast.operator); } }; AstTransformer.prototype.visitBinary = function (ast, context) { return new Binary(ast.span, ast.sourceSpan, ast.operation, ast.left.visit(this), ast.right.visit(this)); }; AstTransformer.prototype.visitPrefixNot = function (ast, context) { return new PrefixNot(ast.span, ast.sourceSpan, ast.expression.visit(this)); }; AstTransformer.prototype.visitNonNullAssert = function (ast, context) { return new NonNullAssert(ast.span, ast.sourceSpan, ast.expression.visit(this)); }; AstTransformer.prototype.visitConditional = function (ast, context) { return new Conditional(ast.span, ast.sourceSpan, ast.condition.visit(this), ast.trueExp.visit(this), ast.falseExp.visit(this)); }; AstTransformer.prototype.visitPipe = function (ast, context) { return new BindingPipe(ast.span, ast.sourceSpan, ast.exp.visit(this), ast.name, this.visitAll(ast.args), ast.nameSpan); }; AstTransformer.prototype.visitKeyedRead = function (ast, context) { return new KeyedRead(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this)); }; AstTransformer.prototype.visitKeyedWrite = function (ast, context) { return new KeyedWrite(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this), ast.value.visit(this)); }; AstTransformer.prototype.visitAll = function (asts) { var res = []; for (var i = 0; i < asts.length; ++i) { res[i] = asts[i].visit(this); } return res; }; AstTransformer.prototype.visitChain = function (ast, context) { return new Chain(ast.span, ast.sourceSpan, this.visitAll(ast.expressions)); }; AstTransformer.prototype.visitQuote = function (ast, context) { return new Quote(ast.span, ast.sourceSpan, ast.prefix, ast.uninterpretedExpression, ast.location); }; AstTransformer.prototype.visitSafeKeyedRead = function (ast, context) { return new SafeKeyedRead(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this)); }; return AstTransformer; }()); // A transformer that only creates new nodes if the transformer makes a change or // a change is made a child node. var AstMemoryEfficientTransformer = /** @class */ (function () { function AstMemoryEfficientTransformer() { } AstMemoryEfficientTransformer.prototype.visitImplicitReceiver = function (ast, context) { return ast; }; AstMemoryEfficientTransformer.prototype.visitThisReceiver = function (ast, context) { return ast; }; AstMemoryEfficientTransformer.prototype.visitInterpolation = function (ast, context) { var expressions = this.visitAll(ast.expressions); if (expressions !== ast.expressions) return new Interpolation(ast.span, ast.sourceSpan, ast.strings, expressions); return ast; }; AstMemoryEfficientTransformer.prototype.visitLiteralPrimitive = function (ast, context) { return ast; }; AstMemoryEfficientTransformer.prototype.visitPropertyRead = function (ast, context) { var receiver = ast.receiver.visit(this); if (receiver !== ast.receiver) { return new PropertyRead(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name); } return ast; }; AstMemoryEfficientTransformer.prototype.visitPropertyWrite = function (ast, context) { var receiver = ast.receiver.visit(this); var value = ast.value.visit(this); if (receiver !== ast.receiver || value !== ast.value) { return new PropertyWrite(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name, value); } return ast; }; AstMemoryEfficientTransformer.prototype.visitSafePropertyRead = function (ast, context) { var receiver = ast.receiver.visit(this); if (receiver !== ast.receiver) { return new SafePropertyRead(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name); } return ast; }; AstMemoryEfficientTransformer.prototype.visitMethodCall = function (ast, context) { var receiver = ast.receiver.visit(this); var args = this.visitAll(ast.args); if (receiver !== ast.receiver || args !== ast.args) { return new MethodCall(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name, args, ast.argumentSpan); } return ast; }; AstMemoryEfficientTransformer.prototype.visitSafeMethodCall = function (ast, context) { var receiver = ast.receiver.visit(this); var args = this.visitAll(ast.args); if (receiver !== ast.receiver || args !== ast.args) { return new SafeMethodCall(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name, args, ast.argumentSpan); } return ast; }; AstMemoryEfficientTransformer.prototype.visitFunctionCall = function (ast, context) { var target = ast.target && ast.target.visit(this); var args = this.visitAll(ast.args); if (target !== ast.target || args !== ast.args) { return new FunctionCall(ast.span, ast.sourceSpan, target, args); } return ast; }; AstMemoryEfficientTransformer.prototype.visitLiteralArray = function (ast, context) { var expressions = this.visitAll(ast.expressions); if (expressions !== ast.expressions) { return new LiteralArray(ast.span, ast.sourceSpan, expressions); } return ast; }; AstMemoryEfficientTransformer.prototype.visitLiteralMap = function (ast, context) { var values = this.visitAll(ast.values); if (values !== ast.values) { return new LiteralMap(ast.span, ast.sourceSpan, ast.keys, values); } return ast; }; AstMemoryEfficientTransformer.prototype.visitUnary = function (ast, context) { var expr = ast.expr.visit(this); if (expr !== ast.expr) { switch (ast.operator) { case '+': return Unary.createPlus(ast.span, ast.sourceSpan, expr); case '-': return Unary.createMinus(ast.span, ast.sourceSpan, expr); default: throw new Error("Unknown unary operator " + ast.operator); } } return ast; }; AstMemoryEfficientTransformer.prototype.visitBinary = function (ast, context) { var left = ast.left.visit(this); var right = ast.right.visit(this); if (left !== ast.left || right !== ast.right) { return new Binary(ast.span, ast.sourceSpan, ast.operation, left, right); } return ast; }; AstMemoryEfficientTransformer.prototype.visitPrefixNot = function (ast, context) { var expression = ast.expression.visit(this); if (expression !== ast.expression) { return new PrefixNot(ast.span, ast.sourceSpan, expression); } return ast; }; AstMemoryEfficientTransformer.prototype.visitNonNullAssert = function (ast, context) { var expression = ast.expression.visit(this); if (expression !== ast.expression) { return new NonNullAssert(ast.span, ast.sourceSpan, expression); } return ast; }; AstMemoryEfficientTransformer.prototype.visitConditional = function (ast, context) { var condition = ast.condition.visit(this); var trueExp = ast.trueExp.visit(this); var falseExp = ast.falseExp.visit(this); if (condition !== ast.condition || trueExp !== ast.trueExp || falseExp !== ast.falseExp) { return new Conditional(ast.span, ast.sourceSpan, condition, trueExp, falseExp); } return ast; }; AstMemoryEfficientTransformer.prototype.visitPipe = function (ast, context) { var exp = ast.exp.visit(this); var args = this.visitAll(ast.args); if (exp !== ast.exp || args !== ast.args) { return new BindingPipe(ast.span, ast.sourceSpan, exp, ast.name, args, ast.nameSpan); } return ast; }; AstMemoryEfficientTransformer.prototype.visitKeyedRead = function (ast, context) { var obj = ast.receiver.visit(this); var key = ast.key.visit(this); if (obj !== ast.receiver || key !== ast.key) { return new KeyedRead(ast.span, ast.sourceSpan, obj, key); } return ast; }; AstMemoryEfficientTransformer.prototype.visitKeyedWrite = function (ast, context) { var obj = ast.receiver.visit(this); var key = ast.key.visit(this); var value = ast.value.visit(this); if (obj !== ast.receiver || key !== ast.key || value !== ast.value) { return new KeyedWrite(ast.span, ast.sourceSpan, obj, key, value); } return ast; }; AstMemoryEfficientTransformer.prototype.visitAll = function (asts) { var res = []; var modified = false; for (var i = 0; i < asts.length; ++i) { var original = asts[i]; var value = original.visit(this); res[i] = value; modified = modified || value !== original; } return modified ? res : asts; }; AstMemoryEfficientTransformer.prototype.visitChain = function (ast, context) { var expressions = this.visitAll(ast.expressions); if (expressions !== ast.expressions) { return new Chain(ast.span, ast.sourceSpan, expressions); } return ast; }; AstMemoryEfficientTransformer.prototype.visitQuote = function (ast, context) { return ast; }; AstMemoryEfficientTransformer.prototype.visitSafeKeyedRead = function (ast, context) { var obj = ast.receiver.visit(this); var key = ast.key.visit(this); if (obj !== ast.receiver || key !== ast.key) { return new SafeKeyedRead(ast.span, ast.sourceSpan, obj, key); } return ast; }; return AstMemoryEfficientTransformer; }()); // Bindings var ParsedProperty = /** @class */ (function () { function ParsedProperty(name, expression, type, // TODO(FW-2095): `keySpan` should really be required but allows `undefined` so VE does // not need to be updated. Make `keySpan` required when VE is removed. sourceSpan, keySpan, valueSpan) { this.name = name; this.expression = expression; this.type = type; this.sourceSpan = sourceSpan; this.keySpan = keySpan; this.valueSpan = valueSpan; this.isLiteral = this.type === exports.ParsedPropertyType.LITERAL_ATTR; this.isAnimation = this.type === exports.ParsedPropertyType.ANIMATION; } return ParsedProperty; }()); (function (ParsedPropertyType) { ParsedPropertyType[ParsedPropertyType["DEFAULT"] = 0] = "DEFAULT"; ParsedPropertyType[ParsedPropertyType["LITERAL_ATTR"] = 1] = "LITERAL_ATTR"; ParsedPropertyType[ParsedPropertyType["ANIMATION"] = 2] = "ANIMATION"; })(exports.ParsedPropertyType || (exports.ParsedPropertyType = {})); var ParsedEvent = /** @class */ (function () { // Regular events have a target // Animation events have a phase function ParsedEvent(name, targetOrPhase, type, handler, sourceSpan, // TODO(FW-2095): keySpan should be required but was made optional to avoid changing VE handlerSpan, keySpan) { this.name = name; this.targetOrPhase = targetOrPhase; this.type = type; this.handler = handler; this.sourceSpan = sourceSpan; this.handlerSpan = handlerSpan; this.keySpan = keySpan; } return ParsedEvent; }()); /** * ParsedVariable represents a variable declaration in a microsyntax expression. */ var ParsedVariable = /** @class */ (function () { function ParsedVariable(name, value, sourceSpan, keySpan, valueSpan) { this.name = name; this.value = value; this.sourceSpan = sourceSpan; this.keySpan = keySpan; this.valueSpan = valueSpan; } return ParsedVariable; }()); var BoundElementProperty = /** @class */ (function () { function BoundElementProperty(name, type, securityContext, value, unit, sourceSpan, keySpan, valueSpan) { this.name = name; this.type = type; this.securityContext = securityContext; this.value = value; this.unit = unit; this.sourceSpan = sourceSpan; this.keySpan = keySpan; this.valueSpan = valueSpan; } return BoundElementProperty; }()); /** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ var CORE$1 = '@angular/core'; var Identifiers$1 = /** @class */ (function () { function Identifiers() { } return Identifiers; }()); Identifiers$1.ANALYZE_FOR_ENTRY_COMPONENTS = { name: 'ANALYZE_FOR_ENTRY_COMPONENTS', moduleName: CORE$1, }; Identifiers$1.ElementRef = { name: 'ElementRef', moduleName: CORE$1 }; Identifiers$1.NgModuleRef = { name: 'NgModuleRef', moduleName: CORE$1 }; Identifiers$1.ViewContainerRef = { name: 'ViewContainerRef', moduleName: CORE$1 }; Identifiers$1.ChangeDetectorRef = { name: 'ChangeDetectorRef', moduleName: CORE$1, }; Identifiers$1.QueryList = { name: 'QueryList', moduleName: CORE$1 }; Identifiers$1.TemplateRef = { name: 'TemplateRef', moduleName: CORE$1 }; Identifiers$1.Renderer2 = { name: 'Renderer2', moduleName: CORE$1 }; Identifiers$1.CodegenComponentFactoryResolver = { name: 'ɵCodegenComponentFactoryResolver', moduleName: CORE$1, }; Identifiers$1.ComponentFactoryResolver = { name: 'ComponentFactoryResolver', moduleName: CORE$1, }; Identifiers$1.ComponentFactory = { name: 'ComponentFactory', moduleName: CORE$1 }; Identifiers$1.ComponentRef = { name: 'ComponentRef', moduleName: CORE$1 }; Identifiers$1.NgModuleFactory = { name: 'NgModuleFactory', moduleName: CORE$1 }; Identifiers$1.createModuleFactory = { name: 'ɵcmf', moduleName: CORE$1, }; Identifiers$1.moduleDef = { name: 'ɵmod', moduleName: CORE$1, }; Identifiers$1.moduleProviderDef = { name: 'ɵmpd', moduleName: CORE$1, }; Identifiers$1.RegisterModuleFactoryFn = { name: 'ɵregisterModuleFactory', moduleName: CORE$1, }; Identifiers$1.inject = { name: 'ɵɵinject', moduleName: CORE$1 }; Identifiers$1.directiveInject = { name: 'ɵɵdirectiveInject', moduleName: CORE$1 }; Identifiers$1.INJECTOR = { name: 'INJECTOR', moduleName: CORE$1 }; Identifiers$1.Injector = { name: 'Injector', moduleName: CORE$1 }; Identifiers$1.ViewEncapsulation = { name: 'ViewEncapsulation', moduleName: CORE$1, }; Identifiers$1.ChangeDetectionStrategy = { name: 'ChangeDetectionStrategy', moduleName: CORE$1, }; Identifiers$1.SecurityContext = { name: 'SecurityContext', moduleName: CORE$1, }; Identifiers$1.LOCALE_ID = { name: 'LOCALE_ID', moduleName: CORE$1 }; Identifiers$1.TRANSLATIONS_FORMAT = { name: 'TRANSLATIONS_FORMAT', moduleName: CORE$1, }; Identifiers$1.inlineInterpolate = { name: 'ɵinlineInterpolate', moduleName: CORE$1, }; Identifiers$1.interpolate = { name: 'ɵinterpolate', moduleName: CORE$1 }; Identifiers$1.EMPTY_ARRAY = { name: 'ɵEMPTY_ARRAY', moduleName: CORE$1 }; Identifiers$1.EMPTY_MAP = { name: 'ɵEMPTY_MAP', moduleName: CORE$1 }; Identifiers$1.Renderer = { name: 'Renderer', moduleName: CORE$1 }; Identifiers$1.viewDef = { name: 'ɵvid', moduleName: CORE$1 }; Identifiers$1.elementDef = { name: 'ɵeld', moduleName: CORE$1 }; Identifiers$1.anchorDef = { name: 'ɵand', moduleName: CORE$1 }; Identifiers$1.textDef = { name: 'ɵted', moduleName: CORE$1 }; Identifiers$1.directiveDef = { name: 'ɵdid', moduleName: CORE$1 }; Identifiers$1.providerDef = { name: 'ɵprd', moduleName: CORE$1 }; Identifiers$1.queryDef = { name: 'ɵqud', moduleName: CORE$1 }; Identifiers$1.pureArrayDef = { name: 'ɵpad', moduleName: CORE$1 }; Identifiers$1.pureObjectDef = { name: 'ɵpod', moduleName: CORE$1 }; Identifiers$1.purePipeDef = { name: 'ɵppd', moduleName: CORE$1 }; Identifiers$1.pipeDef = { name: 'ɵpid', moduleName: CORE$1 }; Identifiers$1.nodeValue = { name: 'ɵnov', moduleName: CORE$1 }; Identifiers$1.ngContentDef = { name: 'ɵncd', moduleName: CORE$1 }; Identifiers$1.unwrapValue = { name: 'ɵunv', moduleName: CORE$1 }; Identifiers$1.createRendererType2 = { name: 'ɵcrt', moduleName: CORE$1 }; // type only Identifiers$1.RendererType2 = { name: 'RendererType2', moduleName: CORE$1, }; // type only Identifiers$1.ViewDefinition = { name: 'ɵViewDefinition', moduleName: CORE$1, }; Identifiers$1.createComponentFactory = { name: 'ɵccf', moduleName: CORE$1 }; function createTokenForReference(reference) { return { identifier: { reference: reference } }; } function createTokenForExternalReference(reflector, reference) { return createTokenForReference(reflector.resolveExternalReference(reference)); } var EventHandlerVars = /** @class */ (function () { function EventHandlerVars() { } return EventHandlerVars; }()); EventHandlerVars.event = variable('$event'); var ConvertActionBindingResult = /** @class */ (function () { function ConvertActionBindingResult( /** * Render2 compatible statements, */ stmts, /** * Variable name used with render2 compatible statements. */ allowDefault) { this.stmts = stmts; this.allowDefault = allowDefault; /** * This is bit of a hack. It converts statements which render2 expects to statements which are * expected by render3. * * Example: `
` will generate: * * Render3: * ``` * const pd_b:any = ((ctx.doSomething($event)) !== false); * return pd_b; * ``` * * but render2 expects: * ``` * return ctx.doSomething($event); * ``` */ // TODO(misko): remove this hack once we no longer support ViewEngine. this.render3Stmts = stmts.map(function (statement) { if (statement instanceof DeclareVarStmt && statement.name == allowDefault.name && statement.value instanceof BinaryOperatorExpr) { var lhs = statement.value.lhs; return new ReturnStatement(lhs.value); } return statement; }); } return ConvertActionBindingResult; }()); /** * Converts the given expression AST into an executable output AST, assuming the expression is * used in an action binding (e.g. an event handler). */ function convertActionBinding(localResolver, implicitReceiver, action, bindingId, interpolationFunction, baseSourceSpan, implicitReceiverAccesses, globals) { if (!localResolver) { localResolver = new DefaultLocalResolver(globals); } var actionWithoutBuiltins = convertPropertyBindingBuiltins({ createLiteralArrayConverter: function (argCount) { // Note: no caching for literal arrays in actions. return function (args) { return literalArr(args); }; }, createLiteralMapConverter: function (keys) { // Note: no caching for literal maps in actions. return function (values) { var entries = keys.map(function (k, i) { return ({ key: k.key, value: values[i], quoted: k.quoted, }); }); return literalMap(entries); }; }, createPipeConverter: function (name) { throw new Error("Illegal State: Actions are not allowed to contain pipes. Pipe: " + name); } }, action); var visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, interpolationFunction, baseSourceSpan, implicitReceiverAccesses); var actionStmts = []; flattenStatements(actionWithoutBuiltins.visit(visitor, _Mode.Statement), actionStmts); prependTemporaryDecls(visitor.temporaryCount, bindingId, actionStmts); if (visitor.usesImplicitReceiver) { localResolver.notifyImplicitReceiverUse(); } var lastIndex = actionStmts.length - 1; var preventDefaultVar = null; if (lastIndex >= 0) { var lastStatement = actionStmts[lastIndex]; var returnExpr = convertStmtIntoExpression(lastStatement); if (returnExpr) { // Note: We need to cast the result of the method call to dynamic, // as it might be a void method! preventDefaultVar = createPreventDefaultVar(bindingId); actionStmts[lastIndex] = preventDefaultVar.set(returnExpr.cast(DYNAMIC_TYPE).notIdentical(literal(false))) .toDeclStmt(null, [exports.StmtModifier.Final]); } } return new ConvertActionBindingResult(actionStmts, preventDefaultVar); } function convertPropertyBindingBuiltins(converterFactory, ast) { return convertBuiltins(converterFactory, ast); } var ConvertPropertyBindingResult = /** @class */ (function () { function ConvertPropertyBindingResult(stmts, currValExpr) { this.stmts = stmts; this.currValExpr = currValExpr; } return ConvertPropertyBindingResult; }()); var BindingForm; (function (BindingForm) { // The general form of binding expression, supports all expressions. BindingForm[BindingForm["General"] = 0] = "General"; // Try to generate a simple binding (no temporaries or statements) // otherwise generate a general binding BindingForm[BindingForm["TrySimple"] = 1] = "TrySimple"; // Inlines assignment of temporaries into the generated expression. The result may still // have statements attached for declarations of temporary variables. // This is the only relevant form for Ivy, the other forms are only used in ViewEngine. BindingForm[BindingForm["Expression"] = 2] = "Expression"; })(BindingForm || (BindingForm = {})); /** * Converts the given expression AST into an executable output AST, assuming the expression * is used in property binding. The expression has to be preprocessed via * `convertPropertyBindingBuiltins`. */ function convertPropertyBinding(localResolver, implicitReceiver, expressionWithoutBuiltins, bindingId, form, interpolationFunction) { if (!localResolver) { localResolver = new DefaultLocalResolver(); } var visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, interpolationFunction); var outputExpr = expressionWithoutBuiltins.visit(visitor, _Mode.Expression); var stmts = getStatementsFromVisitor(visitor, bindingId); if (visitor.usesImplicitReceiver) { localResolver.notifyImplicitReceiverUse(); } if (visitor.temporaryCount === 0 && form == BindingForm.TrySimple) { return new ConvertPropertyBindingResult([], outputExpr); } else if (form === BindingForm.Expression) { return new ConvertPropertyBindingResult(stmts, outputExpr); } var currValExpr = createCurrValueExpr(bindingId); stmts.push(currValExpr.set(outputExpr).toDeclStmt(DYNAMIC_TYPE, [exports.StmtModifier.Final])); return new ConvertPropertyBindingResult(stmts, currValExpr); } /** * Given some expression, such as a binding or interpolation expression, and a context expression to * look values up on, visit each facet of the given expression resolving values from the context * expression such that a list of arguments can be derived from the found values that can be used as * arguments to an external update instruction. * * @param localResolver The resolver to use to look up expressions by name appropriately * @param contextVariableExpression The expression representing the context variable used to create * the final argument expressions * @param expressionWithArgumentsToExtract The expression to visit to figure out what values need to * be resolved and what arguments list to build. * @param bindingId A name prefix used to create temporary variable names if they're needed for the * arguments generated * @returns An array of expressions that can be passed as arguments to instruction expressions like * `o.importExpr(R3.propertyInterpolate).callFn(result)` */ function convertUpdateArguments(localResolver, contextVariableExpression, expressionWithArgumentsToExtract, bindingId) { var visitor = new _AstToIrVisitor(localResolver, contextVariableExpression, bindingId, undefined); var outputExpr = expressionWithArgumentsToExtract.visit(visitor, _Mode.Expression); if (visitor.usesImplicitReceiver) { localResolver.notifyImplicitReceiverUse(); } var stmts = getStatementsFromVisitor(visitor, bindingId); // Removing the first argument, because it was a length for ViewEngine, not Ivy. var args = outputExpr.args.slice(1); if (expressionWithArgumentsToExtract instanceof Interpolation) { // If we're dealing with an interpolation of 1 value with an empty prefix and suffix, reduce the // args returned to just the value, because we're going to pass it to a special instruction. var strings = expressionWithArgumentsToExtract.strings; if (args.length === 3 && strings[0] === '' && strings[1] === '') { // Single argument interpolate instructions. args = [args[1]]; } else if (args.length >= 19) { // 19 or more arguments must be passed to the `interpolateV`-style instructions, which accept // an array of arguments args = [literalArr(args)]; } } return { stmts: stmts, args: args }; } function getStatementsFromVisitor(visitor, bindingId) { var stmts = []; for (var i = 0; i < visitor.temporaryCount; i++) { stmts.push(temporaryDeclaration(bindingId, i)); } return stmts; } function convertBuiltins(converterFactory, ast) { var visitor = new _BuiltinAstConverter(converterFactory); return ast.visit(visitor); } function temporaryName(bindingId, temporaryNumber) { return "tmp_" + bindingId + "_" + temporaryNumber; } function temporaryDeclaration(bindingId, temporaryNumber) { return new DeclareVarStmt(temporaryName(bindingId, temporaryNumber)); } function prependTemporaryDecls(temporaryCount, bindingId, statements) { for (var i = temporaryCount - 1; i >= 0; i--) { statements.unshift(temporaryDeclaration(bindingId, i)); } } var _Mode; (function (_Mode) { _Mode[_Mode["Statement"] = 0] = "Statement"; _Mode[_Mode["Expression"] = 1] = "Expression"; })(_Mode || (_Mode = {})); function ensureStatementMode(mode, ast) { if (mode !== _Mode.Statement) { throw new Error("Expected a statement, but saw " + ast); } } function ensureExpressionMode(mode, ast) { if (mode !== _Mode.Expression) { throw new Error("Expected an expression, but saw " + ast); } } function convertToStatementIfNeeded(mode, expr) { if (mode === _Mode.Statement) { return expr.toStmt(); } else { return expr; } } var _BuiltinAstConverter = /** @class */ (function (_super) { __extends(_BuiltinAstConverter, _super); function _BuiltinAstConverter(_converterFactory) { var _this = _super.call(this) || this; _this._converterFactory = _converterFactory; return _this; } _BuiltinAstConverter.prototype.visitPipe = function (ast, context) { var _this = this; var args = __spreadArray([ast.exp], __read(ast.args)).map(function (ast) { return ast.visit(_this, context); }); return new BuiltinFunctionCall(ast.span, ast.sourceSpan, args, this._converterFactory.createPipeConverter(ast.name, args.length)); }; _BuiltinAstConverter.prototype.visitLiteralArray = function (ast, context) { var _this = this; var args = ast.expressions.map(function (ast) { return ast.visit(_this, context); }); return new BuiltinFunctionCall(ast.span, ast.sourceSpan, args, this._converterFactory.createLiteralArrayConverter(ast.expressions.length)); }; _BuiltinAstConverter.prototype.visitLiteralMap = function (ast, context) { var _this = this; var args = ast.values.map(function (ast) { return ast.visit(_this, context); }); return new BuiltinFunctionCall(ast.span, ast.sourceSpan, args, this._converterFactory.createLiteralMapConverter(ast.keys)); }; return _BuiltinAstConverter; }(AstTransformer$1)); var _AstToIrVisitor = /** @class */ (function () { function _AstToIrVisitor(_localResolver, _implicitReceiver, bindingId, interpolationFunction, baseSourceSpan, implicitReceiverAccesses) { this._localResolver = _localResolver; this._implicitReceiver = _implicitReceiver; this.bindingId = bindingId; this.interpolationFunction = interpolationFunction; this.baseSourceSpan = baseSourceSpan; this.implicitReceiverAccesses = implicitReceiverAccesses; this._nodeMap = new Map(); this._resultMap = new Map(); this._currentTemporary = 0; this.temporaryCount = 0; this.usesImplicitReceiver = false; } _AstToIrVisitor.prototype.visitUnary = function (ast, mode) { var op; switch (ast.operator) { case '+': op = exports.UnaryOperator.Plus; break; case '-': op = exports.UnaryOperator.Minus; break; default: throw new Error("Unsupported operator " + ast.operator); } return convertToStatementIfNeeded(mode, new UnaryOperatorExpr(op, this._visit(ast.expr, _Mode.Expression), undefined, this.convertSourceSpan(ast.span))); }; _AstToIrVisitor.prototype.visitBinary = function (ast, mode) { var op; switch (ast.operation) { case '+': op = exports.BinaryOperator.Plus; break; case '-': op = exports.BinaryOperator.Minus; break; case '*': op = exports.BinaryOperator.Multiply; break; case '/': op = exports.BinaryOperator.Divide; break; case '%': op = exports.BinaryOperator.Modulo; break; case '&&': op = exports.BinaryOperator.And; break; case '||': op = exports.BinaryOperator.Or; break; case '==': op = exports.BinaryOperator.Equals; break; case '!=': op = exports.BinaryOperator.NotEquals; break; case '===': op = exports.BinaryOperator.Identical; break; case '!==': op = exports.BinaryOperator.NotIdentical; break; case '<': op = exports.BinaryOperator.Lower; break; case '>': op = exports.BinaryOperator.Bigger; break; case '<=': op = exports.BinaryOperator.LowerEquals; break; case '>=': op = exports.BinaryOperator.BiggerEquals; break; case '??': return this.convertNullishCoalesce(ast, mode); default: throw new Error("Unsupported operation " + ast.operation); } return convertToStatementIfNeeded(mode, new BinaryOperatorExpr(op, this._visit(ast.left, _Mode.Expression), this._visit(ast.right, _Mode.Expression), undefined, this.convertSourceSpan(ast.span))); }; _AstToIrVisitor.prototype.visitChain = function (ast, mode) { ensureStatementMode(mode, ast); return this.visitAll(ast.expressions, mode); }; _AstToIrVisitor.prototype.visitConditional = function (ast, mode) { var value = this._visit(ast.condition, _Mode.Expression); return convertToStatementIfNeeded(mode, value.conditional(this._visit(ast.trueExp, _Mode.Expression), this._visit(ast.falseExp, _Mode.Expression), this.convertSourceSpan(ast.span))); }; _AstToIrVisitor.prototype.visitPipe = function (ast, mode) { throw new Error("Illegal state: Pipes should have been converted into functions. Pipe: " + ast.name); }; _AstToIrVisitor.prototype.visitFunctionCall = function (ast, mode) { var convertedArgs = this.visitAll(ast.args, _Mode.Expression); var fnResult; if (ast instanceof BuiltinFunctionCall) { fnResult = ast.converter(convertedArgs); } else { fnResult = this._visit(ast.target, _Mode.Expression) .callFn(convertedArgs, this.convertSourceSpan(ast.span)); } return convertToStatementIfNeeded(mode, fnResult); }; _AstToIrVisitor.prototype.visitImplicitReceiver = function (ast, mode) { ensureExpressionMode(mode, ast); this.usesImplicitReceiver = true; return this._implicitReceiver; }; _AstToIrVisitor.prototype.visitThisReceiver = function (ast, mode) { return this.visitImplicitReceiver(ast, mode); }; _AstToIrVisitor.prototype.visitInterpolation = function (ast, mode) { ensureExpressionMode(mode, ast); var args = [literal(ast.expressions.length)]; for (var i = 0; i < ast.strings.length - 1; i++) { args.push(literal(ast.strings[i])); args.push(this._visit(ast.expressions[i], _Mode.Expression)); } args.push(literal(ast.strings[ast.strings.length - 1])); if (this.interpolationFunction) { return this.interpolationFunction(args); } return ast.expressions.length <= 9 ? importExpr(Identifiers$1.inlineInterpolate).callFn(args) : importExpr(Identifiers$1.interpolate).callFn([ args[0], literalArr(args.slice(1), undefined, this.convertSourceSpan(ast.span)) ]); }; _AstToIrVisitor.prototype.visitKeyedRead = function (ast, mode) { var leftMostSafe = this.leftMostSafeNode(ast); if (leftMostSafe) { return this.convertSafeAccess(ast, leftMostSafe, mode); } else { return convertToStatementIfNeeded(mode, this._visit(ast.receiver, _Mode.Expression).key(this._visit(ast.key, _Mode.Expression))); } }; _AstToIrVisitor.prototype.visitKeyedWrite = function (ast, mode) { var obj = this._visit(ast.receiver, _Mode.Expression); var key = this._visit(ast.key, _Mode.Expression); var value = this._visit(ast.value, _Mode.Expression); if (obj === this._implicitReceiver) { this._localResolver.maybeRestoreView(); } return convertToStatementIfNeeded(mode, obj.key(key).set(value)); }; _AstToIrVisitor.prototype.visitLiteralArray = function (ast, mode) { throw new Error("Illegal State: literal arrays should have been converted into functions"); }; _AstToIrVisitor.prototype.visitLiteralMap = function (ast, mode) { throw new Error("Illegal State: literal maps should have been converted into functions"); }; _AstToIrVisitor.prototype.visitLiteralPrimitive = function (ast, mode) { // For literal values of null, undefined, true, or false allow type interference // to infer the type. var type = ast.value === null || ast.value === undefined || ast.value === true || ast.value === true ? INFERRED_TYPE : undefined; return convertToStatementIfNeeded(mode, literal(ast.value, type, this.convertSourceSpan(ast.span))); }; _AstToIrVisitor.prototype._getLocal = function (name, receiver) { var _a; if (((_a = this._localResolver.globals) === null || _a === void 0 ? void 0 : _a.has(name)) && receiver instanceof ThisReceiver) { return null; } return this._localResolver.getLocal(name); }; _AstToIrVisitor.prototype.visitMethodCall = function (ast, mode) { if (ast.receiver instanceof ImplicitReceiver && !(ast.receiver instanceof ThisReceiver) && ast.name === '$any') { var args = this.visitAll(ast.args, _Mode.Expression); if (args.length != 1) { throw new Error("Invalid call to $any, expected 1 argument but received " + (args.length || 'none')); } return args[0].cast(DYNAMIC_TYPE, this.convertSourceSpan(ast.span)); } var leftMostSafe = this.leftMostSafeNode(ast); if (leftMostSafe) { return this.convertSafeAccess(ast, leftMostSafe, mode); } else { var args = this.visitAll(ast.args, _Mode.Expression); var prevUsesImplicitReceiver = this.usesImplicitReceiver; var result = null; var receiver = this._visit(ast.receiver, _Mode.Expression); if (receiver === this._implicitReceiver) { var varExpr = this._getLocal(ast.name, ast.receiver); if (varExpr) { // Restore the previous "usesImplicitReceiver" state since the implicit // receiver has been replaced with a resolved local expression. this.usesImplicitReceiver = prevUsesImplicitReceiver; result = varExpr.callFn(args); this.addImplicitReceiverAccess(ast.name); } } if (result == null) { result = receiver.callMethod(ast.name, args, this.convertSourceSpan(ast.span)); } return convertToStatementIfNeeded(mode, result); } }; _AstToIrVisitor.prototype.visitPrefixNot = function (ast, mode) { return convertToStatementIfNeeded(mode, not(this._visit(ast.expression, _Mode.Expression))); }; _AstToIrVisitor.prototype.visitNonNullAssert = function (ast, mode) { return convertToStatementIfNeeded(mode, assertNotNull(this._visit(ast.expression, _Mode.Expression))); }; _AstToIrVisitor.prototype.visitPropertyRead = function (ast, mode) { var leftMostSafe = this.leftMostSafeNode(ast); if (leftMostSafe) { return this.convertSafeAccess(ast, leftMostSafe, mode); } else { var result = null; var prevUsesImplicitReceiver = this.usesImplicitReceiver; var receiver = this._visit(ast.receiver, _Mode.Expression); if (receiver === this._implicitReceiver) { result = this._getLocal(ast.name, ast.receiver); if (result) { // Restore the previous "usesImplicitReceiver" state since the implicit // receiver has been replaced with a resolved local expression. this.usesImplicitReceiver = prevUsesImplicitReceiver; this.addImplicitReceiverAccess(ast.name); } } if (result == null) { result = receiver.prop(ast.name); } return convertToStatementIfNeeded(mode, result); } }; _AstToIrVisitor.prototype.visitPropertyWrite = function (ast, mode) { var receiver = this._visit(ast.receiver, _Mode.Expression); var prevUsesImplicitReceiver = this.usesImplicitReceiver; var varExpr = null; if (receiver === this._implicitReceiver) { var localExpr = this._getLocal(ast.name, ast.receiver); if (localExpr) { if (localExpr instanceof ReadPropExpr) { // If the local variable is a property read expression, it's a reference // to a 'context.property' value and will be used as the target of the // write expression. varExpr = localExpr; // Restore the previous "usesImplicitReceiver" state since the implicit // receiver has been replaced with a resolved local expression. this.usesImplicitReceiver = prevUsesImplicitReceiver; this.addImplicitReceiverAccess(ast.name); } else { // Otherwise it's an error. var receiver_1 = ast.name; var value = (ast.value instanceof PropertyRead) ? ast.value.name : undefined; throw new Error("Cannot assign value \"" + value + "\" to template variable \"" + receiver_1 + "\". Template variables are read-only."); } } } // If no local expression could be produced, use the original receiver's // property as the target. if (varExpr === null) { varExpr = receiver.prop(ast.name); } return convertToStatementIfNeeded(mode, varExpr.set(this._visit(ast.value, _Mode.Expression))); }; _AstToIrVisitor.prototype.visitSafePropertyRead = function (ast, mode) { return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode); }; _AstToIrVisitor.prototype.visitSafeMethodCall = function (ast, mode) { return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode); }; _AstToIrVisitor.prototype.visitSafeKeyedRead = function (ast, mode) { return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode); }; _AstToIrVisitor.prototype.visitAll = function (asts, mode) { var _this = this; return asts.map(function (ast) { return _this._visit(ast, mode); }); }; _AstToIrVisitor.prototype.visitQuote = function (ast, mode) { throw new Error("Quotes are not supported for evaluation!\n Statement: " + ast.uninterpretedExpression + " located at " + ast.location); }; _AstToIrVisitor.prototype._visit = function (ast, mode) { var result = this._resultMap.get(ast); if (result) return result; return (this._nodeMap.get(ast) || ast).visit(this, mode); }; _AstToIrVisitor.prototype.convertSafeAccess = function (ast, leftMostSafe, mode) { // If the expression contains a safe access node on the left it needs to be converted to // an expression that guards the access to the member by checking the receiver for blank. As // execution proceeds from left to right, the left most part of the expression must be guarded // first but, because member access is left associative, the right side of the expression is at // the top of the AST. The desired result requires lifting a copy of the left part of the // expression up to test it for blank before generating the unguarded version. // Consider, for example the following expression: a?.b.c?.d.e // This results in the ast: // . // / \ // ?. e // / \ // . d // / \ // ?. c // / \ // a b // The following tree should be generated: // // /---- ? ----\ // / | \ // a /--- ? ---\ null // / | \ // . . null // / \ / \ // . c . e // / \ / \ // a b . d // / \ // . c // / \ // a b // // Notice that the first guard condition is the left hand of the left most safe access node // which comes in as leftMostSafe to this routine. var guardedExpression = this._visit(leftMostSafe.receiver, _Mode.Expression); var temporary = undefined; if (this.needsTemporaryInSafeAccess(leftMostSafe.receiver)) { // If the expression has method calls or pipes then we need to save the result into a // temporary variable to avoid calling stateful or impure code more than once. temporary = this.allocateTemporary(); // Preserve the result in the temporary variable guardedExpression = temporary.set(guardedExpression); // Ensure all further references to the guarded expression refer to the temporary instead. this._resultMap.set(leftMostSafe.receiver, temporary); } var condition = guardedExpression.isBlank(); // Convert the ast to an unguarded access to the receiver's member. The map will substitute // leftMostNode with its unguarded version in the call to `this.visit()`. if (leftMostSafe instanceof SafeMethodCall) { this._nodeMap.set(leftMostSafe, new MethodCall(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan, leftMostSafe.receiver, leftMostSafe.name, leftMostSafe.args, leftMostSafe.argumentSpan)); } else if (leftMostSafe instanceof SafeKeyedRead) { this._nodeMap.set(leftMostSafe, new KeyedRead(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.receiver, leftMostSafe.key)); } else { this._nodeMap.set(leftMostSafe, new PropertyRead(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan, leftMostSafe.receiver, leftMostSafe.name)); } // Recursively convert the node now without the guarded member access. var access = this._visit(ast, _Mode.Expression); // Remove the mapping. This is not strictly required as the converter only traverses each node // once but is safer if the conversion is changed to traverse the nodes more than once. this._nodeMap.delete(leftMostSafe); // If we allocated a temporary, release it. if (temporary) { this.releaseTemporary(temporary); } // Produce the conditional return convertToStatementIfNeeded(mode, condition.conditional(NULL_EXPR, access)); }; _AstToIrVisitor.prototype.convertNullishCoalesce = function (ast, mode) { var left = this._visit(ast.left, _Mode.Expression); var right = this._visit(ast.right, _Mode.Expression); var temporary = this.allocateTemporary(); this.releaseTemporary(temporary); // Generate the following expression. It is identical to how TS // transpiles binary expressions with a nullish coalescing operator. // let temp; // (temp = a) !== null && temp !== undefined ? temp : b; return convertToStatementIfNeeded(mode, temporary.set(left) .notIdentical(NULL_EXPR) .and(temporary.notIdentical(literal(undefined))) .conditional(temporary, right)); }; // Given an expression of the form a?.b.c?.d.e then the left most safe node is // the (a?.b). The . and ?. are left associative thus can be rewritten as: // ((((a?.c).b).c)?.d).e. This returns the most deeply nested safe read or // safe method call as this needs to be transformed initially to: // a == null ? null : a.c.b.c?.d.e // then to: // a == null ? null : a.b.c == null ? null : a.b.c.d.e _AstToIrVisitor.prototype.leftMostSafeNode = function (ast) { var _this = this; var visit = function (visitor, ast) { return (_this._nodeMap.get(ast) || ast).visit(visitor); }; return ast.visit({ visitUnary: function (ast) { return null; }, visitBinary: function (ast) { return null; }, visitChain: function (ast) { return null; }, visitConditional: function (ast) { return null; }, visitFunctionCall: function (ast) { return null; }, visitImplicitReceiver: function (ast) { return null; }, visitThisReceiver: function (ast) { return null; }, visitInterpolation: function (ast) { return null; }, visitKeyedRead: function (ast) { return visit(this, ast.receiver); }, visitKeyedWrite: function (ast) { return null; }, visitLiteralArray: function (ast) { return null; }, visitLiteralMap: function (ast) { return null; }, visitLiteralPrimitive: function (ast) { return null; }, visitMethodCall: function (ast) { return visit(this, ast.receiver); }, visitPipe: function (ast) { return null; }, visitPrefixNot: function (ast) { return null; }, visitNonNullAssert: function (ast) { return null; }, visitPropertyRead: function (ast) { return visit(this, ast.receiver); }, visitPropertyWrite: function (ast) { return null; }, visitQuote: function (ast) { return null; }, visitSafeMethodCall: function (ast) { return visit(this, ast.receiver) || ast; }, visitSafePropertyRead: function (ast) { return visit(this, ast.receiver) || ast; }, visitSafeKeyedRead: function (ast) { return visit(this, ast.receiver) || ast; } }); }; // Returns true of the AST includes a method or a pipe indicating that, if the // expression is used as the target of a safe property or method access then // the expression should be stored into a temporary variable. _AstToIrVisitor.prototype.needsTemporaryInSafeAccess = function (ast) { var _this = this; var visit = function (visitor, ast) { return ast && (_this._nodeMap.get(ast) || ast).visit(visitor); }; var visitSome = function (visitor, ast) { return ast.some(function (ast) { return visit(visitor, ast); }); }; return ast.visit({ visitUnary: function (ast) { return visit(this, ast.expr); }, visitBinary: function (ast) { return visit(this, ast.left) || visit(this, ast.right); }, visitChain: function (ast) { return false; }, visitConditional: function (ast) { return visit(this, ast.condition) || visit(this, ast.trueExp) || visit(this, ast.falseExp); }, visitFunctionCall: function (ast) { return true; }, visitImplicitReceiver: function (ast) { return false; }, visitThisReceiver: function (ast) { return false; }, visitInterpolation: function (ast) { return visitSome(this, ast.expressions); }, visitKeyedRead: function (ast) { return false; }, visitKeyedWrite: function (ast) { return false; }, visitLiteralArray: function (ast) { return true; }, visitLiteralMap: function (ast) { return true; }, visitLiteralPrimitive: function (ast) { return false; }, visitMethodCall: function (ast) { return true; }, visitPipe: function (ast) { return true; }, visitPrefixNot: function (ast) { return visit(this, ast.expression); }, visitNonNullAssert: function (ast) { return visit(this, ast.expression); }, visitPropertyRead: function (ast) { return false; }, visitPropertyWrite: function (ast) { return false; }, visitQuote: function (ast) { return false; }, visitSafeMethodCall: function (ast) { return true; }, visitSafePropertyRead: function (ast) { return false; }, visitSafeKeyedRead: function (ast) { return false; } }); }; _AstToIrVisitor.prototype.allocateTemporary = function () { var tempNumber = this._currentTemporary++; this.temporaryCount = Math.max(this._currentTemporary, this.temporaryCount); return new ReadVarExpr(temporaryName(this.bindingId, tempNumber)); }; _AstToIrVisitor.prototype.releaseTemporary = function (temporary) { this._currentTemporary--; if (temporary.name != temporaryName(this.bindingId, this._currentTemporary)) { throw new Error("Temporary " + temporary.name + " released out of order"); } }; /** * Creates an absolute `ParseSourceSpan` from the relative `ParseSpan`. * * `ParseSpan` objects are relative to the start of the expression. * This method converts these to full `ParseSourceSpan` objects that * show where the span is within the overall source file. * * @param span the relative span to convert. * @returns a `ParseSourceSpan` for the given span or null if no * `baseSourceSpan` was provided to this class. */ _AstToIrVisitor.prototype.convertSourceSpan = function (span) { if (this.baseSourceSpan) { var start = this.baseSourceSpan.start.moveBy(span.start); var end = this.baseSourceSpan.start.moveBy(span.end); var fullStart = this.baseSourceSpan.fullStart.moveBy(span.start); return new ParseSourceSpan(start, end, fullStart); } else { return null; } }; /** Adds the name of an AST to the list of implicit receiver accesses. */ _AstToIrVisitor.prototype.addImplicitReceiverAccess = function (name) { if (this.implicitReceiverAccesses) { this.implicitReceiverAccesses.add(name); } }; return _AstToIrVisitor; }()); function flattenStatements(arg, output) { if (Array.isArray(arg)) { arg.forEach(function (entry) { return flattenStatements(entry, output); }); } else { output.push(arg); } } var DefaultLocalResolver = /** @class */ (function () { function DefaultLocalResolver(globals) { this.globals = globals; } DefaultLocalResolver.prototype.notifyImplicitReceiverUse = function () { }; DefaultLocalResolver.prototype.maybeRestoreView = function () { }; DefaultLocalResolver.prototype.getLocal = function (name) { if (name === EventHandlerVars.event.name) { return EventHandlerVars.event; } return null; }; return DefaultLocalResolver; }()); function createCurrValueExpr(bindingId) { return variable("currVal_" + bindingId); // fix syntax highlighting: ` } function createPreventDefaultVar(bindingId) { return variable("pd_" + bindingId); } function convertStmtIntoExpression(stmt) { if (stmt instanceof ExpressionStatement) { return stmt.expr; } else if (stmt instanceof ReturnStatement) { return stmt.value; } return null; } var BuiltinFunctionCall = /** @class */ (function (_super) { __extends(BuiltinFunctionCall, _super); function BuiltinFunctionCall(span, sourceSpan, args, converter) { var _this = _super.call(this, span, sourceSpan, null, args) || this; _this.converter = converter; return _this; } return BuiltinFunctionCall; }(FunctionCall)); // ================================================================================================= // ================================================================================================= // =========== S T O P - S T O P - S T O P - S T O P - S T O P - S T O P =========== // ================================================================================================= // ================================================================================================= // // DO NOT EDIT THIS LIST OF SECURITY SENSITIVE PROPERTIES WITHOUT A SECURITY REVIEW! // Reach out to mprobst for details. // // ================================================================================================= /** Map from tagName|propertyName to SecurityContext. Properties applying to all tags use '*'. */ var _SECURITY_SCHEMA; function SECURITY_SCHEMA() { if (!_SECURITY_SCHEMA) { _SECURITY_SCHEMA = {}; // Case is insignificant below, all element and attribute names are lower-cased for lookup. registerContext(SecurityContext.HTML, [ 'iframe|srcdoc', '*|innerHTML', '*|outerHTML', ]); registerContext(SecurityContext.STYLE, ['*|style']); // NB: no SCRIPT contexts here, they are never allowed due to the parser stripping them. registerContext(SecurityContext.URL, [ '*|formAction', 'area|href', 'area|ping', 'audio|src', 'a|href', 'a|ping', 'blockquote|cite', 'body|background', 'del|cite', 'form|action', 'img|src', 'img|srcset', 'input|src', 'ins|cite', 'q|cite', 'source|src', 'source|srcset', 'track|src', 'video|poster', 'video|src', ]); registerContext(SecurityContext.RESOURCE_URL, [ 'applet|code', 'applet|codebase', 'base|href', 'embed|src', 'frame|src', 'head|profile', 'html|manifest', 'iframe|src', 'link|href', 'media|src', 'object|codebase', 'object|data', 'script|src', ]); } return _SECURITY_SCHEMA; } function registerContext(ctx, specs) { var e_1, _a; try { for (var specs_1 = __values(specs), specs_1_1 = specs_1.next(); !specs_1_1.done; specs_1_1 = specs_1.next()) { var spec = specs_1_1.value; _SECURITY_SCHEMA[spec.toLowerCase()] = ctx; } } catch (e_1_1) { e_1 = { error: e_1_1 }; } finally { try { if (specs_1_1 && !specs_1_1.done && (_a = specs_1.return)) _a.call(specs_1); } finally { if (e_1) throw e_1.error; } } } /** * The set of security-sensitive attributes of an `