• Version 3.1.5
  • Published
  • 60.8 kB
  • 8 dependencies
  • MIT license


npm i eslint-plugin-mdx
yarn add eslint-plugin-mdx
pnpm add eslint-plugin-mdx


ESLint Plugin for MDX



variable base

const base: Linter.Config;

    variable codeBlocks

    const codeBlocks: {
    parserOptions: { ecmaFeatures: { impliedStrict: true } };
    rules: {
    'eol-last': 'off';
    'no-undef': 'off';
    'no-unused-expressions': 'off';
    'no-unused-vars': 'off';
    'padded-blocks': 'off';
    strict: 'off';
    'unicode-bom': 'off';

      variable configs

      const configs: {
      base: any;
      'code-blocks': {
      parserOptions: { ecmaFeatures: { impliedStrict: true } };
      rules: {
      'eol-last': 'off';
      'no-undef': 'off';
      'no-unused-expressions': 'off';
      'no-unused-vars': 'off';
      'padded-blocks': 'off';
      strict: 'off';
      'unicode-bom': 'off';
      codeBlocks: {
      parserOptions: { ecmaFeatures: { impliedStrict: true } };
      rules: {
      'eol-last': 'off';
      'no-undef': 'off';
      'no-unused-expressions': 'off';
      'no-unused-vars': 'off';
      'padded-blocks': 'off';
      strict: 'off';
      'unicode-bom': 'off';
      flat: any;
      flatCodeBlocks: any;
      overrides: any;
      recommended: any;


        const DEFAULT_LANGUAGE_MAPPER: Record<string, string>;

          variable flat

          const flat: Linter.FlatConfig;

            variable flatCodeBlocks

            const flatCodeBlocks: Linter.FlatConfig;

              variable meta

              const meta: { name: string; version: string };

                variable overrides

                const overrides: Linter.Config;

                  variable processorOptions

                  const processorOptions: ProcessorOptions;

                    variable processors

                    const processors: { remark: any };
                      const recommended: Linter.Config;

                        variable remark

                        const remark: Rule.RuleModule;

                          variable rules

                          const rules: { remark: any };


                            function createRemarkProcessor

                            createRemarkProcessor: (
                            processorOptions?: import('./types').ProcessorOptions
                            ) => Linter.Processor;

                              function getGlobals

                              getGlobals: <
                              T extends Record<string, unknown> | string[],
                              G extends Record<string, boolean>,
                              R extends G = G & Record<T extends (infer R_1)[] ? R_1 : keyof T, false>
                              sources: T,
                              initialGlobals?: G
                              ) => R;

                                function getShortLang

                                getShortLang: (
                                filename: string,
                                languageMapper?: Record<string, string> | false
                                ) => string;


                                  interface ESLintMdxSettings

                                  interface ESLintMdxSettings {}

                                    property 'mdx/code-blocks'

                                    'mdx/code-blocks'?: boolean;

                                      property 'mdx/language-mapper'

                                      'mdx/language-mapper'?: Record<string, string> | false;

                                        interface ExpressionStatementWithParent

                                        interface ExpressionStatementWithParent extends ExpressionStatement, WithParent {}

                                          interface LinterConfig

                                          interface LinterConfig extends Linter.Config {}

                                            method extractConfig

                                            extractConfig: (filename?: string) => Linter.Config;

                                              interface ProcessorOptions

                                              interface ProcessorOptions {}

                                                property languageMapper

                                                languageMapper?: Record<string, string> | false;

                                                  property lintCodeBlocks

                                                  lintCodeBlocks: boolean;

                                                    interface RemarkLintMessage

                                                    interface RemarkLintMessage {}

                                                      property reason

                                                      reason: string;

                                                        property ruleId

                                                        ruleId: string;

                                                          property severity

                                                          severity: Linter.Severity;

                                                            property source

                                                            source: string;

                                                              interface WithParent

                                                              interface WithParent {}

                                                                property parent

                                                                parent: NodeWithParent;

                                                                  Type Aliases

                                                                  type NodeWithParent

                                                                  type NodeWithParent = Node & WithParent;

                                                                    Package Files (17)

                                                                    Dependencies (8)

                                                                    Dev Dependencies (0)

                                                                    No dev dependencies.

                                                                    Peer Dependencies (1)


                                                                    To add a badge like this badgeto your package's README, use the codes available below.

                                                                    You may also use to create a custom badge linking to

                                                                    • Markdown
                                                                    • HTML
                                                                      <a href=""><img src="" alt=""></a>