/*
Strips the first decoration from the decorated object. If the object is not decorated the method
returns the object itself.
18510
public static Object stripShallow(Object decorated) {
        try {
            InjectableProperty delegateProperty = new ConfigClassAnalyzer(decorated.getClass()).getDelegateProperty();
            if (delegateProperty == null) {
                return decorated;
            } else {
                return delegateProperty.getValue(decorated);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
1147134
private E unlinkFirst() {
        // assert lock.isHeldByCurrentThread();
        Node<E> f = first;
        if (f == null)
            return null;
        Node<E> n = f.next;
        E item = f.item;
        f.item = null;
        f.next = f; // help GC
        first = n;
        if (n == null)
            last = null;
        else
            n.prev = null;
        --count;
        notFull.signal();
        return item;
    }
263022
function(node) {
    var classesToPreserve = this._classesToPreserve;
    var className = (node.getAttribute("class") || "")
      .split(/\s+/)
      .filter(function(cls) {
        return classesToPreserve.indexOf(cls) != -1;
      })
      .join(" ");

    if (className) {
      node.setAttribute("class", className);
    } else {
      node.removeAttribute("class");
    }

    for (node = node.firstElementChild; node; node = node.nextElementSibling) {
      this._cleanClasses(node);
    }
  }
771416
function removeBrackets(type, nullOrUndefinedOnly) {
  if(typeof nullOrUndefinedOnly === "undefined") {
    nullOrUndefinedOnly = false;
  }
  if (typeof type === 'object') {
    return 'object';
  }
  else if(type.replace(/ /g, '') !== type) {
    return removeBrackets(type.replace(/ /g, ''));
  }
  else if(type.indexOf('null|') === 0) {
    return removeBrackets(type.substr('null|'.length));
  }
  else if(type.indexOf('undefined|') === 0) {
    // Not used currently, but robust code is better code :)
    return removeBrackets(type.substr('undefined|'.length));
  }
  if (type == null || type.length === 0 || nullOrUndefinedOnly) {
    return type;
  }
  var pos = type.indexOf('Array<');
  if (pos >= 0) {
    var start = 'Array<'.length;
    return type.substr(start, type.length - start - 1);
  }
  pos = type.indexOf('[');
  return pos >= 0 ? type.substr(0, pos) : type;
}
980398
function removeObject (obj, iterate, context) {
  if (obj) {
    if (arguments.length > 1) {
      var removeKeys = []
      var rest = []
      context = context || this
      if (!isFunction(iterate)) {
        iterate = pluckProperty(iterate)
      }
      each(obj, function (item, index, rest) {
        if (iterate.call(context, item, index, rest)) {
          removeKeys.push(index)
        }
      })
      if (isArray(obj)) {
        lastEach(removeKeys, function (item, key) {
          rest.push(obj[item])
          obj.splice(item, 1)
        })
      } else {
        rest = {}
        arrayEach(removeKeys, function (key) {
          rest[key] = obj[key]
          deleteProperty(obj, key)
        })
      }
      return rest
    }
    return clearObject(obj)
  }
  return obj
}
491122
public E removeFirst() {
    E first = getFirst();
    swap(0, size - 1);
    size--;
    elements.remove(size);
    heapifyDown(0);
    return first;
  }
577429
function exclude (object, excludedProperties) {
  const strippedObject = Object.assign({}, object)

  excludedProperties.forEach(excludedProperty => {
    delete strippedObject[excludedProperty]
  })

  return strippedObject
}
428227
def unwrap_obj(obj):
    
    try:
        obj = obj.fget
    except (AttributeError, TypeError):
        pass
    try:
        # Cached properties
        if obj.func.__doc__ == obj.__doc__:
            obj = obj.func
    except AttributeError:
        pass
    try:
        # Setter/Getters
        obj = obj.getter
    except AttributeError:
        pass
    try:
        # Wrapped Funcs
        obj = inspect.unwrap(obj)
    except:
        pass
    return obj
166696
function () {
        // we unlink every member from it's parent (assuming this is their parent)
        this.all().forEach(PropertyList._unlinkItemFromParent);

        this.members.length = 0; // remove all items from list

        // now we remove all items from index reference
        Object.keys(this.reference).forEach(function (key) {
            delete this.reference[key];
        }.bind(this));
    }
1007318
function clean(obj) {
  var ret = {};

  // Remove traits/properties that are already represented
  // outside of the data container
  // TODO: Refactor into `omit` call
  var excludeKeys = ['id', 'name', 'firstName', 'lastName'];
  each(excludeKeys, function(omitKey) {
    clear(obj, omitKey);
  });

  // Flatten nested hierarchy, preserving arrays
  obj = flatten(obj);

  // Discard nulls, represent arrays as comma-separated strings
  // FIXME: This also discards `undefined`s. Is that OK?
  for (var key in obj) {
    if (has.call(obj, key)) {
      var val = obj[key];
      if (val == null) {
        continue;
      }

      if (is.array(val)) {
        ret[key] = val.toString();
        continue;
      }

      ret[key] = val;
    }
  }

  return ret;
}
610325
function(object, method) {
       if (method) {
         if (object['__prototype__' + method])
           delete object[method]
         else
           object[method] = object['__original__' + method]
         delete object['__prototype__' + method]
         delete object['__original____' + method]
       }
       else if (object) {
         for (var key in object)
           if (captures = key.match(/^(?:__prototype__|__original__)(.*)/))
             destub(object, captures[1])
       }
       else
         while (JSpec.stubbed.length)
            destub(JSpec.stubbed.shift())
     }
1010960
function removeFirstNot(arr, obj, config) {
    var fn = _createIteratorNotFn(obj, config);
    return _removeFirst(arr, fn);
}
428863
function clearOwnProperties(obj) {
  _.forOwn(obj, function (value, key) {
    delete obj[key];
  });

  return obj;
}
1370244
function (obj) {
            var index;
            if (this.__freeObjects.contains(obj)) {
                this.__freeObjects.remove(obj);
            } else if ((index = this.__inUseObjects.indexOf(obj)) > -1) {
                this.__inUseObjects.splice(index, 1);
            }
            //otherwise its not contained in this pool;
            return obj;
        }
588466
public function removeFirst(): self
    {
        $tmpArray = $this->getArray();

        \array_shift($tmpArray);

        return static::create(
            $tmpArray,
            $this->iteratorClass,
            false
        );
    }
839872
private @Nullable String stripDefault(List<OptionElement> options) {
    String result = null;
    for (Iterator<OptionElement> i = options.iterator(); i.hasNext();) {
      OptionElement option = i.next();
      if (option.getName().equals("default")) {
        i.remove();
        result = String.valueOf(option.getValue()); // Defaults aren't options!
      }
    }
    return result;
  }
415542
function strip(start, end) {
        const before = template.slice(0, start)
        const target = template.slice(start, end)
        const after = template.slice(end)
        template = before + target.replace(/\S/gu, " ") + after
        stripedRanges.push([start, end])
    }