create-packer 1.34.4 → 1.34.6

package/template/lib/react/node_modules/eslint-plugin-import/lib/ExportMap.js

@@ -0,0 +1,856 @@
+'use strict';Object.defineProperty(exports, "__esModule", { value: true });var _createClass = function () {function defineProperties(target, props) {for (var i = 0; i < props.length; i++) {var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);}}return function (Constructor, protoProps, staticProps) {if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;};}();exports.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+recursivePatternCapture = recursivePatternCapture;var _fs = require('fs');var _fs2 = _interopRequireDefault(_fs);var _path = require('path');var _doctrine = require('doctrine');var _doctrine2 = _interopRequireDefault(_doctrine);var _debug = require('debug');var _debug2 = _interopRequireDefault(_debug);var _eslint = require('eslint');var _parse = require('eslint-module-utils/parse');var _parse2 = _interopRequireDefault(_parse);var _visit = require('eslint-module-utils/visit');var _visit2 = _interopRequireDefault(_visit);var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve);var _ignore = require('eslint-module-utils/ignore');var _ignore2 = _interopRequireDefault(_ignore);var _hash = require('eslint-module-utils/hash');var _unambiguous = require('eslint-module-utils/unambiguous');var unambiguous = _interopRequireWildcard(_unambiguous);var _tsconfigLoader = require('tsconfig-paths/lib/tsconfig-loader');var _arrayIncludes = require('array-includes');var _arrayIncludes2 = _interopRequireDefault(_arrayIncludes);function _interopRequireWildcard(obj) {if (obj && obj.__esModule) {return obj;} else {var newObj = {};if (obj != null) {for (var key in obj) {if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];}}newObj['default'] = obj;return newObj;}}function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function _classCallCheck(instance, Constructor) {if (!(instance instanceof Constructor)) {throw new TypeError("Cannot call a class as a function");}}var ts = void 0;var log = (0, _debug2['default'])('eslint-plugin-import:ExportMap');var exportCache = new Map();var tsconfigCache = new Map();var ExportMap = function () {function ExportMap(path) {_classCallCheck(this, ExportMap);this.path = path;this.namespace = new Map(); // todo: restructure to key on path, value is resolver + map of names
+    this.reexports = new Map(); /**
+                                 * star-exports
+                                 * @type {Set} of () => ExportMap
+                                 */this.dependencies = new Set(); /**
+                                                                   * dependencies of this module that are not explicitly re-exported
+                                                                   * @type {Map} from path = () => ExportMap
+                                                                   */this.imports = new Map();this.errors = []; /**
+                                                                                                                 * type {'ambiguous' | 'Module' | 'Script'}
+                                                                                                                 */this.parseGoal = 'ambiguous';}_createClass(ExportMap, [{ key: 'has', /**
+                                                                                                                                                                                         * Note that this does not check explicitly re-exported names for existence
+                                                                                                                                                                                         * in the base namespace, but it will expand all `export * from '...'` exports
+                                                                                                                                                                                         * if not found in the explicit namespace.
+                                                                                                                                                                                         * @param  {string}  name
+                                                                                                                                                                                         * @return {Boolean} true if `name` is exported by this module.
+                                                                                                                                                                                         */value: function () {function has(name) {if (this.namespace.has(name)) {return true;}if (this.reexports.has(name)) {return true;} // default exports must be explicitly re-exported (#328)
+        if (name !== 'default') {var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try {for (var _iterator = this.dependencies[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {var dep = _step.value;var innerMap = dep(); // todo: report as unresolved?
+              if (!innerMap) {continue;}if (innerMap.has(name)) {return true;}}} catch (err) {_didIteratorError = true;_iteratorError = err;} finally {try {if (!_iteratorNormalCompletion && _iterator['return']) {_iterator['return']();}} finally {if (_didIteratorError) {throw _iteratorError;}}}}return false;}return has;}() /**
+                                                                                                                                                                                                                                                                                                                                     * ensure that imported name fully resolves.
+                                                                                                                                                                                                                                                                                                                                     * @param  {string} name
+                                                                                                                                                                                                                                                                                                                                     * @return {{ found: boolean, path: ExportMap[] }}
+                                                                                                                                                                                                                                                                                                                                     */ }, { key: 'hasDeep', value: function () {function hasDeep(name) {if (this.namespace.has(name)) {return { found: true, path: [this] };}if (this.reexports.has(name)) {var reexports = this.reexports.get(name);var imported = reexports.getImport(); // if import is ignored, return explicit 'null'
+          if (imported == null) {return { found: true, path: [this] };} // safeguard against cycles, only if name matches
+          if (imported.path === this.path && reexports.local === name) {return { found: false, path: [this] };}var deep = imported.hasDeep(reexports.local);deep.path.unshift(this);return deep;} // default exports must be explicitly re-exported (#328)
+        if (name !== 'default') {var _iteratorNormalCompletion2 = true;var _didIteratorError2 = false;var _iteratorError2 = undefined;try {for (var _iterator2 = this.dependencies[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {var dep = _step2.value;var innerMap = dep();if (innerMap == null) {return { found: true, path: [this] };} // todo: report as unresolved?
+              if (!innerMap) {continue;} // safeguard against cycles
+              if (innerMap.path === this.path) {continue;}var innerValue = innerMap.hasDeep(name);if (innerValue.found) {innerValue.path.unshift(this);return innerValue;}}} catch (err) {_didIteratorError2 = true;_iteratorError2 = err;} finally {try {if (!_iteratorNormalCompletion2 && _iterator2['return']) {_iterator2['return']();}} finally {if (_didIteratorError2) {throw _iteratorError2;}}}}return { found: false, path: [this] };}return hasDeep;}() }, { key: 'get', value: function () {function get(name) {if (this.namespace.has(name)) {return this.namespace.get(name);}if (this.reexports.has(name)) {var reexports = this.reexports.get(name);var imported = reexports.getImport(); // if import is ignored, return explicit 'null'
+          if (imported == null) {return null;} // safeguard against cycles, only if name matches
+          if (imported.path === this.path && reexports.local === name) {return undefined;}return imported.get(reexports.local);} // default exports must be explicitly re-exported (#328)
+        if (name !== 'default') {var _iteratorNormalCompletion3 = true;var _didIteratorError3 = false;var _iteratorError3 = undefined;try {for (var _iterator3 = this.dependencies[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {var dep = _step3.value;var innerMap = dep(); // todo: report as unresolved?
+              if (!innerMap) {continue;} // safeguard against cycles
+              if (innerMap.path === this.path) {continue;}var innerValue = innerMap.get(name);if (innerValue !== undefined) {return innerValue;}}} catch (err) {_didIteratorError3 = true;_iteratorError3 = err;} finally {try {if (!_iteratorNormalCompletion3 && _iterator3['return']) {_iterator3['return']();}} finally {if (_didIteratorError3) {throw _iteratorError3;}}}}return undefined;}return get;}() }, { key: 'forEach', value: function () {function forEach(callback, thisArg) {var _this = this;this.namespace.forEach(function (v, n) {callback.call(thisArg, v, n, _this);});this.reexports.forEach(function (reexports, name) {var reexported = reexports.getImport(); // can't look up meta for ignored re-exports (#348)
+          callback.call(thisArg, reexported && reexported.get(reexports.local), name, _this);});this.dependencies.forEach(function (dep) {var d = dep(); // CJS / ignored dependencies won't exist (#717)
+          if (d == null) {return;}d.forEach(function (v, n) {if (n !== 'default') {callback.call(thisArg, v, n, _this);}});});}return forEach;}() // todo: keys, values, entries?
+  }, { key: 'reportErrors', value: function () {function reportErrors(context, declaration) {var msg = this.errors.map(function (e) {return String(e.message) + ' (' + String(e.lineNumber) + ':' + String(e.column) + ')';}).join(', ');context.report({ node: declaration.source, message: 'Parse errors in imported module \'' + String(declaration.source.value) + '\': ' + String(msg) });}return reportErrors;}() }, { key: 'hasDefault', get: function () {function get() {return this.get('default') != null;}return get;}() // stronger than this.has
+  }, { key: 'size', get: function () {function get() {var size = this.namespace.size + this.reexports.size;this.dependencies.forEach(function (dep) {var d = dep(); // CJS / ignored dependencies won't exist (#717)
+          if (d == null) {return;}size += d.size;});return size;}return get;}() }]);return ExportMap;}(); /**
+                                                                                                           * parse docs from the first node that has leading comments
+                                                                                                           */exports['default'] = ExportMap;function captureDoc(source, docStyleParsers) {var metadata = {}; // 'some' short-circuits on first 'true'
+  for (var _len = arguments.length, nodes = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {nodes[_key - 2] = arguments[_key];}nodes.some(function (n) {try {var leadingComments = void 0; // n.leadingComments is legacy `attachComments` behavior
+      if ('leadingComments' in n) {leadingComments = n.leadingComments;} else if (n.range) {leadingComments = source.getCommentsBefore(n);}if (!leadingComments || leadingComments.length === 0) {return false;}for (var name in docStyleParsers) {var doc = docStyleParsers[name](leadingComments);if (doc) {metadata.doc = doc;}}return true;} catch (err) {return false;}});return metadata;}var availableDocStyleParsers = { jsdoc: captureJsDoc, tomdoc: captureTomDoc }; /**
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * parse JSDoc from leading comments
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * @param {object[]} comments
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * @return {{ doc: object }}
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */function captureJsDoc(comments) {var doc = void 0; // capture XSDoc
+  comments.forEach(function (comment) {// skip non-block comments
+    if (comment.type !== 'Block') {return;}try {doc = _doctrine2['default'].parse(comment.value, { unwrap: true });} catch (err) {/* don't care, for now? maybe add to `errors?` */}});return doc;} /**
+                                                                                                                                                                                                      * parse TomDoc section from comments
+                                                                                                                                                                                                      */function captureTomDoc(comments) {// collect lines up to first paragraph break
+  var lines = [];for (var i = 0; i < comments.length; i++) {var comment = comments[i];if (comment.value.match(/^\s*$/)) {break;}lines.push(comment.value.trim());} // return doctrine-like object
+  var statusMatch = lines.join(' ').match(/^(Public|Internal|Deprecated):\s*(.+)/);if (statusMatch) {return { description: statusMatch[2], tags: [{ title: statusMatch[1].toLowerCase(), description: statusMatch[2] }] };}}var supportedImportTypes = new Set(['ImportDefaultSpecifier', 'ImportNamespaceSpecifier']);ExportMap.get = function (source, context) {var path = (0, _resolve2['default'])(source, context);if (path == null) {return null;}return ExportMap['for'](childContext(path, context));};ExportMap['for'] = function (context) {var path = context.path;var cacheKey = context.cacheKey || (0, _hash.hashObject)(context).digest('hex');var exportMap = exportCache.get(cacheKey); // return cached ignore
+  if (exportMap === null) {return null;}var stats = _fs2['default'].statSync(path);if (exportMap != null) {// date equality check
+    if (exportMap.mtime - stats.mtime === 0) {return exportMap;} // future: check content equality?
+  } // check valid extensions first
+  if (!(0, _ignore.hasValidExtension)(path, context)) {exportCache.set(cacheKey, null);return null;} // check for and cache ignore
+  if ((0, _ignore2['default'])(path, context)) {log('ignored path due to ignore settings:', path);exportCache.set(cacheKey, null);return null;}var content = _fs2['default'].readFileSync(path, { encoding: 'utf8' }); // check for and cache unambiguous modules
+  if (!unambiguous.test(content)) {log('ignored path due to unambiguous regex:', path);exportCache.set(cacheKey, null);return null;}log('cache miss', cacheKey, 'for path', path);exportMap = ExportMap.parse(path, content, context); // ambiguous modules return null
+  if (exportMap == null) {log('ignored path due to ambiguous parse:', path);exportCache.set(cacheKey, null);return null;}exportMap.mtime = stats.mtime;exportCache.set(cacheKey, exportMap);return exportMap;};ExportMap.parse = function (path, content, context) {var m = new ExportMap(path);var isEsModuleInteropTrue = isEsModuleInterop();var ast = void 0;var visitorKeys = void 0;try {var result = (0, _parse2['default'])(path, content, context);ast = result.ast;visitorKeys = result.visitorKeys;} catch (err) {m.errors.push(err);return m; // can't continue
+  }m.visitorKeys = visitorKeys;var hasDynamicImports = false;function processDynamicImport(source) {hasDynamicImports = true;if (source.type !== 'Literal') {return null;}var p = remotePath(source.value);if (p == null) {return null;}var importedSpecifiers = new Set();importedSpecifiers.add('ImportNamespaceSpecifier');var getter = thunkFor(p, context);m.imports.set(p, { getter: getter, declarations: new Set([{ source: { // capturing actual node reference holds full AST in memory!
+          value: source.value, loc: source.loc }, importedSpecifiers: importedSpecifiers, dynamic: true }]) });}(0, _visit2['default'])(ast, visitorKeys, { ImportExpression: function () {function ImportExpression(node) {processDynamicImport(node.source);}return ImportExpression;}(), CallExpression: function () {function CallExpression(node) {if (node.callee.type === 'Import') {processDynamicImport(node.arguments[0]);}}return CallExpression;}() });var unambiguouslyESM = unambiguous.isModule(ast);if (!unambiguouslyESM && !hasDynamicImports) {return null;}var docstyle = context.settings && context.settings['import/docstyle'] || ['jsdoc'];var docStyleParsers = {};docstyle.forEach(function (style) {docStyleParsers[style] = availableDocStyleParsers[style];}); // attempt to collect module doc
+  if (ast.comments) {ast.comments.some(function (c) {if (c.type !== 'Block') {return false;}try {var doc = _doctrine2['default'].parse(c.value, { unwrap: true });if (doc.tags.some(function (t) {return t.title === 'module';})) {m.doc = doc;return true;}} catch (err) {/* ignore */}return false;});}var namespaces = new Map();function remotePath(value) {return _resolve2['default'].relative(value, path, context.settings);}function resolveImport(value) {var rp = remotePath(value);if (rp == null) {return null;}return ExportMap['for'](childContext(rp, context));}function getNamespace(identifier) {if (!namespaces.has(identifier.name)) {return;}return function () {return resolveImport(namespaces.get(identifier.name));};}function addNamespace(object, identifier) {var nsfn = getNamespace(identifier);if (nsfn) {Object.defineProperty(object, 'namespace', { get: nsfn });}return object;}function processSpecifier(s, n, m) {var nsource = n.source && n.source.value;var exportMeta = {};var local = void 0;switch (s.type) {case 'ExportDefaultSpecifier':if (!nsource) {return;}local = 'default';break;case 'ExportNamespaceSpecifier':m.namespace.set(s.exported.name, Object.defineProperty(exportMeta, 'namespace', { get: function () {function get() {return resolveImport(nsource);}return get;}() }));return;case 'ExportAllDeclaration':m.namespace.set(s.exported.name || s.exported.value, addNamespace(exportMeta, s.source.value));return;case 'ExportSpecifier':if (!n.source) {m.namespace.set(s.exported.name || s.exported.value, addNamespace(exportMeta, s.local));return;} // else falls through
+      default:local = s.local.name;break;} // todo: JSDoc
+    m.reexports.set(s.exported.name, { local: local, getImport: function () {function getImport() {return resolveImport(nsource);}return getImport;}() });}function captureDependencyWithSpecifiers(n) {// import type { Foo } (TS and Flow); import typeof { Foo } (Flow)
+    var declarationIsType = n.importKind === 'type' || n.importKind === 'typeof'; // import './foo' or import {} from './foo' (both 0 specifiers) is a side effect and
+    // shouldn't be considered to be just importing types
+    var specifiersOnlyImportingTypes = n.specifiers.length > 0;var importedSpecifiers = new Set();n.specifiers.forEach(function (specifier) {if (specifier.type === 'ImportSpecifier') {importedSpecifiers.add(specifier.imported.name || specifier.imported.value);} else if (supportedImportTypes.has(specifier.type)) {importedSpecifiers.add(specifier.type);} // import { type Foo } (Flow); import { typeof Foo } (Flow)
+      specifiersOnlyImportingTypes = specifiersOnlyImportingTypes && (specifier.importKind === 'type' || specifier.importKind === 'typeof');});captureDependency(n, declarationIsType || specifiersOnlyImportingTypes, importedSpecifiers);}function captureDependency(_ref, isOnlyImportingTypes) {var source = _ref.source;var importedSpecifiers = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Set();if (source == null) {return null;}var p = remotePath(source.value);if (p == null) {return null;}var declarationMetadata = { // capturing actual node reference holds full AST in memory!
+      source: { value: source.value, loc: source.loc }, isOnlyImportingTypes: isOnlyImportingTypes, importedSpecifiers: importedSpecifiers };var existing = m.imports.get(p);if (existing != null) {existing.declarations.add(declarationMetadata);return existing.getter;}var getter = thunkFor(p, context);m.imports.set(p, { getter: getter, declarations: new Set([declarationMetadata]) });return getter;}var source = makeSourceCode(content, ast);function readTsConfig(context) {var tsconfigInfo = (0, _tsconfigLoader.tsConfigLoader)({ cwd: context.parserOptions && context.parserOptions.tsconfigRootDir || process.cwd(), getEnv: function () {function getEnv(key) {return process.env[key];}return getEnv;}() });try {if (tsconfigInfo.tsConfigPath !== undefined) {// Projects not using TypeScript won't have `typescript` installed.
+        if (!ts) {ts = require('typescript');} // eslint-disable-line import/no-extraneous-dependencies
+        var configFile = ts.readConfigFile(tsconfigInfo.tsConfigPath, ts.sys.readFile);return ts.parseJsonConfigFileContent(configFile.config, ts.sys, (0, _path.dirname)(tsconfigInfo.tsConfigPath));}} catch (e) {// Catch any errors
+    }return null;}function isEsModuleInterop() {var cacheKey = (0, _hash.hashObject)({ tsconfigRootDir: context.parserOptions && context.parserOptions.tsconfigRootDir }).digest('hex');var tsConfig = tsconfigCache.get(cacheKey);if (typeof tsConfig === 'undefined') {tsConfig = readTsConfig(context);tsconfigCache.set(cacheKey, tsConfig);}return tsConfig && tsConfig.options ? tsConfig.options.esModuleInterop : false;}ast.body.forEach(function (n) {if (n.type === 'ExportDefaultDeclaration') {var exportMeta = captureDoc(source, docStyleParsers, n);if (n.declaration.type === 'Identifier') {addNamespace(exportMeta, n.declaration);}m.namespace.set('default', exportMeta);return;}if (n.type === 'ExportAllDeclaration') {var getter = captureDependency(n, n.exportKind === 'type');if (getter) {m.dependencies.add(getter);}if (n.exported) {processSpecifier(n, n.exported, m);}return;} // capture namespaces in case of later export
+    if (n.type === 'ImportDeclaration') {captureDependencyWithSpecifiers(n);var ns = n.specifiers.find(function (s) {return s.type === 'ImportNamespaceSpecifier';});if (ns) {namespaces.set(ns.local.name, n.source.value);}return;}if (n.type === 'ExportNamedDeclaration') {captureDependencyWithSpecifiers(n); // capture declaration
+      if (n.declaration != null) {switch (n.declaration.type) {case 'FunctionDeclaration':case 'ClassDeclaration':case 'TypeAlias': // flowtype with babel-eslint parser
+          case 'InterfaceDeclaration':case 'DeclareFunction':case 'TSDeclareFunction':case 'TSEnumDeclaration':case 'TSTypeAliasDeclaration':case 'TSInterfaceDeclaration':case 'TSAbstractClassDeclaration':case 'TSModuleDeclaration':m.namespace.set(n.declaration.id.name, captureDoc(source, docStyleParsers, n));break;case 'VariableDeclaration':n.declaration.declarations.forEach(function (d) {recursivePatternCapture(d.id, function (id) {return m.namespace.set(id.name, captureDoc(source, docStyleParsers, d, n));});});break;default:}}n.specifiers.forEach(function (s) {return processSpecifier(s, n, m);});}var exports = ['TSExportAssignment'];if (isEsModuleInteropTrue) {exports.push('TSNamespaceExportDeclaration');} // This doesn't declare anything, but changes what's being exported.
+    if ((0, _arrayIncludes2['default'])(exports, n.type)) {var exportedName = n.type === 'TSNamespaceExportDeclaration' ? (n.id || n.name).name : n.expression && n.expression.name || n.expression.id && n.expression.id.name || null;var declTypes = ['VariableDeclaration', 'ClassDeclaration', 'TSDeclareFunction', 'TSEnumDeclaration', 'TSTypeAliasDeclaration', 'TSInterfaceDeclaration', 'TSAbstractClassDeclaration', 'TSModuleDeclaration'];var exportedDecls = ast.body.filter(function (_ref2) {var type = _ref2.type,id = _ref2.id,declarations = _ref2.declarations;return (0, _arrayIncludes2['default'])(declTypes, type) && (id && id.name === exportedName || declarations && declarations.find(function (d) {return d.id.name === exportedName;}));});if (exportedDecls.length === 0) {// Export is not referencing any local declaration, must be re-exporting
+        m.namespace.set('default', captureDoc(source, docStyleParsers, n));return;}if (isEsModuleInteropTrue // esModuleInterop is on in tsconfig
+      && !m.namespace.has('default') // and default isn't added already
+      ) {m.namespace.set('default', {}); // add default export
+        }exportedDecls.forEach(function (decl) {if (decl.type === 'TSModuleDeclaration') {if (decl.body && decl.body.type === 'TSModuleDeclaration') {m.namespace.set(decl.body.id.name, captureDoc(source, docStyleParsers, decl.body));} else if (decl.body && decl.body.body) {decl.body.body.forEach(function (moduleBlockNode) {// Export-assignment exports all members in the namespace,
+              // explicitly exported or not.
+              var namespaceDecl = moduleBlockNode.type === 'ExportNamedDeclaration' ? moduleBlockNode.declaration : moduleBlockNode;if (!namespaceDecl) {// TypeScript can check this for us; we needn't
+              } else if (namespaceDecl.type === 'VariableDeclaration') {namespaceDecl.declarations.forEach(function (d) {return recursivePatternCapture(d.id, function (id) {return m.namespace.set(id.name, captureDoc(source, docStyleParsers, decl, namespaceDecl, moduleBlockNode));});});} else {m.namespace.set(namespaceDecl.id.name, captureDoc(source, docStyleParsers, moduleBlockNode));}});}} else {// Export as default
+          m.namespace.set('default', captureDoc(source, docStyleParsers, decl));}});}});if (isEsModuleInteropTrue // esModuleInterop is on in tsconfig
+  && m.namespace.size > 0 // anything is exported
+  && !m.namespace.has('default') // and default isn't added already
+  ) {m.namespace.set('default', {}); // add default export
+    }if (unambiguouslyESM) {m.parseGoal = 'Module';}return m;}; /**
+                                                                 * The creation of this closure is isolated from other scopes
+                                                                 * to avoid over-retention of unrelated variables, which has
+                                                                 * caused memory leaks. See #1266.
+                                                                 */function thunkFor(p, context) {return function () {return ExportMap['for'](childContext(p, context));};} /**
+                                                                                                                                                                             * Traverse a pattern/identifier node, calling 'callback'
+                                                                                                                                                                             * for each leaf identifier.
+                                                                                                                                                                             * @param  {node}   pattern
+                                                                                                                                                                             * @param  {Function} callback
+                                                                                                                                                                             * @return {void}
+                                                                                                                                                                             */function recursivePatternCapture(pattern, callback) {switch (pattern.type) {case 'Identifier': // base case
+      callback(pattern);break;case 'ObjectPattern':pattern.properties.forEach(function (p) {if (p.type === 'ExperimentalRestProperty' || p.type === 'RestElement') {callback(p.argument);return;}recursivePatternCapture(p.value, callback);});break;case 'ArrayPattern':pattern.elements.forEach(function (element) {if (element == null) {return;}if (element.type === 'ExperimentalRestProperty' || element.type === 'RestElement') {callback(element.argument);return;}recursivePatternCapture(element, callback);});break;case 'AssignmentPattern':callback(pattern.left);break;default:}}var parserOptionsHash = '';var prevParserOptions = '';var settingsHash = '';var prevSettings = ''; /**
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   * don't hold full context object in memory, just grab what we need.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   * also calculate a cacheKey, where parts of the cacheKey hash are memoized
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   */function childContext(path, context) {var settings = context.settings,parserOptions = context.parserOptions,parserPath = context.parserPath;if (JSON.stringify(settings) !== prevSettings) {settingsHash = (0, _hash.hashObject)({ settings: settings }).digest('hex');prevSettings = JSON.stringify(settings);}if (JSON.stringify(parserOptions) !== prevParserOptions) {parserOptionsHash = (0, _hash.hashObject)({ parserOptions: parserOptions }).digest('hex');prevParserOptions = JSON.stringify(parserOptions);}return { cacheKey: String(parserPath) + parserOptionsHash + settingsHash + String(path), settings: settings, parserOptions: parserOptions, parserPath: parserPath, path: path };} /**
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               * sometimes legacy support isn't _that_ hard... right?
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               */function makeSourceCode(text, ast) {if (_eslint.SourceCode.length > 1) {// ESLint 3
+    return new _eslint.SourceCode(text, ast);} else {// ESLint 4, 5
+    return new _eslint.SourceCode({ text: text, ast: ast });}}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ExportMap.js"],"names":["recursivePatternCapture","unambiguous","ts","log","exportCache","Map","tsconfigCache","ExportMap","path","namespace","reexports","dependencies","Set","imports","errors","parseGoal","name","has","dep","innerMap","found","get","imported","getImport","local","deep","hasDeep","unshift","innerValue","undefined","callback","thisArg","forEach","v","n","call","reexported","d","context","declaration","msg","map","e","message","lineNumber","column","join","report","node","source","value","size","captureDoc","docStyleParsers","metadata","nodes","some","leadingComments","range","getCommentsBefore","length","doc","err","availableDocStyleParsers","jsdoc","captureJsDoc","tomdoc","captureTomDoc","comments","comment","type","doctrine","parse","unwrap","lines","i","match","push","trim","statusMatch","description","tags","title","toLowerCase","supportedImportTypes","childContext","cacheKey","digest","exportMap","stats","fs","statSync","mtime","set","content","readFileSync","encoding","test","m","isEsModuleInteropTrue","isEsModuleInterop","ast","visitorKeys","result","hasDynamicImports","processDynamicImport","p","remotePath","importedSpecifiers","add","getter","thunkFor","declarations","loc","dynamic","ImportExpression","CallExpression","callee","arguments","unambiguouslyESM","isModule","docstyle","settings","style","c","t","namespaces","resolve","relative","resolveImport","rp","getNamespace","identifier","addNamespace","object","nsfn","Object","defineProperty","processSpecifier","s","nsource","exportMeta","exported","captureDependencyWithSpecifiers","declarationIsType","importKind","specifiersOnlyImportingTypes","specifiers","specifier","captureDependency","isOnlyImportingTypes","declarationMetadata","existing","makeSourceCode","readTsConfig","tsconfigInfo","cwd","parserOptions","tsconfigRootDir","process","getEnv","key","env","tsConfigPath","require","configFile","readConfigFile","sys","readFile","parseJsonConfigFileContent","config","tsConfig","options","esModuleInterop","body","exportKind","ns","find","id","exports","exportedName","expression","declTypes","exportedDecls","filter","decl","moduleBlockNode","namespaceDecl","pattern","properties","argument","elements","element","left","parserOptionsHash","prevParserOptions","settingsHash","prevSettings","parserPath","JSON","stringify","String","text","SourceCode"],"mappings":"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","file":"ExportMap.js","sourcesContent":["import fs from 'fs';\nimport { dirname } from 'path';\n\nimport doctrine from 'doctrine';\n\nimport debug from 'debug';\n\nimport { SourceCode } from 'eslint';\n\nimport parse from 'eslint-module-utils/parse';\nimport visit from 'eslint-module-utils/visit';\nimport resolve from 'eslint-module-utils/resolve';\nimport isIgnored, { hasValidExtension } from 'eslint-module-utils/ignore';\n\nimport { hashObject } from 'eslint-module-utils/hash';\nimport * as unambiguous from 'eslint-module-utils/unambiguous';\n\nimport { tsConfigLoader } from 'tsconfig-paths/lib/tsconfig-loader';\n\nimport includes from 'array-includes';\n\nlet ts;\n\nconst log = debug('eslint-plugin-import:ExportMap');\n\nconst exportCache = new Map();\nconst tsconfigCache = new Map();\n\nexport default class ExportMap {\n  constructor(path) {\n    this.path = path;\n    this.namespace = new Map();\n    // todo: restructure to key on path, value is resolver + map of names\n    this.reexports = new Map();\n    /**\n     * star-exports\n     * @type {Set} of () => ExportMap\n     */\n    this.dependencies = new Set();\n    /**\n     * dependencies of this module that are not explicitly re-exported\n     * @type {Map} from path = () => ExportMap\n     */\n    this.imports = new Map();\n    this.errors = [];\n    /**\n     * type {'ambiguous' | 'Module' | 'Script'}\n     */\n    this.parseGoal = 'ambiguous';\n  }\n\n  get hasDefault() { return this.get('default') != null; } // stronger than this.has\n\n  get size() {\n    let size = this.namespace.size + this.reexports.size;\n    this.dependencies.forEach((dep) => {\n      const d = dep();\n      // CJS / ignored dependencies won't exist (#717)\n      if (d == null) { return; }\n      size += d.size;\n    });\n    return size;\n  }\n\n  /**\n   * Note that this does not check explicitly re-exported names for existence\n   * in the base namespace, but it will expand all `export * from '...'` exports\n   * if not found in the explicit namespace.\n   * @param  {string}  name\n   * @return {Boolean} true if `name` is exported by this module.\n   */\n  has(name) {\n    if (this.namespace.has(name)) { return true; }\n    if (this.reexports.has(name)) { return true; }\n\n    // default exports must be explicitly re-exported (#328)\n    if (name !== 'default') {\n      for (const dep of this.dependencies) {\n        const innerMap = dep();\n\n        // todo: report as unresolved?\n        if (!innerMap) { continue; }\n\n        if (innerMap.has(name)) { return true; }\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * ensure that imported name fully resolves.\n   * @param  {string} name\n   * @return {{ found: boolean, path: ExportMap[] }}\n   */\n  hasDeep(name) {\n    if (this.namespace.has(name)) { return { found: true, path: [this] }; }\n\n    if (this.reexports.has(name)) {\n      const reexports = this.reexports.get(name);\n      const imported = reexports.getImport();\n\n      // if import is ignored, return explicit 'null'\n      if (imported == null) { return { found: true, path: [this] }; }\n\n      // safeguard against cycles, only if name matches\n      if (imported.path === this.path && reexports.local === name) {\n        return { found: false, path: [this] };\n      }\n\n      const deep = imported.hasDeep(reexports.local);\n      deep.path.unshift(this);\n\n      return deep;\n    }\n\n    // default exports must be explicitly re-exported (#328)\n    if (name !== 'default') {\n      for (const dep of this.dependencies) {\n        const innerMap = dep();\n        if (innerMap == null) { return { found: true, path: [this] }; }\n        // todo: report as unresolved?\n        if (!innerMap) { continue; }\n\n        // safeguard against cycles\n        if (innerMap.path === this.path) { continue; }\n\n        const innerValue = innerMap.hasDeep(name);\n        if (innerValue.found) {\n          innerValue.path.unshift(this);\n          return innerValue;\n        }\n      }\n    }\n\n    return { found: false, path: [this] };\n  }\n\n  get(name) {\n    if (this.namespace.has(name)) { return this.namespace.get(name); }\n\n    if (this.reexports.has(name)) {\n      const reexports = this.reexports.get(name);\n      const imported = reexports.getImport();\n\n      // if import is ignored, return explicit 'null'\n      if (imported == null) { return null; }\n\n      // safeguard against cycles, only if name matches\n      if (imported.path === this.path && reexports.local === name) { return undefined; }\n\n      return imported.get(reexports.local);\n    }\n\n    // default exports must be explicitly re-exported (#328)\n    if (name !== 'default') {\n      for (const dep of this.dependencies) {\n        const innerMap = dep();\n        // todo: report as unresolved?\n        if (!innerMap) { continue; }\n\n        // safeguard against cycles\n        if (innerMap.path === this.path) { continue; }\n\n        const innerValue = innerMap.get(name);\n        if (innerValue !== undefined) { return innerValue; }\n      }\n    }\n\n    return undefined;\n  }\n\n  forEach(callback, thisArg) {\n    this.namespace.forEach((v, n) => { callback.call(thisArg, v, n, this); });\n\n    this.reexports.forEach((reexports, name) => {\n      const reexported = reexports.getImport();\n      // can't look up meta for ignored re-exports (#348)\n      callback.call(thisArg, reexported && reexported.get(reexports.local), name, this);\n    });\n\n    this.dependencies.forEach((dep) => {\n      const d = dep();\n      // CJS / ignored dependencies won't exist (#717)\n      if (d == null) { return; }\n\n      d.forEach((v, n) => {\n        if (n !== 'default') {\n          callback.call(thisArg, v, n, this);\n        }\n      });\n    });\n  }\n\n  // todo: keys, values, entries?\n\n  reportErrors(context, declaration) {\n    const msg = this.errors\n      .map((e) => `${e.message} (${e.lineNumber}:${e.column})`)\n      .join(', ');\n    context.report({\n      node: declaration.source,\n      message: `Parse errors in imported module '${declaration.source.value}': ${msg}`,\n    });\n  }\n}\n\n/**\n * parse docs from the first node that has leading comments\n */\nfunction captureDoc(source, docStyleParsers, ...nodes) {\n  const metadata = {};\n\n  // 'some' short-circuits on first 'true'\n  nodes.some((n) => {\n    try {\n\n      let leadingComments;\n\n      // n.leadingComments is legacy `attachComments` behavior\n      if ('leadingComments' in n) {\n        leadingComments = n.leadingComments;\n      } else if (n.range) {\n        leadingComments = source.getCommentsBefore(n);\n      }\n\n      if (!leadingComments || leadingComments.length === 0) { return false; }\n\n      for (const name in docStyleParsers) {\n        const doc = docStyleParsers[name](leadingComments);\n        if (doc) {\n          metadata.doc = doc;\n        }\n      }\n\n      return true;\n    } catch (err) {\n      return false;\n    }\n  });\n\n  return metadata;\n}\n\nconst availableDocStyleParsers = {\n  jsdoc: captureJsDoc,\n  tomdoc: captureTomDoc,\n};\n\n/**\n * parse JSDoc from leading comments\n * @param {object[]} comments\n * @return {{ doc: object }}\n */\nfunction captureJsDoc(comments) {\n  let doc;\n\n  // capture XSDoc\n  comments.forEach((comment) => {\n    // skip non-block comments\n    if (comment.type !== 'Block') { return; }\n    try {\n      doc = doctrine.parse(comment.value, { unwrap: true });\n    } catch (err) {\n      /* don't care, for now? maybe add to `errors?` */\n    }\n  });\n\n  return doc;\n}\n\n/**\n  * parse TomDoc section from comments\n  */\nfunction captureTomDoc(comments) {\n  // collect lines up to first paragraph break\n  const lines = [];\n  for (let i = 0; i < comments.length; i++) {\n    const comment = comments[i];\n    if (comment.value.match(/^\\s*$/)) { break; }\n    lines.push(comment.value.trim());\n  }\n\n  // return doctrine-like object\n  const statusMatch = lines.join(' ').match(/^(Public|Internal|Deprecated):\\s*(.+)/);\n  if (statusMatch) {\n    return {\n      description: statusMatch[2],\n      tags: [{\n        title: statusMatch[1].toLowerCase(),\n        description: statusMatch[2],\n      }],\n    };\n  }\n}\n\nconst supportedImportTypes = new Set(['ImportDefaultSpecifier', 'ImportNamespaceSpecifier']);\n\nExportMap.get = function (source, context) {\n  const path = resolve(source, context);\n  if (path == null) { return null; }\n\n  return ExportMap.for(childContext(path, context));\n};\n\nExportMap.for = function (context) {\n  const { path } = context;\n\n  const cacheKey = context.cacheKey || hashObject(context).digest('hex');\n  let exportMap = exportCache.get(cacheKey);\n\n  // return cached ignore\n  if (exportMap === null) { return null; }\n\n  const stats = fs.statSync(path);\n  if (exportMap != null) {\n    // date equality check\n    if (exportMap.mtime - stats.mtime === 0) {\n      return exportMap;\n    }\n    // future: check content equality?\n  }\n\n  // check valid extensions first\n  if (!hasValidExtension(path, context)) {\n    exportCache.set(cacheKey, null);\n    return null;\n  }\n\n  // check for and cache ignore\n  if (isIgnored(path, context)) {\n    log('ignored path due to ignore settings:', path);\n    exportCache.set(cacheKey, null);\n    return null;\n  }\n\n  const content = fs.readFileSync(path, { encoding: 'utf8' });\n\n  // check for and cache unambiguous modules\n  if (!unambiguous.test(content)) {\n    log('ignored path due to unambiguous regex:', path);\n    exportCache.set(cacheKey, null);\n    return null;\n  }\n\n  log('cache miss', cacheKey, 'for path', path);\n  exportMap = ExportMap.parse(path, content, context);\n\n  // ambiguous modules return null\n  if (exportMap == null) {\n    log('ignored path due to ambiguous parse:', path);\n    exportCache.set(cacheKey, null);\n    return null;\n  }\n\n  exportMap.mtime = stats.mtime;\n\n  exportCache.set(cacheKey, exportMap);\n  return exportMap;\n};\n\nExportMap.parse = function (path, content, context) {\n  const m = new ExportMap(path);\n  const isEsModuleInteropTrue = isEsModuleInterop();\n\n  let ast;\n  let visitorKeys;\n  try {\n    const result = parse(path, content, context);\n    ast = result.ast;\n    visitorKeys = result.visitorKeys;\n  } catch (err) {\n    m.errors.push(err);\n    return m; // can't continue\n  }\n\n  m.visitorKeys = visitorKeys;\n\n  let hasDynamicImports = false;\n\n  function processDynamicImport(source) {\n    hasDynamicImports = true;\n    if (source.type !== 'Literal') {\n      return null;\n    }\n    const p = remotePath(source.value);\n    if (p == null) {\n      return null;\n    }\n    const importedSpecifiers = new Set();\n    importedSpecifiers.add('ImportNamespaceSpecifier');\n    const getter = thunkFor(p, context);\n    m.imports.set(p, {\n      getter,\n      declarations: new Set([{\n        source: {\n        // capturing actual node reference holds full AST in memory!\n          value: source.value,\n          loc: source.loc,\n        },\n        importedSpecifiers,\n        dynamic: true,\n      }]),\n    });\n  }\n\n  visit(ast, visitorKeys, {\n    ImportExpression(node) {\n      processDynamicImport(node.source);\n    },\n    CallExpression(node) {\n      if (node.callee.type === 'Import') {\n        processDynamicImport(node.arguments[0]);\n      }\n    },\n  });\n\n  const unambiguouslyESM = unambiguous.isModule(ast);\n  if (!unambiguouslyESM && !hasDynamicImports) { return null; }\n\n  const docstyle = context.settings && context.settings['import/docstyle'] || ['jsdoc'];\n  const docStyleParsers = {};\n  docstyle.forEach((style) => {\n    docStyleParsers[style] = availableDocStyleParsers[style];\n  });\n\n  // attempt to collect module doc\n  if (ast.comments) {\n    ast.comments.some((c) => {\n      if (c.type !== 'Block') { return false; }\n      try {\n        const doc = doctrine.parse(c.value, { unwrap: true });\n        if (doc.tags.some((t) => t.title === 'module')) {\n          m.doc = doc;\n          return true;\n        }\n      } catch (err) { /* ignore */ }\n      return false;\n    });\n  }\n\n  const namespaces = new Map();\n\n  function remotePath(value) {\n    return resolve.relative(value, path, context.settings);\n  }\n\n  function resolveImport(value) {\n    const rp = remotePath(value);\n    if (rp == null) { return null; }\n    return ExportMap.for(childContext(rp, context));\n  }\n\n  function getNamespace(identifier) {\n    if (!namespaces.has(identifier.name)) { return; }\n\n    return function () {\n      return resolveImport(namespaces.get(identifier.name));\n    };\n  }\n\n  function addNamespace(object, identifier) {\n    const nsfn = getNamespace(identifier);\n    if (nsfn) {\n      Object.defineProperty(object, 'namespace', { get: nsfn });\n    }\n\n    return object;\n  }\n\n  function processSpecifier(s, n, m) {\n    const nsource = n.source && n.source.value;\n    const exportMeta = {};\n    let local;\n\n    switch (s.type) {\n      case 'ExportDefaultSpecifier':\n        if (!nsource) { return; }\n        local = 'default';\n        break;\n      case 'ExportNamespaceSpecifier':\n        m.namespace.set(s.exported.name, Object.defineProperty(exportMeta, 'namespace', {\n          get() { return resolveImport(nsource); },\n        }));\n        return;\n      case 'ExportAllDeclaration':\n        m.namespace.set(s.exported.name || s.exported.value, addNamespace(exportMeta, s.source.value));\n        return;\n      case 'ExportSpecifier':\n        if (!n.source) {\n          m.namespace.set(s.exported.name || s.exported.value, addNamespace(exportMeta, s.local));\n          return;\n        }\n      // else falls through\n      default:\n        local = s.local.name;\n        break;\n    }\n\n    // todo: JSDoc\n    m.reexports.set(s.exported.name, { local, getImport: () => resolveImport(nsource) });\n  }\n\n  function captureDependencyWithSpecifiers(n) {\n    // import type { Foo } (TS and Flow); import typeof { Foo } (Flow)\n    const declarationIsType = n.importKind === 'type' || n.importKind === 'typeof';\n    // import './foo' or import {} from './foo' (both 0 specifiers) is a side effect and\n    // shouldn't be considered to be just importing types\n    let specifiersOnlyImportingTypes = n.specifiers.length > 0;\n    const importedSpecifiers = new Set();\n    n.specifiers.forEach((specifier) => {\n      if (specifier.type === 'ImportSpecifier') {\n        importedSpecifiers.add(specifier.imported.name || specifier.imported.value);\n      } else if (supportedImportTypes.has(specifier.type)) {\n        importedSpecifiers.add(specifier.type);\n      }\n\n      // import { type Foo } (Flow); import { typeof Foo } (Flow)\n      specifiersOnlyImportingTypes = specifiersOnlyImportingTypes\n        && (specifier.importKind === 'type' || specifier.importKind === 'typeof');\n    });\n    captureDependency(n, declarationIsType || specifiersOnlyImportingTypes, importedSpecifiers);\n  }\n\n  function captureDependency({ source }, isOnlyImportingTypes, importedSpecifiers = new Set()) {\n    if (source == null) { return null; }\n\n    const p = remotePath(source.value);\n    if (p == null) { return null; }\n\n    const declarationMetadata = {\n      // capturing actual node reference holds full AST in memory!\n      source: { value: source.value, loc: source.loc },\n      isOnlyImportingTypes,\n      importedSpecifiers,\n    };\n\n    const existing = m.imports.get(p);\n    if (existing != null) {\n      existing.declarations.add(declarationMetadata);\n      return existing.getter;\n    }\n\n    const getter = thunkFor(p, context);\n    m.imports.set(p, { getter, declarations: new Set([declarationMetadata]) });\n    return getter;\n  }\n\n  const source = makeSourceCode(content, ast);\n\n  function readTsConfig(context) {\n    const tsconfigInfo = tsConfigLoader({\n      cwd: context.parserOptions && context.parserOptions.tsconfigRootDir || process.cwd(),\n      getEnv: (key) => process.env[key],\n    });\n    try {\n      if (tsconfigInfo.tsConfigPath !== undefined) {\n        // Projects not using TypeScript won't have `typescript` installed.\n        if (!ts) { ts = require('typescript'); } // eslint-disable-line import/no-extraneous-dependencies\n\n        const configFile = ts.readConfigFile(tsconfigInfo.tsConfigPath, ts.sys.readFile);\n        return ts.parseJsonConfigFileContent(\n          configFile.config,\n          ts.sys,\n          dirname(tsconfigInfo.tsConfigPath),\n        );\n      }\n    } catch (e) {\n      // Catch any errors\n    }\n\n    return null;\n  }\n\n  function isEsModuleInterop() {\n    const cacheKey = hashObject({\n      tsconfigRootDir: context.parserOptions && context.parserOptions.tsconfigRootDir,\n    }).digest('hex');\n    let tsConfig = tsconfigCache.get(cacheKey);\n    if (typeof tsConfig === 'undefined') {\n      tsConfig = readTsConfig(context);\n      tsconfigCache.set(cacheKey, tsConfig);\n    }\n\n    return tsConfig && tsConfig.options ? tsConfig.options.esModuleInterop : false;\n  }\n\n  ast.body.forEach(function (n) {\n    if (n.type === 'ExportDefaultDeclaration') {\n      const exportMeta = captureDoc(source, docStyleParsers, n);\n      if (n.declaration.type === 'Identifier') {\n        addNamespace(exportMeta, n.declaration);\n      }\n      m.namespace.set('default', exportMeta);\n      return;\n    }\n\n    if (n.type === 'ExportAllDeclaration') {\n      const getter = captureDependency(n, n.exportKind === 'type');\n      if (getter) { m.dependencies.add(getter); }\n      if (n.exported) {\n        processSpecifier(n, n.exported, m);\n      }\n      return;\n    }\n\n    // capture namespaces in case of later export\n    if (n.type === 'ImportDeclaration') {\n      captureDependencyWithSpecifiers(n);\n\n      const ns = n.specifiers.find((s) => s.type === 'ImportNamespaceSpecifier');\n      if (ns) {\n        namespaces.set(ns.local.name, n.source.value);\n      }\n      return;\n    }\n\n    if (n.type === 'ExportNamedDeclaration') {\n      captureDependencyWithSpecifiers(n);\n\n      // capture declaration\n      if (n.declaration != null) {\n        switch (n.declaration.type) {\n          case 'FunctionDeclaration':\n          case 'ClassDeclaration':\n          case 'TypeAlias': // flowtype with babel-eslint parser\n          case 'InterfaceDeclaration':\n          case 'DeclareFunction':\n          case 'TSDeclareFunction':\n          case 'TSEnumDeclaration':\n          case 'TSTypeAliasDeclaration':\n          case 'TSInterfaceDeclaration':\n          case 'TSAbstractClassDeclaration':\n          case 'TSModuleDeclaration':\n            m.namespace.set(n.declaration.id.name, captureDoc(source, docStyleParsers, n));\n            break;\n          case 'VariableDeclaration':\n            n.declaration.declarations.forEach((d) => {\n              recursivePatternCapture(\n                d.id,\n                (id) => m.namespace.set(id.name, captureDoc(source, docStyleParsers, d, n)),\n              );\n            });\n            break;\n          default:\n        }\n      }\n\n      n.specifiers.forEach((s) => processSpecifier(s, n, m));\n    }\n\n    const exports = ['TSExportAssignment'];\n    if (isEsModuleInteropTrue) {\n      exports.push('TSNamespaceExportDeclaration');\n    }\n\n    // This doesn't declare anything, but changes what's being exported.\n    if (includes(exports, n.type)) {\n      const exportedName = n.type === 'TSNamespaceExportDeclaration'\n        ? (n.id || n.name).name\n        : n.expression && n.expression.name || n.expression.id && n.expression.id.name || null;\n      const declTypes = [\n        'VariableDeclaration',\n        'ClassDeclaration',\n        'TSDeclareFunction',\n        'TSEnumDeclaration',\n        'TSTypeAliasDeclaration',\n        'TSInterfaceDeclaration',\n        'TSAbstractClassDeclaration',\n        'TSModuleDeclaration',\n      ];\n      const exportedDecls = ast.body.filter(({ type, id, declarations }) => includes(declTypes, type) && (\n        id && id.name === exportedName || declarations && declarations.find((d) => d.id.name === exportedName)\n      ));\n      if (exportedDecls.length === 0) {\n        // Export is not referencing any local declaration, must be re-exporting\n        m.namespace.set('default', captureDoc(source, docStyleParsers, n));\n        return;\n      }\n      if (\n        isEsModuleInteropTrue // esModuleInterop is on in tsconfig\n        && !m.namespace.has('default') // and default isn't added already\n      ) {\n        m.namespace.set('default', {}); // add default export\n      }\n      exportedDecls.forEach((decl) => {\n        if (decl.type === 'TSModuleDeclaration') {\n          if (decl.body && decl.body.type === 'TSModuleDeclaration') {\n            m.namespace.set(decl.body.id.name, captureDoc(source, docStyleParsers, decl.body));\n          } else if (decl.body && decl.body.body) {\n            decl.body.body.forEach((moduleBlockNode) => {\n              // Export-assignment exports all members in the namespace,\n              // explicitly exported or not.\n              const namespaceDecl = moduleBlockNode.type === 'ExportNamedDeclaration'\n                ? moduleBlockNode.declaration\n                : moduleBlockNode;\n\n              if (!namespaceDecl) {\n                // TypeScript can check this for us; we needn't\n              } else if (namespaceDecl.type === 'VariableDeclaration') {\n                namespaceDecl.declarations.forEach((d) => recursivePatternCapture(d.id, (id) => m.namespace.set(\n                  id.name,\n                  captureDoc(source, docStyleParsers, decl, namespaceDecl, moduleBlockNode),\n                )),\n                );\n              } else {\n                m.namespace.set(\n                  namespaceDecl.id.name,\n                  captureDoc(source, docStyleParsers, moduleBlockNode));\n              }\n            });\n          }\n        } else {\n          // Export as default\n          m.namespace.set('default', captureDoc(source, docStyleParsers, decl));\n        }\n      });\n    }\n  });\n\n  if (\n    isEsModuleInteropTrue // esModuleInterop is on in tsconfig\n    && m.namespace.size > 0 // anything is exported\n    && !m.namespace.has('default') // and default isn't added already\n  ) {\n    m.namespace.set('default', {}); // add default export\n  }\n\n  if (unambiguouslyESM) {\n    m.parseGoal = 'Module';\n  }\n  return m;\n};\n\n/**\n * The creation of this closure is isolated from other scopes\n * to avoid over-retention of unrelated variables, which has\n * caused memory leaks. See #1266.\n */\nfunction thunkFor(p, context) {\n  return () => ExportMap.for(childContext(p, context));\n}\n\n/**\n * Traverse a pattern/identifier node, calling 'callback'\n * for each leaf identifier.\n * @param  {node}   pattern\n * @param  {Function} callback\n * @return {void}\n */\nexport function recursivePatternCapture(pattern, callback) {\n  switch (pattern.type) {\n    case 'Identifier': // base case\n      callback(pattern);\n      break;\n\n    case 'ObjectPattern':\n      pattern.properties.forEach((p) => {\n        if (p.type === 'ExperimentalRestProperty' || p.type === 'RestElement') {\n          callback(p.argument);\n          return;\n        }\n        recursivePatternCapture(p.value, callback);\n      });\n      break;\n\n    case 'ArrayPattern':\n      pattern.elements.forEach((element) => {\n        if (element == null) { return; }\n        if (element.type === 'ExperimentalRestProperty' || element.type === 'RestElement') {\n          callback(element.argument);\n          return;\n        }\n        recursivePatternCapture(element, callback);\n      });\n      break;\n\n    case 'AssignmentPattern':\n      callback(pattern.left);\n      break;\n    default:\n  }\n}\n\nlet parserOptionsHash = '';\nlet prevParserOptions = '';\nlet settingsHash = '';\nlet prevSettings = '';\n/**\n * don't hold full context object in memory, just grab what we need.\n * also calculate a cacheKey, where parts of the cacheKey hash are memoized\n */\nfunction childContext(path, context) {\n  const { settings, parserOptions, parserPath } = context;\n\n  if (JSON.stringify(settings) !== prevSettings) {\n    settingsHash = hashObject({ settings }).digest('hex');\n    prevSettings = JSON.stringify(settings);\n  }\n\n  if (JSON.stringify(parserOptions) !== prevParserOptions) {\n    parserOptionsHash = hashObject({ parserOptions }).digest('hex');\n    prevParserOptions = JSON.stringify(parserOptions);\n  }\n\n  return {\n    cacheKey: String(parserPath) + parserOptionsHash + settingsHash + String(path),\n    settings,\n    parserOptions,\n    parserPath,\n    path,\n  };\n}\n\n/**\n * sometimes legacy support isn't _that_ hard... right?\n */\nfunction makeSourceCode(text, ast) {\n  if (SourceCode.length > 1) {\n    // ESLint 3\n    return new SourceCode(text, ast);\n  } else {\n    // ESLint 4, 5\n    return new SourceCode({ text, ast });\n  }\n}\n"]}