check object is mepty
@param  {[Mixed]}  obj []
@return {Boolean}     []
194656
function isEmpty(obj) {
  if (isTrueEmpty(obj)) return true;
  if (exports.isRegExp(obj)) {
    return false;
  } else if (exports.isDate(obj)) {
    return false;
  } else if (exports.isError(obj)) {
    return false;
  } else if (exports.isArray(obj)) {
    return obj.length === 0;
  } else if (exports.isString(obj)) {
    return obj.length === 0;
  } else if (exports.isNumber(obj)) {
    return obj === 0;
  } else if (exports.isBoolean(obj)) {
    return !obj;
  } else if (exports.isObject(obj)) {
    for (const key in obj) {
      return false && key; // only for eslint
    }
    return true;
  }
  return false;
}
587435
function getFlagArrayFromObject(obj) {
  return Object.keys(obj).reduce((arr, key) => {
    const flag = `--${key.toLowerCase()}`;
    if (key === 'noUpdateNotifier' && typeof obj[key] === 'boolean') {
      return obj[key] ? [...arr, '--no-update-notifier'] : arr;
    } else if (key === 'noIgnore' && typeof obj[key] === 'boolean') {
      return obj[key] ? [...arr, '--no-ignore'] : arr;
    } else if (typeof obj[key] === 'boolean') {
      return obj[key] ? [...arr, flag] : arr;
    } else if (key === 'ignoredFile') {
      return [...arr, '--ignored-file', obj[key]];
    } else if (key === 'ignoredFiles') {
      const ignoredFiles = obj[key].reduce(
        (files, file) => [...files, '--ignored-file', file],
        []
      );
      return [...arr, ...ignoredFiles];
    } else if (key === 'files') {
      return [...arr, ...obj[key]];
    } else {
      return [...arr, flag, obj[key]];
    }
  }, []);
}
527142
def isempty(result):
	'''  '''

	if isinstance(result, list):
		for element in result:
			if isinstance(element, list):
				if not isempty(element):
					return False
			else:
				if element is not None:
					return False
	else:
		if result is not None:
			return False
	return True
1250173
function(obj) {
                if (obj.start && obj.end) { return this.contains(obj.start) && this.contains(obj.end); }
                var P = (obj.elements || obj).slice();
                if (P.length == 2) { P.push(0); }
                if (this.start.eql(P)) { return true; }
                var S = this.start.elements;
                var V = vector.create([S[0] - P[0], S[1] - P[1], S[2] - (P[2] || 0)]);
                var vect = this.toVector();
                return V.isAntiparallelTo(vect) && V.modulus() <= vect.modulus();
              }
488320
function isCyclic(obj) {
    let seenObjects = [];

    const detect = obj => {
        if (obj && typeof obj === "object") {
            if (seenObjects.includes(obj)) {
                return true;
            }

            seenObjects.push(obj);
            for (const key in obj) {
                if (obj.hasOwnProperty(key) && detect(obj[key])) {
                    return true;
                }
            }
        }

        return false;
    };

    return detect(obj);
}
284398
function isObjEmpty(obj) {
  for(var prop in obj) {
    if(obj.hasOwnProperty(prop))
      return false;
  }
  return JSON.stringify(obj) === JSON.stringify({});
}
919092
function(obj) {
            if (obj === null || obj === void 0)
                return false;

            return Object(obj) instanceof this || classOf(obj).linearizedTypes.lastIndexOf(this) != -1;
        }
49879
function isValueEmpty(value) {
  if (_.isUndefined(value)) {
    return true;
  }
  var canUseIsEmpty = _.isString(value) || _.isArray(value) || (_.isObject(value) && !_.isDate(value)) || false;
  if (canUseIsEmpty) {
    return _.isEmpty(value);
  }
  return (_.isNumber(value) || _.isBoolean(value) || _.isDate(value)) ? false : true;
}
170845
function isEmptyObj(object) {
    if(object === undefined)
        return true;

    var objToSend = JSON.parse(JSON.stringify(object));
    var result = nestedEmptyCheck(objToSend);
    if(JSON.stringify(result).indexOf('false') > -1)
        return false;
    return true;
}
639637
function empty(a) {
    var hasLength = typeof a === 'string' ||
      Array.isArray(a);
    if (hasLength) {
      return !a.length;
    }
    if (a instanceof Object) {
      return !Object.keys(a).length;
    }
    return false;
  }
159305
function cleanUndefinedProperties(obj) {
  var newObj;
  var isArray = false;
  if (typeof obj === 'object' && obj !== null) {
    if (Array.isArray(obj)) {
      newObj = [];
      isArray = true;
    } else {
      newObj = {};
    }
  } else {
    return obj;
  }
  var keys = Object.keys(obj);
  keys.forEach(function (key, i) {
    if (isArray || typeof obj[key] !== 'undefined') {
      newObj[key] = cleanUndefinedProperties(obj[key]);
    }
  });
  return newObj;
}
921643
function hasEmptyProperty(obj) {
  return Object.keys(obj)
    .map(key => obj[key])
    .every(
      keyObject =>
        typeof keyObject === 'object' &&
        Object.keys(keyObject).every(key => !(key in keyObject))
    );
}
842507
function isEmpty(object) {
    if (comb.isObject(object)) {
        for (var i in object) {
            if (object.hasOwnProperty(i)) {
                return false;
            }
        }
    }
    return true;
}
285818
public static boolean isObject( Object obj ) {
      return !isNumber( obj ) && !isString( obj ) && !isBoolean( obj ) && !isArray( obj )
            && !isFunction( obj ) || isNull( obj );
   }
1160437
function ( obj ) {
		return obj.nodeName === "FORM" ? false : string.isEmpty( obj.value || element.text( obj ) );
	}
537081
function(obj) {

        if (Array.isArray(obj)) {

            return {

                at: function(skip, pos) { return obj[pos] },
                rest: function(skip, pos) { return obj.slice(pos) }
            };
        }

        var iter = toObject(obj)[Symbol.iterator]();

        return {

            at: function(skip) {

                var r;

                while (skip--)
                    r = iter.next();

                return r.value;
            },

            rest: function(skip) {

                var a = [], r;

                while (--skip)
                    r = iter.next();

                while (r = iter.next(), !r.done)
                    a.push(r.value);

                return a;
            }
        };
    }
1032792
function strip(obj) {

    if (!obj || ! obj instanceof Object || typeof obj === 'string') {
        return undefined;
    }

    if (obj instanceof Array) {
        for (const value of obj) {
            strip(value);
        }
    } else {

        delete obj['loc'];
        delete obj['start'];
        delete obj['end'];

        Object.keys(obj).forEach(key => strip(obj[key]));
    }

    return obj;
}