==== Mutation Observers ====// 
Creates MutationObservers for the host and content Element if they are supported.
961371
function createMutationObservers() {
                    if (_supportMutationObserver) {
                        var mutationObserverContentLag = 11;
                        var mutationObserver = COMPATIBILITY.mO();
                        var contentLastUpdate = COMPATIBILITY.now();
                        var mutationTarget;
                        var mutationAttrName;
                        var contentTimeout;
                        var now;
                        var sizeAuto;
                        var action;

                        _mutationObserverHost = new mutationObserver(function (mutations) {
                            if (!_initialized || _isSleeping)
                                return;

                            var doUpdate = false;
                            var mutation;
                            FRAMEWORK.each(mutations, function () {
                                mutation = this;
                                mutationTarget = mutation.target;
                                mutationAttrName = mutation.attributeName;

                                if (mutationAttrName === LEXICON.c)
                                    doUpdate = hostClassNamesChanged(mutation.oldValue, mutationTarget.className);
                                else if (mutationAttrName === LEXICON.s)
                                    doUpdate = mutation.oldValue !== mutationTarget[LEXICON.s].cssText;
                                else
                                    doUpdate = true;

                                if (doUpdate)
                                    return false;
                            });

                            if (doUpdate)
                                _base.update(_strAuto);
                        });
                        _mutationObserverContent = new mutationObserver(function (mutations) {
                            if (!_initialized || _isSleeping)
                                return;

                            var doUpdate = false;
                            var mutation;
                            FRAMEWORK.each(mutations, function () {
                                mutation = this;
                                doUpdate = isUnknownMutation(mutation);
                                return !doUpdate;
                            });

                            if (doUpdate) {
                                now = COMPATIBILITY.now();
                                sizeAuto = (_heightAutoCache || _widthAutoCache);
                                action = function () {
                                    if(!_destroyed) {
                                        contentLastUpdate = now;

                                        //if cols, rows or wrap attr was changed
                                        if (_isTextarea)
                                            textareaUpdate();

                                        if (sizeAuto)
                                            update();
                                        else
                                            _base.update(_strAuto);
                                    }
                                };
                                clearTimeout(contentTimeout);
                                if (mutationObserverContentLag <= 0 || now - contentLastUpdate > mutationObserverContentLag || !sizeAuto)
                                    action();
                                else
                                    contentTimeout = setTimeout(action, mutationObserverContentLag);
                            }
                        });
                    }
                }
638915
function (mutation) {
        // bail out for empty or unsupported mutations
        if (!(mutation && isPrimitiveMutation(mutation))) {
            return;
        }

        // if autoCompact is set, we need to compact while adding
        if (this.autoCompact) {
            this.addAndCompact(mutation);
            return;
        }

        // otherwise just push to the stream of mutations
        this.stream.push(mutation);
    }
944877
public static VisitorState createConfiguredForCompilation(
      Context context,
      DescriptionListener listener,
      Map<String, SeverityLevel> severityMap,
      ErrorProneOptions errorProneOptions) {
    return new VisitorState(
        context,
        listener,
        severityMap,
        errorProneOptions,
        StatisticsCollector.createCollector(),
        null,
        null,
        SuppressedState.UNSUPPRESSED);
  }
1284192
function addMutationObserver(settings) {
    function isLink(node) {
        const isStylesheet = node.tagName === 'LINK' && (node.getAttribute('rel') || '').indexOf('stylesheet') !== -1;

        return isStylesheet && !node.disabled;
    }
    function isStyle(node) {
        return node.tagName === 'STYLE' && !node.disabled;
    }
    function isValidAddMutation(mutationNodes) {
        return Array.apply(null, mutationNodes).some(node => {
            const isElm           = node.nodeType === 1;
            const hasAttr         = isElm && node.hasAttribute('data-cssvars');
            const isStyleWithVars = isStyle(node) && regex.cssVars.test(node.textContent);
            const isValid         = !hasAttr && (isLink(node) || isStyleWithVars);

            return isValid;
        });
    }
    function isValidRemoveMutation(mutationNodes) {
        return Array.apply(null, mutationNodes).some(node => {
            const isElm     = node.nodeType === 1;
            const isOutNode = isElm && node.getAttribute('data-cssvars') === 'out';
            const isSrcNode = isElm && node.getAttribute('data-cssvars') === 'src';
            const isValid   = isSrcNode;

            if (isSrcNode || isOutNode) {
                const dataGroup  = node.getAttribute('data-cssvars-group');
                const orphanNode = settings.rootElement.querySelector(`[data-cssvars-group="${dataGroup}"]`);

                if (isSrcNode) {
                    resetCssNodes(settings.rootElement);
                    variableStore.dom = {};
                }

                if (orphanNode) {
                    orphanNode.parentNode.removeChild(orphanNode);
                }
            }

            return isValid;
        });
    }

    if (!window.MutationObserver) {
        return;
    }

    if (cssVarsObserver) {
        cssVarsObserver.disconnect();
        cssVarsObserver = null;
    }

    cssVarsObserver = new MutationObserver(function(mutations) {
        const hasValidMutation = mutations.some((mutation) => {
            let isValid = false;

            if (mutation.type === 'attributes') {
                isValid = isLink(mutation.target);
            }
            else if (mutation.type === 'childList') {
                isValid = isValidAddMutation(mutation.addedNodes) || isValidRemoveMutation(mutation.removedNodes);
            }

            return isValid;
        });

        if (hasValidMutation) {
            cssVars(settings);
        }
    });

    cssVarsObserver.observe(document.documentElement, {
        attributes     : true,
        attributeFilter: ['disabled', 'href'],
        childList      : true,
        subtree        : true
    });
}
661001
public void setObserver(Map<String, Object> observer) {
        removeEntriesStartingWith(OBSERVER);
        eventMap.putAll(observer);
    }
945187
function _deliverChangeRecords(observer) {
        var pendingChangeRecords = pendingChangesMap.get(observer);
        pendingChangesMap.delete(observer);
        if (!pendingChangeRecords || pendingChangeRecords.length === 0) {
            return false;
        }
        try {
            observer.call(undefined, pendingChangeRecords);
        }
        catch (e) { }

        _cleanObserver(observer);
        return true;
    }
292728
function waitForChildCallback (parent, predicate, callback) {
  if (predicate(parent)) {
    callback()

    return
  }

  const win = parent.ownerDocument.defaultView

  if (win.MutationObserver) {
    /**
     * @type {!MutationObserver}
     */
    const observer = new win.MutationObserver(() => {
      if (predicate(parent)) {
        observer.disconnect()
        callback()
      }
    })

    observer.observe(parent, {childList: true})

    return
  }

  const intervalId = win.setInterval(() => {
    if (predicate(parent)) {
      win.clearInterval(intervalId)
      callback()
    }
  }, 5)
}
186563
function defer(cb) {
    if (!defer.nextLoop) {
        var ntv = typeof setImmediate === 'function';
        defer.nextLoop = ntv ? setImmediate : function setImmediateShim(cb) {
            if (defer.obj) {
                if (!defer.cbs.length) {
                    defer.obj.setAttribute('cnt', 'inc');
                }
                defer.cbs.push(cb);
            } else {
                setTimeout(cb, 0);
            }
        };
        if (!ntv && typeof MutationObserver === 'object' && typeof document === 'object') {
            defer.cbs = [];
            defer.obj = document.createElement('div');
            defer.ob = new MutationObserver(function mutations() {
                for (var cbl = defer.cbs.slice(), i = defer.cbs.length = 0, l = cbl.length; i < l; i++) {
                    cbl[i]();
                }
            }).observe(defer.obj, { attributes: true });
        }
    }
    return defer.nextLoop.call(null, cb);
}
732631
static void addDetachObserver(HTMLElement element, ObserverCallback callback) {
        if (!ready) {
            startObserving();
        }
        detachObservers.add(createObserver(element, callback, DETACH_UID_KEY));
    }
814961
function init(msg) {
      function iFrameLoaded() {
        trigger('iFrame.onload', msg, iframe, undefined, true)
        checkReset()
      }

      function createDestroyObserver(MutationObserver) {
        if (!iframe.parentNode) {
          return
        }

        var destroyObserver = new MutationObserver(function(mutations) {
          mutations.forEach(function(mutation) {
            var removedNodes = Array.prototype.slice.call(mutation.removedNodes) // Transform NodeList into an Array
            removedNodes.forEach(function(removedNode) {
              if (removedNode === iframe) {
                closeIFrame(iframe)
              }
            })
          })
        })
        destroyObserver.observe(iframe.parentNode, {
          childList: true
        })
      }

      var MutationObserver = getMutationObserver()
      if (MutationObserver) {
        createDestroyObserver(MutationObserver)
      }

      addEventListener(iframe, 'load', iFrameLoaded)
      trigger('init', msg, iframe, undefined, true)
    }
115678
@Override
    public void addObserver(Observer observer) {
        super.addObserver(observer);
        if (countObservers() > 1) {
            super.deleteObserver(observer);
            AbstractConnectionFactoryService cfSvc = (AbstractConnectionFactoryService) observer;
            Object[] params = new Object[] { CONNECTION_MANAGER, name, cfSvc.getConfigElementName() };
            RuntimeException failure = connectorSvc.ignoreWarnOrFail(tc, null, UnsupportedOperationException.class, "CARDINALITY_ERROR_J2CA8040", params);
            if (failure != null)
                throw failure;
        }
    }
23556
def _setup_observers(self):
        
        if self.has_parent():
            self.add_observer(self._parent_, self._parent_._pass_through_notify_observers, -np.inf)
145513
function observe (value) {
	  if (!isObject(value)) {
	    return
	  }
	  var ob;
	  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
	    ob = value.__ob__;
	  } else if (
	    observerState.shouldConvert &&
	    !config._isServer &&
	    (Array.isArray(value) || isPlainObject(value)) &&
	    Object.isExtensible(value) &&
	    !value._isVue
	  ) {
	    ob = new Observer(value);
	  }
	  return ob
	}
1275825
@Override
    public SingleInspectionSpecifier observe(Class<? extends RequestObserver> what) {
        initializeSingleGroup();
        singleGroup.observe(createFilterInstance(what));
        return this;
    }
685800
function detectChangesInternal(hostView, hostNode, component) {
    var oldView = enterView(hostView, hostNode);
    var hostTView = hostView[TVIEW];
    var template = hostTView.template;
    var viewQuery = hostTView.viewQuery;
    try {
        namespaceHTML();
        createViewQuery(viewQuery, hostView[FLAGS], component);
        template(getRenderFlags(hostView), component);
        refreshView();
        updateViewQuery(viewQuery, component);
    }
    finally {
        leaveView(oldView);
    }
}
936853
function(context, expr, callback, callbackContext) {
    if (typeof context === 'string') {
      callbackContext = callback;
      callback = expr;
      expr = context;
      context = null;
    }
    var observer = this.observations.createObserver(expr, callback, callbackContext);
    if (context) {
      observer.bind(context, true);
    }
    return observer;
  }
1001254
function objectObserver(changes) {
    changes.forEach(({type, name}) => {
      switch (type) {
      case 'add':    o[name] = u[name]; break;
      case 'delete': delete o[name];    break;
      }
    });
  }