_copyResponseForDehydrate (res, {responseBodyOnly} = {}) {
		if (!res) return res;

		var resCopy = {};
		if (responseBodyOnly) {
			resCopy.body = res.body;
			return resCopy;
		}

		var parseable = !!responseBodyParsers[res.type];

		Object.keys(res).forEach( (prop) => {
			if ("body" === prop && parseable) {
				// don't copy body if it's a well-known (easily-parsed) content-type
				resCopy._hasBody = true;
			} else {
				if ("body" === prop) {
					// 'parseable' must be false. we should log a warning
					logger.warning(`ReactServerAgent needs responseBodyParser for content-type: ${res.type} to avoid duplicating data in cache body`);
				}
				resCopy[prop] = res[prop];
			}
		});
		return resCopy;
	}
_copyResponseForDehydrate attempts to construct a canonical form of the response object
that can be used later to reconstruct it. Its primary goal is to avoid duplication of
the response body in both the `.text` and `.body` properties of the cached response object.

There are several ways this could have been handled, but the purest way (as of right now)
from the standpoint of the API appears to be to provide parsing functions for known
response types (e.g., "application/json"). If the response content-type is known, we'll
simply serialize a placeholder (`_hasBody`) indicating that we should try to reparse the
body from the response text when rehydrating. If there is a parsed body on the response at
the time of dehydrating and we *don't* recognize the response type, we'll serialize both
`.text` and `.body`, paying a penalty in response size, but guaranteeing correctness.
(We'll also log a warning saying that we should probably add another response type).