@fsvreddit/bot-bouncer-evaluation 0.7.40

package/dist/userEvaluation/EvaluateInconsistentGenderBot.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateInconsistentGenderBot = 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 EvaluateInconsistentGenderBot extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Inconsistent Gender Bot";
+        this.shortname = "inconsistentgender";
+        this.banContentThreshold = 6;
+        this.canAutoBan = true;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_event) {
+        return false;
+    }
+    getGenderFromTitle(title) {
+        const genderRegexes = this.gatherRegexes().map(r => new RegExp(r.regex, r.flags));
+        for (const regex of genderRegexes) {
+            const match = regex.exec(title);
+            if (match?.[1]) {
+                return match[1].toUpperCase();
+            }
+        }
+        return;
+    }
+    gatherRegexes() {
+        const regexes = this.getVariable("genderregexes", []);
+        return regexes.map(regex => ({
+            evaluatorName: this.name,
+            regex,
+            flags: "i",
+        }));
+    }
+    validateVariables() {
+        const regexes = this.gatherRegexes();
+        const results = [];
+        for (const regexObj of regexes) {
+            try {
+                new RegExp(regexObj.regex, regexObj.flags);
+                const parsed = (0, regjsparser_1.parse)(regexObj.regex, "i");
+                if (parsed.type !== "alternative") {
+                    results.push({ severity: "error", message: `No capturing group found in regex: ${regexObj.regex}` });
+                    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: ${regexObj.regex}` });
+                    continue;
+                }
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid regex: ${regexObj.regex}` });
+            }
+        }
+        return results;
+    }
+    preEvaluatePost(post) {
+        return this.getGenderFromTitle(post.title) !== undefined && post.isNsfw() && !post.crosspostParentId;
+    }
+    preEvaluateUser(user) {
+        return user.commentKarma < 100;
+    }
+    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);
+        if (nsfwPosts.length < 4) {
+            return false;
+        }
+        const genderGroups = (0, lodash_1.countBy)((0, lodash_1.compact)(nsfwPosts.map(post => this.getGenderFromTitle(post.title))));
+        const gendersFound = Object.entries(genderGroups)
+            .map(([gender, count]) => ({ gender, count }))
+            .filter(item => item.count > 1)
+            .map(item => item.gender);
+        if (gendersFound.some(gender => gender.length !== 1)) {
+            console.log(`Found invalid genders on post title: ${gendersFound.join(", ")}`);
+            return false;
+        }
+        if (gendersFound.length < 2) {
+            return false;
+        }
+        if (nsfwPosts.some(post => post.subredditName === "bodyswap" || post.subredditName.toLowerCase().includes("roleplay") || post.subredditName.toLowerCase().includes("penpals"))) {
+            return false;
+        }
+        if (user.userDescription?.includes("shared") || user.userDescription?.includes("couple") || nsfwPosts.some(post => post.title.toLowerCase().includes("couple"))) {
+            this.canAutoBan = false;
+        }
+        const sharedRegex = /([0-9]{2}M|M[0-9]{2}) and ([0-9]{2}F|F[0-9]{2})/;
+        if (nsfwPosts.some(post => sharedRegex.test(post.title))) {
+            this.canAutoBan = false;
+        }
+        this.addHitReason(`Inconsistent Gender Bot: Found ${gendersFound.length} different genders in ${nsfwPosts.length} posts`);
+        return true;
+    }
+}
+exports.EvaluateInconsistentGenderBot = EvaluateInconsistentGenderBot;

package/dist/userEvaluation/EvaluateLinkReuse.d.ts

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

package/dist/userEvaluation/EvaluateLinkReuse.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateLinkReuse = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const constants_js_1 = require("../constants.js");
+const date_fns_1 = require("date-fns");
+const index_js_1 = require("../index.js");
+class EvaluateLinkReuse extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Link Reuse Bot";
+        this.shortname = "linkreuse";
+        this.banContentThreshold = 1;
+    }
+    getLinkRegexes() {
+        return this.getVariable("linkRegexes", []);
+    }
+    validateVariables() {
+        const results = [];
+        const linkRegexes = this.getLinkRegexes();
+        if (linkRegexes.length === 0) {
+            results.push({ severity: "error", message: "No link regexes defined" });
+        }
+        for (const regex of linkRegexes) {
+            try {
+                const regexp = new RegExp(regex);
+                if (regexp.test("")) {
+                    results.push({ severity: "error", message: `Link regex in linkreuse matches empty string: ${regex}` });
+                }
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid link regex in linkreuse: ${regex}` });
+            }
+        }
+        const socialLinkRegexes = this.getVariable("socialLinkRegexes", []);
+        if (socialLinkRegexes.length === 0) {
+            results.push({ severity: "error", message: "No social link regexes defined" });
+        }
+        for (const regex of socialLinkRegexes) {
+            try {
+                const regexp = new RegExp(regex);
+                if (regexp.test("")) {
+                    results.push({ severity: "error", message: `Social link regex in linkreuse matches empty string: ${regex}` });
+                }
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid social link regex in linkreuse: ${regex}` });
+            }
+        }
+        return results;
+    }
+    preEvaluatePost(post) {
+        const linkRegexes = this.getLinkRegexes();
+        return linkRegexes.some(regex => new RegExp(regex).test(post.url))
+            && !post.crosspostParentId;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await
+    async preEvaluateComment(_event) {
+        return false;
+    }
+    preEvaluateUser(user) {
+        return user.nsfw;
+    }
+    async getDistinctUsersForLink(link) {
+        const redis = this.context.appSlug === constants_js_1.MAIN_APP_NAME ? this.context.redis.global : this.context.redis;
+        const cacheKey = `bbe:linkreuse:distinctUsers:${link}`;
+        const cachedResults = await redis.get(cacheKey);
+        if (cachedResults !== undefined) {
+            return JSON.parse(cachedResults);
+        }
+        const results = await this.context.reddit.searchPosts({
+            query: `url:"${link}"`,
+            sort: "new",
+            limit: 100,
+        }).all();
+        const distinctUsers = Array.from(new Set(results.filter(post => post.url === link && post.authorName !== "[deleted]").map(post => post.authorName)));
+        await redis.set(cacheKey, JSON.stringify(distinctUsers), { expiration: (0, date_fns_1.addHours)(new Date(), 1) });
+        return distinctUsers;
+    }
+    async isEligibleUserForEvaluator(username, isSubject = false) {
+        let socialLinks;
+        if (isSubject) {
+            socialLinks = await this.getSocialLinks(username);
+        }
+        else {
+            socialLinks = await (0, index_js_1.getSocialLinksWithCache)(username, this.context);
+        }
+        if (socialLinks.length === 0) {
+            return false;
+        }
+        const socialLinkRegexes = this.getVariable("socialLinkRegexes", []);
+        return socialLinks.some(link => socialLinkRegexes.some(regex => new RegExp(regex).test(link.outboundUrl)));
+    }
+    async evaluate(user) {
+        const linkRegexes = this.getLinkRegexes();
+        const requiredLinks = this.getVariable("requiredLinks", 3);
+        const reuseThreshold = this.getVariable("reuseThreshold", 3);
+        const daysToCheck = this.getVariable("daysToCheck", 7);
+        const matchingPosts = this.getPosts()
+            .filter(post => post.createdAt > (0, date_fns_1.subDays)(new Date(), daysToCheck) && linkRegexes.some(regex => new RegExp(regex).test(post.url)) && !post.crosspostParentId)
+            .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
+            .slice(0, 10);
+        if (matchingPosts.length < requiredLinks) {
+            return false;
+        }
+        const distinctLinks = Array.from(new Set(matchingPosts.map(post => post.url)));
+        const reuses = await Promise.all(distinctLinks.map(async (link) => {
+            const distinctUsers = await this.getDistinctUsersForLink(link);
+            return { link, distinctUsers };
+        }));
+        const reusedOverThreshold = reuses.filter(({ distinctUsers }) => distinctUsers.length >= reuseThreshold);
+        if (reusedOverThreshold.length < requiredLinks) {
+            return false;
+        }
+        if (!(await this.isEligibleUserForEvaluator(user.username, true))) {
+            return false;
+        }
+        const eligibleUsers = new Map();
+        // Now we need to check if any of the distinct users are eligible for this evaluator
+        const filteredReuses = [];
+        for (const { link, distinctUsers } of reusedOverThreshold) {
+            const eligibleDistinctUsers = [];
+            for (const username of distinctUsers) {
+                if (username === user.username) {
+                    eligibleDistinctUsers.push(username);
+                    continue;
+                }
+                const isEligibleFromCache = eligibleUsers.get(username);
+                if (isEligibleFromCache !== undefined) {
+                    if (isEligibleFromCache) {
+                        eligibleDistinctUsers.push(username);
+                        continue;
+                    }
+                    else {
+                        const isEligible = await this.isEligibleUserForEvaluator(username);
+                        eligibleUsers.set(username, isEligible);
+                        if (isEligible) {
+                            eligibleDistinctUsers.push(username);
+                        }
+                    }
+                }
+            }
+            filteredReuses.push({ link, distinctUsers: eligibleDistinctUsers });
+        }
+        const filteredReusedOverThreshold = filteredReuses.filter(({ distinctUsers }) => distinctUsers.length >= reuseThreshold);
+        if (filteredReusedOverThreshold.length < requiredLinks) {
+            return false;
+        }
+        this.addHitReason({
+            reason: `User has ${filteredReusedOverThreshold.length} links reused by at least ${reuseThreshold} distinct users`,
+            details: filteredReusedOverThreshold.map(({ link, distinctUsers }) => ({
+                key: link,
+                value: `Also used by by: ${distinctUsers.filter(username => username !== user.username).map(username => `u/${username}`).join(", ")}`,
+            })),
+        });
+        return true;
+    }
+}
+exports.EvaluateLinkReuse = EvaluateLinkReuse;

package/dist/userEvaluation/EvaluateMixedBot.d.ts

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

package/dist/userEvaluation/EvaluateMixedBot.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateMixedBot = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const date_fns_1 = require("date-fns");
+const tid_js_1 = require("@devvit/public-api/types/tid.js");
+const evaluatorHelpers_js_1 = require("./evaluatorHelpers.js");
+class EvaluateMixedBot extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Mixed Bot";
+        this.shortname = "mixed-bot";
+        this.emDashRegex = /\w—\w/i;
+    }
+    eligibleComment(comment) {
+        const isEligible = (0, tid_js_1.isLinkId)(comment.parentId)
+            && comment.body.split("\n\n").length <= 3
+            && (comment.body.slice(0, 25).includes(",")
+                || comment.body.slice(0, 25).includes(".")
+                || this.emDashRegex.test(comment.body)
+                || !comment.body.includes("\n")
+                || comment.body === comment.body.toLowerCase()
+                || comment.body.length < 50
+                || comment.body.includes("\n\n\n\n"));
+        return isEligible;
+    }
+    eligiblePost(post) {
+        if (post.subredditName === "WhatIsMyCQS") {
+            return true;
+        }
+        if (!post.url) {
+            return false;
+        }
+        if (post.url.startsWith("/")) {
+            return false;
+        }
+        const redditDomains = this.getGenericVariable("redditdomains", []);
+        const domain = (0, evaluatorHelpers_js_1.domainFromUrl)(post.url);
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        return (domain && redditDomains.includes(domain)) || post.subredditName === "WhatIsMyCQS";
+    }
+    preEvaluateComment(event) {
+        if (!event.comment) {
+            return false;
+        }
+        return this.eligibleComment(event.comment);
+    }
+    preEvaluatePost(post) {
+        return this.eligiblePost(post);
+    }
+    preEvaluateUser(user) {
+        return (user.createdAt < (0, date_fns_1.subYears)(new Date(), 5) || user.createdAt > (0, date_fns_1.subMonths)(new Date(), 6)) && user.commentKarma < 1000;
+    }
+    evaluate(user, history) {
+        if (history.length > 90) {
+            return false;
+        }
+        const olderContentCount = history.filter(item => item.createdAt < (0, date_fns_1.subYears)(new Date(), 5)).length;
+        if (user.createdAt > (0, date_fns_1.subYears)(new Date(), 5) && olderContentCount > 5) {
+            return false;
+        }
+        const posts = this.getPosts(history, { since: (0, date_fns_1.subMonths)(new Date(), 1), omitRemoved: true });
+        const comments = this.getComments(history, { since: (0, date_fns_1.subMonths)(new Date(), 1) });
+        if (posts.length === 0 || comments.length === 0) {
+            return false;
+        }
+        if (!posts.every(post => this.eligiblePost(post))) {
+            return false;
+        }
+        if (!comments.every(comment => this.eligibleComment(comment))) {
+            return false;
+        }
+        if (!posts.some(post => post.title === post.title.toLowerCase() || post.title === post.title.toUpperCase())) {
+            return false;
+        }
+        if (!comments.some(comment => this.emDashRegex.test(comment.body))) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.EvaluateMixedBot = EvaluateMixedBot;

package/dist/userEvaluation/EvaluateObfuscatedBioKeywords.d.ts

@@ -0,0 +1,16 @@
+import { Post } from "@devvit/public-api";
+import { CommentCreate } from "@devvit/protos";
+import { UserEvaluatorBase } from "./UserEvaluatorBase.js";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+export declare class EvaluateObfuscatedBioKeywords extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    private getKeywords;
+    private getAllowedTerms;
+    private bioTextMatches;
+    preEvaluateComment(event: CommentCreate): boolean;
+    preEvaluatePost(_: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(_user: UserExtended): boolean;
+}

package/dist/userEvaluation/EvaluateObfuscatedBioKeywords.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateObfuscatedBioKeywords = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+class EvaluateObfuscatedBioKeywords extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Obfuscated Bio Keywords Bot";
+        this.shortname = "obfuscatedbiowords";
+        this.banContentThreshold = 0;
+    }
+    getKeywords() {
+        return this.getVariable("keywords", []);
+    }
+    getAllowedTerms() {
+        return this.getVariable("allowedterms", []);
+    }
+    bioTextMatches(bio) {
+        if (!bio) {
+            return false;
+        }
+        const keywords = this.getKeywords();
+        const allowedTerms = this.getAllowedTerms();
+        for (const keyword of keywords) {
+            // eslint-disable-next-line @typescript-eslint/no-misused-spread
+            const keywordLetters = [...keyword.toLowerCase()];
+            for (let i = 0; i < keywordLetters.length; i++) {
+                keywordLetters[i] = keywordLetters[i].replace("i", "[ie1]");
+                keywordLetters[i] = keywordLetters[i].replace("o", "[o0]");
+                keywordLetters[i] = keywordLetters[i].replace("a", "[a4@]");
+                keywordLetters[i] = keywordLetters[i].replace("e", "[ei3]");
+                keywordLetters[i] = keywordLetters[i].replace("s", "[s5]");
+                keywordLetters[i] = keywordLetters[i].replace("t", "[t7]");
+                keywordLetters[i] = keywordLetters[i].replace("b", "[b6]");
+                keywordLetters[i] = keywordLetters[i].replace("g", "[g9]");
+                keywordLetters[i] = keywordLetters[i].replace("l", "[l1]");
+                keywordLetters[i] = keywordLetters[i].replace("z", "[z2]");
+            }
+            const regexComponents = [
+                keywordLetters[0] + ".?" + keywordLetters.slice(1).join(".{0,2}"),
+                keywordLetters.join("."),
+                keywordLetters.join(".{2}"),
+            ];
+            const regexText = "(?:" + regexComponents.join("|") + ")";
+            const regex = new RegExp("\\b" + regexText + "\\b", "i");
+            const matches = bio.match(regex);
+            if (matches?.length !== 1) {
+                continue;
+            }
+            if (matches[0].toLowerCase() === keyword.toLowerCase()) {
+                continue;
+            }
+            if (allowedTerms.includes(matches[0].toLowerCase())) {
+                continue;
+            }
+            this.addHitReason(`Bio text matched obfuscated keyword: ${keyword} (matched "${matches[0]}")`);
+            return true;
+        }
+        return false;
+    }
+    preEvaluateComment(event) {
+        return this.bioTextMatches(event.author?.description);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluatePost(_) {
+        return this.getKeywords().length > 0;
+    }
+    preEvaluateUser(user) {
+        if (user.commentKarma > 1000 || user.linkKarma > 5000) {
+            return false;
+        }
+        return this.bioTextMatches(user.userDescription);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    evaluate(_user) {
+        return true;
+    }
+}
+exports.EvaluateObfuscatedBioKeywords = EvaluateObfuscatedBioKeywords;

package/dist/userEvaluation/EvaluatePinnedPostTitle.d.ts

@@ -0,0 +1,15 @@
+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 EvaluatePinnedPostTitles extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    validateVariables(): ValidationIssue[];
+    gatherRegexes(): EvaluatorRegex[];
+    preEvaluateComment(_: CommentCreate): boolean;
+    preEvaluatePost(post: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(_: UserExtended): boolean;
+}

package/dist/userEvaluation/EvaluatePinnedPostTitle.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluatePinnedPostTitles = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const evaluatorHelpers_js_1 = require("./evaluatorHelpers.js");
+const markdown_escape_1 = __importDefault(require("markdown-escape"));
+const lodash_1 = require("lodash");
+class EvaluatePinnedPostTitles extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Sticky Post Title Bot";
+        this.shortname = "pinnedpost";
+        this.banContentThreshold = 1;
+    }
+    validateVariables() {
+        const results = [];
+        const regexes = this.gatherRegexes();
+        for (const regexVal of regexes) {
+            let regex;
+            try {
+                regex = new RegExp(regexVal.regex, regexVal.flags);
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid regex in sticky post title: ${regexVal.regex}` });
+                continue;
+            }
+            if (regex.test("")) {
+                results.push({ severity: "error", message: `Sticky post title regex is too greedy: ${regexVal.regex}` });
+            }
+        }
+        return results;
+    }
+    gatherRegexes() {
+        const bannableTitles = this.getVariable("bantext", []);
+        return (0, lodash_1.uniq)(bannableTitles.map(title => ({
+            evaluatorName: this.name,
+            regex: title,
+            flags: "u",
+        })));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_) {
+        return false;
+    }
+    preEvaluatePost(post) {
+        const domain = (0, evaluatorHelpers_js_1.domainFromUrl)(post.url);
+        return domain === "reddit.com" && !post.crosspostParentId;
+    }
+    preEvaluateUser(user) {
+        const maxCommentKarma = this.getVariable("maxCommentKarma", 2000);
+        const maxLinkKarma = this.getVariable("maxLinkKarma", 5000);
+        if (user.commentKarma > maxCommentKarma || user.linkKarma > maxLinkKarma) {
+            return false;
+        }
+        return true;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    evaluate(_) {
+        const stickyPosts = this.getPosts().filter(post => post.stickied && !post.crosspostParentId);
+        if (stickyPosts.length === 0) {
+            return false;
+        }
+        const regexes = this.gatherRegexes().map(r => new RegExp(r.regex, r.flags));
+        const matchedBanRegex = regexes.find(regex => stickyPosts.some(post => regex.test(post.title)));
+        if (matchedBanRegex) {
+            const matchedPost = stickyPosts.find(post => matchedBanRegex.test(post.title));
+            this.addHitReason(`Sticky post title "${matchedPost?.title}" matched regex: ${(0, markdown_escape_1.default)(matchedBanRegex.source)}`);
+            this.canAutoBan = true;
+            return true;
+        }
+        return false;
+    }
+}
+exports.EvaluatePinnedPostTitles = EvaluatePinnedPostTitles;

package/dist/userEvaluation/EvaluatePostTitle.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 EvaluatePostTitle extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    validateVariables(): ValidationIssue[];
+    gatherRegexes(): EvaluatorRegex[];
+    preEvaluateComment(_: CommentCreate): boolean;
+    private getTitles;
+    preEvaluatePost(post: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(_: UserExtended): boolean;
+}

package/dist/userEvaluation/EvaluatePostTitle.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluatePostTitle = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const markdown_escape_1 = __importDefault(require("markdown-escape"));
+const date_fns_1 = require("date-fns");
+const lodash_1 = require("lodash");
+class EvaluatePostTitle extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Bad Post Title Bot";
+        this.shortname = "posttitle";
+        this.banContentThreshold = 1;
+    }
+    validateVariables() {
+        const results = [];
+        const regexes = this.gatherRegexes().map(r => r.regex);
+        for (const regexVal of regexes) {
+            let regex;
+            try {
+                regex = new RegExp(regexVal, "u");
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid regex in post title: ${regexVal}` });
+                continue;
+            }
+            if (regex.test("")) {
+                results.push({ severity: "error", message: `Post title regex is too greedy: ${regexVal}` });
+            }
+        }
+        return results;
+    }
+    gatherRegexes() {
+        const bannableTitles = this.getTitles();
+        return (0, lodash_1.uniq)(bannableTitles.map(title => ({
+            evaluatorName: this.name,
+            regex: title,
+            flags: "u",
+        })));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_) {
+        return false;
+    }
+    getTitles() {
+        const prefixesToIgnore = this.getVariable("ignoredRegexPrefixes", []);
+        return this.getVariable("bantext", []).filter(title => !prefixesToIgnore.some(prefix => title.startsWith(prefix)));
+    }
+    preEvaluatePost(post) {
+        if (post.crosspostParentId) {
+            return false;
+        }
+        const bannableTitles = this.getTitles();
+        return bannableTitles.some(title => new RegExp(title, "u").test(post.title));
+    }
+    preEvaluateUser(user) {
+        const maxCommentKarma = this.getVariable("maxCommentKarma", 2000);
+        const maxLinkKarma = this.getVariable("maxLinkKarma", 5000);
+        if (user.commentKarma > maxCommentKarma && user.linkKarma > maxLinkKarma) {
+            return false;
+        }
+        return true;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    evaluate(_) {
+        const userPosts = this.getPosts({ since: (0, date_fns_1.subWeeks)(new Date(), 1) }).filter(post => post.nsfw && !post.crosspostParentId);
+        if (userPosts.length === 0) {
+            return false;
+        }
+        const bannableTitles = this.gatherRegexes().map(title => ({ pattern: title.regex, regex: new RegExp(title.regex, title.flags) }));
+        const nonMatchingTitles = new Set();
+        for (const title of userPosts.map(post => post.title)) {
+            if (nonMatchingTitles.has(title)) {
+                continue;
+            }
+            const matchedBanRegex = bannableTitles.find(bannable => bannable.regex.test(title));
+            if (!matchedBanRegex) {
+                nonMatchingTitles.add(title);
+                continue;
+            }
+            this.addHitReason(`Post title "${title}" matched bannable regex: ${(0, markdown_escape_1.default)(matchedBanRegex.pattern)}`);
+            this.canAutoBan = true;
+            return true;
+        }
+        return false;
+    }
+}
+exports.EvaluatePostTitle = EvaluatePostTitle;