eslint-soml 0.0.2 → 0.0.3

package/index.d.ts

@@ -7,7 +7,6 @@ export type {
 	MemberNode,
 	ArrayNode,
 	KeyNode,
-	KeySegmentNode,
 	ValueNode,
 	StringNode,
 	IntegerNode,

package/language/soml-source-code.js

@@ -16,6 +16,28 @@ const INLINE_CONFIG = /^\s*eslint(?:-enable|-disable(?:(?:-next)?-line)?)?(?:\s|
 
 const isComment = item => item.type === 'Line' || item.type === 'Block';
 
+/*
+Merges the tokens and the comments, which are each in source order, into one list in source order. A merge takes linear time, where a sort would not.
+*/
+function mergeByStart(tokens, comments) {
+	const items = [];
+	let commentIndex = 0;
+
+	for (const token of tokens) {
+		while (commentIndex < comments.length && comments[commentIndex].range[0] < token.range[0]) {
+			items.push(comments[commentIndex++]);
+		}
+
+		items.push(token);
+	}
+
+	while (commentIndex < comments.length) {
+		items.push(comments[commentIndex++]);
+	}
+
+	return items;
+}
+
 /**
 The source code of a SOML document, which rules get as `context.sourceCode`.
 */
@@ -48,7 +70,7 @@ export default class SomlSourceCode extends TextSourceCodeBase {
 		// 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]);
+		this.#items = mergeByStart(ast.tokens, ast.comments);
 	}
 
 	/*

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-soml",
-	"version": "0.0.2",
+	"version": "0.0.3",
 	"description": "ESLint plugin for SOML, a config format for humans",
 	"license": "MIT",
 	"repository": "github:soml-lang/eslint-soml",
@@ -52,8 +52,7 @@
 	],
 	"dependencies": {
 		"@eslint/plugin-kit": "^0.7.3",
-		"natural-compare": "^1.4.0",
-		"soml-lang": "^0.0.3"
+		"soml-lang": "^0.0.4"
 	},
 	"devDependencies": {
 		"@babel/code-frame": "^8.0.6",

package/readme.md

@@ -2,6 +2,8 @@
 
 > ESLint plugin for [SOML](https://github.com/soml-lang/soml), a config format for humans
 
+[`eslint-plugin-unicorn`](https://github.com/sindresorhus/eslint-plugin-unicorn#soml) has more rules that also lint SOML, such as `prefer-https` and `name-replacements`.
+
 [**Propose a new rule ➡**](.github/contributing.md)
 
 *We do not accept pull requests because of too much AI slop.*
@@ -61,7 +63,7 @@ Disable a rule with a comment, in either comment style:
 
 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`:
+ESLint's [`no-restricted-syntax`](https://eslint.org/docs/latest/rules/no-restricted-syntax) rule works too. For example, to disallow a key named `password`:
 
 ```js
 import soml from 'eslint-soml';
@@ -75,7 +77,7 @@ export default defineConfig([
 			'no-restricted-syntax': [
 				'error',
 				{
-					selector: 'Member > Key > KeySegment[value="password"]',
+					selector: 'Member > Key[value="password"]',
 					message: 'Read the password from the environment.',
 				},
 			],
@@ -113,10 +115,8 @@ export default defineConfig([
 | [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.                                          | ✅    | 🔧 |    |

package/rules/format.js

@@ -1,4 +1,5 @@
 import {formatEdits} from 'soml-lang';
+import {isDisabledAnywhere} from './utils/index.js';
 
 /**
 @import {SomlContext} from './rule/soml-context.js';
@@ -32,6 +33,12 @@ const create = context => {
 		const {text} = sourceCode;
 		const edits = formatEdits(text);
 
+		if (edits.length === 0) {
+			return;
+		}
+
+		const isFixable = !isDisabledAnywhere(context);
+
 		// 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;
@@ -54,8 +61,8 @@ const create = context => {
 					deleted: showInvisibles(deleted),
 					inserted: showInvisibles(inserted),
 				},
-				// 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
+				// 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. There is no fix when a directive turns the rule off anywhere, because the fix would change those lines too.
+				fix: index === 0 && isFixable
 					? function * (fixer) {
 						// eslint-disable-next-line internal/no-restricted-property-access -- An edit is not a node.
 						for (const {range, text} of edits) {

package/rules/index.js

@@ -16,10 +16,8 @@ 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';

package/rules/key-name-casing.js

@@ -27,7 +27,7 @@ const create = context => {
 	const pattern = CASES[keyCase];
 	const ignorePatterns = ignore.map(source => new RegExp(source, 'v'));
 
-	context.on('KeySegment', node => {
+	context.on('Key', node => {
 		// A quoted key holds data rather than a name, such as a path or a URL, so it is not checked.
 		if (
 			node.style !== 'bare'

package/rules/no-confusable-keys.js

@@ -21,37 +21,28 @@ const fold = key => trimWhitespace(key).toLowerCase().replaceAll('-', '_');
 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.
+		The first key seen for each folded key.
 		*/
-		const root = new Map();
+		const firstKeys = new Map();
 
 		for (const {key} of node.members) {
-			let keys = root;
+			const folded = fold(key.value);
+			const firstKey = firstKeys.get(folded);
 
-			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;
+			if (firstKey === undefined) {
+				firstKeys.set(folded, key);
+				continue;
 			}
+
+			yield {
+				node: key,
+				messageId: MESSAGE_ID,
+				// The source text shows the quotes, so a key with whitespace stays readable.
+				data: {
+					key: context.sourceCode.getText(key),
+					otherKey: context.sourceCode.getText(firstKey),
+				},
+			};
 		}
 	});
 };

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

@@ -1,3 +1,5 @@
+import {getKeyWords} from './utils/index.js';
+
 /**
 @import {SomlContext} from './rule/soml-context.js';
 @import {SomlRule} from './rule/to-eslint-rule.js';
@@ -11,15 +13,20 @@ const messages = {
 };
 
 /*
-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.
+The last word of a key for a file mode, as in `mode`, `file-mode`, `defaultMode`, `FILE_UPLOAD_PERMISSIONS` (Django), or `'listen.mode'` (PHP-FPM). 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 MODE_WORDS = new Set(['chmod', 'mode', 'perm', 'perms', 'permissions']);
 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) {
+	// A mode has 12 bits, so a larger number is not one, whatever its low digits are.
+	if (mode > 0o7777) {
+		return false;
+	}
+
 	const user = Math.trunc(mode / 64) % 8;
 	const group = Math.trunc(mode / 8) % 8;
 	const other = mode % 8;
@@ -41,7 +48,7 @@ const create = context => {
 	context.on('Member', member => {
 		const {key, value} = member;
 
-		if (value.type !== 'Integer' || value.radix !== 10 || !MODE_KEY.test(key.segments.at(-1).value)) {
+		if (value.type !== 'Integer' || value.radix !== 10 || !MODE_WORDS.has(getKeyWords(key.value).at(-1))) {
 			return;
 		}
 

package/rules/no-duplicate-array-items.js

@@ -1,3 +1,4 @@
+import {stringifyValue} from 'soml-lang';
 import {hasAdjacentComment, isPunctuator} from './utils/index.js';
 
 /**
@@ -71,7 +72,8 @@ const create = context => {
 				node: item,
 				messageId: MESSAGE_ID_ERROR,
 				data: {
-					item: sourceCode.getText(item),
+					// A block string spans lines, so it is shown as a one-line string with the same value.
+					item: item.block ? stringifyValue(item.value) : sourceCode.getText(item),
 					line: sourceCode.getLoc(first).start.line,
 				},
 				// Removing an item changes the value, so it is a suggestion. It is left out when it would remove a comment.

package/rules/no-empty-keys.js

@@ -14,7 +14,7 @@ const messages = {
 @param {SomlContext} context
 */
 const create = context => {
-	context.on('KeySegment', node => {
+	context.on('Key', node => {
 		if (trimWhitespace(node.value) !== '') {
 			return;
 		}

package/rules/no-invisible-characters.js

@@ -8,7 +8,7 @@ import {
 /**
 @import {SomlContext} from './rule/soml-context.js';
 @import {SomlRule} from './rule/to-eslint-rule.js';
-@import {StringNode, KeySegmentNode, Comment} from 'soml-lang';
+@import {StringNode, KeyNode, Comment} from 'soml-lang';
 */
 
 const MESSAGE_ID_ESCAPE = 'no-invisible-characters/escape';
@@ -29,7 +29,7 @@ const create = context => {
 	/**
 	One problem per invisible character in `node`.
 
-	@param {StringNode | KeySegmentNode | Comment} node
+	@param {StringNode | KeyNode | Comment} node
 	*/
 	function * getProblems(node) {
 		const [nodeStart] = sourceCode.getRange(node);
@@ -78,7 +78,7 @@ const create = context => {
 		}
 	}
 
-	context.on(['String', 'KeySegment'], node => {
+	context.on(['String', 'Key'], node => {
 		if (node.style !== 'bare') {
 			return getProblems(node);
 		}

package/rules/no-misplaced-block-string-delimiters.js

@@ -47,15 +47,22 @@ const create = context => {
 				content = trimEnd(content.slice(0, -1), ' \t');
 			}
 
-			const index = content.length - delimiter.length;
+			// Where the run of quotes at the end starts.
+			let index = content.length;
+
+			while (index > 0 && content[index - 1] === delimiter[0]) {
+				index--;
+			}
+
+			// In a `"""` block, `\"` is an escaped quote, so it is not part of the run.
+			if (node.style === 'escaped' && content.length - index >= delimiter.length && ESCAPING_BACKSLASHES.test(content.slice(0, index))) {
+				index++;
+			}
 
 			if (
 				index > 0
-				&& content.endsWith(delimiter)
-				&& content[index - 1] !== delimiter[0]
+				&& content.length - index === delimiter.length
 				&& !isClosingQuote(content, index, delimiter)
-				// In a `"""` block, `\"` is an escaped quote, so the run is shorter than the delimiter.
-				&& !(node.style === 'escaped' && ESCAPING_BACKSLASHES.test(content.slice(0, index)))
 			) {
 				const start = offset + index;
 

package/rules/no-placeholder-values.js

@@ -1,3 +1,5 @@
+import {escapeInvisibleCharacters} from './utils/index.js';
+
 /**
 @import {SomlContext} from './rule/soml-context.js';
 @import {SomlRule} from './rule/to-eslint-rule.js';
@@ -9,9 +11,9 @@ const messages = {
 };
 
 /*
-Words that a placeholder uses to label itself, as a whole token, so that `replacements` does not match: `changeme`, `CHANGE_ME`, `replace-me`, and `your_api_key_here`. The words are joined by `-` or `_`, not a space, so that prose such as "Set your password here" does not match. The part between `your` and `here` is limited, so a long string cannot make the search slow.
+Words that a placeholder uses to label itself, as a whole token, so that `replacements` does not match: `changeme`, `CHANGE_ME`, `replace-me`, and `your_api_key_here`. Digits may follow, as in `ChangeMe123!`, because a password policy often asks for them. The words are joined by `-` or `_`, not a space, so that prose such as "Set your password here" does not match. The part between `your` and `here` is limited, so a long string cannot make the search slow.
 */
-const PLACEHOLDER_WORDS = /(?:^|[^\da-z])(?:(?:change|replace)[\-_]?me|your[\-_][\w\-]{0,40}?[\-_]here)(?:$|[^\da-z])/iv;
+const PLACEHOLDER_WORDS = /(?:^|[^\da-z])(?:(?:change|replace)[\-_]?me|your[\-_][\w\-]{0,40}?[\-_]here)(?:$|[^a-z])/iv;
 
 /*
 A whole value that marks missing work. In uppercase only, because `Todo` is also a word.
@@ -22,7 +24,24 @@ const MARKER = /^(?:FIXME|TBD|TODO)$/v;
 @param {SomlContext} context
 */
 const create = context => {
-	context.on('String', node => {
+	/*
+	Whether each array is a list of markers, found once per array.
+	*/
+	const markerLists = new WeakMap();
+
+	/*
+	Whether an array holds two different markers, as a linter's list of comment tags does, such as `['TODO', 'FIXME']`. Then the markers are data, not placeholders.
+	*/
+	const isMarkerList = array => {
+		if (!markerLists.has(array)) {
+			const markers = new Set(array.elements.filter(element => element.type === 'String' && MARKER.test(element.value)).map(element => element.value));
+			markerLists.set(array, markers.size > 1);
+		}
+
+		return markerLists.get(array);
+	};
+
+	context.on('String', (node, parent) => {
 		const {value} = node;
 		const isMarker = MARKER.test(value);
 
@@ -30,11 +49,15 @@ const create = context => {
 			return;
 		}
 
+		if (isMarker && parent.type === 'Array' && isMarkerList(parent)) {
+			return;
+		}
+
 		return {
 			node,
 			messageId: MESSAGE_ID,
 			// A placeholder word never spans lines, so the message shows only its line of a block string. A marker counts only as the whole value, so a `TODO` line is not that line.
-			data: {value: isMarker ? value : value.split('\n').find(line => PLACEHOLDER_WORDS.test(line))},
+			data: {value: escapeInvisibleCharacters(isMarker ? value : value.split('\n').find(line => PLACEHOLDER_WORDS.test(line)))},
 		};
 	});
 };

package/rules/no-sizes-as-durations.js

@@ -23,14 +23,12 @@ Words that name a size at the end of a longer key, as in `max-size` or `buffer_b
 const SIZE_ENDINGS = new Set(['bytes', 'size']);
 
 /*
-Words that make a key about time, such as `window-size`, `cpu-time`, `chunk-size` in a time-series database, or `cache-expiry`. A plural, such as `intervals`, counts too.
+Words that make a key about time, such as `window-size`, `cpu-time`, or `cache-expiry`. A plural, such as `intervals`, counts too. `block` and `chunk` are not, because a block size or a chunk size is in bytes, as in Hadoop, Spark, RocksDB, and Fluentd, and a block or chunk duration is named with `duration`.
 */
 const TIME_WORDS = new Set([
 	'age',
 	'backoff',
-	'block',
 	'bucket',
-	'chunk',
 	'cooldown',
 	'deadline',
 	'delay',
@@ -75,7 +73,7 @@ function isSizeKey(key) {
 */
 const create = context => {
 	context.on('Member', ({key, value}) => {
-		if (value.type !== 'Duration' || !isSizeLike(value) || !isSizeKey(key.segments.at(-1).value)) {
+		if (value.type !== 'Duration' || !isSizeLike(value) || !isSizeKey(key.value)) {
 			return;
 		}
 

package/rules/no-unnormalized-keys.js

@@ -1,3 +1,5 @@
+import {escapeInvisibleCharacters} from './utils/index.js';
+
 /**
 @import {SomlContext} from './rule/soml-context.js';
 @import {SomlRule} from './rule/to-eslint-rule.js';
@@ -14,7 +16,7 @@ const messages = {
 const create = context => {
 	const [{form}] = context.options;
 
-	context.on('KeySegment', node => {
+	context.on('Key', node => {
 		if (node.value.normalize(form) === node.value) {
 			return;
 		}
@@ -23,7 +25,7 @@ const create = context => {
 			node,
 			messageId: MESSAGE_ID,
 			data: {
-				key: node.value,
+				key: escapeInvisibleCharacters(node.value),
 				form,
 			},
 		};

package/rules/prefer-bare-keys.js

@@ -1,5 +1,4 @@
 import {isBareKey} from 'soml-lang';
-import {isDecimalPoint} from './utils/index.js';
 
 /**
 @import {SomlContext} from './rule/soml-context.js';
@@ -11,36 +10,22 @@ const messages = {
 	[MESSAGE_ID]: 'The key `{{key}}` does not need quotes.',
 };
 
-/*
-The value of a segment that is bare or can be, or an empty string for a segment that must be quoted or is missing.
-*/
-const getBareValue = segment => segment !== undefined && isBareKey(segment.value) ? segment.value : '';
-
 /**
 @param {SomlContext} context
 */
 const create = context => {
-	context.on('Key', function * (key) {
-		for (const [index, node] of key.segments.entries()) {
-			if (node.style === 'bare' || !isBareKey(node.value)) {
-				continue;
-			}
-
-			// Without quotes, a digit on both sides of a `.` reads as a number, as in `1.5`, which `no-numeric-dotted-keys` reports. A neighbor that must keep its quotes, as in `'a 1'`, does not.
-			const previous = getBareValue(key.segments[index - 1]);
-			const next = getBareValue(key.segments[index + 1]);
-
-			if (isDecimalPoint(previous, node.value) || isDecimalPoint(node.value, next)) {
-				continue;
-			}
-
-			yield {
-				node,
-				messageId: MESSAGE_ID,
-				data: {key: node.value},
-				fix: fixer => fixer.replaceText(node, node.value),
-			};
+	context.on('Key', node => {
+		// A key with a `.` is not a bare key, so `'a.b'` keeps its quotes. Without them, `a.b` is a parse error.
+		if (node.style === 'bare' || !isBareKey(node.value)) {
+			return;
 		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			data: {key: node.value},
+			fix: fixer => fixer.replaceText(node, node.value),
+		};
 	});
 };
 

package/rules/prefer-literal-strings.js

@@ -3,7 +3,7 @@ import {canBeLiteral, hasDoubledBackslashes, hasInvisibleCharacter} from './util
 /**
 @import {SomlContext} from './rule/soml-context.js';
 @import {SomlRule} from './rule/to-eslint-rule.js';
-@import {StringNode, KeySegmentNode} from 'soml-lang';
+@import {StringNode, KeyNode} from 'soml-lang';
 */
 
 const MESSAGE_ID = 'prefer-literal-strings';
@@ -14,7 +14,7 @@ const messages = {
 /**
 The literal spelling of a string or key with the same value, or `undefined` when there is none.
 
-@param {StringNode | KeySegmentNode} node
+@param {StringNode | KeyNode} node
 @param {string} text The source text of the node.
 @returns {string | undefined}
 */
@@ -39,7 +39,7 @@ function getLiteral(node, text) {
 @param {SomlContext} context
 */
 const create = context => {
-	context.on(['String', 'KeySegment'], node => {
+	context.on(['String', 'Key'], node => {
 		if (node.style !== 'escaped') {
 			return;
 		}

package/rules/sort-keys.js

@@ -1,6 +1,5 @@
-import naturalCompare from 'natural-compare';
 import {compareKeys} from 'soml-lang';
-import {reorderMembers} from './utils/index.js';
+import {isDisabledAnywhere, reorderMembers} from './utils/index.js';
 
 /**
 @import {SomlContext} from './rule/soml-context.js';
@@ -13,14 +12,71 @@ const messages = {
 	[MESSAGE_ID]: 'Expected keys to be in {{sortName}} case-{{sensitivity}} {{direction}} order. `{{thisName}}` should be before `{{previousName}}`.',
 };
 
+const isDigit = character => character >= '0' && character <= '9';
+
+/*
+The end of the run of digits that starts at `index`.
+*/
+function getDigitsEnd(text, index) {
+	while (index < text.length && isDigit(text[index])) {
+		index++;
+	}
+
+	return index;
+}
+
+/*
+Compares two keys by code point, as canonical form does, except that two runs of digits at the same place are compared by their value, so `a2` comes before `a10` and `a9` before `a010`. A value has any number of digits, so the runs are compared as text, without their leading zeros. When only the leading zeros differ, as in `a01` and `a1`, code point order decides, so two different keys are never equal.
+*/
+function compareNatural(first, second) {
+	let firstIndex = 0;
+	let secondIndex = 0;
+
+	while (firstIndex < first.length && secondIndex < second.length) {
+		if (isDigit(first[firstIndex]) && isDigit(second[secondIndex])) {
+			const firstEnd = getDigitsEnd(first, firstIndex);
+			const secondEnd = getDigitsEnd(second, secondIndex);
+			const firstNumber = first.slice(firstIndex, firstEnd).replace(/^0+/v, '');
+			const secondNumber = second.slice(secondIndex, secondEnd).replace(/^0+/v, '');
+
+			if (firstNumber.length !== secondNumber.length) {
+				return firstNumber.length - secondNumber.length;
+			}
+
+			if (firstNumber !== secondNumber) {
+				return firstNumber < secondNumber ? -1 : 1;
+			}
+
+			firstIndex = firstEnd;
+			secondIndex = secondEnd;
+			continue;
+		}
+
+		const firstCodePoint = first.codePointAt(firstIndex);
+		const secondCodePoint = second.codePointAt(secondIndex);
+
+		if (firstCodePoint !== secondCodePoint) {
+			return firstCodePoint - secondCodePoint;
+		}
+
+		// The two code points are equal, so they have the same length.
+		const length = firstCodePoint > 0xFF_FF ? 2 : 1;
+		firstIndex += length;
+		secondIndex += length;
+	}
+
+	// A key that ends first comes first, as `a` before `a1`.
+	return (first.length - firstIndex) - (second.length - secondIndex) || compareKeys(first, second);
+}
+
 /**
 @param {SomlContext} context
 */
 const create = context => {
 	const {sourceCode} = context;
 	const [direction, {caseSensitive, natural, minKeys, allowLineSeparatedGroups}] = context.options;
-	// Without `natural`, keys are in the order of canonical form, by code point. The `<` operator compares UTF-16 code units, which puts an emoji before U+FF61.
-	const compare = natural ? naturalCompare : compareKeys;
+	// Keys are in the order of canonical form, by code point. The `<` operator compares UTF-16 code units, which puts an emoji before U+FF61.
+	const compare = natural ? compareNatural : compareKeys;
 	const normalize = caseSensitive ? name => name : name => name.toLowerCase();
 	const sign = direction === 'asc' ? 1 : -1;
 
@@ -56,25 +112,11 @@ const create = context => {
 		}
 
 		/*
-		The decoded key paths, so `'a'` and `a` sort the same. Paths are compared segment by segment, and a path sorts before the longer paths it starts, so the members under one dotted prefix stay together, and a quoted `'a.b'` is not mixed in with them.
+		The decoded keys, so `'a'` and `a` sort the same.
 		*/
-		const paths = new Map(node.members.map(member => [member, member.key.segments.map(segment => normalize(segment.value))]));
-
-		const compareMembers = (first, second) => {
-			const firstPath = paths.get(first);
-			const secondPath = paths.get(second);
-
-			// eslint-disable-next-line unicorn/prefer-iterator-zip -- `Iterator.zip()` is not in Node.js 22.
-			for (let index = 0; index < Math.min(firstPath.length, secondPath.length); index++) {
-				const difference = compare(firstPath[index], secondPath[index]);
-
-				if (difference !== 0) {
-					return sign * difference;
-				}
-			}
+		const keys = new Map(node.members.map(member => [member, normalize(member.key.value)]));
 
-			return sign * (firstPath.length - secondPath.length);
-		};
+		const compareMembers = (first, second) => sign * compare(keys.get(first), keys.get(second));
 
 		// A blank line starts a group that is sorted on its own, when that is allowed.
 		const groups = [];
@@ -110,7 +152,7 @@ const create = context => {
 						sortName: natural ? 'natural' : 'code point',
 					},
 					// The fix sorts the whole object at once, so one run of `--fix` is enough, and only the first problem carries it. Giving every problem the same fix would build it once per problem.
-					fix: isFirst ? reorderMembers(context, node.members, groups.flatMap(group => group.toSorted(compareMembers))) : undefined,
+					fix: isFirst && !isDisabledAnywhere(context) ? reorderMembers(context, node.members, groups.flatMap(group => group.toSorted(compareMembers))) : undefined,
 				};
 
 				isFirst = false;

package/rules/spaced-comment.js

@@ -18,9 +18,9 @@ const BLOCK_START = /^\**(?=[^\s*])/v;
 const BLOCK_END = /(?<=[^\s*])\**$/v;
 
 /*
-A line comment that is only a hex color, as in `#ff0000`, is almost always a color meant as an array item, which `#` turned into a comment. Adding a space would hide that mistake, so the rule leaves it.
+A line comment that is only a hex color, as in `#ff0000`, is almost always a color meant as an array item, which `#` turned into a comment. Adding a space would hide that mistake, so the rule leaves it, also with whitespace or another comment after it, as in `#ff0000 # red`.
 */
-const HEX_COLOR = /^(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8}),?$/iv;
+const HEX_COLOR = /^(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8}),?(?:[\t ]+(?:#|\/\*).*|[\t ]*)$/iv;
 
 /**
 @param {SomlContext} context

package/rules/utils/escape-string.js

@@ -12,6 +12,16 @@ export function toUnicodeEscape(character) {
 	return String.raw`\u{${character.codePointAt(0).toString(16)}}`;
 }
 
+/**
+Write every invisible character in `text` as a `\u{…}` escape, such as for a decoded value in a message, where a control character could change the terminal and a bidirectional control could reorder the text.
+
+@param {string} text
+@returns {string}
+*/
+export function escapeInvisibleCharacters(text) {
+	return text.replaceAll(invisibleCharacters, character => toUnicodeEscape(character));
+}
+
 /**
 Write `value` as a `"..."` string. `\`, `"`, LF, and tab use their short escapes, and every invisible character uses a `\u{…}` escape.
 
@@ -23,10 +33,9 @@ export function toEscapedString(value) {
 		.replaceAll('\\', '\\\\')
 		.replaceAll('"', String.raw`\"`)
 		.replaceAll('\n', String.raw`\n`)
-		.replaceAll('\t', String.raw`\t`)
-		.replaceAll(invisibleCharacters, character => toUnicodeEscape(character));
+		.replaceAll('\t', String.raw`\t`);
 
-	return `"${escaped}"`;
+	return `"${escapeInvisibleCharacters(escaped)}"`;
 }
 
 /**

package/rules/utils/get-key-words.js

@@ -1,9 +1,11 @@
 /**
-The words of a key, in lowercase: `maxHeapSize`, `max-heap-size`, and `max_heap_size` all give `max`, `heap`, and `size`. A quoted key may hold dots, as Spark writes `'spark.executor.memory'`, so `.` separates words too.
+The words of a key, in lowercase: `maxHeapSize`, `max-heap-size`, and `max_heap_size` all give `max`, `heap`, and `size`. An acronym is a word too, so `maxRAMSize` gives `max`, `ram`, and `size`. Every character that is not a letter or a digit separates words, so a quoted key works too, as in `'spark.executor.memory'` (Spark) or `'php_admin_value[memory_limit]'` (PHP-FPM). A separator at an end or next to another one makes no empty word, so `_size` is one word.
 
 @param {string} key
 @returns {string[]}
 */
 export default function getKeyWords(key) {
-	return key.split(/[\-._]|(?<=[\da-z])(?=[A-Z])/v).map(word => word.toLowerCase());
+	return key.split(/[^\p{Letter}\p{Number}]|(?<=[\da-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/v)
+		.filter(word => word !== '')
+		.map(word => word.toLowerCase());
 }

package/rules/utils/has-doubled-backslashes.js

@@ -1,16 +1,17 @@
 const BACKSLASH_RUN = /\\+/gv;
 const DOUBLED_ESCAPE = /\\\\[.DSWbdsw]/v;
+const QUOTE = /["']/v;
 
 /**
 Whether every backslash in a value is doubled, as in `^\\d+$`, the way a JSON or JavaScript string writes a regex escape. In a literal string, `\\` is two backslashes, so such a value most likely came from a `"…"` string and was meant with one.
 
-A Windows network path, as in `\\server\share`, has a single backslash too, so it is not counted. A value that holds a `"`, as JSON text in a string does, is not counted either.
+A Windows network path, as in `\\server\share`, has a single backslash too, so it is not counted. A value that holds a quote is not counted either, because it is code with strings in it, which doubles its backslashes on purpose, as JSON text does with `"` and a JavaScript or SQL snippet in a block string can with `'`.
 
 @param {string} value
 @returns {boolean}
 */
 export default function hasDoubledBackslashes(value) {
 	return DOUBLED_ESCAPE.test(value)
-		&& !value.includes('"')
+		&& !QUOTE.test(value)
 		&& value.match(BACKSLASH_RUN).every(run => run.length % 2 === 0);
 }

package/rules/utils/index.js

@@ -1,9 +1,14 @@
 export {invisibleCharacters, hasInvisibleCharacter} from './invisible-characters.js';
-export {toUnicodeEscape, toEscapedString, canBeLiteral} from './escape-string.js';
-export {default as isDecimalPoint} from './is-decimal-point.js';
+export {
+	toUnicodeEscape,
+	escapeInvisibleCharacters,
+	toEscapedString,
+	canBeLiteral,
+} from './escape-string.js';
 export {reorderMembers, hasAdjacentComment} from './reorder-members.js';
 export {default as trimWhitespace} from './trim-whitespace.js';
 export {isComment, isPunctuator} from './token.js';
 export {default as trimEnd} from './trim-end.js';
 export {default as hasDoubledBackslashes} from './has-doubled-backslashes.js';
 export {default as getKeyWords} from './get-key-words.js';
+export {default as isDisabledAnywhere} from './is-disabled-anywhere.js';

package/rules/utils/invisible-characters.js

@@ -1,7 +1,11 @@
 /**
-Characters that a reader cannot see, or cannot tell apart from a space: bidirectional controls (as in Trojan Source), zero-width characters, the byte order mark, the soft hyphen, control characters, and every Unicode whitespace character except space, tab, and line feed. Zero-width joiners and non-joiners are left out, because emoji sequences and several scripts need them.
+Characters that a reader cannot see, or cannot tell apart from a space: bidirectional controls (as in Trojan Source), zero-width characters (including the invisible math operators U+2061 to U+2064), the Hangul fillers, which show as blank, other invisible format characters (U+180E and U+206A to U+206F), the byte order mark, the soft hyphen, control characters, and every Unicode whitespace character except space, tab, and line feed. Zero-width joiners and non-joiners are left out, because emoji sequences and several scripts need them.
+
+Tag characters are invisible too, and can hide text, as in ASCII smuggling. They are left out only in an emoji tag sequence, which is U+1F3F4 and then tags up to U+E007F, as in the flag of Scotland. Such a sequence is short, so the lookbehind is bounded.
 */
-const invisibleCharacter = /[[\p{Control}\p{White_Space}\u{AD}\u{61C}\u{200B}\u{200E}\u{200F}\u{202A}-\u{202E}\u{2060}\u{2066}-\u{2069}\u{FEFF}]--[\t\n ]]/v;
+const characters = /[[\p{Control}\p{White_Space}\u{AD}\u{61C}\u{115F}\u{1160}\u{180E}\u{200B}\u{200E}\u{200F}\u{202A}-\u{202E}\u{2060}-\u{2064}\u{2066}-\u{206F}\u{3164}\u{FEFF}\u{FFA0}]--[\t\n ]]/v;
+const tags = /(?<!\u{1F3F4}[\u{E0020}-\u{E007E}]{0,32})[\u{E0001}\u{E0020}-\u{E007F}]/v;
+const invisibleCharacter = new RegExp(`${characters.source}|${tags.source}`, 'v');
 
 /**
 The same characters, with the `g` flag. Use it only with `String#matchAll()` and `String#replaceAll()`, which start from the beginning when `lastIndex` is 0 and leave it at 0, so the shared regex holds no state between uses.

package/rules/utils/is-disabled-anywhere.js

@@ -0,0 +1,19 @@
+import {ConfigCommentParser} from '@eslint/plugin-kit';
+
+/**
+@import {SomlContext} from '../rule/soml-context.js';
+*/
+
+const commentParser = new ConfigCommentParser();
+
+/**
+Whether a disable directive in the document turns off the rule of `context` anywhere, as `# eslint-disable-next-line soml/format` does, or as one without rule names does.
+
+A rule whose one fix changes the whole document or a whole object leaves out that fix then. ESLint applies a fix when the problem that carries it is reported, even when the other problems are turned off, so the fix would change the lines that the directive keeps, and ESLint would then remove the directive as unused.
+
+@param {SomlContext} context
+@returns {boolean}
+*/
+export default function isDisabledAnywhere(context) {
+	return context.sourceCode.getDisableDirectives().directives.some(({type, value}) => type !== 'enable' && (value === '' || Object.hasOwn(commentParser.parseListConfig(value), context.id)));
+}

package/rules/no-numeric-dotted-keys.js

@@ -1,69 +0,0 @@
-import {isDecimalPoint} from './utils/index.js';
-
-/**
-@import {SomlContext} from './rule/soml-context.js';
-@import {SomlRule} from './rule/to-eslint-rule.js';
-*/
-
-const MESSAGE_ID_ERROR = 'no-numeric-dotted-keys/error';
-const MESSAGE_ID_SUGGESTION = 'no-numeric-dotted-keys/suggestion';
-const messages = {
-	[MESSAGE_ID_ERROR]: '`{{key}}` is a nested key, because `.` separates key segments. It is not one key.',
-	[MESSAGE_ID_SUGGESTION]: 'Quote it as one key: `{{replacement}}`.',
-};
-
-/**
-@param {SomlContext} context
-*/
-const create = context => {
-	context.on('Key', node => {
-		const {segments} = node;
-
-		// Only between bare segments, because a quoted segment shows that the dot separates.
-		const hasDecimalPoint = segments.slice(1).some((next, index) => segments[index].style === 'bare' && next.style === 'bare' && isDecimalPoint(segments[index].value, next.value));
-
-		if (!hasDecimalPoint) {
-			return;
-		}
-
-		const key = context.sourceCode.getText(node);
-		const problem = {
-			node,
-			messageId: MESSAGE_ID_ERROR,
-			data: {key},
-		};
-
-		// A key with quoted segments has no single obvious meaning, so it gets no suggestion. Bare segments never contain `'`.
-		if (segments.every(segment => segment.style === 'bare')) {
-			const replacement = `'${key}'`;
-			problem.suggest = [
-				{
-					messageId: MESSAGE_ID_SUGGESTION,
-					data: {replacement},
-					fix: fixer => fixer.replaceText(node, replacement),
-				},
-			];
-		}
-
-		return problem;
-	});
-};
-
-/**
-@type {SomlRule}
-*/
-const config = {
-	create,
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Disallow dotted keys that read as one number.',
-			recommended: 'unopinionated',
-		},
-		hasSuggestions: true,
-		messages,
-		languages: ['soml/soml'],
-	},
-};
-
-export default config;

package/rules/no-scattered-dotted-keys.js

@@ -1,102 +0,0 @@
-import {reorderMembers} from './utils/index.js';
-
-/**
-@import {SomlContext} from './rule/soml-context.js';
-@import {SomlRule} from './rule/to-eslint-rule.js';
-@import {MemberNode} from 'soml-lang';
-*/
-
-const MESSAGE_ID = 'no-scattered-dotted-keys';
-const messages = {
-	[MESSAGE_ID]: 'Keep the keys under `{{prefix}}` together. Another key comes between them.',
-};
-
-/*
-The first `length` segments of a key path as one string, for a map. JSON keeps the segments apart, whatever characters they hold.
-*/
-const getPrefix = (member, length) => JSON.stringify(member.key.segments.slice(0, length).map(segment => segment.value));
-
-/*
-The members grouped by their dotted prefixes, level by level, each group where its first member is. Members that are not under a shared prefix keep their order.
-*/
-function group(members, depth = 0) {
-	const groups = new Map();
-
-	for (const member of members) {
-		const {segments} = member.key;
-		// A member with no segment past this depth is a group of its own.
-		const groupKey = segments.length > depth + 1 ? segments[depth].value : Symbol('member');
-
-		if (!groups.has(groupKey)) {
-			groups.set(groupKey, []);
-		}
-
-		groups.get(groupKey).push(member);
-	}
-
-	return groups.values().flatMap(members => members.length > 1 ? group(members, depth + 1) : members).toArray();
-}
-
-/**
-@param {SomlContext} context
-*/
-const create = context => {
-	const {sourceCode} = context;
-
-	context.on('Object', function * (node) {
-		// The index of the last member under each prefix.
-		const lastIndexes = new Map();
-		let isFirst = true;
-
-		for (const [index, member] of node.members.entries()) {
-			// The shortest prefix whose members another key came between.
-			let scatteredPrefix;
-
-			for (let length = 1; length < member.key.segments.length; length++) {
-				const prefix = getPrefix(member, length);
-				const lastIndex = lastIndexes.get(prefix);
-
-				if (scatteredPrefix === undefined && lastIndex !== undefined && lastIndex !== index - 1) {
-					scatteredPrefix = member.key.segments.slice(0, length);
-				}
-
-				lastIndexes.set(prefix, index);
-			}
-
-			if (scatteredPrefix === undefined) {
-				continue;
-			}
-
-			yield {
-				node: member.key,
-				messageId: MESSAGE_ID,
-				data: {
-					prefix: sourceCode.text.slice(sourceCode.getRange(scatteredPrefix[0])[0], sourceCode.getRange(scatteredPrefix.at(-1))[1]),
-				},
-				// The fix moves every member at once, so one run of `--fix` is enough, and only the first problem carries it. Giving every problem the same fix would build it once per problem.
-				fix: isFirst ? reorderMembers(context, node.members, group(node.members)) : undefined,
-			};
-
-			isFirst = false;
-		}
-	});
-};
-
-/**
-@type {SomlRule}
-*/
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Require the dotted keys under one prefix to be next to each other.',
-			recommended: true,
-		},
-		fixable: 'code',
-		messages,
-		languages: ['soml/soml'],
-	},
-};
-
-export default config;

package/rules/utils/is-decimal-point.js

@@ -1,12 +0,0 @@
-const isDigit = character => character >= '0' && character <= '9';
-
-/**
-Whether a `.` between two key segments has a digit on each side, so that the key reads as a number, as in `3.14` or `python3.12`, while it is two segments.
-
-@param {string} before The segment before the dot.
-@param {string} after The segment after the dot.
-@returns {boolean}
-*/
-export default function isDecimalPoint(before, after) {
-	return isDigit(before.at(-1)) && isDigit(after[0]);
-}