docs: function checkLoaded() {
              var waitInterval = config.waitSeconds * 1000,
                  //It is possible to disable the wait interval by using waitSeconds of 0.
                  expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
                  noLoads = "", hasLoadedProp = false, stillLoading = false,
                  cycleDeps = [],
                  i, prop, err, manager, cycleManager, moduleDeps;
  
              //If there are items still in the paused queue processing wait.
              //This is particularly important in the sync case where each paused
              //item is processed right away but there may be more waiting.
              if (context.pausedCount > 0) {
                  return undefined;
              }
  
              //Determine if priority loading is done. If so clear the priority. If
              //not, then do not check
              if (config.priorityWait) {
                  if (isPriorityDone()) {
                      //Call resume, since it could have
                      //some waiting dependencies to trace.
                      resume();
                  } else {
                      return undefined;
                  }
              }
  
              //See if anything is still in flight.
              for (prop in loaded) {
                  if (!(prop in empty)) {
                      hasLoadedProp = true;
                      if (!loaded[prop]) {
                          if (expired) {
                              noLoads += prop + " ";
                          } else {
                              stillLoading = true;
                              if (prop.indexOf('!') === -1) {
                                  //No reason to keep looking for unfinished
                                  //loading. If the only stillLoading is a
                                  //plugin resource though, keep going,
                                  //because it may be that a plugin resource
                                  //is waiting on a non-plugin cycle.
                                  cycleDeps = [];
                                  break;
                              } else {
                                  moduleDeps = managerCallbacks[prop] && managerCallbacks[prop].moduleDeps;
                                  if (moduleDeps) {
                                      cycleDeps.push.apply(cycleDeps, moduleDeps);
                                  }
                              }
                          }
                      }
                  }
              }
  
              //Check for exit conditions.
              if (!hasLoadedProp && !context.waitCount) {
                  //If the loaded object had no items, then the rest of
                  //the work below does not need to be done.
                  return undefined;
              }
              if (expired && noLoads) {
                  //If wait time expired, throw error of unloaded modules.
                  err = makeError("timeout", "Load timeout for modules: " + noLoads);
                  err.requireType = "timeout";
                  err.requireModules = noLoads;
                  return req.onError(err);
              }
  
              //If still loading but a plugin is waiting on a regular module cycle
              //break the cycle.
              if (stillLoading && cycleDeps.length) {
                  for (i = 0; (manager = waiting[cycleDeps[i]]); i++) {
                      if ((cycleManager = findCycle(manager, {}))) {
                          forceExec(cycleManager, {});
                          break;
                      }
                  }
  
              }
  
              //If still waiting on loads, and the waiting load is something
              //other than a plugin resource, or there are still outstanding
              //scripts, then just try back later.
              if (!expired && (stillLoading || context.scriptCount)) {
                  //Something is still waiting to load. Wait for it, but only
                  //if a timeout is not already in effect.
                  if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
                      checkLoadedTimeoutId = setTimeout(function () {
                          checkLoadedTimeoutId = 0;
                          checkLoaded();
                      }, 50);
                  }
                  return undefined;
              }
  
              //If still have items in the waiting cue, but all modules have
              //been loaded, then it means there are some circular dependencies
              //that need to be broken.
              //However, as a waiting thing is fired, then it can add items to
              //the waiting cue, and those items should not be fired yet, so
              //make sure to redo the checkLoaded call after breaking a single
              //cycle, if nothing else loaded then this logic will pick it up
              //again.
              if (context.waitCount) {
                  //Cycle through the waitAry, and call items in sequence.
                  for (i = 0; (manager = waitAry[i]); i++) {
                      forceExec(manager, {});
                  }
  
                  //If anything got placed in the paused queue, run it down.
                  if (context.paused.length) {
                      resume();
                  }
  
                  //Only allow this recursion to a certain depth. Only
                  //triggered by errors in calling a module in which its
                  //modules waiting on it cannot finish loading, or some circular
                  //dependencies that then may add more dependencies.
                  //The value of 5 is a bit arbitrary. Hopefully just one extra
                  //pass, or two for the case of circular dependencies generating
                  //more work that gets resolved in the sync node case.
                  if (checkLoadedDepth < 5) {
                      checkLoadedDepth += 1;
                      checkLoaded();
                  }
              }
  
              checkLoadedDepth = 0;
  
              //Check for DOM ready, and nothing is waiting across contexts.
              req.checkReadyState();
  
              return undefined;
          }