_setPendingProperty(property, value, shouldNotify) {
      let isPath = this.__dataHasPaths && isPath$0(property);
      let prevProps = isPath ? this.__dataTemp : this.__data;
      if (this._shouldPropertyChange(property, value, prevProps[property])) {
        if (!this.__dataPending) {
          this.__dataPending = {};
          this.__dataOld = {};
        }
        // Ensure old is captured from the last turn
        if (!(property in this.__dataOld)) {
          this.__dataOld[property] = this.__data[property];
        }
        // Paths are stored in temporary cache (cleared at end of turn),
        // which is used for dirty-checking, all others stored in __data
        if (isPath) {
          this.__dataTemp[property] = value;
        } else {
          this.__data[property] = value;
        }
        // All changes go into pending property bag, passed to _propertiesChanged
        this.__dataPending[property] = value;
        // Track properties that should notify separately
        if (isPath || (this[TYPES.NOTIFY] && this[TYPES.NOTIFY][property])) {
          this.__dataToNotify = this.__dataToNotify || {};
          this.__dataToNotify[property] = shouldNotify;
        }
        return true;
      }
      return false;
    }
/**
     * Overrides the `PropertiesChanged` implementation to introduce special
     * dirty check logic depending on the property & value being set:
     *
     * 1. Any value set to a path (e.g. 'obj.prop': 42 or 'obj.prop': {...})
     *    Stored in `__dataTemp`, dirty checked against `__dataTemp`
     * 2. Object set to simple property (e.g. 'prop': {...})
     *    Stored in `__dataTemp` and `__data`, dirty checked against
     *    `__dataTemp` by default implementation of `_shouldPropertyChange`
     * 3. Primitive value set to simple property (e.g. 'prop': 42)
     *    Stored in `__data`, dirty checked against `__data`
     *
     * The dirty-check is important to prevent cycles due to two-way
     * notification, but paths and objects are only dirty checked against any
     * previous value set during this turn via a "temporary cache" that is
     * cleared when the last `_propertiesChanged` exits. This is so:
     * a. any cached array paths (e.g. 'array.3.prop') may be invalidated
     *    due to array mutations like shift/unshift/splice; this is fine
     *    since path changes are dirty-checked at user entry points like `set`
     * b. dirty-checking for objects only lasts one turn to allow the user
     *    to mutate the object in-place and re-set it with the same identity
     *    and have all sub-properties re-propagated in a subsequent turn.
     *
     * The temp cache is not necessarily sufficient to prevent invalid array
     * paths, since a splice can happen during the same turn (with pathological
     * user code); we could introduce a "fixup" for temporarily cached array
     * paths if needed: https://github.com/Polymer/polymer/issues/4227
     *
     * @override
     * @param {string} property Name of the property
     * @param {*} value Value to set
     * @param {boolean=} shouldNotify True if property should fire notification
     *   event (applies only for `notify: true` properties)
     * @return {boolean} Returns true if the property changed
     */
Overrides the `PropertiesChanged` implementation to introduce special
dirty check logic depending on the property & value being set.

1. Any value set to a path
Stored in `__dataTemp`, dirty checked against `__dataTemp`
2.

The dirty-check is important to prevent cycles due to two-way
notification, but paths and objects are only dirty checked against any
previous value set during this turn via a "temporary cache" that is
cleared when the last `_propertiesChanged` exits. This is so:
a. any cached array paths  may be invalidated
due to array mutations like shift/unshift/splice; this is fine
since path changes are dirty-checked at user entry points like `set`
b.




Overrides the ` PropertiesChanged ` implementation to introduce special dirty check logic depending on the property & value being set . 1 . Any value set to a path Stored in ` __dataTemp ` dirty checked against ` __dataTemp ` 2 . The dirty - check is important to prevent cycles due to two - way notification but paths and objects are only dirty checked against any previous value set during this turn via a " temporary cache " that is cleared when the last ` _propertiesChanged ` exits . This is so : a . any cached array paths may be invalidated due to array mutations like shift / unshift / splice ; this is fine since path changes are dirty - checked at user entry points like ` set ` b .
_setPendingProperty(property, value, shouldNotify) {
      let isPath = this.__dataHasPaths && isPath$0(property);
      let prevProps = isPath ? this.__dataTemp : this.__data;
      if (this._shouldPropertyChange(property, value, prevProps[property])) {
        if (!this.__dataPending) {
          this.__dataPending = {};
          this.__dataOld = {};
        }
        if (!(property in this.__dataOld)) {
          this.__dataOld[property] = this.__data[property];
        }
        if (isPath) {
          this.__dataTemp[property] = value;
        } else {
          this.__data[property] = value;
        }
        this.__dataPending[property] = value;
        if (isPath || (this[TYPES.NOTIFY] && this[TYPES.NOTIFY][property])) {
          this.__dataToNotify = this.__dataToNotify || {};
          this.__dataToNotify[property] = shouldNotify;
        }
        return true;
      }
      return false;
    }
_setPendingProperty ( property , value , shouldNotify ) { let isPath = this . __dataHasPaths && isPath$0 ( property ) ; let prevProps = isPath ? this . __dataTemp : this . __data ; if ( this . _shouldPropertyChange ( property , value , prevProps [ property ] ) ) { if ( ! this . __dataPending ) { this . __dataPending = { } ; this . __dataOld = { } ; } if ( ! ( property in this . __dataOld ) ) { this . __dataOld [ property ] = this . __data [ property ] ; } if ( isPath ) { this . __dataTemp [ property ] = value ; } else { this . __data [ property ] = value ; } this . __dataPending [ property ] = value ; if ( isPath || ( this [ TYPES . NOTIFY ] && this [ TYPES . NOTIFY ] [ property ] ) ) { this . __dataToNotify = this . __dataToNotify || { } ; this . __dataToNotify [ property ] = shouldNotify ; } return true ; } return false ; }
Overrides the `PropertiesChanged` implementation to introduce special
 dirty check logic depending on the property & value being set:
Overrides the ` PropertiesChanged ` implementation to introduce special dirty check logic depending on the property & value being set :
// Ensure old is captured from the last turn // Paths are stored in temporary cache (cleared at end of turn), // which is used for dirty-checking, all others stored in __data // All changes go into pending property bag, passed to _propertiesChanged // Track properties that should notify separately