@acdvs/eslint-plugin-amd 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# eslint-plugin-amd
+
+ESLint plugin for JavaScript AMD module syntax.
+
+[![npm](https://img.shields.io/npm/v/@acdvs/eslint-plugin-amd)](https://www.npmjs.com/package/@acdvs/eslint-plugin-amd)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+## Features
+
+- Lints all AMD `define()` call shapes
+- Detects dynamic `require()` calls
+- Checks for mismatched dependency literals ↔ factory parameters
+- Enforces path conventions (no extensions, sorted dependencies)
+- Exports utility functions for use by other ESLint plugins
+
+## Installation
+
+```sh
+npm i -D eslint @acdvs/eslint-plugin-amd
+```
+
+Requires ESLint 9+ flat config format.
+
+## Configuration (ESLint 9+ flat config)
+
+```js
+// eslint.config.js
+import amd from '@acdvs/eslint-plugin-amd';
+
+export default [
+  // Recommended rules
+  ...amd.configs.recommended,
+
+  // Or configure rules individually
+  {
+    plugins: { amd },
+    rules: {
+      'amd/no-extra-deps': 'error',
+      'amd/no-extra-params': 'error',
+      'amd/no-invalid-define': 'error',
+      'amd/no-module-extensions': 'warn',
+      'amd/no-name': 'warn',
+      'amd/sorted-deps': ['warn', { order: 'asc' }],
+    },
+  },
+];
+```
+
+## Rules
+
+| Rule | Description | Recommended |
+|:--|:--|:--:|
+| [`amd/define-indicator`](docs/rules/define-indicator.md) | Enforce the presence of the AMD module `define()` indicator. | ❌ |
+| [`amd/no-dynamic-require`](docs/rules/no-dynamic-require.md) | Disallow dynamic (non-literal) expressions in `require()` calls. | ❌ |
+| [`amd/no-extra-deps`](docs/rules/no-extra-deps.md) | Disallow more dependency literals than factory parameters. | ✅ |
+| [`amd/no-extra-params`](docs/rules/no-extra-params.md) | Disallow more factory parameters than dependency literals. | ✅ |
+| [`amd/no-invalid-define`](docs/rules/no-invalid-define.md) | Disallow `define()` calls that do not match a valid AMD module signature. | ✅ |
+| [`amd/no-module-extensions`](docs/rules/no-module-extensions.md) | Disallow file extensions in AMD dependency paths. | ✅ |
+| [`amd/no-name`](docs/rules/no-name.md) | Disallow named AMD modules. | ✅ |
+| [`amd/sorted-deps`](docs/rules/sorted-deps.md) | Enforce alphabetical ordering of `define()` dependency literals. | ❌ |
+
+## Using utility functions in your own plugin
+
+```js
+import amdUtils from '@acdvs/eslint-plugin-amd/utils';
+
+create(context) {
+  return {
+    CallExpression(node) {
+      const defineCall = amdUtils.getDefineCall(node);
+
+      if (!defineCall) return;
+
+      // ...
+    },
+  };
+}
+```
+
+## License
+
+[MIT](LICENSE)

package/dist/define-B8C8F-jq.cjs

@@ -0,0 +1,118 @@
+//#region lib/utils/amd.ts
+/**
+* Determines if the source includes a `define.amd = { ... }` expression
+* for indicating that any present `define` calls follow AMD spec.
+* https://github.com/amdjs/amdjs-api/blob/master/AMD.md#defineamd-property-
+*/
+function hasAMDIndicator(sourceCode) {
+	return sourceCode.ast.body.some((stmt) => {
+		if (stmt.type !== "ExpressionStatement" || stmt.expression.type !== "AssignmentExpression") return false;
+		const { left, right } = stmt.expression;
+		return left.type === "MemberExpression" && !left.computed && left.object.type === "Identifier" && left.object.name === "define" && left.property.type === "Identifier" && left.property.name === "amd" && right.type === "ObjectExpression";
+	});
+}
+//#endregion
+//#region lib/utils/require.ts
+function isRequireCall(node) {
+	return node.callee.type === "Identifier" && node.callee.name === "require";
+}
+//#endregion
+//#region lib/utils/define.ts
+function isDefineCall(node) {
+	return node.callee.type === "Identifier" && node.callee.name === "define";
+}
+function isDefineName(node) {
+	return node.type === "Literal";
+}
+function isDefineDepArray(node) {
+	return node.type === "ArrayExpression" && node.elements.every((e) => e?.type === "Literal");
+}
+function isDefineFactory(node) {
+	return node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "ObjectExpression";
+}
+function factoryHasParams(node) {
+	return node.type !== "ObjectExpression" && node.params.length > 0;
+}
+function getDefineArgs(node) {
+	if (node.arguments.length === 0 || node.arguments.length > 3) return;
+	const args = node.arguments;
+	if (args.length === 1 && isDefineFactory(args[0])) return { factory: args[0] };
+	if (args.length === 2 && isDefineDepArray(args[0]) && isDefineFactory(args[1])) return {
+		dependencies: args[0],
+		factory: args[1]
+	};
+	if (args.length === 2 && isDefineName(args[0]) && isDefineFactory(args[1])) return {
+		name: args[0],
+		factory: args[1]
+	};
+	if (args.length === 3 && isDefineName(args[0]) && isDefineDepArray(args[1]) && isDefineFactory(args[2])) return {
+		name: args[0],
+		dependencies: args[1],
+		factory: args[2]
+	};
+}
+function getDependencyAnalysis(deps, factory) {
+	const depCount = deps?.elements.length || 0;
+	if (depCount === 0 && !factoryHasParams(factory)) return;
+	const maxLength = factory.type === "ObjectExpression" ? depCount : Math.max(depCount, factory.params.length);
+	const pairs = [];
+	const extraNames = [];
+	const extraParams = [];
+	for (let i = 0; i < maxLength; i++) {
+		const name = deps?.elements?.[i];
+		const param = factory.type === "ObjectExpression" ? void 0 : factory.params[i];
+		if (name && param) pairs.push({
+			name,
+			param
+		});
+		else if (name && !param) extraNames.push(name);
+		else if (!name && param) extraParams.push(param);
+	}
+	return {
+		pairs,
+		extraNames,
+		extraParams,
+		isBalanced: extraNames.length === 0 && extraParams.length === 0
+	};
+}
+function getDefineCall(node) {
+	if (!isDefineCall(node)) return;
+	const args = getDefineArgs(node);
+	if (!args) return;
+	return {
+		args,
+		depAnalysis: getDependencyAnalysis(args.dependencies, args.factory),
+		node
+	};
+}
+//#endregion
+Object.defineProperty(exports, "getDefineArgs", {
+	enumerable: true,
+	get: function() {
+		return getDefineArgs;
+	}
+});
+Object.defineProperty(exports, "getDefineCall", {
+	enumerable: true,
+	get: function() {
+		return getDefineCall;
+	}
+});
+Object.defineProperty(exports, "hasAMDIndicator", {
+	enumerable: true,
+	get: function() {
+		return hasAMDIndicator;
+	}
+});
+Object.defineProperty(exports, "isDefineCall", {
+	enumerable: true,
+	get: function() {
+		return isDefineCall;
+	}
+});
+Object.defineProperty(exports, "isRequireCall", {
+	enumerable: true,
+	get: function() {
+		return isRequireCall;
+	}
+});

package/dist/define-DldfQ_w6.mjs

@@ -0,0 +1,89 @@
+//#region lib/utils/amd.ts
+/**
+* Determines if the source includes a `define.amd = { ... }` expression
+* for indicating that any present `define` calls follow AMD spec.
+* https://github.com/amdjs/amdjs-api/blob/master/AMD.md#defineamd-property-
+*/
+function hasAMDIndicator(sourceCode) {
+	return sourceCode.ast.body.some((stmt) => {
+		if (stmt.type !== "ExpressionStatement" || stmt.expression.type !== "AssignmentExpression") return false;
+		const { left, right } = stmt.expression;
+		return left.type === "MemberExpression" && !left.computed && left.object.type === "Identifier" && left.object.name === "define" && left.property.type === "Identifier" && left.property.name === "amd" && right.type === "ObjectExpression";
+	});
+}
+//#endregion
+//#region lib/utils/require.ts
+function isRequireCall(node) {
+	return node.callee.type === "Identifier" && node.callee.name === "require";
+}
+//#endregion
+//#region lib/utils/define.ts
+function isDefineCall(node) {
+	return node.callee.type === "Identifier" && node.callee.name === "define";
+}
+function isDefineName(node) {
+	return node.type === "Literal";
+}
+function isDefineDepArray(node) {
+	return node.type === "ArrayExpression" && node.elements.every((e) => e?.type === "Literal");
+}
+function isDefineFactory(node) {
+	return node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "ObjectExpression";
+}
+function factoryHasParams(node) {
+	return node.type !== "ObjectExpression" && node.params.length > 0;
+}
+function getDefineArgs(node) {
+	if (node.arguments.length === 0 || node.arguments.length > 3) return;
+	const args = node.arguments;
+	if (args.length === 1 && isDefineFactory(args[0])) return { factory: args[0] };
+	if (args.length === 2 && isDefineDepArray(args[0]) && isDefineFactory(args[1])) return {
+		dependencies: args[0],
+		factory: args[1]
+	};
+	if (args.length === 2 && isDefineName(args[0]) && isDefineFactory(args[1])) return {
+		name: args[0],
+		factory: args[1]
+	};
+	if (args.length === 3 && isDefineName(args[0]) && isDefineDepArray(args[1]) && isDefineFactory(args[2])) return {
+		name: args[0],
+		dependencies: args[1],
+		factory: args[2]
+	};
+}
+function getDependencyAnalysis(deps, factory) {
+	const depCount = deps?.elements.length || 0;
+	if (depCount === 0 && !factoryHasParams(factory)) return;
+	const maxLength = factory.type === "ObjectExpression" ? depCount : Math.max(depCount, factory.params.length);
+	const pairs = [];
+	const extraNames = [];
+	const extraParams = [];
+	for (let i = 0; i < maxLength; i++) {
+		const name = deps?.elements?.[i];
+		const param = factory.type === "ObjectExpression" ? void 0 : factory.params[i];
+		if (name && param) pairs.push({
+			name,
+			param
+		});
+		else if (name && !param) extraNames.push(name);
+		else if (!name && param) extraParams.push(param);
+	}
+	return {
+		pairs,
+		extraNames,
+		extraParams,
+		isBalanced: extraNames.length === 0 && extraParams.length === 0
+	};
+}
+function getDefineCall(node) {
+	if (!isDefineCall(node)) return;
+	const args = getDefineArgs(node);
+	if (!args) return;
+	return {
+		args,
+		depAnalysis: getDependencyAnalysis(args.dependencies, args.factory),
+		node
+	};
+}
+//#endregion
+export { hasAMDIndicator as a, isRequireCall as i, getDefineCall as n, isDefineCall as r, getDefineArgs as t };

package/dist/index.cjs

@@ -0,0 +1,343 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+const require_define = require("./define-B8C8F-jq.cjs");
+let globals = require("globals");
+globals = __toESM(globals, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+//#region package.json
+var name = "@acdvs/eslint-plugin-amd";
+var version = "1.0.0";
+var homepage = "https://github.com/acdvs/eslint-plugin-amd";
+//#endregion
+//#region lib/rules/index.ts
+var rules_default = {
+	"define-indicator": {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Enforce the presence of the AMD module `define()` indicator.",
+				url: `${homepage}/blob/main/docs/rules/${node_path.default.basename(__filename, ".ts")}.md`
+			},
+			fixable: "code",
+			schema: [],
+			messages: {
+				defineCallWithoutIndicator: "Missing AMD module `define` indicator: `define.amd = {}`",
+				indicatorWithoutDefineCall: "AMD module `define` indicator present without a `define()` call."
+			}
+		},
+		create: (context) => {
+			let hasDefineCall = false;
+			return {
+				"CallExpression[callee.name=define]": () => {
+					hasDefineCall = true;
+				},
+				"Program:exit": (program) => {
+					const hasIndicator = require_define.hasAMDIndicator(context.sourceCode);
+					if (hasDefineCall && !hasIndicator) {
+						context.report({
+							node: program,
+							messageId: "defineCallWithoutIndicator",
+							fix: (fixer) => {
+								return fixer.insertTextAfter(program, "\n\ndefine.amd = {};");
+							}
+						});
+						return;
+					}
+					if (!hasDefineCall && hasIndicator) context.report({
+						node: program,
+						messageId: "indicatorWithoutDefineCall"
+					});
+				}
+			};
+		}
+	},
+	"no-dynamic-require": {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow dynamic (non-literal) expressions in `require()` calls.",
+				url: `${homepage}/blob/main/docs/rules/${node_path.default.basename(__filename, ".ts")}.md`
+			},
+			schema: [],
+			messages: {
+				dynamicRequire: "`require()` argument must be a string literal or an array of string literals.",
+				dynamicRequireElement: "All elements of a `require()` dependency array must be string literals."
+			}
+		},
+		create: (context) => {
+			return { CallExpression: (node) => {
+				if (!require_define.isRequireCall(node) || node.arguments.length === 0) return;
+				const firstArg = node.arguments[0];
+				if (firstArg.type === "Literal") return;
+				if (firstArg.type === "ArrayExpression") {
+					for (const el of firstArg.elements) if (el === null || el.type !== "Literal") context.report({
+						node: el ?? firstArg,
+						messageId: "dynamicRequireElement"
+					});
+					return;
+				}
+				context.report({
+					node: firstArg,
+					messageId: "dynamicRequire"
+				});
+			} };
+		}
+	},
+	"no-extra-deps": {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow more dependency literals than factory parameters.",
+				recommended: true,
+				url: `${homepage}/blob/main/docs/rules/${node_path.default.basename(__filename, ".ts")}.md`
+			},
+			schema: [{
+				type: "object",
+				properties: { ignoreValueFactory: {
+					type: "boolean",
+					default: true
+				} },
+				additionalProperties: false
+			}],
+			defaultOptions: [{ ignoreValueFactory: true }],
+			messages: { extraDep: "Dependency '{{dep}}' has no corresponding factory parameter. Add a parameter or remove the dependency." }
+		},
+		create: (context) => {
+			const { ignoreValueFactory } = context.options[0] ?? {};
+			return { "CallExpression[callee.name=define]": (node) => {
+				const def = require_define.getDefineCall(node);
+				const hasValueFactory = def?.args.factory.type === "ObjectExpression";
+				if (!def?.depAnalysis || hasValueFactory && ignoreValueFactory) return;
+				for (const name of def.depAnalysis.extraNames) context.report({
+					node: name,
+					messageId: "extraDep",
+					data: { dep: String(name.value) }
+				});
+			} };
+		}
+	},
+	"no-extra-params": {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow more factory parameters than dependency literals.",
+				recommended: true,
+				url: `${homepage}/blob/main/docs/rules/${node_path.default.basename(__filename, ".ts")}.md`
+			},
+			schema: [],
+			messages: {
+				extraIdentParam: "Factory parameter '{{param}}' has no corresponding dependency literal. Add a dependency or remove the parameter.",
+				extraNonIdentParam: "Factory parameter has no corresponding dependency literal. Add a dependency or remove the parameter."
+			}
+		},
+		create: (context) => {
+			return { "CallExpression[callee.name=define]": (node) => {
+				const def = require_define.getDefineCall(node);
+				if (!def?.depAnalysis) return;
+				for (const param of def.depAnalysis.extraParams) if (param.type === "Identifier") context.report({
+					node: param,
+					messageId: "extraIdentParam",
+					data: { param: param.name }
+				});
+				else context.report({
+					node: param,
+					messageId: "extraNonIdentParam"
+				});
+			} };
+		}
+	},
+	"no-invalid-define": {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow `define()` calls that do not match a valid AMD module signature.",
+				recommended: true,
+				url: `${homepage}/blob/main/docs/rules/${node_path.default.basename(__filename, ".ts")}.md`
+			},
+			schema: [],
+			messages: { invalidDefine: "`define()` call does not match a valid signature." }
+		},
+		create: (context) => {
+			return { "CallExpression[callee.name=define]": (node) => {
+				if (!require_define.getDefineCall(node)) context.report({
+					node,
+					messageId: "invalidDefine"
+				});
+			} };
+		}
+	},
+	"no-module-extensions": {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow file extensions in AMD dependency paths.",
+				recommended: true,
+				url: `${homepage}/blob/main/docs/rules/${node_path.default.basename(__filename, ".ts")}.md`
+			},
+			schema: [{ oneOf: [{
+				type: "object",
+				properties: {
+					blacklist: {
+						type: "array",
+						items: { type: "string" },
+						minItems: 1,
+						uniqueItems: true,
+						description: "Extensions disallowed in dependency paths. If set, all other extensions are allowed."
+					},
+					whitelist: {
+						type: "array",
+						items: { type: "string" },
+						minItems: 1,
+						uniqueItems: true,
+						description: "Extensions allowed in dependency paths. If set, all other extensions are disallowed and any `blacklist` is ignored."
+					}
+				},
+				additionalProperties: false
+			}] }],
+			messages: {
+				blacklistedDefault: "Dependency '{{dep}}' should not include a file extension.",
+				blacklisted: "Dependency '{{dep}}' should not include a blacklisted file extension.",
+				notWhitelisted: "Dependency '{{dep}}' includes a non-whitelisted file extension."
+			}
+		},
+		create: (context) => {
+			const { blacklist, whitelist } = context.options[0] ?? {};
+			return { "CallExpression[callee.name=define]": (node) => {
+				const def = require_define.getDefineCall(node);
+				if (!def?.args.dependencies) return;
+				for (const el of def.args.dependencies.elements) {
+					const literal = el;
+					const dep = literal.value;
+					if (!/(\.\w+)+$/.test(dep)) continue;
+					if (whitelist && whitelist.length > 0) {
+						if (!whitelist.some((ext) => dep.endsWith(ext))) context.report({
+							node: literal,
+							messageId: "notWhitelisted",
+							data: { dep }
+						});
+						continue;
+					}
+					const isDefaultBlacklist = !blacklist;
+					if (isDefaultBlacklist || blacklist.some((ext) => dep.endsWith(ext))) context.report({
+						node: literal,
+						messageId: isDefaultBlacklist ? "blacklistedDefault" : "blacklisted",
+						data: { dep }
+					});
+				}
+			} };
+		}
+	},
+	"no-name": {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow named AMD modules.",
+				recommended: true,
+				url: `${homepage}/blob/main/docs/rules/${node_path.default.basename(__filename, ".ts")}.md`
+			},
+			schema: [],
+			messages: { noAmdName: "AMD module should be anonymous. Remove the name argument '{{name}}' from the `define()` call." }
+		},
+		create: (context) => {
+			return { "CallExpression[callee.name=define]": (node) => {
+				const def = require_define.getDefineCall(node);
+				if (!def) return;
+				if (def.args.name) context.report({
+					node: def.args.name,
+					messageId: "noAmdName",
+					data: { name: def.args.name.value }
+				});
+			} };
+		}
+	},
+	"sorted-deps": {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Enforce alphabetical ordering of `define()` dependency literals.",
+				url: `${homepage}/blob/main/docs/rules/${node_path.default.basename(__filename, ".ts")}.md`
+			},
+			schema: [{
+				type: "object",
+				properties: { order: {
+					type: "string",
+					enum: ["asc", "desc"],
+					default: "asc"
+				} },
+				additionalProperties: false
+			}],
+			defaultOptions: [{ order: "asc" }],
+			messages: { wrongOrder: "Dependencies should be sorted in {{order}} order." }
+		},
+		create: (context) => {
+			const { order } = context.options[0] ?? {};
+			return { "CallExpression[callee.name=define]": (node) => {
+				const deps = require_define.getDefineCall(node)?.args.dependencies;
+				const els = deps?.elements;
+				if (!deps || !els) return;
+				for (let i = 1; i < els.length; i++) {
+					const prevEl = els[i - 1];
+					const currEl = els[i];
+					const prevDep = prevEl.value;
+					const currDep = currEl.value;
+					if (order === "asc" ? currDep < prevDep : currDep > prevDep) context.report({
+						node: deps,
+						messageId: "wrongOrder",
+						data: { order: order === "asc" ? "alphabetical" : `reverse alphabetical` }
+					});
+				}
+			} };
+		}
+	}
+};
+//#endregion
+//#region lib/index.ts
+const plugin = {
+	meta: {
+		name,
+		version
+	},
+	rules: rules_default,
+	configs: {}
+};
+const defaults = {
+	plugins: { amd: plugin },
+	languageOptions: {
+		sourceType: "commonjs",
+		globals: { ...globals.default.amd }
+	}
+};
+plugin.configs.all = [{
+	...defaults,
+	rules: Object.fromEntries(Object.entries(rules_default).map(entryToConfigArray))
+}];
+plugin.configs.recommended = [{
+	...defaults,
+	rules: Object.fromEntries(Object.entries(rules_default).filter(([, rule]) => rule.meta?.docs?.recommended).map(entryToConfigArray))
+}];
+function entryToConfigArray([name, rule]) {
+	return [`amd/${name}`, rule.meta?.type === "problem" ? "error" : "warn"];
+}
+//#endregion
+module.exports = plugin;

package/dist/index.d.cts

@@ -0,0 +1,23 @@
+import { a as DependencyPair, i as DependencyAnalysis, n as DefineCall, r as DefineFactory, t as DefineArgs } from "./types-OWk_tv7p.cjs";
+import { Linter, Rule } from "eslint";
+
+//#region lib/index.d.ts
+declare const plugin: {
+  meta: {
+    name: string;
+    version: string;
+  };
+  rules: {
+    'define-indicator': Rule.RuleModule;
+    'no-dynamic-require': Rule.RuleModule;
+    'no-extra-deps': Rule.RuleModule;
+    'no-extra-params': Rule.RuleModule;
+    'no-invalid-define': Rule.RuleModule;
+    'no-module-extensions': Rule.RuleModule;
+    'no-name': Rule.RuleModule;
+    'sorted-deps': Rule.RuleModule;
+  };
+  configs: Record<string, Linter.Config[]>;
+};
+//#endregion
+export { DefineArgs, DefineCall, DefineFactory, DependencyAnalysis, DependencyPair, plugin as default };