eslint-soml 0.0.1

package/index.d.ts

@@ -0,0 +1,33 @@
+import type {ESLint, Linter} from 'eslint';
+
+export type {
+	Node,
+	DocumentNode,
+	ObjectNode,
+	MemberNode,
+	ArrayNode,
+	KeyNode,
+	KeySegmentNode,
+	ValueNode,
+	StringNode,
+	IntegerNode,
+	FloatNode,
+	BooleanNode,
+	NullNode,
+	InstantNode,
+	DurationNode,
+	Token,
+	Comment,
+	Position,
+	SourceLocation,
+} from 'soml-lang';
+
+declare const eslintSoml: ESLint.Plugin & {
+	configs: {
+		recommended: Linter.Config;
+		unopinionated: Linter.Config;
+		all: Linter.Config;
+	};
+};
+
+export default eslintSoml;

package/index.js

@@ -0,0 +1,47 @@
+import * as rawRules from './rules/index.js';
+import {toEslintRules} from './rules/rule/index.js';
+import SomlLanguage from './language/soml-language.js';
+import packageJson from './package.json' with {type: 'json'};
+
+const rules = toEslintRules(rawRules);
+
+const createRules = shouldEnable => Object.fromEntries(Object.entries(rules).map(([id, rule]) => [
+	`soml/${id}`,
+	shouldEnable(rule) ? 'error' : 'off',
+]));
+
+const recommendedRules = createRules(rule => Boolean(rule.meta.docs.recommended));
+const unopinionatedRules = createRules(rule => rule.meta.docs.recommended === 'unopinionated');
+const allRules = createRules(() => true);
+
+const createConfig = (rules, flatConfigName) => ({
+	name: flatConfigName,
+	files: ['**/*.soml'],
+	plugins: {
+		soml,
+	},
+	language: 'soml/soml',
+	rules,
+});
+
+const soml = {
+	meta: {
+		// `eslint-doc-generator` derives the rule prefix from this name, expecting either the `eslint-plugin-<prefix>` convention or the prefix itself. The package name does not follow that convention, so this is the prefix.
+		name: 'soml',
+		version: packageJson.version,
+	},
+	languages: {
+		soml: new SomlLanguage(),
+	},
+	rules,
+};
+
+const configs = {
+	recommended: createConfig(recommendedRules, 'soml/recommended'),
+	unopinionated: createConfig(unopinionatedRules, 'soml/unopinionated'),
+	all: createConfig(allRules, 'soml/all'),
+};
+
+soml.configs = configs;
+
+export default soml;

package/language/soml-language.js

@@ -0,0 +1,72 @@
+import {parseTree, ParseError, visitorKeys} from 'soml-lang';
+import SomlSourceCode from './soml-source-code.js';
+
+/**
+@import {File, OkParseResult, ParseResult} from '@eslint/core';
+@import {DocumentNode} from 'soml-lang';
+*/
+
+/*
+A 1-based line and column, with the column in UTF-16 code units like every other ESLint column. ESLint does not adjust a parse error's position by `columnStart`. `ParseError#column` counts code points instead, so it is not used.
+*/
+function locate(text, offset) {
+	const before = text.slice(0, offset);
+	return {line: before.split('\n').length, column: offset - before.lastIndexOf('\n')};
+}
+
+/**
+The SOML language for ESLint.
+*/
+export default class SomlLanguage {
+	fileType = 'text';
+	lineStart = 1;
+	columnStart = 0;
+	nodeTypeKey = 'type';
+	visitorKeys = visitorKeys;
+
+	/**
+	There are no language options.
+	*/
+	validateLanguageOptions() {}
+
+	/**
+	@param {File} file
+	@returns {ParseResult<DocumentNode>}
+	*/
+	parse(file) {
+		// ESLint removes a BOM before this point, so it is checked here.
+		if (file.bom) {
+			return {
+				ok: false,
+				errors: [{message: 'A byte order mark (BOM) is not allowed', line: 1, column: 1}],
+			};
+		}
+
+		const text = /** @type {string} */ (file.body);
+
+		try {
+			return {ok: true, ast: parseTree(text)};
+		} catch (error) {
+			if (!(error instanceof ParseError)) {
+				throw error;
+			}
+
+			// `reason` is the message without the position and the code frame, which ESLint shows on its own.
+			return {
+				ok: false,
+				errors: [{message: error.reason, ...locate(text, error.offset)}],
+			};
+		}
+	}
+
+	/**
+	@param {File} file
+	@param {OkParseResult<DocumentNode>} parseResult
+	*/
+	createSourceCode(file, parseResult) {
+		return new SomlSourceCode({
+			text: /** @type {string} */ (file.body),
+			ast: parseResult.ast,
+		});
+	}
+}

package/language/soml-source-code.js

@@ -0,0 +1,277 @@
+import {
+	TextSourceCodeBase,
+	VisitNodeStep,
+	ConfigCommentParser,
+	Directive,
+} from '@eslint/plugin-kit';
+import {visitorKeys} from 'soml-lang';
+
+/**
+@import {DirectiveType, FileProblem, RulesConfig, SourceLocation} from '@eslint/core';
+@import {DocumentNode, Node, Token, Comment} from 'soml-lang';
+*/
+
+const commentParser = new ConfigCommentParser();
+const INLINE_CONFIG = /^\s*eslint(?:-enable|-disable(?:(?:-next)?-line)?)?(?:\s|$)/v;
+
+const isComment = item => item.type === 'Line' || item.type === 'Block';
+
+/**
+The source code of a SOML document, which rules get as `context.sourceCode`.
+*/
+export default class SomlSourceCode extends TextSourceCodeBase {
+	/**
+	@type {VisitNodeStep[] | undefined}
+	*/
+	#steps;
+	#parents = new WeakMap();
+	/**
+	Every token and comment, in source order.
+
+	@type {Array<Token | Comment>}
+	*/
+	#items;
+	/**
+	@type {Comment[] | undefined}
+	*/
+	#inlineConfigComments;
+	/**
+	@type {DocumentNode}
+	*/
+	ast;
+	visitorKeys = visitorKeys;
+
+	/**
+	@param {{text: string, ast: DocumentNode}} options
+	*/
+	constructor({text, ast}) {
+		// SOML has no carriage returns, so a line ends only at a line feed.
+		super({text, ast, lineEndingPattern: /\n/v});
+		this.ast = ast;
+		this.#items = [...ast.tokens, ...ast.comments].toSorted((first, second) => first.range[0] - second.range[0]);
+	}
+
+	/*
+	The index of the first token or comment that starts at or after `offset`. They never overlap, so their ends are in order too.
+	*/
+	#indexAt(offset) {
+		const items = this.#items;
+		let low = 0;
+		let high = items.length;
+
+		while (low < high) {
+			const middle = Math.floor((low + high) / 2);
+
+			if (items[middle].range[0] < offset) {
+				low = middle + 1;
+			} else {
+				high = middle;
+			}
+		}
+
+		return low;
+	}
+
+	/*
+	Moves from `index` by `step` until it finds a token, or a comment when they are included. Returns `null` when there is none, like ESLint's own `SourceCode`, so rules can use the usual `=== null` check.
+	*/
+	#find(index, step, includeComments, isInside = () => true) {
+		for (; index >= 0 && index < this.#items.length; index += step) {
+			const item = this.#items[index];
+
+			if (!isInside(item)) {
+				return null;
+			}
+
+			if (includeComments || !isComment(item)) {
+				return item;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	@returns {Iterable<VisitNodeStep>}
+	*/
+	traverse() {
+		if (this.#steps) {
+			return this.#steps;
+		}
+
+		const steps = [];
+		const parents = this.#parents;
+
+		const visit = (node, parent) => {
+			if (parent) {
+				parents.set(node, parent);
+			}
+
+			steps.push(new VisitNodeStep({target: node, phase: 1, args: [node, parent]}));
+
+			for (const key of visitorKeys[node.type]) {
+				const child = node[key];
+
+				if (Array.isArray(child)) {
+					for (const item of child) {
+						visit(item, node);
+					}
+				} else {
+					visit(child, node);
+				}
+			}
+
+			steps.push(new VisitNodeStep({target: node, phase: 2, args: [node, parent]}));
+		};
+
+		visit(this.ast);
+		this.#steps = steps;
+		return steps;
+	}
+
+	/**
+	@param {Node} node
+	@returns {Node | undefined}
+	*/
+	getParent(node) {
+		if (!this.#steps) {
+			this.traverse();
+		}
+
+		return this.#parents.get(node);
+	}
+
+	/**
+	@returns {readonly Comment[]}
+	*/
+	getAllComments() {
+		return this.ast.comments;
+	}
+
+	/**
+	@returns {Comment[]}
+	*/
+	getInlineConfigNodes() {
+		this.#inlineConfigComments ??= this.ast.comments.filter(comment => INLINE_CONFIG.test(comment.value));
+		return this.#inlineConfigComments;
+	}
+
+	/**
+	@returns {{problems: FileProblem[], directives: Directive[]}}
+	*/
+	getDisableDirectives() {
+		const problems = [];
+		const directives = [];
+
+		for (const comment of this.getInlineConfigNodes()) {
+			const {label, value, justification} = commentParser.parseDirective(comment.value);
+
+			// An `eslint-disable-line` comment may not span lines, because it would be unclear which line it applies to.
+			if (label === 'eslint-disable-line' && comment.loc.start.line !== comment.loc.end.line) {
+				problems.push({
+					ruleId: null,
+					message: `${label} comment should not span multiple lines.`,
+					loc: comment.loc,
+				});
+				continue;
+			}
+
+			if (label !== 'eslint') {
+				directives.push(new Directive({
+					type: /** @type {DirectiveType} */ (label.slice('eslint-'.length)),
+					node: comment,
+					value,
+					justification,
+				}));
+			}
+		}
+
+		return {problems, directives};
+	}
+
+	/**
+	@returns {{problems: FileProblem[], configs: Array<{config: {rules: RulesConfig}, loc: SourceLocation}>}}
+	*/
+	applyInlineConfig() {
+		const problems = [];
+		const configs = [];
+
+		for (const comment of this.getInlineConfigNodes()) {
+			const {label, value} = commentParser.parseDirective(comment.value);
+
+			if (label !== 'eslint') {
+				continue;
+			}
+
+			const result = commentParser.parseJSONLikeConfig(value);
+
+			if (result.ok) {
+				configs.push({config: {rules: result.config}, loc: comment.loc});
+			} else {
+				problems.push({
+					ruleId: null,
+					message: result.error.message,
+					loc: comment.loc,
+				});
+			}
+		}
+
+		return {configs, problems};
+	}
+
+	/**
+	The token before a node, token, or comment.
+
+	@param {Node | Token | Comment} nodeOrToken
+	@param {{includeComments?: boolean}} [options]
+	@returns {Token | Comment | null}
+	*/
+	getTokenBefore(nodeOrToken, {includeComments = false} = {}) {
+		return this.#find(this.#indexAt(nodeOrToken.range[0]) - 1, -1, includeComments);
+	}
+
+	/**
+	The token after a node, token, or comment.
+
+	@param {Node | Token | Comment} nodeOrToken
+	@param {{includeComments?: boolean}} [options]
+	@returns {Token | Comment | null}
+	*/
+	getTokenAfter(nodeOrToken, {includeComments = false} = {}) {
+		return this.#find(this.#indexAt(nodeOrToken.range[1]), 1, includeComments);
+	}
+
+	/**
+	The first token inside a node.
+
+	@param {Node} node
+	@param {{includeComments?: boolean}} [options]
+	@returns {Token | Comment | null}
+	*/
+	getFirstToken(node, {includeComments = false} = {}) {
+		return this.#find(this.#indexAt(node.range[0]), 1, includeComments, item => item.range[1] <= node.range[1]);
+	}
+
+	/**
+	The last token inside a node.
+
+	@param {Node} node
+	@param {{includeComments?: boolean}} [options]
+	@returns {Token | Comment | null}
+	*/
+	getLastToken(node, {includeComments = false} = {}) {
+		return this.#find(this.#indexAt(node.range[1]) - 1, -1, includeComments, item => item.range[0] >= node.range[0]);
+	}
+
+	/**
+	Every token inside a node, in source order.
+
+	@param {Node} node
+	@param {{includeComments?: boolean}} [options]
+	@returns {Array<Token | Comment>}
+	*/
+	getTokens(node, {includeComments = false} = {}) {
+		const tokens = this.#items.slice(this.#indexAt(node.range[0]), this.#indexAt(node.range[1]));
+		return includeComments ? tokens : tokens.filter(item => !isComment(item));
+	}
+}

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,83 @@
+{
+	"name": "eslint-soml",
+	"version": "0.0.1",
+	"description": "ESLint plugin for SOML, a config format for humans",
+	"license": "MIT",
+	"repository": "github:sindresorhus/eslint-soml",
+	"funding": "https://github.com/sponsors/sindresorhus",
+	"author": "Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)",
+	"type": "module",
+	"exports": {
+		"types": "./index.d.ts",
+		"default": "./index.js"
+	},
+	"sideEffects": false,
+	"engines": {
+		"node": ">=22"
+	},
+	"scripts": {
+		"create-rule": "node ./scripts/create-rule.js && npm run create-rules-index-file && npm run fix:eslint-docs",
+		"create-rules-index-file": "node ./scripts/create-rules-index-file.js",
+		"fix": "run-p --continue-on-error \"fix:*\"",
+		"fix:eslint-docs": "eslint-doc-generator",
+		"fix:js": "eslint --fix",
+		"fix:markdown": "markdownlint --fix \"**/*.md\"",
+		"fix:snapshots": "node --test --test-update-snapshots \"test/*.js\"",
+		"lint": "run-p --continue-on-error \"lint:*\"",
+		"lint:eslint-docs": "eslint-doc-generator --check",
+		"lint:js": "eslint",
+		"lint:markdown": "markdownlint \"**/*.md\"",
+		"rename-rule": "node ./scripts/rename-rule.js && npm run create-rules-index-file && npm run fix:eslint-docs",
+		"sync-conformance": "node ./scripts/sync-conformance.js",
+		"test": "run-s --continue-on-error lint test:js test:types",
+		"test:js": "node --test \"test/*.js\"",
+		"test:types": "tsc --project test/types/tsconfig.json"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts",
+		"language",
+		"rules"
+	],
+	"keywords": [
+		"eslint",
+		"eslintplugin",
+		"eslint-plugin",
+		"soml",
+		"config",
+		"configuration",
+		"linter",
+		"lint",
+		"style"
+	],
+	"dependencies": {
+		"@eslint/plugin-kit": "^0.7.3",
+		"natural-compare": "^1.4.0",
+		"soml-lang": "^0.0.2"
+	},
+	"devDependencies": {
+		"@babel/code-frame": "^8.0.6",
+		"@eslint-community/eslint-utils": "^4.10.1",
+		"@eslint/core": "^1.2.1",
+		"@typescript-eslint/types": "^8.71.0",
+		"enquirer": "^2.4.1",
+		"eslint": "^10.12.0",
+		"eslint-config-xo": "^4.0.1",
+		"eslint-doc-generator": "^3.7.1",
+		"eslint-plugin-eslint-plugin": "^7.6.2",
+		"eslint-plugin-jsdoc": "^65.0.2",
+		"globals": "^17.13.0",
+		"indent-string": "^5.0.0",
+		"markdownlint-cli": "^0.49.1",
+		"nano-spawn": "^2.1.0",
+		"node-style-text": "^2.1.2",
+		"npm-run-all2": "^9.0.3",
+		"open-editor": "^6.0.0",
+		"outdent": "^0.8.0",
+		"typescript": "^6.0.3",
+		"yaml": "^2.9.1"
+	},
+	"peerDependencies": {
+		"eslint": ">=10.4"
+	}
+}

package/readme.md

@@ -0,0 +1,175 @@
+# eslint-soml
+
+> ESLint plugin for [SOML](https://github.com/soml-lang/soml), a config format for humans
+
+Lint `.soml` files with ESLint. The plugin parses them with [`soml-lang`](https://github.com/sindresorhus/soml-js), the reference parser, so ESLint reports every syntax error the specification defines, and `# eslint-disable` comments work as in JavaScript.
+
+[**Propose a new rule ➡**](.github/contributing.md)
+
+*We do not accept pull requests because of too much AI slop.*
+
+## Install
+
+```sh
+npm install --save-dev eslint eslint-soml
+```
+
+**Requires Node.js 26, ESLint `>=10.4`, [flat config](https://eslint.org/docs/latest/use/configure/configuration-files), and [ESM](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c#how-can-i-make-my-typescript-project-output-esm).**
+
+## Usage
+
+Use a [preset config](#preset-configs):
+
+```js
+import soml from 'eslint-soml';
+import {defineConfig} from 'eslint/config';
+
+export default defineConfig([
+	soml.configs.recommended,
+]);
+```
+
+Or configure each rule. Then set `language: 'soml/soml'`, as shown below.
+
+```js
+import soml from 'eslint-soml';
+import {defineConfig} from 'eslint/config';
+
+export default defineConfig([
+	{
+		files: ['**/*.soml'],
+		plugins: {
+			soml,
+		},
+		language: 'soml/soml',
+		rules: {
+			'soml/prefer-literal-strings': 'error',
+			'soml/…': 'error',
+		},
+	},
+]);
+```
+
+Disable a rule with a comment, in either comment style:
+
+```soml
+# eslint-disable-next-line soml/prefer-bare-keys
+'name': 'soml'
+
+'404': 'Not found' /* eslint-disable-line soml/prefer-bare-keys */
+```
+
+## Rules
+
+<!-- Do not manually modify this list. Run: `npm run fix:eslint-docs` -->
+<!-- begin auto-generated rules list -->
+
+💼 [Configurations](https://github.com/sindresorhus/eslint-soml#preset-configs) enabled in.\
+✅ Set in the `recommended` [configuration](https://github.com/sindresorhus/eslint-soml#preset-configs).\
+☑️ Set in the `unopinionated` [configuration](https://github.com/sindresorhus/eslint-soml#preset-configs).\
+🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
+💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
+
+| Name                                                                                     | Description                                                   | 💼   | 🔧 | 💡 |
+| :--------------------------------------------------------------------------------------- | :------------------------------------------------------------ | :--- | :- | :- |
+| [format](docs/rules/format.md)                                                           | Enforce the layout of the SOML formatter.                     | ✅    | 🔧 |    |
+| [key-name-casing](docs/rules/key-name-casing.md)                                         | Enforce a casing style for keys.                              |      |    |    |
+| [no-block-string-trailing-whitespace](docs/rules/no-block-string-trailing-whitespace.md) | Disallow trailing whitespace in block strings.                | ✅ ☑️ |    |    |
+| [no-empty-keys](docs/rules/no-empty-keys.md)                                             | Disallow empty keys.                                          | ✅ ☑️ |    |    |
+| [no-invisible-characters](docs/rules/no-invisible-characters.md)                         | Disallow invisible characters in strings, keys, and comments. | ✅ ☑️ | 🔧 |    |
+| [no-loss-of-precision](docs/rules/no-loss-of-precision.md)                               | Disallow floats that cannot be stored exactly as written.     | ✅ ☑️ |    |    |
+| [no-mixed-number-types](docs/rules/no-mixed-number-types.md)                             | Disallow arrays that mix ints and floats.                     | ✅    |    | 💡 |
+| [no-numeric-dotted-keys](docs/rules/no-numeric-dotted-keys.md)                           | Disallow dotted keys that read as one number.                 | ✅ ☑️ |    | 💡 |
+| [no-unnormalized-keys](docs/rules/no-unnormalized-keys.md)                               | Disallow keys that are not in a Unicode normalization form.   | ✅ ☑️ |    |    |
+| [numeric-separators-style](docs/rules/numeric-separators-style.md)                       | Enforce the grouping of digits with `_` in decimal numbers.   | ✅    | 🔧 |    |
+| [prefer-bare-keys](docs/rules/prefer-bare-keys.md)                                       | Prefer bare keys when a key does not need quotes.             | ✅    | 🔧 |    |
+| [prefer-literal-strings](docs/rules/prefer-literal-strings.md)                           | Prefer literal strings, `'…'`, when a string has no escapes.  | ✅    | 🔧 |    |
+| [prefer-utc-instants](docs/rules/prefer-utc-instants.md)                                 | Prefer instants in UTC.                                       |      | 🔧 |    |
+| [sort-keys](docs/rules/sort-keys.md)                                                     | Require object keys to be sorted.                             |      | 🔧 |    |
+| [spaced-comment](docs/rules/spaced-comment.md)                                           | Require a space after `#` and `/*`, and before `*/`.          | ✅    | 🔧 |    |
+
+<!-- end auto-generated rules list -->
+
+## Preset configs
+
+See the [ESLint docs](https://eslint.org/docs/latest/use/configure/configuration-files) for more information about extending config files.
+
+**Note**: The preset configs apply to `**/*.soml` files. They also set `language: 'soml/soml'`.
+
+### Recommended config
+
+This plugin exports a `recommended` config that enforces good practices.
+
+```js
+import soml from 'eslint-soml';
+import {defineConfig} from 'eslint/config';
+
+export default defineConfig([
+	// …
+	soml.configs.recommended,
+	{
+		files: ['**/*.soml'],
+		rules: {
+			'soml/sort-keys': 'error',
+		},
+	},
+]);
+```
+
+### Unopinionated config
+
+This plugin exports an `unopinionated` config with only the rules that catch bugs. Every syntax error is reported by every config, because it comes from the parser.
+
+```js
+import soml from 'eslint-soml';
+import {defineConfig} from 'eslint/config';
+
+export default defineConfig([
+	// …
+	soml.configs.unopinionated,
+]);
+```
+
+### All config
+
+This plugin exports an `all` config that enables every rule.
+
+```js
+import soml from 'eslint-soml';
+import {defineConfig} from 'eslint/config';
+
+export default defineConfig([
+	// …
+	soml.configs.all,
+	{
+		files: ['**/*.soml'],
+		rules: {
+			'soml/prefer-utc-instants': 'off',
+		},
+	},
+]);
+```
+
+## Editor integration
+
+In Visual Studio Code, the [ESLint extension](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint) only checks the languages listed in its `eslint.validate` setting. Add `soml`. This needs an extension that registers the `soml` language for `.soml` files.
+
+```json
+{
+	"eslint.validate": [
+		"soml"
+	]
+}
+```
+
+## Writing rules
+
+Rules get the tree from [`parseTree()`](https://github.com/sindresorhus/soml-js#parsetreetext) in `soml-lang`. Its readme lists every node type. The node types are exported as TypeScript types from this package too.
+
+`context.sourceCode` has `getParent()`, `getTokenBefore()`, `getTokenAfter()`, `getFirstToken()`, `getLastToken()`, and `getTokens()`, each token method with an `includeComments` option, and `getAllComments()`.
+
+## Related
+
+- [soml-lang](https://github.com/sindresorhus/soml-js) - The reference parser and canonical serializer for SOML
+- [eslint-plugin-unicorn](https://github.com/sindresorhus/eslint-plugin-unicorn) - More than 300 powerful ESLint rules
+- [eslint-package-json](https://github.com/sindresorhus/eslint-package-json) - Powerful ESLint rules for `package.json`