@less-unsound/eslint-plugin 0.0.1

package/dist/esm/index.js

@@ -0,0 +1,352 @@
+import { noForLetRule } from "./rules/no-for-let.js";
+import { noAccidentalMutationRule } from "./rules/no-accidental-mutation.js";
+import { noAmbientDomGlobalsRule } from "./rules/no-ambient-dom-globals.js";
+import { noArgumentsObjectRule } from "./rules/no-arguments-object.js";
+import { noAnyRule } from "./rules/no-any.js";
+import { noAsTypeAssertionRule } from "./rules/no-as-type-assertion.js";
+import { noBigintRule } from "./rules/no-bigint.js";
+import { noBooleanLiteralCompareRule } from "./rules/no-boolean-literal-compare.js";
+import { noBufferRule } from "./rules/no-buffer.js";
+import { noBroadTypesRule } from "./rules/no-broad-types.js";
+import { noClassRule } from "./rules/no-class.js";
+import { noCommaOperatorRule } from "./rules/no-comma-operator.js";
+import { noConditionalTypeRule } from "./rules/no-conditional-type.js";
+import { noDefaultParameterRule } from "./rules/no-default-parameter.js";
+import { noEvalRule } from "./rules/no-eval.js";
+import { noEnumRule } from "./rules/no-enum.js";
+import { noExportDefaultRule } from "./rules/no-export-default.js";
+import { noForInRule } from "./rules/no-for-in.js";
+import { noFunctionConstructorRule } from "./rules/no-function-constructor.js";
+import { noGenericParameterBoundsRule } from "./rules/no-generic-parameter-bounds.js";
+import { noFunctionKeywordRule } from "./rules/no-function-keyword.js";
+import { noGetterSetterRule } from "./rules/no-getter-setter.js";
+import { noGlobalContextRule } from "./rules/no-global-context.js";
+import { noInOperatorRule } from "./rules/no-in-operator.js";
+import { noIndexedObjectTypeRule } from "./rules/no-indexed-object-type.js";
+import { noIndexedAccessTypeRule } from "./rules/no-indexed-access-type.js";
+import { noImportCodeExtensionRule } from "./rules/no-import-code-extension.js";
+import { noImportRenameRule } from "./rules/no-import-rename.js";
+import { noImportTypeRule } from "./rules/no-import-type.js";
+import { noInheritanceRule } from "./rules/no-inheritance.js";
+import { noInlineTaggedObjectRule } from "./rules/no-inline-tagged-object.js";
+import { noIntersectionTypeRule } from "./rules/no-intersection-type.js";
+import { noJsonStaticMethodRule } from "./rules/no-json-static-method.js";
+import { noKeyofRule } from "./rules/no-keyof.js";
+import { noLetRule } from "./rules/no-let.js";
+import { noMappedObjectTypeRule } from "./rules/no-mapped-object-type.js";
+import { noNeverRule } from "./rules/no-never.js";
+import { noNonNullAssertionRule } from "./rules/no-non-null-assertion.js";
+import { noNullRule } from "./rules/no-null.js";
+import { noObjectAsMapRule } from "./rules/no-object-as-map.js";
+import { noObjectSpreadRule } from "./rules/no-object-spread.js";
+import { noObjectStringificationHookRule } from "./rules/no-object-stringification-hook.js";
+import { noOptionalParameterRule } from "./rules/no-optional-parameter.js";
+import { noOptionalPropertyRule } from "./rules/no-optional-property.js";
+import { noOverloadRule } from "./rules/no-overload.js";
+import { noParamAssignRule } from "./rules/no-param-assign.js";
+import { noPrototypeAccessRule } from "./rules/no-prototype-access.js";
+import { noProxyReflectRule } from "./rules/no-proxy-reflect.js";
+import { noRequireRule } from "./rules/no-require.js";
+import { noRegularExpressionRule } from "./rules/no-regular-expression.js";
+import { noReexportOutsideEntrypointRule } from "./rules/no-reexport-outside-entrypoint.js";
+import { noRestParameterRule } from "./rules/no-rest-parameter.js";
+import { noSymbolRule } from "./rules/no-symbol.js";
+import { noSwitchRule } from "./rules/no-switch.js";
+import { noTryCatchRule } from "./rules/no-try-catch.js";
+import { noTsCommentDirectiveRule } from "./rules/no-ts-comment-directive.js";
+import { noTupleRule } from "./rules/no-tuple.js";
+import { noTypeGuardRule } from "./rules/no-type-guard.js";
+import { noTypeofOperatorRule } from "./rules/no-typeof-operator.js";
+import { noTypeofTypeRule } from "./rules/no-typeof-type.js";
+import { noUndefinedTypeRule } from "./rules/no-undefined-type.js";
+import { noUnknownRule } from "./rules/no-unknown.js";
+import { noUntaggedObjectUnionRule } from "./rules/no-untagged-object-union.js";
+import { noUtilityTypeRule } from "./rules/no-utility-type.js";
+import { noVarRule } from "./rules/no-var.js";
+import { noVoidOperatorRule } from "./rules/no-void-operator.js";
+import { noWhileRule } from "./rules/no-while.js";
+import { requireDisjointUnionRule } from "./rules/require-disjoint-union.js";
+import { requireBooleanPrefixRule } from "./rules/require-boolean-prefix.js";
+import { requireFunctionVerbRule } from "./rules/require-function-verb.js";
+import { requireIdentifierCaseRule } from "./rules/require-identifier-case.js";
+import { requireKebabCaseFilenameRule } from "./rules/require-kebab-case-filename.js";
+import { requireNamedUnionBranchRule } from "./rules/require-named-union-branch.js";
+import { requireReadonlyArrayRule } from "./rules/require-readonly-array.js";
+import { requireReadonlyCollectionsRule } from "./rules/require-readonly-collections.js";
+import { requireReadonlyObjectFieldsRule } from "./rules/require-readonly-object-fields.js";
+import { requireReturnTypeRule } from "./rules/require-return-type.js";
+import { requireStringTemplateExpressionRule } from "./rules/require-string-template-expression.js";
+import { requireReadonlyTupleRule } from "./rules/require-readonly-tuple.js";
+export const rules = Object.freeze({
+    "no-for-let": noForLetRule,
+    "no-accidental-mutation": noAccidentalMutationRule,
+    "no-ambient-dom-globals": noAmbientDomGlobalsRule,
+    "no-arguments-object": noArgumentsObjectRule,
+    "no-any": noAnyRule,
+    "no-as-type-assertion": noAsTypeAssertionRule,
+    "no-bigint": noBigintRule,
+    "no-boolean-literal-compare": noBooleanLiteralCompareRule,
+    "no-buffer": noBufferRule,
+    "no-broad-types": noBroadTypesRule,
+    "no-class": noClassRule,
+    "no-comma-operator": noCommaOperatorRule,
+    "no-conditional-type": noConditionalTypeRule,
+    "no-default-parameter": noDefaultParameterRule,
+    "no-eval": noEvalRule,
+    "no-enum": noEnumRule,
+    "no-export-default": noExportDefaultRule,
+    "no-for-in": noForInRule,
+    "no-function-constructor": noFunctionConstructorRule,
+    "no-generic-parameter-bounds": noGenericParameterBoundsRule,
+    "no-function-keyword": noFunctionKeywordRule,
+    "no-getter-setter": noGetterSetterRule,
+    "no-global-context": noGlobalContextRule,
+    "no-in-operator": noInOperatorRule,
+    "no-indexed-access-type": noIndexedAccessTypeRule,
+    "no-indexed-object-type": noIndexedObjectTypeRule,
+    "no-import-code-extension": noImportCodeExtensionRule,
+    "no-import-rename": noImportRenameRule,
+    "no-import-type": noImportTypeRule,
+    "no-inheritance": noInheritanceRule,
+    "no-inline-tagged-object": noInlineTaggedObjectRule,
+    "no-intersection-type": noIntersectionTypeRule,
+    "no-json-static-method": noJsonStaticMethodRule,
+    "no-keyof": noKeyofRule,
+    "no-let": noLetRule,
+    "no-mapped-object-type": noMappedObjectTypeRule,
+    "no-never": noNeverRule,
+    "no-non-null-assertion": noNonNullAssertionRule,
+    "no-null": noNullRule,
+    "no-object-as-map": noObjectAsMapRule,
+    "no-object-spread": noObjectSpreadRule,
+    "no-object-stringification-hook": noObjectStringificationHookRule,
+    "no-optional-parameter": noOptionalParameterRule,
+    "no-optional-property": noOptionalPropertyRule,
+    "no-overload": noOverloadRule,
+    "no-param-assign": noParamAssignRule,
+    "no-prototype-access": noPrototypeAccessRule,
+    "no-proxy-reflect": noProxyReflectRule,
+    "no-require": noRequireRule,
+    "no-reexport-outside-entrypoint": noReexportOutsideEntrypointRule,
+    "no-regular-expression": noRegularExpressionRule,
+    "no-rest-parameter": noRestParameterRule,
+    "no-symbol": noSymbolRule,
+    "no-switch": noSwitchRule,
+    "no-try-catch": noTryCatchRule,
+    "no-ts-comment-directive": noTsCommentDirectiveRule,
+    "no-tuple": noTupleRule,
+    "no-type-guard": noTypeGuardRule,
+    "no-typeof-operator": noTypeofOperatorRule,
+    "no-typeof-type": noTypeofTypeRule,
+    "no-undefined-type": noUndefinedTypeRule,
+    "no-unknown": noUnknownRule,
+    "no-untagged-object-union": noUntaggedObjectUnionRule,
+    "no-utility-type": noUtilityTypeRule,
+    "no-var": noVarRule,
+    "no-void-operator": noVoidOperatorRule,
+    "no-while": noWhileRule,
+    "require-disjoint-union": requireDisjointUnionRule,
+    "require-boolean-prefix": requireBooleanPrefixRule,
+    "require-function-verb": requireFunctionVerbRule,
+    "require-identifier-case": requireIdentifierCaseRule,
+    "require-kebab-case-filename": requireKebabCaseFilenameRule,
+    "require-named-union-branch": requireNamedUnionBranchRule,
+    "require-readonly-array": requireReadonlyArrayRule,
+    "require-readonly-collections": requireReadonlyCollectionsRule,
+    "require-readonly-object-fields": requireReadonlyObjectFieldsRule,
+    "require-return-type": requireReturnTypeRule,
+    "require-string-template-expression": requireStringTemplateExpressionRule,
+    "require-readonly-tuple": requireReadonlyTupleRule
+});
+const namespace = "@less-unsound";
+const packageName = "@less-unsound/eslint-plugin";
+export const plugin = Object.freeze({
+    meta: Object.freeze({
+        name: packageName,
+        version: "0.0.1"
+    }),
+    rules
+});
+const createConfig = (entries) => {
+    const namespacedRules = Object.fromEntries(entries.map(([name, level]) => [namespace + "/" + name, level]));
+    return Object.freeze({
+        plugins: Object.freeze({
+            [namespace]: plugin
+        }),
+        rules: Object.freeze(namespacedRules)
+    });
+};
+export const mutabilityConfig = createConfig([
+    ["no-for-let", "error"],
+    ["no-accidental-mutation", "error"],
+    ["no-let", "error"],
+    ["no-param-assign", "error"],
+    ["no-var", "error"],
+    ["require-readonly-array", "error"],
+    ["require-readonly-collections", "error"],
+    ["require-readonly-object-fields", "error"],
+    ["require-readonly-tuple", "error"]
+]);
+export const oopConfig = createConfig([
+    ["no-class", "error"],
+    ["no-getter-setter", "error"],
+    ["no-global-context", "error"],
+    ["no-inheritance", "error"],
+    ["no-object-stringification-hook", "error"],
+    ["no-prototype-access", "error"],
+    ["no-proxy-reflect", "error"]
+]);
+export const namingConfig = createConfig([
+    ["require-boolean-prefix", "error"],
+    ["require-function-verb", "error"],
+    ["require-identifier-case", "error"],
+    ["require-kebab-case-filename", "error"]
+]);
+export const typesConfig = createConfig([
+    ["no-any", "error"],
+    ["no-as-type-assertion", "error"],
+    ["no-broad-types", "error"],
+    ["no-conditional-type", "error"],
+    ["no-generic-parameter-bounds", "error"],
+    ["no-in-operator", "error"],
+    ["no-indexed-access-type", "error"],
+    ["no-indexed-object-type", "error"],
+    ["no-import-type", "error"],
+    ["no-intersection-type", "error"],
+    ["no-keyof", "error"],
+    ["no-mapped-object-type", "error"],
+    ["no-never", "warn"],
+    ["no-non-null-assertion", "error"],
+    ["no-tuple", "error"],
+    ["no-optional-property", "error"],
+    ["no-symbol", "error"],
+    ["no-overload", "error"],
+    ["no-ts-comment-directive", "error"],
+    ["no-type-guard", "error"],
+    ["no-typeof-operator", "error"],
+    ["no-typeof-type", "error"],
+    ["no-undefined-type", "warn"],
+    ["no-unknown", "error"],
+    ["no-utility-type", "error"],
+    ["require-disjoint-union", "error"],
+    ["require-named-union-branch", "error"],
+    ["require-return-type", "error"]
+]);
+export const syntaxConfig = createConfig([
+    ["no-ambient-dom-globals", "error"],
+    ["no-arguments-object", "error"],
+    ["no-default-parameter", "error"],
+    ["no-eval", "error"],
+    ["no-enum", "error"],
+    ["no-export-default", "error"],
+    ["no-for-in", "error"],
+    ["no-function-constructor", "error"],
+    ["no-function-keyword", "error"],
+    ["no-boolean-literal-compare", "error"],
+    ["no-buffer", "error"],
+    ["no-comma-operator", "error"],
+    ["no-inline-tagged-object", "error"],
+    ["no-json-static-method", "error"],
+    ["no-import-code-extension", "error"],
+    ["no-import-rename", "error"],
+    ["no-null", "error"],
+    ["no-object-as-map", "error"],
+    ["no-object-spread", "error"],
+    ["no-optional-parameter", "error"],
+    ["no-reexport-outside-entrypoint", "error"],
+    ["no-require", "error"],
+    ["no-regular-expression", "error"],
+    ["no-rest-parameter", "error"],
+    ["no-try-catch", "error"],
+    ["no-void-operator", "error"],
+    ["no-while", "error"],
+    ["require-string-template-expression", "error"]
+]);
+export const recommendedConfig = createConfig([
+    ["no-for-let", "error"],
+    ["no-any", "error"],
+    ["no-as-type-assertion", "error"],
+    ["no-accidental-mutation", "error"],
+    ["no-ambient-dom-globals", "error"],
+    ["no-arguments-object", "error"],
+    ["no-bigint", "warn"],
+    ["no-boolean-literal-compare", "error"],
+    ["no-buffer", "error"],
+    ["no-broad-types", "error"],
+    ["no-class", "error"],
+    ["no-comma-operator", "error"],
+    ["no-conditional-type", "error"],
+    ["no-default-parameter", "error"],
+    ["no-eval", "error"],
+    ["no-enum", "error"],
+    ["no-export-default", "error"],
+    ["no-for-in", "error"],
+    ["no-function-constructor", "error"],
+    ["no-function-keyword", "error"],
+    ["no-inline-tagged-object", "error"],
+    ["no-generic-parameter-bounds", "error"],
+    ["no-getter-setter", "error"],
+    ["no-global-context", "error"],
+    ["no-in-operator", "error"],
+    ["no-indexed-access-type", "error"],
+    ["no-indexed-object-type", "error"],
+    ["no-import-code-extension", "error"],
+    ["no-import-rename", "error"],
+    ["no-import-type", "error"],
+    ["no-inheritance", "error"],
+    ["no-intersection-type", "error"],
+    ["no-json-static-method", "error"],
+    ["no-keyof", "error"],
+    ["no-let", "error"],
+    ["no-mapped-object-type", "error"],
+    ["no-never", "warn"],
+    ["no-non-null-assertion", "error"],
+    ["no-null", "error"],
+    ["no-object-as-map", "error"],
+    ["no-object-spread", "error"],
+    ["no-object-stringification-hook", "error"],
+    ["no-optional-parameter", "error"],
+    ["no-optional-property", "error"],
+    ["no-overload", "error"],
+    ["no-param-assign", "error"],
+    ["no-prototype-access", "error"],
+    ["no-proxy-reflect", "error"],
+    ["no-reexport-outside-entrypoint", "error"],
+    ["no-require", "error"],
+    ["no-regular-expression", "error"],
+    ["no-rest-parameter", "error"],
+    ["no-symbol", "error"],
+    ["no-switch", "warn"],
+    ["no-try-catch", "error"],
+    ["no-ts-comment-directive", "error"],
+    ["no-tuple", "error"],
+    ["no-type-guard", "error"],
+    ["no-typeof-operator", "error"],
+    ["no-typeof-type", "error"],
+    ["no-undefined-type", "warn"],
+    ["no-unknown", "error"],
+    ["no-utility-type", "error"],
+    ["no-var", "error"],
+    ["no-void-operator", "error"],
+    ["no-while", "error"],
+    ["require-boolean-prefix", "error"],
+    ["require-disjoint-union", "error"],
+    ["require-function-verb", "error"],
+    ["require-identifier-case", "error"],
+    ["require-kebab-case-filename", "error"],
+    ["require-named-union-branch", "error"],
+    ["require-readonly-array", "error"],
+    ["require-readonly-collections", "error"],
+    ["require-readonly-object-fields", "error"],
+    ["require-return-type", "error"],
+    ["require-string-template-expression", "error"],
+    ["require-readonly-tuple", "off"]
+]);
+export const configs = Object.freeze({
+    mutability: mutabilityConfig,
+    naming: namingConfig,
+    oop: oopConfig,
+    recommended: recommendedConfig,
+    syntax: syntaxConfig,
+    types: typesConfig
+});

package/dist/esm/rules/no-accidental-mutation.d.ts

@@ -0,0 +1,3 @@
+export declare const noAccidentalMutationRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenAccidentalMutation", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-accidental-mutation.js

@@ -0,0 +1,97 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const freshArrayMethods = new Set([
+    "concat",
+    "filter",
+    "flat",
+    "flatMap",
+    "map",
+    "slice",
+    "toReversed",
+    "toSorted",
+    "toSpliced"
+]);
+const mutatingMethods = new Set(["reverse", "sort", "splice"]);
+const messageIds = Object.freeze({
+    forbiddenAccidentalMutation: "Accidental array mutation is not allowed on non-fresh arrays unless mutability is required for performance."
+});
+const getMemberName = (node) => {
+    if (node.computed) {
+        return undefined;
+    }
+    if (node.property.type !== AST_NODE_TYPES.Identifier) {
+        return undefined;
+    }
+    return node.property.name;
+};
+const isArrayFactoryCall = (node) => {
+    if (node.callee.type !== AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    const memberName = getMemberName(node.callee);
+    if (memberName !== "from" && memberName !== "of") {
+        return false;
+    }
+    if (node.callee.object.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return node.callee.object.name === "Array";
+};
+const isFreshArrayExpression = (node) => {
+    if (node.type === AST_NODE_TYPES.ArrayExpression) {
+        return true;
+    }
+    if (node.type === AST_NODE_TYPES.NewExpression) {
+        if (node.callee.type !== AST_NODE_TYPES.Identifier) {
+            return false;
+        }
+        return node.callee.name === "Array";
+    }
+    if (node.type !== AST_NODE_TYPES.CallExpression) {
+        return false;
+    }
+    if (isArrayFactoryCall(node)) {
+        return true;
+    }
+    if (node.callee.type !== AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    const memberName = getMemberName(node.callee);
+    if (memberName === undefined) {
+        return false;
+    }
+    return freshArrayMethods.has(memberName);
+};
+export const noAccidentalMutationRule = createRule({
+    name: "no-accidental-mutation",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow in-place `.sort()`, `.reverse()`, and `.splice()` on non-fresh arrays unless mutability is required for performance."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        CallExpression: (node) => {
+            if (node.callee.type !== AST_NODE_TYPES.MemberExpression) {
+                return;
+            }
+            const memberName = getMemberName(node.callee);
+            if (memberName === undefined) {
+                return;
+            }
+            if (!mutatingMethods.has(memberName)) {
+                return;
+            }
+            if (isFreshArrayExpression(node.callee.object)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenAccidentalMutation"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-ambient-dom-globals.d.ts

@@ -0,0 +1,3 @@
+export declare const noAmbientDomGlobalsRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<string, [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-ambient-dom-globals.js

@@ -0,0 +1,178 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule.js";
+const browserGlobals = new Set([
+    "addEventListener",
+    "blur",
+    "close",
+    "closed",
+    "confirm",
+    "defaultStatus",
+    "defaultstatus",
+    "event",
+    "external",
+    "find",
+    "focus",
+    "frameElement",
+    "frames",
+    "history",
+    "innerHeight",
+    "innerWidth",
+    "length",
+    "location",
+    "locationbar",
+    "menubar",
+    "moveBy",
+    "moveTo",
+    "name",
+    "onblur",
+    "onerror",
+    "onfocus",
+    "onload",
+    "onresize",
+    "onunload",
+    "open",
+    "opener",
+    "opera",
+    "outerHeight",
+    "outerWidth",
+    "pageXOffset",
+    "pageYOffset",
+    "parent",
+    "print",
+    "removeEventListener",
+    "resizeBy",
+    "resizeTo",
+    "screen",
+    "screenLeft",
+    "screenTop",
+    "screenX",
+    "screenY",
+    "scroll",
+    "scrollBy",
+    "scrollTo",
+    "scrollX",
+    "scrollY",
+    "scrollbars",
+    "status",
+    "statusbar",
+    "stop",
+    "toolbar",
+    "top"
+]);
+const messageIds = Object.freeze({
+    forbiddenAmbientDomGlobal: "Ambient DOM globals are not allowed."
+});
+const isBindingIdentifier = (node) => {
+    const parent = node.parent;
+    if (parent === null) {
+        return false;
+    }
+    if (parent.type === AST_NODE_TYPES.VariableDeclarator) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.FunctionDeclaration ||
+        parent.type === AST_NODE_TYPES.FunctionExpression) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.ClassDeclaration ||
+        parent.type === AST_NODE_TYPES.ClassExpression ||
+        parent.type === AST_NODE_TYPES.TSTypeAliasDeclaration ||
+        parent.type === AST_NODE_TYPES.TSInterfaceDeclaration ||
+        parent.type === AST_NODE_TYPES.TSEnumDeclaration) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSEnumMember) {
+        return parent.id === node;
+    }
+    if (parent.type === AST_NODE_TYPES.ImportSpecifier ||
+        parent.type === AST_NODE_TYPES.ImportDefaultSpecifier ||
+        parent.type === AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        return parent.local === node;
+    }
+    if (parent.type === AST_NODE_TYPES.ExportSpecifier) {
+        return parent.local === node || parent.exported === node;
+    }
+    if (parent.type === AST_NODE_TYPES.CatchClause) {
+        return parent.param === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSParameterProperty) {
+        return parent.parameter === node;
+    }
+    if (parent.type === AST_NODE_TYPES.MemberExpression) {
+        return parent.property === node && parent.computed === false;
+    }
+    if (parent.type === AST_NODE_TYPES.Property) {
+        if (parent.parent?.type === AST_NODE_TYPES.ObjectPattern) {
+            return parent.key === node && parent.computed === false;
+        }
+        if (parent.parent?.type === AST_NODE_TYPES.ObjectExpression) {
+            return parent.key === node && parent.computed === false;
+        }
+        return false;
+    }
+    if (parent.type === AST_NODE_TYPES.MethodDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === AST_NODE_TYPES.PropertyDefinition) {
+        return parent.key === node && parent.computed === false;
+    }
+    if (parent.type === AST_NODE_TYPES.TSPropertySignature ||
+        parent.type === AST_NODE_TYPES.TSMethodSignature) {
+        return parent.key === node;
+    }
+    if (parent.type === AST_NODE_TYPES.LabeledStatement) {
+        return parent.label === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSQualifiedName) {
+        return parent.left === node;
+    }
+    if (parent.type === AST_NODE_TYPES.TSImportEqualsDeclaration) {
+        return parent.id === node;
+    }
+    return false;
+};
+const hasDeclaredBinding = (scope, name) => {
+    let current = scope;
+    while (current !== null) {
+        for (const variable of current.variables) {
+            if (variable.name !== name) {
+                continue;
+            }
+            if (variable.defs.length > 0 || variable.identifiers.length > 0) {
+                return true;
+            }
+        }
+        current = current.upper;
+    }
+    return false;
+};
+export const noAmbientDomGlobalsRule = createRule({
+    name: "no-ambient-dom-globals",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow the confusing ambient browser-global surface."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        Identifier: (node) => {
+            if (!browserGlobals.has(node.name)) {
+                return;
+            }
+            if (isBindingIdentifier(node)) {
+                return;
+            }
+            const scope = context.sourceCode.getScope(node);
+            if (hasDeclaredBinding(scope, node.name)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenAmbientDomGlobal"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-any.d.ts

@@ -0,0 +1,3 @@
+export declare const noAnyRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbiddenAny", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/esm/rules/no-any.js

@@ -0,0 +1,24 @@
+import { createRule } from "../utils/create-rule.js";
+const messageIds = Object.freeze({
+    forbiddenAny: "`any` is not allowed."
+});
+export const noAnyRule = createRule({
+    name: "no-any",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow the `any` type."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        TSAnyKeyword: (node) => {
+            context.report({
+                node,
+                messageId: "forbiddenAny"
+            });
+        }
+    })
+});

package/dist/esm/rules/no-arguments-object.d.ts

@@ -0,0 +1,3 @@
+export declare const noArgumentsObjectRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<string, [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};