3rd party modules internal modules
424918
function BucketEmptyError(bucket, limiterId) {
  Error.call(this);
  // captureStackTrace is V8-only (node, chrome)
  Error.captureStackTrace(this, BucketEmptyError);

  this.name = 'BucketEmptyError';
  this.message = util.format('%s - All {%d} tokens from this bucket have been used. Retry after %s',
    limiterId || 'anonymous limiter',
    bucket.limit,
    new Date(parseInt(bucket.reset, 10))
  );
}
1141421
def _setup(module, extras):
    """"""

    Qt.__binding__ = module.__name__

    for name in list(_common_members) + extras:
        try:
            submodule = _import_sub_module(
                module, name)
        except ImportError:
            try:
                # For extra modules like sip and shiboken that may not be
                # children of the binding.
                submodule = __import__(name)
            except ImportError:
                continue

        setattr(Qt, "_" + name, submodule)

        if name not in extras:
            # Store reference to original binding,
            # but don't store speciality modules
            # such as uic or QtUiTools
            setattr(Qt, name, _new_module(name))
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;
	}
559693
def _sio_modules(cls, parent_commit):
        """"""
        sio = BytesIO(parent_commit.tree[cls.k_modules_file].data_stream.read())
        sio.name = cls.k_modules_file
        return sio
1321894
function(wirings) {
		
		
		// Reset the internal structure
		this.pipes = wirings;
		this.pipesByName = {};
	
		// Build the "pipesByName" index
		for(var i = 0 ; i < this.pipes.length ; i++) {
          this.pipesByName[ this.pipes[i].name] = this.pipes[i];
		}
		
		//  Customize to display composed module in the left list
		this.updateComposedModuleList();
	
    	this.updateLoadPanelList();

		// Check for autoload param and display the loadPanel otherwise
		if(!this.checkAutoLoad()) { 
    		this.loadPanel.show();
		}
		
	}
66563
def _is_module_included(self, module):
        
        if module in self.exclude_modules:
            return False

        if self.include_modules is None:
            return True

        return module in self.include_modules
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);

}
1087136
function module$1(name, options, executeNow) {
  	if (focused) {
  		return;
  	}

  	if (arguments.length === 2) {
  		if (objectType(options) === "function") {
  			executeNow = options;
  			options = undefined;
  		}
  	}

  	processModule(name, options, executeNow);
  }
672247
function (options, iterationInfo, modules) {

        // Ignore explicitly excluded directories
        if (options.excludeDirs) {
            var match = iterationInfo.fileName.match(options.excludeDirs);
            if (match)
                return;
        }

        // Recursively call requireAll on each child directory
        var subIterationInfo = _.clone(iterationInfo);
        ++subIterationInfo.depth;
        subIterationInfo.dirName = iterationInfo.absoluteFullPath;

        //process subtree recursively
        var subTreeResult = doInterations(options, subIterationInfo);

        //omit empty dirs
        if (_.isEmpty(subTreeResult))
            return;

        //add to the list or to the subtree
        if (options.mode === 'list') {
            //check uniqueness
            _.forEach(subTreeResult, function (value, index) {
                if (options.useVersions === true) {
                    modules[index] = modules[index] || {};
                    _.forEach(value, function (versionValue, versionIndex) {
                        if (modules[index][versionIndex])
                            throw new Error("Identity '" + index + "' with version '" + versionIndex + "' is already registered by module at '" + modules[index][versionIndex].absoluteFullPath + "'");
                        modules[index][versionIndex] = versionValue;
                    });
                }
                else {
                    if (modules[index])
                        throw new Error("Identity '" + index + "' is already registered by module at '" + modules[index].absoluteFullPath + "'");
                    modules[index] = value;
                }
            })
        }
        else if (options.mode === 'tree') {
            if (options.markDirectories !== false) {
                subTreeResult.isDirectory = true;
            }

            var identity = generateIdentity(options, iterationInfo);
            modules[identity] = subTreeResult;
        }
        else
            throw new Error('Unknown mode');
    }
954550
function (e) {
		currentProgram = undefined;
		currentModule = {
			name: null,
			resource: getResourceName(e.filename),
			module: getModuleName(getResourceName(e.filename)),
			localNames: Object.create(null)
		};
	}
814714
function preloadModules (oData) {

		// prealod the modules from the live-edited src
		sap.ui.require.preload(oData.src);

		// require the init module
		sap.ui.require([oData.moduleNameToRequire]);
	}
910203
function initModule(modName, mod) {
        console.log("Initialising "+modName);
        if (mod.init !== undefined)
          mod.init();
      }
284946
def remove_module(self, module):
        
        with ffi.OutputString() as outerr:
            if ffi.lib.LLVMPY_RemoveModule(self, module, outerr):
                raise RuntimeError(str(outerr))
        self._modules.remove(module)
        module._owned = False
1298931
function modGetModulesExports( modules, buildinModules ) {
        var args = [];
        each(
            modules,
            function ( moduleId ) {
                args.push(
                    buildinModules[ moduleId ]
                    || modGetModuleExports( moduleId )
                );
            }
        );

        return args;
    }
616077
function InternalObjectFactory(injector) {
    this.injector = injector;
    this.internalObjects = {
        resources: true,
        reactors: true,
        adapters: true,
        appConfigs: true,
        eventBus: eventBus,
        chainPromises: utils.chainPromises
    };
}
1166582
def init_module(filesystem):
    """"""
    # pylint: disable=protected-access
    FakePath.filesystem = filesystem
    FakePathlibModule.PureWindowsPath._flavour = _FakeWindowsFlavour(
        filesystem)
    FakePathlibModule.PurePosixPath._flavour = _FakePosixFlavour(filesystem)
1198935
function loadMiddlewareModules (options)
  {
    var middlewareStackClasses = [];

    options.internalMiddleware.forEach (function (moduleName)
    {
      var module = require (moduleName);
      if (!module.middleware)
        util.fatal ('No middleware found on module %.', moduleName);
      if (module.options)
        extend (options, module.options);
      middlewareStackClasses.push (module.middleware);
    });

    if (options.externalMiddleware)
      options.externalMiddleware.forEach (function (info)
      {
        var module = require (info.load);
        if (module.options)
          extend (options, new module.options ());
        var target = info.before || info.after
          , i = middlewareStackClasses.indexOf (target);
        if (~i)
          util.fatal ("Can't locate the % middleware module for inserting %.", target, info.load);
        middlewareStackClasses.splice (i + (info.before ? 0 : 1), 0, module.middleware);
      });

    return middlewareStackClasses;
  }