@fsvreddit/bot-bouncer-evaluation 0.7.40

package/dist/userEvaluation/EvaluateBotGroupAdvancedInternal.d.ts

@@ -0,0 +1,6 @@
+import { EvaluateBotGroupAdvanced } from "./EvaluateBotGroupAdvanced";
+export declare class EvaluateBotGroupAdvancedInternal extends EvaluateBotGroupAdvanced {
+    name: string;
+    shortname: string;
+    allowNewFeatures: boolean;
+}

package/dist/userEvaluation/EvaluateBotGroupAdvancedInternal.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateBotGroupAdvancedInternal = void 0;
+const EvaluateBotGroupAdvanced_1 = require("./EvaluateBotGroupAdvanced");
+class EvaluateBotGroupAdvancedInternal extends EvaluateBotGroupAdvanced_1.EvaluateBotGroupAdvanced {
+    constructor() {
+        super(...arguments);
+        this.name = "Bot Group Advanced Internal";
+        this.shortname = "botgroupadvancedinternal";
+        this.allowNewFeatures = true;
+    }
+}
+exports.EvaluateBotGroupAdvancedInternal = EvaluateBotGroupAdvancedInternal;

package/dist/userEvaluation/EvaluateBotGroupSubmitters.d.ts

@@ -0,0 +1,8 @@
+import { EvaluateBotGroupAdvanced } from "./EvaluateBotGroupAdvanced";
+import { ValidationIssue } from "./UserEvaluatorBase";
+export declare class EvaluateBotGroupAdvancedSubmitters extends EvaluateBotGroupAdvanced {
+    name: string;
+    shortname: string;
+    allowNewFeatures: boolean;
+    validateVariables(): ValidationIssue[];
+}

package/dist/userEvaluation/EvaluateBotGroupSubmitters.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateBotGroupAdvancedSubmitters = void 0;
+const constants_1 = require("../constants");
+const EvaluateBotGroupAdvanced_1 = require("./EvaluateBotGroupAdvanced");
+class EvaluateBotGroupAdvancedSubmitters extends EvaluateBotGroupAdvanced_1.EvaluateBotGroupAdvanced {
+    constructor() {
+        super(...arguments);
+        this.name = "Bot Group Advanced (Submitters)";
+        this.shortname = constants_1.SUBMITTER_BOT_NAME;
+        this.allowNewFeatures = true;
+    }
+    validateVariables() {
+        const issues = super.validateVariables();
+        for (const group of this.getBotGroups()) {
+            if (group.submitterName === undefined) {
+                issues.push({ severity: "error", message: "submitterName is required for all bot groups in this evaluator." });
+            }
+        }
+        return issues;
+    }
+}
+exports.EvaluateBotGroupAdvancedSubmitters = EvaluateBotGroupAdvancedSubmitters;

package/dist/userEvaluation/EvaluateCommentPhrase.d.ts

@@ -0,0 +1,16 @@
+import { Post } from "@devvit/public-api";
+import { CommentCreate } from "@devvit/protos";
+import { EvaluatorRegex, UserEvaluatorBase, ValidationIssue } from "./UserEvaluatorBase.js";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+export declare class EvaluateCommentPhrase extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    validateVariables(): ValidationIssue[];
+    gatherRegexes(): EvaluatorRegex[];
+    private eligibleComment;
+    preEvaluateComment(event: CommentCreate): boolean;
+    preEvaluatePost(_: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(_: UserExtended): boolean;
+}

package/dist/userEvaluation/EvaluateCommentPhrase.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateCommentPhrase = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const date_fns_1 = require("date-fns");
+const lodash_1 = require("lodash");
+class EvaluateCommentPhrase extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Comment Phrase";
+        this.shortname = "commentphrase";
+        this.banContentThreshold = 1;
+    }
+    validateVariables() {
+        const results = [];
+        const regexes = this.getVariable("phrases", []);
+        for (const regexVal of regexes) {
+            let regex;
+            try {
+                regex = new RegExp(regexVal);
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid regex in biotext: ${regexVal}` });
+                continue;
+            }
+            if (regex.test("")) {
+                results.push({ severity: "error", message: `Bio Text regex is too greedy: ${regexVal}` });
+            }
+        }
+        return results;
+    }
+    gatherRegexes() {
+        const phrases = this.getVariable("phrases", []);
+        return (0, lodash_1.uniq)(phrases.map(phrase => ({
+            evaluatorName: this.name,
+            subName: this.shortname,
+            regex: phrase,
+        })));
+    }
+    eligibleComment(comment) {
+        const phrases = this.getVariable("phrases", []);
+        const maxCommentAgeInDays = this.getVariable("maxcommentageindays", 30);
+        if (phrases.length === 0) {
+            return false;
+        }
+        return comment.createdAt > (0, date_fns_1.subDays)(new Date(), maxCommentAgeInDays)
+            && phrases.some(phrase => new RegExp(phrase).test(comment.body));
+    }
+    preEvaluateComment(event) {
+        if (!event.comment) {
+            return false;
+        }
+        return this.eligibleComment(event.comment);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluatePost(_) {
+        return false;
+    }
+    preEvaluateUser(user) {
+        const maxAgeInDays = this.getVariable("maxageindays", 60);
+        const maxCommentKarma = this.getVariable("maxcommentkarma", 100);
+        return user.commentKarma < maxCommentKarma && user.createdAt > (0, date_fns_1.subDays)(new Date(), maxAgeInDays);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    evaluate(_) {
+        const userComments = this.getComments();
+        const matchingComments = userComments.filter(comment => this.eligibleComment(comment));
+        if (matchingComments.length === 0) {
+            return false;
+        }
+        const minNumberOfMatchingComments = this.getVariable("minnumberofmatchingcomments", 1);
+        if (matchingComments.length < minNumberOfMatchingComments) {
+            return false;
+        }
+        const matchingComment = matchingComments[0];
+        const phrases = this.getVariable("phrases", []);
+        const matchedPhrase = phrases.find(phrase => new RegExp(phrase).test(matchingComment.body));
+        if (!matchedPhrase) {
+            // Impossible to reach this point.
+            return false;
+        }
+        this.addHitReason(`Comment found matching regex: "${matchedPhrase}"`);
+        return true;
+    }
+}
+exports.EvaluateCommentPhrase = EvaluateCommentPhrase;

package/dist/userEvaluation/EvaluateDomainSharer.d.ts

@@ -0,0 +1,18 @@
+import { Post } from "@devvit/public-api";
+import { CommentCreate } from "@devvit/protos";
+import { EvaluatorRegex, UserEvaluatorBase } from "./UserEvaluatorBase.js";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+export declare class EvaluateDomainSharer extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    canAutoBan: boolean;
+    gatherRegexes(): EvaluatorRegex[];
+    private domainsFromContent;
+    private ignoredSubreddits;
+    private ignoredSubredditRegexes;
+    private domainsFromPost;
+    preEvaluateComment(event: CommentCreate): boolean;
+    preEvaluatePost(post: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(_: UserExtended): boolean;
+}

package/dist/userEvaluation/EvaluateDomainSharer.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateDomainSharer = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const lodash_1 = require("lodash");
+const date_fns_1 = require("date-fns");
+const evaluatorHelpers_js_1 = require("./evaluatorHelpers.js");
+class EvaluateDomainSharer extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Domain Sharer";
+        this.shortname = "domainsharer";
+        this.canAutoBan = false;
+    }
+    gatherRegexes() {
+        const ignoredSubredditRegexes = this.getVariable("ignoredSubredditRegexes", []);
+        return ignoredSubredditRegexes.map(regex => ({
+            evaluatorName: this.name,
+            regex,
+        }));
+    }
+    domainsFromContent(content) {
+        // eslint-disable-next-line no-useless-escape
+        const domainRegex = /(https?:\/\/[\w\.]+)[\/\)]/g;
+        const matches = content.matchAll(domainRegex);
+        const domains = [];
+        for (const match of matches) {
+            const [, url] = match;
+            domains.push((0, evaluatorHelpers_js_1.domainFromUrl)(url));
+        }
+        const redditDomains = this.getGenericVariable("redditdomains", []);
+        const ignoredDomains = this.getVariable("ignoreddomains", []);
+        const ignoredDomainSuffixes = this.getVariable("ignoredDomainSuffixes", []);
+        return (0, lodash_1.uniq)((0, lodash_1.compact)((domains)).filter((domain) => {
+            if (redditDomains.includes(domain)) {
+                return false;
+            }
+            if (ignoredDomains.includes(domain)) {
+                return false;
+            }
+            if (ignoredDomainSuffixes.some(suffix => domain.endsWith(suffix))) {
+                return false;
+            }
+            return true;
+        }));
+    }
+    ignoredSubreddits() {
+        return this.getVariable("ignoredsubreddits", []);
+    }
+    ignoredSubredditRegexes() {
+        const regexStrings = this.getVariable("ignoredSubredditRegexes", []);
+        return regexStrings.map(str => new RegExp(str));
+    }
+    domainsFromPost(post) {
+        const domains = [];
+        if (!post.url.startsWith("/")) {
+            domains.push((0, evaluatorHelpers_js_1.domainFromUrl)(post.url));
+        }
+        if (post.body) {
+            domains.push(...this.domainsFromContent(post.body));
+        }
+        const redditDomains = this.getGenericVariable("redditdomains", []);
+        const ignoredDomains = this.getVariable("ignoreddomains", []);
+        const ignoredDomainSuffixes = this.getVariable("ignoredDomainSuffixes", []);
+        return (0, lodash_1.uniq)((0, lodash_1.compact)((domains)).filter((domain) => {
+            if (redditDomains.includes(domain)) {
+                return false;
+            }
+            if (ignoredDomains.includes(domain)) {
+                return false;
+            }
+            if (ignoredDomainSuffixes.some(suffix => domain.endsWith(suffix))) {
+                return false;
+            }
+            return true;
+        }));
+    }
+    preEvaluateComment(event) {
+        if (!event.comment) {
+            return false;
+        }
+        if (event.subreddit?.name && this.ignoredSubreddits().includes(event.subreddit.name)) {
+            return false;
+        }
+        if (event.subreddit?.name && this.ignoredSubredditRegexes().some(regex => regex.test(event.subreddit?.name ?? ""))) {
+            return false;
+        }
+        return this.domainsFromContent(event.comment.body).length > 0;
+    }
+    preEvaluatePost(post) {
+        if (this.ignoredSubreddits().includes(post.subredditName)) {
+            return false;
+        }
+        if (this.ignoredSubredditRegexes().some(regex => regex.test(post.subredditName))) {
+            return false;
+        }
+        return this.domainsFromPost(post).length > 0;
+    }
+    preEvaluateUser(user) {
+        return user.commentKarma < 1000 && user.linkKarma < 1000;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    evaluate(_) {
+        const recentPosts = this.getPosts({ since: (0, date_fns_1.subMonths)(new Date(), 6) })
+            .filter(post => !this.ignoredSubreddits().includes(post.subredditName) && !this.ignoredSubredditRegexes().some(regex => regex.test(post.subredditName)));
+        const recentComments = this.getComments({ since: (0, date_fns_1.subMonths)(new Date(), 6) })
+            .filter(comment => !this.ignoredSubreddits().includes(comment.subredditName) && !this.ignoredSubredditRegexes().some(regex => regex.test(comment.subredditName)));
+        const recentContent = [...recentPosts, ...recentComments];
+        if (recentContent.length < 5) {
+            return false;
+        }
+        const domains = [];
+        for (const post of recentPosts) {
+            domains.push(...this.domainsFromPost(post));
+        }
+        for (const comment of recentComments) {
+            domains.push(...this.domainsFromContent(comment.body));
+        }
+        if (domains.length === 0) {
+            return false;
+        }
+        const domainAggregate = (0, lodash_1.toPairs)((0, lodash_1.countBy)(domains)).map(([domain, count]) => ({ domain, count }));
+        const dominantDomains = domainAggregate.filter(item => item.count === recentContent.length);
+        if (dominantDomains.length > 0) {
+            const autobanDomains = this.getVariable("autobandomains", []);
+            if (autobanDomains.some(domain => dominantDomains.some(item => item.domain === domain))) {
+                this.canAutoBan = true;
+                this.banContentThreshold = 5;
+            }
+            this.addHitReason(`User has shared ${recentContent.length} posts with the same domain: ${dominantDomains.map(item => item.domain).join(", ")}`);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+}
+exports.EvaluateDomainSharer = EvaluateDomainSharer;

package/dist/userEvaluation/EvaluateFirstCommentEmDash.d.ts

@@ -0,0 +1,17 @@
+import { Comment, Post } from "@devvit/public-api";
+import { CommentCreate } from "@devvit/protos";
+import { UserEvaluatorBase } from "./UserEvaluatorBase.js";
+import { UserExtended } from "../extendedDevvit.js";
+export declare class EvaluateFirstCommentEmDash extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    private readonly emDashRegex;
+    private isNoCheckSub;
+    private eligibleComment;
+    preEvaluateComment(event: CommentCreate): boolean;
+    private eligiblePost;
+    preEvaluatePost(post: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(_: UserExtended, history: (Post | Comment)[]): boolean;
+}

package/dist/userEvaluation/EvaluateFirstCommentEmDash.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateFirstCommentEmDash = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const tid_js_1 = require("@devvit/public-api/types/tid.js");
+const date_fns_1 = require("date-fns");
+const lodash_1 = require("lodash");
+const evaluatorHelpers_js_1 = require("./evaluatorHelpers.js");
+class EvaluateFirstCommentEmDash extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "First Comment Em Dash";
+        this.shortname = "em-dash";
+        this.banContentThreshold = 1;
+        this.emDashRegex = /\w—\w/i;
+    }
+    isNoCheckSub() {
+        const noCheckSubs = this.getVariable("nochecksubs", []);
+        return this.context.subredditName && noCheckSubs.includes(this.context.subredditName);
+    }
+    eligibleComment(comment) {
+        return (0, tid_js_1.isLinkId)(comment.parentId);
+    }
+    preEvaluateComment(event) {
+        if (!event.comment) {
+            return false;
+        }
+        if (this.isNoCheckSub()) {
+            return false;
+        }
+        return this.eligibleComment(event.comment);
+    }
+    eligiblePost(post) {
+        const domain = (0, evaluatorHelpers_js_1.domainFromUrl)(post.url);
+        const redditDomains = this.getGenericVariable("redditdomains", []);
+        return domain !== undefined && redditDomains.includes(domain);
+    }
+    preEvaluatePost(post) {
+        if (this.isNoCheckSub()) {
+            return false;
+        }
+        return this.eligiblePost(post);
+    }
+    preEvaluateUser(user) {
+        if (user.createdAt < (0, date_fns_1.subMonths)(new Date(), 2)) {
+            return false;
+        }
+        if (this.isNoCheckSub()) {
+            return false;
+        }
+        return true;
+    }
+    evaluate(_, history) {
+        const comments = this.getComments(history);
+        const posts = this.getPosts(history);
+        if (comments.length > 30) {
+            this.canAutoBan = false;
+            return false;
+        }
+        if (comments.length === 0) {
+            return false;
+        }
+        if (comments.some(comment => !this.eligibleComment(comment))) {
+            return false;
+        }
+        if (comments.some(comment => posts.some(post => post.id === comment.parentId))) {
+            return false;
+        }
+        const firstComment = (0, lodash_1.last)(comments);
+        const firstCommentContainsEmDash = firstComment ? this.emDashRegex.test(firstComment.body) : false;
+        let emDashThreshold;
+        if (comments.length > 80) {
+            emDashThreshold = 0.2;
+        }
+        else if (comments.length > 30) {
+            emDashThreshold = 0.25;
+        }
+        else {
+            emDashThreshold = 0.3;
+        }
+        const emDashThresholdMet = comments.filter(comment => this.emDashRegex.test(comment.body)).length / comments.length > emDashThreshold;
+        if (!firstCommentContainsEmDash && !emDashThresholdMet) {
+            const karmaFarmingSubs = this.getGenericVariable("karmafarminglinksubs", []);
+            const postCountNeeded = this.getVariable("postcount", 3);
+            const subsNeeded = this.getVariable("distinctsubs", 3);
+            const backupRequirementsMet = posts.length >= postCountNeeded
+                && (0, lodash_1.uniq)(posts.filter(post => karmaFarmingSubs.includes(post.subredditName)).map(post => post.subredditName)).length >= subsNeeded
+                && comments.filter(comment => comment.body.includes("—")).length > 1;
+            if (!backupRequirementsMet) {
+                return false;
+            }
+        }
+        if (posts.length > 0 && posts.some(post => !this.eligiblePost(post))) {
+            return false;
+        }
+        const noAutoBanSubs = this.getVariable("noautobansubs", []);
+        if (history.some(item => noAutoBanSubs.includes(item.subredditName))) {
+            this.canAutoBan = false;
+        }
+        return true;
+    }
+}
+exports.EvaluateFirstCommentEmDash = EvaluateFirstCommentEmDash;

package/dist/userEvaluation/EvaluateFirstPostWithSelfComment.d.ts

@@ -0,0 +1,14 @@
+import { Comment, Post } from "@devvit/public-api";
+import { CommentCreate } from "@devvit/protos";
+import { UserEvaluatorBase } from "./UserEvaluatorBase.js";
+import { UserExtended } from "../extendedDevvit.js";
+export declare class EvaluateFirstPostWithSelfComment extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    canAutoBan: boolean;
+    banContentThreshold: number;
+    preEvaluateComment(event: CommentCreate): boolean;
+    preEvaluatePost(post: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(user: UserExtended, history: (Post | Comment)[]): boolean;
+}

package/dist/userEvaluation/EvaluateFirstPostWithSelfComment.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateFirstPostWithSelfComment = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const date_fns_1 = require("date-fns");
+class EvaluateFirstPostWithSelfComment extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "First Post with Self Comment Bot";
+        this.shortname = "firstpostselfcomment";
+        this.canAutoBan = true;
+        this.banContentThreshold = 1;
+    }
+    preEvaluateComment(event) {
+        if (!event.author?.id) {
+            return false;
+        }
+        return event.author.id === event.post?.authorId;
+    }
+    preEvaluatePost(post) {
+        return post.body !== undefined && post.body.length > 0;
+    }
+    preEvaluateUser(user) {
+        const maxCommentKarma = this.getVariable("maxcommentkarma", 1);
+        const maxLinkKarma = this.getVariable("maxlinkkarma", 1);
+        return user.commentKarma < maxCommentKarma
+            && user.linkKarma < maxLinkKarma;
+    }
+    evaluate(user, history) {
+        if (history.length >= 50) {
+            return false;
+        }
+        const oldestPost = this.getPosts(history).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime()).shift();
+        if (!oldestPost) {
+            return false;
+        }
+        if (oldestPost.subredditName !== `u_${user.username}`) {
+            return false;
+        }
+        if (oldestPost.createdAt < (0, date_fns_1.subDays)(new Date(), 7)) {
+            return false;
+        }
+        if (oldestPost.numberOfComments > 1) {
+            return false;
+        }
+        const comments = this.getComments(history);
+        if (!comments.some(comment => comment.postId === oldestPost.id && comment.authorId === oldestPost.authorId)) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.EvaluateFirstPostWithSelfComment = EvaluateFirstPostWithSelfComment;

package/dist/userEvaluation/EvaluateInconsistentAgeBot.d.ts

@@ -0,0 +1,17 @@
+import { CommentCreate } from "@devvit/protos";
+import { EvaluatorRegex, UserEvaluatorBase, ValidationIssue } from "./UserEvaluatorBase.js";
+import { Post } from "@devvit/public-api";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+export declare class EvaluateInconsistentAgeBot extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    canAutoBan: boolean;
+    gatherRegexes(): EvaluatorRegex[];
+    validateVariables(): ValidationIssue[];
+    preEvaluateComment(_event: CommentCreate): boolean;
+    private getAgeFromPostTitle;
+    preEvaluatePost(post: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(user: UserExtended): boolean;
+}

package/dist/userEvaluation/EvaluateInconsistentAgeBot.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateInconsistentAgeBot = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const lodash_1 = require("lodash");
+const date_fns_1 = require("date-fns");
+const regjsparser_1 = require("regjsparser");
+class EvaluateInconsistentAgeBot extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Inconsistent Age Bot";
+        this.shortname = "inconsistentage";
+        this.banContentThreshold = 6;
+        this.canAutoBan = true;
+    }
+    gatherRegexes() {
+        const regexes = this.getVariable("ageregexes", []);
+        return regexes.map(regex => ({
+            evaluatorName: this.name,
+            regex,
+        }));
+    }
+    validateVariables() {
+        const regexes = this.gatherRegexes().map(r => r.regex);
+        const results = [];
+        for (const regexVal of regexes) {
+            try {
+                new RegExp(regexVal);
+                const parsed = (0, regjsparser_1.parse)(regexVal, "i");
+                if (parsed.type !== "alternative") {
+                    results.push({ severity: "error", message: `No capturing group found in regex: ${regexVal}` });
+                    continue;
+                }
+                const capturingGroups = parsed.body.filter(part => part.type === "group" && part.behavior === "normal");
+                if (capturingGroups.length !== 1) {
+                    results.push({ severity: "error", message: `Expected exactly one capturing group in regex: ${regexVal}` });
+                    continue;
+                }
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid regex: ${regexVal}` });
+            }
+        }
+        return results;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_event) {
+        return false;
+    }
+    getAgeFromPostTitle(title, regexes) {
+        for (const regex of regexes) {
+            const match = title.match(regex);
+            if (match) {
+                return parseInt(match[1]);
+            }
+        }
+    }
+    preEvaluatePost(post) {
+        if (!post.isNsfw()) {
+            return false;
+        }
+        if (post.crosspostParentId) {
+            return false;
+        }
+        const regexes = this.gatherRegexes().map(r => new RegExp(r.regex, r.flags));
+        return this.getAgeFromPostTitle(post.title, regexes) !== undefined;
+    }
+    preEvaluateUser(user) {
+        return user.commentKarma < 50;
+    }
+    evaluate(user) {
+        const nsfwPosts = this.getPosts({ since: (0, date_fns_1.subWeeks)(new Date(), 2) })
+            .filter(post => post.isNsfw() && !post.subredditName.toLowerCase().includes("roleplay") && !post.crosspostParentId);
+        const contentThreshold = this.getVariable("contentthreshold", 6);
+        this.banContentThreshold = contentThreshold;
+        if (nsfwPosts.length < 4) {
+            return false;
+        }
+        const regexes = this.gatherRegexes().map(r => new RegExp(r.regex, r.flags));
+        const agesFound = (0, lodash_1.uniq)((0, lodash_1.compact)(nsfwPosts.map(post => this.getAgeFromPostTitle(post.title, regexes))));
+        if (agesFound.length < 3) {
+            return false;
+        }
+        if (user.userDescription?.includes("shared") || user.userDescription?.includes("couple") || nsfwPosts.some(post => post.title.toLowerCase().includes("couple"))) {
+            this.canAutoBan = false;
+        }
+        this.addHitReason(`Inconsistent Age Bot: Found ${agesFound.length} different ages in ${nsfwPosts.length} posts`);
+        return true;
+    }
+}
+exports.EvaluateInconsistentAgeBot = EvaluateInconsistentAgeBot;

package/dist/userEvaluation/EvaluateInconsistentGenderBot.d.ts

@@ -0,0 +1,17 @@
+import { CommentCreate } from "@devvit/protos";
+import { EvaluatorRegex, UserEvaluatorBase, ValidationIssue } from "./UserEvaluatorBase.js";
+import { Post } from "@devvit/public-api";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+export declare class EvaluateInconsistentGenderBot extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    canAutoBan: boolean;
+    preEvaluateComment(_event: CommentCreate): boolean;
+    getGenderFromTitle(title: string): string | undefined;
+    gatherRegexes(): EvaluatorRegex[];
+    validateVariables(): ValidationIssue[];
+    preEvaluatePost(post: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(user: UserExtended): boolean;
+}