Returns whether the given ES6 class extends something.
491272
private boolean hasSuperclass(Name es6Class) {
    Node decl = es6Class.getDeclaration().getNode();
    Node classNode = NodeUtil.getRValueOfLValue(decl);
    checkState(classNode.isClass(), classNode);
    Node superclass = classNode.getSecondChild();

    return !superclass.isEmpty();
  }
1085623
static boolean isAliasedConstDefinition(Node lhs) {
    JSDocInfo jsdoc = getBestJSDocInfo(lhs);
    if (jsdoc == null && !lhs.isFromExterns()) {
      return false;
    }
    if (jsdoc != null && !jsdoc.hasConstAnnotation()) {
      return false;
    }
    Node rhs = getRValueOfLValue(lhs);
    if (rhs == null || !rhs.isQualifiedName()) {
      return false;
    }
    Node parent = lhs.getParent();
    return (lhs.isName() && parent.isVar())
        || (lhs.isGetProp() && lhs.isQualifiedName()
            && parent.isAssign() && parent.getParent().isExprResult());
  }
850348
function hasElClass(element, classToCheck) {
  throwIfWhitespace(classToCheck);
  if (element.classList) {
    return element.classList.contains(classToCheck);
  }
  return classRegExp(classToCheck).test(element.className);
}
1313680
function isExtendOf(name, variable) {
		var offset = typeof variable === 'object' && variable ? Object.getPrototypeOf(variable) : null,
			pattern = offset ? new RegExp('^' + name + '$') : null;

		//  It is not quite feasible to compare the inheritance using `instanceof` (all constructors would have to
		//  be registered somehow then) we simply compare the constructor function names.
		//  As a side effect, this enables polymorphic to compare against the exact type (unless a developer has
		//  altered the constructor name, which is not protected from overwriting)
		while (offset && offset.constructor) {
			if (pattern.test(offset.constructor.name)) {
				return true;
			}

			offset = Object.getPrototypeOf(offset);
		}

		return false;
	}
226217
function isClass(clazz) {
    return isFunction(clazz) && (clazz.prototype && clazz === clazz.prototype.constructor);
  }
192866
@Nullable
  private static Node getSubclassForEs6Superclass(Node superclass) {
    Node classNode = superclass.getParent();
    checkArgument(classNode.isClass(), classNode);
    if (NodeUtil.isNameDeclaration(classNode.getGrandparent())) {
      // const Clazz = class extends Super {
      return classNode.getParent();
    } else if (superclass.getGrandparent().isAssign()) {
      // ns.foo.Clazz = class extends Super {
      return classNode.getPrevious();
    } else if (NodeUtil.isClassDeclaration(classNode)) {
      // class Clazz extends Super {
      return classNode.getFirstChild();
    }
    return null;
  }
914466
function(el, cls) {
      var elClass = el.className;
      var elClassList = elClass.split(/\s+/);
      var x = 0;
      for(x in elClassList) {
        if(elClassList[x] == cls) {
          return true;
        }
      }
      return false;
    }
215650
function checkTypes(classes) {
    var classCount = 0, nullType = 0, nullOf = 0, propCount = 0;
    for (var classKey in classes) {
        ++classCount;
        for (var definePropertyKey in classes[classKey].amorphicProperties) {
            var defineProperty = classes[classKey].amorphicProperties[definePropertyKey];
            if (!defineProperty.type) {
                ++nullType;
                console.log('Warning: ' + classKey + '.' + definePropertyKey + ' has no type');
            }
            if (defineProperty instanceof Array && !defineProperty.of) {
                console.log('Warning: ' + classKey + '.' + definePropertyKey + ' has no of');
                ++nullOf
            }
            ++propCount;
        }
    }
    console.log(classCount + ' classes loaded with ' + propCount + ' properties (' + nullType + ' null types, ' + nullOf + ' null ofs)');
}
609996
function hasClass(className) {
  var i, val;
  for(i = 0;i < this.length;i++) {
    val = this.get(i).getAttribute(attr);
    val = val ? val.split(/\s+/) : [];
    if(~val.indexOf(className)) {
      return true;
    }
  }
  return false;
}
871315
function hasClass(element, className) {
    !!/\s/.test(className) ? "development" !== 'production' ? invariant(false, 'CSS.hasClass takes only a single class name.') : invariant(false) : void 0;
    if (element.classList) {
      return !!className && element.classList.contains(className);
    }
    return (' ' + element.className + ' ').indexOf(' ' + className + ' ') > -1;
  }
758626
function isClassConstructor(node) {
    return node.type === "FunctionExpression" &&
        node.parent &&
        node.parent.type === "MethodDefinition" &&
        node.parent.kind === "constructor";
}
989062
function isPropTypesDeclaration(context, node) {
  // Special case for class properties
  // (babel-eslint does not expose property name so we have to rely on tokens)
  if (node.type === 'ClassProperty') {
    const tokens = context.getFirstTokens(node, 2);
    if (isTypesDecl(tokens[0].value) || isTypesDecl(tokens[1].value)) {
      return true;
    }
    return false;
  }

  return Boolean(node && isTypesDecl(node.name));
}
236513
function(name) {
        if (!this.has(name)) return false;

        var eClass = this.eClass;
        if (!eClass) return false;

        var value = this.get(name);
        if (value instanceof EList) {
            return value.size() > 0;
        } else {
            return value !== null && typeof value !== 'undefined';
        }
    }
1358631
function (node) {
      if (node.superClass) {
        return new RegExp('^(' + pragma + '\\.)?PureComponent$').test(sourceCode.getText(node.superClass));
      }
      return false;
    }
887268
function checkClass(i) {
  let l;

  if (i >= tokensLength) return 0;

  if (tokens[i].class_l) return tokens[i].class_l;

  if (tokens[i++].type === TokenType.FullStop) {
    if (l = checkInterpolatedVariable(i)) tokens[i].class_child = 1;
    else if (l = checkIdent(i)) tokens[i].class_child = 2;
    else return 0;

    tokens[i].class_l = l + 1;
    return l + 1;
  }

  return 0;
}
686279
function(node) {
      if (utils.isExplicitComponent(node)) {
        return true;
      }

      if (!node.superClass) {
        return false;
      }
      return new RegExp('^(' + pragma + '\\.)?(Pure)?Component$').test(sourceCode.getText(node.superClass));
    }
359897
protected function extendsAbstractPlugin(AbstractNode $node): bool
    {
        if (!($this instanceof ClassAware)) {
            return false;
        }

        $parentClass = $this->getAstClass($node)->getParentClass();

        if (!($parentClass instanceof ASTClass)) {
            return false;
        }

        if ($parentClass->getName() === static::EXTENDS_CLASS_NAME) {
            return true;
        }

        return false;
    }