@fsvreddit/bot-bouncer-evaluation 0.7.40

package/dist/userEvaluation/EvaluateSocialLinks.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateSocialLinks = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const date_fns_1 = require("date-fns");
+const evaluatorHelpers_js_1 = require("./evaluatorHelpers.js");
+const lodash_1 = require("lodash");
+class EvaluateSocialLinks extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Social Links Bot";
+        this.shortname = "sociallinks";
+        this.banContentThreshold = 0;
+    }
+    validateVariables() {
+        const results = [];
+        const badLinks = this.getVariable("badlinks", []);
+        for (const link of badLinks) {
+            try {
+                (0, evaluatorHelpers_js_1.domainFromUrl)(link);
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid URL in badlinks: ${link}` });
+            }
+        }
+        return results;
+    }
+    getVariableOverrides() {
+        const badLinks = this.getVariable("badlinks", []);
+        if (badLinks.some(link => Array.isArray(link))) {
+            return {
+                badlinks: badLinks.flat(),
+            };
+        }
+        else {
+            return {};
+        }
+    }
+    getDomains() {
+        const domains = new Set(this.getGenericVariable("redditdomains", []));
+        domains.add("redgifs.com");
+        domains.add("instagram.com");
+        domains.add("i.redd.it");
+        const badLinks = this.getVariable("badlinks", []);
+        for (const link of badLinks) {
+            try {
+                const domain = (0, evaluatorHelpers_js_1.domainFromUrl)(link);
+                if (domain) {
+                    domains.add(domain);
+                }
+            }
+            catch {
+                //
+            }
+        }
+        return Array.from(domains);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_) {
+        if (this.socialLinks) {
+            const badSocialLinks = this.getVariable("badlinks", []);
+            return this.socialLinks.some(link => badSocialLinks.some(badLink => link.outboundUrl.startsWith(badLink)));
+        }
+        return false;
+    }
+    preEvaluatePost(post) {
+        return post.nsfw;
+    }
+    preEvaluateUser(user) {
+        const badSocialLinks = this.getVariable("badlinks", []);
+        if (badSocialLinks.length === 0) {
+            return false;
+        }
+        const accountEligible = (user.commentKarma < 500 && user.createdAt > (0, date_fns_1.subMonths)(new Date(), 2))
+            || user.createdAt < (0, date_fns_1.subYears)(new Date(), 5)
+            || user.nsfw;
+        return accountEligible;
+    }
+    async evaluate(user) {
+        const badSocialLinks = this.getVariable("badlinks", []);
+        if (badSocialLinks.length === 0) {
+            return false;
+        }
+        const badLinksFromPosts = badSocialLinks.filter(badLink => this.getPosts().some(post => post.url.startsWith(badLink) && !post.crosspostParentId));
+        if (badLinksFromPosts.length > 0) {
+            this.addHitReason(`User has bad links in posts: ${(0, lodash_1.uniq)(badLinksFromPosts).join(", ")}`);
+            return true;
+        }
+        const userSocialLinks = await this.getSocialLinks(user.username);
+        if (userSocialLinks.length === 0) {
+            return false;
+        }
+        const badSocialLinksFound = userSocialLinks.filter(link => badSocialLinks.some(badLink => link.outboundUrl.startsWith(badLink)));
+        if (badSocialLinksFound.length > 0) {
+            this.addHitReason(`User has bad social links: ${(0, lodash_1.uniq)(badSocialLinksFound.map(link => link.outboundUrl)).join(", ")}`);
+            return true;
+        }
+        return false;
+    }
+}
+exports.EvaluateSocialLinks = EvaluateSocialLinks;

package/dist/userEvaluation/EvaluateSuspiciousFirstPost.d.ts

@@ -0,0 +1,15 @@
+import { CommentCreate } from "@devvit/protos";
+import { UserEvaluatorBase } from "./UserEvaluatorBase.js";
+import { Post } from "@devvit/public-api";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+export declare class EvaluateSuspiciousFirstPost extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    private subList;
+    private eligiblePost;
+    preEvaluateComment(_: CommentCreate): boolean;
+    preEvaluatePost(post: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(_: UserExtended): boolean;
+}

package/dist/userEvaluation/EvaluateSuspiciousFirstPost.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateSuspiciousFirstPost = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const date_fns_1 = require("date-fns");
+const evaluatorHelpers_js_1 = require("./evaluatorHelpers.js");
+const markdown_escape_1 = __importDefault(require("markdown-escape"));
+class EvaluateSuspiciousFirstPost extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Suspicious First Post";
+        this.shortname = "suspiciousfirstpost";
+        this.banContentThreshold = 1;
+    }
+    subList() {
+        return this.getVariable("subreddits", []);
+    }
+    eligiblePost(post) {
+        if (!this.subList().includes(post.subredditName)) {
+            return false;
+        }
+        const domain = (0, evaluatorHelpers_js_1.domainFromUrl)(post.url);
+        return (domain === "i.redd.it" || domain === "v.redd.it")
+            || post.url.startsWith("https://www.reddit.com/gallery/");
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_) {
+        return false;
+    }
+    preEvaluatePost(post) {
+        return this.eligiblePost(post);
+    }
+    preEvaluateUser(user) {
+        const maxAgeInDays = this.getVariable("maxageindays", 14);
+        const maxCommentKarma = this.getVariable("maxcommentkarma", 50);
+        return user.createdAt > (0, date_fns_1.subDays)(new Date(), maxAgeInDays) && user.commentKarma < maxCommentKarma;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    evaluate(_) {
+        const comments = this.getComments();
+        if (comments.length > 1) {
+            return false;
+        }
+        const posts = this.getPosts({ omitRemoved: false });
+        if (posts.length === 0) {
+            return false;
+        }
+        if (posts.length > 1) {
+            return false;
+        }
+        if (!posts.every(post => this.eligiblePost(post))) {
+            return false;
+        }
+        if (comments.length > 0) {
+            const commentDate = comments[0].createdAt;
+            const postDate = posts[0].createdAt;
+            if (commentDate > postDate) {
+                return false;
+            }
+        }
+        this.addHitReason(`Sole post in ${(0, markdown_escape_1.default)(posts[0].subredditName)}`);
+        return true;
+    }
+}
+exports.EvaluateSuspiciousFirstPost = EvaluateSuspiciousFirstPost;

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

package/dist/userEvaluation/EvaluateTGGroup.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateTGGroup = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const date_fns_1 = require("date-fns");
+const lodash_1 = require("lodash");
+class EvaluateTGGroup extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Telegram Group Bot";
+        this.shortname = "tg-group";
+        this.banContentThreshold = 1;
+    }
+    validateVariables() {
+        const results = [];
+        const regexes = this.getVariable("bodyregex", []);
+        for (const regexVal of regexes) {
+            let regex;
+            try {
+                regex = new RegExp(regexVal);
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid regex in TG Group: ${regexVal}` });
+                continue;
+            }
+            if (regex.test("")) {
+                results.push({ severity: "error", message: `TG Group regex is too greedy: ${regexVal}` });
+            }
+        }
+        return results;
+    }
+    gatherRegexes() {
+        const bodyRegexes = this.getVariable("bodyregex", []);
+        return (0, lodash_1.uniq)([
+            ...bodyRegexes.map(bodyRegex => ({
+                evaluatorName: this.name,
+                regex: bodyRegex,
+            })),
+        ]);
+    }
+    eligiblePost(post) {
+        if (!post.body) {
+            return false;
+        }
+        const titleStrings = this.getVariable("titlestrings", []);
+        const bodyRegexes = this.getVariable("bodyregex", []);
+        return post.nsfw
+            && titleStrings.some(titleString => post.title.includes(titleString))
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            && bodyRegexes.some(bodyRegex => new RegExp(bodyRegex).test(post.body));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_) {
+        return false;
+    }
+    preEvaluatePost(post) {
+        return this.eligiblePost(post);
+    }
+    preEvaluateUser(user) {
+        return user.createdAt > (0, date_fns_1.subMonths)(new Date(), 1)
+            || user.commentKarma < 100
+            || user.linkKarma < 50;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    evaluate(_) {
+        const recentPosts = this.getPosts({ since: (0, date_fns_1.subWeeks)(new Date(), 1) }).filter(post => post.nsfw);
+        if (recentPosts.length === 0) {
+            return false;
+        }
+        return recentPosts.some(post => this.eligiblePost(post));
+    }
+}
+exports.EvaluateTGGroup = EvaluateTGGroup;

package/dist/userEvaluation/EvaluateTextInNsfwImages.d.ts

@@ -0,0 +1,14 @@
+import { EvaluatorRegex, ValidationIssue } from "./UserEvaluatorBase";
+import { EvaluateBotGroupAdvanced } from "./EvaluateBotGroupAdvanced";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+export declare class EvaluateTextInNsfwImages extends EvaluateBotGroupAdvanced {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    readonly needsOpenAiKey = true;
+    gatherRegexes(): EvaluatorRegex[];
+    validateVariables(): ValidationIssue[];
+    private getImageUrl;
+    private getTextFromImage;
+    evaluate(user: UserExtended): Promise<boolean>;
+}

package/dist/userEvaluation/EvaluateTextInNsfwImages.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateTextInNsfwImages = void 0;
+const EvaluateBotGroupAdvanced_1 = require("./EvaluateBotGroupAdvanced");
+const date_fns_1 = require("date-fns");
+const evaluatorHelpers_1 = require("./evaluatorHelpers");
+const openai_1 = __importDefault(require("openai"));
+const zod_1 = __importDefault(require("zod"));
+const zod_js_1 = require("openai/helpers/zod.js");
+const constants_1 = require("../constants");
+class EvaluateTextInNsfwImages extends EvaluateBotGroupAdvanced_1.EvaluateBotGroupAdvanced {
+    constructor() {
+        super(...arguments);
+        this.name = "Text in NSFW Images Bot";
+        this.shortname = "nsfwtext";
+        this.banContentThreshold = 0;
+        this.needsOpenAiKey = true;
+    }
+    gatherRegexes() {
+        const regexesFromSuper = super.gatherRegexes();
+        const imageTextRegexes = this.getVariable("imageTextRegexes", []);
+        const requiredPostTitleRegexes = this.getVariable("requiredPostTitleRegexes", []);
+        const allRegexes = [...imageTextRegexes, ...requiredPostTitleRegexes];
+        return [
+            ...regexesFromSuper,
+            ...allRegexes.map(regex => ({
+                evaluatorName: this.name,
+                regex,
+                flags: "u",
+            })),
+        ];
+    }
+    validateVariables() {
+        const issues = super.validateVariables();
+        const imageTextRegexes = this.getVariable("imageTextRegexes", []);
+        if (!Array.isArray(imageTextRegexes)) {
+            issues.push({ severity: "error", message: "imageTextRegexes must be an array." });
+        }
+        for (const regex of imageTextRegexes) {
+            try {
+                new RegExp(regex, "u");
+            }
+            catch {
+                issues.push({ severity: "error", message: `Invalid regex in imageTextRegexes: ${regex}` });
+            }
+        }
+        const requiredPostTitleRegexes = this.getVariable("requiredPostTitleRegexes", []);
+        if (!Array.isArray(requiredPostTitleRegexes)) {
+            issues.push({ severity: "error", message: "requiredPostTitleRegexes must be an array." });
+        }
+        for (const regex of requiredPostTitleRegexes) {
+            try {
+                new RegExp(regex, "u");
+            }
+            catch {
+                issues.push({ severity: "error", message: `Invalid regex in requiredPostTitleRegexes: ${regex}` });
+            }
+        }
+        return issues;
+    }
+    getImageUrl(post) {
+        if ((0, evaluatorHelpers_1.domainFromUrl)(post.url) === "i.redd.it") {
+            return post.url;
+        }
+        if (post.gallery.length > 0) {
+            return post.gallery[0].url;
+        }
+    }
+    async getTextFromImage(url) {
+        if (!this.openAiKey) {
+            return;
+        }
+        const resultCacheKey = `imageText:${url}`;
+        const redis = this.context.subredditName === constants_1.MAIN_APP_NAME ? this.context.redis.global : this.context.redis;
+        const cachedResult = await redis.get(resultCacheKey);
+        if (cachedResult) {
+            console.log(`OpenAI Checks: Using cached result for image ${url}, Extracted Text: ${cachedResult}`);
+            return JSON.parse(cachedResult);
+        }
+        const openAIClient = new openai_1.default({
+            apiKey: this.openAiKey,
+        });
+        const responseFormat = zod_1.default.object({
+            extractedText: zod_1.default.string().optional().nullable(),
+        });
+        const prompt = this.getVariable("prompt", "You are given a list of image URLs. For each image, extract any text that appears in the image. If no text is present, return null.");
+        const content = [
+            {
+                type: "input_text",
+                text: prompt,
+            },
+            {
+                type: "input_image",
+                // eslint-disable-next-line camelcase
+                image_url: url,
+                detail: "low",
+            },
+        ];
+        const model = this.getVariable("openAiModel", "gpt-5.4-nano");
+        let response;
+        try {
+            response = await openAIClient.responses.create({
+                model,
+                input: [
+                    {
+                        role: "user",
+                        content,
+                    },
+                ],
+                text: {
+                    format: (0, zod_js_1.zodTextFormat)(responseFormat, "extracted_text"),
+                },
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`OpenAI Checks: API request failed for image ${url} with error: ${errorMessage}`);
+            return;
+        }
+        const result = JSON.parse(response.output_text);
+        console.log(`OpenAI Checks: Tokens used: ${response.usage?.total_tokens}, Model: ${model}, Image URL: ${url}, Extracted Text: ${result.extractedText}`);
+        await redis.set(resultCacheKey, JSON.stringify(result.extractedText), { expiration: (0, date_fns_1.addHours)(new Date(), 1) });
+        if (!result.extractedText) {
+            return;
+        }
+        return result.extractedText;
+    }
+    async evaluate(user) {
+        if (!this.openAiKey) {
+            return false;
+        }
+        const imageTextRegexes = this.getVariable("imageTextRegexes", []).map(regex => new RegExp(regex, "iu"));
+        if (imageTextRegexes.length === 0) {
+            return false;
+        }
+        const posts = this.getPosts();
+        const recentNsfwPosts = posts.filter(post => post.nsfw && this.getImageUrl(post) && post.createdAt > (0, date_fns_1.subWeeks)(new Date(), 1));
+        if (recentNsfwPosts.length === 0) {
+            return false;
+        }
+        recentNsfwPosts.sort((a, b) => (0, date_fns_1.compareDesc)(a.createdAt, b.createdAt));
+        const anyGroupMatches = await super.evaluate(user);
+        if (!anyGroupMatches) {
+            return false;
+        }
+        // Clear hit reasons from the super.evaluate call, as we want to only report hits from this specific evaluation
+        this.hitReasons = undefined;
+        const mostRecentNsfwPost = recentNsfwPosts[0];
+        const imageUrl = this.getImageUrl(mostRecentNsfwPost);
+        if (!imageUrl || imageUrl.endsWith(".gif") || imageUrl.endsWith(".mp4")) {
+            return false;
+        }
+        const extractedText = await this.getTextFromImage(imageUrl);
+        if (!extractedText) {
+            return false;
+        }
+        for (const regex of imageTextRegexes) {
+            if (regex.test(extractedText)) {
+                this.addHitReason(`Matched regex "${regex.source}" in extracted text from image: "${extractedText}"`);
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.EvaluateTextInNsfwImages = EvaluateTextInNsfwImages;

package/dist/userEvaluation/EvaluateTitleCopyBot.d.ts

@@ -0,0 +1,13 @@
+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 EvaluateTitleCopyBot extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    preEvaluateComment(event: CommentCreate): boolean;
+    preEvaluatePost(_: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(_: UserExtended): Promise<boolean>;
+}

package/dist/userEvaluation/EvaluateTitleCopyBot.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateTitleCopyBot = 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");
+class EvaluateTitleCopyBot extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Title Copy Bot";
+        this.shortname = "titlecopy";
+        this.banContentThreshold = 5;
+    }
+    preEvaluateComment(event) {
+        if (!event.comment?.body || !event.post?.title) {
+            return false;
+        }
+        const tlcOnly = this.getVariable("tlcOnly", false);
+        if (tlcOnly && !(0, tid_js_1.isLinkId)(event.comment.parentId)) {
+            return false;
+        }
+        const minCommentLength = this.getVariable("minCommentLength", 1);
+        if (event.comment.body.trim().length < minCommentLength) {
+            return false;
+        }
+        return event.comment.body.trim() === event.post.title.trim();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluatePost(_) {
+        return false;
+    }
+    preEvaluateUser(user) {
+        return user.createdAt > (0, date_fns_1.subDays)(new Date(), this.getVariable("maxAccountAgeDays", 180));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async evaluate(_) {
+        const ignoredSubs = this.getVariable("ignoredSubs", []);
+        const comments = this.getComments().filter(comment => !ignoredSubs.includes(comment.subredditName));
+        if (comments.some(comment => comment.body.includes("\n"))) {
+            return false;
+        }
+        const tlcOnly = this.getVariable("tlcOnly", false);
+        if (tlcOnly && comments.some(comment => !(0, tid_js_1.isLinkId)(comment.parentId))) {
+            return false;
+        }
+        const minCommentLength = this.getVariable("minCommentLength", 1);
+        if (comments.some(comment => comment.body.trim().length < minCommentLength)) {
+            return false;
+        }
+        const commentsToCheck = this.getVariable("numCommentsToCheck", 5);
+        const mostRecentComments = comments.slice(0, commentsToCheck);
+        if (mostRecentComments.length < commentsToCheck) {
+            return false;
+        }
+        if (this.getPosts().length > 0) {
+            return false;
+        }
+        for (const comment of mostRecentComments) {
+            const post = await this.context.reddit.getPostById(comment.postId);
+            if (comment.body.trim() !== post.title.trim()) {
+                return false;
+            }
+        }
+        this.addHitReason({
+            reason: "User's recent comments copy the post title verbatim, with no other comments or posts.",
+            details: mostRecentComments.map(comment => ({
+                key: `Comment ${comment.id}`,
+                value: comment.body.trim(),
+            })),
+        });
+        return true;
+    }
+}
+exports.EvaluateTitleCopyBot = EvaluateTitleCopyBot;

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

package/dist/userEvaluation/EvaluateWarmupBot.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateWarmupBot = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const lodash_1 = require("lodash");
+const devvit_helpers_1 = require("devvit-helpers");
+class EvaluateWarmupBot extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Warmup Bot";
+        this.shortname = "warmupbot";
+        this.banContentThreshold = 0;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_) {
+        return false;
+    }
+    validateVariables() {
+        const regexes = this.gatherRegexes().map(r => r.regex);
+        const results = [];
+        for (const regexVal of regexes) {
+            let regex;
+            try {
+                regex = new RegExp(regexVal);
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid rege: ${regexVal}` });
+                continue;
+            }
+            if (regex.test("")) {
+                results.push({ severity: "error", message: `Regex is too greedy: ${regexVal}` });
+            }
+        }
+        return results;
+    }
+    gatherRegexes() {
+        const subredditRegexes = this.getVariable("subredditRegexes", []);
+        const postTitleRegexes = this.getVariable("postTitleRegexes", []);
+        return [...subredditRegexes, ...postTitleRegexes].map(regex => ({
+            evaluatorName: this.name,
+            regex,
+        }));
+    }
+    preEvaluatePost(post) {
+        const postTitleRegexes = this.getVariable("postTitleRegexes", []);
+        if (postTitleRegexes.length === 0) {
+            return false;
+        }
+        return postTitleRegexes.some(regex => new RegExp(regex).test(post.title));
+    }
+    preEvaluateUser(user) {
+        return user.isModerator;
+    }
+    async evaluate(user) {
+        const subredditRegexes = this.getVariable("subredditRegexes", []);
+        if (subredditRegexes.length === 0) {
+            return false;
+        }
+        const postTitleRegexes = this.getVariable("postTitleRegexes", []);
+        if (postTitleRegexes.length === 0) {
+            return false;
+        }
+        const userPosts = this.getPosts();
+        const userComments = this.getComments();
+        const history = [...userPosts, ...userComments];
+        if (!userPosts.some(post => postTitleRegexes.some(regex => new RegExp(regex).test(post.title)))) {
+            return false;
+        }
+        const userSubreddits = (0, lodash_1.uniq)(history.map(item => item.subredditName));
+        const matchedSubreddits = userSubreddits.filter(subreddit => subredditRegexes.some(regex => new RegExp(regex).test(subreddit)));
+        if (matchedSubreddits.length === 0) {
+            return false;
+        }
+        // Check to see if the user is a mod of any of the matched subreddits
+        let moddedSubreddit;
+        for (const subreddit of matchedSubreddits) {
+            if (await (0, devvit_helpers_1.isModerator)(this.context.reddit, subreddit, user.username)) {
+                moddedSubreddit = subreddit;
+                break;
+            }
+        }
+        if (!moddedSubreddit) {
+            return false;
+        }
+        this.addHitReason(`User is a moderator of matched subreddit: ${moddedSubreddit}`);
+        return true;
+    }
+}
+exports.EvaluateWarmupBot = EvaluateWarmupBot;

package/dist/userEvaluation/EvaluateWorldTraveller.d.ts

@@ -0,0 +1,18 @@
+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 EvaluateWorldTraveller extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    canAutoBan: boolean;
+    banContentThreshold: number;
+    validateVariables(): ValidationIssue[];
+    private getWTSubGroups;
+    private getSubList;
+    private isInEligibleSubreddit;
+    preEvaluateComment(_: CommentCreate): boolean;
+    preEvaluatePost(post: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(_: UserExtended): boolean;
+}