text: 'use strict';
  
  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 = function(content, filename) {
        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() {
      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;
  }
  
  module.exports = {
    FileSystemBlobStore,
    NativeCompileCache,
    mkdirpSync,
    slashEscape,
    supportsCachedData,
    getCacheDir,
    getMainName,
  };
  