Check if provided value is function
@param value
@param {string} message
@param {string} id
@returns {void}
503992
function isFunction(value, message, id) {
    if (message === void 0) { message = ''; }
    if (id === void 0) { id = ''; }
    if (this.enabled && typeof value !== 'function') {
        throw TypeException.expectedType(assertionTypes.IS_FUNCTION, value, '<function>', message, id);
    }
}
143063
function(i,value){
           if(!value) return;
           var i = i || 1,message = "";
           while(true){
            message += value;
            if((--i) <= 0) break;
          }

          return message;
    }
623417
function _handleReturnMessage(id, method) {
                var callback = this.callbackCache.get(id, true);
                var args = method && method.args;

                if ("function" === typeof callback) {
                    // First try to parse the first parameter in case the error is an object
                    if (args && args.length && args[0] && "Error" === args[0].type && "string" === typeof args[0].message) {
                        args[0] = new Error(args[0].message);
                    }

                    try {
                        callback.apply(null, args);
                    }
                    catch (ex) {
                        PostMessageUtilities.log("Error while trying to handle the returned message from request/command", "ERROR", "PostMessageCourier");
                    }
                }
            }
425116
function Message($, rule_id, options) {

    var rule = new ruleValidator($, rule_id, options),
        message = '';

    if ( typeof rule.valid === 'boolean' && !rule.valid ) {
        message = typeof rule.rule.message == 'function' ? rule.rule.message(options) : rule.rule.message;
    }

    this.text = message;
}
1247109
function isNaN(value, message, id) {
    if (message === void 0) { message = ''; }
    if (id === void 0) { id = ''; }
    if (this.enabled && !Number.isNaN(value)) {
        throw TypeException.unexpectedType(assertionTypes.IS_NAN, value, '<NaN>', message, id);
    }
}
18740
function (value) {
                var type = typeof value,
                    checkLength = false;
                if (value && type != 'string') {
                    // Functions have a length property, so we need to filter them out
                    if (type == 'function') {
                        // In Safari, NodeList/HTMLCollection both return "function" when using typeof, so we need
                        // to explicitly check them here.
//                        if (Ext.isSafari) {
//                            checkLength = value instanceof NodeList || value instanceof HTMLCollection;
//                        }
                    } else {
                        checkLength = true;
                    }
                }
                return checkLength ? value.length !== undefined : false;
            }
785626
function isStringable(value) {
      return _.isString(value) || (_.has(value, 'toString') && _.isFunction(value.toString));
    }
454727
function(message) {
		var identifier = _makeIdentifier(message);
		if (typeof _filter[identifier] !== 'undefined' && _filter[identifier] < ((+new Date()) + 10 * 60000)) {
			console.error('duplicated error', identifier, message);
			return _filter[identifier];
		}

		_filter[identifier] = +new Date();
		return false;
	}
759531
function(value, ifFn, elseFn) {
			if ((ifFn && typeof ifFn !== 'function') || (elseFn && typeof elseFn !== 'function')) return apiRejection('ifFn and elseFn must be functions');

			var fn = value ? ifFn : elseFn;
			if (!fn) return Promise.resolve(value);

			return Promise.resolve(fn.call(this, value));
		}
437711
function ( qu, value ) {
		return (sys.isNull( value ) || sys.isUndefined( value )) !== qu.operands[0];
	}
935737
function isArray(value, message, id) {
    if (message === void 0) { message = ''; }
    if (id === void 0) { id = ''; }
    if (this.enabled && !Array.isArray(value)) {
        throw TypeException.unexpectedType(assertionTypes.IS_ARRAY, value, '<array>', message, id);
    }
}
51657
function (value, node) {
        var valid = false;
        if (typeof value === (node.name === "component" ? "object" : "function"))
            valid = (_cs.annotation(value, "type") === node.name);
        return valid;
    }
36060
function(value) {
      return (angular.isUndefined(value) || value === null) || Object.keys(value).length === 0;
    }
1259984
function isNotNaN(value, message, id) {
    if (message === void 0) { message = ''; }
    if (id === void 0) { id = ''; }
    if (this.enabled && Number.isNaN(value)) {
        throw TypeException.expectedType(assertionTypes.IS_NOT_NAN, value, '<NaN>', message, id);
    }
}
682369
function isBool(value, message, id) {
    if (message === void 0) { message = ''; }
    if (id === void 0) { id = ''; }
    if (this.enabled && typeof value !== 'boolean') {
        throw TypeException.unexpectedType(assertionTypes.IS_BOOL, value, '<boolean>', message, id);
    }
}
1176409
function (orig, response) {
            if (!orig.id) {
                console.log("[Brackets LiveDev] Trying to send a response for a message with no ID");
                return;
            }
            response.id = orig.id;
            this.send(response);
        }
237232
function checkFunction(node) {
            const parent = node.parent;

            if (parent.type === "CallExpression") {
                callbackStack.push(node);
            }

            if (callbackStack.length > THRESHOLD) {
                const opts = { num: callbackStack.length, max: THRESHOLD };

                context.report({ node, messageId: "exceed", data: opts });
            }
        }