Buckets:
| ; | |
| const Module = require('module'); | |
| const crypto = require('crypto'); | |
| const fs = require('fs'); | |
| const path = require('path'); | |
| const vm = require('vm'); | |
| const os = require('os'); | |
| const hasOwnProperty = Object.prototype.hasOwnProperty; | |
| //------------------------------------------------------------------------------ | |
| // FileSystemBlobStore | |
| //------------------------------------------------------------------------------ | |
| class FileSystemBlobStore { | |
| constructor(directory, prefix) { | |
| const name = prefix ? slashEscape(prefix + '.') : ''; | |
| this._blobFilename = path.join(directory, name + 'BLOB'); | |
| this._mapFilename = path.join(directory, name + 'MAP'); | |
| this._lockFilename = path.join(directory, name + 'LOCK'); | |
| this._directory = directory; | |
| this._load(); | |
| } | |
| has(key, invalidationKey) { | |
| if (hasOwnProperty.call(this._memoryBlobs, key)) { | |
| return this._invalidationKeys[key] === invalidationKey; | |
| } else if (hasOwnProperty.call(this._storedMap, key)) { | |
| return this._storedMap[key][0] === invalidationKey; | |
| } | |
| return false; | |
| } | |
| get(key, invalidationKey) { | |
| if (hasOwnProperty.call(this._memoryBlobs, key)) { | |
| if (this._invalidationKeys[key] === invalidationKey) { | |
| return this._memoryBlobs[key]; | |
| } | |
| } else if (hasOwnProperty.call(this._storedMap, key)) { | |
| const mapping = this._storedMap[key]; | |
| if (mapping[0] === invalidationKey) { | |
| return this._storedBlob.slice(mapping[1], mapping[2]); | |
| } | |
| } | |
| } | |
| set(key, invalidationKey, buffer) { | |
| this._invalidationKeys[key] = invalidationKey; | |
| this._memoryBlobs[key] = buffer; | |
| this._dirty = true; | |
| } | |
| delete(key) { | |
| if (hasOwnProperty.call(this._memoryBlobs, key)) { | |
| this._dirty = true; | |
| delete this._memoryBlobs[key]; | |
| } | |
| if (hasOwnProperty.call(this._invalidationKeys, key)) { | |
| this._dirty = true; | |
| delete this._invalidationKeys[key]; | |
| } | |
| if (hasOwnProperty.call(this._storedMap, key)) { | |
| this._dirty = true; | |
| delete this._storedMap[key]; | |
| } | |
| } | |
| isDirty() { | |
| return this._dirty; | |
| } | |
| save() { | |
| const dump = this._getDump(); | |
| const blobToStore = Buffer.concat(dump[0]); | |
| const mapToStore = JSON.stringify(dump[1]); | |
| try { | |
| mkdirpSync(this._directory); | |
| fs.writeFileSync(this._lockFilename, 'LOCK', {flag: 'wx'}); | |
| } catch (error) { | |
| // Swallow the exception if we fail to acquire the lock. | |
| return false; | |
| } | |
| try { | |
| fs.writeFileSync(this._blobFilename, blobToStore); | |
| fs.writeFileSync(this._mapFilename, mapToStore); | |
| } finally { | |
| fs.unlinkSync(this._lockFilename); | |
| } | |
| return true; | |
| } | |
| _load() { | |
| try { | |
| this._storedBlob = fs.readFileSync(this._blobFilename); | |
| this._storedMap = JSON.parse(fs.readFileSync(this._mapFilename)); | |
| } catch (e) { | |
| this._storedBlob = Buffer.alloc(0); | |
| this._storedMap = {}; | |
| } | |
| this._dirty = false; | |
| this._memoryBlobs = {}; | |
| this._invalidationKeys = {}; | |
| } | |
| _getDump() { | |
| const buffers = []; | |
| const newMap = {}; | |
| let offset = 0; | |
| function push(key, invalidationKey, buffer) { | |
| buffers.push(buffer); | |
| newMap[key] = [invalidationKey, offset, offset + buffer.length]; | |
| offset += buffer.length; | |
| } | |
| for (const key of Object.keys(this._memoryBlobs)) { | |
| const buffer = this._memoryBlobs[key]; | |
| const invalidationKey = this._invalidationKeys[key]; | |
| push(key, invalidationKey, buffer); | |
| } | |
| for (const key of Object.keys(this._storedMap)) { | |
| if (hasOwnProperty.call(newMap, key)) continue; | |
| const mapping = this._storedMap[key]; | |
| const buffer = this._storedBlob.slice(mapping[1], mapping[2]); | |
| push(key, mapping[0], buffer); | |
| } | |
| return [buffers, newMap]; | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| // NativeCompileCache | |
| //------------------------------------------------------------------------------ | |
| class NativeCompileCache { | |
| constructor() { | |
| this._cacheStore = null; | |
| this._previousModuleCompile = null; | |
| } | |
| setCacheStore(cacheStore) { | |
| this._cacheStore = cacheStore; | |
| } | |
| install() { | |
| const self = this; | |
| const hasRequireResolvePaths = typeof require.resolve.paths === 'function'; | |
| this._previousModuleCompile = Module.prototype._compile; | |
| Module.prototype._compile = this._ownModuleCompile = _ownModuleCompile; | |
| self.enabled = true; | |
| function _ownModuleCompile(content, filename) { | |
| if(!self.enabled) return this._previousModuleCompile.apply(this, arguments); | |
| const mod = this; | |
| function require(id) { | |
| return mod.require(id); | |
| } | |
| // https://github.com/nodejs/node/blob/v10.15.3/lib/internal/modules/cjs/helpers.js#L28 | |
| function resolve(request, options) { | |
| return Module._resolveFilename(request, mod, false, options); | |
| } | |
| require.resolve = resolve; | |
| // https://github.com/nodejs/node/blob/v10.15.3/lib/internal/modules/cjs/helpers.js#L37 | |
| // resolve.resolve.paths was added in v8.9.0 | |
| if (hasRequireResolvePaths) { | |
| resolve.paths = function paths(request) { | |
| return Module._resolveLookupPaths(request, mod, true); | |
| }; | |
| } | |
| require.main = process.mainModule; | |
| // Enable support to add extra extension types | |
| require.extensions = Module._extensions; | |
| require.cache = Module._cache; | |
| const dirname = path.dirname(filename); | |
| const compiledWrapper = self._moduleCompile(filename, content); | |
| // We skip the debugger setup because by the time we run, node has already | |
| // done that itself. | |
| // `Buffer` is included for Electron. | |
| // See https://github.com/zertosh/v8-compile-cache/pull/10#issuecomment-518042543 | |
| const args = [mod.exports, require, mod, filename, dirname, process, global, Buffer]; | |
| return compiledWrapper.apply(mod.exports, args); | |
| } | |
| } | |
| uninstall() { | |
| this.enabled = false; | |
| // If something else has since been installed on top of us, we cannot overwrite it. | |
| if(Module.prototype._compile === this._ownModuleCompile) { | |
| Module.prototype._compile = this._previousModuleCompile; | |
| } | |
| } | |
| _moduleCompile(filename, content) { | |
| // https://github.com/nodejs/node/blob/v7.5.0/lib/module.js#L511 | |
| // Remove shebang | |
| var contLen = content.length; | |
| if (contLen >= 2) { | |
| if (content.charCodeAt(0) === 35/*#*/ && | |
| content.charCodeAt(1) === 33/*!*/) { | |
| if (contLen === 2) { | |
| // Exact match | |
| content = ''; | |
| } else { | |
| // Find end of shebang line and slice it off | |
| var i = 2; | |
| for (; i < contLen; ++i) { | |
| var code = content.charCodeAt(i); | |
| if (code === 10/*\n*/ || code === 13/*\r*/) break; | |
| } | |
| if (i === contLen) { | |
| content = ''; | |
| } else { | |
| // Note that this actually includes the newline character(s) in the | |
| // new output. This duplicates the behavior of the regular | |
| // expression that was previously used to replace the shebang line | |
| content = content.slice(i); | |
| } | |
| } | |
| } | |
| } | |
| // create wrapper function | |
| var wrapper = Module.wrap(content); | |
| var invalidationKey = crypto | |
| .createHash('sha1') | |
| .update(content, 'utf8') | |
| .digest('hex'); | |
| var buffer = this._cacheStore.get(filename, invalidationKey); | |
| var script = new vm.Script(wrapper, { | |
| filename: filename, | |
| lineOffset: 0, | |
| displayErrors: true, | |
| cachedData: buffer, | |
| produceCachedData: true, | |
| }); | |
| if (script.cachedDataProduced) { | |
| this._cacheStore.set(filename, invalidationKey, script.cachedData); | |
| } else if (script.cachedDataRejected) { | |
| this._cacheStore.delete(filename); | |
| } | |
| var compiledWrapper = script.runInThisContext({ | |
| filename: filename, | |
| lineOffset: 0, | |
| columnOffset: 0, | |
| displayErrors: true, | |
| }); | |
| return compiledWrapper; | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| // utilities | |
| // | |
| // https://github.com/substack/node-mkdirp/blob/f2003bb/index.js#L55-L98 | |
| // https://github.com/zertosh/slash-escape/blob/e7ebb99/slash-escape.js | |
| //------------------------------------------------------------------------------ | |
| function mkdirpSync(p_) { | |
| _mkdirpSync(path.resolve(p_), 0o777); | |
| } | |
| function _mkdirpSync(p, mode) { | |
| try { | |
| fs.mkdirSync(p, mode); | |
| } catch (err0) { | |
| if (err0.code === 'ENOENT') { | |
| _mkdirpSync(path.dirname(p)); | |
| _mkdirpSync(p); | |
| } else { | |
| try { | |
| const stat = fs.statSync(p); | |
| if (!stat.isDirectory()) { throw err0; } | |
| } catch (err1) { | |
| throw err0; | |
| } | |
| } | |
| } | |
| } | |
| function slashEscape(str) { | |
| const ESCAPE_LOOKUP = { | |
| '\\': 'zB', | |
| ':': 'zC', | |
| '/': 'zS', | |
| '\x00': 'z0', | |
| 'z': 'zZ', | |
| }; | |
| const ESCAPE_REGEX = /[\\:/\x00z]/g; // eslint-disable-line no-control-regex | |
| return str.replace(ESCAPE_REGEX, match => ESCAPE_LOOKUP[match]); | |
| } | |
| function supportsCachedData() { | |
| const script = new vm.Script('""', {produceCachedData: true}); | |
| // chakracore, as of v1.7.1.0, returns `false`. | |
| return script.cachedDataProduced === true; | |
| } | |
| function getCacheDir() { | |
| const v8_compile_cache_cache_dir = process.env.V8_COMPILE_CACHE_CACHE_DIR; | |
| if (v8_compile_cache_cache_dir) { | |
| return v8_compile_cache_cache_dir; | |
| } | |
| // Avoid cache ownership issues on POSIX systems. | |
| const dirname = typeof process.getuid === 'function' | |
| ? 'v8-compile-cache-' + process.getuid() | |
| : 'v8-compile-cache'; | |
| const version = typeof process.versions.v8 === 'string' | |
| ? process.versions.v8 | |
| : typeof process.versions.chakracore === 'string' | |
| ? 'chakracore-' + process.versions.chakracore | |
| : 'node-' + process.version; | |
| const cacheDir = path.join(os.tmpdir(), dirname, version); | |
| return cacheDir; | |
| } | |
| function getMainName() { | |
| // `require.main.filename` is undefined or null when: | |
| // * node -e 'require("v8-compile-cache")' | |
| // * node -r 'v8-compile-cache' | |
| // * Or, requiring from the REPL. | |
| const mainName = require.main && typeof require.main.filename === 'string' | |
| ? require.main.filename | |
| : process.cwd(); | |
| return mainName; | |
| } | |
| function install(opts) { | |
| if (!process.env.DISABLE_V8_COMPILE_CACHE && supportsCachedData()) { | |
| if(typeof opts === 'undefined') opts = {} | |
| let cacheDir = opts.cacheDir | |
| if(typeof cacheDir === 'undefined') cacheDir = getCacheDir(); | |
| let prefix = opts.prefix | |
| if(typeof prefix === 'undefined') prefix = getMainName(); | |
| const blobStore = new FileSystemBlobStore(cacheDir, prefix); | |
| const nativeCompileCache = new NativeCompileCache(); | |
| nativeCompileCache.setCacheStore(blobStore); | |
| nativeCompileCache.install(); | |
| let uninstalled = false; | |
| const uninstall = () => { | |
| if(uninstalled) return; | |
| uninstalled = true; | |
| process.removeListener('exit', uninstall); | |
| if (blobStore.isDirty()) { | |
| blobStore.save(); | |
| } | |
| nativeCompileCache.uninstall(); | |
| } | |
| process.once('exit', uninstall); | |
| return {uninstall}; | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| // main | |
| //------------------------------------------------------------------------------ | |
| module.exports.install = install; | |
| module.exports.__TEST__ = { | |
| FileSystemBlobStore, | |
| NativeCompileCache, | |
| mkdirpSync, | |
| slashEscape, | |
| supportsCachedData, | |
| getCacheDir, | |
| getMainName, | |
| }; | |
Xet Storage Details
- Size:
- 11.5 kB
- Xet hash:
- 128f91e0c2a247421d4c2ad4a163441e13c91a05a0ff2c67bb4265cf98c81e85
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.