The source code

    /**
     * @ignore
     * A seed where KISSY grows up from, KISS Yeah !
     * @author lifesinger@gmail.com, yiminghe@gmail.com
     */

    /**
     * The KISSY global namespace object. you can use
     *
     * for example:
     *      @example
     *      KISSY.each/mix
     *
     * to do basic operation. or
     *
     * for example:
     *      @example
     *      KISSY.use('overlay,node', function(S, Overlay, Node){
     *          //
     *      });
     *
     * to do complex task with modules.
     * @singleton
     * @class KISSY
     */
    var KISSY = (function (undefined) {

        var host = this,
            S,
            guid = 0,
            EMPTY = '';

        S = {

            /**
             * The build time of the library.
             * NOTICE: '@TIMESTAMP@' will replace with current timestamp when compressing.
             * @private
             * @type {String}
             */
            __BUILD_TIME: '@TIMESTAMP@',
            /**
             * KISSY Environment.
             * @private
             * @type {Object}
             */
            Env: {
                host: host,
                nodejs: (typeof require == 'function') && (typeof exports == 'object')
            },
            /**
             * KISSY Config.
             * If load kissy.js, Config.debug defaults to true.
             * Else If load kissy-min.js, Config.debug defaults to false.
             * @private
             * @property {Object} Config
             * @property {Boolean} Config.debug
             * @member KISSY
             */
            Config: {
                debug: '@DEBUG@',
                fns: {}
            },

            /**
             * The version of the library.
             * NOTICE: '@VERSION@' will replace with current version when compressing.
             * @type {String}
             */
            version: '@VERSION@',

            /**
             * set KISSY configuration
             * @param {Object|String}   configName Config object or config key.
             * @param {String} configName.base   KISSY 's base path. Default: get from kissy(-min).js or seed(-min).js
             * @param {String} configName.tag    KISSY 's timestamp for native module. Default: KISSY 's build time.
             * @param {Boolean} configName.debug     whether to enable debug mod.
             * @param {Boolean} configName.combine   whether to enable combo.
             * @param {Object} configName.packages Packages definition with package name as the key.
             * @param {String} configName.packages.base    Package base path.
             * @param {String} configName.packages.tag     Timestamp for this package's module file.
             * @param {String} configName.packages.debug     Whether force debug mode for current package.
             * @param {String} configName.packages.combine     Whether allow combine for current package modules.
             * @param {String} [configName.packages.ignorePackageNameInUri=false] whether remove packageName from module request uri,
             * can only be used in production mode.
             * @param {Array[]} configName.map file map      File url map configs.
             * @param {Array[]} configName.map.0     A single map rule.
             * @param {RegExp} configName.map.0.0    A regular expression to match url.
             * @param {String|Function} configName.map.0.1   Replacement for String.replace.
             * @param [configValue] config value.
             *
             * for example:
             *     @example
             *     KISSY.config({
             *      combine: true,
             *      base: '',
             *      packages: {
             *          'gallery': {
             *              base: 'http://a.tbcdn.cn/s/kissy/gallery/'
             *          }
             *      },
             *      modules: {
             *          'gallery/x/y': {
             *              requires: ['gallery/x/z']
             *          }
             *      }
             *     });
             */
            config: function (configName, configValue) {
                var cfg,
                    r,
                    self = this,
                    fn,
                    Config = S.Config,
                    configFns = Config.fns;
                if (S.isObject(configName)) {
                    S.each(configName, function (configValue, p) {
                        fn = configFns[p];
                        if (fn) {
                            fn.call(self, configValue);
                        } else {
                            Config[p] = configValue;
                        }
                    });
                } else {
                    cfg = configFns[configName];
                    if (configValue === undefined) {
                        if (cfg) {
                            r = cfg.call(self);
                        } else {
                            r = Config[configName];
                        }
                    } else {
                        if (cfg) {
                            r = cfg.call(self, configValue);
                        } else {
                            Config[configName] = configValue;
                        }
                    }
                }
                return r;
            },

            /**
             * Prints debug info.
             * @param msg {String} the message to log.
             * @param {String} [cat] the log category for the message. Default
             *        categories are 'info', 'warn', 'error', 'time' etc.
             * @param {String} [src] the source of the the message (opt)
             */
            log: function (msg, cat, src) {
                if (S.Config.debug) {
                    if (src) {
                        msg = src + ': ' + msg;
                    }
                    if (host['console'] !== undefined && console.log) {
                        console[cat && console[cat] ? cat : 'log'](msg);
                    }
                }
            },

            /**
             * Throws error message.
             */
            error: function (msg) {
                if (S.Config.debug) {
                    // with stack info!
                    throw msg instanceof  Error ? msg : new Error(msg);
                }
            },

            /*
             * Generate a global unique id.
             * @param {String} [pre] guid prefix
             * @return {String} the guid
             */
            guid: function (pre) {
                return (pre || EMPTY) + guid++;
            }
        };

        // exports for nodejs
        if (S.Env.nodejs) {
            S.KISSY = S;
            module.exports = S;
        }

        return S;

    })();