build out the require function specific to the module scope
193476
function makeRequire(module) {
		var mrequire = function(id, fn) { return require(module, id, fn); };
		mrequire.resolve = function(id) { return getModule(module, id).uri; };
		mrequire.toUrl = function(id) {
			return getModule(module, id.replace(/\.[^.\\\/]+$/, ''))
				.uri.replace(/\.js$/i, id.match(/\.[^.\\\/]+$/));
		};
		mrequire.cache = modules;
		mrequire.main = main;
		mrequire.map = mapUrlToIds; // allow mapping multiple module ids to a url
		return mrequire;
	}
380690
function _getScopeParams(config, module, scope={}) {
  return [
    module.exports,
    module.require,
    module,
    module.filename,
    config.basedir || path.dirname(module.filename),
    ...values(scope)
  ];
}
128153
function require_reset() {
    ModuleStore        = {}
    ModulePreloadStore = {}
    MainModule         = create_module(null)

    var require = get_require(MainModule)
    var define  = require_define
    
    define("modjewel", modjewel_module)

    global.modjewel            = require("modjewel")
    global.modjewel.require    = require
    global.modjewel.define     = define
    global.modjewel.define.amd = {implementation: PROGRAM, version: VERSION}
}
434962
function(target) {
                // Only store the `module` in the local cache since `module.exports` may not be accurate
                // if there was a circular dependency
                var module = localCache[target] || (localCache[target] = requireModule(target, dirname));
                return module.exports;
            }
772434
function require(p) {
  var path = require.resolve(p)
  var module = require.modules[path];
  if(!module) throw("couldn't find module for: " + p);
  if(!module.exports) {
    module.exports = {};
    module.call(module.exports, module, module.exports, require.bind(path));
  }
  return module.exports;
}
1125120
def require_oauth_scopes(*scopes):
    
    """
    required_scopes = set(scopes)

    def wrapper(f):
        @wraps(f)
        def decorated(*args, **kwargs):
            # Variable requests.oauth is only defined for oauth requests (see
            # require_api_auth() above).
            if hasattr(request, 'oauth') and request.oauth is not None:
                token_scopes = set(request.oauth.access_token.scopes)
                if not required_scopes.issubset(token_scopes):
                    abort(403)
            return f(*args, **kwargs)
        return decorated
    return wrapper
1225486
def require(obj, caller_args=[]):
    
    line, module = get_module_and_line('__spec__')
    src_params = ExpectParams(line, module)

    require_obj = RequireAssert(
        obj,
        src_params=src_params,
        caller_args=caller_args
    )
    _add_expect_to_wrapper(require_obj)
    return require_obj
687567
function optimizeModules () {
			grunt.log.write("Optimizing...");

			var mainModuleOverride = {
				// Specify a callback to be called for writing down app root modules content.
				// The callback wraps modules content into several nested 'require' calls (one for each layer modules)
				onBuildWrite: function (moduleName, modulePath, contents) {
					if (contents.indexOf("require(") < 0) { return contents; }
					if (modules.indexOf(moduleName) < 0) { return contents; }
					var start = "", end = "";
					layers.forEach(function (l) {
						start += "require([\"" + l.name + "\"], function () {\n";
						end += "\n});";
					});
					return contents.replace("require(", start + "require(") + end;
				}
			};
			function writeGenericCss (moduleName, modulePath, content) {
				grunt.verbose.writeln('Combining ' + moduleName + ' into ' + genericCssPath);
				var genericCssContent;
				if (file.exists(genericCssPath)) {
					genericCssContent = file.readFile(genericCssPath);
				}
				genericCssContent = genericCssContent ? genericCssContent + "\n" + content : content;
				file.saveFile(genericCssPath, genericCssContent);
				// remove original css
				file.deleteFile(modulePath);
			}
			// See https://github.com/jrburke/r.js/blob/master/build/example.build.js
			var config = lang.extend({}, requireConfig, {
				isOptimizeStage: true,
				optimize: options.optimizeJs,
				optimizeCss: options.optimizeCss,
				appDir: buildDir,
				dir: outputDir,
				baseUrl: "./",
				logLevel: 2, // WARN
				removeCombined: true,
				//skipDirOptimize: false,
				skipDirOptimize: true,
				keepBuildDir: false,
				locale: options.bundledLocale,
				preserveLicenseComments: options.preserveLicenseComments,
				generateSourceMaps: options.generateSourceMaps,
				writeGenericCss: writeGenericCss,
				// Custom parameter for xcss.js: path from 'generic.css' to baseDir
				genericCssToRootPath: genericCssToRootPath,
				// Pragmas for rjs plugins:
				pragmas: {
					optimize: true,
					build: true
				},
				pragmasOnSave: {
					optimizeSave: true
				},
				modules: [
					// here we'll combine layer modules and app root modules
				]
			});
			if (options.requireConfigOutput) {
				config = lang.extendEx(config, options.requireConfigOutput, {deep: true});
			}

			// Initialize config.modules - root modules to optimize
			// First we're adding "layer modules" (built on the previous step)
			var excludedLayers = options.ignoreModules;
			layers.forEach(function (l) {
				config.modules.push({
					name: l.name,
					exclude: excludedLayers.slice()
				});
				excludedLayers.push(l.name);
			});
			// then add root application modules (main.js and so on)
			modules.forEach(function (m) {
				config.modules.push({
					name: m,
					exclude: excludedLayers,
					override: mainModuleOverride
				});
			});
			// options for particular layers
			if (options.layerOverrides) {
				config.modules.forEach(function (layer) {
					var name = layer.name;
					var overrides = options.layerOverrides[name];
					if (overrides) {
						// convert task's format into rjs format:
						if (overrides.optimizeJs) {
							overrides.optimize = overrides.optimizeJs;
						}
						if (layer.override) {
							layer.override = lang.extendEx(layer.override, overrides, {deep: true});
						} else {
							layer.override = overrides;
						}
					}
				});
			}

			requirejs.optimize(
				config,
				lang.safeCallback(optimizeBootModules),
				lang.errorCallback
			);
		}
243429
function define(id, deps, exp) {
		if (!exp) { exp = deps; deps = [ 'require', 'exports', 'module' ]; }
		var module = getModule(undefined, id);
		module.children = map(deps, function(dep) { return getModule(module, dep); });
		module.loaded = true;
		factories[id] = exp;
		fireWaits(module);
	}
1082064
function wrap(content, scope) {
  const scopeParams = Object.keys(scope).join(',');
  const comma = ((scopeParams !== '')?', ':'');
  return `(function (exports, require, module, __filename, __dirname${comma}${scopeParams}) {
    ${content}
  });`
}
1140470
function mock(_module, _exports) {
	delete require.cache[require.resolve(_module)];
	require(_module);
	_exports && (require.cache[require.resolve(_module)].exports = _exports);
	return require(_module);
}
456117
function(module, exports, __webpack_require__) {

	var __vue_exports__, __vue_options__
	
	/* styles */
	__webpack_require__(/*! !vue-style-loader!css-loader?sourceMap!vue-loader/lib/style-rewriter?id=data-v-3d9c874b!vue-loader/lib/selector?type=styles&index=0!./foo.vue */ 4)
	
	/* script */
	__vue_exports__ = __webpack_require__(/*! !babel-loader!vue-loader/lib/selector?type=script&index=0!./foo.vue */ 8)
	
	/* template */
	var __vue_template__ = __webpack_require__(/*! !vue-loader/lib/template-compiler?id=data-v-3d9c874b!vue-loader/lib/selector?type=template&index=0!./foo.vue */ 9)
	__vue_options__ = __vue_exports__ = __vue_exports__ || {}
	if (
	  typeof __vue_exports__.default === "object" ||
	  typeof __vue_exports__.default === "function"
	) {
	if (Object.keys(__vue_exports__).some(function (key) { return key !== "default" && key !== "__esModule" })) {console.error("named exports are not supported in *.vue files.")}
	__vue_options__ = __vue_exports__ = __vue_exports__.default
	}
	if (typeof __vue_options__ === "function") {
	  __vue_options__ = __vue_options__.options
	}
	__vue_options__.__file = "/Users/zyy/zyy/web-lib/zoro-kit-vue/src/js/module/hello/foo.vue"
	__vue_options__.render = __vue_template__.render
	__vue_options__.staticRenderFns = __vue_template__.staticRenderFns
	
	/* hot reload */
	if (false) {(function () {
	  var hotAPI = require("vue-hot-reload-api")
	  hotAPI.install(require("vue"), false)
	  if (!hotAPI.compatible) return
	  module.hot.accept()
	  if (!module.hot.data) {
	    hotAPI.createRecord("data-v-3d9c874b", __vue_options__)
	  } else {
	    hotAPI.reload("data-v-3d9c874b", __vue_options__)
	  }
	})()}
	if (__vue_options__.functional) {console.error("[vue-loader] foo.vue: functional components are not supported and should be defined in plain js files using render functions.")}
	
	module.exports = __vue_exports__


/***/ }
1336266
function _loadDependencies(moduleName, localParams) {
                    var loadedModule,
                        requires,
                        diff,
                        promisesList = [],
                        self = this;

                    moduleName = self._getModuleName(moduleName);

                    if (moduleName === null) {
                        return $q.when();
                    } else {
                        try {
                            loadedModule = self._getModule(moduleName);
                        } catch (e) {
                            return reject(e);
                        }
                        // get unloaded requires
                        requires = self.getRequires(loadedModule);
                    }

                    angular.forEach(requires, function (requireEntry) {
                        // If no configuration is provided, try and find one from a previous load.
                        // If there isn't one, bail and let the normal flow run
                        if (angular.isString(requireEntry)) {
                            var config = self.getModuleConfig(requireEntry);
                            if (config === null) {
                                moduleCache.push(requireEntry); // We don't know about this module, but something else might, so push it anyway.
                                return;
                            }
                            requireEntry = config;
                            // ignore the name because it's probably not a real module name
                            config.name = undefined;
                        }

                        // Check if this dependency has been loaded previously
                        if (self.moduleExists(requireEntry.name)) {
                            // compare against the already loaded module to see if the new definition adds any new files
                            diff = requireEntry.files.filter(function (n) {
                                return self.getModuleConfig(requireEntry.name).files.indexOf(n) < 0;
                            });

                            // If the module was redefined, advise via the console
                            if (diff.length !== 0) {
                                self._$log.warn('Module "', moduleName, '" attempted to redefine configuration for dependency. "', requireEntry.name, '"\n Additional Files Loaded:', diff);
                            }

                            // Push everything to the file loader, it will weed out the duplicates.
                            if (angular.isDefined(self.filesLoader)) {
                                // if a files loader is defined
                                promisesList.push(self.filesLoader(requireEntry, localParams).then(function () {
                                    return self._loadDependencies(requireEntry);
                                }));
                            } else {
                                return reject(new Error('Error: New dependencies need to be loaded from external files (' + requireEntry.files + '), but no loader has been defined.'));
                            }
                            return;
                        } else if (angular.isArray(requireEntry)) {
                            var files = [];
                            angular.forEach(requireEntry, function (entry) {
                                // let's check if the entry is a file name or a config name
                                var config = self.getModuleConfig(entry);
                                if (config === null) {
                                    files.push(entry);
                                } else if (config.files) {
                                    files = files.concat(config.files);
                                }
                            });
                            if (files.length > 0) {
                                requireEntry = {
                                    files: files
                                };
                            }
                        } else if (angular.isObject(requireEntry)) {
                            if (requireEntry.hasOwnProperty('name') && requireEntry['name']) {
                                // The dependency doesn't exist in the module cache and is a new configuration, so store and push it.
                                self.setModuleConfig(requireEntry);
                                moduleCache.push(requireEntry['name']);
                            }
                        }

                        // Check if the dependency has any files that need to be loaded. If there are, push a new promise to the promise list.
                        if (angular.isDefined(requireEntry.files) && requireEntry.files.length !== 0) {
                            if (angular.isDefined(self.filesLoader)) {
                                // if a files loader is defined
                                promisesList.push(self.filesLoader(requireEntry, localParams).then(function () {
                                    return self._loadDependencies(requireEntry);
                                }));
                            } else {
                                return reject(new Error('Error: the module "' + requireEntry.name + '" is defined in external files (' + requireEntry.files + '), but no loader has been defined.'));
                            }
                        }
                    });

                    // Create a wrapper promise to watch the promise list and resolve it once everything is done.
                    return $q.all(promisesList);
                }
1110207
function (moduleName, modulePath, contents) {
					if (contents.indexOf("require(") < 0) { return contents; }
					if (modules.indexOf(moduleName) < 0) { return contents; }
					var start = "", end = "";
					layers.forEach(function (l) {
						start += "require([\"" + l.name + "\"], function () {\n";
						end += "\n});";
					});
					return contents.replace("require(", start + "require(") + end;
				}
283632
function amdefineWorkaround(requiredModule)
{
  // prepare define function
  var define = amdefine(requiredModule, this.pretendRequire(requiredModule));

  // return wrapper
  function wrapper(id, deps, initializer)
  {
    // init module
    define(id, deps, initializer);

    // if module provides id
    // force it to be executed anyway
    if (typeof id == 'string')
    {
      requiredModule.exports = define.require(id);
    }
  }

  // make it look like legit thing
  if (this.exposeAmdefine)
  {
    wrapper.amd     = define.amd;
    wrapper.require = define.require;
  }

  return wrapper;
}
547179
function(moduleName) {
		var fs = require("fs");
		var ret = false;
    	var dirSeparator = require("path").sep
    	module.paths.forEach(function(nodeModulesPath) {
        	if(fs.existsSync(nodeModulesPath + dirSeparator + moduleName) === true) {
            	ret = true;
            	return false;
        	}
    	});
    	return ret;
	}
120871
function require(name) {
  var module = require.modules[name];
  if (!module) throw new Error('failed to require "' + name + '"');

  if (!('exports' in module) && typeof module.definition === 'function') {
    module.client = module.component = true;
    module.definition.call(this, module.exports = {}, module);
    delete module.definition;
  }

  return module.exports;
}