Begins loading modules asynchronously
762367
function(moduleIds) {
		for (var i = moduleIds.length; i--;) {
			var moduleId = moduleIds[i],
				module = getModule(moduleId);

			if (module == null) {
				module = _modules[moduleId] = {};
				_fetchFunc(moduleId);
			}
		}
	}
814031
function(parentModule, kbox, id, app, callback) {

  if (typeof callback === 'undefined' && typeof app === 'function') {
    callback = app;
    app = undefined;
  }

  // Try to load module from node_module directories.
  return requireFromNodeModules(parentModule, id)
  // If module was not found in node_module directories, try to load
  // from other directories.
  .then(function(mod) {
    if (mod) {
      return mod;
    } else {
      return requireFromOtherDirs(kbox, id, app);
    }
  })
  // Return.
  .nodeify(callback);

}
492376
def load(modname, verbose=False, failfast=False):
    
    for app in settings.INSTALLED_APPS:
        get_module(app, modname, verbose, failfast)
1357096
function optimizeBootModules () {
			grunt.log.writeln('OK'.green);
			if (!options.dirs || !options.dirs.length) {
				finalize();
				return;
			}
			grunt.util.async.forEachSeries(options.dirs, function(dir, next) {
				if (typeof dir === 'string') {
					dir = {
						combine: false,
						name: dir
					}
				}
				optimizeDir(dir, next);
			}, function () {
				finalize();
			});
		}
89113
function(){
		if(shuttingDown == true)
			return;
		modules.logger.log("startup","ISNode System > Loading Dependencies...");
		loadCriticalModules();
		loadNonCriticalModules();
		loadInterfaceModules();
		startEventLoop();
		return true;
	}
648524
function(module) {
		var name = module.$modname;
		if (!this.$hasModule(name)) {
			this._modules.push(module);
			if (gui.Type.isFunction(module.oncontextinitialize)) {
				module.oncontextinitialize(window);
			}
			if (gui.Type.isFunction(module.onrun)) {
				module.onrun();
			}
		} else {
			throw new Error(name + ' loaded twice?');
		}
		return module;
	}
11957
public void onModuleLoad() {
		DockPanel dock = new DockPanel();
		dock.addStyleName("mainBackground");
		dock.setWidth("700px");
		dock.setHeight("300px");
		dock.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_CENTER);
		dock.setVerticalAlignment(HasVerticalAlignment.ALIGN_TOP);

		dock.add(createHeader(), DockPanel.NORTH);

		// Time Picker Examples
		dock.add(createTimePicker(), DockPanel.WEST);
		// Time Picker Small Examples
		dock.add(createSmallTimePicker(), DockPanel.WEST);
		// iOSButton Examples
		dock.add(createIOSButton(), DockPanel.WEST);
		// DatePicker Examples
		dock.add(createDatePicker(), DockPanel.WEST);

		RootPanel.get().add(dock);
	}
1306812
function moduleActivator(defers, meaniosingleton, loadedmodule) {
    if (loadedmodule) {
        meaniosingleton.app.useStatic('/' + loadedmodule.name, loadedmodule.source + '/public');
        var defer = Q.defer();
        defers.push(defer);
        loadedmodule.activate();
        meaniosingleton.resolve(loadedmodule.name, defer.resolve.bind(defer));
    }
}
379845
public void onModuleLoad() {
    VueGWT.init();

    // Inject JS Components
    HTMLScriptElement scriptElement =
        (HTMLScriptElement) DomGlobal.document.createElement("script");
    scriptElement.text = JsFilesResources.INSTANCE.jsComponents().getText();
    DomGlobal.document.body.appendChild(scriptElement);

    MelisandreComponentClientBundle.INSTANCE.melisandreComponentStyle().ensureInjected();
    Vue.customElement("animal-selector", AnimalSelectorComponentFactory.get());

    VueGwtExamplesService.initExamples();
  }
731417
function(){
		if(shuttingDown == true)
			return;
		modules.logger.log("startup","ISNode System > Loading Interface Modules...");
		var fs = require('fs');
		fs.readdirSync("./node_modules").forEach(function(file) {
  			fileSplit = file.split("-");
  			if(fileSplit[0] == "isnode" && fileSplit[1] == "mod" && fileSplit[2] == "interface" && fileSplit[3]) {
  				loadModule(file);
  			}
		});		
		return true;
	}
1273301
function moduleLoaded(resolve, requires, modName, data, loadedModuleData, alreadyMinified){
    // Check for any modules used from this module that we don't already have
    var newRequires = getModulesRequired(data);
    console.log(" - "+modName+" requires "+JSON.stringify(newRequires));
    // if we need new modules, set them to load and get their promises
    var newPromises = [];
    for (var i in newRequires) {
      if (requires.indexOf(newRequires[i])<0) {
        console.log("   Queueing "+newRequires[i]);
        requires.push(newRequires[i]);
        newPromises.push(loadModule(requires, newRequires[i], loadedModuleData));
      } else {
        console.log("   Already loading "+newRequires[i]);
      }
    }

    var loadProcessedModule = function (module) {
      // add the module to the beginning of our array
      if (Espruino.Config.MODULE_AS_FUNCTION)
        loadedModuleData.unshift("Modules.addCached(" + JSON.stringify(module.name) + ",function(){" + module.code + "});");
      else
        loadedModuleData.unshift("Modules.addCached(" + JSON.stringify(module.name) + "," + JSON.stringify(module.code) + ");");
      // if we needed to load something, wait until we have all promises complete before resolving our promise!
      Promise.all(newPromises).then(function(){ resolve(); });
    }
    if (alreadyMinified)
      loadProcessedModule({code:data,name:modName});
    else
      Espruino.callProcessor("transformModuleForEspruino", {code:data,name:modName}, loadProcessedModule);
  }
476969
function(deps, cb, refPath) {
		var unreadyModules = [];

		for (var i = deps.length; i--;) {
			var moduleId = resolveModuleId(deps[i], refPath),
				module = getModule(moduleId);

			if (!areDeepDepsDefined(moduleId)) {
				unreadyModules.push(moduleId);
			}
		}

		if (unreadyModules.length) {
			addCallback(unreadyModules, function() {
				cb(createRequireFunc(refPath));
			});
			queueModules(unreadyModules);
		}
		else {
			setTimeout(function() {
				cb(createRequireFunc(refPath));
			}, 0);
		}
	}
1329196
function preloadRequire (module) {
  if (loadedModules.has(module)) {
    return loadedModules.get(module)
  }
  throw new Error(`module not found: ${module}`)
}
753333
def load_module(self, module_name, path=None):
        ''''''
        self.ensure_started()
        if path is None:
            path = sys.path
        mod = self.client.call(_load_module, module_name, path)
        mod.__isolation_context__ = self
        return mod
1274528
function loaded() {
            if (shimConf) {
                var exports;
                if (typeof shimConf.init === 'function') {
                    exports = shimConf.init.apply(
                        global,
                        modGetModulesExports(shimDeps, BUILDIN_MODULE)
                    );
                }

                if (exports == null && shimConf.exports) {
                    exports = global;
                    each(
                        shimConf.exports.split('.'),
                        function (prop) {
                            exports = exports[prop];
                            return !!exports;
                        }
                    );
                }

                globalDefine(moduleId, shimDeps, function () { 
                    return exports || {};
                });
            }
            else {
                modCompletePreDefine(moduleId);
            }

            modAutoDefine();
        }
1356116
def _on_startup(self, *args):
        
        yield from Controller.instance().start()
        # Because with a large image collection
        # without md5sum already computed we start the
        # computing with server start
        asyncio.async(Qemu.instance().list_images())
1024077
function (grunt, rootPath, tasks) {
		tasks.forEach(function (name) {
			if (name === 'grunt-cli') return;
			var cwd = process.cwd();
			process.chdir(rootPath); // load files from proper root, I don't want to install everything locally per module!
			grunt.loadNpmTasks(name);
			process.chdir(cwd);
		});
	}