Gets the instance name from a DOM element.

@param {Node} element - The DOM element.

@return {string} The instance name.

@alias module:requiem~helpers.getInstanceNameFromElement
769669
function getInstanceNameFromElement(element) {
  let nameFromName = getAttribute(element, 'name');

  if (nameFromName !== null && nameFromName !== undefined && nameFromName !== '')
    return nameFromName;
  else
    return null;
}
906968
public static String getClass(String element) {
        Preconditions.checkNotNull(element,"argument 'element' can not be null");
        return element.substring(element.lastIndexOf('.') + 1);
    }
1374205
function getElementTag(node) {
        if (node.openingElement && t.isJSXIdentifier(node.openingElement.name)) {
            return node.openingElement.name.name;
        } else {
            error(node.openingElement, "Unable to parse opening tag.");
        }
    }
1339521
def get_element_id(element):
        
        id_attrib_key = add_ns('id')
        if id_attrib_key in element.attrib:
            return element.attrib[id_attrib_key]
        try:
            return element.getparent().attrib[id_attrib_key]
        except KeyError as e:
            raise KeyError(
                'Neither the element "{0}" nor its parent "{1}" '
                'have an ID'.format(element, element.getparent()))
447502
function getTag(dom) {
  return dom.tagName && __TAG_IMPL[getAttr(dom, IS_DIRECTIVE) ||
    getAttr(dom, IS_DIRECTIVE) || dom.tagName.toLowerCase()]
}
1308258
public static String getSimpleName(Element element) {
		if (element.getKind() != ElementKind.CLASS) {
			throw new IllegalStateException();
		}
		String str = element.asType().toString();
		int i = str.lastIndexOf(".");
		return str.substring(i + 1);
	}
140416
function getStyle(element) {
    const style = element.style;
    const styles = {};
    for (let i = 0; i < style.length; i++) {
        const name = style.item(i);
        const transformedName = transformName(name);
        styles[transformedName] = style.getPropertyValue(name);
    }
    return styles;
}
1165324
function getInstanceFromNode(node) {
  var inst = getClosestInstanceFromNode(node);
  if (inst != null && inst._hostNode === node) {
    return inst;
  } else {
    return null;
  }
}
28944
function findByNodeName(el, nodeName) {
  if (!el.prop) { // not a jQuery or jqLite object -> wrap it
    el = angular.element(el)
  }

  if (el.prop('nodeName') === nodeName.toUpperCase()) {
    return el
  }

  const c = el.children()
  for (let i = 0; c && i < c.length; i++) {
    const node = findByNodeName(c[i], nodeName)
    if (node) {
      return node
    }
  }
}
435663
function getNearestTypeElement(element) {
		var found = false;
		var moduleBoundaryReached = false;

		// We need to check for the existence of 'element' since occasionally we call this on a detached element node.
		// For example:
		//  1. event handlers like mouseout may sometimes detach nodes from the DOM
		//  2. event handlers like mouseleave will still fire on the detached node
		// Checking existence of element.parentNode ensures the element is a valid HTML Element
		while (!found && element && element.parentNode && !moduleBoundaryReached) {
			found = isTypeElement(element);
			moduleBoundaryReached = isModuleElement(element);

			if (!found) {
				element = element.parentNode;
			}

		}

		return found ? element : null;
	}
432799
int getObjectID(Object element) {
        if (element == null) return NULL;
        else if (Cell.class.isInstance(element)) return CELL;
        else if (Table.class.isInstance(element)) return TABLE; 
        return -1;
    }
953714
public Node getNamedItem(String name)
  {

    for (int n = dtm.getFirstAttribute(element); n != DTM.NULL;
            n = dtm.getNextAttribute(n))
    {
      if (dtm.getNodeName(n).equals(name))
        return dtm.getNode(n);
    }

    return null;
  }
4301
private TypeMirror getTypeFromDOMElement(Element element) {
    return DOMElementsUtil
        .getTypeForElementTag(element.getStartTag().getName())
        .map(Class::getCanonicalName)
        .map(elements::getTypeElement)
        .map(TypeElement::asType)
        .orElse(null);
  }
379991
public static String getAnnotationTableName(AnnotatedElement element) {
        String result = "";
        result = DatabaseTableConfig.extractTableName((Class<?>) element);
        return result;
    }
698594
public static String getNameForNew(Element element) {
		if (element.getKind() != ElementKind.CLASS) {
			throw new IllegalStateException();
		}
		return getNameForNew("", element);
	}
38566
function isInstance(node) {
  if (node.type === 'Identifier') {
    if (currentOptions.angular) {
      if (instanceVarsRegExp.angular.test(node.name)) {
        return true;
      }
    } else {
      if (instanceVarsRegExp.noangular.test(node.name)) {
        return true;
      }
    }
  }
  if (node.type === 'CallExpression') {
    if (isConstructor(node.callee)) {
      return true;
    }
    if (node.callee.type === 'MemberExpression') {
      if (isInstance(node.callee.object)) {
        if (node.callee.property.type === 'Identifier' &&
            constants.METHODS.CHAIN.indexOf(node.callee.property.name) !== -1) {
          return true;
        }
      }
    }
  }
  return false;
}
579763
function ( className ) {
            var el = this.element(),
                cName = $B( el ).attr( 'class' ),
                find = $B.array.is(className)? className : Array.prototype.slice.call(arguments);
    
            return cName? $B.string.isWholeWord( cName, find ) : false;
        }