@fsvreddit/bot-bouncer-evaluation 0.7.40

package/README.md

@@ -0,0 +1 @@
+Evaluation code for Bot Bouncer, a Dev Platform app that detects bots on Reddit.

package/dist/allEvaluators.d.ts

@@ -0,0 +1,16 @@
+import { EvaluatePinnedPostTitles } from "./userEvaluation/EvaluatePinnedPostTitle.js";
+import { EvaluateBotGroupAdvanced } from "./userEvaluation/EvaluateBotGroupAdvanced.js";
+import { EvaluateWarmupBot } from "./userEvaluation/EvaluateWarmupBot.js";
+import { EvaluateBotGroupAdvancedInternal } from "./userEvaluation/EvaluateBotGroupAdvancedInternal.js";
+import { EvaluateLinkReuse } from "./userEvaluation/EvaluateLinkReuse.js";
+/**
+ * Array of all evaluators.
+ *
+ * In some scenarios, evaluators are run exactly in order, and may return true
+ * as soon as one evaluator detects a bot.
+ *
+ * As a result, order entries to prioritise faster evaluators that do not need to
+ * reference social links or account history first.
+ */
+export declare const ALL_EVALUATORS: (typeof EvaluatePinnedPostTitles | typeof EvaluateBotGroupAdvanced | typeof EvaluateWarmupBot | typeof EvaluateLinkReuse)[];
+export declare const ALL_INTERNAL_EVALUATORS: (typeof EvaluateBotGroupAdvancedInternal)[];

package/dist/allEvaluators.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_INTERNAL_EVALUATORS = exports.ALL_EVALUATORS = void 0;
+const EvaluateDomainSharer_js_1 = require("./userEvaluation/EvaluateDomainSharer.js");
+const EvaluateBadUsername_js_1 = require("./userEvaluation/EvaluateBadUsername.js");
+const EvaluatePinnedPostTitle_js_1 = require("./userEvaluation/EvaluatePinnedPostTitle.js");
+const EvaluateSelfComment_js_1 = require("./userEvaluation/EvaluateSelfComment.js");
+const EvaluatePostTitle_js_1 = require("./userEvaluation/EvaluatePostTitle.js");
+const EvaluateBioText_js_1 = require("./userEvaluation/EvaluateBioText.js");
+const EvaluateObfuscatedBioKeywords_js_1 = require("./userEvaluation/EvaluateObfuscatedBioKeywords.js");
+const EvaluateSocialLinks_js_1 = require("./userEvaluation/EvaluateSocialLinks.js");
+const EvaluateSuspiciousFirstPost_js_1 = require("./userEvaluation/EvaluateSuspiciousFirstPost.js");
+const EvaluateInconsistentAgeBot_js_1 = require("./userEvaluation/EvaluateInconsistentAgeBot.js");
+const EvaluateInconsistentGenderBot_js_1 = require("./userEvaluation/EvaluateInconsistentGenderBot.js");
+const EvaluateBadDisplayname_js_1 = require("./userEvaluation/EvaluateBadDisplayname.js");
+const EvaluateWorldTraveller_js_1 = require("./userEvaluation/EvaluateWorldTraveller.js");
+const EvaluateCommentPhrase_js_1 = require("./userEvaluation/EvaluateCommentPhrase.js");
+const EvaluateTGGroup_js_1 = require("./userEvaluation/EvaluateTGGroup.js");
+const EvaluateBotGroupAdvanced_js_1 = require("./userEvaluation/EvaluateBotGroupAdvanced.js");
+const EvaluateBioTextDefinedHandles_js_1 = require("./userEvaluation/EvaluateBioTextDefinedHandles.js");
+const EvaluatePostTitleDefinedHandles_js_1 = require("./userEvaluation/EvaluatePostTitleDefinedHandles.js");
+const EvaluateBadDisplaynameDefinedHandles_js_1 = require("./userEvaluation/EvaluateBadDisplaynameDefinedHandles.js");
+const EvaluatePostTitleMulti_js_1 = require("./userEvaluation/EvaluatePostTitleMulti.js");
+const EvaluateWarmupBot_js_1 = require("./userEvaluation/EvaluateWarmupBot.js");
+const EvaluateBotGroupAdvancedInternal_js_1 = require("./userEvaluation/EvaluateBotGroupAdvancedInternal.js");
+const EvaluateTitleCopyBot_js_1 = require("./userEvaluation/EvaluateTitleCopyBot.js");
+const EvaluateTextInNsfwImages_js_1 = require("./userEvaluation/EvaluateTextInNsfwImages.js");
+const EvaluateRepostBot_js_1 = require("./userEvaluation/EvaluateRepostBot.js");
+const EvaluateLinkReuse_js_1 = require("./userEvaluation/EvaluateLinkReuse.js");
+/**
+ * Array of all evaluators.
+ *
+ * In some scenarios, evaluators are run exactly in order, and may return true
+ * as soon as one evaluator detects a bot.
+ *
+ * As a result, order entries to prioritise faster evaluators that do not need to
+ * reference social links or account history first.
+ */
+exports.ALL_EVALUATORS = [
+    // Evaluators that can work based on the UserExtended object only
+    EvaluateBadUsername_js_1.EvaluateBadUsername,
+    EvaluateBioText_js_1.EvaluateBioText,
+    EvaluateBioTextDefinedHandles_js_1.EvaluateBioTextDefinedHandles,
+    EvaluateBadDisplayname_js_1.EvaluateBadDisplayName,
+    EvaluateBadDisplaynameDefinedHandles_js_1.EvaluateBadDisplayNameDefinedHandles,
+    EvaluateObfuscatedBioKeywords_js_1.EvaluateObfuscatedBioKeywords,
+    // Evaluators that reference posts and comments, but not social links
+    EvaluateDomainSharer_js_1.EvaluateDomainSharer,
+    EvaluatePinnedPostTitle_js_1.EvaluatePinnedPostTitles,
+    EvaluateSelfComment_js_1.EvaluateSelfComment,
+    EvaluatePostTitle_js_1.EvaluatePostTitle,
+    EvaluatePostTitleDefinedHandles_js_1.EvaluatePostTitleDefinedHandles,
+    EvaluatePostTitleMulti_js_1.EvaluatePostTitleMulti,
+    EvaluateSuspiciousFirstPost_js_1.EvaluateSuspiciousFirstPost,
+    EvaluateInconsistentAgeBot_js_1.EvaluateInconsistentAgeBot,
+    EvaluateInconsistentGenderBot_js_1.EvaluateInconsistentGenderBot,
+    EvaluateWorldTraveller_js_1.EvaluateWorldTraveller,
+    EvaluateCommentPhrase_js_1.EvaluateCommentPhrase,
+    EvaluateTGGroup_js_1.EvaluateTGGroup,
+    // Evaluators that need social links or other complicated data should be at the end
+    EvaluateWarmupBot_js_1.EvaluateWarmupBot,
+    EvaluateSocialLinks_js_1.EvaluateSocialLinks,
+    EvaluateBotGroupAdvanced_js_1.EvaluateBotGroupAdvanced,
+    EvaluateTitleCopyBot_js_1.EvaluateTitleCopyBot,
+    EvaluateLinkReuse_js_1.EvaluateLinkReuse,
+    EvaluateTextInNsfwImages_js_1.EvaluateTextInNsfwImages,
+    EvaluateRepostBot_js_1.EvaluateRepostBot,
+];
+// Evaluators that will only run on internal tools and not subreddits that may be out of date.
+exports.ALL_INTERNAL_EVALUATORS = [
+    EvaluateBotGroupAdvancedInternal_js_1.EvaluateBotGroupAdvancedInternal,
+];

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const CONTROL_SUBREDDIT = "BotBouncer";
+export declare const MAIN_APP_NAME = "bot-bouncer";
+export declare const SUBMITTER_BOT_NAME = "botgroupadvancedsubmitters";

package/dist/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBMITTER_BOT_NAME = exports.MAIN_APP_NAME = exports.CONTROL_SUBREDDIT = void 0;
+exports.CONTROL_SUBREDDIT = "BotBouncer";
+exports.MAIN_APP_NAME = "bot-bouncer";
+exports.SUBMITTER_BOT_NAME = "botgroupadvancedsubmitters";

package/dist/extendedDevvit.d.ts

@@ -0,0 +1,36 @@
+import { Devvit, TriggerContext, User } from "@devvit/public-api";
+import * as protos from "@devvit/protos";
+export interface RedditAPIPlugins {
+    NewModmail: protos.NewModmail;
+    Widgets: protos.Widgets;
+    ModNote: protos.ModNote;
+    LinksAndComments: protos.LinksAndComments;
+    Moderation: protos.Moderation;
+    GraphQL: protos.GraphQL;
+    Listings: protos.Listings;
+    Flair: protos.Flair;
+    Wiki: protos.Wiki;
+    Users: protos.Users;
+    PrivateMessages: protos.PrivateMessages;
+    Subreddits: protos.Subreddits;
+}
+export type ExtendedDevvit = typeof Devvit & {
+    redditAPIPlugins: RedditAPIPlugins;
+};
+export declare function getExtendedDevvit(): ExtendedDevvit;
+export interface UserExtended {
+    createdAt: Date;
+    commentKarma: number;
+    displayName?: string;
+    hasVerifiedEmail: boolean;
+    id: string;
+    isAdmin: boolean;
+    isGold: boolean;
+    isModerator: boolean;
+    linkKarma: number;
+    nsfw: boolean;
+    username: string;
+    userDescription?: string;
+}
+export declare function getUserExtended(username: string, context: TriggerContext): Promise<UserExtended | undefined>;
+export declare function getUserExtendedFromUser(user: User, context: TriggerContext): Promise<UserExtended>;

package/dist/extendedDevvit.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExtendedDevvit = getExtendedDevvit;
+exports.getUserExtended = getUserExtended;
+exports.getUserExtendedFromUser = getUserExtendedFromUser;
+const public_api_1 = require("@devvit/public-api");
+function getExtendedDevvit() {
+    return public_api_1.Devvit; // The Devvit object already has the extended properties, they are simply not reflected in the public type definition.
+}
+async function getRawUserData(username, metadata) {
+    let userAboutResponse;
+    try {
+        userAboutResponse = await getExtendedDevvit().redditAPIPlugins.Users.UserAbout({ username }, metadata);
+    }
+    catch (error) {
+        if (error instanceof Error && (error.message.includes("404 Not Found") || error.message.includes("403 Forbidden"))) {
+            return;
+        }
+        throw error; // Rethrow the error if it's not a 404 or 403
+    }
+    return userAboutResponse;
+}
+async function getUserExtended(username, context) {
+    const rawUserData = await getRawUserData(username, context.metadata);
+    if (!rawUserData?.data) {
+        return;
+    }
+    const userExtendedVal = {
+        createdAt: new Date((rawUserData.data.created ?? 0) * 1000),
+        commentKarma: rawUserData.data.commentKarma ?? 0,
+        displayName: rawUserData.data.subreddit?.title,
+        hasVerifiedEmail: rawUserData.data.hasVerifiedEmail ?? false,
+        id: `t2_${rawUserData.data.id ?? ""}`,
+        isAdmin: rawUserData.data.isEmployee ?? false,
+        isGold: rawUserData.data.isGold ?? false,
+        isModerator: rawUserData.data.isMod ?? false,
+        linkKarma: rawUserData.data.linkKarma ?? 0,
+        nsfw: rawUserData.data.subreddit?.over18 ?? false,
+        username: rawUserData.data.name ?? "",
+        userDescription: rawUserData.data.subreddit?.publicDescription,
+    };
+    return userExtendedVal;
+}
+async function getUserExtendedFromUser(user, context) {
+    try {
+        const userExtended = await getUserExtended(user.username, context);
+        if (userExtended) {
+            return userExtended;
+        }
+    }
+    catch {
+        //
+    }
+    return {
+        createdAt: user.createdAt,
+        commentKarma: user.commentKarma,
+        hasVerifiedEmail: user.hasVerifiedEmail,
+        id: user.id,
+        isAdmin: user.isAdmin,
+        isGold: false,
+        isModerator: false,
+        linkKarma: user.linkKarma,
+        nsfw: user.nsfw,
+        username: user.username,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./allEvaluators";
+export * from "./userEvaluation";
+export { yamlToVariables } from "./utility";
+export { getSocialLinksWithCache } from "./userEvaluation/evaluatorHelpers";

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSocialLinksWithCache = exports.yamlToVariables = void 0;
+__exportStar(require("./allEvaluators"), exports);
+__exportStar(require("./userEvaluation"), exports);
+var utility_1 = require("./utility");
+Object.defineProperty(exports, "yamlToVariables", { enumerable: true, get: function () { return utility_1.yamlToVariables; } });
+var evaluatorHelpers_1 = require("./userEvaluation/evaluatorHelpers");
+Object.defineProperty(exports, "getSocialLinksWithCache", { enumerable: true, get: function () { return evaluatorHelpers_1.getSocialLinksWithCache; } });

package/dist/userEvaluation/EvaluateBadDisplayname.d.ts

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

package/dist/userEvaluation/EvaluateBadDisplayname.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateBadDisplayName = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const markdown_escape_1 = __importDefault(require("markdown-escape"));
+const lodash_1 = require("lodash");
+class EvaluateBadDisplayName extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Bad Display Name Bot";
+        this.shortname = "baddisplayname";
+        this.banContentThreshold = 0;
+    }
+    getBadDisplayNameRegexes() {
+        if (this.badDisplayNameRegexes === undefined) {
+            const bannableDisplayNameRegexes = this.getVariable("regexes", []);
+            const ignoredDisplayNameRegexes = this.getVariable("ignoredRegexes", []);
+            this.badDisplayNameRegexes = bannableDisplayNameRegexes.filter(regex => !ignoredDisplayNameRegexes.includes(regex));
+        }
+        return this.badDisplayNameRegexes;
+    }
+    isBadDisplayName(displayName) {
+        if (!displayName) {
+            return false;
+        }
+        const regexes = this.getBadDisplayNameRegexes();
+        const matchedRegex = regexes.find(regex => new RegExp(regex, "u").test(displayName));
+        if (matchedRegex) {
+            this.addHitReason(`Display name matches regex: ${(0, markdown_escape_1.default)(matchedRegex)}`);
+        }
+        return matchedRegex !== undefined;
+    }
+    gatherRegexes() {
+        const regexes = this.getVariable("regexes", []);
+        return (0, lodash_1.uniq)(regexes.map(regex => ({
+            evaluatorName: this.name,
+            regex,
+            flags: "u",
+        })));
+    }
+    validateVariables() {
+        const regexes = this.gatherRegexes().map(r => r.regex);
+        const results = [];
+        for (const regexVal of regexes) {
+            let regex;
+            try {
+                regex = new RegExp(regexVal, "u");
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid regex in baddisplayname: ${regexVal}` });
+                continue;
+            }
+            if (regex.test("")) {
+                results.push({ severity: "error", message: `Display name regex is too greedy: ${regexVal}` });
+            }
+        }
+        return results;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluatePost(_) {
+        return true;
+    }
+    preEvaluateUser(user) {
+        if (!this.isBadDisplayName(user.displayName)) {
+            return false;
+        }
+        return user.commentKarma < 100;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    evaluate(_user) {
+        return true;
+    }
+}
+exports.EvaluateBadDisplayName = EvaluateBadDisplayName;

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

package/dist/userEvaluation/EvaluateBadDisplaynameDefinedHandles.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateBadDisplayNameDefinedHandles = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const lodash_1 = require("lodash");
+const regjsparser_1 = require("regjsparser");
+class EvaluateBadDisplayNameDefinedHandles extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Bad Display Name Defined Handle Bot";
+        this.shortname = "baddisplaynamedefinedhandles";
+        this.banContentThreshold = 0;
+    }
+    isBadDisplayName(displayName) {
+        if (!displayName) {
+            return false;
+        }
+        const regexes = this.gatherRegexes().map(r => r.regex);
+        const matchedRegexes = regexes.filter(regex => new RegExp(regex, "u").test(displayName));
+        if (matchedRegexes.length === 0) {
+            return false;
+        }
+        this.addHitReason(`Display name matches regexes: ${matchedRegexes.map(r => `\`${r}\``).join(", ")}`);
+        return true;
+    }
+    gatherRegexes() {
+        const prefix = this.getVariable("prefix", "");
+        const suffix = this.getVariable("suffix", "");
+        const definedHandles = this.getModuleVariable("substitutions", "definedhandles", "");
+        if (!definedHandles) {
+            return [];
+        }
+        const parsed = (0, regjsparser_1.parse)(definedHandles, "u");
+        if (parsed.type !== "disjunction") {
+            return [];
+        }
+        const regexes = parsed.body.map(part => `${prefix}${part.raw}${suffix}`);
+        return (0, lodash_1.uniq)(regexes.map(regex => ({
+            evaluatorName: this.name,
+            regex,
+            flags: "u",
+        })));
+    }
+    validateVariables() {
+        const results = [];
+        let regexes;
+        try {
+            regexes = this.gatherRegexes().map(r => r.regex);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            results.push({ severity: "error", message: `Invalid defined handles list: ${message}` });
+            return results;
+        }
+        for (const regexVal of regexes) {
+            let regex;
+            try {
+                regex = new RegExp(regexVal, "u");
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid regex in baddisplaynamedefinedhandles: ${regexVal}` });
+                continue;
+            }
+            if (regex.test("")) {
+                results.push({ severity: "error", message: `Display name defined handle regex is too greedy: ${regexVal}` });
+            }
+        }
+        return results;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluateComment(_) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluatePost(_) {
+        return true;
+    }
+    preEvaluateUser(user) {
+        if (!this.isBadDisplayName(user.displayName)) {
+            return false;
+        }
+        return user.commentKarma < 100;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    evaluate(_user) {
+        return true;
+    }
+}
+exports.EvaluateBadDisplayNameDefinedHandles = EvaluateBadDisplayNameDefinedHandles;

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

package/dist/userEvaluation/EvaluateBadUsername.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateBadUsername = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const date_fns_1 = require("date-fns");
+const markdown_escape_1 = __importDefault(require("markdown-escape"));
+const lodash_1 = require("lodash");
+class EvaluateBadUsername extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Bad Username Bot";
+        this.shortname = "badusername";
+        this.banContentThreshold = 0;
+    }
+    isBadUsername(username) {
+        if (!username) {
+            return false;
+        }
+        const regexes = this.getVariable("regexes", []);
+        const matchedRegex = regexes.find(regex => new RegExp(regex).test(username));
+        if (matchedRegex) {
+            this.addHitReason(`Username matches regex: ${(0, markdown_escape_1.default)(matchedRegex)}`);
+        }
+        return matchedRegex !== undefined;
+    }
+    validateVariables() {
+        const results = [];
+        const regexes = this.getVariable("regexes", []);
+        for (const regexVal of regexes) {
+            let regex;
+            try {
+                regex = new RegExp(regexVal);
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid regex in badusername: ${regexVal}` });
+                continue;
+            }
+            if (regex.test("")) {
+                results.push({ severity: "error", message: `Bad username regex is too greedy: ${regexVal}` });
+            }
+        }
+        return results;
+    }
+    gatherRegexes() {
+        const regexes = this.getVariable("regexes", []);
+        return (0, lodash_1.uniq)(regexes.map(regex => ({
+            evaluatorName: this.name,
+            regex,
+        })));
+    }
+    preEvaluateComment(event) {
+        return this.isBadUsername(event.author?.name);
+    }
+    preEvaluatePost(post) {
+        return this.isBadUsername(post.authorName);
+    }
+    preEvaluateUser(user) {
+        if (!this.isBadUsername(user.username)) {
+            return false;
+        }
+        const maxAgeWeeks = this.getVariable("maxageweeks", 4);
+        if (user.createdAt < (0, date_fns_1.subWeeks)(new Date(), maxAgeWeeks)) {
+            return false;
+        }
+        return true;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    evaluate(_user) {
+        return true;
+    }
+}
+exports.EvaluateBadUsername = EvaluateBadUsername;

package/dist/userEvaluation/EvaluateBioText.d.ts

@@ -0,0 +1,18 @@
+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 EvaluateBioText extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    private bioText;
+    private getBioText;
+    preEvaluateComment(event: CommentCreate): boolean;
+    validateVariables(): ValidationIssue[];
+    getVariableOverrides(): Record<string, unknown>;
+    gatherRegexes(): EvaluatorRegex[];
+    preEvaluatePost(_: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(user: UserExtended): boolean;
+}

package/dist/userEvaluation/EvaluateBioText.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateBioText = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const markdown_escape_1 = __importDefault(require("markdown-escape"));
+class EvaluateBioText extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Bio Text Bot";
+        this.shortname = "biotext";
+        this.banContentThreshold = 0;
+    }
+    getBioText() {
+        if (this.bioText === undefined) {
+            const bannableBioText = this.getVariable("bantext", []);
+            const ignoredBanText = this.getVariable("ignoredBanText", []);
+            this.bioText = bannableBioText.filter(bioText => !ignoredBanText.includes(bioText));
+        }
+        return this.bioText;
+    }
+    preEvaluateComment(event) {
+        const problematicBioText = this.getBioText();
+        return problematicBioText.some(bioText => event.author?.description && new RegExp(bioText, "u").test(event.author.description));
+    }
+    validateVariables() {
+        const results = [];
+        const regexes = this.getVariable("bantext", []);
+        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}` });
+            }
+        }
+        if (this.getVariable("reporttext", []).length > 0) {
+            results.push({ severity: "warning", message: "The reporttext variable is obsolete, and should be left empty." });
+        }
+        return results;
+    }
+    getVariableOverrides() {
+        const bannableBioText = this.getVariable("bantext", []);
+        const results = {};
+        if (bannableBioText.some(r => Array.isArray(r))) {
+            results.bantext = bannableBioText.flat();
+        }
+        return results;
+    }
+    gatherRegexes() {
+        const bannableBioText = this.getVariable("bantext", []);
+        return bannableBioText.map(regex => ({
+            evaluatorName: this.name,
+            regex,
+            flags: "u",
+        }));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluatePost(_) {
+        const bannableBioText = this.getBioText();
+        return bannableBioText.length > 0;
+    }
+    preEvaluateUser(user) {
+        const bannableBioText = this.getBioText();
+        if (bannableBioText.length === 0) {
+            return false;
+        }
+        if (user.commentKarma > 2000 && user.linkKarma > 2000) {
+            return false;
+        }
+        return bannableBioText.some(bioText => user.userDescription && new RegExp(bioText, "u").test(user.userDescription));
+    }
+    evaluate(user) {
+        const bannableBioText = this.getBioText();
+        if (bannableBioText.length === 0) {
+            return false;
+        }
+        const bannableBioTextFound = bannableBioText.find(bio => user.userDescription && new RegExp(bio, "u").test(user.userDescription));
+        if (bannableBioTextFound) {
+            this.canAutoBan = true;
+            this.addHitReason(`Bio text matched regex: ${(0, markdown_escape_1.default)(bannableBioTextFound)}`);
+        }
+        else {
+            return false;
+        }
+        return user.nsfw || this.getPosts().some(post => post.isNsfw());
+    }
+}
+exports.EvaluateBioText = EvaluateBioText;