Checks if `value` is likely a prototype object.

@private
@param {*} value The value to check.
@returns {boolean} Returns `true` if `value` is a prototype, else `false`.
348451
function isPrototype(value) {
  var Ctor = value && value.constructor,
      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$9;

  return value === proto;
}
282563
function hasProperty(value, prop) {
    return (value && typeof value === 'object' && prop in value) ||
        value !== null && value !== undefined && value[prop] !== undefined;
}
324770
public static boolean isPrimitive(final Object value)
	{
		return (value == null ||
		        value instanceof String ||
		        value instanceof Number ||
		        value instanceof Boolean ||
		        value instanceof DateTime ||
		        value instanceof Date ||
		        value instanceof SampleCount ||
		        value instanceof Timecode ||
		        value.getClass().isEnum() ||
		        value.getClass().isPrimitive());
	}
849786
public static function isValueType($value)
    {
        if (is_scalar($value) || $value === null) {
            return true;
        } elseif (is_array($value)) {
            $isScalar = true;
            array_walk_recursive($value,
                    function ($value) use (&$isScalar) {
                        if ($isScalar && !(is_scalar($value) || $value === null)) {
                            $isScalar = false;
                        }
                    });

            return $isScalar;
        } else {
            return false;
        }
    }
1141148
public boolean containsValue(Object value) {
        Node<K,V>[] tab; V v;
        if ((tab = table) != null && size > 0) {
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                    if ((v = e.value) == value ||
                        (value != null && value.equals(v)))
                        return true;
                }
            }
        }
        return false;
    }
544467
boolean casValue(Object cmp, Object val) {
            return U.compareAndSwapObject(this, VALUE, cmp, val);
        }
1165775
function typeOf (value) {
  if (value === null) return 'null'
  var valueType = typeof value
  if (valueType === 'object') {
    valueType = value.constructor.name.toLowerCase()
  }
  return valueType
}
632617
function(value) {
		if (Array.isArray && Array.isArray(value)) {
			return true;
		}
		var type = Object.prototype.toString.call(value);
		if (type.substr(0, 7) === '[object' && type.substr(-6) === 'Array]') {
			return true;
		}
		return false;
	}
1174304
function typeOf(value) {
  var returned = Object.prototype.toString.call(value);
  return returned.substring(1, returned.length - 1).split(' ')[1].toLowerCase();
}
646811
function isPrototype(value) {
  var Ctor = value && value.constructor,
      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$5;

  return value === proto;
}
141129
public static boolean isValidPropValue(Object value) {
        boolean isValid = false;

        if(value instanceof Boolean || value instanceof Integer || value instanceof Long
                || value instanceof Float || value instanceof Double || value instanceof String) {
            isValid = true;
        }

        return isValid;
    }
887794
function isPrototype(value) {
  var Ctor = value && value.constructor,
      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$11;

  return value === proto;
}
103840
public boolean containsValue(Object value) {
        Entry tab[] = mTable;
        
        if (value == null) {
            for (int i = tab.length ; i-- > 0 ;) {
                for (Entry e = tab[i], prev = null; e != null; e = e.mNext) {
                    if (e.getKey() == null) {
                        // Clean up after a cleared Reference.
                        mModCount++;
                        if (prev != null) {
                            prev.mNext = e.mNext;
                        }
                        else {
                            tab[i] = e.mNext;
                        }
                        mCount--;
                    }
                    else if (e.mValue == null) {
                        return true;
                    }
                    else {
                        prev = e;
                    }
                }
            }
        }
        else {
            for (int i = tab.length ; i-- > 0 ;) {
                for (Entry e = tab[i], prev = null; e != null; e = e.mNext) {
                    if (e.getKey() == null) {
                        // Clean up after a cleared Reference.
                        mModCount++;
                        if (prev != null) {
                            prev.mNext = e.mNext;
                        }
                        else {
                            tab[i] = e.mNext;
                        }
                        mCount--;
                    }
                    else if (value.equals(e.mValue)) {
                        return true;
                    }
                    else {
                        prev = e;
                    }
                }
            }
        }

        return false;
    }
978984
function inferDtype(value) {
  return (
    (value === null || isUndefined(value)) ? null :
    isNumber(value) ? 'number' :
    isBoolean(value) ? 'boolean' :
    isString(value) ? 'string' :
    isDate(value) ? 'date' :
    'object'
  );
}
853289
public boolean containsValue(Object value) {
		// the value is a direct hit from our cache
		if(cache.containsValue(value))
			return true;
		// the value is a direct hit from our hashmap
		if(container.containsValue(value))
			return true;
		
		// otherwise, the value isn't within this object
		return false;
	}
87985
public function isAssignableFromValue($value)
    {
        if (!is_object($value))
            return false;

        if (get_class($value) === $this->getName())
            return true;

        return is_subclass_of($value, $this->className);
    }
343417
function(value, inferredType) {
      if (inferredType === 'boolean') {
        return value ? '' : undefined;
      } else if (inferredType !== 'object' && inferredType !== 'function'
          && value !== undefined) {
        return value;
      }
    }