@jameswyse/oxc-config 0.1.0

package/dist/vendor/anti-slop/rules/no-conditional-empty-object-spread.js

@@ -0,0 +1,41 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+function unwrapParentheses(node) {
+    let current = node;
+    while (current.type === "ParenthesizedExpression") {
+        current = current.expression;
+    }
+    return current;
+}
+function isEmptyObjectExpression(node) {
+    return node.type === "ObjectExpression" && node.properties.length === 0;
+}
+function isConditionalEmptyObjectSpread(node) {
+    const conditional = unwrapParentheses(node);
+    return (conditional.type === "ConditionalExpression" &&
+        (isEmptyObjectExpression(conditional.consequent) ||
+            isEmptyObjectExpression(conditional.alternate)));
+}
+export const noConditionalEmptyObjectSpread = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Disallow object spreads that conditionally spread an empty object to omit fields.",
+        },
+        messages: {
+            avoid: "This conditional spread hides property omission behind an empty object. Build the object in separate statements and add the property only when present.",
+        },
+    },
+    createOnce(context) {
+        return {
+            SpreadElement(node) {
+                if (node.parent.type !== "ObjectExpression") {
+                    return;
+                }
+                if (isConditionalEmptyObjectSpread(node.argument)) {
+                    context.report({ node, messageId: "avoid" });
+                }
+            },
+        };
+    },
+});

package/dist/vendor/anti-slop/rules/no-known-value-widening.d.ts

@@ -0,0 +1 @@
+export declare const noKnownValueWidening: import("@oxlint/plugins").Rule;

package/dist/vendor/anti-slop/rules/no-known-value-widening.js

@@ -0,0 +1,333 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+import { classifyUnsafeDictionaryValue, classifyWideningTarget, createTypeEnvironment, isKnownEvidenceExpression, } from "../shared/dictionary-types.js";
+import { containsUnknownType, functionParameterBindingName, functionParameterTypeAnnotation, } from "../shared/function-parameters.js";
+import { resolveVariable } from "../shared/scope.js";
+function unwrapExpression(expression) {
+    let current = expression;
+    while (current.type === "ParenthesizedExpression" ||
+        current.type === "TSAsExpression" ||
+        current.type === "TSSatisfiesExpression" ||
+        current.type === "TSTypeAssertion" ||
+        current.type === "TSNonNullExpression") {
+        current = current.expression;
+    }
+    return current;
+}
+function variableDeclarator(variable) {
+    if (variable.defs.length !== 1) {
+        return null;
+    }
+    const [definition] = variable.defs;
+    return definition?.type === "Variable" && definition.node.type === "VariableDeclarator"
+        ? definition.node
+        : null;
+}
+function isStableConstVariable(variable, declarator) {
+    return (declarator.parent.type === "VariableDeclaration" &&
+        declarator.parent.kind === "const" &&
+        variable.references.every((reference) => reference.init || !reference.isWrite()));
+}
+function hasKnownEvidence(sourceCode, expression, visitedVariables = new Set()) {
+    if (isKnownEvidenceExpression(expression)) {
+        return true;
+    }
+    const unwrapped = unwrapExpression(expression);
+    if (unwrapped.type !== "Identifier") {
+        return false;
+    }
+    const variable = resolveVariable(sourceCode, unwrapped);
+    if (variable === null || visitedVariables.has(variable)) {
+        return false;
+    }
+    const declarator = variableDeclarator(variable);
+    if (declarator === null ||
+        declarator.init === null ||
+        !isStableConstVariable(variable, declarator)) {
+        return false;
+    }
+    visitedVariables.add(variable);
+    return hasKnownEvidence(sourceCode, declarator.init, visitedVariables);
+}
+function isFunctionExpression(node) {
+    return (node.type === "ArrowFunctionExpression" ||
+        node.type === "FunctionDeclaration" ||
+        node.type === "FunctionExpression" ||
+        node.type === "TSDeclareFunction" ||
+        node.type === "TSEmptyBodyFunctionExpression");
+}
+function localFunctionForCall(sourceCode, callee) {
+    const unwrapped = unwrapExpression(callee);
+    if (isFunctionExpression(unwrapped)) {
+        return unwrapped;
+    }
+    if (unwrapped.type !== "Identifier") {
+        return null;
+    }
+    const variable = resolveVariable(sourceCode, unwrapped);
+    if (variable === null || variable.defs.length !== 1) {
+        return null;
+    }
+    const [definition] = variable.defs;
+    if (definition === void 0) {
+        return null;
+    }
+    if (definition.type === "FunctionName" && isFunctionExpression(definition.node)) {
+        return definition.node;
+    }
+    if (definition.type !== "Variable" || definition.node.type !== "VariableDeclarator") {
+        return null;
+    }
+    const initializer = definition.node.init;
+    if (initializer === null) {
+        return null;
+    }
+    const unwrappedInitializer = unwrapExpression(initializer);
+    return isFunctionExpression(unwrappedInitializer) ? unwrappedInitializer : null;
+}
+function variableTypeAnnotation(sourceCode, variable) {
+    if (variable.defs.length !== 1) {
+        return null;
+    }
+    const [definition] = variable.defs;
+    if (definition === void 0) {
+        return null;
+    }
+    if (definition.type === "Variable" &&
+        definition.node.type === "VariableDeclarator" &&
+        definition.node.id.type === "Identifier") {
+        return definition.node.id.typeAnnotation ?? null;
+    }
+    if (definition.type !== "Parameter" || !isFunctionExpression(definition.node)) {
+        return null;
+    }
+    const parameter = definition.node.params.find((candidate) => functionParameterBindingName(candidate, sourceCode) === variable.name);
+    return parameter === void 0 ? null : (functionParameterTypeAnnotation(parameter) ?? null);
+}
+function hasInformativeType(type, environment) {
+    return classifyUnsafeDictionaryValue(type, environment) === null;
+}
+function hasKnownCallArgumentEvidence(sourceCode, expression, environment, visitedVariables = new Set()) {
+    if (expression.type === "ParenthesizedExpression" || expression.type === "TSNonNullExpression") {
+        return hasKnownCallArgumentEvidence(sourceCode, expression.expression, environment, visitedVariables);
+    }
+    if (expression.type === "TSAsExpression" || expression.type === "TSTypeAssertion") {
+        return hasInformativeType(expression.typeAnnotation, environment);
+    }
+    if (expression.type === "TSSatisfiesExpression") {
+        return hasKnownCallArgumentEvidence(sourceCode, expression.expression, environment, visitedVariables);
+    }
+    if (expression.type === "CallExpression") {
+        const owner = localFunctionForCall(sourceCode, expression.callee);
+        const returnType = owner?.returnType?.typeAnnotation;
+        return returnType !== void 0 && hasInformativeType(returnType, environment);
+    }
+    if (expression.type !== "Identifier") {
+        return isKnownEvidenceExpression(expression);
+    }
+    const variable = resolveVariable(sourceCode, expression);
+    if (variable === null || visitedVariables.has(variable)) {
+        return false;
+    }
+    const annotation = variableTypeAnnotation(sourceCode, variable);
+    if (annotation !== null) {
+        return hasInformativeType(annotation.typeAnnotation, environment);
+    }
+    const declarator = variableDeclarator(variable);
+    if (declarator === null ||
+        declarator.init === null ||
+        !isStableConstVariable(variable, declarator)) {
+        return false;
+    }
+    visitedVariables.add(variable);
+    return hasKnownCallArgumentEvidence(sourceCode, declarator.init, environment, visitedVariables);
+}
+function typePredicateSubjectIndex(sourceCode, owner) {
+    const predicate = owner.returnType?.typeAnnotation;
+    if (predicate?.type !== "TSTypePredicate" || predicate.parameterName.type !== "Identifier") {
+        return null;
+    }
+    const predicateParameterName = predicate.parameterName.name;
+    const index = owner.params.findIndex((parameter) => functionParameterBindingName(parameter, sourceCode) === predicateParameterName);
+    return index === -1 ? null : index;
+}
+function annotationTarget(annotation, environment) {
+    return annotation === null || annotation === void 0
+        ? null
+        : classifyWideningTarget(annotation.typeAnnotation, environment);
+}
+function enclosingFunction(node) {
+    let current = node.parent;
+    while (current !== null && current.type !== "Program") {
+        if (current.type === "ArrowFunctionExpression" ||
+            current.type === "FunctionDeclaration" ||
+            current.type === "FunctionExpression") {
+            return current;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function sourceKeyName(sourceCode, key) {
+    if (key.type === "Identifier" || key.type === "PrivateIdentifier") {
+        return key.name;
+    }
+    if (key.type === "Literal") {
+        return String(key.value);
+    }
+    return sourceCode.getText(key);
+}
+function functionName(sourceCode, owner) {
+    if (owner === null) {
+        return "anonymous function";
+    }
+    if (owner.id !== null) {
+        return owner.id.name;
+    }
+    const parent = owner.parent;
+    if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+        return parent.id.name;
+    }
+    if (parent.type === "MethodDefinition") {
+        return sourceKeyName(sourceCode, parent.key);
+    }
+    return "anonymous function";
+}
+function isEmptyObjectExpression(expression) {
+    const unwrapped = unwrapExpression(expression);
+    return unwrapped.type === "ObjectExpression" && unwrapped.properties.length === 0;
+}
+function isDictionaryAccumulatorTarget(destination) {
+    return destination.kind === "open dictionary" || destination.kind === "generic container";
+}
+function hasParentAssertion(node) {
+    return node.parent.type === "TSAsExpression" || node.parent.type === "TSTypeAssertion";
+}
+export const noKnownValueWidening = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow syntactically established values from flowing into explicitly broad or anonymous target types that discard useful evidence.",
+        },
+        messages: {
+            widening: "The explicit {{target}} type on {{subject}} discards known type evidence. Keep inference, validate with `satisfies`, or use a named owner contract.",
+        },
+    },
+    createOnce(context) {
+        let environment = null;
+        const reportFlow = (expression, destination, subject) => {
+            if (destination === null) {
+                return;
+            }
+            if (isDictionaryAccumulatorTarget(destination) && isEmptyObjectExpression(expression)) {
+                return;
+            }
+            if (!hasKnownEvidence(context.sourceCode, expression)) {
+                return;
+            }
+            context.report({
+                node: expression,
+                messageId: "widening",
+                data: { subject, target: destination.kind },
+            });
+        };
+        const targetFromAnnotation = (annotation) => environment === null ? null : annotationTarget(annotation, environment);
+        return {
+            Program(node) {
+                environment = createTypeEnvironment(node, context.sourceCode.visitorKeys);
+            },
+            VariableDeclarator(node) {
+                if (node.init === null || node.id.type !== "Identifier") {
+                    return;
+                }
+                reportFlow(node.init, targetFromAnnotation(node.id.typeAnnotation), `binding \`${node.id.name}\``);
+            },
+            PropertyDefinition(node) {
+                if (node.value === null) {
+                    return;
+                }
+                reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+            },
+            AccessorProperty(node) {
+                if (node.value === null) {
+                    return;
+                }
+                reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+            },
+            AssignmentExpression(node) {
+                if (node.operator !== "=" || node.left.type !== "Identifier") {
+                    return;
+                }
+                const variable = resolveVariable(context.sourceCode, node.left);
+                if (variable === null) {
+                    return;
+                }
+                const declarator = variableDeclarator(variable);
+                if (declarator === null || declarator.id.type !== "Identifier") {
+                    return;
+                }
+                reportFlow(node.right, targetFromAnnotation(declarator.id.typeAnnotation), `binding \`${declarator.id.name}\``);
+            },
+            CallExpression(node) {
+                if (environment === null) {
+                    return;
+                }
+                const owner = localFunctionForCall(context.sourceCode, node.callee);
+                if (owner === null) {
+                    return;
+                }
+                const parameterIndex = typePredicateSubjectIndex(context.sourceCode, owner);
+                if (parameterIndex === null) {
+                    return;
+                }
+                const parameter = owner.params[parameterIndex];
+                const argument = node.arguments[parameterIndex];
+                if (parameter === void 0 || argument === void 0 || argument.type === "SpreadElement") {
+                    return;
+                }
+                const parameterAnnotation = functionParameterTypeAnnotation(parameter);
+                if (parameterAnnotation === null ||
+                    parameterAnnotation === void 0 ||
+                    !containsUnknownType(parameterAnnotation.typeAnnotation)) {
+                    return;
+                }
+                if (!hasKnownCallArgumentEvidence(context.sourceCode, argument, environment)) {
+                    return;
+                }
+                context.report({
+                    node: argument,
+                    messageId: "widening",
+                    data: {
+                        subject: `argument for parameter \`${functionParameterBindingName(parameter, context.sourceCode)}\` of \`${functionName(context.sourceCode, owner)}\``,
+                        target: "unknown",
+                    },
+                });
+            },
+            ReturnStatement(node) {
+                if (node.argument === null) {
+                    return;
+                }
+                const owner = enclosingFunction(node);
+                reportFlow(node.argument, targetFromAnnotation(owner?.returnType), `return value of \`${functionName(context.sourceCode, owner)}\``);
+            },
+            ArrowFunctionExpression(node) {
+                if (node.body.type === "BlockStatement") {
+                    return;
+                }
+                reportFlow(node.body, targetFromAnnotation(node.returnType), `return value of \`${functionName(context.sourceCode, node)}\``);
+            },
+            TSAsExpression(node) {
+                if (environment === null || hasParentAssertion(node)) {
+                    return;
+                }
+                reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion");
+            },
+            TSTypeAssertion(node) {
+                if (environment === null || hasParentAssertion(node)) {
+                    return;
+                }
+                reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion");
+            },
+        };
+    },
+});

package/dist/vendor/anti-slop/rules/no-module-mocking.d.ts

@@ -0,0 +1 @@
+export declare const noModuleMocking: import("@oxlint/plugins").Rule;

package/dist/vendor/anti-slop/rules/no-module-mocking.js

@@ -0,0 +1,74 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+import { resolveVariable } from "../shared/scope.js";
+const moduleMockMethods = new Set(["doMock", "mock", "unstable_mockModule"]);
+function importedName(node) {
+    if (node.type !== "ImportSpecifier") {
+        return null;
+    }
+    return node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
+}
+function isTestFrameworkObject(sourceCode, expression) {
+    if (expression.type !== "Identifier") {
+        return false;
+    }
+    if ((expression.name === "vi" || expression.name === "jest") &&
+        sourceCode.isGlobalReference(expression)) {
+        return true;
+    }
+    const variable = resolveVariable(sourceCode, expression);
+    if (variable === null || variable.defs.length === 0) {
+        return expression.name === "vi" || expression.name === "jest";
+    }
+    return variable.defs.some((definition) => {
+        if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") {
+            return false;
+        }
+        const source = definition.parent.source.value;
+        const name = importedName(definition.node);
+        return ((source === "vitest" && name === "vi") || (source === "@jest/globals" && name === "jest"));
+    });
+}
+function moduleMockCall(sourceCode, callee) {
+    if (!("property" in callee) || !("object" in callee) || !("computed" in callee)) {
+        return false;
+    }
+    if (!isTestFrameworkObject(sourceCode, callee.object)) {
+        return false;
+    }
+    const property = callee.property;
+    const method = callee.computed
+        ? property.type === "Literal" &&
+            (property.value === "doMock" ||
+                property.value === "mock" ||
+                property.value === "unstable_mockModule")
+            ? property.value
+            : null
+        : property.type === "Identifier"
+            ? property.name
+            : null;
+    return method !== null && moduleMockMethods.has(method);
+}
+export const noModuleMocking = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow Vitest and Jest module mocking; tests must replace dependencies through real interfaces.",
+        },
+        messages: {
+            moduleMock: "Replace module mocking with dependency injection through a real interface, service layer, or faithful test implementation.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") {
+                    return;
+                }
+                if (moduleMockCall(context.sourceCode, node.callee)) {
+                    context.report({ node, messageId: "moduleMock" });
+                }
+            },
+        };
+    },
+});

package/dist/vendor/anti-slop/rules/no-object-parameters.d.ts

@@ -0,0 +1 @@
+export declare const noObjectParameters: import("@oxlint/plugins").Rule;

package/dist/vendor/anti-slop/rules/no-object-parameters.js

@@ -0,0 +1,59 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+import { functionParameterBindingName, functionParameterTypeAnnotation, } from "../shared/function-parameters.js";
+import { createTypeAliasEnvironment, resolvedTypeMatches, } from "../shared/type-alias-resolution.js";
+export const noObjectParameters = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow object function parameters; inputs must use an owner-provided type and be parsed at their boundary.",
+        },
+        messages: {
+            objectParameter: "Parameter `{{parameter}}` uses the broad `object` type. Accept a named owner type; parse external input at its boundary before calling this function.",
+        },
+    },
+    createOnce(context) {
+        let environment = null;
+        const resolvesToObject = (type) => environment !== null &&
+            resolvedTypeMatches(type, environment, (resolved, matches) => {
+                if (resolved.type === "TSObjectKeyword") {
+                    return true;
+                }
+                if (resolved.type === "TSParenthesizedType") {
+                    return matches(resolved.typeAnnotation);
+                }
+                return resolved.type === "TSUnionType" && resolved.types.some(matches);
+            });
+        const checkParameters = (node) => {
+            for (const parameter of node.params) {
+                const annotation = functionParameterTypeAnnotation(parameter);
+                if (annotation === null || annotation === void 0) {
+                    continue;
+                }
+                if (!resolvesToObject(annotation.typeAnnotation)) {
+                    continue;
+                }
+                context.report({
+                    node: annotation.typeAnnotation,
+                    messageId: "objectParameter",
+                    data: { parameter: functionParameterBindingName(parameter, context.sourceCode) },
+                });
+            }
+        };
+        return {
+            Program(node) {
+                environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys);
+            },
+            ArrowFunctionExpression: checkParameters,
+            FunctionDeclaration: checkParameters,
+            FunctionExpression: checkParameters,
+            TSCallSignatureDeclaration: checkParameters,
+            TSConstructSignatureDeclaration: checkParameters,
+            TSConstructorType: checkParameters,
+            TSDeclareFunction: checkParameters,
+            TSEmptyBodyFunctionExpression: checkParameters,
+            TSFunctionType: checkParameters,
+            TSMethodSignature: checkParameters,
+        };
+    },
+});

package/dist/vendor/anti-slop/rules/no-reduce-accumulator-copy.d.ts

@@ -0,0 +1 @@
+export declare const noReduceAccumulatorCopy: import("@oxlint/plugins").Rule;

package/dist/vendor/anti-slop/rules/no-reduce-accumulator-copy.js

@@ -0,0 +1,124 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+import { arrayMethodTarget, isKnownArrayExpression, resolveArrayBinding, unwrapArrayExpression, } from "../shared/array-method.js";
+function enclosingReducer(node) {
+    let parent = node.parent;
+    while (parent !== null) {
+        if (parent.type === "FunctionDeclaration") {
+            return null;
+        }
+        if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") {
+            const callback = parent;
+            let owner = callback.parent;
+            while (owner !== null && unwrapArrayExpression(owner) === callback) {
+                owner = owner.parent;
+            }
+            if (owner?.type !== "CallExpression") {
+                return null;
+            }
+            const method = arrayMethodTarget(owner.callee);
+            const firstArgument = owner.arguments[0];
+            if (method === null ||
+                (method.name !== "reduce" && method.name !== "reduceRight") ||
+                owner.arguments.length > 2 ||
+                firstArgument === void 0 ||
+                unwrapArrayExpression(firstArgument) !== callback) {
+                return null;
+            }
+            const firstParameter = callback.params[0];
+            const accumulator = firstParameter?.type === "AssignmentPattern" ? firstParameter.left : firstParameter;
+            if (accumulator?.type !== "Identifier") {
+                return null;
+            }
+            return { callback, accumulator, initialValue: owner.arguments[1] };
+        }
+        parent = parent.parent;
+    }
+    return null;
+}
+function referencesAccumulator(sourceCode, node, accumulator, visited = new Set()) {
+    const variable = resolveArrayBinding(sourceCode, node);
+    if (variable === null || visited.has(variable)) {
+        return false;
+    }
+    if (variable === accumulator) {
+        return true;
+    }
+    visited.add(variable);
+    if (variable.references.some((reference) => reference.isWrite() && !reference.init)) {
+        return false;
+    }
+    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 referencesAccumulator(sourceCode, definition.node.init, accumulator, visited);
+        }
+    }
+    return false;
+}
+function isGlobalCopyOwner(sourceCode, expression, name) {
+    const node = unwrapArrayExpression(expression);
+    if (node.type !== "Identifier" || node.name !== name) {
+        return false;
+    }
+    const variable = resolveArrayBinding(sourceCode, node);
+    return variable === null || variable.defs.length === 0;
+}
+export const noReduceAccumulatorCopy = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow copying growing reducer accumulators with Object.assign, Array.from, or array copy methods.",
+        },
+        messages: {
+            accumulatorCopy: "Do not copy the reducer accumulator on every iteration; growing copies can cause quadratic work. Mutate a fresh, locally owned accumulator and return it, or use an iterator pipeline/flatMap.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                const method = arrayMethodTarget(node.callee);
+                if (method === null) {
+                    return;
+                }
+                const reducer = enclosingReducer(node);
+                if (reducer === null) {
+                    return;
+                }
+                const accumulator = context.sourceCode
+                    .getDeclaredVariables(reducer.callback)
+                    .find((variable) => variable.identifiers.some((identifier) => identifier.start === reducer.accumulator.start));
+                if (accumulator === void 0) {
+                    return;
+                }
+                const isAccumulator = (expression) => referencesAccumulator(context.sourceCode, expression, accumulator);
+                let copiesAccumulator = false;
+                if (method.name === "assign" &&
+                    isGlobalCopyOwner(context.sourceCode, method.object, "Object")) {
+                    const target = node.arguments[0];
+                    copiesAccumulator =
+                        target !== void 0 &&
+                            unwrapArrayExpression(target).type === "ObjectExpression" &&
+                            node.arguments.slice(1).some(isAccumulator);
+                }
+                else if (method.name === "from" &&
+                    isGlobalCopyOwner(context.sourceCode, method.object, "Array")) {
+                    const source = node.arguments[0];
+                    copiesAccumulator = source !== void 0 && isAccumulator(source);
+                }
+                else if (["concat", "slice", "toSpliced", "toSorted", "toReversed", "with"].includes(method.name)) {
+                    const initialValue = reducer.initialValue;
+                    const arrayAccumulator = initialValue !== void 0 && isKnownArrayExpression(context.sourceCode, initialValue);
+                    copiesAccumulator = arrayAccumulator && isAccumulator(method.object);
+                }
+                if (copiesAccumulator) {
+                    context.report({ node, messageId: "accumulatorCopy" });
+                }
+            },
+        };
+    },
+});

package/dist/vendor/anti-slop/rules/no-reflect-apply.d.ts

@@ -0,0 +1 @@
+export declare const noReflectApply: import("@oxlint/plugins").Rule;

package/dist/vendor/anti-slop/rules/no-reflect-apply.js

@@ -0,0 +1,26 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+import { isGlobalReflectMethodCall } from "../shared/reflect-method.js";
+export const noReflectApply = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow Reflect.apply; call typed functions directly or model dynamic dispatch behind an interface.",
+        },
+        messages: {
+            reflectApply: "Replace `Reflect.apply` with a typed function call. Model dynamic dispatch behind a named interface.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") {
+                    return;
+                }
+                if (isGlobalReflectMethodCall(context.sourceCode, node.callee, "apply")) {
+                    context.report({ node, messageId: "reflectApply" });
+                }
+            },
+        };
+    },
+});

package/dist/vendor/anti-slop/rules/no-reflect-get.d.ts

@@ -0,0 +1 @@
+export declare const noReflectGet: import("@oxlint/plugins").Rule;