Load config module.
@param  {String} name Config module name.
@return {Function} `null` if module not found.
493846
function(name) {
  try {
    debug(`Loading ${name} configuration`);

    return waigo.load(`config/${name}`);
  } catch (e) {
    debug(`Error loading config: ${name}`);
    debug(e);

    return null;
  }
}
434291
function(name) {
    if (cache[name]) {
        return cache[name]
    } else {
        if (require) {
            return require(name)
        } else if (window.require) {
            return window.require(name)

        } else {
            throw new Error("Cannot find module " + name)
        }
    }
}
1024674
public function loadModule($name)
    {
        // is the module already loaded?
        if (isset($this->_modules[$name])) {
            $this->log(SMARTIRC_DEBUG_NOTICE, 'WARNING! module with the name "'
                .$name.'" already loaded!', __FILE__, __LINE__
            );
            return false;
        }

        $classname = "Net_SmartIRC_module_$name";
        if (class_exists($classname)) {
            $this->log(SMARTIRC_DEBUG_MODULES, "DEBUG_MODULES: \"$name\" module class"
                .' exists, initializing...', __FILE__, __LINE__
            );
        } else {
            $filename = $this->_modulepath."/$name.php";
            if (!file_exists($filename)) {
                $this->log(SMARTIRC_DEBUG_MODULES, "DEBUG_MODULES: couldn't load "
                    ."module; file \"$filename\" doesn't exist", __FILE__, __LINE__
                );
                return false;
            }
            // pray that there is no parse error, it will kill us!
            include_once($filename);

            if (!class_exists($classname)) {
                $this->log(SMARTIRC_DEBUG_MODULES, "DEBUG_MODULES: class $classname"
                    ." not found in $filename, aborting...", __FILE__, __LINE__
                );
                return false;
            }

            $this->log(SMARTIRC_DEBUG_MODULES, 'DEBUG_MODULES: loading module '
                ."\"$name\" from file...", __FILE__, __LINE__
            );
        }

        $methods = array_flip(get_class_methods($classname));

        if (!(isset($methods['__construct']) || isset($methods['module_init']))) {
            $this->log(SMARTIRC_DEBUG_MODULES, 'DEBUG_MODULES: required method '
                .$classname.'::__construct() not found, aborting...',
                __FILE__, __LINE__
            );
            return false;
        }

        if (!(isset($methods['__destruct']) || isset($methods['module_exit']))) {
            $this->log(SMARTIRC_DEBUG_MODULES, 'DEBUG_MODULES: required method '
                .$classname.'::__destruct() not found, aborting...',
                __FILE__, __LINE__
            );
            return false;
        }

        $vars = get_class_vars($classname);
        $required = array('name', 'description', 'author', 'license');

        foreach ($required as $varname) {
            if (!isset($vars[$varname])) {
                $this->log(SMARTIRC_DEBUG_NOTICE, 'NOTICE: required module'
                    ."property {$classname}::\${$varname} not found.",
                    __FILE__, __LINE__
                );
            }
        }

        // looks like the module satisfies us, so instantiate it
        if (isset($methods['module_init'])) {
            // we're using an old module_init style module
            $this->_modules[$name] = new $classname;
            $this->log(SMARTIRC_DEBUG_MODULES, 'DEBUG_MODULES: calling '
                .$classname.'::module_init()', __FILE__, __LINE__
            );
            $this->_modules[$name]->module_init($this);
        } else if (func_num_args() == 1) {
            // we're using a new __construct style module, which maintains its
            // own reference to the $irc client object it's being used on
            $this->_modules[$name] = new $classname($this);
        } else
        // we're using new style AND we have args to pass to the constructor
        if (func_num_args() == 2) {
            // only one arg, so pass it as is
            $this->_modules[$name] = new $classname($this, func_get_arg(1));
        } else {
            // multiple args, so pass them in an array
            $this->_modules[$name] = new $classname($this, array_slice(func_get_args(), 1));
        }

        $this->log(SMARTIRC_DEBUG_MODULES, 'DEBUG_MODULES: successfully loaded'
            ." module: $name", __FILE__, __LINE__
        );
        return $this;
    }
195211
public function getModule($name)
    {
        if ($this->isLoaded($name)) {
            return $this->loaded[$name];
        } else {
            return $this->loadModuleByName($name);
        }
    }
47699
function(name, config) {
            config = config || {};
            config = _.defaults(config, {
                loader: configs.resources.loader
            });
            config = _.extend(config, {
                namespace: name
            });
            Resources.namespaces[name] = config;
        }
167565
async function loadModulesConfig()
{
    if(!modulesLoaded)
    {
		for (let i = 0; i < modules.length; i++) {
			await applyBotDataSource(modules[i]);
        }
        
        modulesLoaded = true;
    }
}
213353
def load_module(self, name):
        
        # allow reload noop
        if name in sys.modules:
            return sys.modules[name]
        raise DisabledIncludeError('Include type %r disabled, cannot import module %r' % (self._module_prefix, name))
1195952
public function &load(string $name) : ModularAbstract
    {
        $modular =& $this->internalGetModular($name);
        if (!$this->hasLoaded($name)) {
            $modular->init();
            $this->loadedModular[$this->sanitizeModularName($name)] = true;
        }

        return $modular;
    }
416282
public Class loadClass(String name)
    {
        try
        {
            return classLoader.loadClass( name );
        }
        catch (ClassNotFoundException notFound)
        {
            return null;
        }
        catch (NoClassDefFoundError notFound)
        {
            return null;
        }
    }
1172335
@Nullable
  JSModule getModuleByName(String name) {
    for (JSModule m : modules) {
      if (m.getName().equals(name)) {
        return m;
      }
    }
    return null;
  }
605492
def get_module_config(self, name):
    
    if self.exists("modules"):
      if name in self._json["modules"] and not isinstance(self._json["modules"][name], str):
        return self._json["modules"][name]
    return None
601930
function load(mod) {
    if (typeof(mod.factory) === "function") {
      return require(mod.deps, mod.factory);
    }
    return mod.factory;
  }
1218104
function _requireModule(rootPath, name) {
  let modulePath = _normalizeRequire(rootPath, name),
    moduleRes;
  try {
    moduleRes = require(modulePath);
  } catch (e) {
    if (e.code === 'MODULE_NOT_FOUND' && e.message.indexOf(name) !== -1) {
      try {
        moduleRes = require(name);
      } catch (e) {
        if (e.code === 'MODULE_NOT_FOUND' && e.message.indexOf(name) !== -1) {
          throw "NOT_FOUND";
        }
        throw e;
      }
    } else {
      throw e;
    }
  }
  return moduleRes;
}
133677
public function loadConfig($name)
    {
        // only if config not yet exists
        if (!$this->configExists($name))
            $this->config[$name] = $this->getConfigObjectFromDatabase($name);
    }
819101
public function getConfig($name = null)
    {
        if (!is_null($name)) {
            if (isset($this->_config[$name])) {
                return $this->_config[$name];
            } else {
                return null;
            }
        }

        return $this->_config;
    }
768270
function require(name, jumped){
    if (cache[name]) return cache[name].exports;
    if (modules[name]) return call(name, require);
    throw new Error('cannot find module "' + name + '"');
  }
1259557
def load_module(self, name):
        """"""
        if name in sys.modules:
            return sys.modules[name]
        # load the actual import hook module
        module_name = self.mount2name(name)
        __import__(module_name)
        # alias the import hook module to the mount, so both can be used interchangeably
        module = sys.modules[name] = sys.modules[module_name]
        module.install()
        return module