/*---------------------------------------start-------------------------------*/

 req({}); // num == 1 跳到 num == 2

 //Exports some context-sensitive methods on global require.

 each([

     'toUrl',

     'undef',

     'defined',

     'specified'

 ], function (prop) {

     //Reference from contexts instead of early binding to default context,

     //so that during builds, the latest instance of the default context

     //with its config gets used.

     req[prop] = function () {

         var ctx = contexts[defContextName];

         return ctx.require[prop].apply(ctx, arguments);

     };

 });

 if (isBrowser && !cfg.skipDataMain) {}  //req.deps[mainscript]

 //Set up with config info.

 req(cfg); //最后启动。 按照之前写的num 一步一步的去加载。

 /*----------------------------------------start---------------------------------*/

 //第一次     num == 2

 //params

 var deps = {},

     callback = undefined,

     errback = undefined,

     optional = undefined;

 //--------------声明------------------

 var context = undefined,

     config = undefined,

     contextName = defContextName;

 //-------------判断---------------

 config = {};

 deps = [];

 //------------判断--------------

 context = contexts[contextName] = req.s.newContext(contextName);  //跳到num ==3

 //时间上就是执行  localRequire(deps, callback, errback);

 context.require(deps, callback, errback);  //跳到 num ==5

 /*---------------------------------------end-------------------------------*/

 /*

 *

 *

 * */

 /*---------------------------------------start-------------------------------*/

 //-----------------------进入核心函数--------------------------

 //第一次

 //function newContext(contextName)   num == 3

 context = {

     config: config,

     contextName: contextName,

     registry: registry,

     defined: defined,

     urlFetched: urlFetched,

     defQueue: defQueue,

     defQueueMap: {},

     Module: Module,

     makeModuleMap: makeModuleMap,

     nextTick: req.nextTick,

     onError: onError,

     /**

      * Set a configuration for the context.

      * @param {Object} cfg config object to integrate.

      */

     configure: function (cfg) {

         //Make sure the baseUrl ends in a slash.

         if (cfg.baseUrl) {

             if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {

                 cfg.baseUrl += '/';

             }

         }

         // Convert old style urlArgs string to a function.

         if (typeof cfg.urlArgs === 'string') {

             var urlArgs = cfg.urlArgs;

             cfg.urlArgs = function(id, url) {

                 return (url.indexOf('?') === -1 ? '?' : '&') + urlArgs;

             };

         }

         //Save off the paths since they require special processing,

         //they are additive.

         var shim = config.shim,

             objs = {

                 paths: true,

                 bundles: true,

                 config: true,

                 map: true

             };

         eachProp(cfg, function (value, prop) {

             if (objs[prop]) {

                 if (!config[prop]) {

                     config[prop] = {};

                 }

                 mixin(config[prop], value, true, true);

             } else {

                 config[prop] = value;

             }

         });

         //Reverse map the bundles

         if (cfg.bundles) {

             eachProp(cfg.bundles, function (value, prop) {

                 each(value, function (v) {

                     if (v !== prop) {

                         bundlesMap[v] = prop;

                     }

                 });

             });

         }

         //Merge shim

         if (cfg.shim) {

             eachProp(cfg.shim, function (value, id) {

                 //Normalize the structure

                 if (isArray(value)) {

                     value = {

                         deps: value

                     };

                 }

                 if ((value.exports || value.init) && !value.exportsFn) {

                     value.exportsFn = context.makeShimExports(value);

                 }

                 shim[id] = value;

             });

             config.shim = shim;

         }

         //Adjust packages if necessary.

         if (cfg.packages) {

             each(cfg.packages, function (pkgObj) {

                 var location, name;

                 pkgObj = typeof pkgObj === 'string' ? {name: pkgObj} : pkgObj;

                 name = pkgObj.name;

                 location = pkgObj.location;

                 if (location) {

                     config.paths[name] = pkgObj.location;

                 }

                 //Save pointer to main module ID for pkg name.

                 //Remove leading dot in main, so main paths are normalized,

                 //and remove any trailing .js, since different package

                 //envs have different conventions: some use a module name,

                 //some use a file name.

                 config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')

                         .replace(currDirRegExp, '')

                         .replace(jsSuffixRegExp, '');

             });

         }

         //If there are any "waiting to execute" modules in the registry,

         //update the maps for them, since their info, like URLs to load,

         //may have changed.

         eachProp(registry, function (mod, id) {

             //If module already has init called, since it is too

             //late to modify them, and ignore unnormalized ones

             //since they are transient.

             if (!mod.inited && !mod.map.unnormalized) {

                 mod.map = makeModuleMap(id, null, true);

             }

         });

         //If a deps array or a config callback is specified, then call

         //require with those args. This is useful when require is defined as a

         //config object before require.js is loaded.

         if (cfg.deps || cfg.callback) {

             context.require(cfg.deps || [], cfg.callback);

         }

     },

     makeShimExports: function (value) {

         function fn() {

             var ret;

             if (value.init) {

                 ret = value.init.apply(global, arguments);

             }

             return ret || (value.exports && getGlobal(value.exports));

         }

         return fn;

     },

     makeRequire: function (relMap, options) {

         options = options || {};

         function localRequire(deps, callback, errback) {

             var id, map, requireMod;

             if (options.enableBuildCallback && callback && isFunction(callback)) {

                 callback.__requireJsBuild = true;

             }

             if (typeof deps === 'string') {

                 if (isFunction(callback)) {

                     //Invalid call

                     return onError(makeError('requireargs', 'Invalid require call'), errback);

                 }

                 //If require|exports|module are requested, get the

                 //value for them from the special handlers. Caveat:

                 //this only works while module is being defined.

                 if (relMap && hasProp(handlers, deps)) {

                     return handlers[deps](registry[relMap.id]);

                 }

                 //Synchronous access to one module. If require.get is

                 //available (as in the Node adapter), prefer that.

                 if (req.get) {

                     return req.get(context, deps, relMap, localRequire);

                 }

                 //Normalize module name, if it contains . or ..

                 map = makeModuleMap(deps, relMap, false, true);

                 id = map.id;

                 if (!hasProp(defined, id)) {

                     return onError(makeError('notloaded', 'Module name "' +

                         id +

                         '" has not been loaded yet for context: ' +

                         contextName +

                         (relMap ? '' : '. Use require([])')));

                 }

                 return defined[id];

             }

             //Grab defines waiting in the global queue.

             intakeDefines();

             //Mark all the dependencies as needing to be loaded.

             context.nextTick(function () {

                 //Some defines could have been added since the

                 //require call, collect them.

                 intakeDefines();

                 requireMod = getModule(makeModuleMap(null, relMap));

                 //Store if map config should be applied to this require

                 //call for dependencies.

                 requireMod.skipMap = options.skipMap;

                 requireMod.init(deps, callback, errback, {

                     enabled: true

                 });

                 checkLoaded();

             });

             return localRequire;

         }

         mixin(localRequire, {

             isBrowser: isBrowser,

             /**

              * Converts a module name + .extension into an URL path.

              * *Requires* the use of a module name. It does not support using

              * plain URLs like nameToUrl.

              */

             toUrl: function (moduleNamePlusExt) {

                 var ext,

                     index = moduleNamePlusExt.lastIndexOf('.'),

                     segment = moduleNamePlusExt.split('/')[0],

                     isRelative = segment === '.' || segment === '..';

                 //Have a file extension alias, and it is not the

                 //dots from a relative path.

                 if (index !== -1 && (!isRelative || index > 1)) {

                     ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);

                     moduleNamePlusExt = moduleNamePlusExt.substring(0, index);

                 }

                 return context.nameToUrl(normalize(moduleNamePlusExt,

                     relMap && relMap.id, true), ext,  true);

             },

             defined: function (id) {

                 return hasProp(defined, makeModuleMap(id, relMap, false, true).id);

             },

             specified: function (id) {

                 id = makeModuleMap(id, relMap, false, true).id;

                 return hasProp(defined, id) || hasProp(registry, id);

             }

         });

         //Only allow undef on top level require calls

         if (!relMap) {

             localRequire.undef = function (id) {

                 //Bind any waiting define() calls to this context,

                 //fix for #408

                 takeGlobalQueue();

                 var map = makeModuleMap(id, relMap, true),

                     mod = getOwn(registry, id);

                 mod.undefed = true;

                 removeScript(id);

                 delete defined[id];

                 delete urlFetched[map.url];

                 delete undefEvents[id];

                 //Clean queued defines too. Go backwards

                 //in array so that the splices do not

                 //mess up the iteration.

                 eachReverse(defQueue, function(args, i) {

                     if (args[0] === id) {

                         defQueue.splice(i, 1);

                     }

                 });

                 delete context.defQueueMap[id];

                 if (mod) {

                     //Hold on to listeners in case the

                     //module will be attempted to be reloaded

                     //using a different config.

                     if (mod.events.defined) {

                         undefEvents[id] = mod.events;

                     }

                     cleanRegistry(id);

                 }

             };

         }

         return localRequire;

     },

     /**

      * Called to enable a module if it is still in the registry

      * awaiting enablement. A second arg, parent, the parent module,

      * is passed in for context, when this method is overridden by

      * the optimizer. Not shown here to keep code compact.

      */

     enable: function (depMap) {

         var mod = getOwn(registry, depMap.id);

         if (mod) {

             getModule(depMap).enable();

         }

     },

     /**

      * Internal method used by environment adapters to complete a load event.

      * A load event could be a script load or just a load pass from a synchronous

      * load call.

      * @param {String} moduleName the name of the module to potentially complete.

      */

     completeLoad: function (moduleName) {

         var found, args, mod,

             shim = getOwn(config.shim, moduleName) || {},

             shExports = shim.exports;

         takeGlobalQueue();

         while (defQueue.length) {

             args = defQueue.shift();

             if (args[0] === null) {

                 args[0] = moduleName;

                 //If already found an anonymous module and bound it

                 //to this name, then this is some other anon module

                 //waiting for its completeLoad to fire.

                 if (found) {

                     break;

                 }

                 found = true;

             } else if (args[0] === moduleName) {

                 //Found matching define call for this script!

                 found = true;

             }

             callGetModule(args);

         }

         context.defQueueMap = {};

         //Do this after the cycle of callGetModule in case the result

         //of those calls/init calls changes the registry.

         mod = getOwn(registry, moduleName);

         if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {

             if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {

                 if (hasPathFallback(moduleName)) {

                     return;

                 } else {

                     return onError(makeError('nodefine',

                         'No define call for ' + moduleName,

                         null,

                         [moduleName]));

                 }

             } else {

                 //A script that does not call define(), so just simulate

                 //the call for it.

                 callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);

             }

         }

         checkLoaded();

     },

     /**

      * Converts a module name to a file path. Supports cases where

      * moduleName may actually be just an URL.

      * Note that it **does not** call normalize on the moduleName,

      * it is assumed to have already been normalized. This is an

      * internal API, not a public one. Use toUrl for the public API.

      */

     nameToUrl: function (moduleName, ext, skipExt) {

         var paths, syms, i, parentModule, url,

             parentPath, bundleId,

             pkgMain = getOwn(config.pkgs, moduleName);

         if (pkgMain) {

             moduleName = pkgMain;

         }

         bundleId = getOwn(bundlesMap, moduleName);

         if (bundleId) {

             return context.nameToUrl(bundleId, ext, skipExt);

         }

         //If a colon is in the URL, it indicates a protocol is used and it is just

         //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)

         //or ends with .js, then assume the user meant to use an url and not a module id.

         //The slash is important for protocol-less URLs as well as full paths.

         if (req.jsExtRegExp.test(moduleName)) {

             //Just a plain path, not module name lookup, so just return it.

             //Add extension if it is included. This is a bit wonky, only non-.js things pass

             //an extension, this method probably needs to be reworked.

             url = moduleName + (ext || '');

         } else {

             //A module that needs to be converted to a path.

             paths = config.paths;

             syms = moduleName.split('/');

             //For each module name segment, see if there is a path

             //registered for it. Start with most specific name

             //and work up from it.

             for (i = syms.length; i > 0; i -= 1) {

                 parentModule = syms.slice(0, i).join('/');

                 parentPath = getOwn(paths, parentModule);

                 if (parentPath) {

                     //If an array, it means there are a few choices,

                     //Choose the one that is desired

                     if (isArray(parentPath)) {

                         parentPath = parentPath[0];

                     }

                     syms.splice(0, i, parentPath);

                     break;

                 }

             }

             //Join the path parts together, then figure out if baseUrl is needed.

             url = syms.join('/');

             url += (ext || (/^data\:|^blob\:|\?/.test(url) || skipExt ? '' : '.js'));

             url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;

         }

         return config.urlArgs && !/^blob\:/.test(url) ?

         url + config.urlArgs(moduleName, url) : url;

     },

     //Delegates to req.load. Broken out as a separate function to

     //allow overriding in the optimizer.

     load: function (id, url) {

         req.load(context, id, url);

     },

     /**

      * Executes a module callback function. Broken out as a separate function

      * solely to allow the build system to sequence the files in the built

      * layer in the right sequence.

      *

      * @private

      */

     execCb: function (name, callback, args, exports) {

         return callback.apply(exports, args);

     },

     /**

      * callback for script loads, used to check status of loading.

      *

      * @param {Event} evt the event from the browser for the script

      * that was loaded.

      */

     onScriptLoad: function (evt) {

         //Using currentTarget instead of target for Firefox 2.0's sake. Not

         //all old browsers will be supported, but this one was easy enough

         //to support and still makes sense.

         if (evt.type === 'load' ||

             (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {

             //Reset interactive script so a script node is not held onto for

             //to long.

             interactiveScript = null;

             //Pull out the name of the module and the context.

             var data = getScriptData(evt);

             context.completeLoad(data.id);

         }

     },

     /**

      * Callback for script errors.

      */

     onScriptError: function (evt) {

         var data = getScriptData(evt);

         if (!hasPathFallback(data.id)) {

             var parents = [];

             eachProp(registry, function(value, key) {

                 if (key.indexOf('_@r') !== 0) {

                     each(value.depMaps, function(depMap) {

                         if (depMap.id === data.id) {

                             parents.push(key);

                             return true;

                         }

                     });

                 }

             });

             return onError(makeError('scripterror', 'Script error for "' + data.id +

                 (parents.length ?

                 '", needed by: ' + parents.join(', ') :

                     '"'), evt, [data.id]));

         }

     }

 };

 //得到一个闭包环境

 context.require = context.makeRequire();  //跳到num ===4

 //return context;

 /*---------------------------------------end-------------------------------*/

 /*

 *

 *

 *

 *

 *

 * */

 /*---------------------------------------start-------------------------------*/

 //--------------------------进入makeRequire------------------------

 //第一次

 //params [relMap , options]   num == 4

 var relMap = undefined,

      options = {};

 //声明localRequire函数

 var localRequire= function(deps, callback, errback){};

 //给localRequire加属性

 var fn1={

     isBrowser: isBrowser,

     /**

      * Converts a module name + .extension into an URL path.

      * *Requires* the use of a module name. It does not support using

      * plain URLs like nameToUrl.

      */

         toUrl: function (moduleNamePlusExt) {

     var ext,

         index = moduleNamePlusExt.lastIndexOf('.'),

         segment = moduleNamePlusExt.split('/')[0],

         isRelative = segment === '.' || segment === '..';

     //Have a file extension alias, and it is not the

     //dots from a relative path.

     if (index !== -1 && (!isRelative || index > 1)) {

         ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);

         moduleNamePlusExt = moduleNamePlusExt.substring(0, index);

     }

     return context.nameToUrl(normalize(moduleNamePlusExt,

         relMap && relMap.id, true), ext,  true);

 },

     defined: function (id) {

         return hasProp(defined, makeModuleMap(id, relMap, false, true).id);

     },

     specified: function (id) {

         id = makeModuleMap(id, relMap, false, true).id;

         return hasProp(defined, id) || hasProp(registry, id);

     }

 };

 //---------------------- 判断 if (!relMap)----------------------

 //加属性

 var fn2 =  undef = function(id){};

 //返回return localRequire;

 //总结一下 就是返回一个函数，给他加了一些属性；

 /*---------------------------------------end-------------------------------*/

 /*

 *

 * */

 /*---------------------------------------start-------------------------------*/

 // num == 5

 intakeDefines() // 调到num == 6

 /*

 *    while (defQueue.length) {}遍历 defQueue；

 *

 *

 *

 * */

 callGetModule(args); //args [id,deps,callb]  跳到num = 7

 context.defQueueMap = {};

 context.nextTick(function () {

     //Some defines could have been added since the

     //require call, collect them.

     intakeDefines();

     requireMod = getModule(makeModuleMap(null, relMap));

     //Store if map config should be applied to this require

     //call for dependencies.

     requireMod.skipMap = options.skipMap;

     requireMod.init(deps, callback, errback, {

         enabled: true

     });

     checkLoaded();

 });  //跳转到 12

 /*---------------------------------------end-------------------------------*/

 /*

 *

 *

 *

 *

 * */

 /*---------------------------------------start-------------------------------*/

 /* function takeGlobalQueue()   num == 6

  * */

 //把globalDefQueue 里面通过define(id,desp,callback) 都放到  特定context 下的 defQueue

 //并且最后清空   globalDefQueue = [];

 /*---------------------------------------end-------------------------------*/

 /*

 *

 *

 *

 *

 * */

 /*---------------------------------------start-------------------------------*/

 //   function callGetModule(args)   num == 7

 //将 defined里没有的 id进行构建模块

 if (!hasProp(defined, args[0])) {

     getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);

 }

 makeModuleMap(args[0], null, true) //跳转到 num== 8

 getModule(makeModuleMap(args[0], null, true))  //跳转到 num == 9

 getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);//跳转到 num == 11

 //生成的Module 里面的map属性 就是 makeModuleMap返回的对象。

 /*---------------------------------------end-------------------------------*/

 /*

 *

 *

 *

 *

 * */

 /*---------------------------------------start-------------------------------*/

 //function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) //num == 8

 //返回obj

 var obj =  {

     prefix: prefix,

     name: normalizedName,

     parentMap: parentModuleMap,

     unnormalized: !!suffix,

     url: url,

     originalName: originalName,

     isDefine: isDefine,

     id: (prefix ?

     prefix + '!' + normalizedName :

         normalizedName) + suffix

 };

 /*---------------------------------------end-------------------------------*/

 /*

  *

  *

  *

  *

  * */

 /*-----------------------------------------start--------------------------------*/

 //function getModule(depMap)   num == 9

 var id = depMap.id,

     mod = getOwn(registry, id);

 if (!mod) {

     mod = registry[id] = new context.Module(depMap);

 }

 new context.Module(depMap); //跳转到10

 //return mod;

 /*----------------------------------------end-------------------------*/

 /*

  *

  *

  *

  *

  * */

 /*-----------------------------------------start--------------------------------*/

 //num ===10

 Module = function (map) {

     this.events = getOwn(undefEvents, map.id) || {};

     this.map = map;

     this.shim = getOwn(config.shim, map.id);

     this.depExports = [];

     this.depMaps = [];

     this.depMatched = [];

     this.pluginMaps = {};

     this.depCount = 0;

     /* this.exports this.factory

      this.depMaps = [],

      this.enabled, this.fetched

      */

 };

 Module.prototype = {

     init: function (depMaps, factory, errback, options) {

         options = options || {};

         //Do not do more inits if already done. Can happen if there

         //are multiple define calls for the same module. That is not

         //a normal, common case, but it is also not unexpected.

         if (this.inited) {

             return;

         }

         this.factory = factory;

         if (errback) {

             //Register for errors on this module.

             this.on('error', errback);

         } else if (this.events.error) {

             //If no errback already, but there are error listeners

             //on this module, set up an errback to pass to the deps.

             errback = bind(this, function (err) {

                 this.emit('error', err);

             });

         }

         //Do a copy of the dependency array, so that

         //source inputs are not modified. For example

         //"shim" deps are passed in here directly, and

         //doing a direct modification of the depMaps array

         //would affect that config.

         this.depMaps = depMaps && depMaps.slice(0);

         this.errback = errback;

         //Indicate this module has be initialized

         this.inited = true;

         this.ignore = options.ignore;

         //Could have option to init this module in enabled mode,

         //or could have been previously marked as enabled. However,

         //the dependencies are not known until init is called. So

         //if enabled previously, now trigger dependencies as enabled.

         if (options.enabled || this.enabled) {

             //Enable this module and dependencies.

             //Will call this.check()

             this.enable();

         } else {

             this.check();

         }

     },

     defineDep: function (i, depExports) {

         //Because of cycles, defined callback for a given

         //export can be called more than once.

         if (!this.depMatched[i]) {

             this.depMatched[i] = true;

             this.depCount -= 1;

             this.depExports[i] = depExports;

         }

     },

     fetch: function () {

         if (this.fetched) {

             return;

         }

         this.fetched = true;

         context.startTime = (new Date()).getTime();

         var map = this.map;

         //If the manager is for a plugin managed resource,

         //ask the plugin to load it now.

         if (this.shim) {

             context.makeRequire(this.map, {

                 enableBuildCallback: true

             })(this.shim.deps || [], bind(this, function () {

                 return map.prefix ? this.callPlugin() : this.load();

             }));

         } else {

             //Regular dependency.

             return map.prefix ? this.callPlugin() : this.load();

         }

     },

     load: function () {

         var url = this.map.url;

         //Regular dependency.

         if (!urlFetched[url]) {

             urlFetched[url] = true;

             context.load(this.map.id, url);

         }

     },

     /**

      * Checks if the module is ready to define itself, and if so,

      * define it.

      */

     check: function () {

         if (!this.enabled || this.enabling) {

             return;

         }

         var err, cjsModule,

             id = this.map.id,

             depExports = this.depExports,

             exports = this.exports,

             factory = this.factory;

         if (!this.inited) {

             // Only fetch if not already in the defQueue.

             if (!hasProp(context.defQueueMap, id)) {

                 this.fetch();

             }

         } else if (this.error) {

             this.emit('error', this.error);

         } else if (!this.defining) {

             //The factory could trigger another require call

             //that would result in checking this module to

             //define itself again. If already in the process

             //of doing that, skip this work.

             this.defining = true;

             if (this.depCount < 1 && !this.defined) {

                 if (isFunction(factory)) {

                     //If there is an error listener, favor passing

                     //to that instead of throwing an error. However,

                     //only do it for define()'d  modules. require

                     //errbacks should not be called for failures in

                     //their callbacks (#699). However if a global

                     //onError is set, use that.

                     if ((this.events.error && this.map.isDefine) ||

                         req.onError !== defaultOnError) {

                         try {

                             exports = context.execCb(id, factory, depExports, exports);

                         } catch (e) {

                             err = e;

                         }

                     } else {

                         exports = context.execCb(id, factory, depExports, exports);

                     }

                     // Favor return value over exports. If node/cjs in play,

                     // then will not have a return value anyway. Favor

                     // module.exports assignment over exports object.

                     if (this.map.isDefine && exports === undefined) {

                         cjsModule = this.module;

                         if (cjsModule) {

                             exports = cjsModule.exports;

                         } else if (this.usingExports) {

                             //exports already set the defined value.

                             exports = this.exports;

                         }

                     }

                     if (err) {

                         err.requireMap = this.map;

                         err.requireModules = this.map.isDefine ? [this.map.id] : null;

                         err.requireType = this.map.isDefine ? 'define' : 'require';

                         return onError((this.error = err));

                     }

                 } else {

                     //Just a literal value

                     exports = factory;

                 }

                 this.exports = exports;

                 if (this.map.isDefine && !this.ignore) {

                     defined[id] = exports;

                     if (req.onResourceLoad) {

                         var resLoadMaps = [];

                         each(this.depMaps, function (depMap) {

                             resLoadMaps.push(depMap.normalizedMap || depMap);

                         });

                         req.onResourceLoad(context, this.map, resLoadMaps);

                     }

                 }

                 //Clean up

                 cleanRegistry(id);

                 this.defined = true;

             }

             //Finished the define stage. Allow calling check again

             //to allow define notifications below in the case of a

             //cycle.

             this.defining = false;

             if (this.defined && !this.defineEmitted) {

                 this.defineEmitted = true;

                 this.emit('defined', this.exports);

                 this.defineEmitComplete = true;

             }

         }

     },

     callPlugin: function () {

         var map = this.map,

             id = map.id,

         //Map already normalized the prefix.

             pluginMap = makeModuleMap(map.prefix);

         //Mark this as a dependency for this plugin, so it

         //can be traced for cycles.

         this.depMaps.push(pluginMap);

         on(pluginMap, 'defined', bind(this, function (plugin) {

             var load, normalizedMap, normalizedMod,

                 bundleId = getOwn(bundlesMap, this.map.id),

                 name = this.map.name,

                 parentName = this.map.parentMap ? this.map.parentMap.name : null,

                 localRequire = context.makeRequire(map.parentMap, {

                     enableBuildCallback: true

                 });

             //If current map is not normalized, wait for that

             //normalized name to load instead of continuing.

             if (this.map.unnormalized) {

                 //Normalize the ID if the plugin allows it.

                 if (plugin.normalize) {

                     name = plugin.normalize(name, function (name) {

                             return normalize(name, parentName, true);

                         }) || '';

                 }

                 //prefix and name should already be normalized, no need

                 //for applying map config again either.

                 normalizedMap = makeModuleMap(map.prefix + '!' + name,

                     this.map.parentMap);

                 on(normalizedMap,

                     'defined', bind(this, function (value) {

                         this.map.normalizedMap = normalizedMap;

                         this.init([], function () { return value; }, null, {

                             enabled: true,

                             ignore: true

                         });

                     }));

                 normalizedMod = getOwn(registry, normalizedMap.id);

                 if (normalizedMod) {

                     //Mark this as a dependency for this plugin, so it

                     //can be traced for cycles.

                     this.depMaps.push(normalizedMap);

                     if (this.events.error) {

                         normalizedMod.on('error', bind(this, function (err) {

                             this.emit('error', err);

                         }));

                     }

                     normalizedMod.enable();

                 }

                 return;

             }

             //If a paths config, then just load that file instead to

             //resolve the plugin, as it is built into that paths layer.

             if (bundleId) {

                 this.map.url = context.nameToUrl(bundleId);

                 this.load();

                 return;

             }

             load = bind(this, function (value) {

                 this.init([], function () { return value; }, null, {

                     enabled: true

                 });

             });

             load.error = bind(this, function (err) {

                 this.inited = true;

                 this.error = err;

                 err.requireModules = [id];

                 //Remove temp unnormalized modules for this module,

                 //since they will never be resolved otherwise now.

                 eachProp(registry, function (mod) {

                     if (mod.map.id.indexOf(id + '_unnormalized') === 0) {

                         cleanRegistry(mod.map.id);

                     }

                 });

                 onError(err);

             });

             //Allow plugins to load other code without having to know the

             //context or how to 'complete' the load.

             load.fromText = bind(this, function (text, textAlt) {

                 /*jslint evil: true */

                 var moduleName = map.name,

                     moduleMap = makeModuleMap(moduleName),

                     hasInteractive = useInteractive;

                 //As of 2.1.0, support just passing the text, to reinforce

                 //fromText only being called once per resource. Still

                 //support old style of passing moduleName but discard

                 //that moduleName in favor of the internal ref.

                 if (textAlt) {

                     text = textAlt;

                 }

                 //Turn off interactive script matching for IE for any define

                 //calls in the text, then turn it back on at the end.

                 if (hasInteractive) {

                     useInteractive = false;

                 }

                 //Prime the system by creating a module instance for

                 //it.

                 getModule(moduleMap);

                 //Transfer any config to this other module.

                 if (hasProp(config.config, id)) {

                     config.config[moduleName] = config.config[id];

                 }

                 try {

                     req.exec(text);

                 } catch (e) {

                     return onError(makeError('fromtexteval',

                         'fromText eval for ' + id +

                         ' failed: ' + e,

                         e,

                         [id]));

                 }

                 if (hasInteractive) {

                     useInteractive = true;

                 }

                 //Mark this as a dependency for the plugin

                 //resource

                 this.depMaps.push(moduleMap);

                 //Support anonymous modules.

                 context.completeLoad(moduleName);

                 //Bind the value of that module to the value for this

                 //resource ID.

                 localRequire([moduleName], load);

             });

             //Use parentName here since the plugin's name is not reliable,

             //could be some weird string with no path that actually wants to

             //reference the parentName's path.

             plugin.load(map.name, localRequire, load, config);

         }));

         context.enable(pluginMap, this);

         this.pluginMaps[pluginMap.id] = pluginMap;

     },

     enable: function () {

         enabledRegistry[this.map.id] = this;

         this.enabled = true;

         //Set flag mentioning that the module is enabling,

         //so that immediate calls to the defined callbacks

         //for dependencies do not trigger inadvertent load

         //with the depCount still being zero.

         this.enabling = true;

         //Enable each dependency

         each(this.depMaps, bind(this, function (depMap, i) {

             var id, mod, handler;

             if (typeof depMap === 'string') {

                 //Dependency needs to be converted to a depMap

                 //and wired up to this module.

                 depMap = makeModuleMap(depMap,

                     (this.map.isDefine ? this.map : this.map.parentMap),

                     false,

                     !this.skipMap);

                 this.depMaps[i] = depMap;

                 handler = getOwn(handlers, depMap.id);

                 if (handler) {

                     this.depExports[i] = handler(this);

                     return;

                 }

                 this.depCount += 1;

                 on(depMap, 'defined', bind(this, function (depExports) {

                     if (this.undefed) {

                         return;

                     }

                     this.defineDep(i, depExports);

                     this.check();

                 }));

                 if (this.errback) {

                     on(depMap, 'error', bind(this, this.errback));

                 } else if (this.events.error) {

                     // No direct errback on this module, but something

                     // else is listening for errors, so be sure to

                     // propagate the error correctly.

                     on(depMap, 'error', bind(this, function(err) {

                         this.emit('error', err);

                     }));

                 }

             }

             id = depMap.id;

             mod = registry[id];

             //Skip special modules like 'require', 'exports', 'module'

             //Also, don't call enable if it is already enabled,

             //important in circular dependency cases.

             if (!hasProp(handlers, id) && mod && !mod.enabled) {

                 context.enable(depMap, this);

             }

         }));

         //Enable each plugin that is used in

         //a dependency

         eachProp(this.pluginMaps, bind(this, function (pluginMap) {

             var mod = getOwn(registry, pluginMap.id);

             if (mod && !mod.enabled) {

                 context.enable(pluginMap, this);

             }

         }));

         this.enabling = false;

         this.check();

     },

     on: function (name, cb) {

         var cbs = this.events[name];

         if (!cbs) {

             cbs = this.events[name] = [];

         }

         cbs.push(cb);

     },

     emit: function (name, evt) {

         each(this.events[name], function (cb) {

             cb(evt);

         });

         if (name === 'error') {

             //Now that the error handler was triggered, remove

             //the listeners, since this broken Module instance

             //can stay around for a while in the registry.

             delete this.events[name];

         }

     }

 };

 /*-----------------------------------------end--------------------------------*/

 /*

 *

 *

 *

 * */

 /*-----------------------------------------start--------------------------------*/

 //num = 11

 //init: function (depMaps, factory, errback, options) {}

 this.factory = factory;

 this.depMaps = depMaps && depMaps.slice(0);

 this.errback = errback;

 //Indicate this module has be initialized

 this.inited = true;

 this.ignore = options.ignore;

 //总结一句话  就是给module.绑定数据。

 /*----------------------------------------end-------------------------*/

 /*

  *

  * */

 /*----------------------------------------start-------------------------*/

 num == 12

 /*----------------------------------------end-------------------------*/

 /*

  *

  * */