Visit case `node`.

@param {Literal} node
@api public
429915
function(node){
    var stmt = t.switchStatement(
      node.astExpr || this.parseExpr(node.expr),
      this.visit(node.block, node)
    );
    return [stmt];
  }
1011430
function findToken(node, test) {
    let find = null
    traverse(node, {
        enter(child) {
            if (test(child)) {
                find = child
                this.break()
            }
        },
    })
    return find
}
140242
function(node) {
			var classes,
				out = [],
				obj,
				itemRootID;

			// loop roots found on one element
			classes = this.getUfClassNames(node);
			if(classes && classes.root.length && classes.root.length > 0){

				this.rootID++;
				itemRootID = this.rootID;
				obj = this.createUfObject(classes.root, classes.typeVersion);

				this.walkChildren(node, obj, classes.root, itemRootID, classes);
				if(this.impliedRules){
					this.impliedRules(node, obj, classes);
				}

				if(this.options.lang === true){
					var lang = modules.domUtils.getFirstAncestorAttribute(node, 'lang');
					if(lang){
						obj.lang = lang;
					}
				}
				out.push( this.cleanUfObject(obj) );


			}
			return out;
		}
672062
function traverseDOM($node, d = document) {
  $node = _doc.ensureDoc.bind(cx)($node);
  return _rxjs.Observable.create($o => {
    $node.subscribe({
      next(vnode) {
        const t = d.createTreeWalker(vnode.node);
        const closers = new WeakMap();

        const isBranch = n => n.nodeType == 1 || n.nodeType == 9 || n.nodeType == 10 || n.nodeType == 11;

        const emitNode = n => {
          $o.next(new _vnode.VNode(cx, n, n.nodeType, n.nodeName, n.nodeType == 2 ? n.nodeName : null, n.textContent, n.parentNode));
        };

        const close = n => {
          $o.next(new _vnode.Close(n));

          if (closers.has(n)) {
            const parent = closers.get(n);
            closers.delete(n);
            close(parent);
          }
        };

        emitNode(t.currentNode);

        while (t.nextNode()) {
          const n = t.currentNode;
          emitNode(n); // if the node is a leaf or an empty branch, close its parent
          // else the node itself should close first
          // so don't close the parent yet, but move it to the closers map
          // and close it after this node closes

          let parent = n.parentNode;

          if (parent && parent.lastChild == n) {
            if (isBranch(n)) {
              if (!n.childNodes.length) {
                close(n);
                close(parent);
              } else {
                closers.set(n, parent);
              }
            } else {
              close(parent);
            }
          }
        }
      },

      complete() {
        $o.complete();
      },

      error(err) {
        $o.error(err);
      }

    });
  });
}
286294
function(node){
    var test = null;
    if ('default' != node.expr) {
      test = node.astExpr || this.parseExpr(node.expr);
    }
    var consequent = []
    if (node.block) {
      consequent = this.visit(node.block, node);
      consequent.push(t.breakStatement());
    }
    var c = t.switchCase(test, consequent);
    return [c];
  }
378540
function Node(grammar, ctorName, matchLength) {
  this.grammar = grammar;
  this.ctorName = ctorName;
  this.matchLength = matchLength;
}
965289
function(node) {
        this.node = node = $(node);

        var element = this.loadElement(node);

        this.fireEvent('showing', [element, node]);

        element.reveal();

        node
            .aria('toggled', true)
            .addClass('is-active');

        this.fireEvent('shown', [element, node]);
    }
342434
function(node, className) {
        var re = Y.DOM._getRegExp('(?:^|\\s+)' + className + '(?:\\s+|$)');
        return re.test(node.className);
    }
264162
function visit(node, context, visitor) {
	if (node === null || node === undefined) {
		return null;
	}

	if (Array.isArray(visitor)) {
		return visitor
			.reduce((n, v) => {
				const newNode = visit(n, context, v);
				return newNode;
			}, node);
	}

	const method = visitor[node.type];
	if (typeof method === 'function') {
		return method.apply(null, [node].concat(context));
	}

	const defaultMethod = visitor.defaultMethod;
	if (typeof defaultMethod === 'function') {
		return defaultMethod.apply(null, [node].concat(context));
	}

	return node;
}
233712
static <K extends Comparable<K>> void checkNode(Node<K> node) {
        node.checkNode(null, null);
    }
889293
@Override
  public boolean visit(final JavaInstance<?> node) {
    this.graphStr
        .append("  \"")
        .append(node.getClass())
        .append('_')
        .append(node.getNode().getName())
        .append("\" [label=\"")
        .append(node.getNode().getName())
        .append(" = ")
        .append(node.getInstanceAsString())
        .append("\", shape=box, style=bold];\n");
    return true;
  }
4801
protected void visitChildren(ParentNode<? extends N> node) {
    List<? extends N> children = node.getChildren();
    int size = children.size();
    for (int i = 0; i < size; i++) {
      visit(children.get(i));
    }
  }
375193
function(node) {
		var hasNodes = false;

		if (node.hasChildNodes()) {
			for (var i = 0, len = node.childNodes.length; i < len; i++) {
				if (node.childNodes[i].nodeType === 1) {
					hasNodes = true;
					break;
				}
			}
		}

		return hasNodes;
	}
3108
function(node) {
            node = Y.Dom.get(node);
            if (!node) {
            }

            return Y.Dom.getChildrenBy(node);
        }
4432
function report(node) {
            context.report({ node, messageId: "unexpected", data: { operator: node.operator } });
        }
17466
function( node ){
			var out = '',
				j = 0;

			// we do not want the outer container
			if(node.childNodes && node.childNodes.length > 0){
				for (j = 0; j < node.childNodes.length; j++) {
					var text = this.walkTreeForHtml( node.childNodes[j] );
					if(text !== undefined){
						out += text;
					}
				}
			}

			return out;
		}
630878
function validateNode(node) {
            const parens = getParenTokens(node);

            if (parens) {
                validateParens(parens, astUtils.isFunction(node) ? node.params : node.arguments);

                if (multilineArgumentsOption) {
                    validateArguments(parens, astUtils.isFunction(node) ? node.params : node.arguments);
                }
            }
        }