oxlint-plugin-eslint 1.52.0

package/rules/init-declarations.cjs

@@ -0,0 +1,88 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/init-declarations.js
+/**
+* @fileoverview A rule to control the style of variable initializations.
+* @author Colin Ihrig
+*/
+var require_init_declarations = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let CONSTANT_BINDINGS = new Set([
+		"const",
+		"using",
+		"await using"
+	]);
+	/**
+	* Checks whether or not a given node is a for loop.
+	* @param {ASTNode} block A node to check.
+	* @returns {boolean} `true` when the node is a for loop.
+	*/
+	function isForLoop(block) {
+		return block.type === "ForInStatement" || block.type === "ForOfStatement" || block.type === "ForStatement";
+	}
+	/**
+	* Checks whether or not a given declarator node has its initializer.
+	* @param {ASTNode} node A declarator node to check.
+	* @returns {boolean} `true` when the node has its initializer.
+	*/
+	function isInitialized(node) {
+		let declaration = node.parent, block = declaration.parent;
+		return isForLoop(block) ? block.type === "ForStatement" ? block.init === declaration : block.left === declaration : !!node.init;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			dialects: ["typescript", "javascript"],
+			language: "javascript",
+			docs: {
+				description: "Require or disallow initialization in variable declarations",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/init-declarations"
+			},
+			schema: { anyOf: [{
+				type: "array",
+				items: [{ enum: ["always"] }],
+				minItems: 0,
+				maxItems: 1
+			}, {
+				type: "array",
+				items: [{ enum: ["never"] }, {
+					type: "object",
+					properties: { ignoreForLoopInit: { type: "boolean" } },
+					additionalProperties: !1
+				}],
+				minItems: 0,
+				maxItems: 2
+			}] },
+			messages: {
+				initialized: "Variable '{{idName}}' should be initialized on declaration.",
+				notInitialized: "Variable '{{idName}}' should not be initialized on declaration."
+			}
+		},
+		create(context) {
+			let MODE_ALWAYS = "always", mode = context.options[0] || MODE_ALWAYS, params = context.options[1] || {}, insideDeclaredNamespace = !1;
+			return {
+				TSModuleDeclaration(node) {
+					node.declare && (insideDeclaredNamespace = !0);
+				},
+				"TSModuleDeclaration:exit"(node) {
+					node.declare && (insideDeclaredNamespace = !1);
+				},
+				"VariableDeclaration:exit"(node) {
+					let kind = node.kind, declarations = node.declarations;
+					if (!(node.declare || insideDeclaredNamespace)) for (let i = 0; i < declarations.length; ++i) {
+						let declaration = declarations[i], id = declaration.id, initialized = isInitialized(declaration), isIgnoredForLoop = params.ignoreForLoopInit && isForLoop(node.parent), messageId = "";
+						mode === MODE_ALWAYS && !initialized ? messageId = "initialized" : mode === "never" && !CONSTANT_BINDINGS.has(kind) && initialized && !isIgnoredForLoop && (messageId = "notInitialized"), id.type === "Identifier" && messageId && context.report({
+							node: declaration,
+							messageId,
+							data: { idName: id.name }
+						});
+					}
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/init-declarations.cjs
+module.exports = require_init_declarations().create;
+//#endregion

package/rules/jsx-quotes.cjs

@@ -0,0 +1,84 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/jsx-quotes.js
+/**
+* @fileoverview A rule to ensure consistent quotes used in jsx syntax.
+* @author Mathias Schreck <https://github.com/lo1tuma>
+* @deprecated in ESLint v8.53.0
+*/
+var require_jsx_quotes = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), QUOTE_SETTINGS = {
+		"prefer-double": {
+			quote: "\"",
+			description: "singlequote",
+			convert(str) {
+				return str.replace(/'/gu, "\"");
+			}
+		},
+		"prefer-single": {
+			quote: "'",
+			description: "doublequote",
+			convert(str) {
+				return str.replace(/"/gu, "'");
+			}
+		}
+	};
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Formatting rules are being moved out of ESLint core.",
+				url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+				deprecatedSince: "8.53.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style"
+					},
+					rule: {
+						name: "jsx-quotes",
+						url: "https://eslint.style/rules/jsx-quotes"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce the consistent use of either double or single quotes in JSX attributes",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/jsx-quotes"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: ["prefer-single", "prefer-double"] }],
+			messages: { unexpected: "Unexpected usage of {{description}}." }
+		},
+		create(context) {
+			let setting = QUOTE_SETTINGS[context.options[0] || "prefer-double"];
+			/**
+			* Checks if the given string literal node uses the expected quotes
+			* @param {ASTNode} node A string literal node.
+			* @returns {boolean} Whether or not the string literal used the expected quotes.
+			* @public
+			*/
+			function usesExpectedQuotes(node) {
+				return node.value.includes(setting.quote) || astUtils.isSurroundedBy(node.raw, setting.quote);
+			}
+			return { JSXAttribute(node) {
+				let attributeValue = node.value;
+				attributeValue && astUtils.isStringLiteral(attributeValue) && !usesExpectedQuotes(attributeValue) && context.report({
+					node: attributeValue,
+					messageId: "unexpected",
+					data: { description: setting.description },
+					fix(fixer) {
+						return fixer.replaceText(attributeValue, setting.convert(attributeValue.raw));
+					}
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/jsx-quotes.cjs
+module.exports = require_jsx_quotes().create;
+//#endregion

package/rules/key-spacing.cjs

@@ -0,0 +1,399 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_string_utils$1 = require("../common/string-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/key-spacing.js
+/**
+* @fileoverview Rule to specify spacing of object literal keys and values
+* @author Brandon Mills
+* @deprecated in ESLint v8.53.0
+*/
+var require_key_spacing = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), { getGraphemeCount } = require_string_utils$1.t();
+	/**
+	* Checks whether a string contains a line terminator as defined in
+	* http://www.ecma-international.org/ecma-262/5.1/#sec-7.3
+	* @param {string} str String to test.
+	* @returns {boolean} True if str contains a line terminator.
+	*/
+	function containsLineTerminator(str) {
+		return astUtils.LINEBREAK_MATCHER.test(str);
+	}
+	/**
+	* Gets the last element of an array.
+	* @param {Array} arr An array.
+	* @returns {any} Last element of arr.
+	*/
+	function last(arr) {
+		return arr.at(-1);
+	}
+	/**
+	* Checks whether a node is contained on a single line.
+	* @param {ASTNode} node AST Node being evaluated.
+	* @returns {boolean} True if the node is a single line.
+	*/
+	function isSingleLine(node) {
+		return node.loc.end.line === node.loc.start.line;
+	}
+	/**
+	* Checks whether the properties on a single line.
+	* @param {ASTNode[]} properties List of Property AST nodes.
+	* @returns {boolean} True if all properties is on a single line.
+	*/
+	function isSingleLineProperties(properties) {
+		let [firstProp] = properties, lastProp = last(properties);
+		return firstProp.loc.start.line === lastProp.loc.end.line;
+	}
+	/**
+	* Initializes a single option property from the configuration with defaults for undefined values
+	* @param {Object} toOptions Object to be initialized
+	* @param {Object} fromOptions Object to be initialized from
+	* @returns {Object} The object with correctly initialized options and values
+	*/
+	function initOptionProperty(toOptions, fromOptions) {
+		return toOptions.mode = fromOptions.mode || "strict", fromOptions.beforeColon === void 0 ? toOptions.beforeColon = 0 : toOptions.beforeColon = +fromOptions.beforeColon, fromOptions.afterColon === void 0 ? toOptions.afterColon = 1 : toOptions.afterColon = +fromOptions.afterColon, fromOptions.align !== void 0 && (typeof fromOptions.align == "object" ? toOptions.align = fromOptions.align : toOptions.align = {
+			on: fromOptions.align,
+			mode: toOptions.mode,
+			beforeColon: toOptions.beforeColon,
+			afterColon: toOptions.afterColon
+		}), toOptions;
+	}
+	/**
+	* Initializes all the option values (singleLine, multiLine and align) from the configuration with defaults for undefined values
+	* @param {Object} toOptions Object to be initialized
+	* @param {Object} fromOptions Object to be initialized from
+	* @returns {Object} The object with correctly initialized options and values
+	*/
+	function initOptions(toOptions, fromOptions) {
+		return typeof fromOptions.align == "object" ? (toOptions.align = initOptionProperty({}, fromOptions.align), toOptions.align.on = fromOptions.align.on || "colon", toOptions.align.mode = fromOptions.align.mode || "strict", toOptions.multiLine = initOptionProperty({}, fromOptions.multiLine || fromOptions), toOptions.singleLine = initOptionProperty({}, fromOptions.singleLine || fromOptions)) : (toOptions.multiLine = initOptionProperty({}, fromOptions.multiLine || fromOptions), toOptions.singleLine = initOptionProperty({}, fromOptions.singleLine || fromOptions), toOptions.multiLine.align && (toOptions.align = {
+			on: toOptions.multiLine.align.on,
+			mode: toOptions.multiLine.align.mode || toOptions.multiLine.mode,
+			beforeColon: toOptions.multiLine.align.beforeColon,
+			afterColon: toOptions.multiLine.align.afterColon
+		})), toOptions;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Formatting rules are being moved out of ESLint core.",
+				url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+				deprecatedSince: "8.53.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style"
+					},
+					rule: {
+						name: "key-spacing",
+						url: "https://eslint.style/rules/key-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent spacing between keys and values in object literal properties",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/key-spacing"
+			},
+			fixable: "whitespace",
+			schema: [{ anyOf: [
+				{
+					type: "object",
+					properties: {
+						align: { anyOf: [{ enum: ["colon", "value"] }, {
+							type: "object",
+							properties: {
+								mode: { enum: ["strict", "minimum"] },
+								on: { enum: ["colon", "value"] },
+								beforeColon: { type: "boolean" },
+								afterColon: { type: "boolean" }
+							},
+							additionalProperties: !1
+						}] },
+						mode: { enum: ["strict", "minimum"] },
+						beforeColon: { type: "boolean" },
+						afterColon: { type: "boolean" }
+					},
+					additionalProperties: !1
+				},
+				{
+					type: "object",
+					properties: {
+						singleLine: {
+							type: "object",
+							properties: {
+								mode: { enum: ["strict", "minimum"] },
+								beforeColon: { type: "boolean" },
+								afterColon: { type: "boolean" }
+							},
+							additionalProperties: !1
+						},
+						multiLine: {
+							type: "object",
+							properties: {
+								align: { anyOf: [{ enum: ["colon", "value"] }, {
+									type: "object",
+									properties: {
+										mode: { enum: ["strict", "minimum"] },
+										on: { enum: ["colon", "value"] },
+										beforeColon: { type: "boolean" },
+										afterColon: { type: "boolean" }
+									},
+									additionalProperties: !1
+								}] },
+								mode: { enum: ["strict", "minimum"] },
+								beforeColon: { type: "boolean" },
+								afterColon: { type: "boolean" }
+							},
+							additionalProperties: !1
+						}
+					},
+					additionalProperties: !1
+				},
+				{
+					type: "object",
+					properties: {
+						singleLine: {
+							type: "object",
+							properties: {
+								mode: { enum: ["strict", "minimum"] },
+								beforeColon: { type: "boolean" },
+								afterColon: { type: "boolean" }
+							},
+							additionalProperties: !1
+						},
+						multiLine: {
+							type: "object",
+							properties: {
+								mode: { enum: ["strict", "minimum"] },
+								beforeColon: { type: "boolean" },
+								afterColon: { type: "boolean" }
+							},
+							additionalProperties: !1
+						},
+						align: {
+							type: "object",
+							properties: {
+								mode: { enum: ["strict", "minimum"] },
+								on: { enum: ["colon", "value"] },
+								beforeColon: { type: "boolean" },
+								afterColon: { type: "boolean" }
+							},
+							additionalProperties: !1
+						}
+					},
+					additionalProperties: !1
+				}
+			] }],
+			messages: {
+				extraKey: "Extra space after {{computed}}key '{{key}}'.",
+				extraValue: "Extra space before value for {{computed}}key '{{key}}'.",
+				missingKey: "Missing space after {{computed}}key '{{key}}'.",
+				missingValue: "Missing space before value for {{computed}}key '{{key}}'."
+			}
+		},
+		create(context) {
+			/**
+			* OPTIONS
+			* "key-spacing": [2, {
+			*     beforeColon: false,
+			*     afterColon: true,
+			*     align: "colon" // Optional, or "value"
+			* }
+			*/
+			let ruleOptions = initOptions({}, context.options[0] || {}), multiLineOptions = ruleOptions.multiLine, singleLineOptions = ruleOptions.singleLine, alignmentOptions = ruleOptions.align || null, sourceCode = context.sourceCode;
+			/**
+			* Determines if the given property is key-value property.
+			* @param {ASTNode} property Property node to check.
+			* @returns {boolean} Whether the property is a key-value property.
+			*/
+			function isKeyValueProperty(property) {
+				return !(property.method || property.shorthand || property.kind !== "init" || property.type !== "Property");
+			}
+			/**
+			* Starting from the given node (a property.key node here) looks forward
+			* until it finds the colon punctuator and returns it.
+			* @param {ASTNode} node The node to start looking from.
+			* @returns {ASTNode} The colon punctuator.
+			*/
+			function getNextColon(node) {
+				return sourceCode.getTokenAfter(node, astUtils.isColonToken);
+			}
+			/**
+			* Starting from the given node (a property.key node here) looks forward
+			* until it finds the last token before a colon punctuator and returns it.
+			* @param {ASTNode} node The node to start looking from.
+			* @returns {ASTNode} The last token before a colon punctuator.
+			*/
+			function getLastTokenBeforeColon(node) {
+				let colonToken = getNextColon(node);
+				return sourceCode.getTokenBefore(colonToken);
+			}
+			/**
+			* Starting from the given node (a property.key node here) looks forward
+			* until it finds the first token after a colon punctuator and returns it.
+			* @param {ASTNode} node The node to start looking from.
+			* @returns {ASTNode} The first token after a colon punctuator.
+			*/
+			function getFirstTokenAfterColon(node) {
+				let colonToken = getNextColon(node);
+				return sourceCode.getTokenAfter(colonToken);
+			}
+			/**
+			* Checks whether a property is a member of the property group it follows.
+			* @param {ASTNode} lastMember The last Property known to be in the group.
+			* @param {ASTNode} candidate The next Property that might be in the group.
+			* @returns {boolean} True if the candidate property is part of the group.
+			*/
+			function continuesPropertyGroup(lastMember, candidate) {
+				let groupEndLine = lastMember.loc.start.line, candidateValueStartLine = (isKeyValueProperty(candidate) ? getFirstTokenAfterColon(candidate.key) : candidate).loc.start.line;
+				if (candidateValueStartLine - groupEndLine <= 1) return !0;
+				let leadingComments = sourceCode.getCommentsBefore(candidate);
+				if (leadingComments.length && leadingComments[0].loc.start.line - groupEndLine <= 1 && candidateValueStartLine - last(leadingComments).loc.end.line <= 1) {
+					for (let i = 1; i < leadingComments.length; i++) if (leadingComments[i].loc.start.line - leadingComments[i - 1].loc.end.line > 1) return !1;
+					return !0;
+				}
+				return !1;
+			}
+			/**
+			* Gets an object literal property's key as the identifier name or string value.
+			* @param {ASTNode} property Property node whose key to retrieve.
+			* @returns {string} The property's key.
+			*/
+			function getKey(property) {
+				let key = property.key;
+				return property.computed ? sourceCode.getText().slice(key.range[0], key.range[1]) : astUtils.getStaticPropertyName(property);
+			}
+			/**
+			* Reports an appropriately-formatted error if spacing is incorrect on one
+			* side of the colon.
+			* @param {ASTNode} property Key-value pair in an object literal.
+			* @param {string} side Side being verified - either "key" or "value".
+			* @param {string} whitespace Actual whitespace string.
+			* @param {number} expected Expected whitespace length.
+			* @param {string} mode Value of the mode as "strict" or "minimum"
+			* @returns {void}
+			*/
+			function report(property, side, whitespace, expected, mode) {
+				let diff = whitespace.length - expected;
+				if ((diff && mode === "strict" || diff < 0 && mode === "minimum" || diff > 0 && !expected && mode === "minimum") && !(expected && containsLineTerminator(whitespace))) {
+					let nextColon = getNextColon(property.key), tokenBeforeColon = sourceCode.getTokenBefore(nextColon, { includeComments: !0 }), tokenAfterColon = sourceCode.getTokenAfter(nextColon, { includeComments: !0 }), isKeySide = side === "key", isExtra = diff > 0, diffAbs = Math.abs(diff), spaces = Array(diffAbs + 1).join(" "), locStart = isKeySide ? tokenBeforeColon.loc.end : nextColon.loc.start, locEnd = isKeySide ? nextColon.loc.start : tokenAfterColon.loc.start, missingLoc = isKeySide ? tokenBeforeColon.loc : tokenAfterColon.loc, loc = isExtra ? {
+						start: locStart,
+						end: locEnd
+					} : missingLoc, fix;
+					if (isExtra) {
+						let range;
+						range = isKeySide ? [tokenBeforeColon.range[1], tokenBeforeColon.range[1] + diffAbs] : [tokenAfterColon.range[0] - diffAbs, tokenAfterColon.range[0]], fix = function(fixer) {
+							return fixer.removeRange(range);
+						};
+					} else fix = isKeySide ? function(fixer) {
+						return fixer.insertTextAfter(tokenBeforeColon, spaces);
+					} : function(fixer) {
+						return fixer.insertTextBefore(tokenAfterColon, spaces);
+					};
+					let messageId;
+					messageId = isExtra ? side === "key" ? "extraKey" : "extraValue" : side === "key" ? "missingKey" : "missingValue", context.report({
+						node: property[side],
+						loc,
+						messageId,
+						data: {
+							computed: property.computed ? "computed " : "",
+							key: getKey(property)
+						},
+						fix
+					});
+				}
+			}
+			/**
+			* Gets the number of characters in a key, including quotes around string
+			* keys and braces around computed property keys.
+			* @param {ASTNode} property Property of on object literal.
+			* @returns {number} Width of the key.
+			*/
+			function getKeyWidth(property) {
+				let startToken = sourceCode.getFirstToken(property), endToken = getLastTokenBeforeColon(property.key);
+				return getGraphemeCount(sourceCode.getText().slice(startToken.range[0], endToken.range[1]));
+			}
+			/**
+			* Gets the whitespace around the colon in an object literal property.
+			* @param {ASTNode} property Property node from an object literal.
+			* @returns {Object} Whitespace before and after the property's colon.
+			*/
+			function getPropertyWhitespace(property) {
+				let whitespace = /(\s*):(\s*)/u.exec(sourceCode.getText().slice(property.key.range[1], property.value.range[0]));
+				return whitespace ? {
+					beforeColon: whitespace[1],
+					afterColon: whitespace[2]
+				} : null;
+			}
+			/**
+			* Creates groups of properties.
+			* @param {ASTNode} node ObjectExpression node being evaluated.
+			* @returns {Array<ASTNode[]>} Groups of property AST node lists.
+			*/
+			function createGroups(node) {
+				return node.properties.length === 1 ? [node.properties] : node.properties.reduce((groups, property) => {
+					let currentGroup = last(groups), prev = last(currentGroup);
+					return !prev || continuesPropertyGroup(prev, property) ? currentGroup.push(property) : groups.push([property]), groups;
+				}, [[]]);
+			}
+			/**
+			* Verifies correct vertical alignment of a group of properties.
+			* @param {ASTNode[]} properties List of Property AST nodes.
+			* @returns {void}
+			*/
+			function verifyGroupAlignment(properties) {
+				let length = properties.length, widths = properties.map(getKeyWidth), align = alignmentOptions.on, targetWidth = Math.max(...widths), beforeColon, afterColon, mode;
+				alignmentOptions && length > 1 ? (beforeColon = alignmentOptions.beforeColon, afterColon = alignmentOptions.afterColon, mode = alignmentOptions.mode) : (beforeColon = multiLineOptions.beforeColon, afterColon = multiLineOptions.afterColon, mode = alignmentOptions.mode), targetWidth += align === "colon" ? beforeColon : afterColon;
+				for (let i = 0; i < length; i++) {
+					let property = properties[i], whitespace = getPropertyWhitespace(property);
+					if (whitespace) {
+						let width = widths[i];
+						align === "value" ? (report(property, "key", whitespace.beforeColon, beforeColon, mode), report(property, "value", whitespace.afterColon, targetWidth - width, mode)) : (report(property, "key", whitespace.beforeColon, targetWidth - width, mode), report(property, "value", whitespace.afterColon, afterColon, mode));
+					}
+				}
+			}
+			/**
+			* Verifies spacing of property conforms to specified options.
+			* @param {ASTNode} node Property node being evaluated.
+			* @param {Object} lineOptions Configured singleLine or multiLine options
+			* @returns {void}
+			*/
+			function verifySpacing(node, lineOptions) {
+				let actual = getPropertyWhitespace(node);
+				actual && (report(node, "key", actual.beforeColon, lineOptions.beforeColon, lineOptions.mode), report(node, "value", actual.afterColon, lineOptions.afterColon, lineOptions.mode));
+			}
+			/**
+			* Verifies spacing of each property in a list.
+			* @param {ASTNode[]} properties List of Property AST nodes.
+			* @param {Object} lineOptions Configured singleLine or multiLine options
+			* @returns {void}
+			*/
+			function verifyListSpacing(properties, lineOptions) {
+				let length = properties.length;
+				for (let i = 0; i < length; i++) verifySpacing(properties[i], lineOptions);
+			}
+			/**
+			* Verifies vertical alignment, taking into account groups of properties.
+			* @param {ASTNode} node ObjectExpression node being evaluated.
+			* @returns {void}
+			*/
+			function verifyAlignment(node) {
+				createGroups(node).forEach((group) => {
+					let properties = group.filter(isKeyValueProperty);
+					properties.length > 0 && isSingleLineProperties(properties) ? verifyListSpacing(properties, multiLineOptions) : verifyGroupAlignment(properties);
+				});
+			}
+			return alignmentOptions ? { ObjectExpression(node) {
+				isSingleLine(node) ? verifyListSpacing(node.properties.filter(isKeyValueProperty), singleLineOptions) : verifyAlignment(node);
+			} } : { Property(node) {
+				verifySpacing(node, isSingleLine(node.parent) ? singleLineOptions : multiLineOptions);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/key-spacing.cjs
+module.exports = require_key_spacing().create;
+//#endregion