oxlint-plugin-eslint 1.52.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "oxlint-plugin-eslint",
+  "version": "1.52.0",
+  "description": "ESLint's built-in rules as an Oxlint plugin",
+  "keywords": [
+    "eslint",
+    "linter",
+    "oxlint",
+    "plugin"
+  ],
+  "homepage": "https://oxc.rs/docs/guide/usage/linter/js-plugins",
+  "bugs": "https://github.com/oxc-project/oxc/issues",
+  "license": "MIT",
+  "author": "Boshen and oxc contributors",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oxc-project/oxc.git",
+    "directory": "npm/oxlint-plugin-eslint"
+  },
+  "funding": {
+    "url": "https://github.com/sponsors/Boshen"
+  },
+  "files": [
+    "index.js",
+    "rules",
+    "common",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "index.js",
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  }
+}

package/rules/accessor-pairs.cjs

@@ -0,0 +1,233 @@
+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/accessor-pairs.js
+/**
+* @fileoverview Rule to enforce getter and setter pairs in objects and classes.
+* @author Gyandeep Singh
+*/
+var require_accessor_pairs = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Property name if it can be computed statically, otherwise the list of the tokens of the key node.
+	* @typedef {string|Token[]} Key
+	*/
+	/**
+	* Accessor nodes with the same key.
+	* @typedef {Object} AccessorData
+	* @property {Key} key Accessor's key
+	* @property {ASTNode[]} getters List of getter nodes.
+	* @property {ASTNode[]} setters List of setter nodes.
+	*/
+	/**
+	* Checks whether or not the given lists represent the equal tokens in the same order.
+	* Tokens are compared by their properties, not by instance.
+	* @param {Token[]} left First list of tokens.
+	* @param {Token[]} right Second list of tokens.
+	* @returns {boolean} `true` if the lists have same tokens.
+	*/
+	function areEqualTokenLists(left, right) {
+		if (left.length !== right.length) return !1;
+		for (let i = 0; i < left.length; i++) {
+			let leftToken = left[i], rightToken = right[i];
+			if (leftToken.type !== rightToken.type || leftToken.value !== rightToken.value) return !1;
+		}
+		return !0;
+	}
+	/**
+	* Checks whether or not the given keys are equal.
+	* @param {Key} left First key.
+	* @param {Key} right Second key.
+	* @returns {boolean} `true` if the keys are equal.
+	*/
+	function areEqualKeys(left, right) {
+		return typeof left == "string" && typeof right == "string" ? left === right : Array.isArray(left) && Array.isArray(right) ? areEqualTokenLists(left, right) : !1;
+	}
+	/**
+	* Checks whether or not a given node is of an accessor kind ('get' or 'set').
+	* @param {ASTNode} node A node to check.
+	* @returns {boolean} `true` if the node is of an accessor kind.
+	*/
+	function isAccessorKind(node) {
+		return node.kind === "get" || node.kind === "set";
+	}
+	/**
+	* Checks whether or not a given node is an argument of a specified method call.
+	* @param {ASTNode} node A node to check.
+	* @param {number} index An expected index of the node in arguments.
+	* @param {string} object An expected name of the object of the method.
+	* @param {string} property An expected name of the method.
+	* @returns {boolean} `true` if the node is an argument of the specified method call.
+	*/
+	function isArgumentOfMethodCall(node, index, object, property) {
+		let parent = node.parent;
+		return parent.type === "CallExpression" && astUtils.isSpecificMemberAccess(parent.callee, object, property) && parent.arguments[index] === node;
+	}
+	/**
+	* Checks whether or not a given node is a property descriptor.
+	* @param {ASTNode} node A node to check.
+	* @returns {boolean} `true` if the node is a property descriptor.
+	*/
+	function isPropertyDescriptor(node) {
+		if (isArgumentOfMethodCall(node, 2, "Object", "defineProperty") || isArgumentOfMethodCall(node, 2, "Reflect", "defineProperty")) return !0;
+		let grandparent = node.parent.parent;
+		return grandparent.type === "ObjectExpression" && (isArgumentOfMethodCall(grandparent, 1, "Object", "create") || isArgumentOfMethodCall(grandparent, 1, "Object", "defineProperties"));
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{
+				enforceForTSTypes: !1,
+				enforceForClassMembers: !0,
+				getWithoutSet: !1,
+				setWithoutGet: !0
+			}],
+			docs: {
+				description: "Enforce getter and setter pairs in objects and classes",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/accessor-pairs"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					getWithoutSet: { type: "boolean" },
+					setWithoutGet: { type: "boolean" },
+					enforceForClassMembers: { type: "boolean" },
+					enforceForTSTypes: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				missingGetterInPropertyDescriptor: "Getter is not present in property descriptor.",
+				missingSetterInPropertyDescriptor: "Setter is not present in property descriptor.",
+				missingGetterInObjectLiteral: "Getter is not present for {{ name }}.",
+				missingSetterInObjectLiteral: "Setter is not present for {{ name }}.",
+				missingGetterInClass: "Getter is not present for class {{ name }}.",
+				missingSetterInClass: "Setter is not present for class {{ name }}.",
+				missingGetterInType: "Getter is not present for type {{ name }}.",
+				missingSetterInType: "Setter is not present for type {{ name }}."
+			}
+		},
+		create(context) {
+			let [{ getWithoutSet: checkGetWithoutSet, setWithoutGet: checkSetWithoutGet, enforceForClassMembers, enforceForTSTypes }] = context.options, sourceCode = context.sourceCode;
+			/**
+			* Reports the given node.
+			* @param {ASTNode} node The node to report.
+			* @param {string} messageKind "missingGetter" or "missingSetter".
+			* @returns {void}
+			* @private
+			*/
+			function report(node, messageKind) {
+				node.type === "Property" ? context.report({
+					node,
+					messageId: `${messageKind}InObjectLiteral`,
+					loc: astUtils.getFunctionHeadLoc(node.value, sourceCode),
+					data: { name: astUtils.getFunctionNameWithKind(node.value) }
+				}) : node.type === "MethodDefinition" ? context.report({
+					node,
+					messageId: `${messageKind}InClass`,
+					loc: astUtils.getFunctionHeadLoc(node.value, sourceCode),
+					data: { name: astUtils.getFunctionNameWithKind(node.value) }
+				}) : node.type === "TSMethodSignature" ? context.report({
+					node,
+					messageId: `${messageKind}InType`,
+					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+					data: { name: astUtils.getFunctionNameWithKind(node) }
+				}) : context.report({
+					node,
+					messageId: `${messageKind}InPropertyDescriptor`
+				});
+			}
+			/**
+			* Reports each of the nodes in the given list using the same messageId.
+			* @param {ASTNode[]} nodes Nodes to report.
+			* @param {string} messageKind "missingGetter" or "missingSetter".
+			* @returns {void}
+			* @private
+			*/
+			function reportList(nodes, messageKind) {
+				for (let node of nodes) report(node, messageKind);
+			}
+			/**
+			* Checks accessor pairs in the given list of nodes.
+			* @param {ASTNode[]} nodes The list to check.
+			* @returns {void}
+			* @private
+			*/
+			function checkList(nodes) {
+				let accessors = [], found = !1;
+				for (let i = 0; i < nodes.length; i++) {
+					let node = nodes[i];
+					if (isAccessorKind(node)) {
+						let name = astUtils.getStaticPropertyName(node), key = name === null ? sourceCode.getTokens(node.key) : name;
+						for (let j = 0; j < accessors.length; j++) {
+							let accessor = accessors[j];
+							if (areEqualKeys(accessor.key, key)) {
+								accessor.getters.push(...node.kind === "get" ? [node] : []), accessor.setters.push(...node.kind === "set" ? [node] : []), found = !0;
+								break;
+							}
+						}
+						found || accessors.push({
+							key,
+							getters: node.kind === "get" ? [node] : [],
+							setters: node.kind === "set" ? [node] : []
+						}), found = !1;
+					}
+				}
+				for (let { getters, setters } of accessors) checkSetWithoutGet && setters.length && !getters.length && reportList(setters, "missingGetter"), checkGetWithoutSet && getters.length && !setters.length && reportList(getters, "missingSetter");
+			}
+			/**
+			* Checks accessor pairs in an object literal.
+			* @param {ASTNode} node `ObjectExpression` node to check.
+			* @returns {void}
+			* @private
+			*/
+			function checkObjectLiteral(node) {
+				checkList(node.properties.filter((p) => p.type === "Property"));
+			}
+			/**
+			* Checks accessor pairs in a property descriptor.
+			* @param {ASTNode} node Property descriptor `ObjectExpression` node to check.
+			* @returns {void}
+			* @private
+			*/
+			function checkPropertyDescriptor(node) {
+				let namesToCheck = new Set(node.properties.filter((p) => p.type === "Property" && p.kind === "init" && !p.computed).map(({ key }) => key.name)), hasGetter = namesToCheck.has("get"), hasSetter = namesToCheck.has("set");
+				checkSetWithoutGet && hasSetter && !hasGetter && report(node, "missingGetter"), checkGetWithoutSet && hasGetter && !hasSetter && report(node, "missingSetter");
+			}
+			/**
+			* Checks the given object expression as an object literal and as a possible property descriptor.
+			* @param {ASTNode} node `ObjectExpression` node to check.
+			* @returns {void}
+			* @private
+			*/
+			function checkObjectExpression(node) {
+				checkObjectLiteral(node), isPropertyDescriptor(node) && checkPropertyDescriptor(node);
+			}
+			/**
+			* Checks the given class body.
+			* @param {ASTNode} node `ClassBody` node to check.
+			* @returns {void}
+			* @private
+			*/
+			function checkClassBody(node) {
+				let methodDefinitions = node.body.filter((m) => m.type === "MethodDefinition");
+				checkList(methodDefinitions.filter((m) => m.static)), checkList(methodDefinitions.filter((m) => !m.static));
+			}
+			/**
+			* Checks the given type.
+			* @param {ASTNode} node `TSTypeLiteral` or `TSInterfaceBody` node to check.
+			* @returns {void}
+			* @private
+			*/
+			function checkType(node) {
+				checkList((node.type === "TSTypeLiteral" ? node.members : node.body).filter((m) => m.type === "TSMethodSignature"));
+			}
+			let listeners = {};
+			return (checkSetWithoutGet || checkGetWithoutSet) && (listeners.ObjectExpression = checkObjectExpression, enforceForClassMembers && (listeners.ClassBody = checkClassBody), enforceForTSTypes && (listeners["TSTypeLiteral, TSInterfaceBody"] = checkType)), listeners;
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/accessor-pairs.cjs
+module.exports = require_accessor_pairs().create;
+//#endregion

package/rules/array-bracket-newline.cjs

@@ -0,0 +1,172 @@
+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/array-bracket-newline.js
+/**
+* @fileoverview Rule to enforce linebreaks after open and before close array brackets
+* @author Jan Peer Stöcklmair <https://github.com/JPeer264>
+* @deprecated in ESLint v8.53.0
+*/
+var require_array_bracket_newline = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @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: "array-bracket-newline",
+						url: "https://eslint.style/rules/array-bracket-newline"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce linebreaks after opening and before closing array brackets",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/array-bracket-newline"
+			},
+			fixable: "whitespace",
+			schema: [{ oneOf: [{ enum: [
+				"always",
+				"never",
+				"consistent"
+			] }, {
+				type: "object",
+				properties: {
+					multiline: { type: "boolean" },
+					minItems: {
+						type: ["integer", "null"],
+						minimum: 0
+					}
+				},
+				additionalProperties: !1
+			}] }],
+			messages: {
+				unexpectedOpeningLinebreak: "There should be no linebreak after '['.",
+				unexpectedClosingLinebreak: "There should be no linebreak before ']'.",
+				missingOpeningLinebreak: "A linebreak is required after '['.",
+				missingClosingLinebreak: "A linebreak is required before ']'."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Normalizes a given option value.
+			* @param {string|Object|undefined} option An option value to parse.
+			* @returns {{multiline: boolean, minItems: number}} Normalized option object.
+			*/
+			function normalizeOptionValue(option) {
+				let consistent = !1, multiline = !1, minItems;
+				return option ? option === "consistent" ? (consistent = !0, minItems = Infinity) : option === "always" || option.minItems === 0 ? minItems = 0 : option === "never" ? minItems = Infinity : (multiline = !!option.multiline, minItems = option.minItems || Infinity) : (consistent = !1, multiline = !0, minItems = Infinity), {
+					consistent,
+					multiline,
+					minItems
+				};
+			}
+			/**
+			* Normalizes a given option value.
+			* @param {string|Object|undefined} options An option value to parse.
+			* @returns {{ArrayExpression: {multiline: boolean, minItems: number}, ArrayPattern: {multiline: boolean, minItems: number}}} Normalized option object.
+			*/
+			function normalizeOptions(options) {
+				let value = normalizeOptionValue(options);
+				return {
+					ArrayExpression: value,
+					ArrayPattern: value
+				};
+			}
+			/**
+			* Reports that there shouldn't be a linebreak after the first token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportNoBeginningLinebreak(node, token) {
+				context.report({
+					node,
+					loc: token.loc,
+					messageId: "unexpectedOpeningLinebreak",
+					fix(fixer) {
+						let nextToken = sourceCode.getTokenAfter(token, { includeComments: !0 });
+						return astUtils.isCommentToken(nextToken) ? null : fixer.removeRange([token.range[1], nextToken.range[0]]);
+					}
+				});
+			}
+			/**
+			* Reports that there shouldn't be a linebreak before the last token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportNoEndingLinebreak(node, token) {
+				context.report({
+					node,
+					loc: token.loc,
+					messageId: "unexpectedClosingLinebreak",
+					fix(fixer) {
+						let previousToken = sourceCode.getTokenBefore(token, { includeComments: !0 });
+						return astUtils.isCommentToken(previousToken) ? null : fixer.removeRange([previousToken.range[1], token.range[0]]);
+					}
+				});
+			}
+			/**
+			* Reports that there should be a linebreak after the first token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportRequiredBeginningLinebreak(node, token) {
+				context.report({
+					node,
+					loc: token.loc,
+					messageId: "missingOpeningLinebreak",
+					fix(fixer) {
+						return fixer.insertTextAfter(token, "\n");
+					}
+				});
+			}
+			/**
+			* Reports that there should be a linebreak before the last token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportRequiredEndingLinebreak(node, token) {
+				context.report({
+					node,
+					loc: token.loc,
+					messageId: "missingClosingLinebreak",
+					fix(fixer) {
+						return fixer.insertTextBefore(token, "\n");
+					}
+				});
+			}
+			/**
+			* Reports a given node if it violated this rule.
+			* @param {ASTNode} node A node to check. This is an ArrayExpression node or an ArrayPattern node.
+			* @returns {void}
+			*/
+			function check(node) {
+				let elements = node.elements, options = normalizeOptions(context.options[0])[node.type], openBracket = sourceCode.getFirstToken(node), closeBracket = sourceCode.getLastToken(node), firstIncComment = sourceCode.getTokenAfter(openBracket, { includeComments: !0 }), lastIncComment = sourceCode.getTokenBefore(closeBracket, { includeComments: !0 }), first = sourceCode.getTokenAfter(openBracket), last = sourceCode.getTokenBefore(closeBracket);
+				elements.length >= options.minItems || options.multiline && elements.length > 0 && firstIncComment.loc.start.line !== lastIncComment.loc.end.line || elements.length === 0 && firstIncComment.type === "Block" && firstIncComment.loc.start.line !== lastIncComment.loc.end.line && firstIncComment === lastIncComment || options.consistent && openBracket.loc.end.line !== first.loc.start.line ? (astUtils.isTokenOnSameLine(openBracket, first) && reportRequiredBeginningLinebreak(node, openBracket), astUtils.isTokenOnSameLine(last, closeBracket) && reportRequiredEndingLinebreak(node, closeBracket)) : (astUtils.isTokenOnSameLine(openBracket, first) || reportNoBeginningLinebreak(node, openBracket), astUtils.isTokenOnSameLine(last, closeBracket) || reportNoEndingLinebreak(node, closeBracket));
+			}
+			return {
+				ArrayPattern: check,
+				ArrayExpression: check
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/array-bracket-newline.cjs
+module.exports = require_array_bracket_newline().create;
+//#endregion

package/rules/array-bracket-spacing.cjs

@@ -0,0 +1,184 @@
+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/array-bracket-spacing.js
+/**
+* @fileoverview Disallows or enforces spaces inside of array brackets.
+* @author Jamund Ferguson
+* @deprecated in ESLint v8.53.0
+*/
+var require_array_bracket_spacing = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @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: "array-bracket-spacing",
+						url: "https://eslint.style/rules/array-bracket-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent spacing inside array brackets",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/array-bracket-spacing"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: ["always", "never"] }, {
+				type: "object",
+				properties: {
+					singleValue: { type: "boolean" },
+					objectsInArrays: { type: "boolean" },
+					arraysInArrays: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				unexpectedSpaceAfter: "There should be no space after '{{tokenValue}}'.",
+				unexpectedSpaceBefore: "There should be no space before '{{tokenValue}}'.",
+				missingSpaceAfter: "A space is required after '{{tokenValue}}'.",
+				missingSpaceBefore: "A space is required before '{{tokenValue}}'."
+			}
+		},
+		create(context) {
+			let spaced = context.options[0] === "always", sourceCode = context.sourceCode;
+			/**
+			* Determines whether an option is set, relative to the spacing option.
+			* If spaced is "always", then check whether option is set to false.
+			* If spaced is "never", then check whether option is set to true.
+			* @param {Object} option The option to exclude.
+			* @returns {boolean} Whether or not the property is excluded.
+			*/
+			function isOptionSet(option) {
+				return context.options[1] ? context.options[1][option] === !spaced : !1;
+			}
+			let options = {
+				spaced,
+				singleElementException: isOptionSet("singleValue"),
+				objectsInArraysException: isOptionSet("objectsInArrays"),
+				arraysInArraysException: isOptionSet("arraysInArrays")
+			};
+			/**
+			* Reports that there shouldn't be a space after the first token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportNoBeginningSpace(node, token) {
+				let nextToken = sourceCode.getTokenAfter(token);
+				context.report({
+					node,
+					loc: {
+						start: token.loc.end,
+						end: nextToken.loc.start
+					},
+					messageId: "unexpectedSpaceAfter",
+					data: { tokenValue: token.value },
+					fix(fixer) {
+						return fixer.removeRange([token.range[1], nextToken.range[0]]);
+					}
+				});
+			}
+			/**
+			* Reports that there shouldn't be a space before the last token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportNoEndingSpace(node, token) {
+				let previousToken = sourceCode.getTokenBefore(token);
+				context.report({
+					node,
+					loc: {
+						start: previousToken.loc.end,
+						end: token.loc.start
+					},
+					messageId: "unexpectedSpaceBefore",
+					data: { tokenValue: token.value },
+					fix(fixer) {
+						return fixer.removeRange([previousToken.range[1], token.range[0]]);
+					}
+				});
+			}
+			/**
+			* Reports that there should be a space after the first token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportRequiredBeginningSpace(node, token) {
+				context.report({
+					node,
+					loc: token.loc,
+					messageId: "missingSpaceAfter",
+					data: { tokenValue: token.value },
+					fix(fixer) {
+						return fixer.insertTextAfter(token, " ");
+					}
+				});
+			}
+			/**
+			* Reports that there should be a space before the last token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportRequiredEndingSpace(node, token) {
+				context.report({
+					node,
+					loc: token.loc,
+					messageId: "missingSpaceBefore",
+					data: { tokenValue: token.value },
+					fix(fixer) {
+						return fixer.insertTextBefore(token, " ");
+					}
+				});
+			}
+			/**
+			* Determines if a node is an object type
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} Whether or not the node is an object type.
+			*/
+			function isObjectType(node) {
+				return node && (node.type === "ObjectExpression" || node.type === "ObjectPattern");
+			}
+			/**
+			* Determines if a node is an array type
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} Whether or not the node is an array type.
+			*/
+			function isArrayType(node) {
+				return node && (node.type === "ArrayExpression" || node.type === "ArrayPattern");
+			}
+			/**
+			* Validates the spacing around array brackets
+			* @param {ASTNode} node The node we're checking for spacing
+			* @returns {void}
+			*/
+			function validateArraySpacing(node) {
+				if (options.spaced && node.elements.length === 0) return;
+				let first = sourceCode.getFirstToken(node), second = sourceCode.getFirstToken(node, 1), last = node.typeAnnotation ? sourceCode.getTokenBefore(node.typeAnnotation) : sourceCode.getLastToken(node), penultimate = sourceCode.getTokenBefore(last), firstElement = node.elements[0], lastElement = node.elements.at(-1), openingBracketMustBeSpaced = options.objectsInArraysException && isObjectType(firstElement) || options.arraysInArraysException && isArrayType(firstElement) || options.singleElementException && node.elements.length === 1 ? !options.spaced : options.spaced, closingBracketMustBeSpaced = options.objectsInArraysException && isObjectType(lastElement) || options.arraysInArraysException && isArrayType(lastElement) || options.singleElementException && node.elements.length === 1 ? !options.spaced : options.spaced;
+				astUtils.isTokenOnSameLine(first, second) && (openingBracketMustBeSpaced && !sourceCode.isSpaceBetweenTokens(first, second) && reportRequiredBeginningSpace(node, first), !openingBracketMustBeSpaced && sourceCode.isSpaceBetweenTokens(first, second) && reportNoBeginningSpace(node, first)), first !== penultimate && astUtils.isTokenOnSameLine(penultimate, last) && (closingBracketMustBeSpaced && !sourceCode.isSpaceBetweenTokens(penultimate, last) && reportRequiredEndingSpace(node, last), !closingBracketMustBeSpaced && sourceCode.isSpaceBetweenTokens(penultimate, last) && reportNoEndingSpace(node, last));
+			}
+			return {
+				ArrayPattern: validateArraySpacing,
+				ArrayExpression: validateArraySpacing
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/array-bracket-spacing.cjs
+module.exports = require_array_bracket_spacing().create;
+//#endregion