ES 5+ will handle null and undefined
181540
function Buffering(options) {
    events.EventEmitter.call(this);

    options = options || {};

    if (options.useUnique) {
        var newOptions = {};
        Object.keys(options).forEach(function(key) {
            if (key != 'useUnique') newOptions[key] = options[key];
        });
        return new UniqueBuffering(newOptions);
    }

    this._timeThreshold = (typeof options.timeThreshold === 'undefined') ? -1 : options.timeThreshold;
    this._sizeThreshold = (typeof options.sizeThreshold === 'undefined') ? -1 : options.sizeThreshold;
    this._data = [];
    this._flushTimer = null;
    this._paused = false;
    this._resumeTimer = null;
    this._flushingBySize = false;
}
740621
function _checkResult(type, err, obj, options)
{
    if (options) {
        if (options.logger) logger.logger(options.logger, 'parse:', type, options, lib.traceError(err), obj);
        if (options.datatype == "object" || options.datatype == "obj") return {};
        if (options.datatype == "list") return [];
        if (options.datatype == "str") return "";
    }
    return null;
}
603239
function (v) {
                            return ((v === undefined) ||
                                    (v === null) ||
                                    (v === Math.NaN) ||
                                    (v === '') ||
                                    (_.isPOD (v) &&
                                        (_.isEmptyObject (v) ||
                                        (v.length === 0)))) ? undefined : v }
14552
function parseIntValue(value, description) {
        if (description === void 0) { description = "integer"; }
        if (angular.isString(value)) {
            try {
                return parseInt(value);
            }
            catch (e) {
                console.log("Failed to parse " + description + " with text '" + value + "'");
            }
        }
        else if (angular.isNumber(value)) {
            return value;
        }
        return null;
    }
1286731
function(x) {
  return _.isUndefined(x) || _.isNull(x) || _.isNaN(x);
}
202377
function isEmpty(val) {
  return _.isNull(val) || _.isUndefined(val) || _.isNaN(val) || helper.isBlank(val);
}
1369312
function valueIsNullForValidator(value, validatorName) {
  if (value === null || value === CONSTANT.NULL || typeof value === 'undefined') {
    return true;
  }

  if (value === '' && VALIDATOR_CONSIDERS_EMPTY_STRING_NULL[validatorName]) {
    return true;
  }

  return false;
}
994356
function(items, handler, userData) {
			if (this.choiceCallback) {
				return this.choiceCallback.call(handler, items, userData);
			}
			return null;
		}
680963
function handleDeletions() {
	return es.mapSync(f => {
		if (/\.ts$/.test(f.relative) && !f.contents) {
			f.contents = Buffer.from('');
			f.stat = { mtime: new Date() };
		}

		return f;
	});
}
300784
function(val){
                            if (val === null) return 'null';
                            else if (val === undefined) return 'undefined';
                            else if (val.constructor === Array) return 'array';
                            else if (val.constructor === Object) return 'object';
                            else if (val.constructor === String) return 'string';
                            else if (val.constructor === Number) return 'number';
                            else if (val.constructor === Boolean) return 'boolean';
                            else if (val.constructor === Function) return 'function';
                            else return 'object'
                        }
971003
function(name) {
			var val = this.get(name);
			if (typeof val === 'undefined' || val === null || val === '')  {
				return null;
			}

			val = val.split(',').map(utils.trim);
			if (!val.length) {
				return null;
			}
			
			return val;
		}
817586
protected Object checkUndefined(Object val) {
        if (val instanceof String && ((String) val).equals("undefined")) {
            return null;
        }
        return val;
    }
214503
function(key, callback) {
		if (typeof data[key] == 'undefined') {
			callback && callback(null, null)
		} else if (typeof data[key] == 'string' || typeof data[key] == 'number' || typeof data[key] == 'boolean') {
			callback && callback(null, data[key])
		} else {
			callback && callback(typeError('getBytes', 'string or number', key))
		}
	}
21503
function(value) {

		var reason = null;

		if (typeof(value) == 'undefined') {

			reason = "Undefined is not a valid value";

		} else if (value == null && !this._is_nullable) {

			reason = "Cannot assign null to non-nullable field";

		}

		return reason;

	}
581803
function objectIsEmpty(obj) {
	if (obj === null || obj === undefined) return true;
	if (obj.isEmpty) return obj.isEmpty();
	for (let k in obj) {
		if (hasOwnProperty(obj, k)) return false;
	}
	return true;
}
114226
function handleError(e, done) {
    if(this.defaultValue) return done(null, this.defaultValue);
    if(this[defaultError]) return done(this[defaultError]);
    done(e);
  }
36060
function(value) {
      return (angular.isUndefined(value) || value === null) || Object.keys(value).length === 0;
    }