Remove the element "el". If not set, will remove the last one
555832
function(el){
		if(!el)
			el = this.$el.last();
		else
			el = $(el);

		el.fadeOut(el.remove);
	}
11732
function removeChild(parEl, el) {
	var node = el._node;

	// already marked for removal
	if (node._dead) { return; }

	var res = deepNotifyRemove(node);

	if (res != null && isProm(res)) {
		node._dead = true;
		res.then(curry(_removeChild, [parEl, el, true]));
	}
	else
		{ _removeChild(parEl, el); }
}
103256
private void eraseValue(HeaderElement elem) {
        // wipe out the removed value
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Erasing existing header: " + elem.getName());
        }
        int next_index = this.lastCRLFBufferIndex;
        int next_pos = this.lastCRLFPosition;
        if (null != elem.nextSequence && !elem.nextSequence.wasAdded()) {
            next_index = elem.nextSequence.getLastCRLFBufferIndex();
            next_pos = elem.nextSequence.getLastCRLFPosition();
        }
        int start = elem.getLastCRLFPosition();
        // if it's only in one buffer, this for loop does nothing
        for (int x = elem.getLastCRLFBufferIndex(); x < next_index; x++) {
            // wiping out this buffer from start to limit
            this.parseBuffers[x].position(start);
            this.parseBuffers[x].limit(start);
            start = 0;
        }
        // last buffer, scribble from start until next_pos
        scribbleWhiteSpace(this.parseBuffers[next_index], start, next_pos);
    }
466333
def delete_element(self, element):
        
        if element not in self.element_finder:
            raise ValueError("No such element in the priority queue.")
        entry = self.element_finder[element]
        entry[1] = self.INVALID
1114599
private void removeNodeFromList(RepairQueueNode el) {
    // the head case
    //
    if (null == el.prev) {
      if (null != el.next) {
        this.head = el.next;
        this.head.prev = null;
        el=null;
      }
      else {
        // can't happen? yep. if there is only one element exists...
        this.head = null;
      }
    }
    // the tail case
    //
    else if (null == el.next) {
      if (null != el.prev) {
        el.prev.next = null;
      }
      else {
        // can't happen?
        throw new RuntimeException("Unrecognized situation here...");
      }
    }
    // all others
    //
    else {
      el.prev.next = el.next;
      el.next.prev = el.prev;
    }

  }
1317166
def remove_element(self, e):
        
        
        if e.label is not None: self.elementdict.pop(e.label)
        self.elementlist.remove(e)
55254
function() {
    var elThead = this._elThead;
    if(elThead) {
        var elTable = elThead.parentNode;
        Ev.purgeElement(elThead, true);
        this._destroyColumnHelpers();
        elTable.removeChild(elThead);
        this._elThead = null;
    }
}
978140
private static void deleteElem(Scriptable target, long index) {
        int i = (int)index;
        if (i == index) { target.delete(i); }
        else { target.delete(Long.toString(index)); }
    }
475352
void removeElement(int element_handle) {
		if (m_b_store_duplicates)
			throw new GeometryException("invalid call");

		int quad_handle = get_quad_(element_handle);
		disconnect_element_handle_(element_handle);
		free_element_and_box_node_(element_handle);

		int q = quad_handle;

		while (q != -1) {
			set_sub_tree_element_count_(q, get_sub_tree_element_count_(q) - 1);
			int parent = get_parent_(q);

			if (get_sub_tree_element_count_(q) == 0) {
				assert (get_local_element_count_(q) == 0);

				if (q != m_root) {
					int quadrant = get_quadrant_(q);
					m_quad_tree_nodes.deleteElement(q);
					set_child_(parent, quadrant, -1);
				}
			}

			q = parent;
		}
	}
240432
function(el, val) {
                        if (val == null || val === "") {
                            el.removeAttribute("src");
                            return null;
                        } else {
                            el.setAttribute("src", val);
                            return val;
                        }
                    }
1228582
public T removeLast()
   {
      T element = elementData[--size];
      elementData[size] = null;
      return element;
   }
1201566
function(el, sub) {
    sub = normalize(sub);

    DOM.removeAllListeners(el);
    DOM.clearData(el);
    DOM.clean(el);

    //el.parentNode.replaceChild(sub, el);
    el.parentNode.insertBefore(sub, el);
    el.parentNode.removeChild(el);

    return sub; 
  }
444573
function () {
		var element = this.element,
			childNodes = element.childNodes,
			i = childNodes.length;

		while (i--) {
			element.removeChild(childNodes[i]);
		}
	}
1352687
protected function removeOverNested( Node $el ) {
        if( $el->isTextNode() )
            return;
        else if( $el->beyondDefinitionLimit() )
        {
            $el->getParent()->removeChild( $el );
        }
        else
        {
            foreach( $el->getChildren() as $child )
                $this->removeOverNested($child);
        }
    }
299503
function() {
    var selectedCells = Dom.getElementsByClassName(DT.CLASS_SELECTED,"td",this._elTbody);
    Dom.removeClass(selectedCells, DT.CLASS_SELECTED);
}
907049
public void removeElementScoped(TreeElement elem, RemoveInfo removes)
    {
        assert(elem != null);

        // check to see if we can exist without processing this element.  If the element
        // didn't define any attribute then we can.  This is inforced in the addElement method.
        ArrayList attrs = elem.getAttributeList();
        if (attrs == null || attrs.size() == 0)
            return;

        // walk all of the lists and each list looking for attributes that
        // are scoped only to the element
        for (int i = 0; i < _lists.length; i++) {
            ArrayList al = _lists[i];
            assert(al != null);

            int cnt = al.size();
            for (int j = 0; j < cnt; j++) {
                TreeHtmlAttributeInfo attr = (TreeHtmlAttributeInfo) al.get(j);
                assert(attr != null);
                // Remove all of the attributes not scoped to the element itself.  We need to
                // update the indexes because this removes the current item..
                if (!attr.isApplyToDescendents()) {
                    al.remove(j);
                    cnt--;
                    j--;
                    if (removes != null && removes.scopeOverrides) {
                        TreeHtmlAttributeInfo addBack = checkScopeRemoval(i, attr, removes);
                        if (addBack != null) {
                            if (!al.contains(addBack))
                                al.add(addBack);
                        }
                    }
                }
            }
        }
    }
94370
function removeElements(collection, newCollection, index) {
        if (index === void 0) { index = 'id'; }
        var oldLength = collection.length;
        _.remove(collection, function (item) { return !_.some(newCollection, function (c) { return c[index] === item[index]; }); });
        return collection.length !== oldLength;
    }