@angular/core 8.0.3 → 8.1.0-beta.0

package/esm2015/src/render3/styling_next/styling_debug.js

@@ -0,0 +1,291 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { attachDebugObject } from '../util/debug_utils';
+import { applyStyling } from './bindings';
+import { activeStylingMapFeature } from './map_based_bindings';
+import { getCurrentOrLViewSanitizer, getDefaultValue, getGuardMask, getProp, getValuesCount, isContextLocked, isSanitizationRequired } from './util';
+/**
+ * A debug/testing-oriented summary of a styling entry.
+ *
+ * A value such as this is generated as an artifact of the `DebugStyling`
+ * summary.
+ * @record
+ */
+export function LStylingSummary() { }
+if (false) {
+    /**
+     * The style/class property that the summary is attached to
+     * @type {?}
+     */
+    LStylingSummary.prototype.prop;
+    /**
+     * The last applied value for the style/class property
+     * @type {?}
+     */
+    LStylingSummary.prototype.value;
+    /**
+     * The binding index of the last applied style/class property
+     * @type {?}
+     */
+    LStylingSummary.prototype.bindingIndex;
+}
+/**
+ * A debug/testing-oriented summary of all styling entries for a `DebugNode` instance.
+ * @record
+ */
+export function DebugStyling() { }
+if (false) {
+    /**
+     * The associated TStylingContext instance
+     * @type {?}
+     */
+    DebugStyling.prototype.context;
+    /**
+     * A summarization of each style/class property
+     * present in the context.
+     * @type {?}
+     */
+    DebugStyling.prototype.summary;
+    /**
+     * A key/value map of all styling properties and their
+     * runtime values.
+     * @type {?}
+     */
+    DebugStyling.prototype.values;
+    /**
+     * Overrides the sanitizer used to process styles.
+     * @param {?} sanitizer
+     * @return {?}
+     */
+    DebugStyling.prototype.overrideSanitizer = function (sanitizer) { };
+}
+/**
+ * A debug/testing-oriented summary of all styling entries within a `TStylingContext`.
+ * @record
+ */
+export function TStylingTupleSummary() { }
+if (false) {
+    /**
+     * The property (style or class property) that this tuple represents
+     * @type {?}
+     */
+    TStylingTupleSummary.prototype.prop;
+    /**
+     * The total amount of styling entries apart of this tuple
+     * @type {?}
+     */
+    TStylingTupleSummary.prototype.valuesCount;
+    /**
+     * The bit guard mask that is used to compare and protect against
+     * styling changes when and styling bindings update
+     * @type {?}
+     */
+    TStylingTupleSummary.prototype.guardMask;
+    /**
+     * Whether or not the entry requires sanitization
+     * @type {?}
+     */
+    TStylingTupleSummary.prototype.sanitizationRequired;
+    /**
+     * The default value that will be applied if any bindings are falsy.
+     * @type {?}
+     */
+    TStylingTupleSummary.prototype.defaultValue;
+    /**
+     * All bindingIndex sources that have been registered for this style.
+     * @type {?}
+     */
+    TStylingTupleSummary.prototype.sources;
+}
+/**
+ * Instantiates and attaches an instance of `TStylingContextDebug` to the provided context.
+ * @param {?} context
+ * @return {?}
+ */
+export function attachStylingDebugObject(context) {
+    /** @type {?} */
+    const debug = new TStylingContextDebug(context);
+    attachDebugObject(context, debug);
+    return debug;
+}
+/**
+ * A human-readable debug summary of the styling data present within `TStylingContext`.
+ *
+ * This class is designed to be used within testing code or when an
+ * application has `ngDevMode` activated.
+ */
+class TStylingContextDebug {
+    /**
+     * @param {?} context
+     */
+    constructor(context) {
+        this.context = context;
+    }
+    /**
+     * @return {?}
+     */
+    get isLocked() { return isContextLocked(this.context); }
+    /**
+     * Returns a detailed summary of each styling entry in the context.
+     *
+     * See `TStylingTupleSummary`.
+     * @return {?}
+     */
+    get entries() {
+        /** @type {?} */
+        const context = this.context;
+        /** @type {?} */
+        const entries = {};
+        /** @type {?} */
+        const start = 2 /* MapBindingsPosition */;
+        /** @type {?} */
+        let i = start;
+        while (i < context.length) {
+            /** @type {?} */
+            const valuesCount = getValuesCount(context, i);
+            // the context may contain placeholder values which are populated ahead of time,
+            // but contain no actual binding values. In this situation there is no point in
+            // classifying this as an "entry" since no real data is stored here yet.
+            if (valuesCount) {
+                /** @type {?} */
+                const prop = getProp(context, i);
+                /** @type {?} */
+                const guardMask = getGuardMask(context, i);
+                /** @type {?} */
+                const defaultValue = getDefaultValue(context, i);
+                /** @type {?} */
+                const sanitizationRequired = isSanitizationRequired(context, i);
+                /** @type {?} */
+                const bindingsStartPosition = i + 3 /* BindingsStartOffset */;
+                /** @type {?} */
+                const sources = [];
+                for (let j = 0; j < valuesCount; j++) {
+                    sources.push((/** @type {?} */ (context[bindingsStartPosition + j])));
+                }
+                entries[prop] = { prop, guardMask, sanitizationRequired, valuesCount, defaultValue, sources };
+            }
+            i += 3 /* BindingsStartOffset */ + valuesCount;
+        }
+        return entries;
+    }
+}
+if (false) {
+    /** @type {?} */
+    TStylingContextDebug.prototype.context;
+}
+/**
+ * A human-readable debug summary of the styling data present for a `DebugNode` instance.
+ *
+ * This class is designed to be used within testing code or when an
+ * application has `ngDevMode` activated.
+ */
+export class NodeStylingDebug {
+    /**
+     * @param {?} context
+     * @param {?} _data
+     * @param {?=} _isClassBased
+     */
+    constructor(context, _data, _isClassBased) {
+        this.context = context;
+        this._data = _data;
+        this._isClassBased = _isClassBased;
+        this._sanitizer = null;
+    }
+    /**
+     * Overrides the sanitizer used to process styles.
+     * @param {?} sanitizer
+     * @return {?}
+     */
+    overrideSanitizer(sanitizer) { this._sanitizer = sanitizer; }
+    /**
+     * Returns a detailed summary of each styling entry in the context and
+     * what their runtime representation is.
+     *
+     * See `LStylingSummary`.
+     * @return {?}
+     */
+    get summary() {
+        /** @type {?} */
+        const entries = {};
+        this._mapValues((/**
+         * @param {?} prop
+         * @param {?} value
+         * @param {?} bindingIndex
+         * @return {?}
+         */
+        (prop, value, bindingIndex) => {
+            entries[prop] = { prop, value, bindingIndex };
+        }));
+        return entries;
+    }
+    /**
+     * Returns a key/value map of all the styles/classes that were last applied to the element.
+     * @return {?}
+     */
+    get values() {
+        /** @type {?} */
+        const entries = {};
+        this._mapValues((/**
+         * @param {?} prop
+         * @param {?} value
+         * @return {?}
+         */
+        (prop, value) => { entries[prop] = value; }));
+        return entries;
+    }
+    /**
+     * @private
+     * @param {?} fn
+     * @return {?}
+     */
+    _mapValues(fn) {
+        // there is no need to store/track an element instance. The
+        // element is only used when the styling algorithm attempts to
+        // style the value (and we mock out the stylingApplyFn anyway).
+        /** @type {?} */
+        const mockElement = (/** @type {?} */ ({}));
+        /** @type {?} */
+        const hasMaps = getValuesCount(this.context, 2 /* MapBindingsPosition */) > 0;
+        if (hasMaps) {
+            activeStylingMapFeature();
+        }
+        /** @type {?} */
+        const mapFn = (/**
+         * @param {?} renderer
+         * @param {?} element
+         * @param {?} prop
+         * @param {?} value
+         * @param {?} bindingIndex
+         * @return {?}
+         */
+        (renderer, element, prop, value, bindingIndex) => {
+            fn(prop, value, bindingIndex || null);
+        });
+        /** @type {?} */
+        const sanitizer = this._isClassBased ? null : (this._sanitizer ||
+            getCurrentOrLViewSanitizer((/** @type {?} */ (this._data))));
+        applyStyling(this.context, null, mockElement, this._data, true, mapFn, sanitizer);
+    }
+}
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    NodeStylingDebug.prototype._sanitizer;
+    /** @type {?} */
+    NodeStylingDebug.prototype.context;
+    /**
+     * @type {?}
+     * @private
+     */
+    NodeStylingDebug.prototype._data;
+    /**
+     * @type {?}
+     * @private
+     */
+    NodeStylingDebug.prototype._isClassBased;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"styling_debug.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/styling_next/styling_debug.ts"],"names":[],"mappings":";;;;AAWA,OAAO,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAC,YAAY,EAAC,MAAM,YAAY,CAAC;AAExC,OAAO,EAAC,uBAAuB,EAAC,MAAM,sBAAsB,CAAC;AAE7D,OAAO,EAAC,0BAA0B,EAAE,eAAe,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAc,sBAAsB,EAAC,MAAM,QAAQ,CAAC;;;;;;;;AAqB/J,qCASC;;;;;;IAPC,+BAAa;;;;;IAGb,gCAA2B;;;;;IAG3B,uCAA0B;;;;;;AAM5B,kCAoBC;;;;;;IAlBC,+BAAyB;;;;;;IAMzB,+BAA0C;;;;;;IAM1C,8BAA0D;;;;;;IAK1D,oEAAyD;;;;;;AAM3D,0CA2BC;;;;;;IAzBC,oCAAa;;;;;IAGb,2CAAoB;;;;;;IAMpB,yCAAkB;;;;;IAKlB,oDAA8B;;;;;IAK9B,4CAAkC;;;;;IAKlC,uCAAgC;;;;;;;AAMlC,MAAM,UAAU,wBAAwB,CAAC,OAAwB;;UACzD,KAAK,GAAG,IAAI,oBAAoB,CAAC,OAAO,CAAC;IAC/C,iBAAiB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAClC,OAAO,KAAK,CAAC;AACf,CAAC;;;;;;;AAQD,MAAM,oBAAoB;;;;IACxB,YAA4B,OAAwB;QAAxB,YAAO,GAAP,OAAO,CAAiB;IAAG,CAAC;;;;IAExD,IAAI,QAAQ,KAAK,OAAO,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;;;;;;;IAOxD,IAAI,OAAO;;cACH,OAAO,GAAG,IAAI,CAAC,OAAO;;cACtB,OAAO,GAA2C,EAAE;;cACpD,KAAK,8BAA2C;;YAClD,CAAC,GAAG,KAAK;QACb,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE;;kBACnB,WAAW,GAAG,cAAc,CAAC,OAAO,EAAE,CAAC,CAAC;YAC9C,gFAAgF;YAChF,+EAA+E;YAC/E,wEAAwE;YACxE,IAAI,WAAW,EAAE;;sBACT,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;;sBAC1B,SAAS,GAAG,YAAY,CAAC,OAAO,EAAE,CAAC,CAAC;;sBACpC,YAAY,GAAG,eAAe,CAAC,OAAO,EAAE,CAAC,CAAC;;sBAC1C,oBAAoB,GAAG,sBAAsB,CAAC,OAAO,EAAE,CAAC,CAAC;;sBACzD,qBAAqB,GAAG,CAAC,8BAA2C;;sBAEpE,OAAO,GAA+B,EAAE;gBAC9C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,CAAC,EAAE,EAAE;oBACpC,OAAO,CAAC,IAAI,CAAC,mBAAA,OAAO,CAAC,qBAAqB,GAAG,CAAC,CAAC,EAA0B,CAAC,CAAC;iBAC5E;gBAED,OAAO,CAAC,IAAI,CAAC,GAAG,EAAC,IAAI,EAAE,SAAS,EAAE,oBAAoB,EAAE,WAAW,EAAE,YAAY,EAAE,OAAO,EAAC,CAAC;aAC7F;YAED,CAAC,IAAI,8BAA2C,WAAW,CAAC;SAC7D;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;CACF;;;IAtCa,uCAAwC;;;;;;;;AA8CtD,MAAM,OAAO,gBAAgB;;;;;;IAG3B,YACW,OAAwB,EAAU,KAAmB,EACpD,aAAuB;QADxB,YAAO,GAAP,OAAO,CAAiB;QAAU,UAAK,GAAL,KAAK,CAAc;QACpD,kBAAa,GAAb,aAAa,CAAU;QAJ3B,eAAU,GAAyB,IAAI,CAAC;IAIV,CAAC;;;;;;IAKvC,iBAAiB,CAAC,SAA+B,IAAI,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC,CAAC;;;;;;;;IAQnF,IAAI,OAAO;;cACH,OAAO,GAAqC,EAAE;QACpD,IAAI,CAAC,UAAU;;;;;;QAAC,CAAC,IAAY,EAAE,KAAU,EAAE,YAA2B,EAAE,EAAE;YACxE,OAAO,CAAC,IAAI,CAAC,GAAG,EAAC,IAAI,EAAE,KAAK,EAAE,YAAY,EAAC,CAAC;QAC9C,CAAC,EAAC,CAAC;QACH,OAAO,OAAO,CAAC;IACjB,CAAC;;;;;IAKD,IAAI,MAAM;;cACF,OAAO,GAAyB,EAAE;QACxC,IAAI,CAAC,UAAU;;;;;QAAC,CAAC,IAAY,EAAE,KAAU,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,EAAC,CAAC;QAC1E,OAAO,OAAO,CAAC;IACjB,CAAC;;;;;;IAEO,UAAU,CAAC,EAAgE;;;;;cAI3E,WAAW,GAAG,mBAAA,EAAE,EAAO;;cACvB,OAAO,GAAG,cAAc,CAAC,IAAI,CAAC,OAAO,8BAA2C,GAAG,CAAC;QAC1F,IAAI,OAAO,EAAE;YACX,uBAAuB,EAAE,CAAC;SAC3B;;cAEK,KAAK;;;;;;;;QACP,CAAC,QAAa,EAAE,OAAiB,EAAE,IAAY,EAAE,KAAU,EAAE,YAAoB,EAAE,EAAE;YACnF,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,YAAY,IAAI,IAAI,CAAC,CAAC;QACxC,CAAC,CAAA;;cAEC,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU;YACf,0BAA0B,CAAC,mBAAA,IAAI,CAAC,KAAK,EAAS,CAAC,CAAC;QAC/F,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;IACpF,CAAC;CACF;;;;;;IArDC,sCAAgD;;IAG5C,mCAA+B;;;;;IAAE,iCAA2B;;;;;IAC5D,yCAA+B","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 {Sanitizer} from '../../sanitization/security';\nimport {StyleSanitizeFn} from '../../sanitization/style_sanitizer';\nimport {RElement} from '../interfaces/renderer';\nimport {LView, SANITIZER} from '../interfaces/view';\nimport {attachDebugObject} from '../util/debug_utils';\n\nimport {applyStyling} from './bindings';\nimport {ApplyStylingFn, LStylingData, TStylingContext, TStylingContextIndex} from './interfaces';\nimport {activeStylingMapFeature} from './map_based_bindings';\nimport {getCurrentStyleSanitizer} from './state';\nimport {getCurrentOrLViewSanitizer, getDefaultValue, getGuardMask, getProp, getValuesCount, isContextLocked, isMapBased, isSanitizationRequired} from './util';\n\n\n\n/**\n * --------\n *\n * This file contains the core debug functionality for styling in Angular.\n *\n * To learn more about the algorithm see `TStylingContext`.\n *\n * --------\n */\n\n\n/**\n * A debug/testing-oriented summary of a styling entry.\n *\n * A value such as this is generated as an artifact of the `DebugStyling`\n * summary.\n */\nexport interface LStylingSummary {\n  /** The style/class property that the summary is attached to */\n  prop: string;\n\n  /** The last applied value for the style/class property */\n  value: string|boolean|null;\n\n  /** The binding index of the last applied style/class property */\n  bindingIndex: number|null;\n}\n\n/**\n * A debug/testing-oriented summary of all styling entries for a `DebugNode` instance.\n */\nexport interface DebugStyling {\n  /** The associated TStylingContext instance */\n  context: TStylingContext;\n\n  /**\n   * A summarization of each style/class property\n   * present in the context.\n   */\n  summary: {[key: string]: LStylingSummary};\n\n  /**\n   * A key/value map of all styling properties and their\n   * runtime values.\n   */\n  values: {[key: string]: string | number | null | boolean};\n\n  /**\n   * Overrides the sanitizer used to process styles.\n   */\n  overrideSanitizer(sanitizer: StyleSanitizeFn|null): void;\n}\n\n/**\n * A debug/testing-oriented summary of all styling entries within a `TStylingContext`.\n */\nexport interface TStylingTupleSummary {\n  /** The property (style or class property) that this tuple represents */\n  prop: string;\n\n  /** The total amount of styling entries apart of this tuple */\n  valuesCount: number;\n\n  /**\n   * The bit guard mask that is used to compare and protect against\n   * styling changes when and styling bindings update\n   */\n  guardMask: number;\n\n  /**\n   * Whether or not the entry requires sanitization\n   */\n  sanitizationRequired: boolean;\n\n  /**\n   * The default value that will be applied if any bindings are falsy.\n   */\n  defaultValue: string|boolean|null;\n\n  /**\n   * All bindingIndex sources that have been registered for this style.\n   */\n  sources: (number|null|string)[];\n}\n\n/**\n * Instantiates and attaches an instance of `TStylingContextDebug` to the provided context.\n */\nexport function attachStylingDebugObject(context: TStylingContext) {\n  const debug = new TStylingContextDebug(context);\n  attachDebugObject(context, debug);\n  return debug;\n}\n\n/**\n * A human-readable debug summary of the styling data present within `TStylingContext`.\n *\n * This class is designed to be used within testing code or when an\n * application has `ngDevMode` activated.\n */\nclass TStylingContextDebug {\n  constructor(public readonly context: TStylingContext) {}\n\n  get isLocked() { return isContextLocked(this.context); }\n\n  /**\n   * Returns a detailed summary of each styling entry in the context.\n   *\n   * See `TStylingTupleSummary`.\n   */\n  get entries(): {[prop: string]: TStylingTupleSummary} {\n    const context = this.context;\n    const entries: {[prop: string]: TStylingTupleSummary} = {};\n    const start = TStylingContextIndex.MapBindingsPosition;\n    let i = start;\n    while (i < context.length) {\n      const valuesCount = getValuesCount(context, i);\n      // the context may contain placeholder values which are populated ahead of time,\n      // but contain no actual binding values. In this situation there is no point in\n      // classifying this as an \"entry\" since no real data is stored here yet.\n      if (valuesCount) {\n        const prop = getProp(context, i);\n        const guardMask = getGuardMask(context, i);\n        const defaultValue = getDefaultValue(context, i);\n        const sanitizationRequired = isSanitizationRequired(context, i);\n        const bindingsStartPosition = i + TStylingContextIndex.BindingsStartOffset;\n\n        const sources: (number | string | null)[] = [];\n        for (let j = 0; j < valuesCount; j++) {\n          sources.push(context[bindingsStartPosition + j] as number | string | null);\n        }\n\n        entries[prop] = {prop, guardMask, sanitizationRequired, valuesCount, defaultValue, sources};\n      }\n\n      i += TStylingContextIndex.BindingsStartOffset + valuesCount;\n    }\n    return entries;\n  }\n}\n\n/**\n * A human-readable debug summary of the styling data present for a `DebugNode` instance.\n *\n * This class is designed to be used within testing code or when an\n * application has `ngDevMode` activated.\n */\nexport class NodeStylingDebug implements DebugStyling {\n  private _sanitizer: StyleSanitizeFn|null = null;\n\n  constructor(\n      public context: TStylingContext, private _data: LStylingData,\n      private _isClassBased?: boolean) {}\n\n  /**\n   * Overrides the sanitizer used to process styles.\n   */\n  overrideSanitizer(sanitizer: StyleSanitizeFn|null) { this._sanitizer = sanitizer; }\n\n  /**\n   * Returns a detailed summary of each styling entry in the context and\n   * what their runtime representation is.\n   *\n   * See `LStylingSummary`.\n   */\n  get summary(): {[key: string]: LStylingSummary} {\n    const entries: {[key: string]: LStylingSummary} = {};\n    this._mapValues((prop: string, value: any, bindingIndex: number | null) => {\n      entries[prop] = {prop, value, bindingIndex};\n    });\n    return entries;\n  }\n\n  /**\n   * Returns a key/value map of all the styles/classes that were last applied to the element.\n   */\n  get values(): {[key: string]: any} {\n    const entries: {[key: string]: any} = {};\n    this._mapValues((prop: string, value: any) => { entries[prop] = value; });\n    return entries;\n  }\n\n  private _mapValues(fn: (prop: string, value: any, bindingIndex: number|null) => any) {\n    // there is no need to store/track an element instance. The\n    // element is only used when the styling algorithm attempts to\n    // style the value (and we mock out the stylingApplyFn anyway).\n    const mockElement = {} as any;\n    const hasMaps = getValuesCount(this.context, TStylingContextIndex.MapBindingsPosition) > 0;\n    if (hasMaps) {\n      activeStylingMapFeature();\n    }\n\n    const mapFn: ApplyStylingFn =\n        (renderer: any, element: RElement, prop: string, value: any, bindingIndex: number) => {\n          fn(prop, value, bindingIndex || null);\n        };\n\n    const sanitizer = this._isClassBased ? null : (this._sanitizer ||\n                                                   getCurrentOrLViewSanitizer(this._data as LView));\n    applyStyling(this.context, null, mockElement, this._data, true, mapFn, sanitizer);\n  }\n}\n"]}

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

@@ -0,0 +1,259 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,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 { SecurityContext } from '../../sanitization/security';
+import { SANITIZER } from '../interfaces/view';
+import { getProp as getOldProp, getSinglePropIndexValue as getOldSinglePropIndexValue } from '../styling/class_and_style_bindings';
+import { getCurrentStyleSanitizer, setCurrentStyleSanitizer } from './state';
+/** @type {?} */
+const MAP_BASED_ENTRY_PROP_NAME = '--MAP--';
+/**
+ * Creates a new instance of the `TStylingContext`.
+ *
+ * This function will also pre-fill the context with data
+ * for map-based bindings.
+ * @return {?}
+ */
+export function allocTStylingContext() {
+    // because map-based bindings deal with a dynamic set of values, there
+    // is no way to know ahead of time whether or not sanitization is required.
+    // For this reason the configuration will always mark sanitization as active
+    // (this means that when map-based values are applied then sanitization will
+    // be checked against each property).
+    /** @type {?} */
+    const mapBasedConfig = 1 /* SanitizationRequired */;
+    return [0 /* Initial */, 0, mapBasedConfig, 0, MAP_BASED_ENTRY_PROP_NAME];
+}
+/**
+ * Temporary function that allows for a string-based property name to be
+ * obtained from an index-based property identifier.
+ *
+ * This function will be removed once the new styling refactor code (which
+ * lives inside of `render3/styling_next/`) replaces the existing styling
+ * implementation.
+ * @param {?} stylingContext
+ * @param {?} offset
+ * @param {?} directiveIndex
+ * @param {?} isClassBased
+ * @return {?}
+ */
+export function getBindingNameFromIndex(stylingContext, offset, directiveIndex, isClassBased) {
+    /** @type {?} */
+    const singleIndex = getOldSinglePropIndexValue(stylingContext, directiveIndex, offset, isClassBased);
+    return getOldProp(stylingContext, singleIndex);
+}
+/**
+ * @param {?} context
+ * @param {?} index
+ * @return {?}
+ */
+export function updateContextDirectiveIndex(context, index) {
+    context[1 /* MaxDirectiveIndexPosition */] = index;
+}
+/**
+ * @param {?} context
+ * @return {?}
+ */
+function getConfig(context) {
+    return context[0 /* ConfigPosition */];
+}
+/**
+ * @param {?} context
+ * @param {?} value
+ * @return {?}
+ */
+export function setConfig(context, value) {
+    context[0 /* ConfigPosition */] = value;
+}
+/**
+ * @param {?} context
+ * @param {?} index
+ * @return {?}
+ */
+export function getProp(context, index) {
+    return (/** @type {?} */ (context[index + 2 /* PropOffset */]));
+}
+/**
+ * @param {?} context
+ * @param {?} index
+ * @return {?}
+ */
+function getPropConfig(context, index) {
+    return ((/** @type {?} */ (context[index + 0 /* ConfigAndGuardOffset */]))) &
+        1 /* Mask */;
+}
+/**
+ * @param {?} context
+ * @param {?} index
+ * @return {?}
+ */
+export function isSanitizationRequired(context, index) {
+    return (getPropConfig(context, index) & 1 /* SanitizationRequired */) > 0;
+}
+/**
+ * @param {?} context
+ * @param {?} index
+ * @return {?}
+ */
+export function getGuardMask(context, index) {
+    /** @type {?} */
+    const configGuardValue = (/** @type {?} */ (context[index + 0 /* ConfigAndGuardOffset */]));
+    return configGuardValue >> 1 /* TotalBits */;
+}
+/**
+ * @param {?} context
+ * @param {?} index
+ * @param {?} maskValue
+ * @return {?}
+ */
+export function setGuardMask(context, index, maskValue) {
+    /** @type {?} */
+    const config = getPropConfig(context, index);
+    /** @type {?} */
+    const guardMask = maskValue << 1 /* TotalBits */;
+    context[index + 0 /* ConfigAndGuardOffset */] = config | guardMask;
+}
+/**
+ * @param {?} context
+ * @param {?} index
+ * @return {?}
+ */
+export function getValuesCount(context, index) {
+    return (/** @type {?} */ (context[index + 1 /* ValuesCountOffset */]));
+}
+/**
+ * @param {?} context
+ * @param {?} index
+ * @param {?} offset
+ * @return {?}
+ */
+export function getBindingValue(context, index, offset) {
+    return (/** @type {?} */ (context[index + 3 /* BindingsStartOffset */ + offset]));
+}
+/**
+ * @param {?} context
+ * @param {?} index
+ * @return {?}
+ */
+export function getDefaultValue(context, index) {
+    /** @type {?} */
+    const valuesCount = getValuesCount(context, index);
+    return (/** @type {?} */ (context[index + 3 /* BindingsStartOffset */ + valuesCount - 1]));
+}
+/**
+ * Temporary function which determines whether or not a context is
+ * allowed to be flushed based on the provided directive index.
+ * @param {?} context
+ * @param {?} index
+ * @return {?}
+ */
+export function allowStylingFlush(context, index) {
+    return index === context[1 /* MaxDirectiveIndexPosition */];
+}
+/**
+ * @param {?} context
+ * @return {?}
+ */
+export function lockContext(context) {
+    setConfig(context, getConfig(context) | 1 /* Locked */);
+}
+/**
+ * @param {?} context
+ * @return {?}
+ */
+export function isContextLocked(context) {
+    return (getConfig(context) & 1 /* Locked */) > 0;
+}
+/**
+ * @param {?} context
+ * @return {?}
+ */
+export function getPropValuesStartPosition(context) {
+    return 5 /* MapBindingsBindingsStartPosition */ +
+        context[3 /* MapBindingsValuesCountPosition */];
+}
+/**
+ * @param {?} prop
+ * @return {?}
+ */
+export function isMapBased(prop) {
+    return prop === MAP_BASED_ENTRY_PROP_NAME;
+}
+/**
+ * @param {?} a
+ * @param {?} b
+ * @return {?}
+ */
+export function hasValueChanged(a, b) {
+    /** @type {?} */
+    const compareValueA = Array.isArray(a) ? a[0 /* RawValuePosition */] : a;
+    /** @type {?} */
+    const compareValueB = Array.isArray(b) ? b[0 /* RawValuePosition */] : b;
+    return compareValueA !== compareValueB;
+}
+/**
+ * Determines whether the provided styling value is truthy or falsy.
+ * @param {?} value
+ * @return {?}
+ */
+export function isStylingValueDefined(value) {
+    // the reason why null is compared against is because
+    // a CSS class value that is set to `false` must be
+    // respected (otherwise it would be treated as falsy).
+    // Empty string values are because developers usually
+    // set a value to an empty string to remove it.
+    return value != null && value !== '';
+}
+/**
+ * Returns the current style sanitizer function for the given view.
+ *
+ * The default style sanitizer (which lives inside of `LView`) will
+ * be returned depending on whether the `styleSanitizer` instruction
+ * was called or not prior to any styling instructions running.
+ * @param {?} lView
+ * @return {?}
+ */
+export function getCurrentOrLViewSanitizer(lView) {
+    /** @type {?} */
+    const sanitizer = (/** @type {?} */ ((getCurrentStyleSanitizer() || lView[SANITIZER])));
+    if (sanitizer && typeof sanitizer !== 'function') {
+        setCurrentStyleSanitizer(sanitizer);
+        return sanitizeUsingSanitizerObject;
+    }
+    return sanitizer;
+}
+/**
+ * Style sanitization function that internally uses a `Sanitizer` instance to handle style
+ * sanitization.
+ * @type {?}
+ */
+const sanitizeUsingSanitizerObject = (/**
+ * @param {?} prop
+ * @param {?} value
+ * @param {?} mode
+ * @return {?}
+ */
+(prop, value, mode) => {
+    /** @type {?} */
+    const sanitizer = (/** @type {?} */ (getCurrentStyleSanitizer()));
+    if (sanitizer) {
+        if (mode & 2 /* SanitizeOnly */) {
+            return sanitizer.sanitize(SecurityContext.STYLE, value);
+        }
+        else {
+            return true;
+        }
+    }
+    return value;
+});
+const ɵ0 = sanitizeUsingSanitizerObject;
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/styling_next/util.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 {Sanitizer, SecurityContext} from '../../sanitization/security';\nimport {StyleSanitizeFn, StyleSanitizeMode} from '../../sanitization/style_sanitizer';\nimport {StylingContext} from '../interfaces/styling';\nimport {LView, SANITIZER} from '../interfaces/view';\nimport {getProp as getOldProp, getSinglePropIndexValue as getOldSinglePropIndexValue} from '../styling/class_and_style_bindings';\n\nimport {LStylingMap, LStylingMapIndex, TStylingConfigFlags, TStylingContext, TStylingContextIndex, TStylingContextPropConfigFlags} from './interfaces';\nimport {getCurrentStyleSanitizer, setCurrentStyleSanitizer} from './state';\n\nconst MAP_BASED_ENTRY_PROP_NAME = '--MAP--';\n\n/**\n * Creates a new instance of the `TStylingContext`.\n *\n * This function will also pre-fill the context with data\n * for map-based bindings.\n */\nexport function allocTStylingContext(): TStylingContext {\n  // because map-based bindings deal with a dynamic set of values, there\n  // is no way to know ahead of time whether or not sanitization is required.\n  // For this reason the configuration will always mark sanitization as active\n  // (this means that when map-based values are applied then sanitization will\n  // be checked against each property).\n  const mapBasedConfig = TStylingContextPropConfigFlags.SanitizationRequired;\n  return [TStylingConfigFlags.Initial, 0, mapBasedConfig, 0, MAP_BASED_ENTRY_PROP_NAME];\n}\n\n/**\n * Temporary function that allows for a string-based property name to be\n * obtained from an index-based property identifier.\n *\n * This function will be removed once the new styling refactor code (which\n * lives inside of `render3/styling_next/`) replaces the existing styling\n * implementation.\n */\nexport function getBindingNameFromIndex(\n    stylingContext: StylingContext, offset: number, directiveIndex: number, isClassBased: boolean) {\n  const singleIndex =\n      getOldSinglePropIndexValue(stylingContext, directiveIndex, offset, isClassBased);\n  return getOldProp(stylingContext, singleIndex);\n}\n\nexport function updateContextDirectiveIndex(context: TStylingContext, index: number) {\n  context[TStylingContextIndex.MaxDirectiveIndexPosition] = index;\n}\n\nfunction getConfig(context: TStylingContext) {\n  return context[TStylingContextIndex.ConfigPosition];\n}\n\nexport function setConfig(context: TStylingContext, value: number) {\n  context[TStylingContextIndex.ConfigPosition] = value;\n}\n\nexport function getProp(context: TStylingContext, index: number) {\n  return context[index + TStylingContextIndex.PropOffset] as string;\n}\n\nfunction getPropConfig(context: TStylingContext, index: number): number {\n  return (context[index + TStylingContextIndex.ConfigAndGuardOffset] as number) &\n      TStylingContextPropConfigFlags.Mask;\n}\n\nexport function isSanitizationRequired(context: TStylingContext, index: number) {\n  return (getPropConfig(context, index) & TStylingContextPropConfigFlags.SanitizationRequired) > 0;\n}\n\nexport function getGuardMask(context: TStylingContext, index: number) {\n  const configGuardValue = context[index + TStylingContextIndex.ConfigAndGuardOffset] as number;\n  return configGuardValue >> TStylingContextPropConfigFlags.TotalBits;\n}\n\nexport function setGuardMask(context: TStylingContext, index: number, maskValue: number) {\n  const config = getPropConfig(context, index);\n  const guardMask = maskValue << TStylingContextPropConfigFlags.TotalBits;\n  context[index + TStylingContextIndex.ConfigAndGuardOffset] = config | guardMask;\n}\n\nexport function getValuesCount(context: TStylingContext, index: number) {\n  return context[index + TStylingContextIndex.ValuesCountOffset] as number;\n}\n\nexport function getBindingValue(context: TStylingContext, index: number, offset: number) {\n  return context[index + TStylingContextIndex.BindingsStartOffset + offset] as number | string;\n}\n\nexport function getDefaultValue(context: TStylingContext, index: number): string|boolean|null {\n  const valuesCount = getValuesCount(context, index);\n  return context[index + TStylingContextIndex.BindingsStartOffset + valuesCount - 1] as string |\n      boolean | null;\n}\n\n/**\n * Temporary function which determines whether or not a context is\n * allowed to be flushed based on the provided directive index.\n */\nexport function allowStylingFlush(context: TStylingContext, index: number) {\n  return index === context[TStylingContextIndex.MaxDirectiveIndexPosition];\n}\n\nexport function lockContext(context: TStylingContext) {\n  setConfig(context, getConfig(context) | TStylingConfigFlags.Locked);\n}\n\nexport function isContextLocked(context: TStylingContext): boolean {\n  return (getConfig(context) & TStylingConfigFlags.Locked) > 0;\n}\n\nexport function getPropValuesStartPosition(context: TStylingContext) {\n  return TStylingContextIndex.MapBindingsBindingsStartPosition +\n      context[TStylingContextIndex.MapBindingsValuesCountPosition];\n}\n\nexport function isMapBased(prop: string) {\n  return prop === MAP_BASED_ENTRY_PROP_NAME;\n}\n\nexport function hasValueChanged(\n    a: LStylingMap | number | String | string | null | boolean | undefined | {},\n    b: LStylingMap | number | String | string | null | boolean | undefined | {}): boolean {\n  const compareValueA = Array.isArray(a) ? a[LStylingMapIndex.RawValuePosition] : a;\n  const compareValueB = Array.isArray(b) ? b[LStylingMapIndex.RawValuePosition] : b;\n  return compareValueA !== compareValueB;\n}\n\n/**\n * Determines whether the provided styling value is truthy or falsy.\n */\nexport function isStylingValueDefined(value: any) {\n  // the reason why null is compared against is because\n  // a CSS class value that is set to `false` must be\n  // respected (otherwise it would be treated as falsy).\n  // Empty string values are because developers usually\n  // set a value to an empty string to remove it.\n  return value != null && value !== '';\n}\n\n/**\n * Returns the current style sanitizer function for the given view.\n *\n * The default style sanitizer (which lives inside of `LView`) will\n * be returned depending on whether the `styleSanitizer` instruction\n * was called or not prior to any styling instructions running.\n */\nexport function getCurrentOrLViewSanitizer(lView: LView): StyleSanitizeFn|null {\n  const sanitizer: StyleSanitizeFn|null = (getCurrentStyleSanitizer() || lView[SANITIZER]) as any;\n  if (sanitizer && typeof sanitizer !== 'function') {\n    setCurrentStyleSanitizer(sanitizer);\n    return sanitizeUsingSanitizerObject;\n  }\n  return sanitizer;\n}\n\n/**\n * Style sanitization function that internally uses a `Sanitizer` instance to handle style\n * sanitization.\n */\nconst sanitizeUsingSanitizerObject: StyleSanitizeFn =\n    (prop: string, value: string, mode: StyleSanitizeMode) => {\n      const sanitizer = getCurrentStyleSanitizer() as Sanitizer;\n      if (sanitizer) {\n        if (mode & StyleSanitizeMode.SanitizeOnly) {\n          return sanitizer.sanitize(SecurityContext.STYLE, value);\n        } else {\n          return true;\n        }\n      }\n      return value;\n    };\n"]}

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

@@ -111,9 +111,10 @@ export function attrsStylingIndexOf(attrs, startIndex) {
  * attribute values in a `TAttributes` array are only the names of attributes,
  * and not name-value pairs.
  * @param {?} marker The attribute marker to test.
- * @return {?} true if the marker is a "name-only" marker (e.g. `Bindings` or `Template`).
+ * @return {?} true if the marker is a "name-only" marker (e.g. `Bindings`, `Template` or `I18n`).
  */
 export function isNameOnlyAttributeMarker(marker) {
-    return marker === 3 /* Bindings */ || marker === 4 /* Template */;
+    return marker === 3 /* Bindings */ || marker === 4 /* Template */ ||
+        marker === 6 /* I18n */;
 }
-//# 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,EAAgC,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAC3F,OAAO,EAAC,QAAQ,EAAC,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAC,QAAQ,EAAC,MAAM,UAAU,CAAC;AAClC,OAAO,EAAC,eAAe,EAAC,MAAM,iBAAiB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BhD,MAAM,UAAU,eAAe,CAAC,MAAgB,EAAE,KAAkB;;UAC5D,QAAQ,GAAG,QAAQ,EAAE,CAAC,QAAQ,CAAC;;UAC/B,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;yBAC5B,YAAY,CAAC,MAAM,EAAE,mBAAA,QAAQ,EAAU,EAAE,mBAAA,OAAO,EAAU,CAAC,CAAC,CAAC;oBAClE,MAAM,CAAC,YAAY,CAAC,mBAAA,QAAQ,EAAU,EAAE,mBAAA,OAAO,EAAU,CAAC,CAAC;aAChE;YACD,CAAC,EAAE,CAAC;SACL;KACF;IAED,8EAA8E;IAC9E,+EAA+E;IAC/E,iFAAiF;IACjF,iBAAiB;IACjB,OAAO,CAAC,CAAC;AACX,CAAC;;;;;;AAGD,MAAM,UAAU,mBAAmB,CAAC,KAAkB,EAAE,UAAkB;IACxE,KAAK,IAAI,CAAC,GAAG,UAAU,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;;cACxC,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC;QACpB,IAAI,GAAG,oBAA4B,IAAI,GAAG,mBAA2B,EAAE;YACrE,OAAO,CAAC,CAAC;SACV;KACF;IACD,OAAO,CAAC,CAAC,CAAC;AACZ,CAAC;;;;;;;;AASD,MAAM,UAAU,yBAAyB,CAAC,MAA8C;IACtF,OAAO,MAAM,qBAA6B,IAAI,MAAM,qBAA6B,CAAC;AACpF,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, isProceduralRenderer} from '../interfaces/renderer';\nimport {RENDERER} from '../interfaces/view';\nimport {getLView} from '../state';\nimport {isAnimationProp} from '../styling/util';\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 *\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(native: RElement, attrs: TAttributes): number {\n  const renderer = getLView()[RENDERER];\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)\n                .setAttribute(native, attrName as string, attrVal as string) :\n            native.setAttribute(attrName as string, 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\nexport function attrsStylingIndexOf(attrs: TAttributes, startIndex: number): number {\n  for (let i = startIndex; i < attrs.length; i++) {\n    const val = attrs[i];\n    if (val === AttributeMarker.Classes || val === AttributeMarker.Styles) {\n      return i;\n    }\n  }\n  return -1;\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` or `Template`).\n */\nexport function isNameOnlyAttributeMarker(marker: string | AttributeMarker | CssSelector) {\n  return marker === AttributeMarker.Bindings || marker === AttributeMarker.Template;\n}\n"]}
+//# 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,EAAgC,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAC3F,OAAO,EAAC,QAAQ,EAAC,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAC,QAAQ,EAAC,MAAM,UAAU,CAAC;AAClC,OAAO,EAAC,eAAe,EAAC,MAAM,iBAAiB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BhD,MAAM,UAAU,eAAe,CAAC,MAAgB,EAAE,KAAkB;;UAC5D,QAAQ,GAAG,QAAQ,EAAE,CAAC,QAAQ,CAAC;;UAC/B,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;yBAC5B,YAAY,CAAC,MAAM,EAAE,mBAAA,QAAQ,EAAU,EAAE,mBAAA,OAAO,EAAU,CAAC,CAAC,CAAC;oBAClE,MAAM,CAAC,YAAY,CAAC,mBAAA,QAAQ,EAAU,EAAE,mBAAA,OAAO,EAAU,CAAC,CAAC;aAChE;YACD,CAAC,EAAE,CAAC;SACL;KACF;IAED,8EAA8E;IAC9E,+EAA+E;IAC/E,iFAAiF;IACjF,iBAAiB;IACjB,OAAO,CAAC,CAAC;AACX,CAAC;;;;;;AAGD,MAAM,UAAU,mBAAmB,CAAC,KAAkB,EAAE,UAAkB;IACxE,KAAK,IAAI,CAAC,GAAG,UAAU,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;;cACxC,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC;QACpB,IAAI,GAAG,oBAA4B,IAAI,GAAG,mBAA2B,EAAE;YACrE,OAAO,CAAC,CAAC;SACV;KACF;IACD,OAAO,CAAC,CAAC,CAAC;AACZ,CAAC;;;;;;;;AASD,MAAM,UAAU,yBAAyB,CAAC,MAA8C;IACtF,OAAO,MAAM,qBAA6B,IAAI,MAAM,qBAA6B;QAC7E,MAAM,iBAAyB,CAAC;AACtC,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, isProceduralRenderer} from '../interfaces/renderer';\nimport {RENDERER} from '../interfaces/view';\nimport {getLView} from '../state';\nimport {isAnimationProp} from '../styling/util';\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 *\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(native: RElement, attrs: TAttributes): number {\n  const renderer = getLView()[RENDERER];\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)\n                .setAttribute(native, attrName as string, attrVal as string) :\n            native.setAttribute(attrName as string, 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\nexport function attrsStylingIndexOf(attrs: TAttributes, startIndex: number): number {\n  for (let i = startIndex; i < attrs.length; i++) {\n    const val = attrs[i];\n    if (val === AttributeMarker.Classes || val === AttributeMarker.Styles) {\n      return i;\n    }\n  }\n  return -1;\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"]}