Module.prototype.require = function(filename, needjsc) {
if (!needjsc) {
return _old_require.call(this, filename);
}
filename = Module._resolveFilename(filename, this);
if (typeof(filename) === 'object') filename = filename[0];
if (exports.enableModuleCache) {
var cachedModule = Module._cache[filename];
if (cachedModule) {
return cachedModule.exports;
}
}
var module = new Module(filename, this);
Module._cache[filename] = module;
try {
module.load(filename);
module.filename = filename;
module.paths = Module._nodeModulePaths(path.dirname(filename));
module.loaded = true;
module.needjsc = needjsc; // need jscoverage process
Module._extensions['.js'](module, filename);
} catch (err) {
delete Module._cache[filename];
throw err;
}
return module.exports;
}
exports.getRequireFunc = function(filename) {
// construct fake module object with useful context
var Module = require('module'),
newModule = new Module(filename, module),
// construct require() function
requireFunc = function(request) {
return newModule.require(request);
};
// construct require.resolve() function
requireFunc.resolve = function(request) {
return Module._resolveFilename(request, newModule);
};
// set module filename for internal use
newModule.filename = filename;
// construct search module paths for require() and require.resolve()
newModule.paths = Module._nodeModulePaths(PATH.dirname(filename));
return requireFunc;
};
function resolveModule(path) {
var localPath = resolve(here, path)
var hasMod = localPath.indexOf("/__mod/"), parent, modPath, resolved
if (hasMod > -1) {
parent = localPath.slice(0, hasMod)
modPath = localPath.slice(hasMod + 7)
} else {
parent = here
modPath = localPath
}
var dummyMod = {
id: parent,
paths: module_._nodeModulePaths(parent).concat(module_.globalPaths)
}
try { resolved = unwin(module_._resolveFilename(modPath, dummyMod)) }
catch(e) { return null }
// Handle builtin modules resolving to strings like "fs", try again
// with slash which makes it possible to locally install an equivalent.
if (resolved.indexOf("/") == -1) {
try { resolved = unwin(module_._resolveFilename(modPath + "/", dummyMod)) }
catch(e) { return null }
}
return relative(here, resolved)
}
function executeConfigFile(saveForReset, ignoreBaseURL, configPath, source) {
var self = this;
// create a safe loader to give to the config execution
var configLoader = Object.create(this.loader);
configLoader.config = function(cfg) {
self.config(cfg, saveForReset, ignoreBaseURL);
};
// make everything in global available to config file code
// only substitute local copy of System
// and prevent that code from adding anything to the real global
var context = Object.create(global);
context.SystemJS = context.System = configLoader;
context.global = context;
if (process.versions.node && process.versions.node.split('.')[0] < 6)
context.GLOBAL = context.root = context;
// make require available too, make it look as if config file was
// loaded like a module
var Module = require('module');
var m = new Module(configPath);
m.filename = configPath;
m.paths = Module._nodeModulePaths(path.dirname(configPath));
context.require = m.require.bind(m);
require('vm').runInNewContext(source.toString(), context);
}
function createSandbox(filename) {
const module = new Module(filename);
module.paths = Module._nodeModulePaths(filename);
const sandbox = vm.createContext({
module,
console: {},
});
lodash_1.defaults(sandbox, global);
// Redirect console calls into logger
Object.keys(console).forEach((k) => {
if (k === 'log') {
sandbox.console.log = createDebugFunction(filename);
}
else if (k in logger_1.logger) {
sandbox.console[k] = logger_1.logger[k];
}
});
sandbox.require = function sandboxRequire(p) {
const oldCompile = Module.prototype._compile;
Module.prototype._compile = compileInSandbox(sandbox);
const moduleExports = sandbox.module.require(p);
Module.prototype._compile = oldCompile;
return moduleExports;
};
// patch `require` in sandbox to run loaded module in sandbox context
// if you need any of these, it might be worth discussing spawning separate processes
sandbox.process = lodash_1.omit(process, BLACKLISTED_GLOBALS);
const devNull = new devnull_1.DevNull();
sandbox.process.stdin = devNull;
sandbox.process.stdout = devNull;
sandbox.process.stderr = devNull;
return sandbox;
}
req.patch = function (module, filename)
{
filename || (filename = '');
module.filename = resolve(filename);
module.paths = paths(module.filename);
}
it('includes paths outside of the resources path', function () {
let modulePath = path.resolve('/foo')
assert.deepEqual(Module._nodeModulePaths(modulePath), [
path.join(modulePath, 'node_modules'),
path.resolve('/node_modules')
])
})
var initModule = function(traceurifiedRequire, ctxModule, filename) {
// A lot of this code is jacked from node-core module.js _compile
var ctxRequire = traceurifiedRequire;
ctxRequire.resolve = function(request) {
return Module._resolveFilename(request, ctxModule);
};
Object.defineProperty(ctxRequire, 'paths', { get: function() {
throw new Error('require.paths is removed. Use ' +
'node_modules folders, or the NODE_PATH ' +
'environment variable instead.');
}});
ctxRequire.main = process.mainModule;
// Enable support to add extra extension types
ctxRequire.extensions = Module._extensions;
ctxRequire.registerExtension = function() {
throw new Error('require.registerExtension() removed. Use ' +
'require.extensions instead.');
};
ctxRequire.cache = Module._cache;
ctxModule.filename = filename;
ctxModule.paths = Module._nodeModulePaths(path.dirname(filename));
};
exports.requireWithContext = function (filename, sandbox, parent) {
if (!parent)
parent = {require: require}
if (!sandbox)
sandbox = {}
// 读取代码
var code = fs.readFileSync(filename, 'utf8');
// 模拟require()环境
sandbox.module = new Module(filename, parent);
sandbox.exports = sandbox.module.exports;
sandbox.__dirname = path.dirname(filename);
sandbox.__filename = filename;
sandbox.module.filename = filename;
sandbox.module.paths = Module._nodeModulePaths(sandbox.__dirname);
sandbox.global = sandbox;
sandbox.root = root;
sandbox.require = function (path) {
var f = sandbox.require.resolve(path);
return parent.require(f);
}
sandbox.require.resolve = function(request) {
return Module._resolveFilename(request, sandbox.module);
}
sandbox.require.main = process.mainModule;
sandbox.require.extensions = Module._extensions;
sandbox.require.cache = Module._cache;
// 运行代码
vm.runInNewContext(code, sandbox, filename);
// 返回模块输出
return sandbox.module.exports;
}
// copied (almost) directly from joyent/node's src/node.js
function evalScript (name) {
var Module = require('module');
var path = require('path');
var cwd = process.cwd();
var module = new Module(name);
module.filename = path.join(cwd, name);
module.paths = Module._nodeModulePaths(cwd);
var script = process._eval;
script = compile(script).code;
if (!Module._contextLoad) {
var body = script;
script = 'global.__filename = ' + JSON.stringify(name) + ';\n' +
'global.exports = exports;\n' +
'global.module = module;\n' +
'global.__dirname = __dirname;\n' +
'global.require = require;\n' +
'return require("vm").runInThisContext(' +
JSON.stringify(body) + ', ' +
JSON.stringify(name) + ', true);\n';
}
var result = module._compile(script, name + '-wrapper');
if (process._print_eval) console.log(result);
}
// Creates a properly working require function from the context of filename as if it were a
// module. Based on code from node's module.js.
function createRequire(filename) {
var newModule = new Module(filename, module);
newModule.filename = filename;
newModule.paths = Module._nodeModulePaths(path.dirname(filename));
function require(path) {
return newModule.require(path);
}
require.resolve = function(request) {
return Module._resolveFilename(request, newModule);
};
Object.defineProperty(require, 'paths', { get: function() {
throw new Error('require.paths is removed. Use ' +
'node_modules folders, or the NODE_PATH ' +
'environment variable instead.');
}});
require.main = process.mainModule;
// Enable support to add extra extension types
require.extensions = Module._extensions;
require.registerExtension = function() {
throw new Error('require.registerExtension() removed. Use ' +
'require.extensions instead.');
};
require.cache = Module._cache;
return require;
}
module.exports = function requireLike(path, uncached) {
var parentModule = new Module(path);
parentModule.filename = path;
parentModule.paths = Module._nodeModulePaths(dirname(path));
function requireLike(file) {
var cache = Module._cache;
if (uncached) {
Module._cache = {};
}
var exports = Module._load(file, parentModule);
Module._cache = cache;
return exports;
};
requireLike.resolve = function(request) {
return Module._resolveFilename(request, parentModule)[1];
}
try {
requireLike.paths = require.paths;
} catch (e) {
//require.paths was deprecated in node v0.5.x
//it now throws an exception when called
}
requireLike.main = process.mainModule;
requireLike.extensions = require.extensions;
requireLike.cache = require.cache;
return requireLike;
};
_representationForModuleHandler: function() {
return {
filename: this._filename,
id: this._filename,
paths: moduleHandler._nodeModulePaths(path.dirname(this._filename))
};
},
it('includes paths outside of the resources path', () => {
const modulePath = path.resolve('/foo')
expect(Module._nodeModulePaths(modulePath)).to.deep.equal([
path.join(modulePath, 'node_modules'),
path.resolve('/node_modules')
])
})
function resolveSourceDir(rootDir, sourceDir) {
var srcDir = path.resolve(rootDir, sourceDir);
if (fs.existsSync(srcDir))
return srcDir;
// Handle module-relative path, e.g. `loopback/common/models`
var start = sourceDir.substring(0, 2);
if (start !== './' && start !== '..') {
// Module.globalPaths is a list of globally configured paths like
// [ env.NODE_PATH values, $HOME/.node_modules, etc. ]
// Module._nodeModulePaths(rootDir) returns a list of paths like
// [ rootDir/node_modules, rootDir/../node_modules, etc. ]
var modulePaths = Module.globalPaths
.concat(Module._nodeModulePaths(rootDir));
srcDir = modulePaths
.map(function(candidateDir) {
return path.join(candidateDir, sourceDir);
})
.filter(function(candidate) {
return fs.existsSync(candidate);
})
[0];
if (srcDir)
return srcDir;
}
return undefined;
}
Module.prototype.load = function (filename){
this.filename = filename;
this.paths = Module._nodeModulePaths(path.dirname(filename));
var ext = findExtension(filename);
Module._extensions[ext](this,filename);
return this.loaded = true;
};
exec: (code, filename) => {
const module = new NativeModule(filename, this);
module.paths = NativeModule._nodeModulePaths(this.context);
module.filename = filename;
module._compile(code, filename);
return module.exports;
},
function loadNodeModule(moduleId, parent) {
var module = require('module');
var amdDefine = define;
var result;
if (module._findPath && module._nodeModulePaths) {
var localModulePath = module._findPath(moduleId, module._nodeModulePaths(toUrl('.', parent)));
if (localModulePath !== false) {
moduleId = localModulePath;
}
}
// Some modules attempt to detect an AMD loader by looking for global AMD `define`. This causes issues
// when other CommonJS modules attempt to load them via the standard Node.js `require`, so hide it
// during the load
define = undefined;
try {
result = requireModule.nodeRequire(moduleId);
}
catch (error) {
// If the Node.js 'require' function cannot locate a module it will throw "Error: Cannot find module"
// Leave it to the caller of this function to handle a non-existent module
// (and throw an error if desired)
result = undefined;
}
finally {
define = amdDefine;
}
return result;
}
Y.Get._exec = function(data, url, cb) {
_yuitest_coverfunc("build/get-nodejs/get-nodejs.js", "_exec", 54);
_yuitest_coverline("build/get-nodejs/get-nodejs.js", 55);
if (data.charCodeAt(0) === 0xFEFF) {
_yuitest_coverline("build/get-nodejs/get-nodejs.js", 56);
data = data.slice(1);
}
_yuitest_coverline("build/get-nodejs/get-nodejs.js", 59);
var mod = new Module(url, module);
_yuitest_coverline("build/get-nodejs/get-nodejs.js", 60);
mod.filename = url;
_yuitest_coverline("build/get-nodejs/get-nodejs.js", 61);
mod.paths = Module._nodeModulePaths(path.dirname(url));
_yuitest_coverline("build/get-nodejs/get-nodejs.js", 62);
if (typeof YUI._getLoadHook === 'function') {
_yuitest_coverline("build/get-nodejs/get-nodejs.js", 63);
data = YUI._getLoadHook(data, url);
}
_yuitest_coverline("build/get-nodejs/get-nodejs.js", 65);
mod._compile('module.exports = function (YUI) {' + data + '\n;return YUI;};', url);
/*global YUI:true */
_yuitest_coverline("build/get-nodejs/get-nodejs.js", 68);
YUI = mod.exports(YUI);
_yuitest_coverline("build/get-nodejs/get-nodejs.js", 70);
mod.loaded = true;
_yuitest_coverline("build/get-nodejs/get-nodejs.js", 72);
cb(null, url);
};
function resolveModulePath(base, packagePath) {
return Module._resolveFilename(packagePath, {
paths: Module._nodeModulePaths(base),
filename: base,
id: base,
});
}
function evalAndExit(code, isPrinted) {
var module = new Module(EVAL_FILENAME);
module.filename = EVAL_FILENAME;
module.paths = Module._nodeModulePaths(cwd);
global.__filename = EVAL_FILENAME;
global.__dirname = cwd;
global.exports = module.exports;
global.module = module;
global.require = module.require.bind(module);
var result;
try {
result = _eval(code, global);
}
catch (error) {
if (error instanceof index_1.TSError) {
console.error(print(error));
process.exit(1);
}
throw error;
}
if (isPrinted) {
console.log(typeof result === 'string' ? result : util_1.inspect(result));
}
process.exit(0);
}
module.exports = function requireFromString(code, filename, opts) {
if (typeof filename === 'object') {
opts = filename;
filename = undefined;
}
opts = opts || {};
filename = filename || '';
opts.appendPaths = opts.appendPaths || [];
opts.prependPaths = opts.prependPaths || [];
if (typeof code !== 'string') {
throw new Error('code must be a string, not ' + typeof code);
}
var paths = Module._nodeModulePaths(path.dirname(filename));
var m = new Module(filename, module.parent);
m.filename = filename;
m.paths = [].concat(opts.prependPaths).concat(paths).concat(opts.appendPaths);
m._compile(code, filename);
return m.exports;
};
return fs.readFile(path).then(function(script) {
// Based on: https://github.com/joyent/node/blob/v0.10.33/src/node.js#L516
var module = new Module(path);
module.filename = path;
module.paths = Module._nodeModulePaths(path);
function require(path) {
return module.require(path);
}
require.resolve = function(request) {
return Module._resolveFilename(request, module);
};
require.main = process.mainModule;
require.extensions = Module._extensions;
require.cache = Module._cache;
script = '(function(exports, require, module, __filename, __dirname, hexo){' +
script + '});';
var fn = vm.runInThisContext(script, path);
return fn(module.exports, require, module, path, pathFn.dirname(path), self);
}).asCallback(callback);
it('includes paths outside of the resources path', () => {
const modulePath = path.resolve('/foo')
assert.deepStrictEqual(Module._nodeModulePaths(modulePath), [
path.join(modulePath, 'node_modules'),
path.resolve('/node_modules')
])
})
var req = function (m) {
function compile(content, mod, filename, dirname) {
var Script = process.binding('evals').NodeScript;
var runInThisContext = Script.runInThisContext;
// create wrapper function
//
var wrapper = Module.wrap(content);
var compiledWrapper = runInThisContext(wrapper, filename, true);
var args = [mod.exports, requireSubst(mod), mod, filename, dirname];
return compiledWrapper.apply(mod.exports, args);
}
var pathToCode;
pathToCode = Module._resolveFilename(m, self || module);
if (Array.isArray(pathToCode)) pathToCode = pathToCode[1];
var existsSync = fs.existsSync || path.existsSync;
if (pathToCode != null && existsSync(pathToCode)) {
var code = fs.readFileSync(pathToCode, 'utf-8');
if (code.length > 1) {
if (code.substr(0, 2) === "#!") {
code = code.substr(code.indexOf("\n") + 1);
}
}
var filepath = path.resolve(pathToCode);
var dirname = path.dirname(filepath);
var cacheKey = filepath;
// test if there is a coveraje-injected version
var cachedModule = Module._cache[filepath + requirePostfix];
if (cachedModule) {
return cachedModule.exports;
}
cachedModule = Module._cache[filepath];
if (cachedModule) {
return cachedModule.exports;
}
var mod = new Module(filepath, module);
Module._cache[filepath] = mod;
mod.filename = filepath;
mod.paths = Module._nodeModulePaths(dirname);
compile(code, mod, filepath, dirname);
mod.loaded = true;
return mod.exports;
}
return require(m);
};
function run(names, config) {
var module = new Module('injective', null);
module.paths = Module._nodeModulePaths(process.cwd());
process.mainModule = module;
Injective(module, config).import(names).catch(function(err) {
console.error(err.stack);
});
}
exec: function(code, filename) {
var Module = require("module");
var m = new Module(filename, module);
m.paths = Module._nodeModulePaths(module.context);
m.filename = filename;
m._compile(code, filename);
return m.exports;
},
module.exports = function (name, fromDir) {
if (!fromDir) fromDir = process.cwd();
var paths = Module._nodeModulePaths(fromDir);
var path = Module._findPath(name, paths);
return path ? require(path) : require(name);
};
function getModulePath(id, from=process.cwd()) {
try {
return path.dirname(Module._resolveFilename(id, _.assign(new Module, {
'paths': Module._nodeModulePaths(from)
})));
} catch (e) {}
return '';
}
exec: (code, filename) => {
// @ts-ignore Argument of type 'this' is not assignable to parameter of type 'Module'.
const module = new NativeModule(filename, this);
// @ts-ignore _nodeModulePaths is deprecated and undocumented Node.js API
module.paths = NativeModule._nodeModulePaths(this.context);
module.filename = filename;
module._compile(code, filename);
return module.exports;
},