@jameswyse/oxc-config 0.1.0

package/dist/vendor/anti-slop/shared/array-method.d.ts

@@ -0,0 +1,10 @@
+import type { ESTree, SourceCode, Variable } from "@oxlint/plugins";
+type ArrayMethodTarget = {
+    readonly name: string;
+    readonly object: ESTree.Expression;
+};
+declare function unwrapArrayExpression(expression: ESTree.Node): ESTree.Node;
+declare function resolveArrayBinding(sourceCode: SourceCode, expression: ESTree.Node): Variable | null;
+declare function arrayMethodTarget(expression: ESTree.Node): ArrayMethodTarget | null;
+declare function isKnownArrayExpression(sourceCode: SourceCode, expression: ESTree.Node, visited?: Set<Variable>): boolean;
+export { arrayMethodTarget, isKnownArrayExpression, resolveArrayBinding, unwrapArrayExpression };

package/dist/vendor/anti-slop/shared/array-method.js

@@ -0,0 +1,95 @@
+import { resolveVariable } from "./scope.js";
+function unwrapArrayExpression(expression) {
+    let node = expression;
+    while (node.type === "ParenthesizedExpression" ||
+        node.type === "ChainExpression" ||
+        node.type === "TSAsExpression" ||
+        node.type === "TSTypeAssertion" ||
+        node.type === "TSNonNullExpression" ||
+        node.type === "TSSatisfiesExpression") {
+        node = node.expression;
+    }
+    return node;
+}
+function resolveArrayBinding(sourceCode, expression) {
+    const node = unwrapArrayExpression(expression);
+    return node.type === "Identifier" ? resolveVariable(sourceCode, node) : null;
+}
+function arrayMethodTarget(expression) {
+    const node = unwrapArrayExpression(expression);
+    if (node.type !== "MemberExpression") {
+        return null;
+    }
+    const property = node.property;
+    if (!node.computed && property.type === "Identifier") {
+        return { name: property.name, object: node.object };
+    }
+    if (node.computed && property.type === "Literal" && typeof property.value === "string") {
+        return { name: property.value, object: node.object };
+    }
+    return null;
+}
+function isArrayAnnotation(type) {
+    if (type.type === "TSArrayType" || type.type === "TSTupleType") {
+        return true;
+    }
+    if (type.type === "TSParenthesizedType") {
+        return isArrayAnnotation(type.typeAnnotation);
+    }
+    if (type.type === "TSTypeOperator" && type.operator === "readonly") {
+        return isArrayAnnotation(type.typeAnnotation);
+    }
+    return (type.type === "TSTypeReference" &&
+        type.typeName.type === "Identifier" &&
+        (type.typeName.name === "Array" || type.typeName.name === "ReadonlyArray"));
+}
+function isKnownArrayExpression(sourceCode, expression, visited = new Set()) {
+    const node = unwrapArrayExpression(expression);
+    if (node.type === "ArrayExpression") {
+        return true;
+    }
+    if (node.type === "CallExpression") {
+        const method = arrayMethodTarget(node.callee);
+        return (method !== null &&
+            [
+                "map",
+                "filter",
+                "flatMap",
+                "slice",
+                "concat",
+                "toSorted",
+                "toReversed",
+                "toSpliced",
+            ].includes(method.name) &&
+            isKnownArrayExpression(sourceCode, method.object, visited));
+    }
+    if (node.type !== "Identifier") {
+        return false;
+    }
+    const variable = resolveArrayBinding(sourceCode, node);
+    if (variable === null || visited.has(variable)) {
+        return false;
+    }
+    visited.add(variable);
+    if (variable.references.some((reference) => reference.isWrite() && !reference.init)) {
+        return false;
+    }
+    for (const identifier of variable.identifiers) {
+        const annotation = identifier.typeAnnotation?.typeAnnotation;
+        if (annotation !== void 0) {
+            return isArrayAnnotation(annotation);
+        }
+    }
+    for (const definition of variable.defs) {
+        if (definition.type === "Variable" &&
+            definition.node.type === "VariableDeclarator" &&
+            definition.node.id.type === "Identifier" &&
+            definition.node.init !== null &&
+            definition.node.parent.type === "VariableDeclaration" &&
+            definition.node.parent.kind === "const") {
+            return isKnownArrayExpression(sourceCode, definition.node.init, visited);
+        }
+    }
+    return false;
+}
+export { arrayMethodTarget, isKnownArrayExpression, resolveArrayBinding, unwrapArrayExpression };

package/dist/vendor/anti-slop/shared/dictionary-types.d.ts

@@ -0,0 +1,23 @@
+import type { ESTree, SourceCode } from "@oxlint/plugins";
+import type { TypeAliasEnvironment } from "./type-alias-resolution.ts";
+type UnsafeValue = "any" | "empty-object" | "object" | "union" | "unknown";
+type UnsafeDictionary = {
+    readonly kind: "unsafe-dictionary";
+    readonly unsafeValue: UnsafeValue;
+};
+type WideningTargetKind = "anonymous object" | "generic container" | "object" | "open dictionary" | "unknown";
+type WideningTarget = {
+    readonly kind: WideningTargetKind;
+};
+type TypeEnvironment = {
+    readonly interfaces: ReadonlyMap<string, readonly ESTree.TSInterfaceDeclaration[]>;
+    readonly typeAliases: TypeAliasEnvironment;
+};
+declare function createTypeEnvironment(program: ESTree.Program, visitorKeys: SourceCode["visitorKeys"]): TypeEnvironment;
+declare function classifyUnsafeDictionaryValue(valueType: ESTree.TSType, environment: TypeEnvironment): UnsafeDictionary | null;
+declare function classifyUnsafeDictionary(type: ESTree.TSType, environment: TypeEnvironment): UnsafeDictionary | null;
+declare function classifyWideningTarget(type: ESTree.TSType, environment: TypeEnvironment): WideningTarget | null;
+declare function isPopulatedObjectExpression(expression: ESTree.Node): boolean;
+declare function isKnownEvidenceExpression(expression: ESTree.Node): boolean;
+export type { TypeEnvironment, UnsafeDictionary, WideningTarget };
+export { classifyUnsafeDictionary, classifyUnsafeDictionaryValue, classifyWideningTarget, createTypeEnvironment, isKnownEvidenceExpression, isPopulatedObjectExpression, };

package/dist/vendor/anti-slop/shared/dictionary-types.js

@@ -0,0 +1,408 @@
+import { createTypeAliasEnvironment, hasVisibleTypeBinding, visibleTypeAlias, } from "./type-alias-resolution.js";
+const BUILT_INS = new Set([
+    "Record",
+    "Readonly",
+    "Partial",
+    "Required",
+    "Pick",
+    "Omit",
+    "PropertyKey",
+    "NonNullable",
+]);
+const TRANSPARENT_WRAPPERS = new Set(["Readonly", "Partial", "Required", "NonNullable"]);
+function declaredStatement(statement) {
+    return statement.type === "ExportNamedDeclaration" ||
+        statement.type === "ExportDefaultDeclaration"
+        ? (statement.declaration ?? null)
+        : statement;
+}
+function createTypeEnvironment(program, visitorKeys) {
+    const interfaces = new Map();
+    for (const statement of program.body) {
+        const declaration = declaredStatement(statement);
+        if (declaration?.type !== "TSInterfaceDeclaration") {
+            continue;
+        }
+        const declarations = interfaces.get(declaration.id.name) ?? [];
+        declarations.push(declaration);
+        interfaces.set(declaration.id.name, declarations);
+    }
+    return { interfaces, typeAliases: createTypeAliasEnvironment(program, visitorKeys) };
+}
+function typeReferenceName(type) {
+    return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function isBuiltIn(name, use, environment) {
+    return BUILT_INS.has(name) && !hasVisibleTypeBinding(name, use, environment.typeAliases);
+}
+function unwrapTransparentType(type) {
+    let current = type;
+    while (current.type === "TSParenthesizedType" ||
+        (current.type === "TSTypeOperator" && current.operator === "readonly")) {
+        current = current.typeAnnotation;
+    }
+    return current;
+}
+function isUnappliedReferenceTo(type, name) {
+    const unwrapped = unwrapTransparentType(type);
+    return (unwrapped.type === "TSTypeReference" &&
+        typeReferenceName(unwrapped) === name &&
+        (unwrapped.typeArguments === null || unwrapped.typeArguments.params.length === 0));
+}
+function isNeverType(type) {
+    return unwrapTransparentType(type).type === "TSNeverKeyword";
+}
+function isEffectivelyEmptyMember(member) {
+    return (member.type === "TSPropertySignature" &&
+        member.optional &&
+        member.typeAnnotation !== null &&
+        isNeverType(member.typeAnnotation.typeAnnotation));
+}
+function isEffectivelyEmptyTypeLiteral(type) {
+    return type.members.length === 0 || type.members.every(isEffectivelyEmptyMember);
+}
+function isEffectivelyEmptyInterface(declarations) {
+    if (declarations.length !== 1) {
+        return false;
+    }
+    const [type] = declarations;
+    return (type !== void 0 &&
+        type.extends.length === 0 &&
+        (type.body.body.length === 0 || type.body.body.every(isEffectivelyEmptyMember)));
+}
+function resolvedSubstitutionArgument(type, base, resolving = new Set()) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type !== "TSTypeReference") {
+        return type;
+    }
+    const name = typeReferenceName(unwrapped);
+    if (name === null || resolving.has(name)) {
+        return type;
+    }
+    const substitution = base.get(name);
+    if (substitution === void 0) {
+        return type;
+    }
+    const nextResolving = new Set(resolving);
+    nextResolving.add(name);
+    return resolvedSubstitutionArgument(substitution, base, nextResolving);
+}
+function aliasSubstitution(alias, type, base) {
+    const parameters = alias.typeParameters?.params ?? [];
+    const arguments_ = type.typeArguments?.params ?? [];
+    const next = new Map(base);
+    for (const [index, parameter] of parameters.entries()) {
+        const argument = arguments_[index] ?? parameter.default;
+        if (argument === null) {
+            return null;
+        }
+        next.set(parameter.name.name, resolvedSubstitutionArgument(argument, next));
+    }
+    return next;
+}
+function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSUnknownKeyword") {
+        return "unknown";
+    }
+    if (unwrapped.type === "TSAnyKeyword") {
+        return "any";
+    }
+    if (unwrapped.type === "TSObjectKeyword") {
+        return "object";
+    }
+    if (unwrapped.type === "TSTypeLiteral" && isEffectivelyEmptyTypeLiteral(unwrapped)) {
+        return "empty-object";
+    }
+    if (unwrapped.type === "TSUnionType") {
+        return unwrapped.types.some((member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases) !== null)
+            ? "union"
+            : null;
+    }
+    if (unwrapped.type === "TSIntersectionType") {
+        const unsafeMembers = unwrapped.types.map((member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases));
+        if (unsafeMembers.includes("any")) {
+            return "any";
+        }
+        const [firstUnsafeMember] = unsafeMembers;
+        return firstUnsafeMember !== undefined && unsafeMembers.every((member) => member !== null)
+            ? firstUnsafeMember
+            : null;
+    }
+    if (unwrapped.type !== "TSTypeReference") {
+        return null;
+    }
+    const name = typeReferenceName(unwrapped);
+    if (name === null) {
+        return null;
+    }
+    if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
+        const wrapped = unwrapped.typeArguments?.params[0];
+        return wrapped === void 0
+            ? null
+            : unsafeDirectValue(wrapped, environment, substitutions, resolvingAliases);
+    }
+    const substitution = substitutions.get(name);
+    if (substitution !== void 0) {
+        return isUnappliedReferenceTo(substitution, name)
+            ? null
+            : unsafeDirectValue(substitution, environment, substitutions, resolvingAliases);
+    }
+    const interfaceDeclarations = environment.interfaces.get(name);
+    if (interfaceDeclarations !== void 0) {
+        return isEffectivelyEmptyInterface(interfaceDeclarations) ? "empty-object" : null;
+    }
+    const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+    if (alias === null || resolvingAliases.has(name)) {
+        return null;
+    }
+    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    if (nextSubstitutions === null) {
+        return null;
+    }
+    const nextResolving = new Set(resolvingAliases);
+    nextResolving.add(name);
+    return unsafeDirectValue(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+function dictionaryValueTypes(type, environment, substitutions, resolvingAliases) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSTypeLiteral") {
+        return unwrapped.members.flatMap((member) => member.type === "TSIndexSignature"
+            ? [{ type: member.typeAnnotation.typeAnnotation, substitutions }]
+            : []);
+    }
+    if (unwrapped.type === "TSMappedType") {
+        return unwrapped.typeAnnotation === null
+            ? []
+            : [{ type: unwrapped.typeAnnotation, substitutions }];
+    }
+    if (unwrapped.type !== "TSTypeReference") {
+        return [];
+    }
+    const name = typeReferenceName(unwrapped);
+    if (name === null) {
+        return [];
+    }
+    const substitution = substitutions.get(name);
+    if (substitution !== void 0) {
+        return isUnappliedReferenceTo(substitution, name)
+            ? []
+            : dictionaryValueTypes(substitution, environment, substitutions, resolvingAliases);
+    }
+    if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
+        const wrapped = unwrapped.typeArguments?.params[0];
+        return wrapped === void 0
+            ? []
+            : dictionaryValueTypes(wrapped, environment, substitutions, resolvingAliases);
+    }
+    if (name === "Record" && isBuiltIn(name, unwrapped, environment)) {
+        const value = unwrapped.typeArguments?.params[1] ?? null;
+        return value === null ? [] : [{ type: value, substitutions }];
+    }
+    if ((name === "Pick" || name === "Omit") && isBuiltIn(name, unwrapped, environment)) {
+        const source = unwrapped.typeArguments?.params[0];
+        return source === void 0
+            ? []
+            : dictionaryValueTypes(source, environment, substitutions, resolvingAliases);
+    }
+    const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+    if (alias === null || resolvingAliases.has(name)) {
+        return [];
+    }
+    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    if (nextSubstitutions === null) {
+        return [];
+    }
+    const nextResolving = new Set(resolvingAliases);
+    nextResolving.add(name);
+    return dictionaryValueTypes(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+function classifyUnsafeDictionaryValue(valueType, environment) {
+    const unsafeValue = unsafeDirectValue(valueType, environment, new Map(), new Set());
+    return unsafeValue === null ? null : { kind: "unsafe-dictionary", unsafeValue };
+}
+function classifyUnsafeDictionary(type, environment) {
+    for (const valueType of dictionaryValueTypes(type, environment, new Map(), new Set())) {
+        const unsafeValue = unsafeDirectValue(valueType.type, environment, valueType.substitutions, new Set());
+        if (unsafeValue !== null) {
+            return { kind: "unsafe-dictionary", unsafeValue };
+        }
+    }
+    return null;
+}
+function isBroadMappedKey(type, environment, substitutions, visitedAliases = new Set()) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSStringKeyword" ||
+        unwrapped.type === "TSNumberKeyword" ||
+        unwrapped.type === "TSSymbolKeyword") {
+        return true;
+    }
+    if (unwrapped.type === "TSUnionType") {
+        return unwrapped.types.some((member) => isBroadMappedKey(member, environment, substitutions, visitedAliases));
+    }
+    if (unwrapped.type !== "TSTypeReference") {
+        return false;
+    }
+    const name = typeReferenceName(unwrapped);
+    if (name === null) {
+        return false;
+    }
+    const substitution = substitutions.get(name);
+    if (substitution !== void 0 && !isUnappliedReferenceTo(substitution, name)) {
+        return isBroadMappedKey(substitution, environment, substitutions, visitedAliases);
+    }
+    if (name === "PropertyKey" && isBuiltIn(name, unwrapped, environment)) {
+        return true;
+    }
+    const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+    if (alias === null ||
+        (alias.typeParameters?.params.length ?? 0) > 0 ||
+        visitedAliases.has(name)) {
+        return false;
+    }
+    const nextVisited = new Set(visitedAliases);
+    nextVisited.add(name);
+    return isBroadMappedKey(alias.typeAnnotation, environment, substitutions, nextVisited);
+}
+function hasBroadRecordKey(type, environment, substitutions) {
+    const key = type.typeArguments?.params[0];
+    return key === void 0 || isBroadMappedKey(key, environment, substitutions);
+}
+function classifyAliasBroadTarget(type, environment, substitutions, resolvingAliases) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSUnknownKeyword") {
+        return { kind: "unknown" };
+    }
+    if (unwrapped.type === "TSObjectKeyword") {
+        return { kind: "object" };
+    }
+    if (unwrapped.type === "TSTypeLiteral") {
+        return unwrapped.members.some((member) => member.type === "TSIndexSignature")
+            ? { kind: "open dictionary" }
+            : null;
+    }
+    if (unwrapped.type === "TSMappedType") {
+        return isBroadMappedKey(unwrapped.constraint, environment, substitutions)
+            ? { kind: "open dictionary" }
+            : null;
+    }
+    if (unwrapped.type !== "TSTypeReference") {
+        return null;
+    }
+    const name = typeReferenceName(unwrapped);
+    if (name === null) {
+        return null;
+    }
+    const substitution = substitutions.get(name);
+    if (substitution !== void 0) {
+        return isUnappliedReferenceTo(substitution, name)
+            ? null
+            : classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
+    }
+    if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
+        const wrapped = unwrapped.typeArguments?.params[0];
+        return wrapped === void 0
+            ? null
+            : classifyAliasBroadTarget(wrapped, environment, substitutions, resolvingAliases);
+    }
+    if (name === "Record" && isBuiltIn(name, unwrapped, environment)) {
+        return hasBroadRecordKey(unwrapped, environment, substitutions)
+            ? { kind: "open dictionary" }
+            : null;
+    }
+    const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+    if (alias === null || resolvingAliases.has(name)) {
+        return null;
+    }
+    const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+    if (nextSubstitutions === null) {
+        return null;
+    }
+    const nextResolving = new Set(resolvingAliases);
+    nextResolving.add(name);
+    return classifyAliasBroadTarget(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+function classifyWideningTarget(type, environment) {
+    const unwrapped = unwrapTransparentType(type);
+    if (unwrapped.type === "TSUnknownKeyword") {
+        return { kind: "unknown" };
+    }
+    if (unwrapped.type === "TSObjectKeyword") {
+        return { kind: "object" };
+    }
+    if (unwrapped.type === "TSTypeLiteral") {
+        return unwrapped.members.some((member) => member.type === "TSIndexSignature")
+            ? { kind: "open dictionary" }
+            : unwrapped.members.length > 0
+                ? { kind: "anonymous object" }
+                : null;
+    }
+    if (unwrapped.type === "TSMappedType") {
+        return { kind: "open dictionary" };
+    }
+    if (unwrapped.type !== "TSTypeReference") {
+        return null;
+    }
+    const name = typeReferenceName(unwrapped);
+    if (name === null) {
+        return null;
+    }
+    if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, unwrapped, environment)) {
+        const wrapped = unwrapped.typeArguments?.params[0];
+        return wrapped === void 0 ? null : classifyWideningTarget(wrapped, environment);
+    }
+    if (name === "Record" && isBuiltIn(name, unwrapped, environment)) {
+        return hasBroadRecordKey(unwrapped, environment, new Map())
+            ? { kind: "open dictionary" }
+            : null;
+    }
+    const alias = visibleTypeAlias(name, unwrapped, environment.typeAliases);
+    if (alias === null) {
+        return null;
+    }
+    if ((alias.typeParameters?.params.length ?? 0) > 0) {
+        const substitutions2 = aliasSubstitution(alias, unwrapped, new Map());
+        const resolved2 = substitutions2 === null
+            ? null
+            : classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions2, new Set([name]));
+        return resolved2?.kind === "open dictionary" ? { kind: "generic container" } : null;
+    }
+    const substitutions = aliasSubstitution(alias, unwrapped, new Map());
+    if (substitutions === null) {
+        return null;
+    }
+    const resolved = classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, new Set([name]));
+    return resolved;
+}
+function isPopulatedObjectExpression(expression) {
+    let current = expression;
+    while (current.type === "ParenthesizedExpression" ||
+        current.type === "TSAsExpression" ||
+        current.type === "TSTypeAssertion" ||
+        current.type === "TSNonNullExpression") {
+        current = current.expression;
+    }
+    return current.type === "ObjectExpression" && current.properties.length > 0;
+}
+function isKnownEvidenceExpression(expression) {
+    let current = expression;
+    while (current.type === "ParenthesizedExpression" ||
+        current.type === "TSAsExpression" ||
+        current.type === "TSTypeAssertion" ||
+        current.type === "TSNonNullExpression" ||
+        current.type === "TSSatisfiesExpression") {
+        current = current.expression;
+    }
+    if (current.type === "ObjectExpression") {
+        return true;
+    }
+    return (current.type === "ArrayExpression" ||
+        current.type === "ArrowFunctionExpression" ||
+        current.type === "ClassExpression" ||
+        current.type === "FunctionExpression" ||
+        current.type === "NewExpression" ||
+        current.type === "Literal" ||
+        current.type === "TemplateLiteral" ||
+        current.type === "UnaryExpression");
+}
+export { classifyUnsafeDictionary, classifyUnsafeDictionaryValue, classifyWideningTarget, createTypeEnvironment, isKnownEvidenceExpression, isPopulatedObjectExpression, };

package/dist/vendor/anti-slop/shared/function-parameters.d.ts

@@ -0,0 +1,6 @@
+import type { ESTree, SourceCode } from "@oxlint/plugins";
+type FunctionParameter = ESTree.ParamPattern | ESTree.BindingPattern;
+declare function containsUnknownType(type: ESTree.TSType): boolean;
+declare function functionParameterTypeAnnotation(parameter: FunctionParameter): ESTree.TSTypeAnnotation | null | undefined;
+declare function functionParameterBindingName(parameter: FunctionParameter, sourceCode: SourceCode): string;
+export { containsUnknownType, functionParameterBindingName, functionParameterTypeAnnotation };

package/dist/vendor/anti-slop/shared/function-parameters.js

@@ -0,0 +1,41 @@
+function containsUnknownType(type) {
+    if (type.type === "TSUnknownKeyword") {
+        return true;
+    }
+    if (type.type === "TSParenthesizedType") {
+        return containsUnknownType(type.typeAnnotation);
+    }
+    return type.type === "TSUnionType" && type.types.some(containsUnknownType);
+}
+function functionParameterTypeAnnotation(parameter) {
+    if (parameter.type === "TSParameterProperty") {
+        return functionParameterTypeAnnotation(parameter.parameter);
+    }
+    if (parameter.type === "RestElement") {
+        return parameter.typeAnnotation ?? functionParameterTypeAnnotation(parameter.argument);
+    }
+    if (parameter.type === "AssignmentPattern") {
+        return parameter.typeAnnotation ?? functionParameterTypeAnnotation(parameter.left);
+    }
+    return parameter.typeAnnotation;
+}
+function functionParameterBindingName(parameter, sourceCode) {
+    if (parameter.type === "TSParameterProperty") {
+        return functionParameterBindingName(parameter.parameter, sourceCode);
+    }
+    if (parameter.type === "AssignmentPattern") {
+        return functionParameterBindingName(parameter.left, sourceCode);
+    }
+    if (parameter.type === "RestElement") {
+        return functionParameterBindingName(parameter.argument, sourceCode);
+    }
+    if (parameter.type === "Identifier") {
+        return parameter.name;
+    }
+    const sourceText = sourceCode.getText(parameter);
+    const annotationStart = parameter.typeAnnotation?.start;
+    return annotationStart === void 0
+        ? sourceText
+        : sourceText.slice(0, annotationStart - parameter.start).trimEnd();
+}
+export { containsUnknownType, functionParameterBindingName, functionParameterTypeAnnotation };

package/dist/vendor/anti-slop/shared/lexical-type-parameters.d.ts

@@ -0,0 +1,4 @@
+import type { ESTree, SourceCode } from "@oxlint/plugins";
+type VisitorKeys = SourceCode["visitorKeys"];
+declare function lexicalTypeParameterNames(node: ESTree.Node, visitorKeys: VisitorKeys): ReadonlySet<string>;
+export { lexicalTypeParameterNames };

package/dist/vendor/anti-slop/shared/lexical-type-parameters.js

@@ -0,0 +1,32 @@
+import { childNodes } from "../../../shared/index.js";
+function collectInferTypeParameterNames(node, visitorKeys, names) {
+    if (node.type === "TSInferType") {
+        names.add(node.typeParameter.name.name);
+    }
+    for (const child of childNodes(node, visitorKeys)) {
+        collectInferTypeParameterNames(child, visitorKeys, names);
+    }
+}
+function lexicalTypeParameterNames(node, visitorKeys) {
+    const names = new Set();
+    let descendant = node;
+    let current = node;
+    while (current.type !== "Program") {
+        if ("typeParameters" in current) {
+            for (const parameter of current.typeParameters?.params ?? []) {
+                names.add(parameter.name.name);
+            }
+        }
+        if (current.type === "TSMappedType" &&
+            (descendant === current.nameType || descendant === current.typeAnnotation)) {
+            names.add(current.key.name);
+        }
+        if (current.type === "TSConditionalType" && descendant === current.trueType) {
+            collectInferTypeParameterNames(current.extendsType, visitorKeys, names);
+        }
+        descendant = current;
+        current = current.parent;
+    }
+    return names;
+}
+export { lexicalTypeParameterNames };

package/dist/vendor/anti-slop/shared/reflect-method.d.ts

@@ -0,0 +1,3 @@
+import type { ESTree, SourceCode } from "@oxlint/plugins";
+declare function isGlobalReflectMethodCall(sourceCode: SourceCode, callee: ESTree.Node, methodName: string): boolean;
+export { isGlobalReflectMethodCall };

package/dist/vendor/anti-slop/shared/reflect-method.js

@@ -0,0 +1,24 @@
+import { resolveVariable } from "./scope.js";
+function isGlobalReflect(sourceCode, expression) {
+    if (expression.type !== "Identifier" || expression.name !== "Reflect") {
+        return false;
+    }
+    if (sourceCode.isGlobalReference(expression)) {
+        return true;
+    }
+    const variable = resolveVariable(sourceCode, expression);
+    return variable === null || variable.defs.length === 0;
+}
+function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
+    if (callee.type !== "MemberExpression") {
+        return false;
+    }
+    if (!isGlobalReflect(sourceCode, callee.object)) {
+        return false;
+    }
+    const property = callee.property;
+    return callee.computed
+        ? property.type === "Literal" && property.value === methodName
+        : property.type === "Identifier" && property.name === methodName;
+}
+export { isGlobalReflectMethodCall };

package/dist/vendor/anti-slop/shared/scope.d.ts

@@ -0,0 +1,3 @@
+import type { ESTree, SourceCode, Variable } from "@oxlint/plugins";
+declare function resolveVariable(sourceCode: SourceCode, identifier: ESTree.IdentifierReference | ESTree.BindingIdentifier): Variable | null;
+export { resolveVariable };

package/dist/vendor/anti-slop/shared/scope.js

@@ -0,0 +1,12 @@
+function resolveVariable(sourceCode, identifier) {
+    let scope = sourceCode.getScope(identifier);
+    while (scope !== null) {
+        const variable = scope.set.get(identifier.name);
+        if (variable !== void 0) {
+            return variable;
+        }
+        scope = scope.upper;
+    }
+    return null;
+}
+export { resolveVariable };