code: function (moduleName) {
                  var args;
  
                  context.takeGlobalQueue();
  
                  while (defQueue.length) {
                      args = defQueue.shift();
  
                      if (args[0] === null) {
                          args[0] = moduleName;
                          break;
                      } else if (args[0] === moduleName) {
                          //Found matching define call for this script!
                          break;
                      } else {
                          //Some other named define call, most likely the result
                          //of a build layer that included many define calls.
                          callDefMain(args);
                          args = null;
                      }
                  }
                  if (args) {
                      callDefMain(args);
                  } else {
                      //A script that does not call define(), so just simulate
                      //the call for it. Special exception for jQuery dynamic load.
                      callDefMain([moduleName, [],
                                  moduleName === "jquery" && typeof jQuery !== "undefined" ?
                                  function () {
                                      return jQuery;
                                  } : null]);
                  }
  
                  //Mark the script as loaded. Note that this can be different from a
                  //moduleName that maps to a define call. This line is important
                  //for traditional browser scripts.
                  loaded[moduleName] = true;
  
                  //If a global jQuery is defined, check for it. Need to do it here
                  //instead of main() since stock jQuery does not register as
                  //a module via define.
                  jQueryCheck();
  
                  //Doing this scriptCount decrement branching because sync envs
                  //need to decrement after resume, otherwise it looks like
                  //loading is complete after the first dependency is fetched.
                  //For browsers, it works fine to decrement after, but it means
                  //the checkLoaded setTimeout 50 ms cost is taken. To avoid
                  //that cost, decrement beforehand.
                  if (req.isAsync) {
                      context.scriptCount -= 1;
                  }
                  resume();
                  if (!req.isAsync) {
                      context.scriptCount -= 1;
                  }
              }
docs: 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.