eslint-soml 0.0.1 → 0.0.2

package/index.d.ts

@@ -16,6 +16,7 @@ export type {
 	NullNode,
 	InstantNode,
 	DurationNode,
+	DurationPart,
 	Token,
 	Comment,
 	Position,

package/language/soml-source-code.js

@@ -134,13 +134,12 @@ export default class SomlSourceCode extends TextSourceCodeBase {
 	@returns {Node | undefined}
 	*/
 	getParent(node) {
-		if (!this.#steps) {
-			this.traverse();
-		}
-
+		// The parents are recorded by the first traversal.
+		this.traverse();
 		return this.#parents.get(node);
 	}
 
+	// TODO: Add a `comments` property that holds `this.ast.comments` when ESLint ships https://github.com/eslint/rfcs/pull/150. It adds `comments` to `SourceCode` and `TextSourceCodeBase`, deprecates `getAllComments()`, and makes `no-irregular-whitespace` work on any language that has `comments`. Then use `comments` in the rules, too.
 	/**
 	@returns {readonly Comment[]}
 	*/

package/package.json

@@ -1,9 +1,9 @@
 {
 	"name": "eslint-soml",
-	"version": "0.0.1",
+	"version": "0.0.2",
 	"description": "ESLint plugin for SOML, a config format for humans",
 	"license": "MIT",
-	"repository": "github:sindresorhus/eslint-soml",
+	"repository": "github:soml-lang/eslint-soml",
 	"funding": "https://github.com/sponsors/sindresorhus",
 	"author": "Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)",
 	"type": "module",
@@ -13,7 +13,7 @@
 	},
 	"sideEffects": false,
 	"engines": {
-		"node": ">=22"
+		"node": "^22.13.0 || >=24"
 	},
 	"scripts": {
 		"create-rule": "node ./scripts/create-rule.js && npm run create-rules-index-file && npm run fix:eslint-docs",
@@ -53,20 +53,19 @@
 	"dependencies": {
 		"@eslint/plugin-kit": "^0.7.3",
 		"natural-compare": "^1.4.0",
-		"soml-lang": "^0.0.2"
+		"soml-lang": "^0.0.3"
 	},
 	"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",
+		"@typescript-eslint/types": "^8.71.1",
 		"enquirer": "^2.4.1",
 		"eslint": "^10.12.0",
-		"eslint-config-xo": "^4.0.1",
+		"eslint-config-xo": "^5.0.0",
 		"eslint-doc-generator": "^3.7.1",
 		"eslint-plugin-eslint-plugin": "^7.6.2",
-		"eslint-plugin-jsdoc": "^65.0.2",
-		"globals": "^17.13.0",
+		"eslint-plugin-jsdoc": "^65.2.1",
 		"indent-string": "^5.0.0",
 		"markdownlint-cli": "^0.49.1",
 		"nano-spawn": "^2.1.0",

package/readme.md

@@ -2,8 +2,6 @@
 
 > 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.*
@@ -14,7 +12,9 @@ Lint `.soml` files with ESLint. The plugin parses them with [`soml-lang`](https:
 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).**
+**Requires Node.js 22.13 or later, 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).**
+
+The parser needs `Temporal` for instants and durations, and Node.js 26 and later have it built in. On older versions, linting a file with an instant or a duration fails, unless a [`Temporal` polyfill](https://github.com/fullcalendar/temporal-polyfill) is loaded first. Make `import 'temporal-polyfill/global';` the first import in `eslint.config.js`, before `eslint-soml`.
 
 ## Usage
 
@@ -59,34 +59,73 @@ Disable a rule with a comment, in either comment style:
 '404': 'Not found' /* eslint-disable-line soml/prefer-bare-keys */
 ```
 
+The [`reportUnusedDisableDirectives`](https://eslint.org/docs/latest/use/configure/configuration-files#report-unused-disable-directives) and [`reportUnusedInlineConfigs`](https://eslint.org/docs/latest/use/configure/configuration-files#report-unused-inline-configs) linter options work for `.soml` files, and so do the rules of [`@eslint-community/eslint-plugin-eslint-comments`](https://github.com/eslint-community/eslint-plugin-eslint-comments), such as `no-unlimited-disable`.
+
+ESLint's [`no-restricted-syntax`](https://eslint.org/docs/latest/rules/no-restricted-syntax) rule works too, with the [node types](#writing-rules) of the tree. For example, to disallow a key named `password`:
+
+```js
+import soml from 'eslint-soml';
+import {defineConfig} from 'eslint/config';
+
+export default defineConfig([
+	soml.configs.recommended,
+	{
+		files: ['**/*.soml'],
+		rules: {
+			'no-restricted-syntax': [
+				'error',
+				{
+					selector: 'Member > Key > KeySegment[value="password"]',
+					message: 'Read the password from the environment.',
+				},
+			],
+		},
+	},
+]);
+```
+
 ## 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).\
+💼 [Configurations](https://github.com/soml-lang/eslint-soml#preset-configs) enabled in.\
+✅ Set in the `recommended` [configuration](https://github.com/soml-lang/eslint-soml#preset-configs).\
+☑️ Set in the `unopinionated` [configuration](https://github.com/soml-lang/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 `*/`.          | ✅    | 🔧 |    |
+| 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-edge-blank-lines](docs/rules/no-block-string-edge-blank-lines.md)                   | Disallow blank lines at the start and end of block strings.                     | ✅    | 🔧 |    |
+| [no-block-string-trailing-whitespace](docs/rules/no-block-string-trailing-whitespace.md)             | Disallow trailing whitespace in block strings.                                  | ✅ ☑️ |    |    |
+| [no-confusable-keys](docs/rules/no-confusable-keys.md)                                               | Disallow keys that differ only in case, `-` and `_`, or surrounding whitespace. | ✅ ☑️ |    |    |
+| [no-decimal-file-modes](docs/rules/no-decimal-file-modes.md)                                         | Disallow file modes written as decimal numbers.                                 | ✅ ☑️ |    | 💡 |
+| [no-doubled-backslashes-in-literal-strings](docs/rules/no-doubled-backslashes-in-literal-strings.md) | Disallow doubled backslashes in literal strings, such as `'^\\d+$'`.            | ✅    |    | 💡 |
+| [no-duplicate-array-items](docs/rules/no-duplicate-array-items.md)                                   | Disallow the same string twice in an array.                                     |      |    | 💡 |
+| [no-empty-keys](docs/rules/no-empty-keys.md)                                                         | Disallow empty and whitespace-only keys.                                        | ✅ ☑️ |    |    |
+| [no-escapes-in-paths](docs/rules/no-escapes-in-paths.md)                                             | Disallow `\n` and `\t` escapes in Windows paths.                                | ✅ ☑️ |    | 💡 |
+| [no-float-trailing-zeros](docs/rules/no-float-trailing-zeros.md)                                     | Disallow trailing zeros in the fraction of a float.                             | ✅    |    | 💡 |
+| [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-misplaced-block-string-delimiters](docs/rules/no-misplaced-block-string-delimiters.md)           | Disallow a block string delimiter at the end of a content line.                 | ✅ ☑️ |    |    |
+| [no-mixed-number-types](docs/rules/no-mixed-number-types.md)                                         | Disallow arrays that mix ints and floats.                                       | ✅    |    | 💡 |
+| [no-negative-zero](docs/rules/no-negative-zero.md)                                                   | Disallow a sign on zero.                                                        | ✅    | 🔧 |    |
+| [no-numeric-dotted-keys](docs/rules/no-numeric-dotted-keys.md)                                       | Disallow dotted keys that read as one number.                                   | ✅ ☑️ |    | 💡 |
+| [no-placeholder-values](docs/rules/no-placeholder-values.md)                                         | Disallow placeholder values, such as `'changeme'`.                              | ✅    |    |    |
+| [no-quoted-keywords](docs/rules/no-quoted-keywords.md)                                               | Disallow the strings `'true'`, `'false'`, and `'null'`.                         | ✅    |    | 💡 |
+| [no-scattered-dotted-keys](docs/rules/no-scattered-dotted-keys.md)                                   | Require the dotted keys under one prefix to be next to each other.              | ✅    | 🔧 |    |
+| [no-sizes-as-durations](docs/rules/no-sizes-as-durations.md)                                         | Disallow sizes that are durations, such as `memory: 512m`.                      | ✅ ☑️ |    | 💡 |
+| [no-unnormalized-keys](docs/rules/no-unnormalized-keys.md)                                           | Disallow keys that are not in a Unicode normalization form.                     | ✅ ☑️ |    |    |
+| [no-zero-duration-parts](docs/rules/no-zero-duration-parts.md)                                       | Disallow duration parts that are zero.                                          | ✅    | 🔧 |    |
+| [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 -->
 
@@ -162,14 +201,8 @@ In Visual Studio Code, the [ESLint extension](https://marketplace.visualstudio.c
 }
 ```
 
-## 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
+- [soml-javascript](https://github.com/soml-lang/soml-javascript) - The reference parser and serializer for SOML
+- [eslint-plugin-unicorn](https://github.com/sindresorhus/eslint-plugin-unicorn) - Powerful ESLint rules
 - [eslint-package-json](https://github.com/sindresorhus/eslint-package-json) - Powerful ESLint rules for `package.json`

package/rules/format.js

@@ -1,4 +1,4 @@
-import {format} from 'soml-lang';
+import {formatEdits} from 'soml-lang';
 
 /**
 @import {SomlContext} from './rule/soml-context.js';
@@ -22,57 +22,6 @@ const showInvisibles = text => text
 	.replaceAll('\n', '⏎')
 	.replaceAll('\t', '↹');
 
-const GAP_CHARACTERS = new Set([' ', '\t', '\n', ',']);
-const isGapCharacter = character => GAP_CHARACTERS.has(character);
-
-/*
-The end of the run of spaces, tabs, line feeds, and commas at `index`.
-*/
-function skipGap(text, index) {
-	while (index < text.length && isGapCharacter(text[index])) {
-		index++;
-	}
-
-	return index;
-}
-
-/*
-The changes from `text` to `formatted`, as ranges of `text` and what replaces them.
-
-The formatter only changes spaces, tabs, line feeds, and commas, so without those the two texts are the same. Walking both at once, every run of those characters that differs is one change. This takes linear time, where a general diff takes quadratic time on a file with many changes.
-*/
-function * getChanges(text, formatted) {
-	let textIndex = 0;
-	let formattedIndex = 0;
-
-	while (textIndex < text.length || formattedIndex < formatted.length) {
-		const textGapEnd = skipGap(text, textIndex);
-		const formattedGapEnd = skipGap(formatted, formattedIndex);
-		const inserted = formatted.slice(formattedIndex, formattedGapEnd);
-
-		if (text.slice(textIndex, textGapEnd) !== inserted) {
-			yield {start: textIndex, end: textGapEnd, inserted};
-		}
-
-		textIndex = textGapEnd;
-		formattedIndex = formattedGapEnd;
-
-		while (textIndex < text.length && !isGapCharacter(text[textIndex]) && text[textIndex] === formatted[formattedIndex]) {
-			textIndex++;
-			formattedIndex++;
-		}
-
-		// Not expected, but if the formatter changed anything else, both stop at a different character, or one at its end, and the rest is one change.
-		const isTextStuck = textIndex === text.length || !isGapCharacter(text[textIndex]);
-		const isFormattedStuck = formattedIndex === formatted.length || !isGapCharacter(formatted[formattedIndex]);
-
-		if (isTextStuck && isFormattedStuck && (textIndex < text.length || formattedIndex < formatted.length)) {
-			yield {start: textIndex, end: text.length, inserted: formatted.slice(formattedIndex)};
-			return;
-		}
-	}
-}
-
 /**
 @param {SomlContext} context
 */
@@ -81,13 +30,11 @@ const create = context => {
 
 	context.on('Document', function * () {
 		const {text} = sourceCode;
-		const formatted = format(text);
-
-		if (formatted === text) {
-			return;
-		}
+		const edits = formatEdits(text);
 
-		for (const {start, end, inserted} of getChanges(text, formatted)) {
+		// eslint-disable-next-line internal/no-restricted-property-access -- An edit is not a node.
+		for (const [index, {range, text: inserted}] of edits.entries()) {
+			const [start, end] = range;
 			const deleted = text.slice(start, end);
 			let messageId = MESSAGE_ID_REPLACE;
 
@@ -107,8 +54,15 @@ const create = context => {
 					deleted: showInvisibles(deleted),
 					inserted: showInvisibles(inserted),
 				},
-				// The whole document is replaced, so the formatting is applied at once. Applying only some changes, when a fix from another rule overlaps one of them, could leave a comma or a block string half moved.
-				fix: fixer => fixer.replaceTextRange([0, text.length], formatted),
+				// Every edit is in one fix, so the formatting is applied at once. Applying only some edits, when a fix from another rule overlaps one of them, could leave a block string half moved. Only the first problem carries the fix, because a copy of every edit in every problem would make the output grow with the file size times the problem count.
+				fix: index === 0
+					? function * (fixer) {
+						// eslint-disable-next-line internal/no-restricted-property-access -- An edit is not a node.
+						for (const {range, text} of edits) {
+							yield fixer.replaceTextRange(range, text);
+						}
+					}
+					: undefined,
 			};
 		}
 	});

package/rules/index.js

@@ -2,13 +2,27 @@
 
 export {default as format} from './format.js';
 export {default as 'key-name-casing'} from './key-name-casing.js';
+export {default as 'no-block-string-edge-blank-lines'} from './no-block-string-edge-blank-lines.js';
 export {default as 'no-block-string-trailing-whitespace'} from './no-block-string-trailing-whitespace.js';
+export {default as 'no-confusable-keys'} from './no-confusable-keys.js';
+export {default as 'no-decimal-file-modes'} from './no-decimal-file-modes.js';
+export {default as 'no-doubled-backslashes-in-literal-strings'} from './no-doubled-backslashes-in-literal-strings.js';
+export {default as 'no-duplicate-array-items'} from './no-duplicate-array-items.js';
 export {default as 'no-empty-keys'} from './no-empty-keys.js';
+export {default as 'no-escapes-in-paths'} from './no-escapes-in-paths.js';
+export {default as 'no-float-trailing-zeros'} from './no-float-trailing-zeros.js';
 export {default as 'no-invisible-characters'} from './no-invisible-characters.js';
 export {default as 'no-loss-of-precision'} from './no-loss-of-precision.js';
+export {default as 'no-misplaced-block-string-delimiters'} from './no-misplaced-block-string-delimiters.js';
 export {default as 'no-mixed-number-types'} from './no-mixed-number-types.js';
+export {default as 'no-negative-zero'} from './no-negative-zero.js';
 export {default as 'no-numeric-dotted-keys'} from './no-numeric-dotted-keys.js';
+export {default as 'no-placeholder-values'} from './no-placeholder-values.js';
+export {default as 'no-quoted-keywords'} from './no-quoted-keywords.js';
+export {default as 'no-scattered-dotted-keys'} from './no-scattered-dotted-keys.js';
+export {default as 'no-sizes-as-durations'} from './no-sizes-as-durations.js';
 export {default as 'no-unnormalized-keys'} from './no-unnormalized-keys.js';
+export {default as 'no-zero-duration-parts'} from './no-zero-duration-parts.js';
 export {default as 'numeric-separators-style'} from './numeric-separators-style.js';
 export {default as 'prefer-bare-keys'} from './prefer-bare-keys.js';
 export {default as 'prefer-literal-strings'} from './prefer-literal-strings.js';

package/rules/key-name-casing.js

@@ -25,8 +25,7 @@ const CASES = {
 const create = context => {
 	const [{case: keyCase, ignore}] = context.options;
 	const pattern = CASES[keyCase];
-	// The `u` flag, as in ESLint's own rules, because the `v` flag rejects some escapes that people write, such as `\-`.
-	const ignorePatterns = ignore.map(source => new RegExp(source, 'u'));
+	const ignorePatterns = ignore.map(source => new RegExp(source, 'v'));
 
 	context.on('KeySegment', node => {
 		// A quoted key holds data rather than a name, such as a path or a URL, so it is not checked.

package/rules/no-block-string-edge-blank-lines.js

@@ -0,0 +1,83 @@
+import {trimEnd} from './utils/index.js';
+
+/**
+@import {SomlContext} from './rule/soml-context.js';
+@import {SomlRule} from './rule/to-eslint-rule.js';
+*/
+
+const MESSAGE_ID = 'no-block-string-edge-blank-lines';
+const messages = {
+	[MESSAGE_ID]: 'Blank lines at the {{edge}} of a block string are not part of the value. To {{edge}} the value with a line break, write `\\n` in a `"""` block string.',
+};
+
+const isBlank = line => trimEnd(line, ' \t') === '';
+
+/**
+@param {SomlContext} context
+*/
+const create = context => {
+	const {sourceCode} = context;
+
+	context.on('String', function * (node) {
+		if (!node.block) {
+			return;
+		}
+
+		const lines = sourceCode.getText(node).split('\n');
+		// The first line holds the opening delimiter, and the last line the closing one.
+		const content = lines.slice(1, -1);
+		// Where each content line starts, and then where the closing line starts.
+		const lineStarts = [sourceCode.getRange(node)[0] + lines[0].length + 1];
+
+		for (const line of content) {
+			lineStarts.push(lineStarts.at(-1) + line.length + 1);
+		}
+
+		const firstContent = content.findIndex(line => !isBlank(line));
+		// With no content, every line is a leading blank line.
+		const startOfContent = firstContent === -1 ? content.length : firstContent;
+		const endOfContent = Math.max(content.findLastIndex(line => !isBlank(line)) + 1, startOfContent);
+
+		// Each range covers whole lines, with their line breaks.
+		const edges = [
+			['start', [lineStarts[0], lineStarts[startOfContent]]],
+			['end', [lineStarts[endOfContent], lineStarts.at(-1)]],
+		];
+
+		for (const [edge, range] of edges) {
+			if (range[0] === range[1]) {
+				continue;
+			}
+
+			yield {
+				loc: {
+					start: sourceCode.getLocFromIndex(range[0]),
+					// Not the line break after the last blank line.
+					end: sourceCode.getLocFromIndex(range[1] - 1),
+				},
+				messageId: MESSAGE_ID,
+				data: {edge},
+				fix: fixer => fixer.removeRange(range),
+			};
+		}
+	});
+};
+
+/**
+@type {SomlRule}
+*/
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow blank lines at the start and end of block strings.',
+			recommended: true,
+		},
+		fixable: 'code',
+		messages,
+		languages: ['soml/soml'],
+	},
+};
+
+export default config;

package/rules/no-block-string-trailing-whitespace.js

@@ -1,3 +1,5 @@
+import {trimEnd} from './utils/index.js';
+
 /**
 @import {SomlContext} from './rule/soml-context.js';
 @import {SomlRule} from './rule/to-eslint-rule.js';
@@ -8,9 +10,6 @@ const messages = {
 	[MESSAGE_ID]: 'Whitespace at the end of a line in a block string is part of the value, and editors often remove it.',
 };
 
-const TRAILING_WHITESPACE = /[\t ]+$/v;
-const BLANK_LINE = /^[\t ]*$/v;
-
 /**
 @param {SomlContext} context
 */
@@ -27,13 +26,13 @@ const create = context => {
 
 		// The first line holds the opening delimiter, and the last line the closing one.
 		for (const line of lines.slice(1, -1)) {
-			const match = TRAILING_WHITESPACE.exec(line);
+			const content = trimEnd(line, ' \t');
 
 			// A blank line becomes an empty line, so its whitespace is not part of the value.
-			if (match && !BLANK_LINE.test(line)) {
+			if (content !== '' && content.length < line.length) {
 				yield {
 					loc: {
-						start: sourceCode.getLocFromIndex(offset + match.index),
+						start: sourceCode.getLocFromIndex(offset + content.length),
 						end: sourceCode.getLocFromIndex(offset + line.length),
 					},
 					messageId: MESSAGE_ID,

package/rules/no-confusable-keys.js

@@ -0,0 +1,75 @@
+import {trimWhitespace} from './utils/index.js';
+
+/**
+@import {SomlContext} from './rule/soml-context.js';
+@import {SomlRule} from './rule/to-eslint-rule.js';
+*/
+
+const MESSAGE_ID = 'no-confusable-keys';
+const messages = {
+	[MESSAGE_ID]: '`{{key}}` and `{{otherKey}}` are one key to a program that ignores case, `-` versus `_`, or surrounding whitespace.',
+};
+
+/*
+What many programs compare keys by: case-insensitive, with `-` and `_` the same, and without surrounding whitespace.
+*/
+const fold = key => trimWhitespace(key).toLowerCase().replaceAll('-', '_');
+
+/**
+@param {SomlContext} context
+*/
+const create = context => {
+	context.on('Object', function * (node) {
+		/*
+		The first key seen for each folded key, as a tree that follows the key paths. A dotted key adds a key to each object on its path, so the keys under two spellings of one prefix are compared as one object.
+		*/
+		const root = new Map();
+
+		for (const {key} of node.members) {
+			let keys = root;
+
+			for (const segment of key.segments) {
+				const folded = fold(segment.value);
+				let entry = keys.get(folded);
+
+				if (entry === undefined) {
+					entry = {first: segment, keys: new Map(), reported: new Set()};
+					keys.set(folded, entry);
+				} else if (entry.first.value !== segment.value && !entry.reported.has(segment.value)) {
+					// Each pair of spellings is reported once, even when a dotted key repeats one of them.
+					entry.reported.add(segment.value);
+
+					yield {
+						node: segment,
+						messageId: MESSAGE_ID,
+						// The source text shows the quotes, so a key with whitespace stays readable.
+						data: {
+							key: context.sourceCode.getText(segment),
+							otherKey: context.sourceCode.getText(entry.first),
+						},
+					};
+				}
+
+				keys = entry.keys;
+			}
+		}
+	});
+};
+
+/**
+@type {SomlRule}
+*/
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow keys that differ only in case, `-` and `_`, or surrounding whitespace.',
+			recommended: 'unopinionated',
+		},
+		messages,
+		languages: ['soml/soml'],
+	},
+};
+
+export default config;

package/rules/no-decimal-file-modes.js

@@ -0,0 +1,91 @@
+/**
+@import {SomlContext} from './rule/soml-context.js';
+@import {SomlRule} from './rule/to-eslint-rule.js';
+*/
+
+const MESSAGE_ID_ERROR = 'no-decimal-file-modes/error';
+const MESSAGE_ID_SUGGESTION = 'no-decimal-file-modes/suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: '`{{number}}` is a decimal number, so this file mode is `{{octal}}`. A file mode is octal, as in `0o{{number}}`.',
+	[MESSAGE_ID_SUGGESTION]: 'Write it as `0o{{number}}`.',
+};
+
+/*
+A key for a file mode: `mode`, `perm`, `perms`, `permissions`, or `chmod`, alone or after `-` or `_` (`file-mode`), or `Mode` at the end of a camelCase key (`defaultMode`). A umask is left out, because it lists the permissions to remove, so what makes a mode sensible does not apply to it.
+*/
+const MODE_KEY = /(?:^|[\-_])(?:chmod|mode|perms?|permissions)$|[a-z]Mode$/v;
+const OCTAL_DIGITS = /^[0-7]{3,4}$/v;
+
+/*
+Whether a number is a sensible file mode, as ansible-lint's `risky-octal` rule decides: no write or execute permission without read permission, except execute alone when the owner can execute, and the owner has at least the permissions of the group, and the group at least those of others.
+*/
+function isSensibleMode(mode) {
+	const user = Math.trunc(mode / 64) % 8;
+	const group = Math.trunc(mode / 8) % 8;
+	const other = mode % 8;
+	const hasWriteWithoutRead = (digit, isUser = false) => digit !== 0 && digit < 4 && !(digit === 1 && (isUser || user % 2 === 1));
+
+	return !hasWriteWithoutRead(user, true)
+		&& !hasWriteWithoutRead(group)
+		&& !hasWriteWithoutRead(other)
+		&& user >= group
+		&& group >= other;
+}
+
+/**
+@param {SomlContext} context
+*/
+const create = context => {
+	const {sourceCode} = context;
+
+	context.on('Member', member => {
+		const {key, value} = member;
+
+		if (value.type !== 'Integer' || value.radix !== 10 || !MODE_KEY.test(key.segments.at(-1).value)) {
+			return;
+		}
+
+		const number = sourceCode.getText(value);
+		const decimal = Number(value.value);
+
+		// The digits look octal, and the value makes no sense as a mode, but the same digits read as octal do.
+		if (!OCTAL_DIGITS.test(number) || isSensibleMode(decimal) || !isSensibleMode(Number.parseInt(number, 8))) {
+			return;
+		}
+
+		return {
+			node: value,
+			messageId: MESSAGE_ID_ERROR,
+			data: {
+				number,
+				octal: `0o${decimal.toString(8)}`,
+			},
+			suggest: [
+				{
+					messageId: MESSAGE_ID_SUGGESTION,
+					data: {number},
+					fix: fixer => fixer.replaceText(value, `0o${number}`),
+				},
+			],
+		};
+	});
+};
+
+/**
+@type {SomlRule}
+*/
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow file modes written as decimal numbers.',
+			recommended: 'unopinionated',
+		},
+		hasSuggestions: true,
+		messages,
+		languages: ['soml/soml'],
+	},
+};
+
+export default config;