Remove from current all element find by property or method value.

@param string $method property or method
@param mixed $value the comparison value

@return $this a new collection with remove element
502718
public function removeFind(string $method, $value) : self
    {
        $list = $this->find($method, $value);
        foreach ($list as $element) {
            $this->removeInstance($element);
        }

        return $list;
    }
1045711
function(element, value) {
	if(element){
		if(typeof element.classList === 'undefined') {
			if(u._removeClass){
				u._removeClass(element, value);
			}else{
				$(element).removeClass(value);
			}

		} else {
			element.classList.remove(value);
		}
	}
	return this;
}
470105
public function removeTransactionMethod($method)
    {
        // if it's not an array, there are no transaction methods
        if (!is_array($this->transactionMethods)) {
            return $this;
        }
        
        // find method in transactionMethods
        $index = array_search($method, $this->transactionMethods);
        
        // remove the method if it exists in array
        if ($index !== false) {
            array_splice($this->transactionMethods, $index, 1);
        }


        // if transaction methods are empty set them to null
        if (empty($this->transactionMethods)) {
            $this->transactionMethods = null;
        }

        return $this;
    }
280902
public function methodsContains($method) {
        if (is_string($method)) {
            $method = array($method);
        }
        $this->rule = "contains";
        $this->method = $method;
        return $this;
    }
385767
public function removeByName($methodName)
    {
        $removedList = new self();
        $list = $this->getIterator();
        foreach ($list as $index => $method) {
            if ((is_array($methodName) && in_array($method->getName(), $methodName))
                || ($method->getName() === $methodName)
            ) {
                $removedList->add($method);
                $this->remove($index);
            }
        }

        return $removedList;
    }
135090
public function from($values): self
    {
        if (!empty($values)) {
            $this->properties['from'] = collect($values)->map(function ($value) {
                return trim($value);
            })->all();
        }

        return $this;
    }
774357
public static function runAll($value)
    {
        foreach (get_class_methods(__CLASS__) as $method) {

            if (strpos($method, 'run') === 0) {
                continue;
            }
            $value = self::$method($value);
        }

        return $value;
    }
505321
public function setMethod($method)
    {
        parent::setMethod($method);
        if ($method !== 'GET') {
            switch ($method) {
                case 'POST':
                    $this->setOption(CURLOPT_POST, true);
                    break;
                default:
                    $this->setOption(CURLOPT_CUSTOMREQUEST, $this->method);
                    break;
            }
        }

        return $this;
    }
402521
public function each($method)
    {
        foreach ($this as $rec) {
            if (is_string($method)) {
                $rec->$method();
            } elseif (is_callable($method)) {
                call_user_func($method, $rec);
            }
        }

        return $this;
    }
578781
public function setMethod($method) {
        if (!is_string($method))                 throw new IllegalTypeException('Illegal type of parameter $method: '.gettype($method));
        if ($method!=='GET' && $method!=='POST') throw new InvalidArgumentException('Invalid argument $method: '.$method);

        $this->method = $method;
        return $this;
    }
483563
public function method(string $method, string ...$methods): self
    {
        array_unshift($methods, $method);

        return $this->setAllowedMethods($methods);
    }
782213
public function addMethodMetadata($method, $index, $value)
    {
        if (!isset($this->methodMetadata[$method])) {
            $this->methodMetadata[$method] = array($index => $value);
        } else {
            $this->methodMetadata[$method][$index] = $value;
        }

        return $this;
    }
978286
public function decrementMemberCount($value){
        if(!is_integer($value)){
            return $this;
        }
        $new_value = $this->count_members - $value;
        if($new_value < 0){
            $new_value = 0;
        }
        $this->count_members = $new_value;
        return $this;
    }
178112
public function findObjectByMethod($method, $value, array $methodArgs = array()) {
        foreach ($this as $object) {
            if (method_exists($object, $method)) {
                if ($value === call_user_func_array(array($object, $method), $methodArgs))
                    return $object;
            }
        }
    }
1292589
public function removeAttributeValue(string $attribute, string $value): self
    {
        // Only remove value if attribute is present
        if (! array_key_exists($attribute, $this->attributes)) {
            return $this;
        }

        // Remove the value from the attribute
        $values = array_filter(
            $this->getAttribute($attribute),
            function ($attributeValue) use ($value) {
                return $attributeValue !== $value;
            }
        );

        // Stores the new values
        $this->setAttribute($attribute, $values);

        return $this;
    }
1097910
public function remove($value)
    {
        if ($this->hasNot($value)) {
            return;
        }

        $item = $this->get($value);

        $this->unset($value);

        return $item;
    }
1183490
public function remove($element) {
		$index = array_search($element, $this->collection, true);
		if ($index !== null) {
			unset($this->collection[$index]);
		}

		return $this;
	}