return the identifiers which are a `memberof` this one. Exclude externals without descriptions.
@param [sortBy] {string} - "kind"
@param [min] {number} - only returns if there are `min` children
@this {identifier}
@returns {identifier[]}
@static
160711
function _children (options) {
  if (!this.id) return []
  var min = options.hash.min
  delete options.hash.min
  options.hash.memberof = this.id
  var output = _identifiers(options)
  output = output.filter(function (identifier) {
    if (identifier.kind === 'external') {
      return identifier.description && identifier.description.length > 0
    } else {
      return true
    }
  })
  if (output.length >= (min || 0)) return output
}
588364
function sortBy(array, attr) {
  assert(Array.isArray(array));
  return array.sort(function(a,b) {
    a = a[attr];
    b = b[attr];
    return (a < b) ? -1 : ((a > b) ? 1 : 0);
  });
}
1197574
function(obj) {
		const keys = Object.keys(obj).sort(function(key1, key2) {
			return key1 === 'id' ? false : key1 > key2;
		});
		return keys;
	}
235888
function sortChildren(parent, sortingFunction) {
  if (!parent.children) return;
  parent.children = new Map([...parent.children.entries()].sort(sortingFunction));
  for (var i = 0; i < parent.children.length; ++i)
    recalculateSiblings(parent.children[i], i);
  for (var child of parent.children.values())
    sortChildren(child, sortingFunction);
}
362068
function sortByName(child1, child2) {
            var ret = checkStatesFirst(child1, child2);
            if (ret) return ret;

            var o1 = objects[child1.key], o2 = objects[child2.key];
            if (o1 && o2) {
                var c1 = o1.common, c2 = o2.common;
                if (c1 && c2) {

                    // var s1 = child1.key.substr(0, child1.key.lastIndexOf('.')); // faster than regexp.
                    // var s2 = child2.key.substr(0, child2.key.lastIndexOf('.'));
                    // if (s1 > s2) return 1;
                    // if (s1 < s2) return -1;

                    if (!data.sortConfig.ignoreSortOrder && c1.sortOrder && c2.sortOrder) {
                        if (c1.sortOrder > c2.sortOrder) return 1;
                        if (c1.sortOrder < c2.sortOrder) return -1;
                        return 0;
                    }
                    var name1;
                    var name2;
                    if (c1.name) {
                        name1 = c1.name;
                        if (typeof name1 === 'object') {
                            name1 = (name1[systemLang] || name1.en).toLowerCase();
                        } else {
                            name1 = name1.toLowerCase();
                        }
                    } else {
                        name1 = child1.key;
                    }
                    if (c2.name) {
                        name2 = c2.name;
                        if (typeof name2 === 'object') {
                            name2 = (name2[systemLang] || name2.en).toLowerCase();
                        } else {
                            name2 = name2.toLowerCase();
                        }
                    } else {
                        name2 = child1.key;
                    }
                    if (name1 > name2) return 1;
                    if (name1 < name2) return -1;
                }
            }
            if (child1.key > child2.key) return 1;
            if (child1.key < child2.key) return -1;
            return 0;
        }
60557
function isHelperGroup(helpers) {
  if (!helpers) return false;
  if (typeof helpers === 'function' || isObject(helpers)) {
    var len = Object.keys(helpers).length;
    var min = helpers.async ? 1 : 0;
    return helpers.isGroup === true || len > min;
  }
  if (Array.isArray(helpers)) {
    return helpers.isGroup === true;
  }
  return false;
}
638894
function containsOnlyIdentifiers(node) {
            if (node.type === "Identifier") {
                return true;
            }

            if (node.type === "MemberExpression") {
                if (node.object.type === "Identifier") {
                    return true;
                }
                if (node.object.type === "MemberExpression") {
                    return containsOnlyIdentifiers(node.object);
                }
            }

            return false;
        }
923179
function countIdentifiers(parsedSelector) {
    switch (parsedSelector.type) {
        case "child":
        case "descendant":
        case "sibling":
        case "adjacent":
            return countIdentifiers(parsedSelector.left) + countIdentifiers(parsedSelector.right);

        case "compound":
        case "not":
        case "matches":
            return parsedSelector.selectors.reduce((sum, childSelector) => sum + countIdentifiers(childSelector), 0);

        case "identifier":
            return 1;

        default:
            return 0;
    }
}
1126978
def get_id2children(objs):
    """"""
    id2children = {}
    for obj in objs:
        _get_id2children(id2children, obj.item_id, obj)
    return id2children
398497
function classId(func) {
	var result = func['__id__'];
	if (result == null) {
		result = nonenum(func, '__id__', currentId++);
	}
	return result;
}
642716
def compact
      sort_by(&:length).each_with_object([]) do |c, result|
        result << c unless result.any? { |r| c.start_with?(r) }
      end.compact
    end
605618
def sortable
      [
        last,
        [
          prefix,
          first,
          middle,
          suffix
        ].reject( &:blank? ).
          join( ' ' )
      ].reject( &:blank? ).
        join( ', ' )
    end
1122124
function getComparator(sortOrder) {
  if (typeof sortOrder === 'function') {
    return sortOrder;
  }

  const comparators = {
    [ASC]: ascendingSort,
    [DESC]: descendingSort,
    [ASC_LENGTH]: lengthSort,
    [DESC_LENGTH]: lengthReverseSort
  };

  return comparators[sortOrder];
}
1019218
function(node, nodeType)
	{
		nodeType = nodeType || mxConstants.NODETYPE_ELEMENT;
		
		var children = [];
		var tmp = node.firstChild;
		
		while (tmp != null)
		{
			if (tmp.nodeType == nodeType)
			{
				children.push(tmp);
			}
			
			tmp = tmp.nextSibling;
		}
		
		return children;
	}
189949
def get_minimal_id(self):
        

        if not self.__response:
            raise TwitterSearchException(1013)

        return min(
            self.__response['content']['statuses'] if self.__order_is_search
            else self.__response['content'],
            key=lambda i: i['id']
            )['id'] - 1
554173
def IdentifiersIndexer(instance):
    
    identifiers = instance.Schema()['Identifiers'].get(instance)
    return [safe_unicode(i['Identifier']) for i in identifiers]
780657
def get_objects_or_children_by_type(self, *types):
        

        objects = self.get_objects_by_type(*types)
        return objects if objects else self.get_children(*types)