@lipemat/eslint-config 4.0.5 → 5.0.0-beta.2

package/helpers/config.js

@@ -1,11 +1,9 @@
-import {getExtensionsConfig} from '@lipemat/js-boilerplate/helpers/config.js';
-
-
+import { getExtensionsConfig } from '@lipemat/js-boilerplate/helpers/config.js';
 /**
  * Get a config from our /index.js merged with any
  * matching configuration from the project directory.
  *
- * For instance if we have a file named config/eslint.config.js in our project
+ * For instance, if we have a file named config/eslint.config.js in our project
  * we will merge the contents with our config/eslint.config.js in favor of whatever
  * is specified with the project's file.
  *
@@ -20,12 +18,14 @@ import {getExtensionsConfig} from '@lipemat/js-boilerplate/helpers/config.js';
  *     config.configs[0].push({extra: 'Extra'});
  *     return config
  * }
- * ```
- *
- * @return {Object[]} - `eslint.Linter.Config[]`
  */
-export function getConfig( mergedConfig ) {
-	const BASE = {configs: mergedConfig};
-	mergedConfig = {...BASE, ...getExtensionsConfig( 'eslint.config', BASE )};
-	return mergedConfig.configs;
+export function getConfig(configs) {
+    const BASE = {
+        configs: configs
+    };
+    const mergedConfig = {
+        ...BASE,
+        ...getExtensionsConfig('eslint.config', BASE)
+    };
+    return mergedConfig.configs;
 }

package/index.js

@@ -1,135 +1,131 @@
-import {fixupConfigRules} from '@eslint/compat';
-import {FlatCompat} from '@eslint/eslintrc';
+import { fixupConfigRules } from '@eslint/compat';
+import { FlatCompat } from '@eslint/eslintrc';
 import tsPlugin from '@typescript-eslint/eslint-plugin';
 import tsParser from '@typescript-eslint/parser';
+import securityPlugin from './plugins/security/index.js';
 import globals from 'globals';
 import stylisticTs from '@stylistic/eslint-plugin-ts';
-import {getConfig} from './helpers/config.js';
-
-
+import { getConfig } from './helpers/config.js';
 const flatCompat = new FlatCompat();
-
 /**
  * Default config if no extensions override it.
  *
  */
 const BASE_CONFIG = {
-	languageOptions: {
-		ecmaVersion: 7,
-		globals: {
-			...globals.browser,
-			$: 'readonly',
-			jQuery: 'readonly',
-		},
-		parser: tsParser,
-		parserOptions: {
-			project: './tsconfig.json',
-			warnOnUnsupportedTypeScriptVersion: false,
-		},
-		sourceType: 'module',
-	},
-	rules: {
-		'arrow-parens': [ 1, 'as-needed' ],
-		'arrow-spacing': [ 1, {before: true, after: true} ],
-		camelcase: [ 2, {properties: 'never'} ],
-		indent: [ 1, 'tab', {SwitchCase: 1} ],
-		'lines-around-comment': 'off',
-		'jsdoc/require-param': 'off',
-		'jsdoc/require-param-type': 'off',
-		'jsdoc/require-returns-description': 'off',
-		'jsdoc/check-tag-names': [ 1, {definedTags: [ 'notice', 'link', 'task', 'ticket', 'note' ]} ],
-		// Parse error with Svelte v4 due to `as` operator.
-		'import/named': 'off',
-		'import/no-unresolved': 'off',
-		'no-console': [ 'warn', {allow: [ 'warn', 'error', 'debug' ]} ],
-		'no-constant-binary-expression': [ 'warn' ],
-		'no-multiple-empty-lines': [ 'error', {max: 2} ],
-		'object-curly-spacing': [ 1, 'never' ],
-		'react/no-unescaped-entities': [ 2, {forbid: [ '>', '}' ]} ],
-		'react/display-name': 'off',
-		'react-hooks/rules-of-hooks': 'error',
-		'react-hooks/exhaustive-deps': 'warn',
-		'react/jsx-curly-spacing': [ 1, {
-			when: 'never',
-			allowMultiline: false,
-			children: true,
-		} ],
-		'react/prop-types': [ 2, {skipUndeclared: true} ],
-		'space-before-blocks': [ 1, 'always' ],
-		'space-before-function-paren': [ 'error', {
-			anonymous: 'never',
-			named: 'never',
-			asyncArrow: 'ignore',
-		} ],
-		'space-in-parens': [ 2, 'always' ],
-		'template-curly-spacing': [ 1, 'never' ],
-		yoda: [ 2, 'always', {onlyEquality: true} ],
-	},
-	settings: {
-		react: {
-			version: '18.0',
-		},
-	},
+    languageOptions: {
+        ecmaVersion: 7,
+        globals: {
+            ...globals.browser,
+            $: 'readonly',
+            jQuery: 'readonly',
+        },
+        parser: tsParser,
+        parserOptions: {
+            project: './tsconfig.json',
+            warnOnUnsupportedTypeScriptVersion: false,
+        },
+        sourceType: 'module',
+    },
+    rules: {
+        'arrow-parens': [1, 'as-needed'],
+        'arrow-spacing': [1, { before: true, after: true }],
+        camelcase: [2, { properties: 'never' }],
+        indent: [1, 'tab', { SwitchCase: 1 }],
+        'lines-around-comment': 'off',
+        'jsdoc/require-param': 'off',
+        'jsdoc/require-param-type': 'off',
+        'jsdoc/require-returns-description': 'off',
+        'jsdoc/check-tag-names': [1, { definedTags: ['notice', 'link', 'task', 'ticket', 'note'] }],
+        // Parse error with Svelte v4 due to `as` operator.
+        'import/named': 'off',
+        'import/no-unresolved': 'off',
+        'no-console': ['warn', { allow: ['warn', 'error', 'debug'] }],
+        'no-constant-binary-expression': ['warn'],
+        'no-multiple-empty-lines': ['error', { max: 2 }],
+        'object-curly-spacing': [1, 'never'],
+        'react/no-unescaped-entities': [2, { forbid: ['>', '}'] }],
+        'react/display-name': 'off',
+        'react-hooks/rules-of-hooks': 'error',
+        'react-hooks/exhaustive-deps': 'warn',
+        'react/jsx-curly-spacing': [1, {
+                when: 'never',
+                allowMultiline: false,
+                children: true,
+            }],
+        'react/prop-types': [2, { skipUndeclared: true }],
+        'space-before-blocks': [1, 'always'],
+        'space-before-function-paren': ['error', {
+                anonymous: 'never',
+                named: 'never',
+                asyncArrow: 'ignore',
+            }],
+        'space-in-parens': [2, 'always'],
+        'template-curly-spacing': [1, 'never'],
+        yoda: [2, 'always', { onlyEquality: true }],
+    },
+    settings: {
+        react: {
+            version: '18.0',
+        },
+    },
 };
-
-
 const TS_CONFIG = {
-	files: [ '**/*.ts', '**/*.tsx' ],
-	plugins: {
-		'@typescript-eslint': tsPlugin,
-		'@stylistic/ts': stylisticTs,
-	},
-	//Rules to override the standard JS ones when we get undesired results for TypeScript may be found here
-	//@link https://typescript-eslint.io/rules/
-	rules: {
-		'jsdoc/no-undefined-types': 'off',
-		'no-magic-numbers': 'off',
-		'no-redeclare': 'off',
-		'no-shadow': 'off',
-		'no-undef': 'off',
-		'no-unused-vars': 'off',
-		semi: 'off',
-		'@typescript-eslint/no-empty-object-type': 'warn',
-		'@typescript-eslint/no-explicit-any': 'error',
-		'@typescript-eslint/no-redeclare': [ 'error' ],
-		'@typescript-eslint/no-restricted-types': [ 'error', {
-			types: {
-				unknown: 'Use a specific type.',
-			},
-		} ],
-		'@typescript-eslint/no-shadow': [ 'error' ],
-		'@typescript-eslint/no-unsafe-function-type': 'error',
-		'@typescript-eslint/no-unused-vars': 'error',
-		'@typescript-eslint/no-wrapper-object-types': 'error',
-		'@typescript-eslint/strict-boolean-expressions': [ 'warn', {
-			allowString: false, allowNumber: false,
-		} ],
-		'@stylistic/ts/type-annotation-spacing': [ 'warn', {
-			before: false,
-			after: true,
-			overrides: {
-				arrow: {
-					before: true,
-					after: true,
-				},
-			},
-		} ],
-	},
+    files: ['**/*.ts', '**/*.tsx'],
+    plugins: {
+        '@typescript-eslint': tsPlugin,
+        '@stylistic/ts': stylisticTs,
+    },
+    //Rules to override the standard JS ones when we get undesired results for TypeScript may be found here
+    //@link https://typescript-eslint.io/rules/
+    rules: {
+        'jsdoc/no-undefined-types': 'off',
+        'no-magic-numbers': 'off',
+        'no-redeclare': 'off',
+        'no-shadow': 'off',
+        'no-undef': 'off',
+        'no-unused-vars': 'off',
+        semi: 'off',
+        '@typescript-eslint/no-empty-object-type': 'warn',
+        '@typescript-eslint/no-explicit-any': 'error',
+        '@typescript-eslint/no-redeclare': ['error'],
+        '@typescript-eslint/no-restricted-types': ['error', {
+                types: {
+                    unknown: 'Use a specific type.',
+                },
+            }],
+        '@typescript-eslint/no-shadow': ['error'],
+        '@typescript-eslint/no-unsafe-function-type': 'error',
+        '@typescript-eslint/no-unused-vars': 'error',
+        '@typescript-eslint/no-wrapper-object-types': 'error',
+        '@typescript-eslint/strict-boolean-expressions': ['warn', {
+                allowString: false, allowNumber: false,
+            }],
+        '@stylistic/ts/type-annotation-spacing': ['warn', {
+                before: false,
+                after: true,
+                overrides: {
+                    arrow: {
+                        before: true,
+                        after: true,
+                    },
+                },
+            }],
+    },
 };
-
 /**
  * Merge in any extensions' config.
  */
-let mergedConfig = [ BASE_CONFIG, TS_CONFIG ];
+let mergedConfig = [BASE_CONFIG, TS_CONFIG];
 try {
-	mergedConfig = getConfig( mergedConfig );
-} catch ( e ) {
-	console.debug( e );
-	// JS Boilerplate is not installed.
+    mergedConfig = getConfig(mergedConfig);
+}
+catch (e) {
+    console.debug(e);
+    // JS Boilerplate is not installed.
 }
-
 export default [
-	...fixupConfigRules( flatCompat.extends( 'plugin:@wordpress/eslint-plugin/recommended-with-formatting' ) ),
-	...fixupConfigRules( flatCompat.extends( 'plugin:deprecation/recommended' ) ),
-	...mergedConfig,
+    ...securityPlugin.configs.recommended,
+    ...fixupConfigRules(flatCompat.extends('plugin:@wordpress/eslint-plugin/recommended-with-formatting')),
+    ...fixupConfigRules(flatCompat.extends('plugin:deprecation/recommended')),
+    ...mergedConfig,
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lipemat/eslint-config",
-  "version": "4.0.5",
+  "version": "5.0.0-beta.2",
   "license": "MIT",
   "description": "Eslint configuration for all @lipemat packages",
   "engines": {
@@ -8,9 +8,12 @@
   },
   "type": "module",
   "main": "index.js",
+  "types": "types",
   "files": [
     "index.js",
-    "helpers/"
+    "helpers/**/*.js",
+    "plugins/**/*.js",
+    "types"
   ],
   "repository": {
     "type": "git",
@@ -21,16 +24,21 @@
   },
   "homepage": "https://github.com/lipemat/eslint-config#readme",
   "scripts": {
-    "test": "lipemat-js-boilerplate test"
+    "build": "tsc --project ./plugins --declaration --declarationDir types",
+    "prepublishOnly": "yarn run build",
+    "test": "lipemat-js-boilerplate test",
+    "validate-ts": "tsc --project ./plugins --noEmit",
+    "watch": "tsc --project ./plugins --watch --inlineSourceMap"
   },
   "dependencies": {
     "@eslint/compat": "^1.2.4",
     "@eslint/eslintrc": "^3.2.0",
-    "@lipemat/js-boilerplate": "^10.13.1",
+    "@lipemat/js-boilerplate": "^10.14.1",
     "@stylistic/eslint-plugin-ts": "^2.12.1",
     "@types/eslint": "^9",
-    "@typescript-eslint/eslint-plugin": "^8.18.0",
-    "@typescript-eslint/parser": "^8.18.0",
+    "@typescript-eslint/eslint-plugin": "^8.40.0",
+    "@typescript-eslint/parser": "^8.40.0",
+    "@typescript-eslint/utils": "^8.40.0",
     "@wordpress/eslint-plugin": "^22.0.0",
     "eslint": "^9",
     "eslint-plugin-deprecation": "^3",
@@ -41,11 +49,18 @@
   "devDependencies": {
     "@lipemat/js-boilerplate-svelte": "^2.0.0",
     "@types/jest": "^29.5.3",
+    "@types/jquery": "^3.5.16",
     "@types/node": "^20",
+    "@typescript-eslint/rule-tester": "^8.40.0",
+    "@typescript-eslint/types": "^8.40.0",
+    "dompurify": "^3.2.6",
     "execa": "^5.1.1",
     "jest": "^29",
     "jest-runner-eslint": "^2.2.1",
-    "typescript": "^5.7.2"
+    "typescript": "5.8.3"
+  },
+  "peerDependencies": {
+    "typescript": "^5.8.3"
   },
   "resolutions": {
     "@babel/runtime": "^7.27.0"

package/plugins/security/index.js

@@ -0,0 +1,51 @@
+import dangerouslySetInnerHtml from './rules/dangerously-set-inner-html.js';
+import htmlExecutingAssignment from './rules/html-executing-assignment.js';
+import htmlExecutingFunction from './rules/html-executing-function.js';
+import htmlSinks from './rules/html-sinks.js';
+import htmlStringConcat from './rules/html-string-concat.js';
+import jqueryExecuting from './rules/jquery-executing.js';
+import vulnerableTagStripping from './rules/vulnerable-tag-stripping.js';
+import windowEscaping from './rules/window-escaping.js';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+const pkg = JSON.parse(readFileSync(resolve('./package.json'), 'utf8'));
+const plugin = {
+    meta: {
+        name: pkg.name,
+        version: pkg.version,
+    },
+    rules: {
+        'dangerously-set-inner-html': dangerouslySetInnerHtml,
+        'html-executing-assignment': htmlExecutingAssignment,
+        'html-executing-function': htmlExecutingFunction,
+        'html-sinks': htmlSinks,
+        'html-string-concat': htmlStringConcat,
+        'jquery-executing': jqueryExecuting,
+        'vulnerable-tag-stripping': vulnerableTagStripping,
+        'window-escaping': windowEscaping,
+    },
+    configs: {
+        recommended: [],
+    },
+};
+// Freeze the plugin to prevent modifications and use the plugin within.
+plugin.configs = Object.freeze({
+    recommended: [
+        {
+            plugins: {
+                '@lipemat/security': plugin,
+            },
+            rules: {
+                '@lipemat/security/dangerously-set-inner-html': 'error',
+                '@lipemat/security/html-executing-assignment': 'error',
+                '@lipemat/security/html-executing-function': 'error',
+                '@lipemat/security/html-sinks': 'error',
+                '@lipemat/security/html-string-concat': 'error',
+                '@lipemat/security/jquery-executing': 'error',
+                '@lipemat/security/vulnerable-tag-stripping': 'error',
+                '@lipemat/security/window-escaping': 'error',
+            },
+        },
+    ],
+});
+export default plugin;

package/plugins/security/rules/dangerously-set-inner-html.js

@@ -0,0 +1,62 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { isSanitized } from '../utils/shared.js';
+function isDangerouslySetInnerHTML(node) {
+    return ('JSXAttribute' === node.type &&
+        'dangerouslySetInnerHTML' === node.name.name);
+}
+function getDangerouslySetInnerHTMLValue(node) {
+    // Expecting value like: {{ __html: expr }}
+    const val = node.value;
+    if (null === val) {
+        return null; // No value provided
+    }
+    if (AST_NODE_TYPES.JSXExpressionContainer !== val.type) {
+        return null;
+    }
+    const expr = val.expression;
+    if (AST_NODE_TYPES.ObjectExpression !== expr.type) {
+        return null;
+    }
+    const htmlProp = expr.properties.find(p => (AST_NODE_TYPES.Property === p.type &&
+        ((AST_NODE_TYPES.Identifier === p.key.type && '__html' === p.key.name) ||
+            (AST_NODE_TYPES.Literal === p.key.type && '__html' === p.key.value))));
+    if (undefined !== htmlProp && 'value' in htmlProp) {
+        return htmlProp.value;
+    }
+    return null;
+}
+const plugin = {
+    defaultOptions: [],
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            description: 'Disallow using unsanitized values in dangerouslySetInnerHTML',
+        },
+        messages: {
+            dangerousInnerHtml: 'Any HTML passed to `dangerouslySetInnerHTML` gets executed. Please make sure it\'s properly escaped.',
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            JSXAttribute(node) {
+                if (!isDangerouslySetInnerHTML(node)) {
+                    return;
+                }
+                const htmlValue = getDangerouslySetInnerHTMLValue(node);
+                if (null === htmlValue || isSanitized(htmlValue)) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'dangerousInnerHtml',
+                    fix: (fixer) => {
+                        return fixer.replaceText(node, `dangerouslySetInnerHTML={{__html: DOMPurify.sanitize(${context.sourceCode.getText(htmlValue)})}}`);
+                    },
+                });
+            },
+        };
+    },
+};
+export default plugin;

package/plugins/security/rules/html-executing-assignment.js

@@ -0,0 +1,67 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { isSanitized } from '../utils/shared.js';
+const UNSAFE_PROPERTIES = [
+    'innerHTML', 'outerHTML',
+];
+function isUnsafeProperty(propertyName) {
+    return UNSAFE_PROPERTIES.includes(propertyName);
+}
+const plugin = {
+    defaultOptions: [],
+    meta: {
+        docs: {
+            description: 'Disallow using unsanitized values in HTML executing property assignments',
+        },
+        fixable: 'code',
+        hasSuggestions: true,
+        messages: {
+            executed: 'Any HTML used with `{{propertyName}}` gets executed. Make sure it\'s properly escaped.',
+            // Suggestions
+            domPurify: 'Wrap the argument with a `DOMPurify.sanitize()` call.',
+            sanitize: 'Wrap the argument with a `sanitize()` call.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    create(context) {
+        return {
+            AssignmentExpression(node) {
+                // Handle element.innerHTML = value and element.outerHTML = value
+                if (AST_NODE_TYPES.MemberExpression !== node.left.type || !('name' in node.left.property)) {
+                    return;
+                }
+                const propertyName = node.left.property.name;
+                if (!isUnsafeProperty(propertyName)) {
+                    return;
+                }
+                const value = node.right;
+                if (!isSanitized(value)) {
+                    context.report({
+                        node,
+                        messageId: 'executed',
+                        data: {
+                            propertyName,
+                        },
+                        suggest: [
+                            {
+                                messageId: 'domPurify',
+                                fix: (fixer) => {
+                                    const valueText = context.sourceCode.getText(value);
+                                    return fixer.replaceText(value, `DOMPurify.sanitize(${valueText})`);
+                                },
+                            },
+                            {
+                                messageId: 'sanitize',
+                                fix: (fixer) => {
+                                    const valueText = context.sourceCode.getText(value);
+                                    return fixer.replaceText(value, `sanitize(${valueText})`);
+                                },
+                            },
+                        ],
+                    });
+                }
+            },
+        };
+    },
+};
+export default plugin;

package/plugins/security/rules/html-executing-function.js

@@ -0,0 +1,129 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { isDomElementType, isSanitized } from '../utils/shared.js';
+import { isJQueryCall } from './jquery-executing.js';
+const DOCUMENT_METHODS = [
+    'document.write',
+    'document.writeln',
+];
+const SECOND_ARG_METHODS = new Set([
+    'insertAdjacentHTML',
+    'setAttribute',
+]);
+const UNSAFE_METHODS = [
+    'after', 'append', 'before', 'insertAdjacentHTML', 'prepend', 'replaceWith', 'setAttribute',
+];
+function isDocumentMethod(methodName) {
+    return DOCUMENT_METHODS.includes(methodName);
+}
+function isUnsafeMethod(methodName) {
+    return UNSAFE_METHODS.includes(methodName);
+}
+function isSecondArgMethod(methodName) {
+    return SECOND_ARG_METHODS.has(methodName);
+}
+function getDocumentCall(node) {
+    let calleeName = '';
+    if (AST_NODE_TYPES.Identifier === node.callee.type) {
+        calleeName = node.callee.name;
+    }
+    else if (AST_NODE_TYPES.MemberExpression === node.callee.type) {
+        if ('name' in node.callee.object) {
+            calleeName = node.callee.object.name;
+            if ('name' in node.callee.property) {
+                calleeName += '.' + node.callee.property.name;
+            }
+        }
+        else if ('name' in node.callee.property) {
+            calleeName = node.callee.property.name;
+        }
+    }
+    if (isDocumentMethod(calleeName)) {
+        return calleeName;
+    }
+    return null;
+}
+function getElementMethodCall(node) {
+    // Detect element.method(userInput) calls
+    if (AST_NODE_TYPES.MemberExpression !== node.callee.type || !('name' in node.callee.property)) {
+        return null;
+    }
+    const methodName = node.callee.property.name;
+    if (!isUnsafeMethod(methodName)) {
+        return null;
+    }
+    if (isJQueryCall(node)) {
+        return null; // Handled in jquery-executing rule
+    }
+    // This is a generic element method call, not jQuery specific
+    return methodName;
+}
+const plugin = {
+    defaultOptions: [],
+    meta: {
+        docs: {
+            description: 'Disallow using unsanitized values in functions that execute HTML',
+        },
+        fixable: 'code',
+        hasSuggestions: true,
+        messages: {
+            'document.write': 'Any HTML used with `document.write` gets executed. Make sure it\'s properly escaped.',
+            'document.writeln': 'Any HTML used with `document.writeln` gets executed. Make sure it\'s properly escaped.',
+            after: 'Any HTML used with `after` gets executed. Make sure it\'s properly escaped.',
+            append: 'Any HTML used with `append` gets executed. Make sure it\'s properly escaped.',
+            before: 'Any HTML used with `before` gets executed. Make sure it\'s properly escaped.',
+            insertAdjacentHTML: 'Any HTML used with `insertAdjacentHTML` gets executed. Make sure it\'s properly escaped.',
+            prepend: 'Any HTML used with `prepend` gets executed. Make sure it\'s properly escaped.',
+            replaceWith: 'Any HTML used with `replaceWith` gets executed. Make sure it\'s properly escaped.',
+            setAttribute: 'Any HTML used with `setAttribute` can lead to XSS. Make sure it\'s properly escaped.',
+            // Suggestions
+            domPurify: 'Wrap the argument with a `DOMPurify.sanitize()` call.',
+            sanitize: 'Wrap the argument with a `sanitize()` call.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                let method;
+                const documentMethod = getDocumentCall(node);
+                if (null !== documentMethod) {
+                    method = documentMethod;
+                }
+                else {
+                    method = getElementMethodCall(node);
+                    if (null === method) {
+                        return;
+                    }
+                }
+                let arg = node.arguments[0];
+                if (isSecondArgMethod(method)) {
+                    arg = node.arguments[1];
+                }
+                if (!isSanitized(arg) && !isDomElementType(arg, context)) {
+                    context.report({
+                        node,
+                        messageId: method,
+                        suggest: [
+                            {
+                                messageId: 'domPurify',
+                                fix: (fixer) => {
+                                    const argText = context.sourceCode.getText(arg);
+                                    return fixer.replaceText(arg, `DOMPurify.sanitize(${argText})`);
+                                },
+                            },
+                            {
+                                messageId: 'sanitize',
+                                fix: (fixer) => {
+                                    const argText = context.sourceCode.getText(arg);
+                                    return fixer.replaceText(arg, `sanitize(${argText})`);
+                                },
+                            },
+                        ],
+                    });
+                }
+            },
+        };
+    },
+};
+export default plugin;