'use strict';var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {return typeof obj;} : function (obj) {return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;};





var _ignore = require('eslint-module-utils/ignore');
var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve);
var _visit = require('eslint-module-utils/visit');var _visit2 = _interopRequireDefault(_visit);
var _path = require('path');
var _readPkgUp2 = require('eslint-module-utils/readPkgUp');var _readPkgUp3 = _interopRequireDefault(_readPkgUp2);
var _object = require('object.values');var _object2 = _interopRequireDefault(_object);
var _arrayIncludes = require('array-includes');var _arrayIncludes2 = _interopRequireDefault(_arrayIncludes);
var _arrayPrototype = require('array.prototype.flatmap');var _arrayPrototype2 = _interopRequireDefault(_arrayPrototype);

var _fsWalk = require('../core/fsWalk');
var _builder = require('../exportMap/builder');var _builder2 = _interopRequireDefault(_builder);
var _patternCapture = require('../exportMap/patternCapture');var _patternCapture2 = _interopRequireDefault(_patternCapture);
var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function _toConsumableArray(arr) {if (Array.isArray(arr)) {for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {arr2[i] = arr[i];}return arr2;} else {return Array.from(arr);}} /**
                                                                                                                                                                                                                                                                                                                                                                                 * @fileOverview Ensures that modules contain exports and/or all
                                                                                                                                                                                                                                                                                                                                                                                 * modules are consumed within other modules.
                                                                                                                                                                                                                                                                                                                                                                                 * @author René Fermann
                                                                                                                                                                                                                                                                                                                                                                                 */ /**
                                                                                                                                                                                                                                                                                                                                                                                     * Attempt to load the internal `FileEnumerator` class, which has existed in a couple
                                                                                                                                                                                                                                                                                                                                                                                     * of different places, depending on the version of `eslint`.  Try requiring it from both
                                                                                                                                                                                                                                                                                                                                                                                     * locations.
                                                                                                                                                                                                                                                                                                                                                                                     * @returns Returns the `FileEnumerator` class if its requirable, otherwise `undefined`.
                                                                                                                                                                                                                                                                                                                                                                                     */function requireFileEnumerator() {var FileEnumerator = void 0;

  // Try getting it from the eslint private / deprecated api
  try {var _require =
    require('eslint/use-at-your-own-risk');FileEnumerator = _require.FileEnumerator;
  } catch (e) {
    // Absorb this if it's MODULE_NOT_FOUND
    if (e.code !== 'MODULE_NOT_FOUND') {
      throw e;
    }

    // If not there, then try getting it from eslint/lib/cli-engine/file-enumerator (moved there in v6)
    try {var _require2 =
      require('eslint/lib/cli-engine/file-enumerator');FileEnumerator = _require2.FileEnumerator;
    } catch (e) {
      // Absorb this if it's MODULE_NOT_FOUND
      if (e.code !== 'MODULE_NOT_FOUND') {
        throw e;
      }
    }
  }
  return FileEnumerator;
}

/**
   *
   * @param FileEnumerator the `FileEnumerator` class from `eslint`'s internal api
   * @param {string} src path to the src root
   * @param {string[]} extensions list of supported extensions
   * @returns {{ filename: string, ignored: boolean }[]} list of files to operate on
   */
function listFilesUsingFileEnumerator(FileEnumerator, src, extensions) {
  var e = new FileEnumerator({
    extensions: extensions });


  return Array.from(
  e.iterateFiles(src),
  function (_ref) {var filePath = _ref.filePath,ignored = _ref.ignored;return { filename: filePath, ignored: ignored };});

}

/**
   * Attempt to require old versions of the file enumeration capability from v6 `eslint` and earlier, and use
   * those functions to provide the list of files to operate on
   * @param {string} src path to the src root
   * @param {string[]} extensions list of supported extensions
   * @returns {string[]} list of files to operate on
   */
function listFilesWithLegacyFunctions(src, extensions) {
  try {
    // eslint/lib/util/glob-util has been moved to eslint/lib/util/glob-utils with version 5.3
    var _require3 = require('eslint/lib/util/glob-utils'),originalListFilesToProcess = _require3.listFilesToProcess;
    // Prevent passing invalid options (extensions array) to old versions of the function.
    // https://github.com/eslint/eslint/blob/v5.16.0/lib/util/glob-utils.js#L178-L280
    // https://github.com/eslint/eslint/blob/v5.2.0/lib/util/glob-util.js#L174-L269

    return originalListFilesToProcess(src, {
      extensions: extensions });

  } catch (e) {
    // Absorb this if it's MODULE_NOT_FOUND
    if (e.code !== 'MODULE_NOT_FOUND') {
      throw e;
    }

    // Last place to try (pre v5.3)
    var _require4 =

    require('eslint/lib/util/glob-util'),_originalListFilesToProcess = _require4.listFilesToProcess;
    var patterns = src.concat(
    (0, _arrayPrototype2['default'])(
    src,
    function (pattern) {return extensions.map(function (extension) {return (/\*\*|\*\./.test(pattern) ? pattern : String(pattern) + '/**/*' + String(extension));});}));



    return _originalListFilesToProcess(patterns);
  }
}

/**
   * Given a source root and list of supported extensions, use fsWalk and the
   * new `eslint` `context.session` api to build the list of files we want to operate on
   * @param {string[]} srcPaths array of source paths (for flat config this should just be a singular root (e.g. cwd))
   * @param {string[]} extensions list of supported extensions
   * @param {{ isDirectoryIgnored: (path: string) => boolean, isFileIgnored: (path: string) => boolean }} session eslint context session object
   * @returns {string[]} list of files to operate on
   */
function listFilesWithModernApi(srcPaths, extensions, session) {
  /** @type {string[]} */
  var files = [];var _loop = function _loop(

  i) {
    var src = srcPaths[i];
    // Use walkSync along with the new session api to gather the list of files
    var entries = (0, _fsWalk.walkSync)(src, {
      deepFilter: function () {function deepFilter(entry) {
          var fullEntryPath = (0, _path.resolve)(src, entry.path);

          // Include the directory if it's not marked as ignore by eslint
          return !session.isDirectoryIgnored(fullEntryPath);
        }return deepFilter;}(),
      entryFilter: function () {function entryFilter(entry) {
          var fullEntryPath = (0, _path.resolve)(src, entry.path);

          // Include the file if it's not marked as ignore by eslint and its extension is included in our list
          return (
            !session.isFileIgnored(fullEntryPath) &&
            extensions.find(function (extension) {return entry.path.endsWith(extension);}));

        }return entryFilter;}() });


    // Filter out directories and map entries to their paths
    files.push.apply(files, _toConsumableArray(
    entries.
    filter(function (entry) {return !entry.dirent.isDirectory();}).
    map(function (entry) {return entry.path;})));};for (var i = 0; i < srcPaths.length; i++) {_loop(i);

  }
  return files;
}

/**
   * Given a src pattern and list of supported extensions, return a list of files to process
   * with this rule.
   * @param {string} src - file, directory, or glob pattern of files to act on
   * @param {string[]} extensions - list of supported file extensions
   * @param {import('eslint').Rule.RuleContext} context - the eslint context object
   * @returns {string[] | { filename: string, ignored: boolean }[]} the list of files that this rule will evaluate.
   */
function listFilesToProcess(src, extensions, context) {
  // If the context object has the new session functions, then prefer those
  // Otherwise, fallback to using the deprecated `FileEnumerator` for legacy support.
  // https://github.com/eslint/eslint/issues/18087
  if (
  context.session &&
  context.session.isFileIgnored &&
  context.session.isDirectoryIgnored)
  {
    return listFilesWithModernApi(src, extensions, context.session);
  }

  // Fallback to og FileEnumerator
  var FileEnumerator = requireFileEnumerator();

  // If we got the FileEnumerator, then let's go with that
  if (FileEnumerator) {
    return listFilesUsingFileEnumerator(FileEnumerator, src, extensions);
  }
  // If not, then we can try even older versions of this capability (listFilesToProcess)
  return listFilesWithLegacyFunctions(src, extensions);
}

var EXPORT_DEFAULT_DECLARATION = 'ExportDefaultDeclaration';
var EXPORT_NAMED_DECLARATION = 'ExportNamedDeclaration';
var EXPORT_ALL_DECLARATION = 'ExportAllDeclaration';
var IMPORT_DECLARATION = 'ImportDeclaration';
var IMPORT_NAMESPACE_SPECIFIER = 'ImportNamespaceSpecifier';
var IMPORT_DEFAULT_SPECIFIER = 'ImportDefaultSpecifier';
var VARIABLE_DECLARATION = 'VariableDeclaration';
var FUNCTION_DECLARATION = 'FunctionDeclaration';
var CLASS_DECLARATION = 'ClassDeclaration';
var IDENTIFIER = 'Identifier';
var OBJECT_PATTERN = 'ObjectPattern';
var ARRAY_PATTERN = 'ArrayPattern';
var TS_INTERFACE_DECLARATION = 'TSInterfaceDeclaration';
var TS_TYPE_ALIAS_DECLARATION = 'TSTypeAliasDeclaration';
var TS_ENUM_DECLARATION = 'TSEnumDeclaration';
var DEFAULT = 'default';

function forEachDeclarationIdentifier(declaration, cb) {
  if (declaration) {
    var isTypeDeclaration = declaration.type === TS_INTERFACE_DECLARATION ||
    declaration.type === TS_TYPE_ALIAS_DECLARATION ||
    declaration.type === TS_ENUM_DECLARATION;

    if (
    declaration.type === FUNCTION_DECLARATION ||
    declaration.type === CLASS_DECLARATION ||
    isTypeDeclaration)
    {
      cb(declaration.id.name, isTypeDeclaration);
    } else if (declaration.type === VARIABLE_DECLARATION) {
      declaration.declarations.forEach(function (_ref2) {var id = _ref2.id;
        if (id.type === OBJECT_PATTERN) {
          (0, _patternCapture2['default'])(id, function (pattern) {
            if (pattern.type === IDENTIFIER) {
              cb(pattern.name, false);
            }
          });
        } else if (id.type === ARRAY_PATTERN) {
          id.elements.forEach(function (_ref3) {var name = _ref3.name;
            cb(name, false);
          });
        } else {
          cb(id.name, false);
        }
      });
    }
  }
}

/**
   * List of imports per file.
   *
   * Represented by a two-level Map to a Set of identifiers. The upper-level Map
   * keys are the paths to the modules containing the imports, while the
   * lower-level Map keys are the paths to the files which are being imported
   * from. Lastly, the Set of identifiers contains either names being imported
   * or a special AST node name listed above (e.g ImportDefaultSpecifier).
   *
   * For example, if we have a file named foo.js containing:
   *
   *   import { o2 } from './bar.js';
   *
   * Then we will have a structure that looks like:
   *
   *   Map { 'foo.js' => Map { 'bar.js' => Set { 'o2' } } }
   *
   * @type {Map<string, Map<string, Set<string>>>}
   */
var importList = new Map();

/**
                             * List of exports per file.
                             *
                             * Represented by a two-level Map to an object of metadata. The upper-level Map
                             * keys are the paths to the modules containing the exports, while the
                             * lower-level Map keys are the specific identifiers or special AST node names
                             * being exported. The leaf-level metadata object at the moment only contains a
                             * `whereUsed` property, which contains a Set of paths to modules that import
                             * the name.
                             *
                             * For example, if we have a file named bar.js containing the following exports:
                             *
                             *   const o2 = 'bar';
                             *   export { o2 };
                             *
                             * And a file named foo.js containing the following import:
                             *
                             *   import { o2 } from './bar.js';
                             *
                             * Then we will have a structure that looks like:
                             *
                             *   Map { 'bar.js' => Map { 'o2' => { whereUsed: Set { 'foo.js' } } } }
                             *
                             * @type {Map<string, Map<string, object>>}
                             */
var exportList = new Map();

var visitorKeyMap = new Map();

/** @type {Set<string>} */
var ignoredFiles = new Set();
var filesOutsideSrc = new Set();

var isNodeModule = function isNodeModule(path) {return (/\/(node_modules)\//.test(path));};

/**
                                                                                             * read all files matching the patterns in src and ignoreExports
                                                                                             *
                                                                                             * return all files matching src pattern, which are not matching the ignoreExports pattern
                                                                                             * @type {(src: string, ignoreExports: string, context: import('eslint').Rule.RuleContext) => Set<string>}
                                                                                             */
function resolveFiles(src, ignoreExports, context) {
  var extensions = Array.from((0, _ignore.getFileExtensions)(context.settings));

  var srcFileList = listFilesToProcess(src, extensions, context);

  // prepare list of ignored files
  var ignoredFilesList = listFilesToProcess(ignoreExports, extensions, context);

  // The modern api will return a list of file paths, rather than an object
  if (ignoredFilesList.length && typeof ignoredFilesList[0] === 'string') {
    ignoredFilesList.forEach(function (filename) {return ignoredFiles.add(filename);});
  } else {
    ignoredFilesList.forEach(function (_ref4) {var filename = _ref4.filename;return ignoredFiles.add(filename);});
  }

  // prepare list of source files, don't consider files from node_modules
  var resolvedFiles = srcFileList.length && typeof srcFileList[0] === 'string' ?
  srcFileList.filter(function (filePath) {return !isNodeModule(filePath);}) :
  (0, _arrayPrototype2['default'])(srcFileList, function (_ref5) {var filename = _ref5.filename;return isNodeModule(filename) ? [] : filename;});

  return new Set(resolvedFiles);
}

/**
   * parse all source files and build up 2 maps containing the existing imports and exports
   */
var prepareImportsAndExports = function prepareImportsAndExports(srcFiles, context) {
  var exportAll = new Map();
  srcFiles.forEach(function (file) {
    var exports = new Map();
    var imports = new Map();
    var currentExports = _builder2['default'].get(file, context);
    if (currentExports) {var

      dependencies =




      currentExports.dependencies,reexports = currentExports.reexports,localImportList = currentExports.imports,namespace = currentExports.namespace,visitorKeys = currentExports.visitorKeys;

      visitorKeyMap.set(file, visitorKeys);
      // dependencies === export * from
      var currentExportAll = new Set();
      dependencies.forEach(function (getDependency) {
        var dependency = getDependency();
        if (dependency === null) {
          return;
        }

        currentExportAll.add(dependency.path);
      });
      exportAll.set(file, currentExportAll);

      reexports.forEach(function (value, key) {
        if (key === DEFAULT) {
          exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed: new Set() });
        } else {
          exports.set(key, { whereUsed: new Set() });
        }
        var reexport = value.getImport();
        if (!reexport) {
          return;
        }
        var localImport = imports.get(reexport.path);
        var currentValue = void 0;
        if (value.local === DEFAULT) {
          currentValue = IMPORT_DEFAULT_SPECIFIER;
        } else {
          currentValue = value.local;
        }
        if (typeof localImport !== 'undefined') {
          localImport = new Set([].concat(_toConsumableArray(localImport), [currentValue]));
        } else {
          localImport = new Set([currentValue]);
        }
        imports.set(reexport.path, localImport);
      });

      localImportList.forEach(function (value, key) {
        if (isNodeModule(key)) {
          return;
        }
        var localImport = imports.get(key) || new Set();
        value.declarations.forEach(function (_ref6) {var importedSpecifiers = _ref6.importedSpecifiers;
          importedSpecifiers.forEach(function (specifier) {
            localImport.add(specifier);
          });
        });
        imports.set(key, localImport);
      });
      importList.set(file, imports);

      // build up export list only, if file is not ignored
      if (ignoredFiles.has(file)) {
        return;
      }
      namespace.forEach(function (value, key) {
        if (key === DEFAULT) {
          exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed: new Set() });
        } else {
          exports.set(key, { whereUsed: new Set() });
        }
      });
    }
    exports.set(EXPORT_ALL_DECLARATION, { whereUsed: new Set() });
    exports.set(IMPORT_NAMESPACE_SPECIFIER, { whereUsed: new Set() });
    exportList.set(file, exports);
  });
  exportAll.forEach(function (value, key) {
    value.forEach(function (val) {
      var currentExports = exportList.get(val);
      if (currentExports) {
        var currentExport = currentExports.get(EXPORT_ALL_DECLARATION);
        currentExport.whereUsed.add(key);
      }
    });
  });
};

/**
    * traverse through all imports and add the respective path to the whereUsed-list
    * of the corresponding export
    */
var determineUsage = function determineUsage() {
  importList.forEach(function (listValue, listKey) {
    listValue.forEach(function (value, key) {
      var exports = exportList.get(key);
      if (typeof exports !== 'undefined') {
        value.forEach(function (currentImport) {
          var specifier = void 0;
          if (currentImport === IMPORT_NAMESPACE_SPECIFIER) {
            specifier = IMPORT_NAMESPACE_SPECIFIER;
          } else if (currentImport === IMPORT_DEFAULT_SPECIFIER) {
            specifier = IMPORT_DEFAULT_SPECIFIER;
          } else {
            specifier = currentImport;
          }
          if (typeof specifier !== 'undefined') {
            var exportStatement = exports.get(specifier);
            if (typeof exportStatement !== 'undefined') {var
              whereUsed = exportStatement.whereUsed;
              whereUsed.add(listKey);
              exports.set(specifier, { whereUsed: whereUsed });
            }
          }
        });
      }
    });
  });
};

var getSrc = function getSrc(src) {
  if (src) {
    return src;
  }
  return [process.cwd()];
};

/**
    * prepare the lists of existing imports and exports - should only be executed once at
    * the start of a new eslint run
    */
/** @type {Set<string>} */
var srcFiles = void 0;
var lastPrepareKey = void 0;
var doPreparation = function doPreparation(src, ignoreExports, context) {
  var prepareKey = JSON.stringify({
    src: (src || []).sort(),
    ignoreExports: (ignoreExports || []).sort(),
    extensions: Array.from((0, _ignore.getFileExtensions)(context.settings)).sort() });

  if (prepareKey === lastPrepareKey) {
    return;
  }

  importList.clear();
  exportList.clear();
  ignoredFiles.clear();
  filesOutsideSrc.clear();

  srcFiles = resolveFiles(getSrc(src), ignoreExports, context);
  prepareImportsAndExports(srcFiles, context);
  determineUsage();
  lastPrepareKey = prepareKey;
};

var newNamespaceImportExists = function newNamespaceImportExists(specifiers) {return specifiers.some(function (_ref7) {var type = _ref7.type;return type === IMPORT_NAMESPACE_SPECIFIER;});};

var newDefaultImportExists = function newDefaultImportExists(specifiers) {return specifiers.some(function (_ref8) {var type = _ref8.type;return type === IMPORT_DEFAULT_SPECIFIER;});};

var fileIsInPkg = function fileIsInPkg(file) {var _readPkgUp =
  (0, _readPkgUp3['default'])({ cwd: file }),path = _readPkgUp.path,pkg = _readPkgUp.pkg;
  var basePath = (0, _path.dirname)(path);

  var checkPkgFieldString = function checkPkgFieldString(pkgField) {
    if ((0, _path.join)(basePath, pkgField) === file) {
      return true;
    }
  };

  var checkPkgFieldObject = function checkPkgFieldObject(pkgField) {
    var pkgFieldFiles = (0, _arrayPrototype2['default'])((0, _object2['default'])(pkgField), function (value) {return typeof value === 'boolean' ? [] : (0, _path.join)(basePath, value);});

    if ((0, _arrayIncludes2['default'])(pkgFieldFiles, file)) {
      return true;
    }
  };

  var checkPkgField = function checkPkgField(pkgField) {
    if (typeof pkgField === 'string') {
      return checkPkgFieldString(pkgField);
    }

    if ((typeof pkgField === 'undefined' ? 'undefined' : _typeof(pkgField)) === 'object') {
      return checkPkgFieldObject(pkgField);
    }
  };

  if (pkg['private'] === true) {
    return false;
  }

  if (pkg.bin) {
    if (checkPkgField(pkg.bin)) {
      return true;
    }
  }

  if (pkg.browser) {
    if (checkPkgField(pkg.browser)) {
      return true;
    }
  }

  if (pkg.main) {
    if (checkPkgFieldString(pkg.main)) {
      return true;
    }
  }

  return false;
};

module.exports = {
  meta: {
    type: 'suggestion',
    docs: {
      category: 'Helpful warnings',
      description: 'Forbid modules without exports, or exports without matching import in another module.',
      url: (0, _docsUrl2['default'])('no-unused-modules') },

    schema: [{
      properties: {
        src: {
          description: 'files/paths to be analyzed (only for unused exports)',
          type: 'array',
          uniqueItems: true,
          items: {
            type: 'string',
            minLength: 1 } },


        ignoreExports: {
          description: 'files/paths for which unused exports will not be reported (e.g module entry points)',
          type: 'array',
          uniqueItems: true,
          items: {
            type: 'string',
            minLength: 1 } },


        missingExports: {
          description: 'report modules without any exports',
          type: 'boolean' },

        unusedExports: {
          description: 'report exports without any usage',
          type: 'boolean' },

        ignoreUnusedTypeExports: {
          description: 'ignore type exports without any usage',
          type: 'boolean' } },


      anyOf: [
      {
        properties: {
          unusedExports: { 'enum': [true] },
          src: {
            minItems: 1 } },


        required: ['unusedExports'] },

      {
        properties: {
          missingExports: { 'enum': [true] } },

        required: ['missingExports'] }] }] },





  create: function () {function create(context) {var _ref9 =






      context.options[0] || {},src = _ref9.src,_ref9$ignoreExports = _ref9.ignoreExports,ignoreExports = _ref9$ignoreExports === undefined ? [] : _ref9$ignoreExports,missingExports = _ref9.missingExports,unusedExports = _ref9.unusedExports,ignoreUnusedTypeExports = _ref9.ignoreUnusedTypeExports;

      if (unusedExports) {
        doPreparation(src, ignoreExports, context);
      }

      var file = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();

      var checkExportPresence = function () {function checkExportPresence(node) {
          if (!missingExports) {
            return;
          }

          if (ignoredFiles.has(file)) {
            return;
          }

          var exportCount = exportList.get(file);
          var exportAll = exportCount.get(EXPORT_ALL_DECLARATION);
          var namespaceImports = exportCount.get(IMPORT_NAMESPACE_SPECIFIER);

          exportCount['delete'](EXPORT_ALL_DECLARATION);
          exportCount['delete'](IMPORT_NAMESPACE_SPECIFIER);
          if (exportCount.size < 1) {
            // node.body[0] === 'undefined' only happens, if everything is commented out in the file
            // being linted
            context.report(node.body[0] ? node.body[0] : node, 'No exports found');
          }
          exportCount.set(EXPORT_ALL_DECLARATION, exportAll);
          exportCount.set(IMPORT_NAMESPACE_SPECIFIER, namespaceImports);
        }return checkExportPresence;}();

      var checkUsage = function () {function checkUsage(node, exportedValue, isTypeExport) {
          if (!unusedExports) {
            return;
          }

          if (isTypeExport && ignoreUnusedTypeExports) {
            return;
          }

          if (ignoredFiles.has(file)) {
            return;
          }

          if (fileIsInPkg(file)) {
            return;
          }

          if (filesOutsideSrc.has(file)) {
            return;
          }

          // make sure file to be linted is included in source files
          if (!srcFiles.has(file)) {
            srcFiles = resolveFiles(getSrc(src), ignoreExports, context);
            if (!srcFiles.has(file)) {
              filesOutsideSrc.add(file);
              return;
            }
          }

          exports = exportList.get(file);

          if (!exports) {
            console.error('file `' + String(file) + '` has no exports. Please update to the latest, and if it still happens, report this on https://github.com/import-js/eslint-plugin-import/issues/2866!');
          }

          // special case: export * from
          var exportAll = exports.get(EXPORT_ALL_DECLARATION);
          if (typeof exportAll !== 'undefined' && exportedValue !== IMPORT_DEFAULT_SPECIFIER) {
            if (exportAll.whereUsed.size > 0) {
              return;
            }
          }

          // special case: namespace import
          var namespaceImports = exports.get(IMPORT_NAMESPACE_SPECIFIER);
          if (typeof namespaceImports !== 'undefined') {
            if (namespaceImports.whereUsed.size > 0) {
              return;
            }
          }

          // exportsList will always map any imported value of 'default' to 'ImportDefaultSpecifier'
          var exportsKey = exportedValue === DEFAULT ? IMPORT_DEFAULT_SPECIFIER : exportedValue;

          var exportStatement = exports.get(exportsKey);

          var value = exportsKey === IMPORT_DEFAULT_SPECIFIER ? DEFAULT : exportsKey;

          if (typeof exportStatement !== 'undefined') {
            if (exportStatement.whereUsed.size < 1) {
              context.report(
              node, 'exported declaration \'' +
              value + '\' not used within other modules');

            }
          } else {
            context.report(
            node, 'exported declaration \'' +
            value + '\' not used within other modules');

          }
        }return checkUsage;}();

      /**
                                 * only useful for tools like vscode-eslint
                                 *
                                 * update lists of existing exports during runtime
                                 */
      var updateExportUsage = function () {function updateExportUsage(node) {
          if (ignoredFiles.has(file)) {
            return;
          }

          var exports = exportList.get(file);

          // new module has been created during runtime
          // include it in further processing
          if (typeof exports === 'undefined') {
            exports = new Map();
          }

          var newExports = new Map();
          var newExportIdentifiers = new Set();

          node.body.forEach(function (_ref10) {var type = _ref10.type,declaration = _ref10.declaration,specifiers = _ref10.specifiers;
            if (type === EXPORT_DEFAULT_DECLARATION) {
              newExportIdentifiers.add(IMPORT_DEFAULT_SPECIFIER);
            }
            if (type === EXPORT_NAMED_DECLARATION) {
              if (specifiers.length > 0) {
                specifiers.forEach(function (specifier) {
                  if (specifier.exported) {
                    newExportIdentifiers.add(specifier.exported.name || specifier.exported.value);
                  }
                });
              }
              forEachDeclarationIdentifier(declaration, function (name) {
                newExportIdentifiers.add(name);
              });
            }
          });

          // old exports exist within list of new exports identifiers: add to map of new exports
          exports.forEach(function (value, key) {
            if (newExportIdentifiers.has(key)) {
              newExports.set(key, value);
            }
          });

          // new export identifiers added: add to map of new exports
          newExportIdentifiers.forEach(function (key) {
            if (!exports.has(key)) {
              newExports.set(key, { whereUsed: new Set() });
            }
          });

          // preserve information about namespace imports
          var exportAll = exports.get(EXPORT_ALL_DECLARATION);
          var namespaceImports = exports.get(IMPORT_NAMESPACE_SPECIFIER);

          if (typeof namespaceImports === 'undefined') {
            namespaceImports = { whereUsed: new Set() };
          }

          newExports.set(EXPORT_ALL_DECLARATION, exportAll);
          newExports.set(IMPORT_NAMESPACE_SPECIFIER, namespaceImports);
          exportList.set(file, newExports);
        }return updateExportUsage;}();

      /**
                                        * only useful for tools like vscode-eslint
                                        *
                                        * update lists of existing imports during runtime
                                        */
      var updateImportUsage = function () {function updateImportUsage(node) {
          if (!unusedExports) {
            return;
          }

          var oldImportPaths = importList.get(file);
          if (typeof oldImportPaths === 'undefined') {
            oldImportPaths = new Map();
          }

          var oldNamespaceImports = new Set();
          var newNamespaceImports = new Set();

          var oldExportAll = new Set();
          var newExportAll = new Set();

          var oldDefaultImports = new Set();
          var newDefaultImports = new Set();

          var oldImports = new Map();
          var newImports = new Map();
          oldImportPaths.forEach(function (value, key) {
            if (value.has(EXPORT_ALL_DECLARATION)) {
              oldExportAll.add(key);
            }
            if (value.has(IMPORT_NAMESPACE_SPECIFIER)) {
              oldNamespaceImports.add(key);
            }
            if (value.has(IMPORT_DEFAULT_SPECIFIER)) {
              oldDefaultImports.add(key);
            }
            value.forEach(function (val) {
              if (
              val !== IMPORT_NAMESPACE_SPECIFIER &&
              val !== IMPORT_DEFAULT_SPECIFIER)
              {
                oldImports.set(val, key);
              }
            });
          });

          function processDynamicImport(source) {
            if (source.type !== 'Literal') {
              return null;
            }
            var p = (0, _resolve2['default'])(source.value, context);
            if (p == null) {
              return null;
            }
            newNamespaceImports.add(p);
          }

          (0, _visit2['default'])(node, visitorKeyMap.get(file), {
            ImportExpression: function () {function ImportExpression(child) {
                processDynamicImport(child.source);
              }return ImportExpression;}(),
            CallExpression: function () {function CallExpression(child) {
                if (child.callee.type === 'Import') {
                  processDynamicImport(child.arguments[0]);
                }
              }return CallExpression;}() });


          node.body.forEach(function (astNode) {
            var resolvedPath = void 0;

            // support for export { value } from 'module'
            if (astNode.type === EXPORT_NAMED_DECLARATION) {
              if (astNode.source) {
                resolvedPath = (0, _resolve2['default'])(astNode.source.raw.replace(/('|")/g, ''), context);
                astNode.specifiers.forEach(function (specifier) {
                  var name = specifier.local.name || specifier.local.value;
                  if (name === DEFAULT) {
                    newDefaultImports.add(resolvedPath);
                  } else {
                    newImports.set(name, resolvedPath);
                  }
                });
              }
            }

            if (astNode.type === EXPORT_ALL_DECLARATION) {
              resolvedPath = (0, _resolve2['default'])(astNode.source.raw.replace(/('|")/g, ''), context);
              newExportAll.add(resolvedPath);
            }

            if (astNode.type === IMPORT_DECLARATION) {
              resolvedPath = (0, _resolve2['default'])(astNode.source.raw.replace(/('|")/g, ''), context);
              if (!resolvedPath) {
                return;
              }

              if (isNodeModule(resolvedPath)) {
                return;
              }

              if (newNamespaceImportExists(astNode.specifiers)) {
                newNamespaceImports.add(resolvedPath);
              }

              if (newDefaultImportExists(astNode.specifiers)) {
                newDefaultImports.add(resolvedPath);
              }

              astNode.specifiers.
              filter(function (specifier) {return specifier.type !== IMPORT_DEFAULT_SPECIFIER && specifier.type !== IMPORT_NAMESPACE_SPECIFIER;}).
              forEach(function (specifier) {
                newImports.set(specifier.imported.name || specifier.imported.value, resolvedPath);
              });
            }
          });

          newExportAll.forEach(function (value) {
            if (!oldExportAll.has(value)) {
              var imports = oldImportPaths.get(value);
              if (typeof imports === 'undefined') {
                imports = new Set();
              }
              imports.add(EXPORT_ALL_DECLARATION);
              oldImportPaths.set(value, imports);

              var _exports = exportList.get(value);
              var currentExport = void 0;
              if (typeof _exports !== 'undefined') {
                currentExport = _exports.get(EXPORT_ALL_DECLARATION);
              } else {
                _exports = new Map();
                exportList.set(value, _exports);
              }

              if (typeof currentExport !== 'undefined') {
                currentExport.whereUsed.add(file);
              } else {
                var whereUsed = new Set();
                whereUsed.add(file);
                _exports.set(EXPORT_ALL_DECLARATION, { whereUsed: whereUsed });
              }
            }
          });

          oldExportAll.forEach(function (value) {
            if (!newExportAll.has(value)) {
              var imports = oldImportPaths.get(value);
              imports['delete'](EXPORT_ALL_DECLARATION);

              var _exports2 = exportList.get(value);
              if (typeof _exports2 !== 'undefined') {
                var currentExport = _exports2.get(EXPORT_ALL_DECLARATION);
                if (typeof currentExport !== 'undefined') {
                  currentExport.whereUsed['delete'](file);
                }
              }
            }
          });

          newDefaultImports.forEach(function (value) {
            if (!oldDefaultImports.has(value)) {
              var imports = oldImportPaths.get(value);
              if (typeof imports === 'undefined') {
                imports = new Set();
              }
              imports.add(IMPORT_DEFAULT_SPECIFIER);
              oldImportPaths.set(value, imports);

              var _exports3 = exportList.get(value);
              var currentExport = void 0;
              if (typeof _exports3 !== 'undefined') {
                currentExport = _exports3.get(IMPORT_DEFAULT_SPECIFIER);
              } else {
                _exports3 = new Map();
                exportList.set(value, _exports3);
              }

              if (typeof currentExport !== 'undefined') {
                currentExport.whereUsed.add(file);
              } else {
                var whereUsed = new Set();
                whereUsed.add(file);
                _exports3.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed: whereUsed });
              }
            }
          });

          oldDefaultImports.forEach(function (value) {
            if (!newDefaultImports.has(value)) {
              var imports = oldImportPaths.get(value);
              imports['delete'](IMPORT_DEFAULT_SPECIFIER);

              var _exports4 = exportList.get(value);
              if (typeof _exports4 !== 'undefined') {
                var currentExport = _exports4.get(IMPORT_DEFAULT_SPECIFIER);
                if (typeof currentExport !== 'undefined') {
                  currentExport.whereUsed['delete'](file);
                }
              }
            }
          });

          newNamespaceImports.forEach(function (value) {
            if (!oldNamespaceImports.has(value)) {
              var imports = oldImportPaths.get(value);
              if (typeof imports === 'undefined') {
                imports = new Set();
              }
              imports.add(IMPORT_NAMESPACE_SPECIFIER);
              oldImportPaths.set(value, imports);

              var _exports5 = exportList.get(value);
              var currentExport = void 0;
              if (typeof _exports5 !== 'undefined') {
                currentExport = _exports5.get(IMPORT_NAMESPACE_SPECIFIER);
              } else {
                _exports5 = new Map();
                exportList.set(value, _exports5);
              }

              if (typeof currentExport !== 'undefined') {
                currentExport.whereUsed.add(file);
              } else {
                var whereUsed = new Set();
                whereUsed.add(file);
                _exports5.set(IMPORT_NAMESPACE_SPECIFIER, { whereUsed: whereUsed });
              }
            }
          });

          oldNamespaceImports.forEach(function (value) {
            if (!newNamespaceImports.has(value)) {
              var imports = oldImportPaths.get(value);
              imports['delete'](IMPORT_NAMESPACE_SPECIFIER);

              var _exports6 = exportList.get(value);
              if (typeof _exports6 !== 'undefined') {
                var currentExport = _exports6.get(IMPORT_NAMESPACE_SPECIFIER);
                if (typeof currentExport !== 'undefined') {
                  currentExport.whereUsed['delete'](file);
                }
              }
            }
          });

          newImports.forEach(function (value, key) {
            if (!oldImports.has(key)) {
              var imports = oldImportPaths.get(value);
              if (typeof imports === 'undefined') {
                imports = new Set();
              }
              imports.add(key);
              oldImportPaths.set(value, imports);

              var _exports7 = exportList.get(value);
              var currentExport = void 0;
              if (typeof _exports7 !== 'undefined') {
                currentExport = _exports7.get(key);
              } else {
                _exports7 = new Map();
                exportList.set(value, _exports7);
              }

              if (typeof currentExport !== 'undefined') {
                currentExport.whereUsed.add(file);
              } else {
                var whereUsed = new Set();
                whereUsed.add(file);
                _exports7.set(key, { whereUsed: whereUsed });
              }
            }
          });

          oldImports.forEach(function (value, key) {
            if (!newImports.has(key)) {
              var imports = oldImportPaths.get(value);
              imports['delete'](key);

              var _exports8 = exportList.get(value);
              if (typeof _exports8 !== 'undefined') {
                var currentExport = _exports8.get(key);
                if (typeof currentExport !== 'undefined') {
                  currentExport.whereUsed['delete'](file);
                }
              }
            }
          });
        }return updateImportUsage;}();

      return {
        'Program:exit': function () {function ProgramExit(node) {
            updateExportUsage(node);
            updateImportUsage(node);
            checkExportPresence(node);
          }return ProgramExit;}(),
        ExportDefaultDeclaration: function () {function ExportDefaultDeclaration(node) {
            checkUsage(node, IMPORT_DEFAULT_SPECIFIER, false);
          }return ExportDefaultDeclaration;}(),
        ExportNamedDeclaration: function () {function ExportNamedDeclaration(node) {
            node.specifiers.forEach(function (specifier) {
              checkUsage(specifier, specifier.exported.name || specifier.exported.value, false);
            });
            forEachDeclarationIdentifier(node.declaration, function (name, isTypeExport) {
              checkUsage(node, name, isTypeExport);
            });
          }return ExportNamedDeclaration;}() };

    }return create;}() };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-unused-modules.js"],"names":["requireFileEnumerator","FileEnumerator","require","e","code","listFilesUsingFileEnumerator","src","extensions","Array","from","iterateFiles","filePath","ignored","filename","listFilesWithLegacyFunctions","originalListFilesToProcess","listFilesToProcess","patterns","concat","pattern","map","extension","test","listFilesWithModernApi","srcPaths","session","files","i","entries","deepFilter","entry","fullEntryPath","path","isDirectoryIgnored","entryFilter","isFileIgnored","find","endsWith","push","filter","dirent","isDirectory","length","context","EXPORT_DEFAULT_DECLARATION","EXPORT_NAMED_DECLARATION","EXPORT_ALL_DECLARATION","IMPORT_DECLARATION","IMPORT_NAMESPACE_SPECIFIER","IMPORT_DEFAULT_SPECIFIER","VARIABLE_DECLARATION","FUNCTION_DECLARATION","CLASS_DECLARATION","IDENTIFIER","OBJECT_PATTERN","ARRAY_PATTERN","TS_INTERFACE_DECLARATION","TS_TYPE_ALIAS_DECLARATION","TS_ENUM_DECLARATION","DEFAULT","forEachDeclarationIdentifier","declaration","cb","isTypeDeclaration","type","id","name","declarations","forEach","elements","importList","Map","exportList","visitorKeyMap","ignoredFiles","Set","filesOutsideSrc","isNodeModule","resolveFiles","ignoreExports","settings","srcFileList","ignoredFilesList","add","resolvedFiles","prepareImportsAndExports","srcFiles","exportAll","file","exports","imports","currentExports","ExportMapBuilder","get","dependencies","reexports","localImportList","namespace","visitorKeys","set","currentExportAll","getDependency","dependency","value","key","whereUsed","reexport","getImport","localImport","currentValue","local","importedSpecifiers","specifier","has","val","currentExport","determineUsage","listValue","listKey","currentImport","exportStatement","getSrc","process","cwd","lastPrepareKey","doPreparation","prepareKey","JSON","stringify","sort","clear","newNamespaceImportExists","specifiers","some","newDefaultImportExists","fileIsInPkg","pkg","basePath","checkPkgFieldString","pkgField","checkPkgFieldObject","pkgFieldFiles","checkPkgField","bin","browser","main","module","meta","docs","category","description","url","schema","properties","uniqueItems","items","minLength","missingExports","unusedExports","ignoreUnusedTypeExports","anyOf","minItems","required","create","options","getPhysicalFilename","getFilename","checkExportPresence","node","exportCount","namespaceImports","size","report","body","checkUsage","exportedValue","isTypeExport","console","error","exportsKey","updateExportUsage","newExports","newExportIdentifiers","exported","updateImportUsage","oldImportPaths","oldNamespaceImports","newNamespaceImports","oldExportAll","newExportAll","oldDefaultImports","newDefaultImports","oldImports","newImports","processDynamicImport","source","p","ImportExpression","child","CallExpression","callee","arguments","astNode","resolvedPath","raw","replace","imported","ExportDefaultDeclaration","ExportNamedDeclaration"],"mappings":"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","file":"no-unused-modules.js","sourcesContent":["/**\n * @fileOverview Ensures that modules contain exports and/or all\n * modules are consumed within other modules.\n * @author René Fermann\n */\n\nimport { getFileExtensions } from 'eslint-module-utils/ignore';\nimport resolve from 'eslint-module-utils/resolve';\nimport visit from 'eslint-module-utils/visit';\nimport { dirname, join, resolve as resolvePath } from 'path';\nimport readPkgUp from 'eslint-module-utils/readPkgUp';\nimport values from 'object.values';\nimport includes from 'array-includes';\nimport flatMap from 'array.prototype.flatmap';\n\nimport { walkSync } from '../core/fsWalk';\nimport ExportMapBuilder from '../exportMap/builder';\nimport recursivePatternCapture from '../exportMap/patternCapture';\nimport docsUrl from '../docsUrl';\n\n/**\n * Attempt to load the internal `FileEnumerator` class, which has existed in a couple\n * of different places, depending on the version of `eslint`.  Try requiring it from both\n * locations.\n * @returns Returns the `FileEnumerator` class if its requirable, otherwise `undefined`.\n */\nfunction requireFileEnumerator() {\n  let FileEnumerator;\n\n  // Try getting it from the eslint private / deprecated api\n  try {\n    ({ FileEnumerator } = require('eslint/use-at-your-own-risk'));\n  } catch (e) {\n    // Absorb this if it's MODULE_NOT_FOUND\n    if (e.code !== 'MODULE_NOT_FOUND') {\n      throw e;\n    }\n\n    // If not there, then try getting it from eslint/lib/cli-engine/file-enumerator (moved there in v6)\n    try {\n      ({ FileEnumerator } = require('eslint/lib/cli-engine/file-enumerator'));\n    } catch (e) {\n      // Absorb this if it's MODULE_NOT_FOUND\n      if (e.code !== 'MODULE_NOT_FOUND') {\n        throw e;\n      }\n    }\n  }\n  return FileEnumerator;\n}\n\n/**\n *\n * @param FileEnumerator the `FileEnumerator` class from `eslint`'s internal api\n * @param {string} src path to the src root\n * @param {string[]} extensions list of supported extensions\n * @returns {{ filename: string, ignored: boolean }[]} list of files to operate on\n */\nfunction listFilesUsingFileEnumerator(FileEnumerator, src, extensions) {\n  const e = new FileEnumerator({\n    extensions,\n  });\n\n  return Array.from(\n    e.iterateFiles(src),\n    ({ filePath, ignored }) => ({ filename: filePath, ignored }),\n  );\n}\n\n/**\n * Attempt to require old versions of the file enumeration capability from v6 `eslint` and earlier, and use\n * those functions to provide the list of files to operate on\n * @param {string} src path to the src root\n * @param {string[]} extensions list of supported extensions\n * @returns {string[]} list of files to operate on\n */\nfunction listFilesWithLegacyFunctions(src, extensions) {\n  try {\n    // eslint/lib/util/glob-util has been moved to eslint/lib/util/glob-utils with version 5.3\n    const { listFilesToProcess: originalListFilesToProcess } = require('eslint/lib/util/glob-utils');\n    // Prevent passing invalid options (extensions array) to old versions of the function.\n    // https://github.com/eslint/eslint/blob/v5.16.0/lib/util/glob-utils.js#L178-L280\n    // https://github.com/eslint/eslint/blob/v5.2.0/lib/util/glob-util.js#L174-L269\n\n    return originalListFilesToProcess(src, {\n      extensions,\n    });\n  } catch (e) {\n    // Absorb this if it's MODULE_NOT_FOUND\n    if (e.code !== 'MODULE_NOT_FOUND') {\n      throw e;\n    }\n\n    // Last place to try (pre v5.3)\n    const {\n      listFilesToProcess: originalListFilesToProcess,\n    } = require('eslint/lib/util/glob-util');\n    const patterns = src.concat(\n      flatMap(\n        src,\n        (pattern) => extensions.map((extension) => (/\\*\\*|\\*\\./).test(pattern) ? pattern : `${pattern}/**/*${extension}`),\n      ),\n    );\n\n    return originalListFilesToProcess(patterns);\n  }\n}\n\n/**\n * Given a source root and list of supported extensions, use fsWalk and the\n * new `eslint` `context.session` api to build the list of files we want to operate on\n * @param {string[]} srcPaths array of source paths (for flat config this should just be a singular root (e.g. cwd))\n * @param {string[]} extensions list of supported extensions\n * @param {{ isDirectoryIgnored: (path: string) => boolean, isFileIgnored: (path: string) => boolean }} session eslint context session object\n * @returns {string[]} list of files to operate on\n */\nfunction listFilesWithModernApi(srcPaths, extensions, session) {\n  /** @type {string[]} */\n  const files = [];\n\n  for (let i = 0; i < srcPaths.length; i++) {\n    const src = srcPaths[i];\n    // Use walkSync along with the new session api to gather the list of files\n    const entries = walkSync(src, {\n      deepFilter(entry) {\n        const fullEntryPath = resolvePath(src, entry.path);\n\n        // Include the directory if it's not marked as ignore by eslint\n        return !session.isDirectoryIgnored(fullEntryPath);\n      },\n      entryFilter(entry) {\n        const fullEntryPath = resolvePath(src, entry.path);\n\n        // Include the file if it's not marked as ignore by eslint and its extension is included in our list\n        return (\n          !session.isFileIgnored(fullEntryPath)\n          && extensions.find((extension) => entry.path.endsWith(extension))\n        );\n      },\n    });\n\n    // Filter out directories and map entries to their paths\n    files.push(\n      ...entries\n        .filter((entry) => !entry.dirent.isDirectory())\n        .map((entry) => entry.path),\n    );\n  }\n  return files;\n}\n\n/**\n * Given a src pattern and list of supported extensions, return a list of files to process\n * with this rule.\n * @param {string} src - file, directory, or glob pattern of files to act on\n * @param {string[]} extensions - list of supported file extensions\n * @param {import('eslint').Rule.RuleContext} context - the eslint context object\n * @returns {string[] | { filename: string, ignored: boolean }[]} the list of files that this rule will evaluate.\n */\nfunction listFilesToProcess(src, extensions, context) {\n  // If the context object has the new session functions, then prefer those\n  // Otherwise, fallback to using the deprecated `FileEnumerator` for legacy support.\n  // https://github.com/eslint/eslint/issues/18087\n  if (\n    context.session\n    && context.session.isFileIgnored\n    && context.session.isDirectoryIgnored\n  ) {\n    return listFilesWithModernApi(src, extensions, context.session);\n  }\n\n  // Fallback to og FileEnumerator\n  const FileEnumerator = requireFileEnumerator();\n\n  // If we got the FileEnumerator, then let's go with that\n  if (FileEnumerator) {\n    return listFilesUsingFileEnumerator(FileEnumerator, src, extensions);\n  }\n  // If not, then we can try even older versions of this capability (listFilesToProcess)\n  return listFilesWithLegacyFunctions(src, extensions);\n}\n\nconst EXPORT_DEFAULT_DECLARATION = 'ExportDefaultDeclaration';\nconst EXPORT_NAMED_DECLARATION = 'ExportNamedDeclaration';\nconst EXPORT_ALL_DECLARATION = 'ExportAllDeclaration';\nconst IMPORT_DECLARATION = 'ImportDeclaration';\nconst IMPORT_NAMESPACE_SPECIFIER = 'ImportNamespaceSpecifier';\nconst IMPORT_DEFAULT_SPECIFIER = 'ImportDefaultSpecifier';\nconst VARIABLE_DECLARATION = 'VariableDeclaration';\nconst FUNCTION_DECLARATION = 'FunctionDeclaration';\nconst CLASS_DECLARATION = 'ClassDeclaration';\nconst IDENTIFIER = 'Identifier';\nconst OBJECT_PATTERN = 'ObjectPattern';\nconst ARRAY_PATTERN = 'ArrayPattern';\nconst TS_INTERFACE_DECLARATION = 'TSInterfaceDeclaration';\nconst TS_TYPE_ALIAS_DECLARATION = 'TSTypeAliasDeclaration';\nconst TS_ENUM_DECLARATION = 'TSEnumDeclaration';\nconst DEFAULT = 'default';\n\nfunction forEachDeclarationIdentifier(declaration, cb) {\n  if (declaration) {\n    const isTypeDeclaration = declaration.type === TS_INTERFACE_DECLARATION\n      || declaration.type === TS_TYPE_ALIAS_DECLARATION\n      || declaration.type === TS_ENUM_DECLARATION;\n\n    if (\n      declaration.type === FUNCTION_DECLARATION\n      || declaration.type === CLASS_DECLARATION\n      || isTypeDeclaration\n    ) {\n      cb(declaration.id.name, isTypeDeclaration);\n    } else if (declaration.type === VARIABLE_DECLARATION) {\n      declaration.declarations.forEach(({ id }) => {\n        if (id.type === OBJECT_PATTERN) {\n          recursivePatternCapture(id, (pattern) => {\n            if (pattern.type === IDENTIFIER) {\n              cb(pattern.name, false);\n            }\n          });\n        } else if (id.type === ARRAY_PATTERN) {\n          id.elements.forEach(({ name }) => {\n            cb(name, false);\n          });\n        } else {\n          cb(id.name, false);\n        }\n      });\n    }\n  }\n}\n\n/**\n * List of imports per file.\n *\n * Represented by a two-level Map to a Set of identifiers. The upper-level Map\n * keys are the paths to the modules containing the imports, while the\n * lower-level Map keys are the paths to the files which are being imported\n * from. Lastly, the Set of identifiers contains either names being imported\n * or a special AST node name listed above (e.g ImportDefaultSpecifier).\n *\n * For example, if we have a file named foo.js containing:\n *\n *   import { o2 } from './bar.js';\n *\n * Then we will have a structure that looks like:\n *\n *   Map { 'foo.js' => Map { 'bar.js' => Set { 'o2' } } }\n *\n * @type {Map<string, Map<string, Set<string>>>}\n */\nconst importList = new Map();\n\n/**\n * List of exports per file.\n *\n * Represented by a two-level Map to an object of metadata. The upper-level Map\n * keys are the paths to the modules containing the exports, while the\n * lower-level Map keys are the specific identifiers or special AST node names\n * being exported. The leaf-level metadata object at the moment only contains a\n * `whereUsed` property, which contains a Set of paths to modules that import\n * the name.\n *\n * For example, if we have a file named bar.js containing the following exports:\n *\n *   const o2 = 'bar';\n *   export { o2 };\n *\n * And a file named foo.js containing the following import:\n *\n *   import { o2 } from './bar.js';\n *\n * Then we will have a structure that looks like:\n *\n *   Map { 'bar.js' => Map { 'o2' => { whereUsed: Set { 'foo.js' } } } }\n *\n * @type {Map<string, Map<string, object>>}\n */\nconst exportList = new Map();\n\nconst visitorKeyMap = new Map();\n\n/** @type {Set<string>} */\nconst ignoredFiles = new Set();\nconst filesOutsideSrc = new Set();\n\nconst isNodeModule = (path) => (/\\/(node_modules)\\//).test(path);\n\n/**\n * read all files matching the patterns in src and ignoreExports\n *\n * return all files matching src pattern, which are not matching the ignoreExports pattern\n * @type {(src: string, ignoreExports: string, context: import('eslint').Rule.RuleContext) => Set<string>}\n */\nfunction resolveFiles(src, ignoreExports, context) {\n  const extensions = Array.from(getFileExtensions(context.settings));\n\n  const srcFileList = listFilesToProcess(src, extensions, context);\n\n  // prepare list of ignored files\n  const ignoredFilesList = listFilesToProcess(ignoreExports, extensions, context);\n\n  // The modern api will return a list of file paths, rather than an object\n  if (ignoredFilesList.length && typeof ignoredFilesList[0] === 'string') {\n    ignoredFilesList.forEach((filename) => ignoredFiles.add(filename));\n  } else {\n    ignoredFilesList.forEach(({ filename }) => ignoredFiles.add(filename));\n  }\n\n  // prepare list of source files, don't consider files from node_modules\n  const resolvedFiles = srcFileList.length && typeof srcFileList[0] === 'string'\n    ? srcFileList.filter((filePath) => !isNodeModule(filePath))\n    : flatMap(srcFileList, ({ filename }) => isNodeModule(filename) ? [] : filename);\n\n  return new Set(resolvedFiles);\n}\n\n/**\n * parse all source files and build up 2 maps containing the existing imports and exports\n */\nconst prepareImportsAndExports = (srcFiles, context) => {\n  const exportAll = new Map();\n  srcFiles.forEach((file) => {\n    const exports = new Map();\n    const imports = new Map();\n    const currentExports = ExportMapBuilder.get(file, context);\n    if (currentExports) {\n      const {\n        dependencies,\n        reexports,\n        imports: localImportList,\n        namespace,\n        visitorKeys,\n      } = currentExports;\n\n      visitorKeyMap.set(file, visitorKeys);\n      // dependencies === export * from\n      const currentExportAll = new Set();\n      dependencies.forEach((getDependency) => {\n        const dependency = getDependency();\n        if (dependency === null) {\n          return;\n        }\n\n        currentExportAll.add(dependency.path);\n      });\n      exportAll.set(file, currentExportAll);\n\n      reexports.forEach((value, key) => {\n        if (key === DEFAULT) {\n          exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed: new Set() });\n        } else {\n          exports.set(key, { whereUsed: new Set() });\n        }\n        const reexport = value.getImport();\n        if (!reexport) {\n          return;\n        }\n        let localImport = imports.get(reexport.path);\n        let currentValue;\n        if (value.local === DEFAULT) {\n          currentValue = IMPORT_DEFAULT_SPECIFIER;\n        } else {\n          currentValue = value.local;\n        }\n        if (typeof localImport !== 'undefined') {\n          localImport = new Set([...localImport, currentValue]);\n        } else {\n          localImport = new Set([currentValue]);\n        }\n        imports.set(reexport.path, localImport);\n      });\n\n      localImportList.forEach((value, key) => {\n        if (isNodeModule(key)) {\n          return;\n        }\n        const localImport = imports.get(key) || new Set();\n        value.declarations.forEach(({ importedSpecifiers }) => {\n          importedSpecifiers.forEach((specifier) => {\n            localImport.add(specifier);\n          });\n        });\n        imports.set(key, localImport);\n      });\n      importList.set(file, imports);\n\n      // build up export list only, if file is not ignored\n      if (ignoredFiles.has(file)) {\n        return;\n      }\n      namespace.forEach((value, key) => {\n        if (key === DEFAULT) {\n          exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed: new Set() });\n        } else {\n          exports.set(key, { whereUsed: new Set() });\n        }\n      });\n    }\n    exports.set(EXPORT_ALL_DECLARATION, { whereUsed: new Set() });\n    exports.set(IMPORT_NAMESPACE_SPECIFIER, { whereUsed: new Set() });\n    exportList.set(file, exports);\n  });\n  exportAll.forEach((value, key) => {\n    value.forEach((val) => {\n      const currentExports = exportList.get(val);\n      if (currentExports) {\n        const currentExport = currentExports.get(EXPORT_ALL_DECLARATION);\n        currentExport.whereUsed.add(key);\n      }\n    });\n  });\n};\n\n/**\n * traverse through all imports and add the respective path to the whereUsed-list\n * of the corresponding export\n */\nconst determineUsage = () => {\n  importList.forEach((listValue, listKey) => {\n    listValue.forEach((value, key) => {\n      const exports = exportList.get(key);\n      if (typeof exports !== 'undefined') {\n        value.forEach((currentImport) => {\n          let specifier;\n          if (currentImport === IMPORT_NAMESPACE_SPECIFIER) {\n            specifier = IMPORT_NAMESPACE_SPECIFIER;\n          } else if (currentImport === IMPORT_DEFAULT_SPECIFIER) {\n            specifier = IMPORT_DEFAULT_SPECIFIER;\n          } else {\n            specifier = currentImport;\n          }\n          if (typeof specifier !== 'undefined') {\n            const exportStatement = exports.get(specifier);\n            if (typeof exportStatement !== 'undefined') {\n              const { whereUsed } = exportStatement;\n              whereUsed.add(listKey);\n              exports.set(specifier, { whereUsed });\n            }\n          }\n        });\n      }\n    });\n  });\n};\n\nconst getSrc = (src) => {\n  if (src) {\n    return src;\n  }\n  return [process.cwd()];\n};\n\n/**\n * prepare the lists of existing imports and exports - should only be executed once at\n * the start of a new eslint run\n */\n/** @type {Set<string>} */\nlet srcFiles;\nlet lastPrepareKey;\nconst doPreparation = (src, ignoreExports, context) => {\n  const prepareKey = JSON.stringify({\n    src: (src || []).sort(),\n    ignoreExports: (ignoreExports || []).sort(),\n    extensions: Array.from(getFileExtensions(context.settings)).sort(),\n  });\n  if (prepareKey === lastPrepareKey) {\n    return;\n  }\n\n  importList.clear();\n  exportList.clear();\n  ignoredFiles.clear();\n  filesOutsideSrc.clear();\n\n  srcFiles = resolveFiles(getSrc(src), ignoreExports, context);\n  prepareImportsAndExports(srcFiles, context);\n  determineUsage();\n  lastPrepareKey = prepareKey;\n};\n\nconst newNamespaceImportExists = (specifiers) => specifiers.some(({ type }) => type === IMPORT_NAMESPACE_SPECIFIER);\n\nconst newDefaultImportExists = (specifiers) => specifiers.some(({ type }) => type === IMPORT_DEFAULT_SPECIFIER);\n\nconst fileIsInPkg = (file) => {\n  const { path, pkg } = readPkgUp({ cwd: file });\n  const basePath = dirname(path);\n\n  const checkPkgFieldString = (pkgField) => {\n    if (join(basePath, pkgField) === file) {\n      return true;\n    }\n  };\n\n  const checkPkgFieldObject = (pkgField) => {\n    const pkgFieldFiles = flatMap(values(pkgField), (value) => typeof value === 'boolean' ? [] : join(basePath, value));\n\n    if (includes(pkgFieldFiles, file)) {\n      return true;\n    }\n  };\n\n  const checkPkgField = (pkgField) => {\n    if (typeof pkgField === 'string') {\n      return checkPkgFieldString(pkgField);\n    }\n\n    if (typeof pkgField === 'object') {\n      return checkPkgFieldObject(pkgField);\n    }\n  };\n\n  if (pkg.private === true) {\n    return false;\n  }\n\n  if (pkg.bin) {\n    if (checkPkgField(pkg.bin)) {\n      return true;\n    }\n  }\n\n  if (pkg.browser) {\n    if (checkPkgField(pkg.browser)) {\n      return true;\n    }\n  }\n\n  if (pkg.main) {\n    if (checkPkgFieldString(pkg.main)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Helpful warnings',\n      description: 'Forbid modules without exports, or exports without matching import in another module.',\n      url: docsUrl('no-unused-modules'),\n    },\n    schema: [{\n      properties: {\n        src: {\n          description: 'files/paths to be analyzed (only for unused exports)',\n          type: 'array',\n          uniqueItems: true,\n          items: {\n            type: 'string',\n            minLength: 1,\n          },\n        },\n        ignoreExports: {\n          description: 'files/paths for which unused exports will not be reported (e.g module entry points)',\n          type: 'array',\n          uniqueItems: true,\n          items: {\n            type: 'string',\n            minLength: 1,\n          },\n        },\n        missingExports: {\n          description: 'report modules without any exports',\n          type: 'boolean',\n        },\n        unusedExports: {\n          description: 'report exports without any usage',\n          type: 'boolean',\n        },\n        ignoreUnusedTypeExports: {\n          description: 'ignore type exports without any usage',\n          type: 'boolean',\n        },\n      },\n      anyOf: [\n        {\n          properties: {\n            unusedExports: { enum: [true] },\n            src: {\n              minItems: 1,\n            },\n          },\n          required: ['unusedExports'],\n        },\n        {\n          properties: {\n            missingExports: { enum: [true] },\n          },\n          required: ['missingExports'],\n        },\n      ],\n    }],\n  },\n\n  create(context) {\n    const {\n      src,\n      ignoreExports = [],\n      missingExports,\n      unusedExports,\n      ignoreUnusedTypeExports,\n    } = context.options[0] || {};\n\n    if (unusedExports) {\n      doPreparation(src, ignoreExports, context);\n    }\n\n    const file = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();\n\n    const checkExportPresence = (node) => {\n      if (!missingExports) {\n        return;\n      }\n\n      if (ignoredFiles.has(file)) {\n        return;\n      }\n\n      const exportCount = exportList.get(file);\n      const exportAll = exportCount.get(EXPORT_ALL_DECLARATION);\n      const namespaceImports = exportCount.get(IMPORT_NAMESPACE_SPECIFIER);\n\n      exportCount.delete(EXPORT_ALL_DECLARATION);\n      exportCount.delete(IMPORT_NAMESPACE_SPECIFIER);\n      if (exportCount.size < 1) {\n        // node.body[0] === 'undefined' only happens, if everything is commented out in the file\n        // being linted\n        context.report(node.body[0] ? node.body[0] : node, 'No exports found');\n      }\n      exportCount.set(EXPORT_ALL_DECLARATION, exportAll);\n      exportCount.set(IMPORT_NAMESPACE_SPECIFIER, namespaceImports);\n    };\n\n    const checkUsage = (node, exportedValue, isTypeExport) => {\n      if (!unusedExports) {\n        return;\n      }\n\n      if (isTypeExport && ignoreUnusedTypeExports) {\n        return;\n      }\n\n      if (ignoredFiles.has(file)) {\n        return;\n      }\n\n      if (fileIsInPkg(file)) {\n        return;\n      }\n\n      if (filesOutsideSrc.has(file)) {\n        return;\n      }\n\n      // make sure file to be linted is included in source files\n      if (!srcFiles.has(file)) {\n        srcFiles = resolveFiles(getSrc(src), ignoreExports, context);\n        if (!srcFiles.has(file)) {\n          filesOutsideSrc.add(file);\n          return;\n        }\n      }\n\n      exports = exportList.get(file);\n\n      if (!exports) {\n        console.error(`file \\`${file}\\` has no exports. Please update to the latest, and if it still happens, report this on https://github.com/import-js/eslint-plugin-import/issues/2866!`);\n      }\n\n      // special case: export * from\n      const exportAll = exports.get(EXPORT_ALL_DECLARATION);\n      if (typeof exportAll !== 'undefined' && exportedValue !== IMPORT_DEFAULT_SPECIFIER) {\n        if (exportAll.whereUsed.size > 0) {\n          return;\n        }\n      }\n\n      // special case: namespace import\n      const namespaceImports = exports.get(IMPORT_NAMESPACE_SPECIFIER);\n      if (typeof namespaceImports !== 'undefined') {\n        if (namespaceImports.whereUsed.size > 0) {\n          return;\n        }\n      }\n\n      // exportsList will always map any imported value of 'default' to 'ImportDefaultSpecifier'\n      const exportsKey = exportedValue === DEFAULT ? IMPORT_DEFAULT_SPECIFIER : exportedValue;\n\n      const exportStatement = exports.get(exportsKey);\n\n      const value = exportsKey === IMPORT_DEFAULT_SPECIFIER ? DEFAULT : exportsKey;\n\n      if (typeof exportStatement !== 'undefined') {\n        if (exportStatement.whereUsed.size < 1) {\n          context.report(\n            node,\n            `exported declaration '${value}' not used within other modules`,\n          );\n        }\n      } else {\n        context.report(\n          node,\n          `exported declaration '${value}' not used within other modules`,\n        );\n      }\n    };\n\n    /**\n     * only useful for tools like vscode-eslint\n     *\n     * update lists of existing exports during runtime\n     */\n    const updateExportUsage = (node) => {\n      if (ignoredFiles.has(file)) {\n        return;\n      }\n\n      let exports = exportList.get(file);\n\n      // new module has been created during runtime\n      // include it in further processing\n      if (typeof exports === 'undefined') {\n        exports = new Map();\n      }\n\n      const newExports = new Map();\n      const newExportIdentifiers = new Set();\n\n      node.body.forEach(({ type, declaration, specifiers }) => {\n        if (type === EXPORT_DEFAULT_DECLARATION) {\n          newExportIdentifiers.add(IMPORT_DEFAULT_SPECIFIER);\n        }\n        if (type === EXPORT_NAMED_DECLARATION) {\n          if (specifiers.length > 0) {\n            specifiers.forEach((specifier) => {\n              if (specifier.exported) {\n                newExportIdentifiers.add(specifier.exported.name || specifier.exported.value);\n              }\n            });\n          }\n          forEachDeclarationIdentifier(declaration, (name) => {\n            newExportIdentifiers.add(name);\n          });\n        }\n      });\n\n      // old exports exist within list of new exports identifiers: add to map of new exports\n      exports.forEach((value, key) => {\n        if (newExportIdentifiers.has(key)) {\n          newExports.set(key, value);\n        }\n      });\n\n      // new export identifiers added: add to map of new exports\n      newExportIdentifiers.forEach((key) => {\n        if (!exports.has(key)) {\n          newExports.set(key, { whereUsed: new Set() });\n        }\n      });\n\n      // preserve information about namespace imports\n      const exportAll = exports.get(EXPORT_ALL_DECLARATION);\n      let namespaceImports = exports.get(IMPORT_NAMESPACE_SPECIFIER);\n\n      if (typeof namespaceImports === 'undefined') {\n        namespaceImports = { whereUsed: new Set() };\n      }\n\n      newExports.set(EXPORT_ALL_DECLARATION, exportAll);\n      newExports.set(IMPORT_NAMESPACE_SPECIFIER, namespaceImports);\n      exportList.set(file, newExports);\n    };\n\n    /**\n     * only useful for tools like vscode-eslint\n     *\n     * update lists of existing imports during runtime\n     */\n    const updateImportUsage = (node) => {\n      if (!unusedExports) {\n        return;\n      }\n\n      let oldImportPaths = importList.get(file);\n      if (typeof oldImportPaths === 'undefined') {\n        oldImportPaths = new Map();\n      }\n\n      const oldNamespaceImports = new Set();\n      const newNamespaceImports = new Set();\n\n      const oldExportAll = new Set();\n      const newExportAll = new Set();\n\n      const oldDefaultImports = new Set();\n      const newDefaultImports = new Set();\n\n      const oldImports = new Map();\n      const newImports = new Map();\n      oldImportPaths.forEach((value, key) => {\n        if (value.has(EXPORT_ALL_DECLARATION)) {\n          oldExportAll.add(key);\n        }\n        if (value.has(IMPORT_NAMESPACE_SPECIFIER)) {\n          oldNamespaceImports.add(key);\n        }\n        if (value.has(IMPORT_DEFAULT_SPECIFIER)) {\n          oldDefaultImports.add(key);\n        }\n        value.forEach((val) => {\n          if (\n            val !== IMPORT_NAMESPACE_SPECIFIER\n            && val !== IMPORT_DEFAULT_SPECIFIER\n          ) {\n            oldImports.set(val, key);\n          }\n        });\n      });\n\n      function processDynamicImport(source) {\n        if (source.type !== 'Literal') {\n          return null;\n        }\n        const p = resolve(source.value, context);\n        if (p == null) {\n          return null;\n        }\n        newNamespaceImports.add(p);\n      }\n\n      visit(node, visitorKeyMap.get(file), {\n        ImportExpression(child) {\n          processDynamicImport(child.source);\n        },\n        CallExpression(child) {\n          if (child.callee.type === 'Import') {\n            processDynamicImport(child.arguments[0]);\n          }\n        },\n      });\n\n      node.body.forEach((astNode) => {\n        let resolvedPath;\n\n        // support for export { value } from 'module'\n        if (astNode.type === EXPORT_NAMED_DECLARATION) {\n          if (astNode.source) {\n            resolvedPath = resolve(astNode.source.raw.replace(/('|\")/g, ''), context);\n            astNode.specifiers.forEach((specifier) => {\n              const name = specifier.local.name || specifier.local.value;\n              if (name === DEFAULT) {\n                newDefaultImports.add(resolvedPath);\n              } else {\n                newImports.set(name, resolvedPath);\n              }\n            });\n          }\n        }\n\n        if (astNode.type === EXPORT_ALL_DECLARATION) {\n          resolvedPath = resolve(astNode.source.raw.replace(/('|\")/g, ''), context);\n          newExportAll.add(resolvedPath);\n        }\n\n        if (astNode.type === IMPORT_DECLARATION) {\n          resolvedPath = resolve(astNode.source.raw.replace(/('|\")/g, ''), context);\n          if (!resolvedPath) {\n            return;\n          }\n\n          if (isNodeModule(resolvedPath)) {\n            return;\n          }\n\n          if (newNamespaceImportExists(astNode.specifiers)) {\n            newNamespaceImports.add(resolvedPath);\n          }\n\n          if (newDefaultImportExists(astNode.specifiers)) {\n            newDefaultImports.add(resolvedPath);\n          }\n\n          astNode.specifiers\n            .filter((specifier) => specifier.type !== IMPORT_DEFAULT_SPECIFIER && specifier.type !== IMPORT_NAMESPACE_SPECIFIER)\n            .forEach((specifier) => {\n              newImports.set(specifier.imported.name || specifier.imported.value, resolvedPath);\n            });\n        }\n      });\n\n      newExportAll.forEach((value) => {\n        if (!oldExportAll.has(value)) {\n          let imports = oldImportPaths.get(value);\n          if (typeof imports === 'undefined') {\n            imports = new Set();\n          }\n          imports.add(EXPORT_ALL_DECLARATION);\n          oldImportPaths.set(value, imports);\n\n          let exports = exportList.get(value);\n          let currentExport;\n          if (typeof exports !== 'undefined') {\n            currentExport = exports.get(EXPORT_ALL_DECLARATION);\n          } else {\n            exports = new Map();\n            exportList.set(value, exports);\n          }\n\n          if (typeof currentExport !== 'undefined') {\n            currentExport.whereUsed.add(file);\n          } else {\n            const whereUsed = new Set();\n            whereUsed.add(file);\n            exports.set(EXPORT_ALL_DECLARATION, { whereUsed });\n          }\n        }\n      });\n\n      oldExportAll.forEach((value) => {\n        if (!newExportAll.has(value)) {\n          const imports = oldImportPaths.get(value);\n          imports.delete(EXPORT_ALL_DECLARATION);\n\n          const exports = exportList.get(value);\n          if (typeof exports !== 'undefined') {\n            const currentExport = exports.get(EXPORT_ALL_DECLARATION);\n            if (typeof currentExport !== 'undefined') {\n              currentExport.whereUsed.delete(file);\n            }\n          }\n        }\n      });\n\n      newDefaultImports.forEach((value) => {\n        if (!oldDefaultImports.has(value)) {\n          let imports = oldImportPaths.get(value);\n          if (typeof imports === 'undefined') {\n            imports = new Set();\n          }\n          imports.add(IMPORT_DEFAULT_SPECIFIER);\n          oldImportPaths.set(value, imports);\n\n          let exports = exportList.get(value);\n          let currentExport;\n          if (typeof exports !== 'undefined') {\n            currentExport = exports.get(IMPORT_DEFAULT_SPECIFIER);\n          } else {\n            exports = new Map();\n            exportList.set(value, exports);\n          }\n\n          if (typeof currentExport !== 'undefined') {\n            currentExport.whereUsed.add(file);\n          } else {\n            const whereUsed = new Set();\n            whereUsed.add(file);\n            exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed });\n          }\n        }\n      });\n\n      oldDefaultImports.forEach((value) => {\n        if (!newDefaultImports.has(value)) {\n          const imports = oldImportPaths.get(value);\n          imports.delete(IMPORT_DEFAULT_SPECIFIER);\n\n          const exports = exportList.get(value);\n          if (typeof exports !== 'undefined') {\n            const currentExport = exports.get(IMPORT_DEFAULT_SPECIFIER);\n            if (typeof currentExport !== 'undefined') {\n              currentExport.whereUsed.delete(file);\n            }\n          }\n        }\n      });\n\n      newNamespaceImports.forEach((value) => {\n        if (!oldNamespaceImports.has(value)) {\n          let imports = oldImportPaths.get(value);\n          if (typeof imports === 'undefined') {\n            imports = new Set();\n          }\n          imports.add(IMPORT_NAMESPACE_SPECIFIER);\n          oldImportPaths.set(value, imports);\n\n          let exports = exportList.get(value);\n          let currentExport;\n          if (typeof exports !== 'undefined') {\n            currentExport = exports.get(IMPORT_NAMESPACE_SPECIFIER);\n          } else {\n            exports = new Map();\n            exportList.set(value, exports);\n          }\n\n          if (typeof currentExport !== 'undefined') {\n            currentExport.whereUsed.add(file);\n          } else {\n            const whereUsed = new Set();\n            whereUsed.add(file);\n            exports.set(IMPORT_NAMESPACE_SPECIFIER, { whereUsed });\n          }\n        }\n      });\n\n      oldNamespaceImports.forEach((value) => {\n        if (!newNamespaceImports.has(value)) {\n          const imports = oldImportPaths.get(value);\n          imports.delete(IMPORT_NAMESPACE_SPECIFIER);\n\n          const exports = exportList.get(value);\n          if (typeof exports !== 'undefined') {\n            const currentExport = exports.get(IMPORT_NAMESPACE_SPECIFIER);\n            if (typeof currentExport !== 'undefined') {\n              currentExport.whereUsed.delete(file);\n            }\n          }\n        }\n      });\n\n      newImports.forEach((value, key) => {\n        if (!oldImports.has(key)) {\n          let imports = oldImportPaths.get(value);\n          if (typeof imports === 'undefined') {\n            imports = new Set();\n          }\n          imports.add(key);\n          oldImportPaths.set(value, imports);\n\n          let exports = exportList.get(value);\n          let currentExport;\n          if (typeof exports !== 'undefined') {\n            currentExport = exports.get(key);\n          } else {\n            exports = new Map();\n            exportList.set(value, exports);\n          }\n\n          if (typeof currentExport !== 'undefined') {\n            currentExport.whereUsed.add(file);\n          } else {\n            const whereUsed = new Set();\n            whereUsed.add(file);\n            exports.set(key, { whereUsed });\n          }\n        }\n      });\n\n      oldImports.forEach((value, key) => {\n        if (!newImports.has(key)) {\n          const imports = oldImportPaths.get(value);\n          imports.delete(key);\n\n          const exports = exportList.get(value);\n          if (typeof exports !== 'undefined') {\n            const currentExport = exports.get(key);\n            if (typeof currentExport !== 'undefined') {\n              currentExport.whereUsed.delete(file);\n            }\n          }\n        }\n      });\n    };\n\n    return {\n      'Program:exit'(node) {\n        updateExportUsage(node);\n        updateImportUsage(node);\n        checkExportPresence(node);\n      },\n      ExportDefaultDeclaration(node) {\n        checkUsage(node, IMPORT_DEFAULT_SPECIFIER, false);\n      },\n      ExportNamedDeclaration(node) {\n        node.specifiers.forEach((specifier) => {\n          checkUsage(specifier, specifier.exported.name || specifier.exported.value, false);\n        });\n        forEachDeclarationIdentifier(node.declaration, (name, isTypeExport) => {\n          checkUsage(node, name, isTypeExport);\n        });\n      },\n    };\n  },\n};\n"]}