Continue with spiritualize/materialize of given node?
@returns {boolean}
421334
function(node) {
		return node && !this._suspended &&
			gui.DOMPlugin.embedded(node) &&
			node.nodeType === Node.ELEMENT_NODE;
	}
113327
function process(node) {
          var children, i, l, lastContentEditable, hasContentEditableState;

          // Node has a contentEditable value
          if (node.nodeType === 1 && getContentEditable(node)) {
            lastContentEditable = contentEditable;
            contentEditable = getContentEditable(node) === "true";
            hasContentEditableState = true; // We don't want to wrap the container only it's children
          }

          // Grab the children first since the nodelist might be changed
          children = grep(node.childNodes);

          // Process current node
          if (contentEditable && !hasContentEditableState) {
            for (i = 0, l = formatList.length; i < l; i++) {
              if (removeFormat(formatList[i], vars, node, node)) {
                break;
              }
            }
          }

          // Process the children
          if (format.deep) {
            if (children.length) {
              for (i = 0, l = children.length; i < l; i++) {
                process(children[i]);
              }

              if (hasContentEditableState) {
                contentEditable = lastContentEditable; // Restore last contentEditable state from stack
              }
            }
          }
        }
86311
function walk (node, fn) {
  if (node.childNodes) {
    for (let i = 0, l = node.childNodes.length; i < l; i++) {
      const child = node.childNodes[i]
      const stop = fn(child)
      if (!stop) {
        walk(child, fn)
      }
    }
  }

  // also walk shadow DOM
  if (node.shadowRoot) {
    walk(node.shadowRoot, fn)
  }
}
793633
function() {
    this.expect('unless');
    this.state.push('conditional');
    this.cond = true;
    var node = new nodes.If(this.expression(), true);
    this.cond = false;
    node.block = this.block(node, false);
    this.state.pop();
    return node;
  }
22544
protected synchronized Object materializeSubject() throws PersistenceBrokerException
	{
		TemporaryBrokerWrapper tmp = getBroker();
        try
		{
			Object realSubject = tmp.broker.getObjectByIdentity(_id);
			if (realSubject == null)
			{
				LoggerFactory.getLogger(IndirectionHandler.class).warn(
						"Can not materialize object for Identity " + _id + " - using PBKey " + getBrokerKey());
			}
			return realSubject;
		} catch (Exception ex)
		{
			throw new PersistenceBrokerException(ex);
		} finally
		{
			tmp.close();
		}
	}
338855
function(target) {
		target = target instanceof gui.Spirit ? target.element : target;
		this._maybespiritualize(target, false, false);
	}
121384
function doVisitFull(visit, node) {
  if(node.left) {
    var v = doVisitFull(visit, node.left)
    if(v) { return v }
  }
  var v = visit(node.key, node.value)
  if(v) { return v }
  if(node.right) {
    return doVisitFull(visit, node.right)
  }
}
101379
function visit() {
  if (this.isBlacklisted()) return false;
  if (this.opts.shouldSkip && this.opts.shouldSkip(this)) return false;

  this.call("enter");

  if (this.shouldSkip) {
    return this.shouldStop;
  }

  var node = this.node;
  var opts = this.opts;

  if (node) {
    if (Array.isArray(node)) {
      // traverse over these replacement nodes we purposely don't call exitNode
      // as the original node has been destroyed
      for (var i = 0; i < node.length; i++) {
        _index2["default"].node(node[i], opts, this.scope, this.state, this, this.skipKeys);
      }
    } else {
      _index2["default"].node(node, opts, this.scope, this.state, this, this.skipKeys);
      this.call("exit");
    }
  }

  return this.shouldStop;
}
234039
function(things) {
				var els = things,
					element = this.spirit.element;
				els.forEach(function(el) {
					element.appendChild(el);
					maybespiritualize(el);
				});
			}
906915
function (node) {
        var newNode = node.clone();
        var clonedNodesMap = {};
        function buildNodesMap(sNode, tNode) {
            clonedNodesMap[sNode.__uid__] = tNode;

            for (var i = 0; i < sNode._children.length; i++) {
                var sChild = sNode._children[i];
                var tChild = tNode._children[i];
                buildNodesMap(sChild, tChild);
            }
        }
        buildNodesMap(node, newNode);

        newNode.traverse(function (newChild) {
            if (newChild.skeleton) {
                newChild.skeleton = newChild.skeleton.clone(clonedNodesMap);
            }
            if (newChild.material) {
                newChild.material = newChild.material.clone();
            }
        });

        return newNode;
    }
1101588
function(node) {
    cnt++;
    if (!node || cnt >= step) {
      if (ydn.db.core.req.SimpleCursor.DEBUG) {
        goog.global.console.log('advance to ' + (node ? node.value : 'null'));
      }
      return me.defaultOnSuccess_(node);
    }
  }
1036016
function(node, callback, depth) {
			if (this.isSkipped(node)) {
				return;
			}

			var childNode,
				childNodes = node && node.childNodes || [];

			depth = (depth || 1);

			for (var n = 0, len = childNodes.length; n < len; n++) {
				childNode = childNodes[n];

				// callback can return false to stop recursive
				if (callback(childNode, depth) !== false) {
					this.walk(childNode, callback, depth + 1);
				}
			}
		}
832426
function move(node, stayWithin, directionIsNext) {
  if (directionIsNext) {
    return NodeTraversal.next(node, stayWithin);
  } else {
    if (node === stayWithin) {
      return null;
    }
    return NodeTraversal.previous(node, null);
  }
}
894010
function(b) {
			var map = b.global ? this._globals : this._locals[gui.$contextid];
			if (gui.hasModule('gui-spirits@wunderbyte.com')) {
				if(!gui.spiritualized) {
					if(b.type !== gui.BROADCAST_WILL_SPIRITUALIZE) {
						// TODO: cache broadcast until spiritualized?
					}
				}
			}
			if (this.$target) {
				if (!b.global) {
					b.target = this.$target;
				}
				this.$target = null;
			}
			if (b instanceof gui.Broadcast === false) {
				b = new gui.Broadcast(b);
			}
			if (map) {
				var handlers = map[b.type];
				if (handlers) {
					handlers.slice().forEach(function(handler) {
						handler.onbroadcast(b);
					});
				}
			}
			if (b.global) {
				this._propagate(b);
			}
			return b;
		}
961741
function hasRest (node) {
    for (var i = 0, child; (child = node.children[i]); i++) {
      if (child.type === "rest") return true;
    }
    return false;
  }
1275478
def physicalize(options = {})

            @revisions.each do |revision|
                # Do not use each_object here as build_object may modify the iterator.
                revision.objects.each do |obj|
                    build_object(obj, revision, options)
                end
            end

            self
        end
433496
function processNode(node) {
            if (!node.code.trim()) {
                // empty
                return
            }

            const innerTokens = microTemplateService.getMicroTemplateTokensInfo(
                node
            ).innerTokens
            if (!innerTokens.length) {
                return
            }
            const statement = microTemplateService.getMicroTemplateExpressionStatement(
                node,
                sourceCode
            )
            if (!statement) {
                return
            }

            const innerLast = innerTokens[innerTokens.length - 1]
            if (innerLast.value === ";") {
                context.report({
                    node: innerLast,
                    messageId: "unexpected",
                    fix: fixer => fixer.remove(innerLast),
                })
            }
        }