TODO: remove this method and make the modules bindable *
@deprecated will be removed soon
@return {Array}
1222
function () {
                var modules = [], conf;
                for (var i = 0; i < this.$configurations.length; i++) {
                    conf = this.$configurations[i];
                    if (conf instanceof ModuleConfiguration) {
                        modules.push(conf.$.name);
                    }
                }
                return modules;
            }
498033
function modules() {
  // Bootstrap
  var bootstrap = gulp.src('./node_modules/bootstrap/dist/**/*')
    .pipe(gulp.dest('./vendor/bootstrap'));
  // Font Awesome
  var fontAwesome = gulp.src('./node_modules/@fortawesome/**/*')
    .pipe(gulp.dest('./vendor'));
  // jQuery
  var jquery = gulp.src([
      './node_modules/jquery/dist/*',
      '!./node_modules/jquery/dist/core.js'
    ])
    .pipe(gulp.dest('./vendor/jquery'));
  return merge(bootstrap, fontAwesome, jquery);
}
32863
function () {
            this.unloadCommonModules();
            var pageModRefpaths = this._modulesPaths.page;
            for (var pageId in pageModRefpaths) {
                if (pageModRefpaths.hasOwnProperty(pageId)) {
                    this.unloadPageModules(pageId);
                }
            }
        }
260490
function (module) {

            var moduleObj;

            if (typeof module !== "string") {
                throw new Error("Missing or invalid argument");
            }

            if (!_initialized) {
                throw new Error("The Browser History Manager is not initialized");
            }

            moduleObj = _modules[module];
            if (!moduleObj) {
                throw new Error("No such registered module: " + module);
            }

            return unescape(moduleObj.currentState);
        }
551377
function removeExcludedModules(modules, packageForceExcludes, log) {
  const excludedModules = _.remove(modules, externalModule => {   // eslint-disable-line lodash/prefer-immutable-method
    const splitModule = _.split(externalModule, '@');
    // If we have a scoped module we have to re-add the @
    if (_.startsWith(externalModule, '@')) {
      splitModule.splice(0, 1);
      splitModule[0] = '@' + splitModule[0];
    }
    const moduleName = _.first(splitModule);
    return _.includes(packageForceExcludes, moduleName);
  });

  if (log && !_.isEmpty(excludedModules)) {
    this.serverless.cli.log(`Excluding external modules: ${_.join(excludedModules, ', ')}`);
  }
}
927500
function fromRawMappings(modules: Array<ModuleTransport>): Generator {
  const generator = new Generator();
  let carryOver = 0;

  for (var j = 0, o = modules.length; j < o; ++j) {
    var module = modules[j];
    var {code, map} = module;

    if (Array.isArray(map)) {
      addMappingsForFile(generator, map, module, carryOver);
    } else if (map != null) {
      throw new Error(
        `Unexpected module with full source map found: ${module.sourcePath}`
      );
    }

    carryOver = carryOver + countLines(code);
  }

  return generator;
}
1233609
function getCleanTargets() {
    var directDeps = targets.map(function (pattern) {
            return '*/' + pattern;
        }),

        indirectDeps = targets.map(function (pattern) {
            return '**/node_modules/*/' + pattern;
        });

    return directDeps.concat(indirectDeps);
}
767840
function bootstrap(bootstrapModules) {

  var modules = [],
      components = [];

  function hasModule(m) {
    return modules.indexOf(m) >= 0;
  }

  function addModule(m) {
    modules.push(m);
  }

  function visit(m) {
    if (hasModule(m)) {
      return;
    }

    (m.__depends__ || []).forEach(visit);

    if (hasModule(m)) {
      return;
    }

    addModule(m);

    (m.__init__ || []).forEach(function(c) {
      components.push(c);
    });
  }

  bootstrapModules.forEach(visit);

  var injector = new Injector(modules);

  components.forEach(function(c) {

    try {
      // eagerly resolve component (fn or string)
      injector[typeof c === 'string' ? 'get' : 'invoke'](c);
    } catch (e) {
      console.error('Failed to instantiate component');
      console.error(e.stack);

      throw e;
    }
  });

  return injector;
}
1124206
function getDefaultModules()
{
    return {
        rules :
        [
            {
                test : /\.css$/,
                use  : [ 'style-loader', 'css-loader' ]
            },
            {
                test : /\.(png|jpg|gif)$/,
                use  :
                [
                    {
                        loader  : 'url-loader',
                        options : { limit: 8192 }
                    }
                ]
            },
            {
                test : /\.html$/,
                use  : 'raw-loader'
            },
            {
                test : /\.svg(\?v=\d+\.\d+\.\d+)?$/,
                use  :
                {
                    loader  : 'url-loader',
                    options :
                    {
                        limit    : 8192,
                        mimetype : 'image/svg+xml'
                    }
                }
            }
        ]
    };
}
743946
function () {
            var bindings = this._bindings;
            for (var refpath in bindings) {
                if (bindings.hasOwnProperty(refpath)) {
                    var moduleBindings = bindings[refpath];
                    for (var bind in moduleBindings) {
                        if (moduleBindings.hasOwnProperty(bind)) {
                            var moduleDataDescription = this._getModuleDataDescription(refpath, bind);
                            var location = this._getStorage(moduleBindings[bind][0]);
                            var storedValue = this._utils.resolvePath(location.path, location.storage);
                            this.json.setValue(moduleDataDescription.container, moduleDataDescription.property, storedValue, moduleBindings[bind][1]);
                        }
                    }
                }
            }
        }
269452
function nodeModules() {
  return fs.readdirSync('node_modules')
           .filter(dir => ['.bin'].indexOf(dir) === -1)
           .reduce((modules, m) => {
             modules[m] = 'commonjs2 ' + m
             return modules
           }, {})
}
668329
function _getModule (moduleElement) {
    var id = moduleElement.getAttribute('id');
    var dir = moduleElement.getAttribute('dir');
    var name = moduleElement.getAttribute('name');
    var fileSets = domutils.getChild(moduleElement, 'desc', 'fileSets');
    var modules = domutils.getChild(moduleElement, 'desc', 'modules');
    var module = { id: id, dir: dir, name: name, fileSets: [], modules: [] };
    if (fileSets !== undefined) {
      var fileSetElements = domutils.selectMatchingXPath('desc:fileSet', fileSets);
      var numFileSets = fileSetElements.length;
      for (var fsIdx = 0; fsIdx < numFileSets; fsIdx++) {
        module.fileSets.push(_getFileSet(fileSetElements[fsIdx]));
      }
    }
    if (modules !== undefined) {
      var moduleElements = domutils.selectMatchingXPath('desc:module', modules);
      var numModules = moduleElements.length;
      for (var mIdx = 0; mIdx < numModules; mIdx++) {
        module.modules.push(_getModule(moduleElements[mIdx]));
      }
    }
    return module;
  }
663363
function ModuleGraph(moduleData) {
  var self = this;
  var modules = {};
  var moduleNameList = [];
  moduleData.forEach(function(info) {
    var m = new Module(info);
    modules[info.name] = m;
    moduleNameList.push(info.name);
  });

  /**
   * Get a list of all module names.
   * @return {Array.<string>} List of module names.
   */
  this.getAllModules = function() {
    return moduleNameList;
  };

  /**
   * Get transitive dependencies for a given module
   * @param {string} name Name of the module.
   * @return {Array.<string>} List of module names.
   */
  this.getTransitiveDependencies = function(name) {
    var m = getModule(name);
    return m.transitiveDeps || [];
  };

  function getModule(name) {
    var m = modules[name];
    if (!m) {
      throw new self.NotFoundException(name);
    }
    return m;
  }

  /**
   * Error object used when a requested module cannot be found.
   * @constructor
   */
  this.NotFoundException = function(name) {
    var msg = 'Unknown module: ' + name;
    this.name = name;
    this.message = msg;
    Error.call(this, msg);
  };
  this.NotFoundException.prototype = new Error();
  this.NotFoundException.prototype.statusCode = 404;

  /**
   * Gets the requested module names and their transitive deps minus the
   * transitive deps (and the) of the optional excluded names.
   * @param {Array.<string>} moduleNames List of module names.
   * @apram {Array.<string>} opt_excludeNames List of module names to exclude.
   * @return {Array.<string>} List of module names.
   */
  this.getModules = function(moduleNames, opt_excludeNames) {
    var list = [];
    var seen = {};
    var exclude = {};

    if (opt_excludeNames) {
      opt_excludeNames.forEach(function(name) {
        exclude[name] = true;
        var m = getModule(name);
        m.transitiveDeps.forEach(function(name) {
          exclude[name] = true;
        });
      });
    }

    function addModule(name) {
      if (!seen[name] && !exclude[name]) {
        seen[name] = true;
        list.push(name)
      }
    }
    moduleNames.forEach(function(name) {
      var m = getModule(name);
      m.transitiveDeps.forEach(addModule);
      addModule(m.name);
    });
    return list;
  };
}
92021
public function getModulesAsArray()
    {

        // initialize the array for the modules
        $modules = array();

        // iterate over the module nodes and sort them into an array
        /** @var \AppserverIo\Appserver\Core\Api\Node\ModuleNode $module */
        foreach ($this->getModules() as $module) {
            $modules[$module->getUuid()] = $module->getType();
        }

        // return the array
        return $modules;
    }
1272485
function() {
			return Array.map(this, function(thing) {
				if (edb.Type.is(thing)) {
					return thing.toJSON();
				}
				return thing;
			});
		}
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;
	}
741677
function () {
        var module = "Global";
        for(var i = 0; i < doc.tags.length; i++) {
            var tag = doc.tags[i];
            if (tag.type === "method") {
                module = tag.content;
            }
            else if (tag.type === "function") {
                module = tag.content;
            }
        }
        
        return module.trim();
    }