eslint-soml 0.0.2 → 0.0.4

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,4 +1,5 @@
-import {hasAdjacentComment, isPunctuator} from './utils/index.js';
+import {stringifyValue} from 'soml-lang';
+import {escapeInvisibleCharacters, hasAdjacentComment, isPunctuator} from './utils/index.js';
 
 /**
 @import {SomlContext} from './rule/soml-context.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. Canonical form writes a bidirectional control as it is, so it is escaped, as an escape in the block string was.
+					item: item.block ? escapeInvisibleCharacters(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-loss-of-precision.js

@@ -81,7 +81,7 @@ const config = {
 	meta: {
 		type: 'problem',
 		docs: {
-			description: 'Disallow floats that cannot be stored exactly as written.',
+			description: 'Disallow floats whose written digits are lost when they are stored.',
 			recommended: 'unopinionated',
 		},
 		messages,

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

@@ -1,4 +1,4 @@
-import {trimEnd} from './utils/index.js';
+import {getLines} from './utils/index.js';
 
 /**
 @import {SomlContext} from './rule/soml-context.js';
@@ -22,6 +22,33 @@ function isClosingQuote(line, index, delimiter) {
 	return runs.filter(run => run.length === delimiter.length).length % 2 === 1;
 }
 
+/*
+What may follow a closing delimiter on its line: whitespace, commas, closing brackets, and a comment. It is sticky, so it matches from `lastIndex`, which is set before every use.
+*/
+const AFTER_DELIMITER = /[\t ]*(?:[,\]\}][\t ]*)*(?:(?:#|\/\*).*)?$/vy;
+
+/*
+Where a misplaced delimiter starts on a content line, or `undefined`: a run of exactly the delimiter's length with only what may follow a closing delimiter after it, as TOML and Java allow, in `Welcome!'''`, `Hi'''}`, or `Welcome!''' # greeting`. Only the first run with such a tail is checked, because what follows it is a comment or brackets.
+*/
+function getMisplacedDelimiterIndex(line, delimiter, isEscaped) {
+	for (const match of line.matchAll(QUOTE_RUNS[delimiter[0]])) {
+		let {index} = match;
+		const end = index + match[0].length;
+		AFTER_DELIMITER.lastIndex = end;
+
+		if (!AFTER_DELIMITER.test(line)) {
+			continue;
+		}
+
+		// In a `"""` block, `\"` is an escaped quote, so it is not part of the run.
+		if (isEscaped && ESCAPING_BACKSLASHES.test(line.slice(0, index))) {
+			index++;
+		}
+
+		return index > 0 && end - index === delimiter.length && !isClosingQuote(line, index, delimiter) ? index : undefined;
+	}
+}
+
 /**
 @param {SomlContext} context
 */
@@ -33,43 +60,24 @@ const create = context => {
 			return;
 		}
 
-		const lines = sourceCode.getText(node).split('\n');
+		const lines = getLines(context, node);
 		// The first line is the opening delimiter, so it is a run of one quote character.
-		const delimiter = lines[0];
-		let offset = sourceCode.getRange(node)[0] + delimiter.length + 1;
+		const delimiter = lines[0].text;
 
 		// The last line holds the closing delimiter. Only the first misplaced delimiter is reported, because the lines after it, such as the opening of another block string, are content only because of it.
-		for (const line of lines.slice(1, -1)) {
-			// A run of exactly the delimiter's length at the end of a line, as TOML and Java allow, optionally followed by a comma.
-			let content = trimEnd(line, ' \t');
-
-			if (content.endsWith(',')) {
-				content = trimEnd(content.slice(0, -1), ' \t');
-			}
-
-			const index = content.length - delimiter.length;
-
-			if (
-				index > 0
-				&& content.endsWith(delimiter)
-				&& content[index - 1] !== delimiter[0]
-				&& !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;
+		for (const {text, start} of lines.slice(1, -1)) {
+			const index = getMisplacedDelimiterIndex(text, delimiter, node.style === 'escaped');
 
+			if (index !== undefined) {
 				return {
 					loc: {
-						start: sourceCode.getLocFromIndex(start),
-						end: sourceCode.getLocFromIndex(start + delimiter.length),
+						start: sourceCode.getLocFromIndex(start + index),
+						end: sourceCode.getLocFromIndex(start + index + delimiter.length),
 					},
 					messageId: MESSAGE_ID,
 					data: {delimiter},
 				};
 			}
-
-			offset += line.length + 1;
 		}
 	});
 };

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;
 		}
@@ -66,7 +66,7 @@ const config = {
 	meta: {
 		type: 'suggestion',
 		docs: {
-			description: 'Prefer literal strings, `\'…\'`, when a string has no escapes.',
+			description: 'Prefer literal strings, `\'…\'`, when a string does not need escapes.',
 			recommended: true,
 		},
 		fixable: 'code',

package/rules/rule/to-eslint-problem.js

@@ -31,6 +31,7 @@ Convert a problem from a listener to an ESLint problem. A suggestion gets the `d
 */
 export default function toEslintProblem(somlProblem) {
 	const {fix, suggest, ...problem} = somlProblem;
+
 	/**
 	@type {EslintProblem}
 	*/

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,70 @@ 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 a surrogate pair is followed by the same low surrogate in both.
+		firstIndex++;
+		secondIndex++;
+	}
+
+	// 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;
 
@@ -38,6 +93,9 @@ const create = context => {
 		return commentLines;
 	};
 
+	// Whether the fix is allowed, found once per file, because the directives would be parsed again for every object.
+	let isFixable;
+
 	/**
 	Whether a blank line separates two members. A line in a comment is not blank.
 
@@ -56,25 +114,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 +154,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 && (isFixable ??= !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`. A word after an acronym has at least two lowercase letters, so a plural acronym, as in `maxCPUs`, stays one word. 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]{2})/v)
+		.filter(word => word !== '')
+		.map(word => word.toLowerCase());
 }