eslint-plugin-jsdoc 52.0.4 → 53.0.1

package/src/exportParser.js

@@ -1,978 +0,0 @@
-import {
-  findJSDocComment,
-} from '@es-joy/jsdoccomment';
-import debugModule from 'debug';
-
-const debug = debugModule('requireExportJsdoc');
-
-/**
- * @typedef {{
- *   value: string
- * }} ValueObject
- */
-
-/**
- * @typedef {{
- *   type?: string,
- *   value?: ValueObject|import('eslint').Rule.Node|import('@typescript-eslint/types').TSESTree.Node,
- *   props: {
- *     [key: string]: CreatedNode|null,
- *   },
- *   special?: true,
- *   globalVars?: CreatedNode,
- *   exported?: boolean,
- *   ANONYMOUS_DEFAULT?: import('eslint').Rule.Node
- * }} CreatedNode
- */
-
-/**
- * @returns {CreatedNode}
- */
-const createNode = function () {
-  return {
-    props: {},
-  };
-};
-
-/**
- * @param {CreatedNode|null} symbol
- * @returns {string|null}
- */
-const getSymbolValue = function (symbol) {
-  /* c8 ignore next 3 */
-  if (!symbol) {
-    return null;
-  }
-
-  /* c8 ignore else */
-  if (symbol.type === 'literal') {
-    return /** @type {ValueObject} */ (symbol.value).value;
-  }
-  /* c8 ignore next 2 */
-  // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
-  return null;
-};
-
-/**
- *
- * @param {import('estree').Identifier} node
- * @param {CreatedNode} globals
- * @param {CreatedNode} scope
- * @param {SymbolOptions} opts
- * @returns {CreatedNode|null}
- */
-const getIdentifier = function (node, globals, scope, opts) {
-  if (opts.simpleIdentifier) {
-    // Type is Identier for noncomputed properties
-    const identifierLiteral = createNode();
-    identifierLiteral.type = 'literal';
-    identifierLiteral.value = {
-      value: node.name,
-    };
-
-    return identifierLiteral;
-  }
-
-  /* c8 ignore next */
-  const block = scope || globals;
-
-  // As scopes are not currently supported, they are not traversed upwards recursively
-  if (block.props[node.name]) {
-    return block.props[node.name];
-  }
-
-  // Seems this will only be entered once scopes added and entered
-  /* c8 ignore next 3 */
-  if (globals.props[node.name]) {
-    return globals.props[node.name];
-  }
-
-  return null;
-};
-
-/**
- * @callback CreateSymbol
- * @param {import('eslint').Rule.Node|null} node
- * @param {CreatedNode} globals
- * @param {import('eslint').Rule.Node|import('@typescript-eslint/types').TSESTree.Node|null} value
- * @param {CreatedNode} [scope]
- * @param {boolean|SymbolOptions} [isGlobal]
- * @returns {CreatedNode|null}
- */
-
-/** @type {CreateSymbol} */
-let createSymbol; // eslint-disable-line prefer-const
-
-/* eslint-disable complexity -- Temporary */
-
-/**
- * @typedef {{
- *   simpleIdentifier?: boolean
- * }} SymbolOptions
- */
-
-/**
- *
- * @param {import('eslint').Rule.Node|import('@typescript-eslint/types').TSESTree.Node} node
- * @param {CreatedNode} globals
- * @param {CreatedNode} scope
- * @param {SymbolOptions} [opt]
- * @returns {CreatedNode|null}
- */
-const getSymbol = function (node, globals, scope, opt) {
-  /* eslint-enable complexity -- Temporary */
-  const opts = opt || {};
-  /* c8 ignore next */
-  switch (node.type) {
-    /* c8 ignore next 4 -- No longer needed? */
-    case 'ArrowFunctionExpression':
-
-    // Fallthrough
-    case 'ClassDeclaration':
-
-    case 'FunctionDeclaration':
-
-    case 'FunctionExpression':
-    case 'TSEnumDeclaration':
-    case 'TSInterfaceDeclaration':
-    case 'TSTypeAliasDeclaration': {
-      const val = createNode();
-      val.props.prototype = createNode();
-      val.props.prototype.type = 'object';
-      val.type = 'object';
-      val.value = node;
-
-      return val;
-    }
-
-    case 'AssignmentExpression': {
-      return createSymbol(
-      /** @type {import('eslint').Rule.Node} */
-        (node.left),
-        globals,
-        /** @type {import('eslint').Rule.Node} */
-        (node.right),
-        scope,
-        opts,
-      );
-    }
-
-    case 'ClassBody': {
-      const val = createNode();
-      for (const method of node.body) {
-        // StaticBlock
-        if (!('key' in method)) {
-          continue;
-        }
-
-        val.props[
-        /** @type {import('estree').Identifier} */ (
-          /** @type {import('estree').MethodDefinition} */ (
-              method
-            ).key
-          ).name
-        ] = createNode();
-        /** @type {{[key: string]: CreatedNode}} */ (val.props)[
-        /** @type {import('estree').Identifier} */ (
-          /** @type {import('estree').MethodDefinition} */ (
-              method
-            ).key
-          ).name
-        ].type = 'object';
-        /** @type {{[key: string]: CreatedNode}} */ (val.props)[
-        /** @type {import('estree').Identifier} */ (
-          /** @type {import('estree').MethodDefinition} */ (
-              method
-            ).key
-          ).name
-        ].value = /** @type {import('eslint').Rule.Node} */ (
-        /** @type {import('estree').MethodDefinition} */ (method).value
-        );
-      }
-
-      val.type = 'object';
-      val.value = node.parent;
-
-      return val;
-    }
-
-    case 'ClassExpression': {
-      return getSymbol(
-      /** @type {import('eslint').Rule.Node} */
-        (node.body),
-        globals,
-        scope,
-        opts,
-      );
-    }
-
-    case 'Identifier': {
-      return getIdentifier(node, globals, scope, opts);
-    }
-
-    case 'Literal': {
-      const val = createNode();
-      val.type = 'literal';
-      val.value = node;
-
-      return val;
-    }
-
-    case 'MemberExpression': {
-      const obj = getSymbol(
-      /** @type {import('eslint').Rule.Node} */
-        (node.object),
-        globals,
-        scope,
-        opts,
-      );
-      const propertySymbol = getSymbol(
-      /** @type {import('eslint').Rule.Node} */
-        (node.property),
-        globals,
-        scope,
-        {
-          simpleIdentifier: !node.computed,
-        },
-      );
-      const propertyValue = getSymbolValue(propertySymbol);
-
-      /* c8 ignore else */
-      if (obj && propertyValue && obj.props[propertyValue]) {
-        const block = obj.props[propertyValue];
-
-        return block;
-      }
-      /* c8 ignore next 11 */
-      /*
-    if (opts.createMissingProps && propertyValue) {
-      obj.props[propertyValue] = createNode();
-
-      return obj.props[propertyValue];
-    }
-    */
-      // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
-      debug(`MemberExpression: Missing property ${
-      /** @type {import('estree').PrivateIdentifier} */ (node.property).name
-      }`);
-      /* c8 ignore next 2 */
-      return null;
-    }
-
-    case 'ObjectExpression': {
-      const val = createNode();
-      val.type = 'object';
-      for (const prop of node.properties) {
-        if ([
-        // @babel/eslint-parser
-          'ExperimentalSpreadProperty',
-
-          // typescript-eslint, espree, acorn, etc.
-          'SpreadElement',
-        ].includes(prop.type)) {
-          continue;
-        }
-
-        const propVal = getSymbol(
-        /** @type {import('eslint').Rule.Node} */ (
-          /** @type {import('estree').Property} */
-            (prop).value
-          ),
-          globals,
-          scope,
-          opts,
-        );
-        /* c8 ignore next 8 */
-        if (propVal) {
-          val.props[
-          /** @type {import('estree').PrivateIdentifier} */
-            (
-            /** @type {import('estree').Property} */ (prop).key
-            ).name
-          ] = propVal;
-        }
-      }
-
-      return val;
-    }
-  }
-  /* c8 ignore next 2 */
-  // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
-  return null;
-};
-
-/**
- *
- * @param {CreatedNode} block
- * @param {string} name
- * @param {CreatedNode|null} value
- * @param {CreatedNode} globals
- * @param {boolean|SymbolOptions|undefined} isGlobal
- * @returns {void}
- */
-const createBlockSymbol = function (block, name, value, globals, isGlobal) {
-  block.props[name] = value;
-  if (isGlobal && globals.props.window && globals.props.window.special) {
-    globals.props.window.props[name] = value;
-  }
-};
-
-createSymbol = function (node, globals, value, scope, isGlobal) {
-  const block = scope || globals;
-  /* c8 ignore next 3 */
-  if (!node) {
-    return null;
-  }
-
-  let symbol;
-  switch (node.type) {
-    case 'ClassDeclaration':
-      /* c8 ignore next */
-      // @ts-expect-error TS OK
-      // Fall through
-    case 'FunctionDeclaration': case 'TSEnumDeclaration':
-      /* c8 ignore next */
-      // @ts-expect-error TS OK
-      // Fall through
-    case 'TSInterfaceDeclaration': case 'TSTypeAliasDeclaration': {
-      const nde = /** @type {import('estree').ClassDeclaration} */ (node);
-      /* c8 ignore else */
-      if (nde.id && nde.id.type === 'Identifier') {
-        return createSymbol(
-        /** @type {import('eslint').Rule.Node} */ (nde.id),
-          globals,
-          node,
-          globals,
-        );
-      }
-      /* c8 ignore next 3 */
-      // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
-      break;
-    }
-
-    case 'Identifier': {
-      const nde = /** @type {import('estree').Identifier} */ (node);
-      if (value) {
-        const valueSymbol = getSymbol(value, globals, block);
-        /* c8 ignore else */
-        if (valueSymbol) {
-          createBlockSymbol(block, nde.name, valueSymbol, globals, isGlobal);
-
-          return block.props[nde.name];
-        }
-        /* c8 ignore next 2 */
-        // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
-        debug('Identifier: Missing value symbol for %s', nde.name);
-      } else {
-        createBlockSymbol(block, nde.name, createNode(), globals, isGlobal);
-
-        return block.props[nde.name];
-      }
-      /* c8 ignore next 3 */
-      // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
-      break;
-    }
-
-    case 'MemberExpression': {
-      const nde = /** @type {import('estree').MemberExpression} */ (node);
-      symbol = getSymbol(
-      /** @type {import('eslint').Rule.Node} */ (nde.object), globals, block,
-      );
-
-      const propertySymbol = getSymbol(
-      /** @type {import('eslint').Rule.Node} */ (nde.property),
-        globals,
-        block,
-        {
-          simpleIdentifier: !nde.computed,
-        },
-      );
-      const propertyValue = getSymbolValue(propertySymbol);
-      if (symbol && propertyValue) {
-        createBlockSymbol(symbol, propertyValue, getSymbol(
-        /** @type {import('eslint').Rule.Node} */
-          (value), globals, block,
-        ), globals, isGlobal);
-        return symbol.props[propertyValue];
-      }
-
-      debug(
-        'MemberExpression: Missing symbol: %s',
-        /** @type {import('estree').Identifier} */ (
-          nde.property
-        ).name,
-      );
-      break;
-    }
-  }
-
-  return null;
-};
-
-/**
- * Creates variables from variable definitions
- * @param {import('eslint').Rule.Node} node
- * @param {CreatedNode} globals
- * @param {import('./rules/requireJsdoc.js').RequireJsdocOpts} opts
- * @returns {void}
- */
-const initVariables = function (node, globals, opts) {
-  switch (node.type) {
-    case 'ExportNamedDeclaration': {
-      if (node.declaration) {
-        initVariables(
-        /** @type {import('eslint').Rule.Node} */
-          (node.declaration),
-          globals,
-          opts,
-        );
-      }
-
-      break;
-    }
-
-    case 'ExpressionStatement': {
-      initVariables(
-      /** @type {import('eslint').Rule.Node} */
-        (node.expression),
-        globals,
-        opts,
-      );
-      break;
-    }
-
-    case 'Program': {
-      for (const childNode of node.body) {
-        initVariables(
-        /** @type {import('eslint').Rule.Node} */
-          (childNode),
-          globals,
-          opts,
-        );
-      }
-
-      break;
-    }
-
-    case 'VariableDeclaration': {
-      for (const declaration of node.declarations) {
-      // let and const
-        const symbol = createSymbol(
-        /** @type {import('eslint').Rule.Node} */
-          (declaration.id),
-          globals,
-          null,
-          globals,
-        );
-        if (opts.initWindow && node.kind === 'var' && globals.props.window) {
-        // If var, also add to window
-          globals.props.window.props[
-          /** @type {import('estree').Identifier} */
-            (declaration.id).name
-          ] = symbol;
-        }
-      }
-
-      break;
-    }
-  }
-};
-
-/* eslint-disable complexity -- Temporary */
-
-/**
- * Populates variable maps using AST
- * @param {import('eslint').Rule.Node|import('@typescript-eslint/types').TSESTree.Node} node
- * @param {CreatedNode} globals
- * @param {import('./rules/requireJsdoc.js').RequireJsdocOpts} opt
- * @param {true} [isExport]
- * @returns {boolean}
- */
-const mapVariables = function (node, globals, opt, isExport) {
-  /* eslint-enable complexity -- Temporary */
-  /* c8 ignore next */
-  const opts = opt || {};
-  /* c8 ignore next */
-  switch (node.type) {
-    case 'AssignmentExpression': {
-      createSymbol(
-      /** @type {import('eslint').Rule.Node} */
-        (node.left),
-        globals,
-        /** @type {import('eslint').Rule.Node} */
-        (node.right),
-      );
-      break;
-    }
-
-    case 'ClassDeclaration': {
-      createSymbol(
-      /** @type {import('eslint').Rule.Node|null} */ (node.id),
-        globals,
-        /** @type {import('eslint').Rule.Node} */ (node.body),
-        globals,
-      );
-      break;
-    }
-
-    case 'ExportDefaultDeclaration': {
-      const symbol = createSymbol(
-      /** @type {import('eslint').Rule.Node} */
-        (node.declaration),
-        globals,
-        /** @type {import('eslint').Rule.Node} */
-        (node.declaration),
-      );
-      if (symbol) {
-        symbol.exported = true;
-        /* c8 ignore next 6 */
-      } else {
-      // if (!node.id) {
-        globals.ANONYMOUS_DEFAULT = /** @type {import('eslint').Rule.Node} */ (
-          node.declaration
-        );
-      }
-
-      break;
-    }
-
-    case 'ExportNamedDeclaration': {
-      if (node.declaration) {
-        if (node.declaration.type === 'VariableDeclaration') {
-          mapVariables(
-          /** @type {import('eslint').Rule.Node} */
-            (node.declaration),
-            globals,
-            opts,
-            true,
-          );
-        } else {
-          const symbol = createSymbol(
-          /** @type {import('eslint').Rule.Node} */
-            (node.declaration),
-            globals,
-            /** @type {import('eslint').Rule.Node} */
-            (node.declaration),
-          );
-          /* c8 ignore next 3 */
-          if (symbol) {
-            symbol.exported = true;
-          }
-        }
-      }
-
-      for (const specifier of node.specifiers) {
-        mapVariables(
-        /** @type {import('eslint').Rule.Node} */
-          (specifier),
-          globals,
-          opts,
-        );
-      }
-
-      break;
-    }
-
-    case 'ExportSpecifier': {
-      const symbol = getSymbol(
-      /** @type {import('eslint').Rule.Node} */
-        (node.local),
-        globals,
-        globals,
-      );
-      /* c8 ignore next 3 */
-      if (symbol) {
-        symbol.exported = true;
-      }
-
-      break;
-    }
-
-    case 'ExpressionStatement': {
-      mapVariables(
-      /** @type {import('eslint').Rule.Node} */
-        (node.expression),
-        globals,
-        opts,
-      );
-      break;
-    }
-
-    case 'FunctionDeclaration':
-
-    case 'TSTypeAliasDeclaration': {
-    /* c8 ignore next 10 */
-      if (/** @type {import('estree').Identifier} */ (node.id).type === 'Identifier') {
-        createSymbol(
-        /** @type {import('eslint').Rule.Node} */
-          (node.id),
-          globals,
-          node,
-          globals,
-          true,
-        );
-      }
-
-      break;
-    }
-
-    case 'Program': {
-      if (opts.ancestorsOnly) {
-        return false;
-      }
-
-      for (const childNode of node.body) {
-        mapVariables(
-        /** @type {import('eslint').Rule.Node} */
-          (childNode),
-          globals,
-          opts,
-        );
-      }
-
-      break;
-    }
-
-    case 'VariableDeclaration': {
-      for (const declaration of node.declarations) {
-        const isGlobal = Boolean(opts.initWindow && node.kind === 'var' && globals.props.window);
-        const symbol = createSymbol(
-        /** @type {import('eslint').Rule.Node} */
-          (declaration.id),
-          globals,
-          /** @type {import('eslint').Rule.Node} */
-          (declaration.init),
-          globals,
-          isGlobal,
-        );
-        if (symbol && isExport) {
-          symbol.exported = true;
-        }
-      }
-
-      break;
-    }
-
-    default: {
-    /* c8 ignore next */
-      return false;
-    }
-  }
-
-  return true;
-};
-
-/**
- *
- * @param {import('eslint').Rule.Node} node
- * @param {CreatedNode|ValueObject|string|undefined|
- *   import('eslint').Rule.Node|import('@typescript-eslint/types').TSESTree.Node} block
- * @param {(CreatedNode|ValueObject|string|
- *   import('eslint').Rule.Node|import('@typescript-eslint/types').TSESTree.Node)[]} [cache]
- * @returns {boolean}
- */
-const findNode = function (node, block, cache) {
-  let blockCache = cache || [];
-  if (!block || blockCache.includes(block)) {
-    return false;
-  }
-
-  blockCache = blockCache.slice();
-  blockCache.push(block);
-
-  if (
-    typeof block === 'object' &&
-    'type' in block &&
-    (block.type === 'object' || block.type === 'MethodDefinition') &&
-    block.value === node
-  ) {
-    return true;
-  }
-
-  if (typeof block !== 'object') {
-    return false;
-  }
-
-  const props = ('props' in block && block.props) || ('body' in block && block.body);
-  for (const propval of Object.values(props || {})) {
-    if (Array.isArray(propval)) {
-      /* c8 ignore next 5 */
-      if (propval.some((val) => {
-        return findNode(node, val, blockCache);
-      })) {
-        return true;
-      }
-    } else if (findNode(node, propval, blockCache)) {
-      return true;
-    }
-  }
-
-  return false;
-};
-
-const exportTypes = new Set([
-  'ExportDefaultDeclaration', 'ExportNamedDeclaration',
-]);
-const ignorableNestedTypes = new Set([
-  'ArrowFunctionExpression', 'FunctionDeclaration', 'FunctionExpression',
-]);
-
-/**
- * @param {import('eslint').Rule.Node} nde
- * @returns {import('eslint').Rule.Node|false}
- */
-const getExportAncestor = function (nde) {
-  let node = nde;
-  let idx = 0;
-  const ignorableIfDeep = ignorableNestedTypes.has(nde?.type);
-  while (node) {
-    // Ignore functions nested more deeply than say `export default function () {}`
-    if (idx >= 2 && ignorableIfDeep) {
-      break;
-    }
-
-    if (exportTypes.has(node.type)) {
-      return node;
-    }
-
-    node = node.parent;
-    idx++;
-  }
-
-  return false;
-};
-
-const canBeExportedByAncestorType = new Set([
-  'ClassProperty',
-  'Method',
-  'PropertyDefinition',
-  'TSMethodSignature',
-  'TSPropertySignature',
-]);
-
-const canExportChildrenType = new Set([
-  'ClassBody',
-  'ClassDeclaration',
-  'ClassDefinition',
-  'ClassExpression',
-  'Program',
-  'TSInterfaceBody',
-  'TSInterfaceDeclaration',
-  'TSTypeAliasDeclaration',
-  'TSTypeLiteral',
-  'TSTypeParameterInstantiation',
-  'TSTypeReference',
-]);
-
-/**
- * @param {import('eslint').Rule.Node} nde
- * @returns {false|import('eslint').Rule.Node}
- */
-const isExportByAncestor = function (nde) {
-  if (!canBeExportedByAncestorType.has(nde.type)) {
-    return false;
-  }
-
-  let node = nde.parent;
-  while (node) {
-    if (exportTypes.has(node.type)) {
-      return node;
-    }
-
-    if (!canExportChildrenType.has(node.type)) {
-      return false;
-    }
-
-    node = node.parent;
-  }
-
-  return false;
-};
-
-/**
- *
- * @param {CreatedNode} block
- * @param {import('eslint').Rule.Node} node
- * @param {CreatedNode[]} [cache] Currently unused
- * @returns {boolean}
- */
-const findExportedNode = function (block, node, cache) {
-  /* c8 ignore next 3 */
-  if (block === null) {
-    return false;
-  }
-
-  const blockCache = cache || [];
-  const {
-    props,
-  } = block;
-  for (const propval of Object.values(props)) {
-    const pval = /** @type {CreatedNode} */ (propval);
-    blockCache.push(pval);
-    if (pval.exported && (node === pval.value || findNode(node, pval.value))) {
-      return true;
-    }
-
-    // No need to check `propval` for exported nodes as ESM
-    //  exports are only global
-  }
-
-  return false;
-};
-
-/**
- *
- * @param {import('eslint').Rule.Node} node
- * @param {CreatedNode} globals
- * @param {import('./rules/requireJsdoc.js').RequireJsdocOpts} opt
- * @returns {boolean}
- */
-const isNodeExported = function (node, globals, opt) {
-  const moduleExports = globals.props.module?.props?.exports;
-  if (
-    opt.initModuleExports && moduleExports && findNode(node, moduleExports)
-  ) {
-    return true;
-  }
-
-  if (opt.initWindow && globals.props.window && findNode(node, globals.props.window)) {
-    return true;
-  }
-
-  if (opt.esm && findExportedNode(globals, node)) {
-    return true;
-  }
-
-  return false;
-};
-
-/**
- *
- * @param {import('eslint').Rule.Node} node
- * @param {CreatedNode} globalVars
- * @param {import('./rules/requireJsdoc.js').RequireJsdocOpts} opts
- * @returns {boolean}
- */
-const parseRecursive = function (node, globalVars, opts) {
-  // Iterate from top using recursion - stop at first processed node from top
-  if (node.parent && parseRecursive(node.parent, globalVars, opts)) {
-    return true;
-  }
-
-  return mapVariables(node, globalVars, opts);
-};
-
-/**
- *
- * @param {import('eslint').Rule.Node} ast
- * @param {import('eslint').Rule.Node} node
- * @param {import('./rules/requireJsdoc.js').RequireJsdocOpts} opt
- * @returns {CreatedNode}
- */
-const parse = function (ast, node, opt) {
-  /* c8 ignore next 6 */
-  const opts = opt || {
-    ancestorsOnly: false,
-    esm: true,
-    initModuleExports: true,
-    initWindow: true,
-  };
-
-  const globalVars = createNode();
-  if (opts.initModuleExports) {
-    globalVars.props.module = createNode();
-    globalVars.props.module.props.exports = createNode();
-    globalVars.props.exports = globalVars.props.module.props.exports;
-  }
-
-  if (opts.initWindow) {
-    globalVars.props.window = createNode();
-    globalVars.props.window.special = true;
-  }
-
-  if (opts.ancestorsOnly) {
-    parseRecursive(node, globalVars, opts);
-  } else {
-    initVariables(ast, globalVars, opts);
-    mapVariables(ast, globalVars, opts);
-  }
-
-  return {
-    globalVars,
-    props: {},
-  };
-};
-
-const accessibilityNodes = new Set([
-  'MethodDefinition',
-  'PropertyDefinition',
-]);
-
-/**
- *
- * @param {import('eslint').Rule.Node} node
- * @returns {boolean}
- */
-const isPrivate = (node) => {
-  return accessibilityNodes.has(node.type) &&
-    (
-      'accessibility' in node &&
-      node.accessibility !== 'public' && node.accessibility !== undefined
-    ) ||
-  'key' in node &&
-    node.key.type === 'PrivateIdentifier';
-};
-
-/**
- *
- * @param {import('eslint').Rule.Node} node
- * @param {import('eslint').SourceCode} sourceCode
- * @param {import('./rules/requireJsdoc.js').RequireJsdocOpts} opt
- * @param {import('./iterateJsdoc.js').Settings} settings
- * @returns {boolean}
- */
-const isUncommentedExport = function (node, sourceCode, opt, settings) {
-  // console.log({node});
-  // Optimize with ancestor check for esm
-  if (opt.esm) {
-    if (isPrivate(node) ||
-      node.parent && isPrivate(node.parent)) {
-      return false;
-    }
-
-    const exportNode = getExportAncestor(node);
-
-    // Is export node comment
-    if (exportNode && !findJSDocComment(exportNode, sourceCode, settings)) {
-      return true;
-    }
-
-    /**
-     * Some typescript types are not in variable map, but inherit exported (interface property and method)
-     */
-    if (
-      isExportByAncestor(node) &&
-      !findJSDocComment(node, sourceCode, settings)
-    ) {
-      return true;
-    }
-  }
-
-  const ast = /** @type {unknown} */ (sourceCode.ast);
-
-  const parseResult = parse(
-    /** @type {import('eslint').Rule.Node} */
-    (ast),
-    node,
-    opt,
-  );
-
-  return isNodeExported(
-    node, /** @type {CreatedNode} */ (parseResult.globalVars), opt,
-  );
-};
-
-export default {
-  isUncommentedExport,
-  parse,
-};