tools_auto_web/node_modules/eslint-plugin-import/lib/rules/no-unused-modules.js

'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 _contextCompat = require('eslint-module-utils/contextCompat');
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 _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;
}

/**
   * Given a FileEnumerator class, instantiate and load the list of files.
   * @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) {
  // We need to know whether this is being run with flat config in order to
  // determine how to report errors if FileEnumerator throws due to a lack of eslintrc.
  var
  ESLINT_USE_FLAT_CONFIG = process.env.ESLINT_USE_FLAT_CONFIG;

  // This condition is sufficient to test in v8, since the environment variable is necessary to turn on flat config
  var isUsingFlatConfig = ESLINT_USE_FLAT_CONFIG && process.env.ESLINT_USE_FLAT_CONFIG !== 'false';

  // In the case of using v9, we can check the `shouldUseFlatConfig` function
  // If this function is present, then we assume it's v9
  try {var _require3 =
    require('eslint/use-at-your-own-risk'),shouldUseFlatConfig = _require3.shouldUseFlatConfig;
    isUsingFlatConfig = shouldUseFlatConfig && ESLINT_USE_FLAT_CONFIG !== 'false';
  } catch (_) {
    // We don't want to throw here, since we only want to update the
    // boolean if the function is available.
  }

  var enumerator = new FileEnumerator({
    extensions: extensions });


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

  } catch (e) {
    // If we're using flat config, and FileEnumerator throws due to a lack of eslintrc,
    // then we want to throw an error so that the user knows about this rule's reliance on
    // the legacy config.
    if (
    isUsingFlatConfig &&
    e.message.includes('No ESLint configuration found'))
    {
      throw new Error('\nDue to the exclusion of certain internal ESLint APIs when using flat config,\nthe import/no-unused-modules rule requires an .eslintrc file to know which\nfiles to ignore (even when using flat config).\nThe .eslintrc file only needs to contain "ignorePatterns", or can be empty if\nyou do not want to ignore any files.\n\nSee https://github.com/import-js/eslint-plugin-import/issues/3079\nfor additional context.\n');









    }
    // If this isn't the case, then we'll just let the error bubble up
    throw e;
  }
}

/**
   * 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 _require4 = require('eslint/lib/util/glob-utils'),originalListFilesToProcess = _require4.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 _require5 =

    require('eslint/lib/util/glob-util'),_originalListFilesToProcess = _require5.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 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
   * @returns {string[] | { filename: string, ignored: boolean }[]} the list of files that this rule will evaluate.
   */
function listFilesToProcess(src, extensions) {
  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);

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

  // 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 = (0, _contextCompat.getPhysicalFilename)(context);

      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","ESLINT_USE_FLAT_CONFIG","process","env","isUsingFlatConfig","shouldUseFlatConfig","_","enumerator","Array","from","iterateFiles","filePath","ignored","filename","message","includes","Error","listFilesWithLegacyFunctions","originalListFilesToProcess","listFilesToProcess","patterns","concat","pattern","map","extension","test","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","path","resolveFiles","ignoreExports","context","settings","srcFileList","ignoredFilesList","length","add","resolvedFiles","filter","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","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","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 { getPhysicalFilename } from 'eslint-module-utils/contextCompat';\nimport { getFileExtensions } from 'eslint-module-utils/ignore';\nimport resolve from 'eslint-module-utils/resolve';\nimport visit from 'eslint-module-utils/visit';\nimport { dirname, join } 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 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 * Given a FileEnumerator class, instantiate and load the list of files.\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  // We need to know whether this is being run with flat config in order to\n  // determine how to report errors if FileEnumerator throws due to a lack of eslintrc.\n\n  const { ESLINT_USE_FLAT_CONFIG } = process.env;\n\n  // This condition is sufficient to test in v8, since the environment variable is necessary to turn on flat config\n  let isUsingFlatConfig = ESLINT_USE_FLAT_CONFIG && process.env.ESLINT_USE_FLAT_CONFIG !== 'false';\n\n  // In the case of using v9, we can check the `shouldUseFlatConfig` function\n  // If this function is present, then we assume it's v9\n  try {\n    const { shouldUseFlatConfig } = require('eslint/use-at-your-own-risk');\n    isUsingFlatConfig = shouldUseFlatConfig && ESLINT_USE_FLAT_CONFIG !== 'false';\n  } catch (_) {\n    // We don't want to throw here, since we only want to update the\n    // boolean if the function is available.\n  }\n\n  const enumerator = new FileEnumerator({\n    extensions,\n  });\n\n  try {\n    return Array.from(\n      enumerator.iterateFiles(src),\n      ({ filePath, ignored }) => ({ filename: filePath, ignored }),\n    );\n  } catch (e) {\n    // If we're using flat config, and FileEnumerator throws due to a lack of eslintrc,\n    // then we want to throw an error so that the user knows about this rule's reliance on\n    // the legacy config.\n    if (\n      isUsingFlatConfig\n      && e.message.includes('No ESLint configuration found')\n    ) {\n      throw new Error(`\nDue to the exclusion of certain internal ESLint APIs when using flat config,\nthe import/no-unused-modules rule requires an .eslintrc file to know which\nfiles to ignore (even when using flat config).\nThe .eslintrc file only needs to contain \"ignorePatterns\", or can be empty if\nyou do not want to ignore any files.\n\nSee https://github.com/import-js/eslint-plugin-import/issues/3079\nfor additional context.\n`);\n    }\n    // If this isn't the case, then we'll just let the error bubble up\n    throw e;\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 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 * @returns {string[] | { filename: string, ignored: boolean }[]} the list of files that this rule will evaluate.\n */\nfunction listFilesToProcess(src, extensions) {\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);\n\n  // prepare list of ignored files\n  const ignoredFilesList = listFilesToProcess(ignoreExports, extensions);\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 = getPhysicalFilename(context);\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"]}