returns if a value is an instance of a primitive type
@param  {*}  thing  value to check if is primitive
@return {Boolean}   true if val is primitive, else false
970354
function isPrimitive (val) {
  if (val === null || val === undefined || val === Infinity || isLiterallyNaN(val)) {
    return true
  }
  return primitives.some(function (Class) {
    return val === Class || directInstanceOf(val, Class)
  })
}
1360297
public static boolean isPrimitive(Object value) {

        if (value == null) {
            return true;

        } else if (value.getClass().isPrimitive() == true) {
            return true;

        } else if (Integer.class.isInstance(value)) {
            return true;

        } else if (Long.class.isInstance(value)) {
            return true;

        } else if (Double.class.isInstance(value)) {
            return true;

        } else if (Float.class.isInstance(value)) {
            return true;

        } else if (Short.class.isInstance(value)) {
            return true;

        } else if (Byte.class.isInstance(value)) {
            return true;

        } else if (Character.class.isInstance(value)) {
            return true;

        } else if (Boolean.class.isInstance(value)) {
            return true;

        } else if (BigDecimal.class.isInstance(value)) {
            return true;

        } else if (BigInteger.class.isInstance(value)) {
            return true;
        }

        return false;
    }
1337423
function isNumber( value ) {
	return ( typeof value === 'number' || Object.prototype.toString.call( value ) === '[object Number]' ) && value.valueOf() === value.valueOf();
}
776032
function(value)
    {
        var result = {};

        var t = typeof(value);
        //primitives are kept as such
        if (t == "number" || t == "string" || t == "boolean" || t == null || t == undefined)
        {
            result = value;
        }
        else if (value instanceof Array)
        {
            //arrays are serializesd recursively
            result = [];
            for (var i = 0; i < value.length; i++)
            {
                result[i] = this.serialize(value[i]);
            }
        }
        else if (t == "function")
        {
            //js functions are assigned an ID and stored in the local cache 
            result.type = FABridge.TYPE_JSFUNCTION;
            result.value = this.getFunctionID(value);
        }
        else if (value instanceof ASProxy)
        {
            result.type = FABridge.TYPE_ASINSTANCE;
            result.value = value.fb_instance_id;
        }
        else
        {
            result.type = FABridge.TYPE_ANONYMOUS;
            result.value = value;
        }

        return result;
    }
831262
function checkType(value, type) {
  if (typeof type === 'string') {
    switch (type) {
      case 'string':
      case 'object':
      case 'number':
      case 'boolean':
      case 'function':
        return typeof value === type;
      case 'class':
        return typeof value === 'function';
      case 'array':
        return value.constructor === Array;
      default:
        return false;
    }
  }
  else {
    return value instanceof type;
  }
}
736801
function(value, context, scope) {
				return this.isInstance(value, context, scope) || (Jsonix.Util.Type.isObject(value) && !Jsonix.Util.Type.isArray(value));
			}
118215
function isTypedArrayLike( value ) {
	return (
		value !== null &&
		typeof value === 'object' &&
		isInteger( value.length ) &&
		value.length >= 0 &&
		value.length <= MAX &&
		typeof value.BYTES_PER_ELEMENT === 'number' &&
		typeof value.byteOffset === 'number' &&
		typeof value.byteLength === 'number'
	);
}
823857
public static boolean isTypePrimitive(TypeName value) {
		return isTypeIncludedIn(value, Byte.TYPE, Character.TYPE, Boolean.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE,
				Float.TYPE, Double.TYPE);
	}
53682
function isString(value) {
    return typeof value == 'string' ||
      value && typeof value == 'object' && toString.call(value) == stringClass || false;
  }
348451
function isPrototype(value) {
  var Ctor = value && value.constructor,
      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$9;

  return value === proto;
}
419806
def is_type(value):
        """"""
        if isinstance(value, type):
            return issubclass(value, Type)
        return isinstance(value, Type)
186762
function is (value) {
  return {
    a: function (check) {
      if (check.prototype) check = check.prototype.constructor.name
      var type = Object.prototype.toString.call(value).slice(8, -1).toLowerCase()
      return value != null && type === check.toLowerCase()
    }
  }
}
905830
@Override
    public boolean hasInstance(Scriptable value) {
        Scriptable proto = value.getPrototype();
        while (proto != null) {
            if (proto.equals(this))
                return true;
            proto = proto.getPrototype();
        }

        return false;
    }
1133620
def is_primitive(var):
    
    primitives = ( float, long, str, int, dict, list, unicode, tuple, set, frozenset, datetime.datetime, datetime.timedelta, type(None) )
    for primitive in primitives:
        if type( var ) == primitive:
            return True
    return False
1038337
function isPrimitiveArray( value ) {
	var len;
	if ( !isArray( value ) ) {
		return false;
	}
	len = value.length;
	if ( !len ) {
		return false;
	}
	for ( var i = 0; i < len; i++ ) {
		if ( !isPrimitive( value[i] ) ) {
			return false;
		}
	}
	return true;
}
58076
function isKeyable$1(value) {
  var type = typeof value;
  return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean' ? value !== '__proto__' : value === null;
}
154611
private boolean isPrimitiveValue( Object obj ) {
        return obj instanceof Primitive
            && obj != Primitive.VOID && obj != Primitive.NULL;
    }