.eslintrc.js

const confusingBrowserGlobals = require('confusing-browser-globals');

const braceStyle = ['error', '1tbs', { allowSingleLine: true }];
const commaSpacing = [
	'error',
	{
		after:  true,
		before: false,
	},
];
const funcCallSpacing = ['error', 'never'];
const indent = [
	'error',
	'tab',
	{
		ArrayExpression:     1,
		CallExpression:      { arguments: 1 },
		FunctionDeclaration: {
			body:       1,
			parameters: 1,
		},
		ImportDeclaration:      1,
		MemberExpression:       1,
		ObjectExpression:       1,
		SwitchCase:             1,
		VariableDeclarator:     'first',
		flatTernaryExpressions: true,
		ignoreComments:         false,
		ignoredNodes:           [
			'JSXElement',
			'JSXElement > *',
			'JSXAttribute',
			'JSXIdentifier',
			'JSXNamespacedName',
			'JSXMemberExpression',
			'JSXSpreadAttribute',
			'JSXExpressionContainer',
			'JSXOpeningElement',
			'JSXClosingElement',
			'JSXText',
			'JSXEmptyExpression',
			'JSXSpreadChild',
		],
		outerIIFEBody: 1,
	},
];
const keywordSpacing = [
	'error',
	{
		after:  true,
		before: true,
	},
];
const noEmptyFunction = ['error', { allow: ['arrowFunctions', 'methods'] }];
const linesBetweenClassMembers = ['error', 'never'];
const noExtraParens = [
	'error',
	'all',
	{
		conditionalAssign:           false,
		enforceForArrowConditionals: false,
		ignoreJSX:                   'multi-line',
		nestedBinaryExpressions:     false,
		returnAssign:                false,
	},
];
const noUnusedExpressions = [
	'error',
	{
		allowShortCircuit:    false,
		allowTaggedTemplates: false,
		allowTernary:         false,
	},
];
const noUnusedVars = [
	'error',
	{
		vars:               'all',
		args:               'after-used',
		ignoreRestSiblings: true,
	},
];
const noUseBeforeDefine = [
	'error',
	{
		functions: true,
		classes:   true,
		variables: true,
	},
];
const quotes = ['error', 'single'];
const semi = ['error', 'always'];
const spaceBeforeFunctionParen = [
	'error',
	{
		anonymous:  'never',
		asyncArrow: 'always',
		named:      'never',
	},
];

module.exports = {
	env: {
		es6:  true,
		node: true,
	},
	globals:       { process: 'readonly' },
	parser:        'babel-eslint',
	parserOptions: { ecmaFeatures: { jsx: true } },
	plugins:       [
		'config-files',
		'eslint-comments',
		'fp',
		'import',
		'jsx-a11y',
		'node',
		'optimize-regex',
		'promise',
		'react',
		'react-hooks',
		'unicorn',
	],
	settings: {
		'import/extensions': [
			'.node.mjs',
			'.web.mjs',
			'.mjs',
			'.node.js',
			'.web.js',
			'.js',
			'.ts',
			'.tsx',
			'.json',
			'.node.jsx',
			'.web.jsx',
			'.jsx',
			'.node',
		],
		'import/resolver': {
			node: {
				paths:      ['src'],
				extensions: [
					'.node.mjs',
					'.web.mjs',
					'.mjs',
					'.node.js',
					'.web.js',
					'.js',
					'.node.ts',
					'.web.ts',
					'.ts',
					'.node.tsx',
					'.web.tsx',
					'.tsx',
					'.json',
					'.node.jsx',
					'.web.jsx',
					'.jsx',
					'.node',
				],
			},
		},
		'react': { version: 'detect' },
	},
	rules: {
		'accessor-pairs':        'off',
		'array-bracket-newline': ['error', { multiline: true }],
		'array-bracket-spacing': ['error', 'never'],
		'array-callback-return': 'error',
		'array-element-newline': [
			'error',
			{
				minItems:  4,
				multiline: true,
			},
		],
		'arrow-body-style': ['error', 'as-needed', { requireReturnForObjectLiteral: false }],
		'arrow-parens':     ['error', 'always'],
		'arrow-spacing':    [
			'error',
			{
				before: true,
				after:  true,
			},
		],
		'block-scoped-var':       'error',
		'block-spacing':          ['error', 'always'],
		'brace-style':            braceStyle,
		'camelcase':              'off',
		'capitalized-comments':   'off',
		'class-methods-use-this': 'warn',
		'comma-dangle':           [
			'error',
			{
				arrays:    'always-multiline',
				exports:   'always-multiline',
				functions: 'never',
				imports:   'always-multiline',
				objects:   'always-multiline',
			},
		],
		'comma-spacing':                         commaSpacing,
		'comma-style':                           ['error', 'last'],
		'complexity':                            'off',
		'computed-property-spacing':             ['error', 'never'],
		'config-files/order-options':            'error',
		'consistent-return':                     'off',
		'consistent-this':                       'off',
		'constructor-super':                     'error',
		'curly':                                 ['error', 'all'],
		'default-case':                          'off',
		'default-case-last':                     'error',
		'default-param-last':                    'warn',
		'dot-location':                          ['error', 'property'],
		'dot-notation':                          'error',
		'eol-last':                              ['error', 'always'],
		'eqeqeq':                                ['error', 'always'],
		'eslint-comments/disable-enable-pair':   ['error', { allowWholeFile: true }],
		'eslint-comments/no-aggregating-enable': 'error',
		'eslint-comments/no-duplicate-disable':  'error',
		'eslint-comments/no-restricted-disable': 'off',
		'eslint-comments/no-unlimited-disable':  'error',
		'eslint-comments/no-unused-disable':     'error',
		'eslint-comments/no-unused-enable':      'error',
		'eslint-comments/no-use':                'off',
		'eslint-comments/require-description':   'error',
		'for-direction':                         'off',
		'fp/no-arguments':                       'error',
		'fp/no-class':                           'warn',
		'fp/no-delete':                          'error',
		'fp/no-events':                          'warn',
		'fp/no-get-set':                         'error',
		'fp/no-let':                             'warn',
		'fp/no-loops':                           'error',
		'fp/no-mutating-assign':                 'error',
		'fp/no-mutating-methods':                'error',
		'fp/no-mutation':                        ['warn', { commonjs: true }],
		'fp/no-nil':                             'off',
		'fp/no-proxy':                           'error',
		'fp/no-rest-parameters':                 'off',
		'fp/no-this':                            'error',
		'fp/no-throw':                           'off',
		'fp/no-unused-expression':               'off',
		'fp/no-valueof-field':                   'warn',
		'func-call-spacing':                     funcCallSpacing,
		'func-name-matching':                    ['error', 'always'],
		'func-names':                            ['error', 'as-needed'],
		'func-style':                            ['error', 'declaration', { allowArrowFunctions: true }],
		'function-call-argument-newline':        ['error', 'consistent'],
		'function-paren-newline':                ['error', 'multiline-arguments'],
		'generator-star-spacing':                [
			'error',
			{
				before: false,
				after:  true,
			},
		],
		'getter-return':                   'off',
		'grouped-accessor-pairs':          ['error', 'getBeforeSet'],
		'guard-for-in':                    'off',
		'id-denylist':                     'off',
		'id-length':                       'off',
		'id-match':                        'off',
		'implicit-arrow-linebreak':        ['error', 'beside'],
		'import/default':                  'error',
		'import/dynamic-import-chunkname': 'off',
		'import/export':                   'error',
		'import/exports-last':             'off',
		'import/extensions':               [
			'error',
			'always',
			{
				'node.mjs': 'never',
				'web.mjs':  'never',
				'mjs':      'never',
				'node.js':  'never',
				'web.js':   'never',
				'js':       'never',
				'ts':       'never',
				'tsx':      'never',
				'json':     'always',
				'node.jsx': 'never',
				'web.jsx':  'never',
				'jsx':      'never',
				'node':     'never',
			},
		],
		'import/first':                       'error',
		'import/group-exports':               'off',
		'import/max-dependencies':            'off',
		'import/named':                       'error',
		'import/namespace':                   'error',
		'import/newline-after-import':        'error',
		'import/no-absolute-path':            'error',
		'import/no-amd':                      'error',
		'import/no-anonymous-default-export': 'off',
		'import/no-commonjs':                 'error',
		'import/no-cycle':                    'error',
		'import/no-default-export':           'off',
		'import/no-deprecated':               'warn',
		'import/no-duplicates':               'error',
		'import/no-dynamic-require':          'error',
		'import/no-extraneous-dependencies':  [
			'error',
			{
				devDependencies: [
					'**/*{.,_}{test,spec}.{js,jsx}', // tests where the extension or filename suffix denotes that it is a test
					'**/Gruntfile{,.js}', // grunt config
					'**/__mocks__/**', // jest pattern
					'**/__tests__/**', // jest pattern
					'**/gulpfile.*.js', // gulp config
					'**/gulpfile.js', // gulp config
					'**/jest.config.js', // jest config
					'**/jest.setup.js', // jest setup
					'**/protractor.conf.*.js', // protractor config
					'**/protractor.conf.js', // protractor config
					'**/rollup.config.*.js', // rollup config
					'**/rollup.config.js', // rollup config
					'**/vue.config.js', // vue-cli config
					'**/webpack.config.*.js', // webpack config
					'**/webpack.config.js', // webpack config
					'spec/**', // mocha, rspec-like pattern
					'test-*.{js,jsx}', // repos with multiple top-level test files
					'test.{js,jsx}', // repos with a single test file
					'test/**', // tape, common npm pattern
					'tests/**', // also common npm pattern
				],
				optionalDependencies: false,
			},
		],
		'import/no-import-module-exports':   'off',
		'import/no-internal-modules':        'off',
		'import/no-mutable-exports':         'error',
		'import/no-named-as-default':        'error',
		'import/no-named-as-default-member': 'error',
		'import/no-named-default':           'error',
		'import/no-named-export':            'off',
		'import/no-namespace':               'off',
		'import/no-nodejs-modules':          'off',
		'import/no-relative-packages':       'error',
		'import/no-relative-parent-imports': 'off',
		'import/no-restricted-paths':        'off',
		'import/no-self-import':             'error',
		'import/no-unassigned-import':       'off',
		'import/no-unresolved':              ['error', { commonjs: true }],
		'import/no-unused-modules':          'off',
		'import/no-useless-path-segments':   'error',
		'import/no-webpack-loader-syntax':   'error',
		'import/order':                      [
			'error',
			{
				'newlines-between': 'always',
				'alphabetize':      { order: 'asc' },
				'groups':           [
					'builtin',
					'external',
					'internal',
					'parent',
					'sibling',
					'index',
				],
			},
		],
		'import/prefer-default-export': 'off',
		'import/unambiguous':           'off',
		'indent':                       indent,
		'init-declarations':            'off',
		'jsx-a11y/alt-text':            'warn',
		'jsx-a11y/anchor-has-content':  ['warn', { components: ['Link'] }],
		'jsx-a11y/anchor-is-valid':     [
			'error',
			{
				aspects:     ['noHref', 'invalidHref', 'preferButton'],
				components:  ['Link'],
				specialLink: ['to'],
			},
		],
		'jsx-a11y/aria-activedescendant-has-tabindex': 'warn',
		'jsx-a11y/aria-props':                         'error',
		'jsx-a11y/aria-proptypes':                     'error',
		'jsx-a11y/aria-role':                          ['error', { ignoreNonDom: false }],
		'jsx-a11y/aria-unsupported-elements':          'error',
		'jsx-a11y/autocomplete-valid':                 'error',
		'jsx-a11y/click-events-have-key-events':       'warn',
		'jsx-a11y/control-has-associated-label':       'off',
		'jsx-a11y/heading-has-content':                'error',
		'jsx-a11y/html-has-lang':                      'warn',
		'jsx-a11y/iframe-has-title':                   'error',
		'jsx-a11y/img-redundant-alt':                  'warn',
		'jsx-a11y/interactive-supports-focus':         'warn',
		'jsx-a11y/label-has-associated-control':       [
			'warn',
			{
				assert:            'either',
				controlComponents: [],
				depth:             25,
				labelAttributes:   [],
				labelComponents:   [],
			},
		],
		'jsx-a11y/lang':              'error',
		'jsx-a11y/media-has-caption': [
			'warn',
			{
				audio: [],
				video: [],
				track: [],
			},
		],
		'jsx-a11y/mouse-events-have-key-events':                  'warn',
		'jsx-a11y/no-access-key':                                 'error',
		'jsx-a11y/no-autofocus':                                  'warn',
		'jsx-a11y/no-distracting-elements':                       'error',
		'jsx-a11y/no-interactive-element-to-noninteractive-role': ['warn', { tr: ['none', 'presentation'] }],
		'jsx-a11y/no-noninteractive-element-interactions':        'warn',
		'jsx-a11y/no-noninteractive-element-to-interactive-role': 'warn',
		'jsx-a11y/no-noninteractive-tabindex':                    'error',
		'jsx-a11y/no-onchange':                                   'warn',
		'jsx-a11y/no-redundant-roles':                            'error',
		'jsx-a11y/no-static-element-interactions':                'warn',
		'jsx-a11y/role-has-required-aria-props':                  'error',
		'jsx-a11y/role-supports-aria-props':                      'error',
		'jsx-a11y/scope':                                         'error',
		'jsx-a11y/tabindex-no-positive':                          'error',
		'jsx-quotes':                                             ['error', 'prefer-double'],
		'key-spacing':                                            [
			'error',
			{
				afterColon:  true,
				align:       'value',
				beforeColon: false,
				mode:        'strict',
			},
		],
		'keyword-spacing':       keywordSpacing,
		'line-comment-position': 'off',
		'linebreak-style':       ['error', 'unix'],
		'lines-around-comment':  [
			'error',
			{
				afterBlockComment:  true,
				afterLineComment:   false,
				allowArrayEnd:      true,
				allowArrayStart:    true,
				allowBlockEnd:      true,
				allowBlockStart:    true,
				allowClassEnd:      true,
				allowClassStart:    true,
				allowObjectEnd:     true,
				allowObjectStart:   true,
				beforeBlockComment: true,
				beforeLineComment:  false,
			},
		],
		'lines-between-class-members': linesBetweenClassMembers,
		'max-classes-per-file':        'off',
		'max-depth':                   'off',
		'max-len':                     'off',
		'max-lines':                   'off',
		'max-lines-per-function':      'off',
		'max-nested-callbacks':        'off',
		'max-params':                  'off',
		'max-statements':              'off',
		'max-statements-per-line':     ['error', { max: 1 }],
		'multiline-comment-style':     ['error', 'starred-block'],
		'multiline-ternary':           ['error', 'always-multiline'],
		'new-cap':                     [
			'error',
			{
				capIsNew:           false,
				capIsNewExceptions: ['Immutable.Map', 'Immutable.Set', 'Immutable.List'],
				newIsCap:           true,
				newIsCapExceptions: [],
			},
		],
		'new-parens':                'error',
		'newline-per-chained-call':  'error',
		'no-alert':                  'error',
		'no-array-constructor':      'error',
		'no-async-promise-executor': 'error',
		'no-await-in-loop':          'error',
		'no-bitwise':                'error',
		'no-caller':                 'error',
		'no-case-declarations':      'off',
		'no-class-assign':           'error',
		'no-compare-neg-zero':       'error',
		'no-cond-assign':            ['error', 'always'],
		'no-confusing-arrow':        ['error', { allowParens: true }],
		'no-console':                ['error'],
		'no-const-assign':           'error',
		'no-constant-condition':     'error',
		'no-constructor-return':     'error',
		'no-continue':               'off',
		'no-control-regex':          'warn',
		'no-debugger':               'error',
		'no-delete-var':             'error',
		'no-div-regex':              'error',
		'no-dupe-args':              'error',
		'no-dupe-class-members':     'error',
		'no-dupe-else-if':           'error',
		'no-dupe-keys':              'error',
		'no-duplicate-case':         'error',
		'no-duplicate-imports':      'error',
		'no-else-return':            ['error', { allowElseIf: false }],
		'no-empty':                  ['error', { allowEmptyCatch: true }],
		'no-empty-character-class':  'error',
		'no-empty-function':         noEmptyFunction,
		'no-empty-pattern':          'error',
		'no-eq-null':                'error',
		'no-eval':                   'error',
		'no-ex-assign':              'error',
		'no-extend-native':          'error',
		'no-extra-bind':             'error',
		'no-extra-boolean-cast':     'error',
		'no-extra-label':            'error',
		'no-extra-parens':           noExtraParens,
		'no-extra-semi':             'error',
		'no-fallthrough':            'error',
		'no-floating-decimal':       'error',
		'no-func-assign':            'error',
		'no-global-assign':          'error',
		'no-implicit-coercion':      'error',
		'no-implicit-globals':       'off',
		'no-implied-eval':           'error',
		'no-import-assign':          'error',
		'no-inline-comments':        'off',
		'no-inner-declarations':     ['error', 'both'],
		'no-invalid-regexp':         'error',
		'no-invalid-this':           'error',
		'no-irregular-whitespace':   [
			'error',
			{
				skipComments:  true,
				skipRegExps:   true,
				skipStrings:   true,
				skipTemplates: true,
			},
		],
		'no-iterator':                   'error',
		'no-label-var':                  'error',
		'no-labels':                     'error',
		'no-lone-blocks':                'error',
		'no-lonely-if':                  'error',
		'no-loop-func':                  'error',
		'no-loss-of-precision':          'error',
		'no-magic-numbers':              'off',
		'no-misleading-character-class': 'error',
		'no-mixed-operators':            ['error', { allowSamePrecedence: false }],
		'no-mixed-spaces-and-tabs':      ['error', 'smart-tabs'],
		'no-multi-assign':               'error',
		'no-multi-spaces':               ['error', { ignoreEOLComments: true }],
		'no-multi-str':                  'error',
		'no-multiple-empty-lines':       [
			'error',
			{
				max:    1,
				maxBOF: 0,
				maxEOF: 0,
			},
		],
		'no-negated-condition':       'off',
		'no-nested-ternary':          'off',
		'no-new':                     'error',
		'no-new-func':                'error',
		'no-new-object':              'error',
		'no-new-symbol':              'error',
		'no-new-wrappers':            'error',
		'no-nonoctal-decimal-escape': 'error',
		'no-obj-calls':               'error',
		'no-octal':                   'error',
		'no-octal-escape':            'error',
		'no-param-reassign':          [
			'error',
			{
				props:                          true,
				ignorePropertyModificationsFor: [
					'acc', // for reduce accumulators
					'accumulator', // for reduce accumulators
					'e', // for e.returnvalue
					'ctx', // for Koa routing
					'req', // for Express requests
					'request', // for Express requests
					'res', // for Express responses
					'response', // for Express responses
					'$scope', // for Angular 1 scopes
					'staticContext', // for ReactRouter context
				],
			},
		],
		'no-plusplus':                ['error', { allowForLoopAfterthoughts: true }],
		'no-promise-executor-return': 'error',
		'no-proto':                   'error',
		'no-prototype-builtins':      'error',
		'no-redeclare':               'error',
		'no-regex-spaces':            'error',
		'no-restricted-exports':      'off',
		'no-restricted-globals':      ['error', 'isFinite', 'isNaN'].concat(confusingBrowserGlobals),
		'no-restricted-imports':      'off',
		'no-restricted-properties':   [
			'error',
			{
				object:   'arguments',
				property: 'callee',
				message:  'arguments.callee is deprecated',
			},
			{
				object:   'global',
				property: 'isFinite',
				message:  'Please use Number.isFinite instead',
			},
			{
				object:   'self',
				property: 'isFinite',
				message:  'Please use Number.isFinite instead',
			},
			{
				object:   'window',
				property: 'isFinite',
				message:  'Please use Number.isFinite instead',
			},
			{
				object:   'global',
				property: 'isNaN',
				message:  'Please use Number.isNaN instead',
			},
			{
				object:   'self',
				property: 'isNaN',
				message:  'Please use Number.isNaN instead',
			},
			{
				object:   'window',
				property: 'isNaN',
				message:  'Please use Number.isNaN instead',
			},
			{
				property: '__defineGetter__',
				message:  'Please use Object.defineProperty instead.',
			},
			{
				property: '__defineSetter__',
				message:  'Please use Object.defineProperty instead.',
			},
		],
		'no-restricted-syntax': [
			'error',
			{
				selector: 'ForInStatement',
				message:  'for..in loops iterate over the entire prototype chain, which is virtually never what you want. Use Object.{keys,values,entries}, and iterate over the resulting array.',
			},
			{
				selector: 'ForOfStatement',
				message:  'iterators/generators require regenerator-runtime, which is too heavyweight for this guide to allow them. Separately, loops should be avoided in favor of array iterations.',
			},
			{
				selector: 'LabeledStatement',
				message:  'Labels are a form of GOTO; using them makes code confusing and hard to maintain and understand.',
			},
			{
				selector: 'WithStatement',
				message:  '`with` is disallowed in strict mode because it makes code impossible to predict and optimize.',
			},
		],
		'no-return-assign':            ['error', 'always'],
		'no-return-await':             'error',
		'no-script-url':               'error',
		'no-self-assign':              'error',
		'no-self-compare':             'error',
		'no-sequences':                'error',
		'no-setter-return':            'error',
		'no-shadow':                   'warn',
		'no-shadow-restricted-names':  'error',
		'no-sparse-arrays':            'error',
		'no-tabs':                     ['error', { allowIndentationTabs: true }],
		'no-template-curly-in-string': 'error',
		'no-ternary':                  'off',
		'no-this-before-super':        'error',
		'no-throw-literal':            'error',
		'no-trailing-spaces':          [
			'error',
			{
				ignoreComments: false,
				skipBlankLines: false,
			},
		],
		'no-undef':                                   'error',
		'no-undef-init':                              'error',
		'no-undefined':                               'off',
		'no-underscore-dangle':                       'off',
		'no-unexpected-multiline':                    'error',
		'no-unmodified-loop-condition':               'error',
		'no-unneeded-ternary':                        ['error', { defaultAssignment: false }],
		'no-unreachable':                             'error',
		'no-unreachable-loop':                        'error',
		'no-unsafe-finally':                          'error',
		'no-unsafe-negation':                         'error',
		'no-unsafe-optional-chaining':                'error',
		'no-unused-expressions':                      noUnusedExpressions,
		'no-unused-labels':                           'error',
		'no-unused-vars':                             noUnusedVars,
		'no-use-before-define':                       noUseBeforeDefine,
		'no-useless-backreference':                   'error',
		'no-useless-call':                            'error',
		'no-useless-catch':                           'error',
		'no-useless-computed-key':                    'error',
		'no-useless-concat':                          'error',
		'no-useless-constructor':                     'error',
		'no-useless-escape':                          'error',
		'no-useless-rename':                          'error',
		'no-useless-return':                          'error',
		'no-var':                                     'error',
		'no-void':                                    ['error', { allowAsStatement: true }],
		'no-warning-comments':                        'off',
		'no-whitespace-before-property':              'error',
		'no-with':                                    'error',
		'node/callback-return':                       'off',
		'node/exports-style':                         ['error', 'module.exports'],
		'node/file-extension-in-import':              'off',
		'node/global-require':                        'off',
		'node/handle-callback-err':                   'warn',
		'node/no-callback-literal':                   'error',
		'node/no-deprecated-api':                     'error',
		'node/no-exports-assign':                     'error',
		'node/no-extraneous-import':                  'off',
		'node/no-extraneous-require':                 'off',
		'node/no-missing-import':                     'off',
		'node/no-missing-require':                    'off',
		'node/no-mixed-requires':                     'off',
		'node/no-new-require':                        'off',
		'node/no-path-concat':                        'error',
		'node/no-process-env':                        'off',
		'node/no-process-exit':                       'off',
		'node/no-restricted-import':                  'off',
		'node/no-restricted-require':                 'off',
		'node/no-sync':                               'warn',
		'node/no-unpublished-bin':                    'off',
		'node/no-unpublished-import':                 'off',
		'node/no-unpublished-require':                'off',
		'node/no-unsupported-features/es-builtins':   'off',
		'node/no-unsupported-features/es-syntax':     'off',
		'node/no-unsupported-features/node-builtins': 'off',
		'node/prefer-global/buffer':                  'off',
		'node/prefer-global/console':                 'off',
		'node/prefer-global/process':                 'off',
		'node/prefer-global/text-decoder':            'off',
		'node/prefer-global/text-encoder':            'off',
		'node/prefer-global/url':                     'off',
		'node/prefer-global/url-search-params':       'off',
		'node/prefer-promises/dns':                   'off',
		'node/prefer-promises/fs':                    'off',
		'node/process-exit-as-throw':                 'error',
		'node/shebang':                               ['error', { convertPath: { 'src/**/*': ['^src/(.+?)$', 'lib/$1'] } }],
		'nonblock-statement-body-position':           'off',
		'object-curly-newline':                       [
			'error',
			{
				ExportDeclaration: 'always',
				ImportDeclaration: 'never',
				ObjectExpression:  { multiline: true },
				ObjectPattern:     { multiline: true },
			},
		],
		'object-curly-spacing': [
			'error',
			'always',
			{
				arraysInObjects:  true,
				objectsInObjects: true,
			},
		],
		'object-property-newline': 'error',
		'object-shorthand':        [
			'error',
			'always',
			{
				avoidExplicitReturnArrows: true,
				avoidQuotes:               true,
				ignoreConstructors:        false,
			},
		],
		'one-var':                         ['error', 'never'],
		'one-var-declaration-per-line':    ['error', 'always'],
		'operator-assignment':             ['error', 'always'],
		'operator-linebreak':              ['error', 'before', { overrides: { '=': 'none' } }],
		'optimize-regex/optimize-regex':   'error',
		'padded-blocks':                   ['error', 'never'],
		'padding-line-between-statements': [
			'error',
			// Padding After
			{
				blankLine: 'always',
				prev:      'cjs-import',
				next:      '*',
			},
			{
				blankLine: 'always',
				prev:      'directive',
				next:      '*',
			},

			// Padding Before
			{
				blankLine: 'always',
				prev:      '*',
				next:      'break',
			},
			{
				blankLine: 'always',
				prev:      '*',
				next:      'cjs-export',
			},
			{
				blankLine: 'always',
				prev:      '*',
				next:      'continue',
			},
			{
				blankLine: 'always',
				prev:      '*',
				next:      'export',
			},
			{
				blankLine: 'always',
				prev:      '*',
				next:      'return',
			},
			{
				blankLine: 'always',
				prev:      '*',
				next:      'throw',
			},

			// Padding Around
			{
				blankLine: 'always',
				prev:      'class',
				next:      '*',
			},
			{
				blankLine: 'always',
				prev:      '*',
				next:      'class',
			},
			{
				blankLine: 'always',
				prev:      'do',
				next:      '*',
			},
			{
				blankLine: 'always',
				prev:      '*',
				next:      'do',
			},
			{
				blankLine: 'always',
				prev:      'for',
				next:      '*',
			},
			{
				blankLine: 'always',
				prev:      '*',
				next:      'for',
			},
			{
				blankLine: 'always',
				prev:      'function',
				next:      '*',
			},
			{
				blankLine: 'always',
				prev:      '*',
				next:      'function',
			},
			{
				blankLine: 'always',
				prev:      'iife',
				next:      '*',
			},
			{
				blankLine: 'always',
				prev:      '*',
				next:      'iife',
			},
			{
				blankLine: 'always',
				prev:      'switch',
				next:      '*',
			},
			{
				blankLine: 'always',
				prev:      '*',
				next:      'switch',
			},
			{
				blankLine: 'always',
				prev:      'try',
				next:      '*',
			},
			{
				blankLine: 'always',
				prev:      '*',
				next:      'try',
			},
			{
				blankLine: 'always',
				prev:      'while',
				next:      '*',
			},
			{
				blankLine: 'always',
				prev:      '*',
				next:      'while',
			},

			// Never
			{
				blankLine: 'never',
				prev:      'case',
				next:      '*',
			},
			{
				blankLine: 'never',
				prev:      '*',
				next:      'case',
			},
			{
				blankLine: 'never',
				prev:      'default',
				next:      '*',
			},
			{
				blankLine: 'never',
				prev:      '*',
				next:      'default',
			},
		],
		'prefer-arrow-callback': [
			'error',
			{
				allowNamedFunctions: false,
				allowUnboundThis:    true,
			},
		],
		'prefer-const':         'error',
		'prefer-destructuring': [
			'error',
			{
				VariableDeclarator: {
					array:  false,
					object: true,
				},
				AssignmentExpression: {
					array:  false,
					object: false,
				},
			},
			{ enforceForRenamedProperties: false },
		],
		'prefer-exponentiation-operator':       'error',
		'prefer-named-capture-group':           'off',
		'prefer-numeric-literals':              'error',
		'prefer-object-spread':                 'error',
		'prefer-promise-reject-errors':         ['error', { allowEmptyReject: true }],
		'prefer-regex-literals':                'error',
		'prefer-rest-params':                   'error',
		'prefer-spread':                        'error',
		'prefer-template':                      'error',
		'promise/always-return':                'error',
		'promise/avoid-new':                    'off',
		'promise/catch-or-return':              'error',
		'promise/no-callback-in-promise':       'warn',
		'promise/no-native':                    'off',
		'promise/no-nesting':                   'warn',
		'promise/no-new-statics':               'error',
		'promise/no-promise-in-callback':       'warn',
		'promise/no-return-in-finally':         'error',
		'promise/no-return-wrap':               'error',
		'promise/param-names':                  'error',
		'promise/prefer-await-to-callbacks':    'off',
		'promise/prefer-await-to-then':         'error',
		'promise/valid-params':                 'error',
		'quote-props':                          ['error', 'consistent-as-needed'],
		'quotes':                               quotes,
		'radix':                                'error',
		'react-hooks/exhaustive-deps':          'error',
		'react-hooks/rules-of-hooks':           'error',
		'react/boolean-prop-naming':            'off',
		'react/button-has-type':                'error',
		'react/default-props-match-prop-types': ['error', { allowRequiredDefaults: true }],
		'react/destructuring-assignment':       ['error', 'always'],
		'react/display-name':                   ['error', { ignoreTranspilerName: false }],
		'react/forbid-component-props':         'off',
		'react/forbid-dom-props':               'off',
		'react/forbid-elements':                'off',
		'react/forbid-foreign-prop-types':      'off',
		'react/forbid-prop-types':              'off',
		'react/function-component-definition':  [
			'error',
			{
				namedComponents:   'arrow-function',
				unnamedComponents: 'arrow-function',
			},
		],
		'react/jsx-boolean-value':            ['error', 'never'],
		'react/jsx-child-element-spacing':    'off',
		'react/jsx-closing-bracket-location': ['error', 'line-aligned'],
		'react/jsx-closing-tag-location':     'error',
		'react/jsx-curly-brace-presence':     [
			'error',
			{
				props:    'never',
				children: 'never',
			},
		],
		'react/jsx-curly-newline': ['error', 'consistent'],
		'react/jsx-curly-spacing': [
			'error',
			{
				when:     'never',
				children: true,
			},
		],
		'react/jsx-equals-spacing':      ['error', 'never'],
		'react/jsx-filename-extension':  'off',
		'react/jsx-first-prop-new-line': ['error', 'multiline'],
		'react/jsx-fragments':           ['error', 'syntax'],
		'react/jsx-handler-names':       [
			'off',
			{
				eventHandlerPrefix:     'handle',
				eventHandlerPropPrefix: 'on',
			},
		],
		'react/jsx-indent': [
			'error',
			'tab',
			{
				checkAttributes:          true,
				indentLogicalExpressions: true,
			},
		],
		'react/jsx-indent-props':       ['error', 'tab'],
		'react/jsx-key':                'error',
		'react/jsx-max-depth':          'off',
		'react/jsx-max-props-per-line': [
			'error',
			{
				maximum: 1,
				when:    'multiline',
			},
		],
		'react/jsx-newline': 'off',
		'react/jsx-no-bind': [
			'error',
			{
				allowArrowFunctions: true,
				allowBind:           false,
				allowFunctions:      false,
				ignoreDOMComponents: false,
				ignoreRefs:          false,
			},
		],
		'react/jsx-no-comment-textnodes':          'error',
		'react/jsx-no-constructed-context-values': 'error',
		'react/jsx-no-duplicate-props':            'error',
		'react/jsx-no-literals':                   'off',
		'react/jsx-no-script-url':                 'error',
		'react/jsx-no-target-blank':               ['error', { enforceDynamicLinks: 'always' }],
		'react/jsx-no-undef':                      ['error', { allowGlobals: true }],
		'react/jsx-no-useless-fragment':           'error',
		'react/jsx-one-expression-per-line':       ['error', { allow: 'literal' }],
		'react/jsx-pascal-case':                   'error',
		'react/jsx-props-no-multi-spaces':         'error',
		'react/jsx-props-no-spreading':            'off',
		'react/jsx-sort-default-props':            'error',
		'react/jsx-sort-props':                    [
			'off',
			{
				callbacksLast:        true,
				ignoreCase:           false,
				noSortAlphabetically: true,
				reservedFirst:        true,
				shorthandFirst:       true,
				shorthandLast:        false,
			},
		],
		'react/jsx-tag-spacing': [
			'error',
			{
				afterOpening:      'never',
				beforeClosing:     'never',
				beforeSelfClosing: 'always',
				closingSlash:      'never',
			},
		],
		'react/jsx-uses-react':      'error',
		'react/jsx-uses-vars':       'error',
		'react/jsx-wrap-multilines': [
			'error',
			{
				arrow:       'parens-new-line',
				assignment:  'parens-new-line',
				condition:   'parens-new-line',
				declaration: 'parens-new-line',
				logical:     'parens-new-line',
				prop:        'parens-new-line',
				return:      'parens-new-line',
			},
		],
		'react/no-access-state-in-setstate':          'error',
		'react/no-adjacent-inline-elements':          'error',
		'react/no-array-index-key':                   'warn',
		'react/no-children-prop':                     'error',
		'react/no-danger':                            'error',
		'react/no-danger-with-children':              'error',
		'react/no-deprecated':                        'error',
		'react/no-did-mount-set-state':               'error',
		'react/no-did-update-set-state':              'error',
		'react/no-direct-mutation-state':             'error',
		'react/no-find-dom-node':                     'error',
		'react/no-is-mounted':                        'error',
		'react/no-multi-comp':                        'off',
		'react/no-redundant-should-component-update': 'error',
		'react/no-render-return-value':               'error',
		'react/no-set-state':                         'off',
		'react/no-string-refs':                       'error',
		'react/no-this-in-sfc':                       'error',
		'react/no-typos':                             'error',
		'react/no-unescaped-entities':                'error',
		'react/no-unknown-property':                  'error',
		'react/no-unsafe':                            'error',
		'react/no-unused-prop-types':                 'off',
		'react/no-unused-state':                      'off',
		'react/no-will-update-set-state':             'error',
		'react/prefer-es6-class':                     ['error', 'always'],
		'react/prefer-read-only-props':               'off',
		'react/prefer-stateless-function':            'error',
		'react/prop-types':                           'off',
		'react/react-in-jsx-scope':                   'error',
		'react/require-default-props':                'off',
		'react/require-optimization':                 'off',
		'react/require-render-return':                'error',
		'react/self-closing-comp':                    'error',
		'react/sort-comp':                            [
			'error',
			{
				order: [
					'static-methods',
					'instance-variables',
					'lifecycle',
					'/^on.+$/',
					'getters',
					'setters',
					'/^(get|set)(?!(InitialState$|DefaultProps$|ChildContext$)).+$/',
					'instance-methods',
					'everything-else',
					'rendering',
				],
				groups: {
					lifecycle: [
						'displayName',
						'propTypes',
						'contextTypes',
						'childContextTypes',
						'mixins',
						'statics',
						'defaultProps',
						'constructor',
						'getDefaultProps',
						'getInitialState',
						'state',
						'getChildContext',
						'componentWillMount',
						'componentDidMount',
						'componentWillReceiveProps',
						'shouldComponentUpdate',
						'componentWillUpdate',
						'componentDidUpdate',
						'componentWillUnmount',
					],
					rendering: ['/^render.+$/', 'render'],
				},
			},
		],
		'react/sort-prop-types': [
			'error',
			{
				callbacksLast:        true,
				ignoreCase:           false,
				noSortAlphabetically: false,
				requiredFirst:        true,
				sortShapeProp:        true,
			},
		],
		'react/state-in-constructor':          ['error', 'never'],
		'react/static-property-placement':     ['error', 'static public field'],
		'react/style-prop-object':             'error',
		'react/void-dom-elements-no-children': 'error',
		'require-atomic-updates':              'error',
		'require-await':                       'error',
		'require-unicode-regexp':              'error',
		'require-yield':                       'error',
		'rest-spread-spacing':                 ['error', 'never'],
		'semi':                                semi,
		'semi-spacing':                        [
			'error',
			{
				before: false,
				after:  true,
			},
		],
		'semi-style':                  ['error', 'last'],
		'sort-imports':                'off',
		'sort-keys':                   'off',
		'sort-vars':                   'off',
		'space-before-blocks':         ['error', 'always'],
		'space-before-function-paren': spaceBeforeFunctionParen,
		'space-in-parens':             ['error', 'never'],
		'space-infix-ops':             'error',
		'space-unary-ops':             [
			'error',
			{
				nonwords: false,
				words:    true,
			},
		],
		'spaced-comment':       ['error', 'always', { block: { balanced: true } }],
		'strict':               ['error', 'never'],
		'switch-colon-spacing': [
			'error',
			{
				after:  true,
				before: false,
			},
		],
		'symbol-description':                        'error',
		'template-curly-spacing':                    ['error', 'never'],
		'template-tag-spacing':                      ['error', 'never'],
		'unicode-bom':                               ['error', 'never'],
		'unicorn/better-regex':                      'error',
		'unicorn/catch-error-name':                  ['error', { name: 'err' }],
		'unicorn/consistent-destructuring':          'error',
		'unicorn/consistent-function-scoping':       'off',
		'unicorn/custom-error-definition':           'error',
		'unicorn/empty-brace-spaces':                'off',
		'unicorn/error-message':                     'error',
		'unicorn/escape-case':                       'error',
		'unicorn/expiring-todo-comments':            'off',
		'unicorn/explicit-length-check':             'off',
		'unicorn/filename-case':                     'off',
		'unicorn/import-index':                      'error',
		'unicorn/import-style':                      'off',
		'unicorn/new-for-builtins':                  'error',
		'unicorn/no-abusive-eslint-disable':         'error',
		'unicorn/no-array-callback-reference':       'error',
		'unicorn/no-array-for-each':                 'error',
		'unicorn/no-array-push-push':                'off',
		'unicorn/no-array-reduce':                   'off',
		'unicorn/no-console-spaces':                 'error',
		'unicorn/no-for-loop':                       'error',
		'unicorn/no-hex-escape':                     'off',
		'unicorn/no-instanceof-array':               'error',
		'unicorn/no-keyword-prefix':                 'off',
		'unicorn/no-lonely-if':                      'error',
		'unicorn/no-nested-ternary':                 'off',
		'unicorn/no-new-array':                      'off',
		'unicorn/no-new-buffer':                     'error',
		'unicorn/no-null':                           'off',
		'unicorn/no-object-as-default-parameter':    'error',
		'unicorn/no-process-exit':                   'error',
		'unicorn/no-this-assignment':                'error',
		'unicorn/no-unreadable-array-destructuring': 'error',
		'unicorn/no-unsafe-regex':                   'warn',
		'unicorn/no-unused-properties':              'error',
		'unicorn/no-useless-undefined':              'off',
		'unicorn/no-zero-fractions':                 'error',
		'unicorn/number-literal-case':               'error',
		'unicorn/numeric-separators-style':          'off',
		'unicorn/prefer-add-event-listener':         'error',
		'unicorn/prefer-array-find':                 'error',
		'unicorn/prefer-array-flat-map':             'error',
		'unicorn/prefer-array-index-of':             'error',
		'unicorn/prefer-array-some':                 'error',
		'unicorn/prefer-date-now':                   'error',
		'unicorn/prefer-default-parameters':         'error',
		'unicorn/prefer-dom-node-append':            'error',
		'unicorn/prefer-dom-node-dataset':           'error',
		'unicorn/prefer-dom-node-remove':            'error',
		'unicorn/prefer-dom-node-text-content':      'error',
		'unicorn/prefer-includes':                   'error',
		'unicorn/prefer-keyboard-event-key':         'error',
		'unicorn/prefer-math-trunc':                 'off',
		'unicorn/prefer-modern-dom-apis':            'error',
		'unicorn/prefer-negative-index':             'error',
		'unicorn/prefer-number-properties':          'error',
		'unicorn/prefer-optional-catch-binding':     'error',
		'unicorn/prefer-query-selector':             'error',
		'unicorn/prefer-reflect-apply':              'error',
		'unicorn/prefer-regexp-test':                'off',
		'unicorn/prefer-set-has':                    'error',
		'unicorn/prefer-spread':                     'error',
		'unicorn/prefer-string-replace-all':         'off',
		'unicorn/prefer-string-slice':               'error',
		'unicorn/prefer-string-starts-ends-with':    'error',
		'unicorn/prefer-string-trim-start-end':      'error',
		'unicorn/prefer-ternary':                    'error',
		'unicorn/prefer-type-error':                 'error',
		'unicorn/prevent-abbreviations':             'off',
		'unicorn/string-content':                    'off',
		'unicorn/throw-new-error':                   'error',
		'use-isnan':                                 'error',
		'valid-typeof':                              ['error', { requireStringLiterals: true }],
		'vars-on-top':                               'error',
		'wrap-iife':                                 ['error', 'outside', { functionPrototypeMethods: false }],
		'wrap-regex':                                'error',
		'yield-star-spacing':                        ['error', 'after'],
		'yoda':                                      'error',
	},
	overrides: [
		{
			files: ['./*.js'],
			env:   { commonjs: true },
			rules: { 'import/no-commonjs': 'off' },
		},
		{
			files:    ['*.web.js'],
			settings: {
				'import/resolver': {
					node: {
						extensions: [
							'.web.mjs',
							'.mjs',
							'.web.js',
							'.js',
							'.web.ts',
							'.ts',
							'.web.tsx',
							'.tsx',
							'.json',
							'.web.jsx',
							'.jsx',
						],
					},
				},
			},
			env: {
				browser: true,
				node:    false,
			},
			rules: {
				'import/extensions': [
					'error',
					'always',
					{
						'web.mjs': 'never',
						'mjs':     'never',
						'web.js':  'never',
						'js':      'never',
						'ts':      'never',
						'tsx':     'never',
						'json':    'always',
						'web.jsx': 'never',
						'jsx':     'never',
					},
				],
				'import/no-nodejs-modules': 'error',
			},
		},
		{
			files:    ['*.node.js'],
			settings: {
				'import/resolver': {
					node: {
						extensions: [
							'.node.mjs',
							'.mjs',
							'.node.js',
							'.js',
							'.node.ts',
							'.ts',
							'.node.tsx',
							'.tsx',
							'.json',
							'.node.jsx',
							'.jsx',
							'.node',
						],
					},
				},
			},
			env:   { node: true },
			rules: {
				'import/extensions': [
					'error',
					'always',
					{
						'node.mjs': 'never',
						'mjs':      'never',
						'node.js':  'never',
						'js':       'never',
						'ts':       'never',
						'tsx':      'never',
						'json':     'always',
						'node.jsx': 'never',
						'jsx':      'never',
						'node':     'never',
					},
				],
			},
		},
		{
			files:   ['*.spec.js', '*.test.js'],
			env:     { jest: true },
			plugins: ['jest', 'jest-formatting'],
			rules:   {
				'jest-formatting/padding-around-after-all-blocks':   'error',
				'jest-formatting/padding-around-after-each-blocks':  'error',
				'jest-formatting/padding-around-all':                'error',
				'jest-formatting/padding-around-before-all-blocks':  'error',
				'jest-formatting/padding-around-before-each-blocks': 'error',
				'jest-formatting/padding-around-describe-blocks':    'error',
				'jest-formatting/padding-around-expect-groups':      'error',
				'jest-formatting/padding-around-test-blocks':        'error',
				'jest/consistent-test-it':                           [
					'error',
					{
						fn:             'it',
						withinDescribe: 'it',
					},
				],
				'jest/expect-expect':                 'error',
				'jest/lowercase-name':                ['error', { ignore: ['describe'] }],
				'jest/no-alias-methods':              'error',
				'jest/no-commented-out-tests':        'error',
				'jest/no-conditional-expect':         'error',
				'jest/no-deprecated-functions':       'error',
				'jest/no-disabled-tests':             'error',
				'jest/no-done-callback':              'error',
				'jest/no-duplicate-hooks':            'error',
				'jest/no-export':                     'error',
				'jest/no-focused-tests':              'error',
				'jest/no-hooks':                      'off',
				'jest/no-identical-title':            'error',
				'jest/no-if':                         'warn',
				'jest/no-interpolation-in-snapshots': 'error',
				'jest/no-jasmine-globals':            'error',
				'jest/no-jest-import':                'error',
				'jest/no-large-snapshots':            'off',
				'jest/no-mocks-import':               'error',
				'jest/no-restricted-matchers':        'off',
				'jest/no-standalone-expect':          'error',
				'jest/no-test-prefixes':              'error',
				'jest/no-test-return-statement':      'off',
				'jest/prefer-called-with':            'error',
				'jest/prefer-expect-assertions':      'off',
				'jest/prefer-hooks-on-top':           'error',
				'jest/prefer-spy-on':                 'off',
				'jest/prefer-strict-equal':           'error',
				'jest/prefer-to-be-null':             'error',
				'jest/prefer-to-be-undefined':        'error',
				'jest/prefer-to-contain':             'error',
				'jest/prefer-to-have-length':         'error',
				'jest/prefer-todo':                   'error',
				'jest/require-to-throw-message':      'warn',
				'jest/require-top-level-describe':    'off',
				'jest/valid-describe':                'error',
				'jest/valid-expect':                  ['error', { alwaysAwait: true }],
				'jest/valid-expect-in-promise':       'error',
				'jest/valid-title':                   'error',
				'no-global-assign':                   'off',
			},
		},
		{
			files:         ['*.ts', '*.tsx'],
			parser:        '@typescript-eslint/parser',
			parserOptions: {
				sourceType: 'module',
				project:    ['./tsconfig.json'],
			},
			plugins: ['@typescript-eslint'],
			rules:   {
				'@typescript-eslint/adjacent-overload-signatures':           'error',
				'@typescript-eslint/array-type':                             'error',
				'@typescript-eslint/await-thenable':                         'error',
				'@typescript-eslint/ban-ts-comment':                         'error',
				'@typescript-eslint/ban-tslint-comment':                     'error',
				'@typescript-eslint/ban-types':                              ['error', { types: { object: false } }],
				'@typescript-eslint/brace-style':                            braceStyle,
				'@typescript-eslint/class-literal-property-style':           'error',
				'@typescript-eslint/comma-spacing':                          commaSpacing,
				'@typescript-eslint/consistent-type-assertions':             'error',
				'@typescript-eslint/consistent-type-definitions':            'error',
				'@typescript-eslint/consistent-type-imports':                'error',
				'@typescript-eslint/default-param-last':                     'warn',
				'@typescript-eslint/dot-notation':                           'error',
				'@typescript-eslint/explicit-function-return-type':          'warn',
				'@typescript-eslint/explicit-member-accessibility':          'error',
				'@typescript-eslint/explicit-module-boundary-types':         'error',
				'@typescript-eslint/func-call-spacing':                      funcCallSpacing,
				'@typescript-eslint/indent':                                 indent,
				'@typescript-eslint/init-declarations':                      'off',
				'@typescript-eslint/keyword-spacing':                        keywordSpacing,
				'@typescript-eslint/lines-between-class-members':            linesBetweenClassMembers,
				'@typescript-eslint/member-delimiter-style':                 'error',
				'@typescript-eslint/member-ordering':                        'error',
				'@typescript-eslint/method-signature-style':                 'error',
				'@typescript-eslint/naming-convention':                      'off',
				'@typescript-eslint/no-array-constructor':                   'error',
				'@typescript-eslint/no-base-to-string':                      'error',
				'@typescript-eslint/no-confusing-non-null-assertion':        'error',
				'@typescript-eslint/no-dupe-class-members':                  'error',
				'@typescript-eslint/no-dynamic-delete':                      'error',
				'@typescript-eslint/no-empty-function':                      noEmptyFunction,
				'@typescript-eslint/no-empty-interface':                     'error',
				'@typescript-eslint/no-explicit-any':                        'warn',
				'@typescript-eslint/no-extra-non-null-assertion':            'error',
				'@typescript-eslint/no-extra-parens':                        noExtraParens,
				'@typescript-eslint/no-extra-semi':                          'error',
				'@typescript-eslint/no-extraneous-class':                    'warn',
				'@typescript-eslint/no-floating-promises':                   'error',
				'@typescript-eslint/no-for-in-array':                        'error',
				'@typescript-eslint/no-implied-eval':                        'error',
				'@typescript-eslint/no-inferrable-types':                    'error',
				'@typescript-eslint/no-invalid-this':                        'error',
				'@typescript-eslint/no-invalid-void-type':                   'error',
				'@typescript-eslint/no-loss-of-precision':                   'error',
				'@typescript-eslint/no-magic-numbers':                       'off',
				'@typescript-eslint/no-misused-new':                         'error',
				'@typescript-eslint/no-misused-promises':                    'error',
				'@typescript-eslint/no-namespace':                           'error',
				'@typescript-eslint/no-non-null-asserted-optional-chain':    'error',
				'@typescript-eslint/no-non-null-assertion':                  'off',
				'@typescript-eslint/no-parameter-properties':                'error',
				'@typescript-eslint/no-require-imports':                     'error',
				'@typescript-eslint/no-this-alias':                          'error',
				'@typescript-eslint/no-throw-literal':                       'error',
				'@typescript-eslint/no-type-alias':                          'off',
				'@typescript-eslint/no-unnecessary-boolean-literal-compare': 'error',
				'@typescript-eslint/no-unnecessary-condition':               'error',
				'@typescript-eslint/no-unnecessary-qualifier':               'error',
				'@typescript-eslint/no-unnecessary-type-arguments':          'error',
				'@typescript-eslint/no-unnecessary-type-assertion':          'error',
				'@typescript-eslint/no-unsafe-assignment':                   'error',
				'@typescript-eslint/no-unsafe-call':                         'error',
				'@typescript-eslint/no-unsafe-member-access':                'error',
				'@typescript-eslint/no-unsafe-return':                       'error',
				'@typescript-eslint/no-unused-expressions':                  noUnusedExpressions,
				'@typescript-eslint/no-unused-vars':                         noUnusedVars,
				'@typescript-eslint/no-unused-vars-experimental':            'off',
				'@typescript-eslint/no-use-before-define':                   noUseBeforeDefine,
				'@typescript-eslint/no-useless-constructor':                 'error',
				'@typescript-eslint/no-var-requires':                        'error',
				'@typescript-eslint/prefer-as-const':                        'error',
				'@typescript-eslint/prefer-enum-initializers':               'error',
				'@typescript-eslint/prefer-for-of':                          'error',
				'@typescript-eslint/prefer-function-type':                   'error',
				'@typescript-eslint/prefer-includes':                        'error',
				'@typescript-eslint/prefer-literal-enum-member':             'error',
				'@typescript-eslint/prefer-namespace-keyword':               'error',
				'@typescript-eslint/prefer-nullish-coalescing':              [
					'error',
					{
						ignoreConditionalTests:        true,
						ignoreMixedLogicalExpressions: true,
					},
				],
				'@typescript-eslint/prefer-optional-chain':           'error',
				'@typescript-eslint/prefer-readonly':                 'error',
				'@typescript-eslint/prefer-readonly-parameter-types': 'off',
				'@typescript-eslint/prefer-reduce-type-parameter':    'error',
				'@typescript-eslint/prefer-regexp-exec':              'error',
				'@typescript-eslint/prefer-string-starts-ends-with':  'error',
				'@typescript-eslint/prefer-ts-expect-error':          'error',
				'@typescript-eslint/promise-function-async':          'error',
				'@typescript-eslint/quotes':                          quotes,
				'@typescript-eslint/require-array-sort-compare':      'error',
				'@typescript-eslint/require-await':                   'error',
				'@typescript-eslint/restrict-plus-operands':          'error',
				'@typescript-eslint/restrict-template-expressions':   'error',
				'@typescript-eslint/return-await':                    'error',
				'@typescript-eslint/semi':                            semi,
				'@typescript-eslint/space-before-function-paren':     spaceBeforeFunctionParen,
				'@typescript-eslint/strict-boolean-expressions':      'off',
				'@typescript-eslint/switch-exhaustiveness-check':     'error',
				'@typescript-eslint/triple-slash-reference':          'error',
				'@typescript-eslint/type-annotation-spacing':         'error',
				'@typescript-eslint/typedef':                         'off',
				'@typescript-eslint/unbound-method':                  'error',
				'@typescript-eslint/unified-signatures':              'error',
				'brace-style':                                        'off',
				'comma-spacing':                                      'off',
				'constructor-super':                                  'off', // ts(2335) & ts(2377)
				'default-param-last':                                 'off',
				'dot-notation':                                       'off',
				'func-call-spacing':                                  'off',
				'getter-return':                                      'off', // ts(2378)
				'import/default':                                     'off', // https://github.com/typescript-eslint/typescript-eslint/blob/master/docs/getting-started/linting/FAQ.md#eslint-plugin-import
				'import/named':                                       'off', // https://github.com/typescript-eslint/typescript-eslint/blob/master/docs/getting-started/linting/FAQ.md#eslint-plugin-import
				'import/namespace':                                   'off', // https://github.com/typescript-eslint/typescript-eslint/blob/master/docs/getting-started/linting/FAQ.md#eslint-plugin-import
				'import/no-named-as-default-member':                  'off', // https://github.com/typescript-eslint/typescript-eslint/blob/master/docs/getting-started/linting/FAQ.md#eslint-plugin-import
				'indent':                                             'off',
				'init-declarations':                                  'off',
				'jsx-a11y/anchor-is-valid':                           'off',
				'keyword-spacing':                                    'off',
				'lines-between-class-members':                        'off',
				'no-array-constructor':                               'off',
				'no-const-assign':                                    'off', // ts(2588)
				'no-dupe-args':                                       'off', // ts(2300)
				'no-dupe-class-members':                              'off', // ts(2393) & ts(2300)
				'no-dupe-keys':                                       'off', // ts(1117)
				'no-duplicate-imports':                               'off', // https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules/no-duplicates.md
				'no-empty-function':                                  'off',
				'no-extra-parens':                                    'off',
				'no-extra-semi':                                      'off',
				'no-func-assign':                                     'off', // ts(2539)
				'no-import-assign':                                   'off', // ts(2539) & ts(2540)
				'no-invalid-this':                                    'off',
				'no-loss-of-precision':                               'off',
				'no-magic-numbers':                                   'off',
				'no-new-symbol':                                      'off', // ts(2588)
				'no-obj-calls':                                       'off', // ts(2349)
				'no-redeclare':                                       'off', // ts(2451)
				'no-return-await':                                    'off',
				'no-setter-return':                                   'off', // ts(2408)
				'no-this-before-super':                               'off', // ts(2376)
				'no-undef':                                           'off', // ts(2304)
				'no-unreachable':                                     'off', // ts(7027)
				'no-unsafe-negation':                                 'off', // ts(2365) & ts(2360) & ts(2358)
				'no-unsafe-optional-chaining':                        'off',
				'no-unused-expressions':                              'off',
				'no-unused-vars':                                     'off',
				'no-use-before-define':                               'off',
				'no-useless-constructor':                             'off',
				'no-var':                                             'error', // ts transpiles let/const to var, so no need for vars any more
				'prefer-const':                                       'error', // ts provides better types with const
				'prefer-rest-params':                                 'error', // ts provides better types with rest args over arguments
				'prefer-spread':                                      'error', // ts transpiles spread to apply, so no need for manual apply
				'quotes':                                             'off',
				'require-await':                                      'off',
				'semi':                                               'off',
				'space-before-function-paren':                        'off',
				'valid-typeof':                                       'off', // ts(2367)
			},
		},
	],
	reportUnusedDisableDirectives: true,
};