@granite-js/mpack 0.0.1

package/dist/vendors/metro/src/lib/transformHelpers.js

@@ -0,0 +1,112 @@
+"use strict";
+var import_contextModuleTemplates = require("./contextModuleTemplates");
+const path = require("path");
+const baseIgnoredInlineRequires = ["React", "react", "react-native"];
+async function calcTransformerOptions(entryFiles, bundler, deltaBundler, config, options, resolverOptions) {
+  const baseOptions = {
+    customTransformOptions: options.customTransformOptions,
+    dev: options.dev,
+    hot: options.hot,
+    inlineRequires: false,
+    inlinePlatform: true,
+    minify: options.minify,
+    platform: options.platform,
+    runtimeBytecodeVersion: options.runtimeBytecodeVersion,
+    unstable_transformProfile: options.unstable_transformProfile
+  };
+  if (options.type === "script") {
+    return {
+      ...baseOptions,
+      type: "script"
+    };
+  }
+  const getDependencies = async (path2) => {
+    const dependencies = await deltaBundler.getDependencies([path2], {
+      resolve: await getResolveDependencyFn(bundler, options.platform, resolverOptions),
+      transform: await getTransformFn(
+        [path2],
+        bundler,
+        deltaBundler,
+        config,
+        {
+          ...options,
+          minify: false
+        },
+        resolverOptions
+      ),
+      transformOptions: options,
+      onProgress: null,
+      experimentalImportBundleSupport: config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext: config.transformer.unstable_allowRequireContext,
+      shallow: false
+    });
+    return Array.from(dependencies.keys());
+  };
+  const { transform } = await config.transformer.getTransformOptions(
+    entryFiles,
+    { dev: options.dev, hot: options.hot, platform: options.platform },
+    getDependencies
+  );
+  return {
+    ...baseOptions,
+    inlineRequires: transform.inlineRequires || false,
+    experimentalImportSupport: transform.experimentalImportSupport || false,
+    unstable_disableES6Transforms: transform.unstable_disableES6Transforms || false,
+    nonInlinedRequires: transform.nonInlinedRequires || baseIgnoredInlineRequires,
+    type: "module"
+  };
+}
+function removeInlineRequiresBlockListFromOptions(path2, inlineRequires) {
+  if (typeof inlineRequires === "object") {
+    return !(path2 in inlineRequires.blockList);
+  }
+  return inlineRequires;
+}
+async function getTransformFn(entryFiles, bundler, deltaBundler, config, options, resolverOptions) {
+  const { inlineRequires, ...transformOptions } = await calcTransformerOptions(
+    entryFiles,
+    bundler,
+    deltaBundler,
+    config,
+    options,
+    resolverOptions
+  );
+  return async (modulePath, requireContext) => {
+    let templateBuffer;
+    if (requireContext) {
+      const graph = await bundler.getDependencyGraph();
+      const files = graph.matchFilesWithContext(requireContext.from, {
+        filter: requireContext.filter,
+        recursive: requireContext.recursive
+      });
+      const template = (0, import_contextModuleTemplates.getContextModuleTemplate)(requireContext.mode, requireContext.from, files);
+      templateBuffer = Buffer.from(template);
+    }
+    return await bundler.transformFile(
+      modulePath,
+      {
+        ...transformOptions,
+        type: getType(transformOptions.type, modulePath, config.resolver.assetExts),
+        inlineRequires: removeInlineRequiresBlockListFromOptions(modulePath, inlineRequires)
+      },
+      templateBuffer
+    );
+  };
+}
+function getType(type, filePath, assetExts) {
+  if (type === "script") {
+    return type;
+  }
+  if (assetExts.indexOf(path.extname(filePath).slice(1)) !== -1) {
+    return "asset";
+  }
+  return "module";
+}
+async function getResolveDependencyFn(bundler, platform, resolverOptions) {
+  const dependencyGraph = await await bundler.getDependencyGraph();
+  return (from, to) => dependencyGraph.resolveDependency(from, to, platform ?? null, resolverOptions);
+}
+module.exports = {
+  getTransformFn,
+  getResolveDependencyFn
+};

package/dist/vendors/metro/src/node-haste/DependencyGraph/ModuleResolution.js

@@ -0,0 +1,221 @@
+"use strict";
+const { codeFrameColumns } = require("@babel/code-frame");
+const fs = require("fs");
+const invariant = require("invariant");
+const Resolver = require("metro-resolver");
+const path = require("path");
+const util = require("util");
+class ModuleResolver {
+  _options;
+  // A module representing the project root, used as the origin when resolving `emptyModulePath`.
+  _projectRootFakeModule;
+  // An empty module, the result of resolving `emptyModulePath` from the project root.
+  _cachedEmptyModule;
+  // $FlowFixMe[missing-local-annot]
+  constructor(options) {
+    this._options = options;
+    const { projectRoot, moduleCache } = this._options;
+    this._projectRootFakeModule = {
+      path: path.join(projectRoot, "_"),
+      getPackage: () => moduleCache.getPackageOf(this._projectRootFakeModule.path),
+      isHaste() {
+        throw new Error("not implemented");
+      },
+      getName() {
+        throw new Error("not implemented");
+      }
+    };
+  }
+  _getEmptyModule() {
+    let emptyModule = this._cachedEmptyModule;
+    if (!emptyModule) {
+      emptyModule = this.resolveDependency(
+        this._projectRootFakeModule,
+        this._options.emptyModulePath,
+        false,
+        null,
+        /* resolverOptions */
+        {}
+      );
+      this._cachedEmptyModule = emptyModule;
+    }
+    return emptyModule;
+  }
+  _redirectRequire(fromModule, modulePath) {
+    const moduleCache = this._options.moduleCache;
+    try {
+      if (modulePath.startsWith(".")) {
+        const fromPackage = fromModule.getPackage();
+        if (fromPackage) {
+          const fromPackagePath = "./" + path.relative(path.dirname(fromPackage.path), path.resolve(path.dirname(fromModule.path), modulePath));
+          let redirectedPath = fromPackage.redirectRequire(fromPackagePath, this._options.mainFields);
+          if (redirectedPath !== false) {
+            redirectedPath = "./" + path.relative(
+              path.dirname(fromModule.path),
+              path.resolve(path.dirname(fromPackage.path), redirectedPath)
+            );
+          }
+          return redirectedPath;
+        }
+      } else {
+        const pck = path.isAbsolute(modulePath) ? moduleCache.getPackageOf(modulePath) : fromModule.getPackage();
+        if (pck) {
+          return pck.redirectRequire(modulePath, this._options.mainFields);
+        }
+      }
+    } catch (err) {
+    }
+    return modulePath;
+  }
+  resolveDependency(fromModule, moduleName, allowHaste, platform, resolverOptions) {
+    try {
+      const result = Resolver.resolve(
+        {
+          ...this._options,
+          customResolverOptions: resolverOptions.customResolverOptions ?? {},
+          originModulePath: fromModule.path,
+          redirectModulePath: (modulePath) => this._redirectRequire(fromModule, modulePath),
+          allowHaste,
+          platform,
+          resolveHasteModule: (name) => this._options.moduleMap.getModule(name, platform, true),
+          resolveHastePackage: (name) => this._options.moduleMap.getPackage(name, platform, true),
+          getPackageMainPath: this._getPackageMainPath
+        },
+        moduleName,
+        platform
+      );
+      return this._getFileResolvedModule(result);
+    } catch (error) {
+      if (error instanceof Resolver.FailedToResolvePathError) {
+        const { candidates } = error;
+        throw new UnableToResolveError(
+          fromModule.path,
+          moduleName,
+          [
+            "\n\nNone of these files exist:",
+            `  * ${Resolver.formatFileCandidates(this._removeRoot(candidates.file))}`,
+            `  * ${Resolver.formatFileCandidates(this._removeRoot(candidates.dir))}`
+          ].join("\n"),
+          {
+            cause: error
+          }
+        );
+      }
+      if (error instanceof Resolver.FailedToResolveNameError) {
+        const dirPaths = error.dirPaths;
+        const extraPaths = error.extraPaths;
+        const displayDirPaths = dirPaths.filter((dirPath) => this._options.dirExists(dirPath)).map((dirPath) => path.relative(this._options.projectRoot, dirPath)).concat(extraPaths);
+        const hint = displayDirPaths.length ? " or in these directories:" : "";
+        throw new UnableToResolveError(
+          fromModule.path,
+          moduleName,
+          [
+            `${moduleName} could not be found within the project${hint || "."}`,
+            ...displayDirPaths.map((dirPath) => `  ${dirPath}`)
+          ].join("\n"),
+          {
+            cause: error
+          }
+        );
+      }
+      throw error;
+    }
+  }
+  _getPackageMainPath = (packageJsonPath) => {
+    const package_ = this._options.moduleCache.getPackage(packageJsonPath);
+    return package_.getMain(this._options.mainFields);
+  };
+  /**
+   * FIXME: get rid of this function and of the reliance on `TModule`
+   * altogether, return strongly typed resolutions at the top-level instead.
+   */
+  _getFileResolvedModule(resolution) {
+    switch (resolution.type) {
+      case "sourceFile":
+        return this._options.moduleCache.getModule(resolution.filePath);
+      case "assetFiles":
+        const arbitrary = getArrayLowestItem(resolution.filePaths);
+        invariant(arbitrary != null, "invalid asset resolution");
+        return this._options.moduleCache.getModule(arbitrary);
+      case "empty":
+        return this._getEmptyModule();
+      default:
+        resolution.type;
+        throw new Error("invalid type");
+    }
+  }
+  _removeRoot(candidates) {
+    if (candidates.filePathPrefix) {
+      candidates.filePathPrefix = path.relative(this._options.projectRoot, candidates.filePathPrefix);
+    }
+    return candidates;
+  }
+}
+function getArrayLowestItem(a) {
+  if (a.length === 0) {
+    return void 0;
+  }
+  let lowest = a[0];
+  for (let i = 1; i < a.length; ++i) {
+    if (a[i] < lowest) {
+      lowest = a[i];
+    }
+  }
+  return lowest;
+}
+class UnableToResolveError extends Error {
+  /**
+   * File path of the module that tried to require a module, ex. `/js/foo.js`.
+   */
+  originModulePath;
+  /**
+   * The name of the module that was required, no necessarily a path,
+   * ex. `./bar`, or `invariant`.
+   */
+  targetModuleName;
+  /**
+   * Original error that causes this error
+   */
+  cause;
+  constructor(originModulePath, targetModuleName, message, options) {
+    super();
+    this.originModulePath = originModulePath;
+    this.targetModuleName = targetModuleName;
+    const codeFrameMessage = this.buildCodeFrameMessage();
+    this.message = util.format("Unable to resolve module %s from %s: %s", targetModuleName, originModulePath, message) + (codeFrameMessage ? "\n" + codeFrameMessage : "");
+    this.cause = options?.cause;
+  }
+  buildCodeFrameMessage() {
+    let file;
+    try {
+      file = fs.readFileSync(this.originModulePath, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT" || error.code === "EISDIR") {
+        return null;
+      }
+      throw error;
+    }
+    const lines = file.split("\n");
+    let lineNumber = 0;
+    let column = -1;
+    for (let line = 0; line < lines.length; line++) {
+      const columnLocation = lines[line].lastIndexOf(this.targetModuleName);
+      if (columnLocation >= 0) {
+        lineNumber = line;
+        column = columnLocation;
+        break;
+      }
+    }
+    return codeFrameColumns(
+      fs.readFileSync(this.originModulePath, "utf8"),
+      {
+        start: { column: column + 1, line: lineNumber + 1 }
+      },
+      { forceColor: process.env.NODE_ENV !== "test" }
+    );
+  }
+}
+module.exports = {
+  ModuleResolver,
+  UnableToResolveError
+};

package/dist/vendors/metro/src/node-haste/DependencyGraph/createHasteMap.js

@@ -0,0 +1,71 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_metro_file_map = __toESM(require("metro-file-map"));
+const ci = require("ci-info");
+const path = require("path");
+function getIgnorePattern(config) {
+  const { blockList, blacklistRE } = config.resolver;
+  const ignorePattern = blacklistRE || blockList;
+  if (!ignorePattern) {
+    return / ^/;
+  }
+  const combine = (regexes) => new RegExp(regexes.map((regex) => "(" + regex.source.replace(/\//g, path.sep) + ")").join("|"));
+  if (Array.isArray(ignorePattern)) {
+    return combine(ignorePattern);
+  }
+  return ignorePattern;
+}
+function createHasteMap(config, options) {
+  const dependencyExtractor = options?.extractDependencies === false ? null : config.resolver.dependencyExtractor;
+  const computeDependencies = dependencyExtractor != null;
+  return import_metro_file_map.default.create({
+    cacheManagerFactory: config?.unstable_fileMapCacheManagerFactory ?? ((buildParameters) => new import_metro_file_map.DiskCacheManager({
+      buildParameters,
+      cacheDirectory: config.fileMapCacheDirectory ?? config.hasteMapCacheDirectory,
+      cacheFilePrefix: options?.cacheFilePrefix
+    })),
+    perfLogger: config.unstable_perfLogger?.subSpan("hasteMap") ?? null,
+    computeDependencies,
+    computeSha1: true,
+    dependencyExtractor: config.resolver.dependencyExtractor,
+    extensions: Array.from(
+      /* @__PURE__ */ new Set([...config.resolver.sourceExts, ...config.resolver.assetExts, ...config.watcher.additionalExts])
+    ),
+    forceNodeFilesystemAPI: !config.resolver.useWatchman,
+    hasteImplModulePath: config.resolver.hasteImplModulePath,
+    ignorePattern: getIgnorePattern(config),
+    maxWorkers: config.maxWorkers,
+    mocksPattern: "",
+    platforms: config.resolver.platforms,
+    retainAllFiles: true,
+    resetCache: config.resetCache,
+    rootDir: config.projectRoot,
+    roots: config.watchFolders,
+    throwOnModuleCollision: options?.throwOnModuleCollision ?? true,
+    useWatchman: config.resolver.useWatchman,
+    watch: options?.watch == null ? !ci.isCI : options.watch,
+    watchmanDeferStates: config.watcher.watchman.deferStates
+  });
+}
+module.exports = createHasteMap;

package/dist/vendors/metro/src/node-haste/DependencyGraph.js

@@ -0,0 +1,223 @@
+"use strict";
+var import_metro_file_map = require("metro-file-map");
+const canonicalize = require("../../../metro-core/src/canonicalize");
+const createHasteMap = require("./DependencyGraph/createHasteMap");
+const { ModuleResolver } = require("./DependencyGraph/ModuleResolution");
+const ModuleCache = require("./ModuleCache");
+const { EventEmitter } = require("events");
+const fs = require("fs");
+const {
+  AmbiguousModuleResolutionError,
+  Logger: { createActionStartEntry, createActionEndEntry, log },
+  PackageResolutionError
+} = require("../../../metro-core/src");
+const { InvalidPackageError } = require("metro-resolver");
+const nullthrows = require("nullthrows");
+const path = require("path");
+const isPnP = require("../isPnP");
+let pnpapi;
+if (isPnP()) {
+  pnpapi = require("pnpapi");
+}
+const { DuplicateHasteCandidatesError } = import_metro_file_map.ModuleMap;
+const NULL_PLATFORM = Symbol();
+function getOrCreateMap(map, field) {
+  let subMap = map.get(field);
+  if (!subMap) {
+    subMap = /* @__PURE__ */ new Map();
+    map.set(field, subMap);
+  }
+  return subMap;
+}
+class DependencyGraph extends EventEmitter {
+  _assetExtensions;
+  _config;
+  _haste;
+  _hasteFS;
+  _moduleCache;
+  _moduleMap;
+  _moduleResolver;
+  _resolutionCache;
+  _readyPromise;
+  constructor(config, options) {
+    super();
+    this._config = config;
+    this._assetExtensions = new Set(config.resolver.assetExts.map((asset) => "." + asset));
+    const { hasReducedPerformance, watch } = options ?? {};
+    const initializingMetroLogEntry = log(createActionStartEntry("Initializing Metro"));
+    config.reporter.update({
+      type: "dep_graph_loading",
+      hasReducedPerformance: !!hasReducedPerformance
+    });
+    const haste = createHasteMap(config, { watch });
+    haste.setMaxListeners(1e3);
+    this._haste = haste;
+    this._readyPromise = haste.build().then(({ hasteFS, moduleMap }) => {
+      log(createActionEndEntry(initializingMetroLogEntry));
+      config.reporter.update({ type: "dep_graph_loaded" });
+      this._hasteFS = hasteFS;
+      this._moduleMap = moduleMap;
+      this._haste.on("change", this._onHasteChange.bind(this));
+      this._resolutionCache = /* @__PURE__ */ new Map();
+      this._moduleCache = this._createModuleCache();
+      this._createModuleResolver();
+    });
+  }
+  // Waits for the dependency graph to become ready after initialisation.
+  // Don't read anything from the graph until this resolves.
+  async ready() {
+    await this._readyPromise;
+  }
+  // Creates the dependency graph and waits for it to become ready.
+  // @deprecated Use the constructor + ready() directly.
+  static async load(config, options) {
+    const self = new DependencyGraph(config, options);
+    await self.ready();
+    return self;
+  }
+  _getClosestPackage(filePath) {
+    const parsedPath = path.parse(filePath);
+    const root = parsedPath.root;
+    let dir = parsedPath.dir;
+    do {
+      const candidate = path.join(dir, "package.json");
+      if (this._hasteFS.exists(candidate)) {
+        return candidate;
+      }
+      dir = path.dirname(dir);
+    } while (dir !== "." && dir !== root);
+    return null;
+  }
+  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+   * LTI update could not be added via codemod */
+  _onHasteChange({ eventsQueue, hasteFS, moduleMap }) {
+    this._hasteFS = hasteFS;
+    this._resolutionCache = /* @__PURE__ */ new Map();
+    this._moduleMap = moduleMap;
+    eventsQueue.forEach(({ type, filePath }) => this._moduleCache.processFileChange(type, filePath));
+    this._createModuleResolver();
+    this.emit("change");
+  }
+  _createModuleResolver() {
+    this._moduleResolver = new ModuleResolver({
+      dirExists: (filePath) => {
+        try {
+          return fs.lstatSync(filePath).isDirectory();
+        } catch (e) {
+        }
+        return false;
+      },
+      disableHierarchicalLookup: this._config.resolver.disableHierarchicalLookup,
+      doesFileExist: this._doesFileExist,
+      emptyModulePath: this._config.resolver.emptyModulePath,
+      extraNodeModules: this._config.resolver.extraNodeModules,
+      isAssetFile: (file) => this._assetExtensions.has(path.extname(file)),
+      mainFields: this._config.resolver.resolverMainFields,
+      moduleCache: this._moduleCache,
+      moduleMap: this._moduleMap,
+      nodeModulesPaths: this._config.resolver.nodeModulesPaths,
+      preferNativePlatform: true,
+      projectRoot: this._config.projectRoot,
+      resolveAsset: (dirPath, assetName, extension) => {
+        const basePath = dirPath + path.sep + assetName;
+        const assets = [
+          basePath + extension,
+          ...this._config.resolver.assetResolutions.map((resolution) => basePath + "@" + resolution + "x" + extension)
+        ].filter((candidate) => this._hasteFS.exists(candidate));
+        return assets.length ? assets : null;
+      },
+      resolveRequest: this._config.resolver.resolveRequest,
+      sourceExts: this._config.resolver.sourceExts
+    });
+  }
+  _createModuleCache() {
+    return new ModuleCache({
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      getClosestPackage: this._getClosestPackage.bind(this)
+    });
+  }
+  getSha1(filename) {
+    const splitIndex = filename.indexOf(".zip/");
+    const containerName = splitIndex !== -1 ? filename.slice(0, splitIndex + 4) : filename;
+    const realpath = fs.realpathSync(containerName);
+    const resolvedPath = (pnpapi ? pnpapi.resolveVirtual(realpath) : realpath) ?? realpath;
+    const sha1 = this._hasteFS.getSha1(resolvedPath);
+    if (!sha1) {
+      throw new ReferenceError(
+        `SHA-1 for file ${filename} (${resolvedPath}) is not computed.
+         Potential causes:
+           1) You have symlinks in your project - watchman does not follow symlinks.
+           2) Check \`blockList\` in your metro.config.js and make sure it isn't excluding the file path.`
+      );
+    }
+    return sha1;
+  }
+  getWatcher() {
+    return this._haste;
+  }
+  end() {
+    this._haste.end();
+  }
+  /** Given a search context, return a list of file paths matching the query. */
+  matchFilesWithContext(from, context) {
+    return this._hasteFS.matchFilesWithContext(from, context);
+  }
+  resolveDependency(from, to, platform, resolverOptions, { assumeFlatNodeModules } = {
+    assumeFlatNodeModules: false
+  }) {
+    const isSensitiveToOriginFolder = (
+      // Resolution is always relative to the origin folder unless we assume a flat node_modules
+      !assumeFlatNodeModules || // Path requests are resolved relative to the origin folder
+      to.includes("/") || to === "." || to === ".." || // Preserve standard assumptions under node_modules
+      from.includes(path.sep + "node_modules" + path.sep)
+    );
+    const resolverOptionsKey = JSON.stringify(resolverOptions.customResolverOptions ?? {}, canonicalize) ?? "";
+    const originKey = isSensitiveToOriginFolder ? path.dirname(from) : "";
+    const targetKey = to;
+    const platformKey = platform ?? NULL_PLATFORM;
+    const mapByResolverOptions = this._resolutionCache;
+    const mapByOrigin = getOrCreateMap(mapByResolverOptions, resolverOptionsKey);
+    const mapByTarget = getOrCreateMap(mapByOrigin, originKey);
+    const mapByPlatform = getOrCreateMap(mapByTarget, targetKey);
+    let modulePath = mapByPlatform.get(platformKey);
+    if (!modulePath) {
+      try {
+        modulePath = this._moduleResolver.resolveDependency(
+          this._moduleCache.getModule(from),
+          to,
+          true,
+          platform,
+          resolverOptions
+        ).path;
+      } catch (error) {
+        if (error instanceof DuplicateHasteCandidatesError) {
+          throw new AmbiguousModuleResolutionError(from, error);
+        }
+        if (error instanceof InvalidPackageError) {
+          throw new PackageResolutionError({
+            packageError: error,
+            originModulePath: from,
+            targetModuleName: to
+          });
+        }
+        throw error;
+      }
+    }
+    mapByPlatform.set(platformKey, modulePath);
+    return modulePath;
+  }
+  _doesFileExist = (filePath) => {
+    return this._hasteFS.exists(filePath);
+  };
+  getHasteName(filePath) {
+    const hasteName = this._hasteFS.getModuleName(filePath);
+    if (hasteName) {
+      return hasteName;
+    }
+    return path.relative(this._config.projectRoot, filePath);
+  }
+  getDependencies(filePath) {
+    return nullthrows(this._hasteFS.getDependencies(filePath));
+  }
+}
+module.exports = DependencyGraph;

package/dist/vendors/metro/src/node-haste/Module.js

@@ -0,0 +1,21 @@
+"use strict";
+const isAbsolutePath = require("absolute-path");
+class Module {
+  path;
+  _moduleCache;
+  _sourceCode;
+  // $FlowFixMe[missing-local-annot]
+  constructor(file, moduleCache) {
+    if (!isAbsolutePath(file)) {
+      throw new Error("Expected file to be absolute path but got " + file);
+    }
+    this.path = file;
+    this._moduleCache = moduleCache;
+  }
+  getPackage() {
+    return this._moduleCache.getPackageForModule(this);
+  }
+  invalidate() {
+  }
+}
+module.exports = Module;