The source code

    /**
     * @ignore
     *   type of land
     * @author  lifesinger@gmail.com, yiminghe@gmail.com
     *
     */
    (function (S, undefined) {
        // [[Class]] -> type pairs
        var class2type = {},
            FALSE = false,
            OP = Object.prototype,
            toString = OP.toString;

        function hasOwnProperty(o, p) {
            return Object.prototype.hasOwnProperty.call(o, p);
        }

        S.mix(S,
            {
                /**
                 * test whether o is boolean
                 * @method
                 * @param  o
                 * @return {Boolean}
                 * @member KISSY
                 */
                isBoolean: 0,
                /**
                 * test whether o is number
                 * @method
                 * @param  o
                 * @return {Boolean}
                 * @member KISSY
                 */
                isNumber: 0,
                /**
                 * test whether o is String
                 * @method
                 * @param  o
                 * @return {Boolean}
                 * @member KISSY
                 */
                isString: 0,
                /**
                 * test whether o is function
                 * @method
                 * @param  o
                 * @return {Boolean}
                 * @member KISSY
                 */
                isFunction: 0,
                /**
                 * test whether o is Array
                 * @method
                 * @param  o
                 * @return {Boolean}
                 * @member KISSY
                 */
                isArray: 0,
                /**
                 * test whether o is Date
                 * @method
                 * @param  o
                 * @return {Boolean}
                 * @member KISSY
                 */
                isDate: 0,
                /**
                 * test whether o is RegExp
                 * @method
                 * @param  o
                 * @return {Boolean}
                 * @member KISSY
                 */
                isRegExp: 0,
                /**
                 * test whether o is Object
                 * @method
                 * @param  o
                 * @return {Boolean}
                 * @member KISSY
                 */
                isObject: 0,

                /**
                 * Determine the internal JavaScript [[Class]] of an object.
                 * @member KISSY
                 */
                type: function (o) {
                    return o == null ?
                        String(o) :
                        class2type[toString.call(o)] || 'object';
                },

                /**
                 * whether o === null
                 * @param o
                 * @member KISSY
                 */
                isNull: function (o) {
                    return o === null;
                },

                /**
                 * whether o === undefined
                 * @param o
                 * @member KISSY
                 */
                isUndefined: function (o) {
                    return o === undefined;
                },

                /**
                 * Checks to see if an object is empty.
                 * @member KISSY
                 */
                isEmptyObject: function (o) {
                    for (var p in o) {
                        if (p !== undefined) {
                            return FALSE;
                        }
                    }
                    return true;
                },

                /**
                 * Checks to see if an object is a plain object (created using '{}'
                 * or 'new Object()' but not 'new FunctionClass()').
                 * @member KISSY
                 */
                isPlainObject: function (obj) {
                    // credits to jq

                    // Must be an Object.
                    // Because of IE, we also have to check the presence of the constructor property.
                    // Make sure that DOM nodes and window objects don't pass through, as well
                    if (!obj || S.type(obj) !== "object" || obj.nodeType || obj.window == obj) {
                        return FALSE;
                    }

                    try {
                        // Not own constructor property must be Object
                        if (obj.constructor &&
                            !hasOwnProperty(obj, "constructor") &&
                            !hasOwnProperty(obj.constructor.prototype, "isPrototypeOf")) {
                            return FALSE;
                        }
                    } catch (e) {
                        // IE8,9 Will throw exceptions on certain host objects #9897
                        return FALSE;
                    }

                    // Own properties are enumerated firstly, so to speed up,
                    // if last one is own, then all properties are own.

                    var key;
                    for (key in obj) {
                    }

                    return key === undefined || hasOwnProperty(obj, key);
                }
            });

        S.each('Boolean Number String Function Array Date RegExp Object'.split(' '),
            function (name, lc) {
                // populate the class2type map
                class2type['[object ' + name + ']'] = (lc = name.toLowerCase());

                // add isBoolean/isNumber/...
                S['is' + name] = function (o) {
                    return S.type(o) == lc;
                }
            });

    })(KISSY);