Suspend mutation monitoring of document; enable
monitoring again after executing provided function.
@param {Node} node
@param @optional {function} action
@param @optional {object} thisp
@returns {object} if action was defined, we might return something
355042
function(action, thisp) {
		var res;
		if (this.observes) {
			if (++this._suspend === 1) {
				this._connect(false);
			}
		}
		if (gui.Type.isFunction(action)) {
			res = action.call(thisp);
		}
		if (this.observes) {
			this.resume();
		}
		return res;
	}
1339238
function(oThis, oEvent){
		oEvent.stopPropagation();
		oEvent.preventDefault();

		var jTarget = jQuery(oEvent.target);
		var sTargetId = jTarget.attr("id");

		if (!sTargetId) {
			return;
		}

		//Handle event for the end of an expandable step
		var iIdx = sTargetId.lastIndexOf("-expandend");
		if (iIdx != -1) {
			var oStep = sap.ui.getCore().byId(sTargetId.substring(0, iIdx));
			if (oStep && oThis.indexOfStep(oStep) >= 0) {
				oStep.handleSelect(oEvent, true);
				return;
			}
		}

		//Handle select on delimiter
		if (sTargetId == oThis.getId() + "-Start") {
			if (jTarget.hasClass("sapUiRoadMapStartScroll")) {
				scrollToNextStep(oThis, "prev", true);
			} else {
				refreshFocus(oThis);
			}
		} else if (sTargetId == oThis.getId() + "-End") {
			if (jTarget.hasClass("sapUiRoadMapEndScroll")) {
				scrollToNextStep(oThis, "next", true);
			} else {
				refreshFocus(oThis);
			}
		}
	}
566182
function executeDispatch(event, listener, inst) {
  var type = event.type || 'unknown-event';
  event.currentTarget = getNodeFromInstance(inst);
  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
  event.currentTarget = null;
}
1133855
function startObserving() {

	if (config.skipObserving) {
		return;
	}

	// Reprocess now
	scheduleExecution(1);

	window.addEventListener('DOMContentLoaded', scheduleExecution.bind(undefined, 1, undefined, undefined));
	window.addEventListener('load', scheduleExecution.bind(undefined, 1, undefined, undefined));
	window.addEventListener('resize', scheduleExecution.bind(undefined, 3, true, undefined));

	var MutationObserver = window.MutationObserver || window.WebKitMutationObserver;
	if (MutationObserver) {
		observer = new MutationObserver(checkMutations);
		observer.observe(document.documentElement, {
			childList: true,
			subtree: true,
		});
	}
	else {
		window.addEventListener('DOMNodeInserted', onDomMutate);
		window.addEventListener('DOMNodeRemoved', onDomMutate);
	}

}
1285795
function checkNode(node, clone)
			{
				if (node != null)
				{
					if (clone.originalNode != node)
					{
						cleanNode(node);
					}
					else
					{
						node = node.firstChild;
						clone = clone.firstChild;
						
						while (node != null)
						{
							var nextNode = node.nextSibling;
							
							if (clone == null)
							{
								cleanNode(node);
							}
							else
							{
								checkNode(node, clone);
								clone = clone.nextSibling;
							}
	
							node = nextNode;
						}
					}
				}
			}
1006687
async function onCreateNode({
  node,
  actions,
  loadNodeContent,
  createNodeId,
  createContentDigest,
}) {
  if (!canParse(node)) return

  const sourceText = await loadNodeContent(node);
  let parsed = null;
  try {
    if (isTSX(node)) {
      // Load up the already transpiled file
      const transpiledPath = node.absolutePath
        .replace(/react-(.*)\/src/, 'react-$1/dist/esm')
        .replace(/\.tsx?$/, '.js');
      const jsText = fs.readFileSync(transpiledPath, 'utf8');
      parsed = docgenJavascript.parse(jsText);
    }
    else if (isJSX(node)) {
      parsed = docgenJavascript.parse(sourceText);
    }
  } catch (err) {
    console.warn('No component found in', node.absolutePath);
  }

  if (parsed) {
    const metadataNode = {
      name: parsed.displayName,
      description: parsed.description,
      props: flattenProps(parsed.props),
      path: node.relativePath,
      basePath: node.relativePath.split('/')[0],
      id: createNodeId(`${node.id}imunique${node.relativePath}`),
      children: [],
      parent: node.id,
      internal: {
        contentDigest: createContentDigest(node),
        type: `ComponentMetadata`,
      },
    }
    actions.createNode(metadataNode)
    actions.createParentChildLink({ parent: node, child: metadataNode })
  }
}
1360481
function _changeEvent(el,attr,value,oldValue,args,action,type,stopChange)
        {
          this.stopPropagation = function(){this._stopPropogation = true;};
          this.preventDefault = function(){this._preventDefault = true;};
          this.value = value;
          this.oldValue = oldValue;
          this.target = el;
          this.attr = attr;
          this.arguments = args;
          this.action = action;
          this.child = undefined;
          this.type = type;
          this.stopChange = stopChange;
        }
537519
function Scope(node, parent, scope, state) {
    // check if this scope has a local binding that will shadow the rest parameter
    if (!scope.bindingIdentifierEquals(state.name, state.outerBinding)) {
      this.skip();
    }
  }
492817
function _onChildNodeInserted(event, res) {
        // res = {parentNodeId, previousNodeId, node}
        if (_insertTrace) {
            var node = DOMAgent.nodeWithId(res.node.nodeId);
            node.trace = _insertTrace;
            _insertTrace = undefined;
        }
    }
430047
function(action, thisp) {
			this.init(action, thisp);
			if(gui.debug) {
				console.warn('gui.ready() is for spirits, use gui.init()');
			}
			return false;
		}
636683
function(name, action, context) {
        if (!name || !action) {
            return;
        }
        var self = this;
        function wrapper() {
            self.off(name, wrapper);
            action.apply(this, arguments);
        }
        return this.on(name, wrapper, context);
    }
565546
function(operation, thisp) {
		this._suspended = true;
		var res = operation.call(thisp);
		this._suspended = false;
		return res;
	}
708490
function Node(config) {
    RED.nodes.createNode(this,config);
    var node = this,
      message = '';

    this.on('input', function (msg) {
      node.status({});

      payloadCheck(msg)
      .then(function(){
        return wordcountCheck(msg, config);
      })
      .then(function(){
        return credentialsCheck(node);
      })
      .then(function(){
        return setEndPoint(config);
      })
      .then(function(){
        return prepareParams(msg, config);
      })
      .then(function(params){

        node.status({fill:'blue', shape:'dot', text:'requesting'});
        return executeService(msg, params);
      })
      .then(function(){
        node.status({});
        node.send(msg);
      })
      .catch(function(err){
        payloadutils.reportError(node, msg, err);
        node.send(msg);
      });
    });
  }
913036
function autoUpdateOne(MutationObserver) {
    var self = this
    var watcher

    if (this._au) {
        return
    }

    function actualizeWatcher() {
        if (!self.root[self.origin.offset]) {
            startWatch()
        } else {
            stopWatch()
        }
    }

    // Set interval timeout for watching when root node will be visible
    function startWatch() {
        if (watcher) return

        watcher = setInterval(function() {
            if (self.root[self.origin.offset]) {
                stopWatch()
                self.update()
            }
        }, 300) // is it good enought for you?)
    }

    function stopWatch() {
        clearInterval(watcher)
        watcher = null
    }

    var debouncedUpdater = self._debounce(function() {
        self.update()
    }, 300)

    this._observer = new MutationObserver(function() {
        actualizeWatcher()
        self.update()
        debouncedUpdater()
    })

    this.on('init', function() {
        self._observer.observe(self.root, {
            childList: true,
            subtree: true,
            characterData: true
            // attributes: true
            // No reasons to set attributes to true
            // The case when root/child node with already properly inited baron toggled to hidden and then back to visible,
            // and the size of parent was changed during that hidden state, is very rare
            // Other cases are covered by watcher, and you still can do .update by yourself
        })

        actualizeWatcher()
    })

    this.on('dispose', function() {
        self._observer.disconnect()
        stopWatch()
        delete self._observer
    })

    this._au = true
}
729634
async function action_handler(req, h) {
    const data = req.payload
    const json = 'string' === typeof data ? tu.parseJSON(data) : data
    if (json instanceof Error) {
      throw json
    }

    const seneca = prepare_seneca(req, json)
    const msg = tu.internalize_msg(seneca, json)

    return await new Promise(resolve => {
      var out = null
      for (var i = 0; i < modify_action.length; i++) {
        out = modify_action[i].call(seneca, msg, req)
        if (out) {
          return resolve(out)
        }
      }

      seneca.act(msg, function(err, out, meta) {
        if (err && !options.debug) {
          err.stack = null
        }

        resolve(tu.externalize_reply(this, err, out, meta))
      })
    })
  }
843217
public void doTag()
            throws JspException, IOException
    {
        // It is only legal to set either an action or an href, this will verify we have exactly one.
        // report an error when there is more than one specified.
        int have = 0;
        if (_href != null) have++;
        if (_action != null) have++;
        if (have > 1) {
            String s = Bundle.getString("Tags_Node_InvalidNode", new Object[]{"href, action"});
            registerTagError(s, null);
        }

        // If we have specified an action, then we need to verify that the action is a valid action
        PageContext pageContext = getPageContext();
        if (_action != null) {
            HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();
            boolean isAction = PageFlowTagUtils.isAction(request, _action);
            if (!isAction) {
                registerTagError(Bundle.getString("Tags_BadAction", _action), null);
            }
        }

        // create the tree node
        JspTag parentTag = getParent();
        if (parentTag instanceof Tree) {
            _treeElement = new TreeRootElement();
        }
        else {
            _treeElement = new TreeElement();
        }

        // the the values
        _treeElement.setIcon(_icon);
        _treeElement.setClientAction(_clientAction);
        _treeElement.setScope(_scope);
        _treeElement.setTitle(_title);
        _treeElement.setTagId(_tagId);
        _treeElement.setExpandOnServer(_expandOnServer);
        _treeElement.setExpanded(_expanded);
        _treeElement.setDisabled(_disabled);
        _treeElement.setTarget(_target);
        _treeElement.setHref(_href);
        _treeElement.setAction(_action);

        boolean inlineError = false;
        if (hasErrors()) {
            String s = getInlineError();
            if (s == null)
                s = Bundle.getString("Tags_TreeItemErrorNoInline");
            else
                inlineError = true;
            _treeElement.setContent(s);
        }

        // insert the node into the parent node or into the tree itself.
        if (parentTag instanceof Tree) {
            Tree parentTree = (Tree) parentTag;
            if (parentTree.getRootNode() != null) {
                String s = Bundle.getString("Tags_TreeMultipleRootNodes");
                parentTree.registerTagError(s, null);
                //reportErrors();
                return;
            }
            parentTree.setRootNode(_treeElement);
        }
        else if (parentTag instanceof TreeItem) {
            TreeItem parentNode = (TreeItem) parentTag;
            parentNode.getNode().addChild(_treeElement);
            parentNode.setAddedChild();
        }
        else {
            // The parent is neither a Tree or a TreeItem so we must report an error
            String s = Bundle.getString("Tags_InvalidNodeParent");
            registerTagError(s, null);
            reportErrors();
            return;
        }

        String content = getBufferBody(true);
        if (!_child) {
            if (content != null)
                _childLabel = content;
        }

        // if there was a childLabel set then we need to update the label value for the tag.
        if (_childLabel != null) {
            _treeElement.setLabel(_childLabel);
        }

        if (hasErrors()) {
            if (!inlineError)
                reportErrors();
            return;
        }

        // if there was content defined for the node then we will set it on the node...
        if (_childContent != null) {
            _treeElement.setContent(_childContent);
        }

        // if there was inherited state set it now...
        if (_state != null) {
            _treeElement.setInheritableState(_state);
        }

        // if there is attribute then we should insert that into the TreeElement
        if (_attributes != null && _attributes.size() > 0) {
            Iterator it = _attributes.iterator();
            while (it.hasNext()) {
                TreeHtmlAttributeInfo jsi = (TreeHtmlAttributeInfo) it.next();
                _treeElement.addAttribute(jsi);
            }
        }
    }
442544
function (pointer, event, eventTarget, curEventTarget, matches, matchElements) {
            var target = this.target;

            if (!this.prepared.name && this.mouse) {

                var action;

                // update pointer coords for defaultActionChecker to use
                this.setEventXY(this.curCoords, [pointer]);

                if (matches) {
                    action = this.validateSelector(pointer, event, matches, matchElements);
                }
                else if (target) {
                    action = validateAction(target.getAction(this.pointers[0], event, this, this.element), this.target);
                }

                if (target && target.options.styleCursor) {
                    if (action) {
                        target._doc.documentElement.style.cursor = getActionCursor(action);
                    }
                    else {
                        target._doc.documentElement.style.cursor = '';
                    }
                }
            }
            else if (this.prepared.name) {
                this.checkAndPreventDefault(event, target, this.element);
            }
        }