eslint-plugin-jsdoc 56.0.0 → 56.0.2

package/dist/cjs/exportParser.js

@@ -1,754 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsdoccomment_1 = require("@es-joy/jsdoccomment");
-const debug_1 = __importDefault(require("debug"));
-const debug = (0, debug_1.default)('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 && !(0, jsdoccomment_1.findJSDocComment)(exportNode, sourceCode, settings)) {
-            return true;
-        }
-        /**
-         * Some typescript types are not in variable map, but inherit exported (interface property and method)
-         */
-        if (isExportByAncestor(node) &&
-            !(0, jsdoccomment_1.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);
-};
-exports.default = {
-    isUncommentedExport,
-    parse,
-};