@angular/core 9.0.0-rc.7 → 9.0.1

package/esm2015/src/render3/styling/styling_parser.js

@@ -0,0 +1,336 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: packages/core/src/render3/styling/styling_parser.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+import { assertEqual, throwError } from '../../util/assert';
+/**
+ * Stores the locations of key/value indexes while parsing styling.
+ *
+ * In case of `cssText` parsing the indexes are like so:
+ * ```
+ *   "key1: value1; key2: value2; key3: value3"
+ *                  ^   ^ ^     ^             ^
+ *                  |   | |     |             +-- textEnd
+ *                  |   | |     +---------------- valueEnd
+ *                  |   | +---------------------- value
+ *                  |   +------------------------ keyEnd
+ *                  +---------------------------- key
+ * ```
+ *
+ * In case of `className` parsing the indexes are like so:
+ * ```
+ *   "key1 key2 key3"
+ *         ^   ^    ^
+ *         |   |    +-- textEnd
+ *         |   +------------------------ keyEnd
+ *         +---------------------------- key
+ * ```
+ * NOTE: `value` and `valueEnd` are used only for styles, not classes.
+ * @record
+ */
+function ParserState() { }
+if (false) {
+    /** @type {?} */
+    ParserState.prototype.textEnd;
+    /** @type {?} */
+    ParserState.prototype.key;
+    /** @type {?} */
+    ParserState.prototype.keyEnd;
+    /** @type {?} */
+    ParserState.prototype.value;
+    /** @type {?} */
+    ParserState.prototype.valueEnd;
+}
+// Global state of the parser. (This makes parser non-reentrant, but that is not an issue)
+/** @type {?} */
+const parserState = {
+    textEnd: 0,
+    key: 0,
+    keyEnd: 0,
+    value: 0,
+    valueEnd: 0,
+};
+/**
+ * Retrieves the last parsed `key` of style.
+ * @param {?} text the text to substring the key from.
+ * @return {?}
+ */
+export function getLastParsedKey(text) {
+    return text.substring(parserState.key, parserState.keyEnd);
+}
+/**
+ * Retrieves the last parsed `value` of style.
+ * @param {?} text the text to substring the key from.
+ * @return {?}
+ */
+export function getLastParsedValue(text) {
+    return text.substring(parserState.value, parserState.valueEnd);
+}
+/**
+ * Initializes `className` string for parsing and parses the first token.
+ *
+ * This function is intended to be used in this format:
+ * ```
+ * for (let i = parseClassName(text); i >= 0; i = parseClassNameNext(text, i)) {
+ *   const key = getLastParsedKey();
+ *   ...
+ * }
+ * ```
+ * @param {?} text `className` to parse
+ * @return {?} index where the next invocation of `parseClassNameNext` should resume.
+ */
+export function parseClassName(text) {
+    resetParserState(text);
+    return parseClassNameNext(text, consumeWhitespace(text, 0, parserState.textEnd));
+}
+/**
+ * Parses next `className` token.
+ *
+ * This function is intended to be used in this format:
+ * ```
+ * for (let i = parseClassName(text); i >= 0; i = parseClassNameNext(text, i)) {
+ *   const key = getLastParsedKey();
+ *   ...
+ * }
+ * ```
+ *
+ * @param {?} text `className` to parse
+ * @param {?} index where the parsing should resume.
+ * @return {?} index where the next invocation of `parseClassNameNext` should resume.
+ */
+export function parseClassNameNext(text, index) {
+    /** @type {?} */
+    const end = parserState.textEnd;
+    if (end === index) {
+        return -1;
+    }
+    index = parserState.keyEnd = consumeClassToken(text, parserState.key = index, end);
+    return consumeWhitespace(text, index, end);
+}
+/**
+ * Initializes `cssText` string for parsing and parses the first key/values.
+ *
+ * This function is intended to be used in this format:
+ * ```
+ * for (let i = parseStyle(text); i >= 0; i = parseStyleNext(text, i))) {
+ *   const key = getLastParsedKey();
+ *   const value = getLastParsedValue();
+ *   ...
+ * }
+ * ```
+ * @param {?} text `cssText` to parse
+ * @return {?} index where the next invocation of `parseStyleNext` should resume.
+ */
+export function parseStyle(text) {
+    resetParserState(text);
+    return parseStyleNext(text, consumeWhitespace(text, 0, parserState.textEnd));
+}
+/**
+ * Parses the next `cssText` key/values.
+ *
+ * This function is intended to be used in this format:
+ * ```
+ * for (let i = parseStyle(text); i >= 0; i = parseStyleNext(text, i))) {
+ *   const key = getLastParsedKey();
+ *   const value = getLastParsedValue();
+ *   ...
+ * }
+ *
+ * @param {?} text `cssText` to parse
+ * @param {?} startIndex
+ * @return {?} index where the next invocation of `parseStyleNext` should resume.
+ */
+export function parseStyleNext(text, startIndex) {
+    /** @type {?} */
+    const end = parserState.textEnd;
+    /** @type {?} */
+    let index = parserState.key = consumeWhitespace(text, startIndex, end);
+    if (end === index) {
+        // we reached an end so just quit
+        return -1;
+    }
+    index = parserState.keyEnd = consumeStyleKey(text, index, end);
+    index = consumeSeparator(text, index, end, 58 /* COLON */);
+    index = parserState.value = consumeWhitespace(text, index, end);
+    index = parserState.valueEnd = consumeStyleValue(text, index, end);
+    return consumeSeparator(text, index, end, 59 /* SEMI_COLON */);
+}
+/**
+ * Reset the global state of the styling parser.
+ * @param {?} text The styling text to parse.
+ * @return {?}
+ */
+export function resetParserState(text) {
+    parserState.key = 0;
+    parserState.keyEnd = 0;
+    parserState.value = 0;
+    parserState.valueEnd = 0;
+    parserState.textEnd = text.length;
+}
+/**
+ * Returns index of next non-whitespace character.
+ *
+ * @param {?} text Text to scan
+ * @param {?} startIndex Starting index of character where the scan should start.
+ * @param {?} endIndex Ending index of character where the scan should end.
+ * @return {?} Index of next non-whitespace character (May be the same as `start` if no whitespace at
+ *          that location.)
+ */
+export function consumeWhitespace(text, startIndex, endIndex) {
+    while (startIndex < endIndex && text.charCodeAt(startIndex) <= 32 /* SPACE */) {
+        startIndex++;
+    }
+    return startIndex;
+}
+/**
+ * Returns index of last char in class token.
+ *
+ * @param {?} text Text to scan
+ * @param {?} startIndex Starting index of character where the scan should start.
+ * @param {?} endIndex Ending index of character where the scan should end.
+ * @return {?} Index after last char in class token.
+ */
+export function consumeClassToken(text, startIndex, endIndex) {
+    while (startIndex < endIndex && text.charCodeAt(startIndex) > 32 /* SPACE */) {
+        startIndex++;
+    }
+    return startIndex;
+}
+/**
+ * Consumes all of the characters belonging to style key and token.
+ *
+ * @param {?} text Text to scan
+ * @param {?} startIndex Starting index of character where the scan should start.
+ * @param {?} endIndex Ending index of character where the scan should end.
+ * @return {?} Index after last style key character.
+ */
+export function consumeStyleKey(text, startIndex, endIndex) {
+    /** @type {?} */
+    let ch;
+    while (startIndex < endIndex &&
+        ((ch = text.charCodeAt(startIndex)) === 45 /* DASH */ || ch === 95 /* UNDERSCORE */ ||
+            ((ch & -33 /* UPPER_CASE */) >= 65 /* A */ && (ch & -33 /* UPPER_CASE */) <= 90 /* Z */))) {
+        startIndex++;
+    }
+    return startIndex;
+}
+/**
+ * Consumes all whitespace and the separator `:` after the style key.
+ *
+ * @param {?} text Text to scan
+ * @param {?} startIndex Starting index of character where the scan should start.
+ * @param {?} endIndex Ending index of character where the scan should end.
+ * @param {?} separator
+ * @return {?} Index after separator and surrounding whitespace.
+ */
+export function consumeSeparator(text, startIndex, endIndex, separator) {
+    startIndex = consumeWhitespace(text, startIndex, endIndex);
+    if (startIndex < endIndex) {
+        if (ngDevMode && text.charCodeAt(startIndex) !== separator) {
+            malformedStyleError(text, String.fromCharCode(separator), startIndex);
+        }
+        startIndex++;
+    }
+    return startIndex;
+}
+/**
+ * Consumes style value honoring `url()` and `""` text.
+ *
+ * @param {?} text Text to scan
+ * @param {?} startIndex Starting index of character where the scan should start.
+ * @param {?} endIndex Ending index of character where the scan should end.
+ * @return {?} Index after last style value character.
+ */
+export function consumeStyleValue(text, startIndex, endIndex) {
+    /** @type {?} */
+    let ch1 = -1;
+    // 1st previous character
+    /** @type {?} */
+    let ch2 = -1;
+    // 2nd previous character
+    /** @type {?} */
+    let ch3 = -1;
+    // 3rd previous character
+    /** @type {?} */
+    let i = startIndex;
+    /** @type {?} */
+    let lastChIndex = i;
+    while (i < endIndex) {
+        /** @type {?} */
+        const ch = text.charCodeAt(i++);
+        if (ch === 59 /* SEMI_COLON */) {
+            return lastChIndex;
+        }
+        else if (ch === 34 /* DOUBLE_QUOTE */ || ch === 39 /* SINGLE_QUOTE */) {
+            lastChIndex = i = consumeQuotedText(text, ch, i, endIndex);
+        }
+        else if (startIndex ===
+            i - 4 && // We have seen only 4 characters so far "URL(" (Ignore "foo_URL()")
+            ch3 === 85 /* U */ &&
+            ch2 === 82 /* R */ && ch1 === 76 /* L */ && ch === 40 /* OPEN_PAREN */) {
+            lastChIndex = i = consumeQuotedText(text, 41 /* CLOSE_PAREN */, i, endIndex);
+        }
+        else if (ch > 32 /* SPACE */) {
+            // if we have a non-whitespace character then capture its location
+            lastChIndex = i;
+        }
+        ch3 = ch2;
+        ch2 = ch1;
+        ch1 = ch & -33 /* UPPER_CASE */;
+    }
+    return lastChIndex;
+}
+/**
+ * Consumes all of the quoted characters.
+ *
+ * @param {?} text Text to scan
+ * @param {?} quoteCharCode CharCode of either `"` or `'` quote or `)` for `url(...)`.
+ * @param {?} startIndex Starting index of character where the scan should start.
+ * @param {?} endIndex Ending index of character where the scan should end.
+ * @return {?} Index after quoted characters.
+ */
+export function consumeQuotedText(text, quoteCharCode, startIndex, endIndex) {
+    /** @type {?} */
+    let ch1 = -1;
+    // 1st previous character
+    /** @type {?} */
+    let index = startIndex;
+    while (index < endIndex) {
+        /** @type {?} */
+        const ch = text.charCodeAt(index++);
+        if (ch == quoteCharCode && ch1 !== 92 /* BACK_SLASH */) {
+            return index;
+        }
+        if (ch == 92 /* BACK_SLASH */ && ch1 === 92 /* BACK_SLASH */) {
+            // two back slashes cancel each other out. For example `"\\"` should properly end the
+            // quotation. (It should not assume that the last `"` is escaped.)
+            ch1 = 0;
+        }
+        else {
+            ch1 = ch;
+        }
+    }
+    throw ngDevMode ? malformedStyleError(text, String.fromCharCode(quoteCharCode), endIndex) :
+        new Error();
+}
+/**
+ * @param {?} text
+ * @param {?} expecting
+ * @param {?} index
+ * @return {?}
+ */
+function malformedStyleError(text, expecting, index) {
+    ngDevMode && assertEqual(typeof text === 'string', true, 'String expected here');
+    throw throwError(`Malformed style at location ${index} in string '` + text.substring(0, index) + '[>>' +
+        text.substring(index, index + 1) + '<<]' + text.substr(index + 1) +
+        `'. Expecting '${expecting}'.`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styling_parser.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/styling/styling_parser.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {assertEqual, throwError} from '../../util/assert';\nimport {CharCode} from '../../util/char_code';\n\n/**\n * Stores the locations of key/value indexes while parsing styling.\n *\n * In case of `cssText` parsing the indexes are like so:\n * ```\n *   \"key1: value1; key2: value2; key3: value3\"\n *                  ^   ^ ^     ^             ^\n *                  |   | |     |             +-- textEnd\n *                  |   | |     +---------------- valueEnd\n *                  |   | +---------------------- value\n *                  |   +------------------------ keyEnd\n *                  +---------------------------- key\n * ```\n *\n * In case of `className` parsing the indexes are like so:\n * ```\n *   \"key1 key2 key3\"\n *         ^   ^    ^\n *         |   |    +-- textEnd\n *         |   +------------------------ keyEnd\n *         +---------------------------- key\n * ```\n * NOTE: `value` and `valueEnd` are used only for styles, not classes.\n */\ninterface ParserState {\n  textEnd: number;\n  key: number;\n  keyEnd: number;\n  value: number;\n  valueEnd: number;\n}\n// Global state of the parser. (This makes parser non-reentrant, but that is not an issue)\nconst parserState: ParserState = {\n  textEnd: 0,\n  key: 0,\n  keyEnd: 0,\n  value: 0,\n  valueEnd: 0,\n};\n\n/**\n * Retrieves the last parsed `key` of style.\n * @param text the text to substring the key from.\n */\nexport function getLastParsedKey(text: string): string {\n  return text.substring(parserState.key, parserState.keyEnd);\n}\n\n/**\n * Retrieves the last parsed `value` of style.\n * @param text the text to substring the key from.\n */\nexport function getLastParsedValue(text: string): string {\n  return text.substring(parserState.value, parserState.valueEnd);\n}\n\n/**\n * Initializes `className` string for parsing and parses the first token.\n *\n * This function is intended to be used in this format:\n * ```\n * for (let i = parseClassName(text); i >= 0; i = parseClassNameNext(text, i)) {\n *   const key = getLastParsedKey();\n *   ...\n * }\n * ```\n * @param text `className` to parse\n * @returns index where the next invocation of `parseClassNameNext` should resume.\n */\nexport function parseClassName(text: string): number {\n  resetParserState(text);\n  return parseClassNameNext(text, consumeWhitespace(text, 0, parserState.textEnd));\n}\n\n/**\n * Parses next `className` token.\n *\n * This function is intended to be used in this format:\n * ```\n * for (let i = parseClassName(text); i >= 0; i = parseClassNameNext(text, i)) {\n *   const key = getLastParsedKey();\n *   ...\n * }\n * ```\n *\n * @param text `className` to parse\n * @param index where the parsing should resume.\n * @returns index where the next invocation of `parseClassNameNext` should resume.\n */\nexport function parseClassNameNext(text: string, index: number): number {\n  const end = parserState.textEnd;\n  if (end === index) {\n    return -1;\n  }\n  index = parserState.keyEnd = consumeClassToken(text, parserState.key = index, end);\n  return consumeWhitespace(text, index, end);\n}\n\n/**\n * Initializes `cssText` string for parsing and parses the first key/values.\n *\n * This function is intended to be used in this format:\n * ```\n * for (let i = parseStyle(text); i >= 0; i = parseStyleNext(text, i))) {\n *   const key = getLastParsedKey();\n *   const value = getLastParsedValue();\n *   ...\n * }\n * ```\n * @param text `cssText` to parse\n * @returns index where the next invocation of `parseStyleNext` should resume.\n */\nexport function parseStyle(text: string): number {\n  resetParserState(text);\n  return parseStyleNext(text, consumeWhitespace(text, 0, parserState.textEnd));\n}\n\n/**\n * Parses the next `cssText` key/values.\n *\n * This function is intended to be used in this format:\n * ```\n * for (let i = parseStyle(text); i >= 0; i = parseStyleNext(text, i))) {\n *   const key = getLastParsedKey();\n *   const value = getLastParsedValue();\n *   ...\n * }\n *\n * @param text `cssText` to parse\n * @param index where the parsing should resume.\n * @returns index where the next invocation of `parseStyleNext` should resume.\n */\nexport function parseStyleNext(text: string, startIndex: number): number {\n  const end = parserState.textEnd;\n  let index = parserState.key = consumeWhitespace(text, startIndex, end);\n  if (end === index) {\n    // we reached an end so just quit\n    return -1;\n  }\n  index = parserState.keyEnd = consumeStyleKey(text, index, end);\n  index = consumeSeparator(text, index, end, CharCode.COLON);\n  index = parserState.value = consumeWhitespace(text, index, end);\n  index = parserState.valueEnd = consumeStyleValue(text, index, end);\n  return consumeSeparator(text, index, end, CharCode.SEMI_COLON);\n}\n\n/**\n * Reset the global state of the styling parser.\n * @param text The styling text to parse.\n */\nexport function resetParserState(text: string): void {\n  parserState.key = 0;\n  parserState.keyEnd = 0;\n  parserState.value = 0;\n  parserState.valueEnd = 0;\n  parserState.textEnd = text.length;\n}\n\n/**\n * Returns index of next non-whitespace character.\n *\n * @param text Text to scan\n * @param startIndex Starting index of character where the scan should start.\n * @param endIndex Ending index of character where the scan should end.\n * @returns Index of next non-whitespace character (May be the same as `start` if no whitespace at\n *          that location.)\n */\nexport function consumeWhitespace(text: string, startIndex: number, endIndex: number): number {\n  while (startIndex < endIndex && text.charCodeAt(startIndex) <= CharCode.SPACE) {\n    startIndex++;\n  }\n  return startIndex;\n}\n\n/**\n * Returns index of last char in class token.\n *\n * @param text Text to scan\n * @param startIndex Starting index of character where the scan should start.\n * @param endIndex Ending index of character where the scan should end.\n * @returns Index after last char in class token.\n */\nexport function consumeClassToken(text: string, startIndex: number, endIndex: number): number {\n  while (startIndex < endIndex && text.charCodeAt(startIndex) > CharCode.SPACE) {\n    startIndex++;\n  }\n  return startIndex;\n}\n\n/**\n * Consumes all of the characters belonging to style key and token.\n *\n * @param text Text to scan\n * @param startIndex Starting index of character where the scan should start.\n * @param endIndex Ending index of character where the scan should end.\n * @returns Index after last style key character.\n */\nexport function consumeStyleKey(text: string, startIndex: number, endIndex: number): number {\n  let ch: number;\n  while (startIndex < endIndex &&\n         ((ch = text.charCodeAt(startIndex)) === CharCode.DASH || ch === CharCode.UNDERSCORE ||\n          ((ch & CharCode.UPPER_CASE) >= CharCode.A && (ch & CharCode.UPPER_CASE) <= CharCode.Z))) {\n    startIndex++;\n  }\n  return startIndex;\n}\n\n/**\n * Consumes all whitespace and the separator `:` after the style key.\n *\n * @param text Text to scan\n * @param startIndex Starting index of character where the scan should start.\n * @param endIndex Ending index of character where the scan should end.\n * @returns Index after separator and surrounding whitespace.\n */\nexport function consumeSeparator(\n    text: string, startIndex: number, endIndex: number, separator: number): number {\n  startIndex = consumeWhitespace(text, startIndex, endIndex);\n  if (startIndex < endIndex) {\n    if (ngDevMode && text.charCodeAt(startIndex) !== separator) {\n      malformedStyleError(text, String.fromCharCode(separator), startIndex);\n    }\n    startIndex++;\n  }\n  return startIndex;\n}\n\n\n/**\n * Consumes style value honoring `url()` and `\"\"` text.\n *\n * @param text Text to scan\n * @param startIndex Starting index of character where the scan should start.\n * @param endIndex Ending index of character where the scan should end.\n * @returns Index after last style value character.\n*/\nexport function consumeStyleValue(text: string, startIndex: number, endIndex: number): number {\n  let ch1 = -1;  // 1st previous character\n  let ch2 = -1;  // 2nd previous character\n  let ch3 = -1;  // 3rd previous character\n  let i = startIndex;\n  let lastChIndex = i;\n  while (i < endIndex) {\n    const ch: number = text.charCodeAt(i++);\n    if (ch === CharCode.SEMI_COLON) {\n      return lastChIndex;\n    } else if (ch === CharCode.DOUBLE_QUOTE || ch === CharCode.SINGLE_QUOTE) {\n      lastChIndex = i = consumeQuotedText(text, ch, i, endIndex);\n    } else if (\n        startIndex ===\n            i - 4 &&  // We have seen only 4 characters so far \"URL(\" (Ignore \"foo_URL()\")\n        ch3 === CharCode.U &&\n        ch2 === CharCode.R && ch1 === CharCode.L && ch === CharCode.OPEN_PAREN) {\n      lastChIndex = i = consumeQuotedText(text, CharCode.CLOSE_PAREN, i, endIndex);\n    } else if (ch > CharCode.SPACE) {\n      // if we have a non-whitespace character then capture its location\n      lastChIndex = i;\n    }\n    ch3 = ch2;\n    ch2 = ch1;\n    ch1 = ch & CharCode.UPPER_CASE;\n  }\n  return lastChIndex;\n}\n\n/**\n * Consumes all of the quoted characters.\n *\n * @param text Text to scan\n * @param quoteCharCode CharCode of either `\"` or `'` quote or `)` for `url(...)`.\n * @param startIndex Starting index of character where the scan should start.\n * @param endIndex Ending index of character where the scan should end.\n * @returns Index after quoted characters.\n */\nexport function consumeQuotedText(\n    text: string, quoteCharCode: number, startIndex: number, endIndex: number): number {\n  let ch1 = -1;  // 1st previous character\n  let index = startIndex;\n  while (index < endIndex) {\n    const ch = text.charCodeAt(index++);\n    if (ch == quoteCharCode && ch1 !== CharCode.BACK_SLASH) {\n      return index;\n    }\n    if (ch == CharCode.BACK_SLASH && ch1 === CharCode.BACK_SLASH) {\n      // two back slashes cancel each other out. For example `\"\\\\\"` should properly end the\n      // quotation. (It should not assume that the last `\"` is escaped.)\n      ch1 = 0;\n    } else {\n      ch1 = ch;\n    }\n  }\n  throw ngDevMode ? malformedStyleError(text, String.fromCharCode(quoteCharCode), endIndex) :\n                    new Error();\n}\n\nfunction malformedStyleError(text: string, expecting: string, index: number): never {\n  ngDevMode && assertEqual(typeof text === 'string', true, 'String expected here');\n  throw throwError(\n      `Malformed style at location ${index} in string '` + text.substring(0, index) + '[>>' +\n      text.substring(index, index + 1) + '<<]' + text.substr(index + 1) +\n      `'. Expecting '${expecting}'.`);\n}\n"]}

package/esm2015/src/render3/tokens.js

@@ -15,5 +15,5 @@
  * A special value which designates that a value has not changed.
  * @type {?}
  */
-export const NO_CHANGE = (/** @type {?} */ ({}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvcmVuZGVyMy90b2tlbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFjQSxNQUFNLE9BQU8sU0FBUyxHQUFHLG1CQUFBLEVBQUUsRUFBYSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IGludGVyZmFjZSBOT19DSEFOR0Uge1xuICAvLyBUaGlzIGlzIGEgYnJhbmQgdGhhdCBlbnN1cmVzIHRoYXQgdGhpcyB0eXBlIGNhbiBuZXZlciBtYXRjaCBhbnl0aGluZyBlbHNlXG4gIGJyYW5kOiAnTk9fQ0hBTkdFJztcbn1cblxuLyoqIEEgc3BlY2lhbCB2YWx1ZSB3aGljaCBkZXNpZ25hdGVzIHRoYXQgYSB2YWx1ZSBoYXMgbm90IGNoYW5nZWQuICovXG5leHBvcnQgY29uc3QgTk9fQ0hBTkdFID0ge30gYXMgTk9fQ0hBTkdFO1xuIl19
+export const NO_CHANGE = (typeof ngDevMode === 'undefined' || ngDevMode) ? { __brand__: 'NO_CHANGE' } : ((/** @type {?} */ ({})));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvcmVuZGVyMy90b2tlbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFjQSxNQUFNLE9BQU8sU0FBUyxHQUNsQixDQUFDLE9BQU8sU0FBUyxLQUFLLFdBQVcsSUFBSSxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBQyxTQUFTLEVBQUUsV0FBVyxFQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsbUJBQUEsRUFBRSxFQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCBpbnRlcmZhY2UgTk9fQ0hBTkdFIHtcbiAgLy8gVGhpcyBpcyBhIGJyYW5kIHRoYXQgZW5zdXJlcyB0aGF0IHRoaXMgdHlwZSBjYW4gbmV2ZXIgbWF0Y2ggYW55dGhpbmcgZWxzZVxuICBfX2JyYW5kX186ICdOT19DSEFOR0UnO1xufVxuXG4vKiogQSBzcGVjaWFsIHZhbHVlIHdoaWNoIGRlc2lnbmF0ZXMgdGhhdCBhIHZhbHVlIGhhcyBub3QgY2hhbmdlZC4gKi9cbmV4cG9ydCBjb25zdCBOT19DSEFOR0U6IE5PX0NIQU5HRSA9XG4gICAgKHR5cGVvZiBuZ0Rldk1vZGUgPT09ICd1bmRlZmluZWQnIHx8IG5nRGV2TW9kZSkgPyB7X19icmFuZF9fOiAnTk9fQ0hBTkdFJ30gOiAoe30gYXMgTk9fQ0hBTkdFKTtcbiJdfQ==

package/esm2015/src/render3/util/attrs_utils.js

@@ -105,6 +105,129 @@ export function isAnimationProp(name) {
     // Perf note: accessing charCodeAt to check for the first character of a string is faster as
     // compared to accessing a character at index 0 (ex. name[0]). The main reason for this is that
     // charCodeAt doesn't allocate memory to return a substring.
-    return name.charCodeAt(0) === 64; // @
+    return name.charCodeAt(0) === 64 /* AT_SIGN */;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attrs_utils.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/util/attrs_utils.ts"],"names":[],"mappings":";;;;;AASA,OAAO,EAA2C,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BtG,MAAM,UAAU,eAAe,CAAC,QAAmB,EAAE,MAAgB,EAAE,KAAkB;;UACjF,MAAM,GAAG,oBAAoB,CAAC,QAAQ,CAAC;;QAEzC,CAAC,GAAG,CAAC;IACT,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE;;cACjB,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC;QACtB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC7B,wEAAwE;YACxE,+CAA+C;YAC/C,IAAI,KAAK,yBAAiC,EAAE;gBAC1C,MAAM;aACP;YAED,mDAAmD;YACnD,mCAAmC;YACnC,CAAC,EAAE,CAAC;;kBAEE,YAAY,GAAG,mBAAA,KAAK,CAAC,CAAC,EAAE,CAAC,EAAU;;kBACnC,QAAQ,GAAG,mBAAA,KAAK,CAAC,CAAC,EAAE,CAAC,EAAU;;kBAC/B,OAAO,GAAG,mBAAA,KAAK,CAAC,CAAC,EAAE,CAAC,EAAU;YACpC,SAAS,IAAI,SAAS,CAAC,oBAAoB,EAAE,CAAC;YAC9C,MAAM,CAAC,CAAC;gBACJ,CAAC,mBAAA,QAAQ,EAAuB,CAAC,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;gBACzF,MAAM,CAAC,cAAc,CAAC,YAAY,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;SAC5D;aAAM;;;kBAEC,QAAQ,GAAG,mBAAA,KAAK,EAAU;;kBAC1B,OAAO,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;YAC1B,sBAAsB;YACtB,SAAS,IAAI,SAAS,CAAC,oBAAoB,EAAE,CAAC;YAC9C,IAAI,eAAe,CAAC,QAAQ,CAAC,EAAE;gBAC7B,IAAI,MAAM,EAAE;oBACV,CAAC,mBAAA,QAAQ,EAAuB,CAAC,CAAC,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;iBAC1E;aACF;iBAAM;gBACL,MAAM,CAAC,CAAC;oBACJ,CAAC,mBAAA,QAAQ,EAAuB,CAAC,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,mBAAA,OAAO,EAAU,CAAC,CAAC,CAAC;oBACrF,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,mBAAA,OAAO,EAAU,CAAC,CAAC;aACtD;YACD,CAAC,EAAE,CAAC;SACL;KACF;IAED,8EAA8E;IAC9E,+EAA+E;IAC/E,iFAAiF;IACjF,iBAAiB;IACjB,OAAO,CAAC,CAAC;AACX,CAAC;;;;;;;;AASD,MAAM,UAAU,yBAAyB,CAAC,MAA8C;IACtF,OAAO,MAAM,qBAA6B,IAAI,MAAM,qBAA6B;QAC7E,MAAM,iBAAyB,CAAC;AACtC,CAAC;;;;;AAED,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,4FAA4F;IAC5F,+FAA+F;IAC/F,4DAA4D;IAC5D,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAE,IAAI;AACzC,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {AttributeMarker, TAttributes} from '../interfaces/node';\nimport {CssSelector} from '../interfaces/projection';\nimport {ProceduralRenderer3, RElement, Renderer3, isProceduralRenderer} from '../interfaces/renderer';\n\n\n/**\n * Assigns all attribute values to the provided element via the inferred renderer.\n *\n * This function accepts two forms of attribute entries:\n *\n * default: (key, value):\n *  attrs = [key1, value1, key2, value2]\n *\n * namespaced: (NAMESPACE_MARKER, uri, name, value)\n *  attrs = [NAMESPACE_MARKER, uri, name, value, NAMESPACE_MARKER, uri, name, value]\n *\n * The `attrs` array can contain a mix of both the default and namespaced entries.\n * The \"default\" values are set without a marker, but if the function comes across\n * a marker value then it will attempt to set a namespaced value. If the marker is\n * not of a namespaced value then the function will quit and return the index value\n * where it stopped during the iteration of the attrs array.\n *\n * See [AttributeMarker] to understand what the namespace marker value is.\n *\n * Note that this instruction does not support assigning style and class values to\n * an element. See `elementStart` and `elementHostAttrs` to learn how styling values\n * are applied to an element.\n * @param renderer The renderer to be used\n * @param native The element that the attributes will be assigned to\n * @param attrs The attribute array of values that will be assigned to the element\n * @returns the index value that was last accessed in the attributes array\n */\nexport function setUpAttributes(renderer: Renderer3, native: RElement, attrs: TAttributes): number {\n  const isProc = isProceduralRenderer(renderer);\n\n  let i = 0;\n  while (i < attrs.length) {\n    const value = attrs[i];\n    if (typeof value === 'number') {\n      // only namespaces are supported. Other value types (such as style/class\n      // entries) are not supported in this function.\n      if (value !== AttributeMarker.NamespaceURI) {\n        break;\n      }\n\n      // we just landed on the marker value ... therefore\n      // we should skip to the next entry\n      i++;\n\n      const namespaceURI = attrs[i++] as string;\n      const attrName = attrs[i++] as string;\n      const attrVal = attrs[i++] as string;\n      ngDevMode && ngDevMode.rendererSetAttribute++;\n      isProc ?\n          (renderer as ProceduralRenderer3).setAttribute(native, attrName, attrVal, namespaceURI) :\n          native.setAttributeNS(namespaceURI, attrName, attrVal);\n    } else {\n      // attrName is string;\n      const attrName = value as string;\n      const attrVal = attrs[++i];\n      // Standard attributes\n      ngDevMode && ngDevMode.rendererSetAttribute++;\n      if (isAnimationProp(attrName)) {\n        if (isProc) {\n          (renderer as ProceduralRenderer3).setProperty(native, attrName, attrVal);\n        }\n      } else {\n        isProc ?\n            (renderer as ProceduralRenderer3).setAttribute(native, attrName, attrVal as string) :\n            native.setAttribute(attrName, attrVal as string);\n      }\n      i++;\n    }\n  }\n\n  // another piece of code may iterate over the same attributes array. Therefore\n  // it may be helpful to return the exact spot where the attributes array exited\n  // whether by running into an unsupported marker or if all the static values were\n  // iterated over.\n  return i;\n}\n\n/**\n * Test whether the given value is a marker that indicates that the following\n * attribute values in a `TAttributes` array are only the names of attributes,\n * and not name-value pairs.\n * @param marker The attribute marker to test.\n * @returns true if the marker is a \"name-only\" marker (e.g. `Bindings`, `Template` or `I18n`).\n */\nexport function isNameOnlyAttributeMarker(marker: string | AttributeMarker | CssSelector) {\n  return marker === AttributeMarker.Bindings || marker === AttributeMarker.Template ||\n      marker === AttributeMarker.I18n;\n}\n\nexport function isAnimationProp(name: string): boolean {\n  // Perf note: accessing charCodeAt to check for the first character of a string is faster as\n  // compared to accessing a character at index 0 (ex. name[0]). The main reason for this is that\n  // charCodeAt doesn't allocate memory to return a substring.\n  return name.charCodeAt(0) === 64;  // @\n}\n"]}
+/**
+ * Merges `src` `TAttributes` into `dst` `TAttributes` removing any duplicates in the process.
+ *
+ * This merge function keeps the order of attrs same.
+ *
+ * @param {?} dst Location of where the merged `TAttributes` should end up.
+ * @param {?} src `TAttributes` which should be appended to `dst`
+ * @return {?}
+ */
+export function mergeHostAttrs(dst, src) {
+    if (src === null || src.length === 0) {
+        // do nothing
+    }
+    else if (dst === null || dst.length === 0) {
+        // We have source, but dst is empty, just make a copy.
+        dst = src.slice();
+    }
+    else {
+        /** @type {?} */
+        let srcMarker = -1 /* ImplicitAttributes */;
+        for (let i = 0; i < src.length; i++) {
+            /** @type {?} */
+            const item = src[i];
+            if (typeof item === 'number') {
+                srcMarker = item;
+            }
+            else {
+                if (srcMarker === 0 /* NamespaceURI */) {
+                    // Case where we need to consume `key1`, `key2`, `value` items.
+                }
+                else if (srcMarker === -1 /* ImplicitAttributes */ ||
+                    srcMarker === 2 /* Styles */) {
+                    // Case where we have to consume `key1` and `value` only.
+                    mergeHostAttribute(dst, srcMarker, (/** @type {?} */ (item)), null, (/** @type {?} */ (src[++i])));
+                }
+                else {
+                    // Case where we have to consume `key1` only.
+                    mergeHostAttribute(dst, srcMarker, (/** @type {?} */ (item)), null, null);
+                }
+            }
+        }
+    }
+    return dst;
+}
+/**
+ * Append `key`/`value` to existing `TAttributes` taking region marker and duplicates into account.
+ *
+ * @param {?} dst `TAttributes` to append to.
+ * @param {?} marker Region where the `key`/`value` should be added.
+ * @param {?} key1 Key to add to `TAttributes`
+ * @param {?} key2 Key to add to `TAttributes` (in case of `AttributeMarker.NamespaceURI`)
+ * @param {?} value Value to add or to overwrite to `TAttributes` Only used if `marker` is not Class.
+ * @return {?}
+ */
+export function mergeHostAttribute(dst, marker, key1, key2, value) {
+    /** @type {?} */
+    let i = 0;
+    // Assume that new markers will be inserted at the end.
+    /** @type {?} */
+    let markerInsertPosition = dst.length;
+    // scan until correct type.
+    if (marker === -1 /* ImplicitAttributes */) {
+        markerInsertPosition = -1;
+    }
+    else {
+        while (i < dst.length) {
+            /** @type {?} */
+            const dstValue = dst[i++];
+            if (typeof dstValue === 'number') {
+                if (dstValue === marker) {
+                    markerInsertPosition = -1;
+                    break;
+                }
+                else if (dstValue > marker) {
+                    // We need to save this as we want the markers to be inserted in specific order.
+                    markerInsertPosition = i - 1;
+                    break;
+                }
+            }
+        }
+    }
+    // search until you find place of insertion
+    while (i < dst.length) {
+        /** @type {?} */
+        const item = dst[i];
+        if (typeof item === 'number') {
+            // since `i` started as the index after the marker, we did not find it if we are at the next
+            // marker
+            break;
+        }
+        else if (item === key1) {
+            // We already have same token
+            if (key2 === null) {
+                if (value !== null) {
+                    dst[i + 1] = value;
+                }
+                return;
+            }
+            else if (key2 === dst[i + 1]) {
+                dst[i + 2] = (/** @type {?} */ (value));
+                return;
+            }
+        }
+        // Increment counter.
+        i++;
+        if (key2 !== null)
+            i++;
+        if (value !== null)
+            i++;
+    }
+    // insert at location.
+    if (markerInsertPosition !== -1) {
+        dst.splice(markerInsertPosition, 0, marker);
+        i = markerInsertPosition + 1;
+    }
+    dst.splice(i++, 0, key1);
+    if (key2 !== null) {
+        dst.splice(i++, 0, key2);
+    }
+    if (value !== null) {
+        dst.splice(i++, 0, value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attrs_utils.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/util/attrs_utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {CharCode} from '../../util/char_code';\nimport {AttributeMarker, TAttributes} from '../interfaces/node';\nimport {CssSelector} from '../interfaces/projection';\nimport {ProceduralRenderer3, RElement, Renderer3, isProceduralRenderer} from '../interfaces/renderer';\n\n\n\n/**\n * Assigns all attribute values to the provided element via the inferred renderer.\n *\n * This function accepts two forms of attribute entries:\n *\n * default: (key, value):\n *  attrs = [key1, value1, key2, value2]\n *\n * namespaced: (NAMESPACE_MARKER, uri, name, value)\n *  attrs = [NAMESPACE_MARKER, uri, name, value, NAMESPACE_MARKER, uri, name, value]\n *\n * The `attrs` array can contain a mix of both the default and namespaced entries.\n * The \"default\" values are set without a marker, but if the function comes across\n * a marker value then it will attempt to set a namespaced value. If the marker is\n * not of a namespaced value then the function will quit and return the index value\n * where it stopped during the iteration of the attrs array.\n *\n * See [AttributeMarker] to understand what the namespace marker value is.\n *\n * Note that this instruction does not support assigning style and class values to\n * an element. See `elementStart` and `elementHostAttrs` to learn how styling values\n * are applied to an element.\n * @param renderer The renderer to be used\n * @param native The element that the attributes will be assigned to\n * @param attrs The attribute array of values that will be assigned to the element\n * @returns the index value that was last accessed in the attributes array\n */\nexport function setUpAttributes(renderer: Renderer3, native: RElement, attrs: TAttributes): number {\n  const isProc = isProceduralRenderer(renderer);\n\n  let i = 0;\n  while (i < attrs.length) {\n    const value = attrs[i];\n    if (typeof value === 'number') {\n      // only namespaces are supported. Other value types (such as style/class\n      // entries) are not supported in this function.\n      if (value !== AttributeMarker.NamespaceURI) {\n        break;\n      }\n\n      // we just landed on the marker value ... therefore\n      // we should skip to the next entry\n      i++;\n\n      const namespaceURI = attrs[i++] as string;\n      const attrName = attrs[i++] as string;\n      const attrVal = attrs[i++] as string;\n      ngDevMode && ngDevMode.rendererSetAttribute++;\n      isProc ?\n          (renderer as ProceduralRenderer3).setAttribute(native, attrName, attrVal, namespaceURI) :\n          native.setAttributeNS(namespaceURI, attrName, attrVal);\n    } else {\n      // attrName is string;\n      const attrName = value as string;\n      const attrVal = attrs[++i];\n      // Standard attributes\n      ngDevMode && ngDevMode.rendererSetAttribute++;\n      if (isAnimationProp(attrName)) {\n        if (isProc) {\n          (renderer as ProceduralRenderer3).setProperty(native, attrName, attrVal);\n        }\n      } else {\n        isProc ?\n            (renderer as ProceduralRenderer3).setAttribute(native, attrName, attrVal as string) :\n            native.setAttribute(attrName, attrVal as string);\n      }\n      i++;\n    }\n  }\n\n  // another piece of code may iterate over the same attributes array. Therefore\n  // it may be helpful to return the exact spot where the attributes array exited\n  // whether by running into an unsupported marker or if all the static values were\n  // iterated over.\n  return i;\n}\n\n/**\n * Test whether the given value is a marker that indicates that the following\n * attribute values in a `TAttributes` array are only the names of attributes,\n * and not name-value pairs.\n * @param marker The attribute marker to test.\n * @returns true if the marker is a \"name-only\" marker (e.g. `Bindings`, `Template` or `I18n`).\n */\nexport function isNameOnlyAttributeMarker(marker: string | AttributeMarker | CssSelector) {\n  return marker === AttributeMarker.Bindings || marker === AttributeMarker.Template ||\n      marker === AttributeMarker.I18n;\n}\n\nexport function isAnimationProp(name: string): boolean {\n  // Perf note: accessing charCodeAt to check for the first character of a string is faster as\n  // compared to accessing a character at index 0 (ex. name[0]). The main reason for this is that\n  // charCodeAt doesn't allocate memory to return a substring.\n  return name.charCodeAt(0) === CharCode.AT_SIGN;\n}\n\n/**\n * Merges `src` `TAttributes` into `dst` `TAttributes` removing any duplicates in the process.\n *\n * This merge function keeps the order of attrs same.\n *\n * @param dst Location of where the merged `TAttributes` should end up.\n * @param src `TAttributes` which should be appended to `dst`\n */\nexport function mergeHostAttrs(dst: TAttributes | null, src: TAttributes | null): TAttributes|null {\n  if (src === null || src.length === 0) {\n    // do nothing\n  } else if (dst === null || dst.length === 0) {\n    // We have source, but dst is empty, just make a copy.\n    dst = src.slice();\n  } else {\n    let srcMarker: AttributeMarker = AttributeMarker.ImplicitAttributes;\n    for (let i = 0; i < src.length; i++) {\n      const item = src[i];\n      if (typeof item === 'number') {\n        srcMarker = item;\n      } else {\n        if (srcMarker === AttributeMarker.NamespaceURI) {\n          // Case where we need to consume `key1`, `key2`, `value` items.\n        } else if (\n            srcMarker === AttributeMarker.ImplicitAttributes ||\n            srcMarker === AttributeMarker.Styles) {\n          // Case where we have to consume `key1` and `value` only.\n          mergeHostAttribute(dst, srcMarker, item as string, null, src[++i] as string);\n        } else {\n          // Case where we have to consume `key1` only.\n          mergeHostAttribute(dst, srcMarker, item as string, null, null);\n        }\n      }\n    }\n  }\n  return dst;\n}\n\n/**\n * Append `key`/`value` to existing `TAttributes` taking region marker and duplicates into account.\n *\n * @param dst `TAttributes` to append to.\n * @param marker Region where the `key`/`value` should be added.\n * @param key1 Key to add to `TAttributes`\n * @param key2 Key to add to `TAttributes` (in case of `AttributeMarker.NamespaceURI`)\n * @param value Value to add or to overwrite to `TAttributes` Only used if `marker` is not Class.\n */\nexport function mergeHostAttribute(\n    dst: TAttributes, marker: AttributeMarker, key1: string, key2: string | null,\n    value: string | null): void {\n  let i = 0;\n  // Assume that new markers will be inserted at the end.\n  let markerInsertPosition = dst.length;\n  // scan until correct type.\n  if (marker === AttributeMarker.ImplicitAttributes) {\n    markerInsertPosition = -1;\n  } else {\n    while (i < dst.length) {\n      const dstValue = dst[i++];\n      if (typeof dstValue === 'number') {\n        if (dstValue === marker) {\n          markerInsertPosition = -1;\n          break;\n        } else if (dstValue > marker) {\n          // We need to save this as we want the markers to be inserted in specific order.\n          markerInsertPosition = i - 1;\n          break;\n        }\n      }\n    }\n  }\n\n  // search until you find place of insertion\n  while (i < dst.length) {\n    const item = dst[i];\n    if (typeof item === 'number') {\n      // since `i` started as the index after the marker, we did not find it if we are at the next\n      // marker\n      break;\n    } else if (item === key1) {\n      // We already have same token\n      if (key2 === null) {\n        if (value !== null) {\n          dst[i + 1] = value;\n        }\n        return;\n      } else if (key2 === dst[i + 1]) {\n        dst[i + 2] = value !;\n        return;\n      }\n    }\n    // Increment counter.\n    i++;\n    if (key2 !== null) i++;\n    if (value !== null) i++;\n  }\n\n  // insert at location.\n  if (markerInsertPosition !== -1) {\n    dst.splice(markerInsertPosition, 0, marker);\n    i = markerInsertPosition + 1;\n  }\n  dst.splice(i++, 0, key1);\n  if (key2 !== null) {\n    dst.splice(i++, 0, key2);\n  }\n  if (value !== null) {\n    dst.splice(i++, 0, value);\n  }\n}"]}

package/esm2015/src/render3/util/change_detection_utils.js

@@ -0,0 +1,33 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: packages/core/src/render3/util/change_detection_utils.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+import { detectChanges, markDirty } from '../instructions/all';
+import { getRootComponents } from './discovery_utils';
+/**
+ * Marks a component for check (in case of OnPush components) and synchronously
+ * performs change detection on the application this component belongs to.
+ *
+ * \@publicApi
+ * \@globalApi ng
+ * @param {?} component Component to {\@link ChangeDetectorRef#markForCheck mark for check}.
+ *
+ * @return {?}
+ */
+export function applyChanges(component) {
+    markDirty(component);
+    getRootComponents(component).forEach((/**
+     * @param {?} rootComponent
+     * @return {?}
+     */
+    rootComponent => detectChanges(rootComponent)));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhbmdlX2RldGVjdGlvbl91dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL3JlbmRlcjMvdXRpbC9jaGFuZ2VfZGV0ZWN0aW9uX3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztBQVFBLE9BQU8sRUFBQyxhQUFhLEVBQUUsU0FBUyxFQUFDLE1BQU0scUJBQXFCLENBQUM7QUFDN0QsT0FBTyxFQUFDLGlCQUFpQixFQUFDLE1BQU0sbUJBQW1CLENBQUM7Ozs7Ozs7Ozs7O0FBV3BELE1BQU0sVUFBVSxZQUFZLENBQUMsU0FBYTtJQUN4QyxTQUFTLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDckIsaUJBQWlCLENBQUMsU0FBUyxDQUFDLENBQUMsT0FBTzs7OztJQUFDLGFBQWEsQ0FBQyxFQUFFLENBQUMsYUFBYSxDQUFDLGFBQWEsQ0FBQyxFQUFDLENBQUM7QUFDdEYsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtkZXRlY3RDaGFuZ2VzLCBtYXJrRGlydHl9IGZyb20gJy4uL2luc3RydWN0aW9ucy9hbGwnO1xuaW1wb3J0IHtnZXRSb290Q29tcG9uZW50c30gZnJvbSAnLi9kaXNjb3ZlcnlfdXRpbHMnO1xuXG4vKipcbiAqIE1hcmtzIGEgY29tcG9uZW50IGZvciBjaGVjayAoaW4gY2FzZSBvZiBPblB1c2ggY29tcG9uZW50cykgYW5kIHN5bmNocm9ub3VzbHlcbiAqIHBlcmZvcm1zIGNoYW5nZSBkZXRlY3Rpb24gb24gdGhlIGFwcGxpY2F0aW9uIHRoaXMgY29tcG9uZW50IGJlbG9uZ3MgdG8uXG4gKlxuICogQHBhcmFtIGNvbXBvbmVudCBDb21wb25lbnQgdG8ge0BsaW5rIENoYW5nZURldGVjdG9yUmVmI21hcmtGb3JDaGVjayBtYXJrIGZvciBjaGVja30uXG4gKlxuICogQHB1YmxpY0FwaVxuICogQGdsb2JhbEFwaSBuZ1xuICovXG5leHBvcnQgZnVuY3Rpb24gYXBwbHlDaGFuZ2VzKGNvbXBvbmVudDoge30pOiB2b2lkIHtcbiAgbWFya0RpcnR5KGNvbXBvbmVudCk7XG4gIGdldFJvb3RDb21wb25lbnRzKGNvbXBvbmVudCkuZm9yRWFjaChyb290Q29tcG9uZW50ID0+IGRldGVjdENoYW5nZXMocm9vdENvbXBvbmVudCkpO1xufVxuIl19