@fsvreddit/bot-bouncer-evaluation 0.7.40

package/dist/userEvaluation/EvaluateBotGroupAdvanced.js

@@ -0,0 +1,1360 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateBotGroupAdvanced = void 0;
+const tid_js_1 = require("@devvit/public-api/types/tid.js");
+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");
+const constants_js_1 = require("../constants.js");
+const utility_js_1 = require("../utility.js");
+function validateAgeCriteria(age) {
+    const errors = [];
+    const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+    if (Object.keys(age).includes("dateFrom")) {
+        const { dateFrom, dateTo } = age;
+        if (!dateRegex.test(dateFrom)) {
+            errors.push({ severity: "error", message: "Invalid or missing dateFrom in age criteria." });
+        }
+        if (dateTo && !dateRegex.test(dateTo)) {
+            errors.push({ severity: "error", message: "Invalid date format for dateTo in age criteria. Expected format is YYYY-MM-DD." });
+        }
+        if (Object.keys(age).includes("maxAgeInDays") || Object.keys(age).includes("minAgeInDays")) {
+            errors.push({ severity: "error", message: "Cannot specify both date range and min/maxAgeInDays in age criteria." });
+        }
+    }
+    if (Object.keys(age).includes("maxAgeInDays")) {
+        const { maxAgeInDays } = age;
+        if (typeof maxAgeInDays !== "number" || maxAgeInDays <= 0) {
+            errors.push({ severity: "error", message: "maxAgeInDays must be a positive number." });
+        }
+    }
+    if (Object.keys(age).includes("minAgeInDays")) {
+        const { minAgeInDays } = age;
+        if (typeof minAgeInDays !== "number" || minAgeInDays <= 0) {
+            errors.push({ severity: "error", message: "minAgeInDays must be a positive number." });
+        }
+    }
+    else if (!Object.keys(age).includes("dateFrom") && !Object.keys(age).includes("maxAgeInDays") && !Object.keys(age).includes("minAgeInDays")) {
+        // If neither date range nor maxAgeInDays is specified, it's an error
+        errors.push({ severity: "error", message: "Age criteria must specify either date range, maxAgeInDays, or minAgeInDays." });
+    }
+    if (Object.keys(age).includes("maxAgeInMinutes")) {
+        const { maxAgeInMinutes, maxAgeInDays } = age;
+        if (typeof maxAgeInMinutes !== "number" || maxAgeInMinutes <= 0) {
+            errors.push({ severity: "error", message: "maxAgeInMinutes must be a positive number." });
+        }
+        if (maxAgeInDays !== 1) {
+            errors.push({ severity: "error", message: "maxAgeInMinutes cannot be specified without maxAgeInDays being set to 1." });
+        }
+    }
+    if (Object.keys(age).includes("minAgeInMinutes")) {
+        const { minAgeInMinutes, minAgeInDays } = age;
+        if (typeof minAgeInMinutes !== "number" || minAgeInMinutes <= 0) {
+            errors.push({ severity: "error", message: "minAgeInMinutes must be a positive number." });
+        }
+        if (!minAgeInDays) {
+            errors.push({ severity: "error", message: "minAgeInMinutes cannot be specified without minAgeInDays being set." });
+        }
+    }
+    const keys = Object.keys(age);
+    const expectedKeys = ["dateFrom", "dateTo", "maxAgeInDays", "minAgeInDays", "maxAgeInMinutes", "minAgeInMinutes"];
+    for (const key of keys) {
+        if (!expectedKeys.includes(key)) {
+            errors.push({ severity: "error", message: `Unexpected key in age criteria: ${key}` });
+        }
+    }
+    if (!keys.includes("dateFrom") && !keys.includes("maxAgeInDays") && !keys.includes("minAgeInDays")) {
+        errors.push({ severity: "error", message: "Age criteria must specify at least one of dateFrom, maxAgeInDays, or minAgeInDays." });
+    }
+    return errors;
+}
+function validateRegexArray(regexes) {
+    const errors = [];
+    if (!Array.isArray(regexes)) {
+        errors.push({ severity: "error", message: "Expected an array of regex strings." });
+    }
+    else {
+        for (const regexString of regexes) {
+            if (Array.isArray(regexString)) {
+                errors.push({ severity: "error", message: "Regex must be a string, not an array." });
+                continue;
+            }
+            if (typeof regexString !== "string") {
+                errors.push({ severity: "error", message: `Invalid regex: ${regexString}. Must be a string.` });
+                continue;
+            }
+            try {
+                const regex = new RegExp(regexString, "u");
+                if (regex.test("")) {
+                    errors.push({ severity: "error", message: `Regex ${regexString} appears to be too greedy.` });
+                }
+            }
+            catch {
+                errors.push({ severity: "error", message: `Invalid regex: ${regexString}` });
+            }
+        }
+    }
+    return errors;
+}
+function validatePostCondition(condition) {
+    const errors = [];
+    if (condition.pinned !== undefined && typeof condition.pinned !== "boolean") {
+        errors.push({ severity: "error", message: "pinned must be a boolean." });
+    }
+    if (condition.titleRegex) {
+        errors.push(...validateRegexArray(condition.titleRegex));
+    }
+    if (condition.nsfw !== undefined && typeof condition.nsfw !== "boolean") {
+        errors.push({ severity: "error", message: "nsfw must be a boolean." });
+    }
+    if (condition.urlRegex) {
+        errors.push(...validateRegexArray(condition.urlRegex));
+    }
+    if (condition.domain) {
+        if (!Array.isArray(condition.domain)) {
+            errors.push({ severity: "error", message: "domain must be an array." });
+        }
+        else {
+            if (condition.domain.some(subreddit => Array.isArray(subreddit))) {
+                errors.push({ severity: "error", message: "domain must be an array of strings, not arrays." });
+            }
+            else if (condition.domain.some(name => typeof name !== "string")) {
+                errors.push({ severity: "error", message: "domain must be an array of strings." });
+            }
+            if (condition.domain.includes("")) {
+                errors.push({ severity: "error", message: "domain cannot be an empty string." });
+            }
+        }
+    }
+    if (condition.isCrossPost !== undefined && typeof condition.isCrossPost !== "boolean") {
+        errors.push({ severity: "error", message: "isCrossPost must be a boolean." });
+    }
+    const keys = Object.keys(condition);
+    const expectedKeys = ["type", "pinned", "matchesNeeded", "distinctSubsNeeded", "age", "edited", "subredditName", "notSubredditName", "bodyRegex", "minBodyLength", "maxBodyLength", "minParaCount", "maxParaCount", "minKarma", "maxKarma", "titleRegex", "nsfw", "urlRegex", "domain", "isCrossPost"];
+    for (const key of keys) {
+        if (!expectedKeys.includes(key)) {
+            errors.push({ severity: "error", message: `Unexpected key in post condition: ${key}` });
+        }
+    }
+    return errors;
+}
+function validateCommentCondition(condition) {
+    const errors = [];
+    if (condition.postId !== undefined) {
+        if (!Array.isArray(condition.postId)) {
+            errors.push({ severity: "error", message: "postId must be an array." });
+        }
+        else if (condition.postId.some(postId => typeof postId !== "string")) {
+            errors.push({ severity: "error", message: "postId must be an array of strings." });
+        }
+        else {
+            const validPostIdRegex = /^[a-z0-9]{6,8}$/;
+            if (!condition.postId.every(id => validPostIdRegex.test(id))) {
+                errors.push({ severity: "error", message: `Invalid postId(s): ${condition.postId.filter(id => !validPostIdRegex.test(id)).join(", ")}. Must be a 6-8 character lower-case alphanumeric string.` });
+            }
+        }
+    }
+    if (condition.isTopLevel !== undefined && typeof condition.isTopLevel !== "boolean") {
+        errors.push({ severity: "error", message: "isTopLevel must be a boolean." });
+    }
+    if (condition.isCommentOnOwnPost !== undefined && typeof condition.isCommentOnOwnPost !== "boolean") {
+        errors.push({ severity: "error", message: "isCommentOnOwnPost must be a boolean." });
+    }
+    if (condition.postAuthorNameRegex) {
+        errors.push(...validateRegexArray(condition.postAuthorNameRegex));
+    }
+    if (condition.postTitleRegex) {
+        errors.push(...validateRegexArray(condition.postTitleRegex));
+    }
+    if (condition.postBodyRegex) {
+        errors.push(...validateRegexArray(condition.postBodyRegex));
+    }
+    if (condition.postUrlRegex) {
+        errors.push(...validateRegexArray(condition.postUrlRegex));
+    }
+    if (condition.postCreatedAtAge) {
+        errors.push(...validateAgeCriteria(condition.postCreatedAtAge).map(error => ({ severity: error.severity, message: `Post created at age criteria: ${error.message}` })));
+    }
+    const keys = Object.keys(condition);
+    const expectedKeys = ["type", "matchesNeeded", "distinctSubsNeeded", "age", "edited", "subredditName", "notSubredditName", "bodyRegex", "minBodyLength", "maxBodyLength", "minParaCount", "maxParaCount", "minKarma", "maxKarma", "postId", "isTopLevel", "isCommentOnOwnPost", "postAuthorNameRegex", "postTitleRegex", "postBodyRegex", "postUrlRegex", "postCreatedAtAge"];
+    for (const key of keys) {
+        if (!expectedKeys.includes(key)) {
+            errors.push({ severity: "error", message: `Unexpected key in comment condition: ${key}` });
+        }
+    }
+    return errors;
+}
+function validateCondition(condition) {
+    const errors = [];
+    if (typeof condition.type !== "string" || !["post", "comment"].includes(condition.type)) {
+        errors.push({ severity: "error", message: "type must be either 'post' or 'comment'. Check indents!" });
+    }
+    if (condition.matchesNeeded !== undefined && typeof condition.matchesNeeded !== "number") {
+        errors.push({ severity: "error", message: "matchesNeeded must be a number." });
+    }
+    if (condition.distinctSubsNeeded !== undefined && typeof condition.distinctSubsNeeded !== "number") {
+        errors.push({ severity: "error", message: "distinctSubsNeeded must be a number." });
+    }
+    if (condition.matchesNeeded !== undefined && condition.matchesNeeded < 1) {
+        errors.push({ severity: "error", message: "matchesNeeded must be at least 1." });
+    }
+    if (condition.edited !== undefined && typeof condition.edited !== "boolean") {
+        errors.push({ severity: "error", message: "edited must be a boolean." });
+    }
+    if (condition.age) {
+        errors.push(...validateAgeCriteria(condition.age).map(error => ({ severity: error.severity, message: `Age criteria: ${error.message}` })));
+    }
+    if (condition.subredditName) {
+        if (!Array.isArray(condition.subredditName)) {
+            errors.push({ severity: "error", message: "subredditName must be an array." });
+        }
+        else {
+            if (condition.subredditName.some(subreddit => Array.isArray(subreddit))) {
+                errors.push({ severity: "error", message: "subredditName must be an array of strings, not arrays." });
+            }
+            else if (condition.subredditName.some(name => typeof name !== "string")) {
+                errors.push({ severity: "error", message: "subredditName must be an array of strings." });
+            }
+            if (condition.subredditName.includes("")) {
+                errors.push({ severity: "error", message: "subredditName cannot be an empty string." });
+            }
+        }
+    }
+    if (condition.notSubredditName) {
+        if (!Array.isArray(condition.notSubredditName)) {
+            errors.push({ severity: "error", message: "notSubredditName must be an array." });
+        }
+        else {
+            if (condition.notSubredditName.some(subreddit => Array.isArray(subreddit))) {
+                errors.push({ severity: "error", message: "notSubredditName must be an array of strings, not arrays." });
+            }
+            else if (condition.notSubredditName.some(name => typeof name !== "string")) {
+                errors.push({ severity: "error", message: "notSubredditName must be an array of strings." });
+            }
+            if (condition.notSubredditName.includes("")) {
+                errors.push({ severity: "error", message: "notSubredditName cannot be an empty string." });
+            }
+        }
+    }
+    if (condition.bodyRegex) {
+        errors.push(...validateRegexArray(condition.bodyRegex));
+    }
+    if (condition.minBodyLength !== undefined && (typeof condition.minBodyLength !== "number" || condition.minBodyLength < 0)) {
+        errors.push({ severity: "error", message: "minBodyLength must be a non-negative number." });
+    }
+    if (condition.maxBodyLength !== undefined && (typeof condition.maxBodyLength !== "number" || condition.maxBodyLength < 0)) {
+        errors.push({ severity: "error", message: "maxBodyLength must be a non-negative number." });
+    }
+    if (condition.minParaCount !== undefined && (typeof condition.minParaCount !== "number" || condition.minParaCount < 0)) {
+        errors.push({ severity: "error", message: "minParaCount must be a non-negative number." });
+    }
+    if (condition.maxParaCount !== undefined && (typeof condition.maxParaCount !== "number" || condition.maxParaCount < 0)) {
+        errors.push({ severity: "error", message: "maxParaCount must be a non-negative number." });
+    }
+    if (condition.minKarma !== undefined && (typeof condition.minKarma !== "number" || condition.minKarma < 0)) {
+        errors.push({ severity: "error", message: "minKarma must be a non-negative number." });
+    }
+    if (condition.maxKarma !== undefined && (typeof condition.maxKarma !== "number" || condition.maxKarma < 0)) {
+        errors.push({ severity: "error", message: "maxKarma must be a non-negative number." });
+    }
+    if (condition.type === "post") {
+        errors.push(...validatePostCondition(condition));
+    }
+    else { // Comment condition
+        errors.push(...validateCommentCondition(condition));
+    }
+    return errors;
+}
+function validateCriteriaGroup(criteria, level = 0) {
+    const errors = [];
+    if (Array.isArray(criteria)) {
+        errors.push({ severity: "error", message: "Criteria cannot be an array. Use 'every' or 'some' to combine conditions." });
+        return errors;
+    }
+    const subKeys = Object.keys(criteria).filter(key => ["not", "every", "some", "type"].includes(key));
+    if (subKeys.length === 0) {
+        errors.push({ severity: "error", message: "Criteria must contain one condition or a group (not, every, some)." });
+        return errors;
+    }
+    if (subKeys.length > 1) {
+        errors.push({ severity: "error", message: "Criteria cannot contain multiple top-level conditions. Use 'every' or 'some' to combine them." });
+        return errors;
+    }
+    if ("not" in criteria) {
+        if (level > 1) {
+            errors.push({ severity: "error", message: "Nested 'not' conditions are not allowed." });
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (criteria.not === null) {
+            errors.push({ severity: "error", message: "'not' condition must not be empty." });
+        }
+        else if (typeof criteria.not !== "object" || Array.isArray(criteria.not)) {
+            errors.push({ severity: "error", message: "'not' condition must be a single condition." });
+        }
+        else {
+            errors.push(...validateCriteriaGroup(criteria.not, level + 1));
+        }
+    }
+    else if ("every" in criteria) {
+        if (!Array.isArray(criteria.every)) {
+            errors.push({ severity: "error", message: "'every' must be an array of conditions." });
+        }
+        else if (criteria.every.length === 0) {
+            errors.push({ severity: "error", message: "'every' must not be an empty array." });
+        }
+        else {
+            for (const subCriteria of criteria.every) {
+                errors.push(...validateCriteriaGroup(subCriteria, level + 1));
+            }
+        }
+    }
+    else if ("some" in criteria) {
+        if (!Array.isArray(criteria.some)) {
+            errors.push({ severity: "error", message: "'some' must be an array of conditions." });
+        }
+        else if (criteria.some.length === 0) {
+            errors.push({ severity: "error", message: "'some' must not be an empty array." });
+        }
+        else {
+            if (criteria.some.some(subCriteria => "not" in subCriteria)) {
+                errors.push({ severity: "error", message: "Nested 'not' conditions within 'or' are not allowed." });
+            }
+            for (const subCriteria of criteria.some) {
+                errors.push(...validateCriteriaGroup(subCriteria, level + 1));
+            }
+        }
+    }
+    else {
+        errors.push(...validateCondition(criteria));
+    }
+    const keys = Object.keys(criteria);
+    const expectedKeys = ["not", "every", "some", "type", "pinned", "matchesNeeded", "distinctSubsNeeded", "age", "edited", "subredditName", "notSubredditName", "bodyRegex", "titleRegex", "nsfw", "urlRegex", "domain", "postId", "isTopLevel", "isCommentOnOwnPost", "minBodyLength", "maxBodyLength", "minParaCount", "maxParaCount", "minKarma", "maxKarma", "postAuthorNameRegex", "postTitleRegex", "postBodyRegex", "postUrlRegex", "postCreatedAtAge", "isCrossPost"];
+    for (const key of keys) {
+        if (!expectedKeys.includes(key)) {
+            errors.push({ severity: "error", message: `Unexpected key in criteria group: ${key}` });
+        }
+    }
+    return errors;
+}
+function validateBotGroup(group, allowNewFeatures, evaluatorName) {
+    const errors = [];
+    if (group === null) {
+        return [{ severity: "error", message: "Bot group contains no properties." }];
+    }
+    if (!group.name) {
+        errors.push({ severity: "error", message: "Bot group name is required." });
+    }
+    if (typeof group.name !== "string") {
+        errors.push({ severity: "error", message: "Bot group name must be a string. You may need to enclose the group name in single quotes." });
+    }
+    if (group.submitterName !== undefined) {
+        if (typeof group.submitterName !== "string" && !Array.isArray(group.submitterName)) {
+            errors.push({ severity: "error", message: "submitterName must be a string or an array of strings." });
+        }
+        else if (Array.isArray(group.submitterName) && group.submitterName.some(name => typeof name !== "string")) {
+            errors.push({ severity: "error", message: "All elements of submitterName array must be strings." });
+        }
+        if (evaluatorName !== constants_js_1.SUBMITTER_BOT_NAME) {
+            errors.push({ severity: "error", message: "submitterName is not allowed in this evaluator." });
+        }
+    }
+    if (group.descriptionForAI !== undefined && typeof group.descriptionForAI !== "string") {
+        errors.push({ severity: "error", message: "descriptionForAI must be a string." });
+    }
+    if (group.usernameRegex) {
+        errors.push(...validateRegexArray(group.usernameRegex));
+    }
+    if (group.matchesDefaultUsernameRegex !== undefined && typeof group.matchesDefaultUsernameRegex !== "boolean") {
+        errors.push({ severity: "error", message: "matchesDefaultUsernameRegex must be a boolean." });
+    }
+    if (group.matchesDefaultUsernameRegex !== undefined && !allowNewFeatures) {
+        errors.push({ severity: "error", message: "matchesDefaultUsernameRegex is not allowed in this evaluator." });
+    }
+    if (group.age) {
+        errors.push(...validateAgeCriteria(group.age).map(error => ({ severity: error.severity, message: `Account age: ${error.message}` })));
+    }
+    if (group.bioRegex) {
+        errors.push(...validateRegexArray(group.bioRegex));
+    }
+    if (group.displayNameRegex) {
+        errors.push(...validateRegexArray(group.displayNameRegex));
+    }
+    if (group.socialLinkRegex) {
+        errors.push(...validateRegexArray(group.socialLinkRegex));
+    }
+    if (group.socialLinkTitleRegex) {
+        errors.push(...validateRegexArray(group.socialLinkTitleRegex));
+        if (!group.socialLinkRegex || group.socialLinkRegex.length === 0) {
+            errors.push({ severity: "error", message: "socialLinkTitleRegex is specified but socialLinkRegex is missing. socialLinkRegex must be specified if socialLinkTitleRegex is used." });
+        }
+    }
+    if (group.hasNoSocialLinks !== undefined && typeof group.hasNoSocialLinks !== "boolean") {
+        errors.push({ severity: "error", message: "hasNoSocialLinks must be a boolean." });
+    }
+    if (group.criteria) {
+        errors.push(...validateCriteriaGroup(group.criteria));
+    }
+    if (group.maxLinkKarma !== undefined) {
+        if (typeof group.maxLinkKarma !== "number") {
+            errors.push({ severity: "error", message: "Max link karma must be a number." });
+        }
+        else if (group.maxLinkKarma <= 0) {
+            errors.push({ severity: "error", message: "Max link karma must be a positive number." });
+        }
+    }
+    if (group.maxCommentKarma !== undefined) {
+        if (typeof group.maxCommentKarma !== "number") {
+            errors.push({ severity: "error", message: "Max comment karma must be a number." });
+        }
+        else if (group.maxCommentKarma <= 0) {
+            errors.push({ severity: "error", message: "Max comment karma must be a positive number." });
+        }
+    }
+    if (group.minLinkKarma !== undefined) {
+        if (typeof group.minLinkKarma !== "number") {
+            errors.push({ severity: "error", message: "Min link karma must be a number." });
+        }
+        else if (group.minLinkKarma < 0) {
+            errors.push({ severity: "error", message: "Min link karma must be a non-negative number." });
+        }
+    }
+    if (group.minCommentKarma !== undefined) {
+        if (typeof group.minCommentKarma !== "number") {
+            errors.push({ severity: "error", message: "Min comment karma must be a number." });
+        }
+        else if (group.minCommentKarma < 0) {
+            errors.push({ severity: "error", message: "Min comment karma must be a non-negative number." });
+        }
+    }
+    if (group.nsfw !== undefined && typeof group.nsfw !== "boolean") {
+        errors.push({ severity: "error", message: "NSFW must be a boolean." });
+    }
+    if (group.hasVerifiedEmail !== undefined && typeof group.hasVerifiedEmail !== "boolean") {
+        errors.push({ severity: "error", message: "Has verified email must be a boolean." });
+    }
+    if (group.hasRedditPremium !== undefined && typeof group.hasRedditPremium !== "boolean") {
+        errors.push({ severity: "error", message: "Has Reddit Premium must be a boolean." });
+    }
+    if (group.isSubredditModerator !== undefined && typeof group.isSubredditModerator !== "boolean") {
+        errors.push({ severity: "error", message: "Is subreddit moderator must be a boolean." });
+    }
+    if (group.hasMoreThanOneCommentOnPosts !== undefined && typeof group.hasMoreThanOneCommentOnPosts !== "boolean") {
+        errors.push({ severity: "error", message: "Has more than one comment on posts must be a boolean." });
+    }
+    const keys = Object.keys(group);
+    const expectedKeys = ["name", "submitterName", "descriptionForAI", "usernameRegex", "matchesDefaultUsernameRegex", "maxCommentKarma", "maxLinkKarma", "minCommentKarma", "minLinkKarma", "age", "nsfw", "bioRegex", "displayNameRegex", "socialLinkRegex", "socialLinkTitleRegex", "hasNoSocialLinks", "hasVerifiedEmail", "hasRedditPremium", "isSubredditModerator", "hasMoreThanOneCommentOnPosts", "criteria"];
+    for (const key of keys) {
+        if (!expectedKeys.includes(key)) {
+            errors.push({ severity: "error", message: `Unexpected key in bot group: ${key}` });
+        }
+    }
+    return errors;
+}
+class EvaluateBotGroupAdvanced extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor(context, history, socialLinks, variables) {
+        super(context, history, socialLinks, variables);
+        this.name = "Bot Group Advanced";
+        this.shortname = "botgroupadvanced";
+        this.banContentThreshold = 0; // No content ban threshold for this evaluator to support account properties only checks
+        this.verboseLogging = false;
+        this.allowNewFeatures = false;
+        this.cachedPostProperties = {};
+        this.postPropertiesStatistics = {
+            totalTime: 0,
+            inMemoryHits: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            errors: 0,
+        };
+        this.verboseLogging = this.getVariable("verboseLogging", false);
+        this.redis = context.appSlug === constants_js_1.MAIN_APP_NAME ? context.redis.global : context.redis;
+    }
+    anyRegexMatches(input, regexes) {
+        return regexes.some(regex => new RegExp(regex, "u").test(input));
+    }
+    getBotGroups() {
+        const groups = this.getAllVariables("group");
+        return Object.values(groups);
+    }
+    validateVariables() {
+        const errors = [];
+        const groups = this.getAllVariables("group");
+        for (const [key, group] of Object.entries(groups)) {
+            errors.push(...validateBotGroup(group, this.allowNewFeatures, this.shortname).map(error => ({ severity: error.severity, message: `Bot group ${key}: ${error.message}` })));
+        }
+        return errors;
+    }
+    uniqueMatchReasons(reasons) {
+        const uniqueReasons = {};
+        for (const reason of reasons) {
+            uniqueReasons[`${reason.key}:${reason.value}`] = reason;
+        }
+        return Object.values(uniqueReasons);
+    }
+    getCriteriaGroupRegexes(criteria, groupName) {
+        if ("not" in criteria) {
+            return this.getCriteriaGroupRegexes(criteria.not, groupName);
+        }
+        else if ("every" in criteria) {
+            return criteria.every.flatMap(subCriteria => this.getCriteriaGroupRegexes(subCriteria, groupName));
+        }
+        else if ("some" in criteria) {
+            return criteria.some.flatMap(subCriteria => this.getCriteriaGroupRegexes(subCriteria, groupName));
+        }
+        else {
+            const regexes = [];
+            if (criteria.bodyRegex) {
+                regexes.push(...criteria.bodyRegex.map(regex => ({ evaluatorName: this.name, subName: groupName, regex, flags: "u" })));
+            }
+            if (criteria.type === "post") {
+                if (criteria.titleRegex) {
+                    regexes.push(...criteria.titleRegex.map(regex => ({ evaluatorName: this.name, subName: groupName, regex, flags: "u" })));
+                }
+                if (criteria.urlRegex) {
+                    regexes.push(...criteria.urlRegex.map(regex => ({ evaluatorName: this.name, subName: groupName, regex })));
+                }
+            }
+            else {
+                if (criteria.postTitleRegex) {
+                    regexes.push(...criteria.postTitleRegex.map(regex => ({ evaluatorName: this.name, subName: groupName, regex, flags: "u" })));
+                }
+            }
+            return regexes;
+        }
+    }
+    getBotGroupRegexes(group) {
+        const regexes = [];
+        if (group.usernameRegex) {
+            for (const regex of group.usernameRegex) {
+                regexes.push({ evaluatorName: this.name, subName: group.name, regex });
+            }
+        }
+        if (group.bioRegex) {
+            for (const regex of group.bioRegex) {
+                regexes.push({ evaluatorName: this.name, subName: group.name, regex, flags: "u" });
+            }
+        }
+        if (group.displayNameRegex) {
+            for (const regex of group.displayNameRegex) {
+                regexes.push({ evaluatorName: this.name, subName: group.name, regex, flags: "u" });
+            }
+        }
+        if (group.socialLinkRegex) {
+            for (const regex of group.socialLinkRegex) {
+                regexes.push({ evaluatorName: this.name, subName: group.name, regex });
+            }
+        }
+        if (group.socialLinkTitleRegex) {
+            for (const regex of group.socialLinkTitleRegex) {
+                regexes.push({ evaluatorName: this.name, subName: group.name, regex, flags: "u" });
+            }
+        }
+        if (group.criteria) {
+            regexes.push(...this.getCriteriaGroupRegexes(group.criteria, group.name));
+        }
+        return regexes;
+    }
+    gatherRegexes() {
+        const groups = this.getBotGroups();
+        return (0, lodash_1.uniq)(groups.flatMap(group => this.getBotGroupRegexes(group)));
+    }
+    getSubGroups() {
+        const botGroups = this.getBotGroups();
+        if (botGroups.length === 0) {
+            return;
+        }
+        return botGroups.map(group => group.name);
+    }
+    matchesAgeCriteria(date, age, baseline = new Date()) {
+        // For absolute date range checks, baseline is not used.
+        if ("dateFrom" in age) {
+            const dateFrom = (0, date_fns_1.parse)(age.dateFrom, "yyyy-MM-dd", new Date());
+            if (date < dateFrom) {
+                return false;
+            }
+            if (age.dateTo) {
+                const dateTo = (0, date_fns_1.parse)(age.dateTo, "yyyy-MM-dd", new Date());
+                if (date > (0, date_fns_1.endOfDay)(dateTo)) {
+                    return false;
+                }
+            }
+        }
+        // Baseline is only used for relative checks.
+        if ("maxAgeInDays" in age && age.maxAgeInDays) {
+            const maxAgeDate = (0, date_fns_1.subDays)(baseline, age.maxAgeInDays);
+            if (date < maxAgeDate) {
+                return false;
+            }
+        }
+        if ("minAgeInDays" in age && age.minAgeInDays) {
+            const minAgeDate = (0, date_fns_1.subDays)(baseline, age.minAgeInDays);
+            if (date > minAgeDate) {
+                return false;
+            }
+        }
+        if ("maxAgeInMinutes" in age && age.maxAgeInMinutes) {
+            const maxAgeDate = (0, date_fns_1.subMinutes)(baseline, age.maxAgeInMinutes);
+            if (date < maxAgeDate) {
+                return false;
+            }
+        }
+        if ("minAgeInMinutes" in age && age.minAgeInMinutes) {
+            const minAgeDate = (0, date_fns_1.subMinutes)(baseline, age.minAgeInMinutes);
+            if (date > minAgeDate) {
+                return false;
+            }
+        }
+        return true;
+    }
+    anySubredditMatches(item, subredditNames) {
+        const subredditName = "subredditName" in item ? item.subredditName : this.context.subredditName;
+        const authorName = "authorName" in item ? item.authorName : undefined;
+        return subredditNames.some(subreddit => subredditName?.toLowerCase() === subreddit.toLowerCase())
+            || subredditNames.some(subreddit => subreddit === "$profile" && subredditName === `u_${authorName}`);
+    }
+    postOrCommentMatchesCondition(item, condition) {
+        const matchReasons = [];
+        if (condition.age) {
+            const referenceDate = item.createdAt instanceof Date ? item.createdAt : new Date(item.createdAt);
+            if (!this.matchesAgeCriteria(referenceDate, condition.age)) {
+                return { matched: false };
+            }
+        }
+        if (condition.edited !== undefined && "edited" in item && item.edited !== condition.edited) {
+            return { matched: false };
+        }
+        if (condition.minBodyLength) {
+            if (item.body === undefined) {
+                return { matched: false };
+            }
+            if (item.body.length < condition.minBodyLength) {
+                return { matched: false };
+            }
+        }
+        if (condition.maxBodyLength) {
+            const body = item.body ?? "";
+            if (body.length > condition.maxBodyLength) {
+                return { matched: false };
+            }
+        }
+        if (condition.minParaCount) {
+            if (item.body === undefined) {
+                return { matched: false };
+            }
+            const paraCount = item.body.split("\n").filter(para => para.trim() !== "").length;
+            if (paraCount < condition.minParaCount) {
+                return { matched: false };
+            }
+        }
+        if (condition.maxParaCount !== undefined) {
+            const body = item.body ?? "";
+            const paraCount = body.split("\n").filter(para => para.trim() !== "").length;
+            if (paraCount > condition.maxParaCount) {
+                return { matched: false };
+            }
+        }
+        if (condition.subredditName) {
+            if (this.anySubredditMatches(item, condition.subredditName)) {
+                if ("subredditName" in item) {
+                    matchReasons.push({ key: "subredditName", value: item.subredditName });
+                }
+            }
+            else {
+                return { matched: false };
+            }
+        }
+        if (condition.notSubredditName && this.anySubredditMatches(item, condition.notSubredditName)) {
+            return { matched: false };
+        }
+        if (condition.minKarma !== undefined) {
+            if (item.score < condition.minKarma) {
+                return { matched: false };
+            }
+        }
+        if (condition.maxKarma !== undefined) {
+            if (item.score > condition.maxKarma) {
+                return { matched: false };
+            }
+        }
+        if (condition.bodyRegex) {
+            if (item.body === undefined) {
+                return { matched: false }; // Body regex check requires body to be present
+            }
+            if (this.anyRegexMatches(item.body, condition.bodyRegex)) {
+                matchReasons.push({ key: "bodyRegex", value: item.body });
+            }
+            else {
+                return { matched: false };
+            }
+        }
+        return { matched: true, reasons: matchReasons };
+    }
+    collectCommentConditionsForPreEvalation(criteria) {
+        const conditions = [];
+        if ("type" in criteria && criteria.type === "comment") {
+            conditions.push(criteria);
+        }
+        else if ("every" in criteria) {
+            for (const subCriteria of criteria.every) {
+                conditions.push(...this.collectCommentConditionsForPreEvalation(subCriteria));
+            }
+        }
+        else if ("some" in criteria) {
+            for (const subCriteria of criteria.some) {
+                conditions.push(...this.collectCommentConditionsForPreEvalation(subCriteria));
+            }
+        }
+        return conditions;
+    }
+    collectNegatedCommentConditionsForPreEvaluation(criteria) {
+        const conditions = [];
+        if ("not" in criteria) {
+            conditions.push(...this.collectCommentConditionsForPreEvalation(criteria.not));
+        }
+        else if ("every" in criteria) {
+            for (const subCriteria of criteria.every) {
+                conditions.push(...this.collectNegatedCommentConditionsForPreEvaluation(subCriteria));
+            }
+        }
+        return conditions.filter(condition => condition.matchesNeeded === undefined || condition.matchesNeeded === 1);
+    }
+    async preEvaluateComment(comment) {
+        if (!comment.comment || !comment.author) {
+            return false;
+        }
+        const groups = this.getBotGroups();
+        let userInfo;
+        for (const group of groups) {
+            if (group.usernameRegex) {
+                if (!this.anyRegexMatches(comment.author.name, group.usernameRegex)) {
+                    continue;
+                }
+            }
+            if (group.bioRegex) {
+                if (!comment.author.description) {
+                    continue;
+                }
+                if (!this.anyRegexMatches(comment.author.description, group.bioRegex)) {
+                    continue;
+                }
+            }
+            if (group.maxCommentKarma !== undefined && comment.author.karma > group.maxCommentKarma) {
+                continue;
+            }
+            if (group.maxLinkKarma !== undefined && comment.author.karma > group.maxLinkKarma) {
+                continue;
+            }
+            if (!group.criteria) {
+                if (this.verboseLogging) {
+                    console.log(`Pre-evaluation: Comment ${comment.comment.id} for ${comment.author.name} matches bot group with no criteria ${group.name}`);
+                }
+                return true;
+            }
+            ;
+            const negativeCommentConditions = this.collectNegatedCommentConditionsForPreEvaluation(group.criteria);
+            let negativeConditionMatched = false;
+            for (const condition of negativeCommentConditions) {
+                const conditionMatches = await this.commentMatchesCondition(comment.comment, condition);
+                if (conditionMatches.matched) {
+                    negativeConditionMatched = true;
+                    break;
+                }
+            }
+            if (negativeConditionMatched) {
+                continue;
+            }
+            const commentConditions = this.collectCommentConditionsForPreEvalation(group.criteria);
+            let commentConditionMatched = false;
+            const matchReasons = [];
+            for (const condition of commentConditions) {
+                const conditionMatches = await this.commentMatchesCondition(comment.comment, condition);
+                if (conditionMatches.matched) {
+                    commentConditionMatched = true;
+                    if (this.verboseLogging) {
+                        matchReasons.push(...(conditionMatches.reasons ?? []));
+                    }
+                    break;
+                }
+            }
+            if (!commentConditionMatched) {
+                continue;
+            }
+            if (group.age || group.displayNameRegex || group.nsfw || group.hasRedditPremium || group.hasVerifiedEmail || group.isSubredditModerator) {
+                userInfo ?? (userInfo = await (0, utility_js_1.getAdditionalUserInfo)(comment.author.name, this.context));
+                if (!userInfo) {
+                    continue;
+                }
+                if (group.age) {
+                    if (!this.matchesAgeCriteria(userInfo.createdAt, group.age)) {
+                        continue;
+                    }
+                }
+                if (group.displayNameRegex) {
+                    if (!userInfo.displayName || !this.anyRegexMatches(userInfo.displayName, group.displayNameRegex)) {
+                        continue;
+                    }
+                }
+                if (group.nsfw !== undefined) {
+                    if (userInfo.nsfw !== group.nsfw) {
+                        continue;
+                    }
+                }
+                if (group.hasRedditPremium !== undefined) {
+                    if (userInfo.hasRedditPremium !== group.hasRedditPremium) {
+                        continue;
+                    }
+                }
+                if (group.hasVerifiedEmail !== undefined) {
+                    if (userInfo.hasVerifiedEmail !== group.hasVerifiedEmail) {
+                        continue;
+                    }
+                }
+                if (group.isSubredditModerator !== undefined) {
+                    if (userInfo.isSubredditModerator !== group.isSubredditModerator) {
+                        continue;
+                    }
+                }
+            }
+            console.log(`Pre-evaluation: Comment ${comment.comment.id} for ${comment.author.name} matches bot group ${group.name}`);
+            for (const reason of matchReasons) {
+                console.log(`- Matched reason: ${reason.key} = ${reason.value}`);
+            }
+            return true;
+        }
+        return false;
+    }
+    postMatchesCondition(post, condition) {
+        const conditionMatch = this.postOrCommentMatchesCondition(post, condition);
+        if (!conditionMatch.matched) {
+            return { matched: false };
+        }
+        const matchReasons = [...(conditionMatch.reasons ?? []).map(reason => ({ key: `post ${reason.key}`, value: reason.value }))];
+        if (condition.pinned !== undefined && post.stickied !== condition.pinned) {
+            return { matched: false };
+        }
+        if (condition.nsfw !== undefined && post.nsfw !== condition.nsfw) {
+            return { matched: false };
+        }
+        if (condition.titleRegex) {
+            if (this.anyRegexMatches(post.title, condition.titleRegex)) {
+                matchReasons.push({ key: "titleRegex", value: post.title });
+            }
+            else {
+                return { matched: false };
+            }
+        }
+        if (condition.urlRegex) {
+            if (this.anyRegexMatches(post.url, condition.urlRegex)) {
+                matchReasons.push({ key: "urlRegex", value: post.url });
+            }
+            else {
+                return { matched: false };
+            }
+        }
+        if (condition.domain) {
+            const domain = (0, evaluatorHelpers_js_1.domainFromUrl)(post.url);
+            if (!domain) {
+                return { matched: false };
+            }
+            if (!condition.domain.includes(domain)) {
+                return { matched: false };
+            }
+        }
+        if (condition.isCrossPost !== undefined) {
+            const isCrossPost = post.crosspostParentId !== undefined;
+            if (isCrossPost !== condition.isCrossPost) {
+                return { matched: false };
+            }
+        }
+        return { matched: true, reasons: matchReasons };
+    }
+    async getPostProperties(postId) {
+        const now = Date.now();
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (this.cachedPostProperties[postId]) {
+            this.postPropertiesStatistics.inMemoryHits++;
+            return this.cachedPostProperties[postId];
+        }
+        const cacheKey = `bbe~postProperties~${postId}`;
+        const cachedPostProperties = await this.redis.get(cacheKey);
+        if (cachedPostProperties) {
+            this.cachedPostProperties[postId] = JSON.parse(cachedPostProperties);
+            this.postPropertiesStatistics.cacheHits++;
+            this.postPropertiesStatistics.totalTime += Date.now() - now;
+            return this.cachedPostProperties[postId];
+        }
+        try {
+            const postProperties = await this.context.reddit.getPostById(postId).then(post => ({
+                authorName: post.authorName,
+                title: post.title,
+                body: post.body,
+                url: post.url,
+                createdAt: post.createdAt.getTime(),
+            }));
+            await this.redis.set(cacheKey, JSON.stringify(postProperties), { expiration: (0, date_fns_1.addDays)(new Date(), 7) });
+            this.cachedPostProperties[postId] = postProperties;
+            this.postPropertiesStatistics.cacheMisses++;
+            this.postPropertiesStatistics.totalTime += Date.now() - now;
+            return postProperties;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.evaluationError = `Error fetching post properties for postId ${postId}: ${message}`;
+            this.postPropertiesStatistics.errors++;
+            this.postPropertiesStatistics.totalTime += Date.now() - now;
+            return;
+        }
+    }
+    async commentMatchesCondition(comment, condition, history) {
+        const conditionMatch = this.postOrCommentMatchesCondition(comment, condition);
+        if (!conditionMatch.matched) {
+            return { matched: false };
+        }
+        const matchReasons = [...(conditionMatch.reasons ?? []).map(reason => ({ key: `comment ${reason.key}`, value: reason.value }))];
+        if (condition.postId && !condition.postId.some(postId => comment.postId === `t3_${postId}`)) {
+            return { matched: false };
+        }
+        if (condition.isTopLevel !== undefined && condition.isTopLevel !== (0, tid_js_1.isLinkId)(comment.parentId)) {
+            return { matched: false };
+        }
+        if (condition.isCommentOnOwnPost !== undefined) {
+            if (!history || !("authorName" in comment)) {
+                return { matched: false };
+            }
+            const posts = this.getPosts();
+            const parentPost = posts.find(post => post.id === comment.postId);
+            const matchesCriteria = condition.isCommentOnOwnPost === (parentPost?.authorName === comment.authorName);
+            if (!matchesCriteria) {
+                return { matched: false };
+            }
+        }
+        let postProperties;
+        if (condition.postAuthorNameRegex || condition.postTitleRegex || condition.postBodyRegex || condition.postUrlRegex || condition.postCreatedAtAge) {
+            postProperties = await this.getPostProperties(comment.postId);
+        }
+        if (condition.postCreatedAtAge) {
+            if (!postProperties) {
+                return { matched: false };
+            }
+            if (!this.matchesAgeCriteria(new Date(postProperties.createdAt), condition.postCreatedAtAge, comment.createdAt instanceof Date ? comment.createdAt : new Date(comment.createdAt))) {
+                return { matched: false };
+            }
+        }
+        if (condition.postAuthorNameRegex) {
+            if (!postProperties) {
+                return { matched: false };
+            }
+            if (this.anyRegexMatches(postProperties.authorName, condition.postAuthorNameRegex)) {
+                matchReasons.push({ key: "postAuthorNameRegex", value: postProperties.authorName });
+            }
+            else {
+                return { matched: false };
+            }
+        }
+        if (condition.postTitleRegex) {
+            if (!postProperties?.title) {
+                return { matched: false };
+            }
+            if (this.anyRegexMatches(postProperties.title, condition.postTitleRegex)) {
+                matchReasons.push({ key: "postTitleRegex", value: postProperties.title });
+            }
+            else {
+                return { matched: false };
+            }
+        }
+        if (condition.postBodyRegex) {
+            if (!postProperties?.body) {
+                return { matched: false };
+            }
+            if (this.anyRegexMatches(postProperties.body, condition.postBodyRegex)) {
+                matchReasons.push({ key: "postBodyRegex", value: postProperties.body });
+            }
+            else {
+                return { matched: false };
+            }
+        }
+        if (condition.postUrlRegex) {
+            if (!postProperties?.url) {
+                return { matched: false };
+            }
+            if (this.anyRegexMatches(postProperties.url, condition.postUrlRegex)) {
+                matchReasons.push({ key: "postUrlRegex", value: postProperties.url });
+            }
+            else {
+                return { matched: false };
+            }
+        }
+        return { matched: true, reasons: matchReasons };
+    }
+    collectPostConditionsForPreEvalation(criteria) {
+        const conditions = [];
+        if ("type" in criteria && criteria.type === "post") {
+            conditions.push(criteria);
+        }
+        else if ("every" in criteria) {
+            for (const subCriteria of criteria.every) {
+                conditions.push(...this.collectPostConditionsForPreEvalation(subCriteria));
+            }
+        }
+        else if ("some" in criteria) {
+            for (const subCriteria of criteria.some) {
+                conditions.push(...this.collectPostConditionsForPreEvalation(subCriteria));
+            }
+        }
+        return conditions;
+    }
+    collectNegatedPostConditionsForPreEvaluation(criteria) {
+        const conditions = [];
+        if ("not" in criteria) {
+            conditions.push(...this.collectPostConditionsForPreEvalation(criteria.not));
+        }
+        else if ("every" in criteria) {
+            for (const subCriteria of criteria.every) {
+                conditions.push(...this.collectNegatedPostConditionsForPreEvaluation(subCriteria));
+            }
+        }
+        return conditions.filter(condition => condition.matchesNeeded === undefined || condition.matchesNeeded === 1);
+    }
+    async preEvaluatePost(post) {
+        const groups = this.getBotGroups();
+        let userInfo;
+        for (const group of groups) {
+            if (group.usernameRegex && !this.anyRegexMatches(post.authorName, group.usernameRegex)) {
+                continue;
+            }
+            if (group.criteria) {
+                const negativePostConditions = this.collectNegatedPostConditionsForPreEvaluation(group.criteria);
+                let negativeConditionMatched = false;
+                for (const condition of negativePostConditions.filter(condition => condition.matchesNeeded === undefined || condition.matchesNeeded === 1)) {
+                    const conditionMatches = this.postMatchesCondition(post, condition);
+                    if (conditionMatches.matched) {
+                        negativeConditionMatched = true;
+                        break;
+                    }
+                }
+                if (negativeConditionMatched) {
+                    continue;
+                }
+                const postConditions = this.collectPostConditionsForPreEvalation(group.criteria);
+                if (!postConditions.some(condition => this.postMatchesCondition(post, condition).matched)) {
+                    continue;
+                }
+            }
+            ;
+            if (group.age || group.minCommentKarma || group.maxCommentKarma || group.minLinkKarma || group.maxLinkKarma || group.displayNameRegex || group.nsfw || group.hasRedditPremium || group.hasVerifiedEmail || group.isSubredditModerator) {
+                userInfo ?? (userInfo = await (0, utility_js_1.getAdditionalUserInfo)(post.authorName, this.context));
+                if (!userInfo) {
+                    continue;
+                }
+                if (group.age && !this.matchesAgeCriteria(userInfo.createdAt, group.age)) {
+                    continue;
+                }
+                if (group.minCommentKarma !== undefined && userInfo.commentKarma < group.minCommentKarma) {
+                    continue;
+                }
+                if (group.maxCommentKarma !== undefined && userInfo.commentKarma > group.maxCommentKarma) {
+                    continue;
+                }
+                if (group.minLinkKarma !== undefined && userInfo.linkKarma < group.minLinkKarma) {
+                    continue;
+                }
+                if (group.maxLinkKarma !== undefined && userInfo.linkKarma > group.maxLinkKarma) {
+                    continue;
+                }
+                if (group.bioRegex && (!userInfo.userDescription || !this.anyRegexMatches(userInfo.userDescription, group.bioRegex))) {
+                    continue;
+                }
+                if (group.displayNameRegex && (!userInfo.displayName || !this.anyRegexMatches(userInfo.displayName, group.displayNameRegex))) {
+                    continue;
+                }
+                if (group.nsfw !== undefined && userInfo.nsfw !== group.nsfw) {
+                    continue;
+                }
+                if (group.hasRedditPremium !== undefined && userInfo.hasRedditPremium !== group.hasRedditPremium) {
+                    continue;
+                }
+                if (group.hasVerifiedEmail !== undefined && userInfo.hasVerifiedEmail !== group.hasVerifiedEmail) {
+                    continue;
+                }
+                if (group.isSubredditModerator !== undefined && userInfo.isSubredditModerator !== group.isSubredditModerator) {
+                    continue;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    async accountMatchesSocialLinkCriteria(user, group) {
+        const matchReasons = [];
+        if (group.socialLinkRegex) {
+            const userSocialLinks = await this.getSocialLinks(user.username);
+            if (userSocialLinks.length === 0) {
+                return { matched: false };
+            }
+            const matchingSocialLink = userSocialLinks.find(userLink => group.socialLinkRegex && this.anyRegexMatches(userLink.outboundUrl, group.socialLinkRegex));
+            if (matchingSocialLink) {
+                matchReasons.push({ key: "socialLinkRegex", value: matchingSocialLink.outboundUrl });
+            }
+            else {
+                return { matched: false };
+            }
+        }
+        if (group.socialLinkTitleRegex) {
+            const userSocialLinks = await this.getSocialLinks(user.username);
+            if (userSocialLinks.length === 0) {
+                return { matched: false };
+            }
+            const matchingSocialLink = userSocialLinks.find(userLink => group.socialLinkTitleRegex && userLink.title && this.anyRegexMatches(userLink.title, group.socialLinkTitleRegex));
+            if (matchingSocialLink) {
+                matchReasons.push({ key: "socialLinkTitleRegex", value: matchingSocialLink.title });
+            }
+            else {
+                return { matched: false };
+            }
+        }
+        if (group.hasNoSocialLinks !== undefined) {
+            const userSocialLinks = await this.getSocialLinks(user.username);
+            const hasNoSocialLinks = userSocialLinks.length === 0;
+            if (group.hasNoSocialLinks !== hasNoSocialLinks) {
+                return { matched: false };
+            }
+        }
+        return { matched: true, reasons: matchReasons };
+    }
+    async accountMatchesGroup(user, group, evaluateSocialLinks = true) {
+        if (group.usernameRegex && !this.anyRegexMatches(user.username, group.usernameRegex)) {
+            return { matched: false };
+        }
+        if (group.matchesDefaultUsernameRegex !== undefined) {
+            const defaultUsernameRegex = /^(?:[A-Z][a-z]+[_-]?){2}\d{3,4}$/;
+            const matchesDefaultRegex = defaultUsernameRegex.test(user.username);
+            if (group.matchesDefaultUsernameRegex !== matchesDefaultRegex) {
+                return { matched: false };
+            }
+        }
+        if (group.age && !this.matchesAgeCriteria(user.createdAt, group.age)) {
+            return { matched: false };
+        }
+        if (group.maxCommentKarma && user.commentKarma > group.maxCommentKarma) {
+            return { matched: false };
+        }
+        if (group.maxLinkKarma && user.linkKarma > group.maxLinkKarma) {
+            return { matched: false };
+        }
+        if (group.minCommentKarma && user.commentKarma < group.minCommentKarma) {
+            return { matched: false };
+        }
+        if (group.minLinkKarma && user.linkKarma < group.minLinkKarma) {
+            return { matched: false };
+        }
+        if (group.nsfw !== undefined && user.nsfw !== group.nsfw) {
+            return { matched: false };
+        }
+        if (group.hasVerifiedEmail !== undefined && user.hasVerifiedEmail !== group.hasVerifiedEmail) {
+            return { matched: false };
+        }
+        if (group.hasRedditPremium !== undefined && user.isGold !== group.hasRedditPremium) {
+            return { matched: false };
+        }
+        if (group.isSubredditModerator !== undefined && user.isModerator !== group.isSubredditModerator) {
+            return { matched: false };
+        }
+        const matchReasons = [];
+        if (group.bioRegex) {
+            if (!user.userDescription) {
+                return { matched: false };
+            }
+            if (this.anyRegexMatches(user.userDescription, group.bioRegex)) {
+                matchReasons.push({ key: "bioRegex", value: user.userDescription });
+            }
+            else {
+                return { matched: false };
+            }
+        }
+        if (group.displayNameRegex) {
+            if (!user.displayName) {
+                return { matched: false };
+            }
+            if (this.anyRegexMatches(user.displayName, group.displayNameRegex)) {
+                matchReasons.push({ key: "displayNameRegex", value: user.displayName });
+            }
+            else {
+                return { matched: false };
+            }
+        }
+        if (evaluateSocialLinks) {
+            const socialLinkEvaluationResult = await this.accountMatchesSocialLinkCriteria(user, group);
+            if (!socialLinkEvaluationResult.matched) {
+                return { matched: false };
+            }
+            if (socialLinkEvaluationResult.reasons?.length) {
+                matchReasons.push(...socialLinkEvaluationResult.reasons);
+            }
+        }
+        return { matched: true, reasons: matchReasons };
+    }
+    async preEvaluateUser(user) {
+        const botGroups = this.getBotGroups();
+        for (const group of botGroups) {
+            const matches = await this.accountMatchesGroup(user, group);
+            if (matches.matched) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async historyMatchesCriteriaGroup(criteria, inNot = false) {
+        if ("not" in criteria) {
+            const matchesGroup = await this.historyMatchesCriteriaGroup(criteria.not, true);
+            return { matched: !matchesGroup.matched };
+        }
+        else if ("every" in criteria) {
+            // Check "not" groups first to allow for early exits before doing more expensive checks for reasons
+            const notCriteria = criteria.every.filter(subCriteria => "not" in subCriteria);
+            if (notCriteria.length > 0) {
+                const notMatches = await Promise.all(notCriteria.map(subCriteria => this.historyMatchesCriteriaGroup(subCriteria)));
+                if (notMatches.some(result => !result.matched)) {
+                    return { matched: false };
+                }
+            }
+            const matchReasons = [];
+            // Check remaining criteria.
+            const remainingCriteria = criteria.every.filter(subCriteria => !("not" in subCriteria));
+            for (const subCriteria of remainingCriteria) {
+                const criteriaResult = await this.historyMatchesCriteriaGroup(subCriteria);
+                if (!criteriaResult.matched) {
+                    return { matched: false };
+                }
+                if (criteriaResult.reasons) {
+                    matchReasons.push(...criteriaResult.reasons);
+                }
+            }
+            return { matched: true, reasons: matchReasons };
+        }
+        else if ("some" in criteria) {
+            const someMatch = await Promise.all(criteria.some.map(subCriteria => this.historyMatchesCriteriaGroup(subCriteria)));
+            if (!someMatch.some(result => result.matched)) {
+                return { matched: false };
+            }
+            return { matched: true, reasons: someMatch.filter(item => item.matched).flatMap(result => result.reasons ?? []) };
+        }
+        else if ("type" in criteria) {
+            const matches = [];
+            const subredditsMatched = new Set();
+            const matchesNeeded = criteria.matchesNeeded ?? 1;
+            const maxMatchesNeeded = Math.max(matchesNeeded, 5);
+            const distinctSubredditsNeeded = criteria.distinctSubsNeeded ?? 1;
+            if (criteria.type === "post") {
+                const posts = this.getPosts();
+                for (const post of posts) {
+                    if (subredditsMatched.size >= distinctSubredditsNeeded && matches.length >= maxMatchesNeeded) {
+                        break;
+                    }
+                    if (inNot && matches.length >= matchesNeeded && subredditsMatched.size >= distinctSubredditsNeeded) {
+                        break;
+                    }
+                    const matchResult = this.postMatchesCondition(post, criteria);
+                    if (matchResult.matched) {
+                        matches.push(matchResult);
+                        subredditsMatched.add(post.subredditName);
+                    }
+                }
+            }
+            else { // comments
+                const comments = this.getComments();
+                const currentSubreddit = this.context.subredditName ?? await this.context.reddit.getCurrentSubredditName();
+                for (const comment of comments) {
+                    if (subredditsMatched.size >= distinctSubredditsNeeded && matches.length >= maxMatchesNeeded) {
+                        break;
+                    }
+                    if (inNot && matches.length >= matchesNeeded && subredditsMatched.size >= distinctSubredditsNeeded) {
+                        break;
+                    }
+                    const matchResult = await this.commentMatchesCondition(comment, criteria, this.history);
+                    if (matchResult.matched) {
+                        matches.push(matchResult);
+                        const subredditName = "subredditName" in comment ? comment.subredditName : currentSubreddit;
+                        subredditsMatched.add(subredditName);
+                    }
+                }
+            }
+            if (matches.length < matchesNeeded) {
+                return { matched: false };
+            }
+            if (subredditsMatched.size < distinctSubredditsNeeded) {
+                return { matched: false };
+            }
+            return { matched: true, reasons: this.uniqueMatchReasons(matches.flatMap(result => result.reasons ?? [])) };
+        }
+        return { matched: false }; // Default case, no specific conditions
+    }
+    logEvaluationTime(startTime, username, groupName) {
+        if (!this.verboseLogging) {
+            return;
+        }
+        const endTime = Date.now();
+        if (endTime - startTime > 500) {
+            console.log(`Evaluation for user ${username} and group took ${endTime - startTime} ms "${groupName}"`);
+        }
+    }
+    setSubmitterName(submitterName) {
+        this.submitterName = submitterName;
+    }
+    async evaluate(user) {
+        const botGroups = this.getBotGroups();
+        for (const group of botGroups) {
+            const startTime = Date.now();
+            if (group.submitterName !== undefined) {
+                if (this.submitterName === undefined) {
+                    continue;
+                }
+                const validSubmitterNames = new Set(Array.isArray(group.submitterName) ? group.submitterName : [group.submitterName]);
+                if (!validSubmitterNames.has(this.submitterName)) {
+                    continue;
+                }
+            }
+            const accountMatches = await this.accountMatchesGroup(user, group, false);
+            if (!accountMatches.matched) {
+                this.logEvaluationTime(startTime, user.username, group.name);
+                continue;
+            }
+            const matchReasons = [...(accountMatches.reasons ?? [])];
+            if (group.criteria) {
+                const historyMatchesGroup = await this.historyMatchesCriteriaGroup(group.criteria);
+                if (!historyMatchesGroup.matched) {
+                    this.logEvaluationTime(startTime, user.username, group.name);
+                    continue;
+                }
+                matchReasons.push(...(historyMatchesGroup.reasons ?? []));
+            }
+            const socialLinksMatches = await this.accountMatchesSocialLinkCriteria(user, group);
+            if (!socialLinksMatches.matched) {
+                this.logEvaluationTime(startTime, user.username, group.name);
+                continue;
+            }
+            else {
+                matchReasons.push(...(socialLinksMatches.reasons ?? []));
+            }
+            if (group.hasMoreThanOneCommentOnPosts !== undefined) {
+                const comments = this.getComments();
+                const commentCounts = (0, lodash_1.countBy)(comments.map(comment => comment.postId));
+                const hasMultipleComments = Object.values(commentCounts).some(count => count > 1);
+                if (group.hasMoreThanOneCommentOnPosts !== hasMultipleComments) {
+                    this.logEvaluationTime(startTime, user.username, group.name);
+                    continue;
+                }
+            }
+            this.addHitReason({ reason: group.name, details: this.uniqueMatchReasons(matchReasons) });
+            this.logEvaluationTime(startTime, user.username, group.name);
+        }
+        if (this.evaluationError) {
+            console.error(`Evaluation error for user ${user.username}: ${this.evaluationError}`);
+        }
+        if (this.verboseLogging && this.postPropertiesStatistics.totalTime > 1000) {
+            console.log(`Post properties fetching statistics for user ${user.username}:`, this.postPropertiesStatistics);
+        }
+        return this.hitReasons !== undefined && this.hitReasons.length > 0;
+    }
+}
+exports.EvaluateBotGroupAdvanced = EvaluateBotGroupAdvanced;