Chaturbate

Bots Home | Create an App
SBC Gray Limiter w/[LEAK] Block
Author: salserobachaterocasinero
Description Source Code Launch Bot Current Users
/* [BOT]

Title: "SBC Gray Limiter w/[LEAK] Block"
Version 1.0.0 (3/2/2016)
Author: SalseroBachateroCasinero

This bot presents multiple gray limiting features, including disabling of:

- ":" Graphics
- Demand Terms
- Private Message or Cam Request Terms
- Spam Terms
- Rude Terms
- Obsessive Terms
- Fetish Terms
- Foreign Characters (Option to Override and Allow Spanish Letters/Accents/Punctuation Specifically)
- Sticky Keys (3+ Repeated Characters)
- CAPITALIZED Words (Single Word or Entire Message)

Included is an automatic "Token Generator" spam blocker (simply based on "[LEAK]" and "[LEAKED]") with a notice to broadcaster/moderators for manual booting of user from room if desired. Nothing is shown in chat when these words are detected, so it's never an issue should you just decide to ignore the notices.

Type '/sbc-gl toggle' to turn this bot on or off.
Type '/sbc-gl status' to check whether the bot is currently running or not.
Type '/sbc-mltm moderators' to toggle command access for all moderators for the current session. <Broadcaster Only>
Type '/sbc-mltm access' to list the users who currently have command access for the current session. <Broadcaster Only>
Type '/sbc-mltm access +[U]' or '/sbc-mltm access -[U]' to respectively grant or revoke command access to a specific user for the current session (where [U] is the user's chat name). <Broadcaster Only>
Type '/sbc-gl stats' to view the running time and number of muted violations for the current session. <Broadcaster Only>
Type '/sbc-gl help' if you forget the above commands.

*/


var Code = {
    Name    : "SBC Gray Limiter w/[LEAK] Block", // The name of the bot
    Version : "1.0.0 (3/2/2016)",                // The current version of the bot
    Author  : "SalseroBachateroCasinero",        // The author of this version of the bot
        // Don't change the author unless you've modified something!
    Command : "sbc-gl"                           // The "/" command of the bot
};


/* ************************************************** */
var Debug = { Mode : false, Count : 1, Verbose : false };
/* ************************************************** */

var ShowDebugMessage = function (out) {
    if (Debug.Mode) {
        out = out.trim();
        output = '<{{0}}> Debug ~ {{1}}: ';
        output = output.toReplace(String(Debug.Count).toPad(2), Code.Name);
        if (out.charAt(0) == '*') {
            cb.sendNotice(output + String(out.substring(1).trim()), Code.Author.toLowerCase(), '#FFFFFF', '#FF0000', 'bolder');
            Debug.Count++;
        } else if (Debug.Verbose) {
            cb.sendNotice(output + String(out), Code.Author.toLowerCase(), '#FFFFFF', '#7F0000', 'bolder');
            Debug.Count++;
        };
    };
    return Debug.Mode;
};


String.prototype.toReplace = function () {
    var newString = String(this);
    for (idx=0;idx<arguments.length;idx++) {
        newString = newString.replace('{{' + idx + '}}', arguments[idx]);
    };
    return String(newString);
};

String.prototype.toLowerCaseTrim = function () {
    return String(this).toLowerCase().trim();
};

String.prototype.toPad = function (digits) {
    var newString = String(this);
    while (newString.length < digits) {
        newString = '0' + newString;
    };
    return newString;
};

Array.prototype.toCheckIfExists = function (what) {
    for (i=0;i<this.length;i++) {
        if (this[i] == what) {
            return true;
        }
    }
};

Array.prototype.toAddAndSort = function (what) {
    this.push(what);
    this.sort();
};

Array.prototype.toRemoveAndSort = function (what) {
    for (i=this.length-1;i>=0;i--) {
        if (this[i] == what) {
            this.splice(i, 1);
        }
    }
    this.sort();
};


var Identification = '{{0}} v{{1}} by {{2}}'.toReplace(Code.Name, Code.Version, Code.Author);

var FormatCommand = function (info,doublespace) {
    var newString = "Type '/{{0}} {{1}}" + '\n';
    if (doublespace) { newString += '\n'; };
    return String(newString.toReplace(Code.Command, info));
};

var Command = {
    Toggle        : 'toggle',
    Status        : 'status',
    Access        :
    {
        Moderator : 'moderators',
        Usage     : 'access',
        Grant     : '+',
        Revoke    : '-'
    },
    Stats         : 'stats',
    Help          : 'help'
};

var CommandList  = '\n';

    CommandList += FormatCommand("{{0}}' to toggle this bot on or off.".toReplace(Command.Toggle), true);

    CommandList += FormatCommand("{{0}}' to check whether the bot is currently running or not.".toReplace(Command.Status), true);

    CommandList += FormatCommand("{{0}}' to toggle command access for all moderators for the current session. <Broadcaster Only>".toReplace(Command.Access.Moderator), true);

    CommandList += FormatCommand("{{0}}' to list the users who currently have command access for the current session. <Broadcaster Only>".toReplace(Command.Access.Usage), false);
    CommandList += FormatCommand("{{0}} {{1}}[U]' or '/{{2}} {{3}} {{4}}[U]' to respectively grant or revoke command access to a specific user for the current session (where [U] is the user's chat name). <Broadcaster Only>".toReplace(Command.Access.Usage, Command.Access.Grant, Code.Command, Command.Access.Usage, Command.Access.Revoke), true);

    CommandList += FormatCommand("{{0}}' to view the running time and number of muted violations for the current session. <Broadcaster Only>".toReplace(Command.Stats), true);

    CommandList += FormatCommand("{{0}}' if you forget the above commands.".toReplace(Command.Help), false);

var HelpNotification  = '\n' + '*** {{0}} ***' + '\n';
    HelpNotification += '{{1}}';
    HelpNotification  = HelpNotification.toReplace(Identification, CommandList);


cb.settings_choices = [
    {
        name         : 'support',
        type         : 'choice',
        label        : "Enable support mode?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'No'
    },
    {
        name         : 'moderation',
        type         : 'choice',
        label        : "Allow moderators to access this feature?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes'
    },
    {
        name         : 'alwaysallowedusers',
        type         : 'str',
      required: false,
        label        : 'List of users that will have feature access at all times, regardless of moderator status or the previous question (separate with ; for more than 1 or leave blank for none)',
        defaultValue : ''
    },
    {
        name         : 'noticebackground',
        type         : 'str',
        label        : 'Notification background color in hex #RrGgBb format (default is white / #FFFFFF)',
        defaultValue : '#FFFFFF'
    },
    {
        name         : 'noticetext',
        type         : 'str',
        label        : 'Notification text color in hex #RrGgBb format (default is red / #FF0000)',
        defaultValue : '#FF0000'
    },
    {
        name         : 'noticeweight',
        type         : 'choice',
        label        : 'Notification weight',
        choice1      : 'Normal',
        choice2      : 'Bold',
        choice3      : 'Bolder',
        defaultValue : 'Bolder'
    },
    {
        name         : 'graylimitdefault',
        type         : 'choice',
        label        : "Enable gray-limiting features to hinder chat abuse by default?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes'
    },
    {
        name         : 'recentgraymode',
        type         : 'choice',
        label        : "Treat grays who have tipped recently (who have run out of tokens recently) as if they aren't gray?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes'
    },
    {
        name         : 'msgonentry',
        type         : 'choice',
        label        : "Display warning to grays on entry (set to 'no' for busy rooms)?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes'
    },
    {
        name         : 'mutehide',
        type         : 'choice',
        label        : "Mute (replaces message with 'muted' version) or hide (does not show at all) a violating message?",
        choice1      : 'Mute',
        choice2      : 'Hide',
        defaultValue : 'Hide'
    },
    {
        name         : 're_tokengen',
        type         : 'choice',
        label        : "Target 'Token Generator' Spam Specifically (e.g. [LEAK], [LEAKED], etc.)?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes'
    },
    {
        name         : 're_l33t',
        type         : 'choice',
        label        : "Translate common 'l33t' style characters (e.g. @$$ = ass, p0rn = porn, 80085 = boobs, etc. -- recommended to prevent popular cheating tricks)?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes'
    },
    {
        name         : 're0',
        type         : 'choice',
        label        : "Process ':' graphics (e.g. :deepthroat)?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes'
    },
    {
        name         : 're8',
        type         : 'choice',
        label        : "Process sticky keys (3+ repeating characters eg. mmmm)?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes'
    },
    {
        name         : 're9',
        type         : 'choice',
        label        : "Process yelling/emphasis (words in ALL CAPS)?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes'
    },
    {
        name         : 're9_mode',
        type         : 'choice',
        label        : "Any word or whole message mode for ALL CAPS?",
        choice1      : 'Any Word',
        choice2      : 'Whole Message',
        defaultValue : 'Any Word'
    },
    {
        name         : 'rex',
        type         : 'choice',
        label        : "For best results, use lowercase letters, digits, and single spaces only per block list term below. Use a '.' as a wildcard replacement for any single letter (e.g. 17f/18f/19f/etc. = 1.f / use 's?' for simple plural specification e.g. boob/boobs = boobs? / complicated plurals must be separately listed e.g. boobs?|bitch|bitches|foot|feet)",
        choice1      : 'N/A',
        defaultValue : 'N/A'
    },
    {
        name         : 're1',
        type         : 'choice',
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes',
        label        : "Process demand terms?"
    },
    {
        name         : 're1_terms',
        type         : 'str',
        required     : false,
        label        : "Demand terms block list (separate with | for more than 1)",
        defaultValue : "pleases?|plz|pls|opens?|view?|shows?|zooms?|sees?|body|bodies|dances?|twerks?|kiss|kisses|faces?|touch|touches|mast.rbates?|strokes?|balls?|cocks?|dicks?|penis|penises|dildos?|vibrators?|sucks?|licks?|bjs?|blows?|blowjobs?|deep|throats?|deepthroats?|selfsucks?|cums?|shots?|cumshots?|facials?|swallows?|snowballs?|spits?|eats?|boobs?|bobs?|tits?|nipples?|squirts?|pussy|pussies|vaginas?|clits?|clitoris|sex|sexx|sexxx|f.cks?|doggy|doggie|rims?|rimjobs?|spanks?|spreads?|ass|asses|assholes?|anal"
    },
    {
        name         : 're2',
        type         : 'choice',
        label        : "Process private message and cam request terms?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes'
    },
    {
        name         : "re2_terms",
        type         : 'str',
        required     : false,
        label        : "Request term block list (separate with | for more than 1)",
        defaultValue : "pm|privates?|pvts?|privets?|c2c|cams?|shares?|msgs?|myspace|fb|facebook|snaps?|snapchat|kik"
    },
    {
        name         : 're3',
        type         : 'choice',
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes',
        label        : "Process spam terms?"
    },
    {
        name         : 're3_terms',
        type         : 'str',
        required     : false,
        label        : "Spam term block list (separate with | for more than 1)",
        defaultValue : "porns?|prons?|pornos?|pronos?|streamingnaked|1.f|2.f|1.fcam|2.fcam|1. female|2. female|1.female|2. female|erotimo|amecam|goo|mybio|myprofile|swipegirls|freecambook|dotcom|dot com"
    },
    {
        name         : 're4',
        type         : 'choice',
        label        : "Process rude terms?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes'
    },
    {
        name         : 're4_terms',
        type         : 'str',
        required     : false,
        label        : "Rude term block list (separate with | for more than 1)",
        defaultValue : "cunts?|bitch|bitches|sluts?|whores?|ugly|fat|pees?|peeing|poos?|poops?|pooping|fists?|fisting|farts?|farting|kiddies?|bestiality|animals?|fags?|homos?|gays?|losers?"
    },
    {
        name         : 're5',
        type         : 'choice',
        label        : "Process obsessive terms?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes'
    },
    {
        name         : 're5_terms',
        type         : 'str',
        required     : false,
        label        : "Obsessive term block list (separate with | for more than 1)",
        defaultValue : "bb|baby|daddy|sexy|sexxy|sexxxy"
    },
    {
        name         : 're6',
        type         : 'choice',
        label        : "Process fetish terms?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes'
    },
    {
        name         : 're6_terms',
        type         : 'str',
        required     : false,
        label        : "Fetish term block list (separate with | for more than 1)",
        defaultValue : "foot|feet|soles?|toes?|heels?|milfs?|versatile"
    },
    {
        name         : 're7',
        type         : 'choice',
        label        : "Process non-English characters (Cyrillic, Arabic, Chinese, Accented)?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'Yes'
    },
    {
        name         : 're7_spanish',
        type         : 'choice',
        label        : "Allow Spanish characters (accented, punctuation, etc.)?",
        choice1      : 'Yes',
        choice2      : 'No',
        defaultValue : 'No'
    }
];


var Settings = {
    SupportMode          : cb.settings['support'] == 'Yes',

    // Moderators "Allowed" To Use This? //
    ModeratorsAllowed    : cb.settings['moderation'] == 'Yes',
    // Moderators "Allowed" To Use This? //

    // Users "Always Allowed" To Use This //
    AlwaysAllowedUsers   : cb.settings['alwaysallowedusers'] == null ? []
                                                                     : cb.settings['alwaysallowedusers'].length == 0 ? []
                                                                                                                     : cb.settings['alwaysallowedusers'].split(';'),
    // Users "Always Allowed" To Use This //

    NotificationStyle    :
    {
        Background       : cb.settings['noticebackground'],
        Text             : cb.settings['noticetext'],
        Weight           : cb.settings['noticeweight']
    },
    GrayLimiterStatus    : cb.settings['graylimitdefault'] == 'Yes',
    RecentGrayMode       : cb.settings['recentgraymode'] == 'Yes',
    MessageOnEntryStatus : cb.settings['msgonentry'] == 'Yes',
    ViolationResponse    : cb.settings['mutehide']  == 'Hide',
    DoSpamCheck          : cb.settings['re_tokengen'] == 'Yes',
    Dol33tCheck          : cb.settings['re_l33t'] == 'Yes',
    DoSpanishCheck       : cb.settings['re7_spanish'] == 'Yes',
    DoTestCheck          : [],
    Terms                : [],
    CAPSMode             : cb.settings['re9_mode'] == 'Whole Message'
};

for (i=0;i<=9;i++) {
    Settings.DoTestCheck[i] = cb.settings['re'+i] == 'Yes';
};

for (i=1;i<=6;i++) {
    Settings.Terms[i] = cb.settings['re'+i+'_terms'];
};


Settings.AlwaysAllowedUsers.sort();

var ShowUserAccessList = function () {
    output = '\n' + "All users with command access for the current session:";

    var usernames = '';
    for (i=0;i<Settings.AlwaysAllowedUsers.length;i++) {
        usernames += '\n' + ' * {{0}}';
        usernames  = usernames.toReplace(Settings.AlwaysAllowedUsers[i]);
    };
    output += usernames == '' ? ' [NONE]'
                              : usernames;

    output += '\n';

    SendTo.Default(output, CurrentUser);
};

var SetUserAccess = function (doadd, user) {
    if (doadd) {
        if (!(Settings.AlwaysAllowedUsers.toCheckIfExists(user))) { // Add (By Explicit Command), But Only If User Doesn't Already Exist In List
            Settings.AlwaysAllowedUsers.toAddAndSort(user);
        };
    } else {
        if (Settings.AlwaysAllowedUsers.toCheckIfExists(user)) { // Remove (By Explicit Command), But Only If User Already Exists In List
            Settings.AlwaysAllowedUsers.toRemoveAndSort(user);
        };
    };
};


var Moderators = [];

var SetModeratorStatus = function (msg) {
    if (UserIs.Moderator(msg)) {
        if (!(Moderators.toCheckIfExists(CurrentUser))) { // Add If Moderator, But Only If User Doesn't Already Exist In List
            Moderators.toAddAndSort(CurrentUser);
        };
    } else {
        if (Moderators.toCheckIfExists(CurrentUser)) { // Remove If No Longer Moderator, But Only If User Already Exists In List
            Moderators.toRemoveAndSort(CurrentUser);
        };
    };
};


var Broadcaster = {
    Actual : cb['room_slug'],
    Active : (Settings.SupportMode ? Code.Author.toLowerCase()
                                   : cb['room_slug'])
};

var CurrentUser = '';


var UserIs = [];

    // User Specified Is The Current User //
    UserIs.ThisUser = function (CompareUser) {
        return CurrentUser == CompareUser;
    };
    // User Specified Is The Current User //

    // User Is The Author //
    UserIs.Author = function () {
        return UserIs.ThisUser(Code.Author.toLowerCase());
    };
    // User Is The Author //

    // User Is The Actual Broadcaster //
    UserIs.ActualBroadcaster = function () {
        return UserIs.ThisUser(Broadcaster.Actual);
    };
    // User Is The Actual Broadcaster //

    // User Is The Active Broadcaster (Spoofed To Author When Support Mode Is Active) //
    UserIs.ActiveBroadcaster = function () {
        return UserIs.ThisUser(Broadcaster.Active);
    };
    // User Is The Active Broadcaster (Spoofed To Author When Support Mode Is Active) //

    // User Exists In The "Always-Allowed Users" List //
    UserIs.AlwaysAllowed = function () {
        if (Settings.SupportMode && UserIs.ActualBroadcaster()) {
            return true;
        };
        return Settings.AlwaysAllowedUsers.toCheckIfExists(CurrentUser);
    };
    // User Exists In The "Always-Allowed Users" List //

    // User Is An "Allowed" Moderator //
    UserIs.AllowedModerator = function (msg) {
        return (UserIs.Moderator(msg) && Settings.ModeratorsAllowed);
    };
    // User Is An "Allowed" Moderator //

    // User Is A Moderator //
    UserIs.Moderator = function (msg) {
        return msg['is_mod'];
    };
    // User Is A Moderator //

    // User Is A Fan Club Member //
    UserIs.FanClubMember = function (msg) {
        return msg['in_fanclub'];
    };
    // User Is A Fan Club Member //

    // User Is A Super Tipper //
    UserIs.SuperTipper = function (msg) {
        return msg['tipped_tons_recently'];
    };
    // User Is A Super Tipper //

    // User Is A Big Tipper //
    UserIs.BigTipper = function (msg) {
        return msg['tipped_alot_recently'];
    };
    // User Is A Big Tipper //

    // User Is A Tipper //
    UserIs.Tipper = function (msg) {
        return msg['tipped_recently'];
    };
    // User Is A Tipper //

    // User Is A Token Owner //
    UserIs.TokenOwner = function (msg) {
        return msg['has_tokens'];
    };
    // User Is A Token Owner //

    // User Is Gray //
    UserIs.Gray = function (user) {
        GrayMode = false;
        if (Settings.RecentGrayMode) { // Ignore Gray Status If User Is A Recent Tipper
            GrayMode = UserIs.Tipper(user);
        };
        return ((!(GrayMode)) && (!(UserIs.TokenOwner(user))) && (!(UserIs.FanClubMember(user))) && (!(UserIs.Moderator(user))) && (!(UserIs.AlwaysAllowed())) && (!(UserIs.Author())) && (!(UserIs.ActualBroadcaster())));
    };
    // User Is Gray //


var SendTo = [];

    // Send Notice To User/Group As Indicated //
    SendTo.Default = function (msg,user,group) {
        if (group == null || group == '') {
            cb.sendNotice(msg, user, Settings.NotificationStyle.Background, Settings.NotificationStyle.Text, Settings.NotificationStyle.Weight);
        } else {
            cb.sendNotice(msg, user, Settings.NotificationStyle.Background, Settings.NotificationStyle.Text, Settings.NotificationStyle.Weight, group);
        };
    };
    // Send Notice To User/Group As Indicated //

    // Send Notice To "Important" Users //
    SendTo.ImportantUsers = function (msg) {

        // Send Notice To Actual Broadcaster //
        SendTo.Default(msg, Broadcaster.Actual);
        var TestForAuthor = Broadcaster.Actual == Code.Author.toLowerCase();
        // Send Notice To Actual Broadcaster //

        // Send Notice To "Moderators" (Array-Based) ~ As Long As They Aren't On The "Always-Allowed Users" List //
        for (i=0;i<Moderators.length;i++) {
            if (!(Settings.AlwaysAllowedUsers.toCheckIfExists(Moderators[i]))) {
                SendTo.Default(msg, Moderators[i]);
            };
            if (!(TestForAuthor)) { TestForAuthor = Moderators[i] == Code.Author.toLowerCase(); };
        }
        // Send Notice To "Moderators" (Array-Based) ~ As Long As They Aren't On The "Always-Allowed Users" List //

        // Send Notice To "Always-Allowed Users" //
        for (i=0;i<Settings.AlwaysAllowedUsers.length;i++) {
            SendTo.Default(msg, Settings.AlwaysAllowedUsers[i].toLowerCaseTrim());
            if (!(TestForAuthor)) { TestForAuthor = Settings.AlwaysAllowedUsers[i] == Code.Author.toLowerCase(); };
        };
        // Send Notice To "Always-Allowed Users" //

        // Send Notice To Author //
        if (Settings.SupportMode && (!(TestForAuthor))) {
            SendTo.Default(msg, Code.Author.toLowerCase());
        };
        // Send Notice To Author //

    };
    // Send Notice To "Important" Users //

    // Send Notice To "Always-Allowed Users" //
    SendTo.AlwaysAllowedUsers = function (msg,bg,fg,wt) {
        for (i=0;i<Settings.AlwaysAllowedUsers.length;i++) {
            cb.sendNotice(msg, Settings.AlwaysAllowedUsers[i].toLowerCaseTrim(), bg, fg, wt);
        }
    };
    // Send Notice To "Always-Allowed Users" //

    // Send Notice To "Moderators" (Array-Based) //
    SendTo.Moderators = function (msg,bg,fg,wt) {
        for (i=0;i<Moderators.length;i++) {
            cb.sendNotice(msg, Moderators[i], bg, fg, wt);
        }
    };
    // Send Notice To "Moderators" (Array-Based) //

    // Send Special Case //
    SendTo.Special = function (msg,user,group) {
        cb.sendNotice(msg, user, '#FFFFFF', '#FF0000', 'bolder', group);
    };
    // Send Special Case //

    // Send Inverse Notice To Broadcaster, Moderators (If "Allowed"), And "Always-Allowed Users" List //
    SendTo.InverseImportantUsers = function (msg) {

        // Send Notice To Actual Broadcaster //
        cb.sendNotice(msg, Broadcaster.Actual, '#FF0000', '#FFFFFF', 'bolder');
        var TestForAuthor = Broadcaster.Actual == Code.Author.toLowerCase();
        // Send Notice To Actual Broadcaster //

        // Send Notice To "Moderators" (Array-Based) ~ As Long As They Aren't On The "Always-Allowed Users" List //
        for (i=0;i<Moderators.length;i++) {
            if (!(Settings.AlwaysAllowedUsers.toCheckIfExists(Moderators[i]))) {
                cb.sendNotice(msg, Moderators[i], '#FF0000', '#FFFFFF', 'bolder');
            };
            if (!(TestForAuthor)) { TestForAuthor = Moderators[i] == Code.Author.toLowerCase(); };
        }
        // Send Notice To "Moderators" (Array-Based) ~ As Long As They Aren't On The "Always-Allowed Users" List //

        // Send Notice To "Always-Allowed Users" //
        for (i=0;i<Settings.AlwaysAllowedUsers.length;i++) {
            cb.sendNotice(msg, Settings.AlwaysAllowedUsers[i].toLowerCaseTrim(), '#FF0000', '#FFFFFF', 'bolder');
            if (!(TestForAuthor)) { TestForAuthor = Settings.AlwaysAllowedUsers[i] == Code.Author.toLowerCase(); };
        };
        // Send Notice To "Always-Allowed Users" //

        // Send Notice To Author //
        if (Settings.SupportMode && (!(TestForAuthor))) {
            cb.sendNotice(msg, Code.Author.toLowerCase(), '#FF0000', '#FFFFFF', 'bolder');
        };
        // Send Notice To Author //

    };
    // Send Inverse Notice To Broadcaster, Moderators (If "Allowed"), And "Always-Allowed Users" List //


// Feature Functions //
var Feature = [];

// Gray Limiter Feature //
var TheReasons = [
    {
        notice  : 'at least one graphic',
        message : 'graphics',
        check   : new RegExp(':\\b'),
        index   : 0
    },
    {
        notice  : 'at least one demand term',
        message : 'demands',
        check   : new RegExp('(?=.*\\b({{0}})\\b)'.toReplace(Settings.Terms[1]),'i'),
        index   : 1
    },
    {
        notice  : 'at least one private message or cam request term',
        message : 'private message or cam requests',
        check   : new RegExp('(?=.*\\b({{0}})\\b)'.toReplace(Settings.Terms[2]),'i'),
        index   : 2
    },
    {
        notice  : 'at least one spam term',
        message : 'spam',
        check   : new RegExp('(?=.*\\b({{0}})\\b)'.toReplace(Settings.Terms[3]),'i'),
        index   : 3
    },
    {
        notice  : 'at least one rude term',
        message : 'rudeness',
        check   : new RegExp('(?=.*\\b({{0}})\\b)'.toReplace(Settings.Terms[4]),'i'),
        index   : 4
    },
    {
        notice  : 'at least one obsessed term',
        message : 'obsessiveness',
        check   : new RegExp('(?=.*\\b({{0}})\\b)'.toReplace(Settings.Terms[5]),'i'),
        index   : 5
    },
    {
        notice  : 'at least one fetish term',
        message : 'fetishism',
        check   : new RegExp('(?=.*\\b({{0}})\\b)'.toReplace(Settings.Terms[6]),'i'),
        index   : 6
    },
    {
        notice  : 'at least one non-English character',
        message : 'foreign characters',
        check   : new RegExp('([^\\u0020-\\u007E]+)'),
        index   : 7
    },
    {
        notice  : 'sticky keys',
        message : 'sticky keys (3+ repeated characters)',
        check   : new RegExp('(.)\\1{2}'),
        index   : 8
    },
    {
        notice  : 'at least one word in ALL CAPS',
        message : 'CAPITALIZED words (no yelling! no emphasis!)',
        check   : new RegExp('\\b[A-Z]{2,}\\b'),
        index   : 9
    }
];

// Regular Characters + ¡ ¿ Á Ç É Í Ó Ú Ü á é í ó ú ü
if (Settings.DoSpanishCheck) { TheReasons[7].check = '([^\\u0020-\\u007E\\u00A1\\u00BF\\u00C1\\u00C7\\u00C9\\u00CD\\u00D1\\u00D3\\u00DA\\u00DC\\u00E1\\u00E7\\u00E9\\u00ED\\u00F1\\u00F3\\u00FA\\u00FC]+)'; };
// Regular Characters + ¡ ¿ Á Ç É Í Ó Ú Ü á é í ó ú ü

// ALL CAPS Mode Check //
if (Settings.CAPSMode) { TheReasons[9].notice = 'ALL CAPS'; TheReasons[9].message = 'CAPITALIZED messages (no yelling! no emphasis!)'; };
// ALL CAPS Mode Check //

var TotalChecks = TheReasons.length;

var ProcessMessage = false;
var Violation = '';

    Feature.GrayLimiter = function (msg) {

/* ************************************************** */
ShowDebugMessage("* Feature.GrayLimiter(msg)");
/* ************************************************** */

      // Grays Only! //
      if (UserIs.Gray(msg) && (!(UserIs.ActiveBroadcaster()))) {

/* ************************************************** */
ShowDebugMessage("User Is Gray & Not The Broadcaster");
/* ************************************************** */

        ProcessMessage = false;

        // Token Spam //
        if (Settings.DoSpamCheck) {

/* ************************************************** */
ShowDebugMessage("Token Spam?");
/* ************************************************** */

          if (Feature.GrayLimiterTokenSpamCheck(msg)) {

/* ************************************************** */
ShowDebugMessage("Token Spam!");
/* ************************************************** */

              ProcessMessage = true;
              Utility.HideMessageFromChatRoom(msg);
              output  = '\n' + "*** Probable 'token generator spam' sent by {{0}} (automatically hidden from chat, but you might still want to kick the person out). ***" + '\n';
              output += '\n' + "Original message (for manual inspection/verification prior to booting user: {{1}}" + '\n';
              output  = output.toReplace(CurrentUser, msg['m']);
              SendTo.InverseImportantUsers(output);
          };
        };
        // Token Spam //

        // Not Token Spam //
        if (!(ProcessMessage)) {

/* ************************************************** */
ShowDebugMessage("Testing!");
/* ************************************************** */

          var OriginalMessage = msg['m'];

/* ************************************************** */
ShowDebugMessage("ProcessMessage=" + ProcessMessage);
/* ************************************************** */

          // Spanish Override For Foreign Character Filter //
          if (Settings.DoSpanishCheck) { // "Spanish Accents" Allowed, So Convert Before Stripping
            OriginalMessage = OriginalMessage.replace(/\u00C1/g, 'A'); OriginalMessage = OriginalMessage.replace(/\u00E1/g, 'a');
            OriginalMessage = OriginalMessage.replace(/\u00C7/g, 'C'); OriginalMessage = OriginalMessage.replace(/\u00E7/g, 'c');
            OriginalMessage = OriginalMessage.replace(/\u00C9/g, 'E'); OriginalMessage = OriginalMessage.replace(/\u00E9/g, 'e');
            OriginalMessage = OriginalMessage.replace(/\u00CD/g, 'I'); OriginalMessage = OriginalMessage.replace(/\u00ED/g, 'i');
            OriginalMessage = OriginalMessage.replace(/\u00D1/g, 'N'); OriginalMessage = OriginalMessage.replace(/\u00F1/g, 'n');
            OriginalMessage = OriginalMessage.replace(/\u00D3/g, 'O'); OriginalMessage = OriginalMessage.replace(/\u00F3/g, 'o');
            OriginalMessage = OriginalMessage.replace(/\u00DA/g, 'U'); OriginalMessage = OriginalMessage.replace(/\u00FA/g, 'u');
            OriginalMessage = OriginalMessage.replace(/\u00DC/g, 'U'); OriginalMessage = OriginalMessage.replace(/\u00FC/g, 'u');
          };
          // Spanish Override For Foreign Character Filter //

          // Process Filters (For Loop) //
          var Reason;
          var TestMessage = '';

          for (i=0;i<=TotalChecks;i++) {
            if (Settings.DoTestCheck[i]) {
                if (!(Reason == null)) { break; };

                if (!(ProcessMessage)) {
                    TestMessage = OriginalMessage;

                    // ":" Graphic Tokenization To Process Remaining Filters Correctly //
                    if (!(i == 0)) { TestMessage = TestMessage.replace(/:/g, 'ZyXw'); };
                    // ":" Graphic Tokenization To Process Remaining Filters Correctly //

                    // Disabled To Allow For Foreign Character Filter //
                    // TestMessage = TestMessage.replace(/[^\w\s\:]/g, ''); // Strip Non-Standard Characters
                    // Disabled To Allow For Foreign Character Filter //

                    TestMessage = TestMessage.replace(/\s+/g, ' ');

/* ************************************************** */
ShowDebugMessage("TestMessage -> Message=" + TestMessage);
/* ************************************************** */

                    Reason = Feature.GrayLimiterMessageCheck(TestMessage, i);
                };

                // "l33t" Check //
                if (Settings.Dol33tCheck) {

                    if (!(ProcessMessage)) {
                        TestMessage = OriginalMessage;

                        TestMessage = TestMessage.replace(/4|\@/g,        'A');
                        TestMessage = TestMessage.replace(/8/g,           'B');
                        TestMessage = TestMessage.replace(/3/g,           'E');
                        TestMessage = TestMessage.replace(/1|\!|\u00A1/g, 'I');
                        TestMessage = TestMessage.replace(/0/g,           'O');
                        TestMessage = TestMessage.replace(/5|\$/g,        'S');
                        TestMessage = TestMessage.replace(/7/g,           'T');

                        // ":" Graphic Tokenization To Process Remaining Filters Correctly //
                        if (!(i == 0)) { TestMessage = TestMessage.replace(/:/g, 'ZyXw'); };
                        // ":" Graphic Tokenization To Process Remaining Filters Correctly //

                        // Disabled To Allow For Foreign Character Filter //
                        // TestMessage = TestMessage.replace(/[^\w\s\:]/g, ''); // Strip Non-Standard Characters
                        // Disabled To Allow For Foreign Character Filter //

                        TestMessage = TestMessage.replace(/\s+/g, ' ');

/* ************************************************** */
ShowDebugMessage('"l33t" Check TestMessage -> Message=' + TestMessage);
/* ************************************************** */

                        Reason = Feature.GrayLimiterMessageCheck(TestMessage, i);
                    };

                };
                // "l33t" Check //
            };

          };
          // Process Filters (For Loop) //

          // Block Unwanted Content! //
          if (ProcessMessage) {
              output  = '\n' + ':nograyhammer' + '\n';
              if (Settings.ViolationResponse) {
                  Utility.HideMessageFromChatRoom(msg);
                  output += 'Your message was hidden from chat for violating the room rules established for gray users by abusing {{0}}: {{1}}' + '\n';
                  output = output.toReplace(Reason, Violation);
                  SendTo.Special(output, CurrentUser);
              } else {
                  msg['m'] = '*** Muted for abusing {{0}}: {{1}} ***';
                  msg['m'] = msg['m'].toReplace(Reason, Violation);
              };
              SendTo.Special(WelcomeMessage, CurrentUser);
              SendTo.Special('Continued abuse will likely result in your being silenced for violating these rules.' + '\n', CurrentUser);
          };
          // Block Unwanted Content! //

        };
        // Not Token Spam //

      };
      // Grays Only! //

/* ************************************************** */
ShowDebugMessage("* Feature.GrayLimiter(msg) Complete");
/* ************************************************** */

    };

    // Token Spam Check //
    Feature.GrayLimiterTokenSpamCheck = function (msg) {

/* ************************************************** */
ShowDebugMessage("* Feature.GrayLimiterTokenSpamCheck(msg)");
/* ************************************************** */

        var Match = /\[([^\]]+)\]/;
        var Spam = Match.exec(msg['m'].toLowerCase());

/* ************************************************** */
if (!(Spam == null)) { ShowDebugMessage("Found Spam Term: " + Spam[1]); };
ShowDebugMessage("* Feature.GrayLimiterTokenSpamCheck(msg) Complete");
/* ************************************************** */

        var SpamFound = false;
        if (!(Spam == null)) { SpamFound = (Spam[1] == 'leak' || Spam[1] == 'leaked'); };
        if (SpamFound) { ViolationTally[0]++; };
        return SpamFound;
    };
    // Token Spam Check //

    Feature.GrayLimiterMessageCheck = function (Message, i) {

/* ************************************************** */
ShowDebugMessage("* Feature.GrayLimiterMessageCheck(Message, i)");
/* ************************************************** */

        Violation = '';

        // All Checks Except For "ALL CAPS" //
        if (!(i == 9)) { Message = Message.toLowerCase(); };
        // All Checks Except For "ALL CAPS" //

        // "ALL CAPS" *Mode* Check //
        if (i == 9 && Settings.CAPSMode) { Message = Message.replace(/\s/g, ''); };
        // "ALL CAPS" *Mode* Check //

/* ************************************************** */
ShowDebugMessage("["+i+"] Message=" + Message);
/* ************************************************** */

        if (Message.search(TheReasons[i].check) != -1) {

            var Test1 = Message.match(TheReasons[i].check);

/* ************************************************** */
ShowDebugMessage("Test1[0]=" + Test1[0]);
ShowDebugMessage("Test1[1]=" + Test1[1]);
/* ************************************************** */

            var Test2 = Message.substring(Message.search(TheReasons[i].check)).split(" ", 1);

/* ************************************************** */
ShowDebugMessage("Test2[0]=" + Test2[0]);
/* ************************************************** */

            ProcessMessage = true;

            Violation = (i == 0 || i == 8) ? Test2[0]
                                           : (i == 9 && Settings.CAPSMode) ? 'Whole Message'
                                                                           : i == 9 ? 'Any Word ({{0}})'.toReplace(Test2[0].toUpperCase())
                                                                                    : Test1[1];

/* ************************************************** */
ShowDebugMessage("ProcessMessage=" + ProcessMessage);
ShowDebugMessage("Violation=" + Violation);
ShowDebugMessage("* Feature.GrayLimiterMessageCheck(Message, i) Complete");
/* ************************************************** */

            ViolationTally[i]++;

            return TheReasons[i].notice;
        };

/* ************************************************** */
ShowDebugMessage("* Feature.GrayLimiterMessageCheck(Message, i) Complete");
/* ************************************************** */

        return null;
    };

// Welcome Message //
var WelcomeMessage = '';

    Feature.GrayLimiterWelcomeMessage = function () {

/* ************************************************** */
ShowDebugMessage("* Feature.GrayLimiterWelcomeMessage()");
/* ************************************************** */

        var BuildMessage = 'No ';

        for (i=0;i<=TotalChecks;i++) {
            if (Settings.DoTestCheck[i]){
                BuildMessage += '{{0}}, ';
                BuildMessage  = BuildMessage.toReplace(TheReasons[i].message);
            };
        };
        BuildMessage += ' or any other abuse will be tolerated.' + '\n';

/* ************************************************** */
ShowDebugMessage("BuildMessage=" + BuildMessage);
ShowDebugMessage("* Feature.GrayLimiterWelcomeMessage() Complete");
/* ************************************************** */

        return BuildMessage;
    };
// Welcome Message //

// Gray Limiter Feature //

// Feature Functions //


// Utility Functions //
var Utility = [];

var StartTime = new Date();

    Utility.GetUpTime = function () {
        var CurrentTime = new Date();
        var d = (CurrentTime - StartTime) / 1000;
        if (d < 60) {
            return Math.floor(d) + " Seconds"
        };
        d /= 60;
        var m = Math.floor(d % 60);
        var h = Math.floor(d / 60);
        var str = '';
        if (h) str += h + ' Hours, ';
        str += m + ' Minutes'
        return str;
    };

var ViolationTally = [];
for (i=0;i<=TheReasons.length;i++) {
    ViolationTally[i] = 0;
};

    // Show Session Stats //
    Utility.ShowStats = function () {
        output  = 'Current Session Running Time: {{0}}' + '\n\n';
        output  = output.toReplace(Utility.GetUpTime());

        output += "Total 'token generator spam' violations: {{0}}" + '\n';
        output  = output.toReplace(ViolationTally[0]);
        for (i=0;i<TheReasons.length;i++) {
            output += "Total '{{0}}' violations: {{1}}" + '\n';
            output  = output.toReplace(TheReasons[i].message, ViolationTally[i+1]);
        };

        return output;
    };
    // Show Session Stats //

    // Hide Message From Chat Room //
    Utility.HideMessageFromChatRoom = function (msg) {
        msg['X-Spam'] = true;
    };
    // Hide Message From Chat Room //

    // Command Handler //
    Utility.CheckForCommand = function (msg) {

        var CommandParamaters = msg['m'].toLowerCaseTrim().split(' ');
        var CommandCheck = CommandParamaters[0].substring(1);

        var InvalidCommand = true;

/* ************************************************** */
if (Debug.Mode) {
    for (x=0;x<CommandParamaters.length;x++) {
        ShowDebugMessage(x + '=[' + CommandParamaters[x] + ']');
    };
};

ShowDebugMessage("CommandParamaters[0].charAt(0)=[" + CommandParamaters[0].charAt(0) + "]");
ShowDebugMessage("CommandCheck / CommandParamaters[0].substring(1)=[" + CommandCheck + "]");
/* ************************************************** */

        // All Users //
        switch (CommandParamaters[0].charAt(0)) {

            // Commands //
            case ('/'):
                Utility.HideMessageFromChatRoom(msg);

                /* if (CommandCheck == Code.Command) {
                    switch (CommandParamaters[1]) {
                        case null:
                        case undefined:
                            InvalidCommand = true;
                            break;
                        default:
                            InvalidCommand = false;
                            break;
                    }; // (End Switch)
                }; */
                break;
            // Commands //

        }; // (End Switch)
        // All Users //

        // Broadcaster, Moderators (If "Allowed"), And "Always-Allowed Users" Only //
        if (UserIs.ActualBroadcaster() || UserIs.ActiveBroadcaster() || UserIs.AllowedModerator(msg) || UserIs.AlwaysAllowed()) {

            switch (CommandParamaters[0].charAt(0)) {

              // Commands //
              case ('/'):

                // Show "Universal" Help //
                if (CommandCheck == 'help') {
                    SendTo.Default(HelpNotification, CurrentUser);
                    InvalidCommand = false;
                    break;
                };
                // Show "Universal" Help //

                if (CommandCheck == Code.Command) {

                  switch (CommandParamaters[1]) {

                    // Toggle On/Off //
                    case Command.Toggle:
                        Settings.GrayLimiterStatus = !Settings.GrayLimiterStatus;
                        output = '\n' + '{{0}}: the feature has been {{1}}abled by {{2}}.' + '\n';
                        output = output.toReplace(Code.Name, (Settings.GrayLimiterStatus ? 'en'
                                                                                         : 'dis'
                                                                                         ), CurrentUser);
                        SendTo.ImportantUsers(output);
                        InvalidCommand = false;
                        break;
                    // Toggle On/Off //

                    // Check Status //
                    case Command.Status:
                        output = '\n' + "{{0}}: the feature is currently {{1}}abled (use '/{{2}} {{3}}' to {{4}}able)." + '\n';
                        output = output.toReplace(Code.Name, (Settings.GrayLimiterStatus ? 'en'
                                                                                         : 'dis'
                                                                                         ), Code.Command, Command.Toggle, (Settings.GrayLimiterStatus ? 'dis'
                                                                                                                                                      : 'en'
                                                                                                                                                      ));
                        SendTo.Default(output, CurrentUser);
                        InvalidCommand = false;
                        break;
                    // Check Status //

                    // Toggle Moderator Access //
                    case Command.Access.Moderator:
                        if ((UserIs.ActualBroadcaster()) || ((Settings.SupportMode) && (UserIs.Author()))) {
                            Settings.ModeratorsAllowed = !Settings.ModeratorsAllowed;
                            if (Settings.ModeratorsAllowed) {
                                output = '\n' + "{{0}}: command access for all moderators has been granted by {{1}} for this session." + '\n';
                            } else {
                                output = '\n' + "{{0}}: command access for all moderators has been revoked by {{1}} for this session." + '\n';
                            };
                            output = output.toReplace(Code.Name, CurrentUser);
                            SendTo.ImportantUsers(output);
                            InvalidCommand = false;
                        };
                        break;
                    // Toggle Moderator Access //

                    // Process Access List //
                    case Command.Access.Usage:
                        if ((UserIs.ActualBroadcaster()) || ((Settings.SupportMode) && (UserIs.Author()))) {

                            // Show User Access List //
                            if (CommandParamaters[2] == null) {
                                ShowUserAccessList();
                                InvalidCommand = false;
                                break;
                            };
                            // Show User Access List //

                            switch (CommandParamaters[2].charAt(0)) {

                                // Grant User Access //
                                case Command.Access.Grant:
                                    if ((UserIs.ActualBroadcaster()) || ((Settings.SupportMode) && (UserIs.Author()))) {
                                        if (CommandParamaters[2].length > 1) {
                                            SetUserAccess(true, CommandParamaters[2].substring(1).toLowerCaseTrim());
                                            output = '\n' + '{{0}}: access has been granted to {{1}} for the current session.' + '\n';
                                            output = output.toReplace(Code.Name, CommandParamaters[2].substring(1).toLowerCaseTrim());
                                            SendTo.Default(output, CurrentUser);
                                            output = '\n' + '{{0}}: command access has been granted to you for the current session.' + '\n';
                                            output = output.toReplace(Code.Name);
                                            SendTo.Default(output, CommandParamaters[2].substring(1).toLowerCaseTrim());
                                        } else {
                                            output = '\n' + '{{0}}: no user name was specified.' + '\n';
                                            output = output.toReplace(Code.Name);
                                            SendTo.Special(output, CurrentUser);
                                        };
                                    };
                                    break;
                                // Grant User Access //

                                // Revoke User Access //
                                case Command.Access.Revoke:
                                    if ((UserIs.ActualBroadcaster()) || ((Settings.SupportMode) && (UserIs.Author()))) {
                                        if (CommandParamaters[2].length > 1) {
                                            SetUserAccess(false, CommandParamaters[2].substring(1).toLowerCaseTrim());
                                            output = '\n' + '{{0}}: access has been revoked for {{1}} for the current session.' + '\n';
                                            output = output.toReplace(Code.Name, CommandParamaters[2].substring(1).toLowerCaseTrim());
                                            SendTo.Default(output, CurrentUser);
                                            output = '\n' + '{{0}}: your command access has been revoked for the current session.' + '\n';
                                            output = output.toReplace(Code.Name);
                                            SendTo.Default(output, CommandParamaters[2].substring(1).toLowerCaseTrim());
                                        } else {
                                            output = '\n' + '{{0}}: no user name was specified.' + '\n';
                                            output = output.toReplace(Code.Name);
                                            SendTo.Special(output, CurrentUser);
                                        };
                                    };
                                    break;
                                // Revoke User Access //

                                default:
                                    output = '\n' + "{{0}}: '{{1}}' is not a valid option. Please choose from '{{2}}[U]' or '{{3}}[U]' (where [U] is the user's chat name), or leave blank to show the current list of users with command access." + '\n';
                                    output = output.toReplace(Code.Name, CommandParamaters[2], Command.Access.Grant, Command.Access.Revoke);
                                    SendTo.Special(output, CurrentUser);
                                    break;
                            }; // (End Switch)

                            InvalidCommand = false;
                        };
                        break;
                    // Process Access List //

                    // Show Stats //
                    case Command.Stats:
                        if ((UserIs.ActualBroadcaster()) || ((Settings.SupportMode) && (UserIs.Author()))) {
                            output  = '\n' + '{{0}}: stats for this session are shown below.' + '\n\n';
                            output  = output.toReplace(Code.Name);
                            output += Utility.ShowStats();
                            SendTo.Default(output, CurrentUser);
                            InvalidCommand = false;
                        };
                        break;
                    // Show Stats //

                    // Show Help //
                    case undefined:
                    case Command.Help:
                        SendTo.Default(HelpNotification, CurrentUser);
                        InvalidCommand = false;
                        break;
                    // Show Help //

                    // Toggle Support Mode (Must Be Broadcaster) //
                    case 'support':
                        if (UserIs.ActualBroadcaster()) {
                            Settings.SupportMode = !Settings.SupportMode;
                            Broadcaster.Active = Settings.SupportMode ? Code.Author.toLowerCase()
                                                                      : Broadcaster.Actual;
                            output = '\n' + '{{0}}: support mode {{1}}abled.' + '\n';
                            output = output.toReplace(Code.Name, (Settings.SupportMode ? 'en'
                                                                                       : 'dis'
                                                                                       ));
                            SendTo.Special(output, CurrentUser);
                            if (UserIs.ActualBroadcaster() != UserIs.Author()) { SendTo.Special(output, Code.Author.toLowerCase()); };
                            InvalidCommand = false;
                        };
                        break;
                    // Toggle Support Mode (Must Be Broadcaster) //

                    // Toggle Debug Mode (Must Be Author) //
                    case 'debug':
                        if ((!(Settings.SupportMode)) && (Debug.Mode) && (UserIs.Author())) { // Escape Debug Mode If Support Mode Is Prematurely Deactivated
                            Debug.Mode = false;
                            output = '\n' + '{{0}}: debug mode disabled.' + '\n';
                            output = output.toReplace(Code.Name);
                            SendTo.Special(output, CurrentUser);
                            InvalidCommand = false;
                        };
                        if ((Settings.SupportMode) && (UserIs.Author())) {
                            Debug.Mode = !Debug.Mode;
                            if (Debug.Mode) { Debug.Count = 1; };
                            output = '\n' + '{{0}}: debug mode {{1}}abled.' + '\n';
                            output = output.toReplace(Code.Name, (Debug.Mode ? 'en'
                                                                             : 'dis'
                                                                             ));
                            SendTo.Special(output, CurrentUser);
                            InvalidCommand = false;
                        };
                        break;
                    // Toggle Debug Mode (Must Be Author) //

                    // Toggle Verbose Debug Mode (Must Be Author) //
                    case 'verbose':
                        if ((!(Settings.SupportMode)) && (Debug.Mode) && (Debug.Verbose) && (UserIs.Author())) { // Allow Verbose Debug Mode Toggle If Support Mode Is Prematurely Deactivated
                            Debug.Verbose = !Debug.Verbose;
                            output = '\n' + '{{0}}: verbose debug mode {{1}}abled.' + '\n';
                            output = output.toReplace(Code.Name, (Debug.Verbose ? 'en'
                                                                                : 'dis'
                                                                                ));
                            SendTo.Special(output, CurrentUser);
                            InvalidCommand = false;
                        };
                        if ((Settings.SupportMode) && (UserIs.Author())) {
                            if (Debug.Mode) {
                                Debug.Verbose = !Debug.Verbose;
                            } else {
                                Debug.Mode = true;
                                Debug.Verbose = true;
                            };
                            output = '\n' + '{{0}}: verbose debug mode {{1}}abled.' + '\n';
                            output = output.toReplace(Code.Name, (Debug.Verbose ? 'en'
                                                                                : 'dis'
                                                                                ));
                            SendTo.Special(output, CurrentUser);
                            InvalidCommand = false;
                        };
                        break;
                    // Toggle Verbose Debug Mode (Must Be Author) //

                    // Invalid Command Option //
                    default:
                        InvalidCommand = true;
                        break;
                    // Invalid Command Option //

                  }; // (End Switch)
                };
                break;
              // Commands //

            }; // (End Switch)
        };
        // Broadcaster, Moderators (If "Allowed"), And "Always-Allowed Users" Only //


/* ************************************************** */
ShowDebugMessage("InvalidCommand=" + InvalidCommand);
/* ************************************************** */


        if ((Debug.Mode && UserIs.Author()) || CommandCheck == Code.Command) {
            if (InvalidCommand && CommandParamaters[0].charAt(0) == '/') {
                output  = '\n' + "{{0}}: invalid command or access denied: '{{1}}'." + '\n'
                if (UserIs.ActualBroadcaster() || UserIs.ActiveBroadcaster() || UserIs.AllowedModerator(msg) || UserIs.AlwaysAllowed()) {
                    output += '\n' + FormatCommand("{{2}}' to see a list of the available commands.", false);
                    output  = output.toReplace(Code.Name, msg['m'].trim(), Command.Help);
                } else {
                    output  = output.toReplace(Code.Name, msg['m'].trim());
                };
                SendTo.Special(output, CurrentUser);
            };
        };


/* Disabled: NOT COMPATIBLE WITH MULTIPLE APP/BOT COMBINATIONS
        if (CommandCheck == Code.Command) {
            output = "Command {{0}}executed: '{{1}}'";
            output = output.toReplace((InvalidCommand ? 'not '
                                                      : ''
                                                      ), msg['m']);
            msg['m'] = output;
        };
*/

    };
    // Command Handler //

// Utility Functions //


// Chaturbate Tip Handler //
var LastTipAmount = 0;
var LastTipper = null;

function onTip(tip) {

/* ************************************************** */
ShowDebugMessage("* onTip(tip)");
/* ************************************************** */

    LastTipAmount = parseInt(tip['amount']);
    LastTipper = tip['from_user'];

/* ************************************************** */
ShowDebugMessage("LastTipper=" + LastTipper);
ShowDebugMessage("LastTipAmount=" + LastTipAmount);
/* ************************************************** */

    CurrentUser = LastTipper;

/* ************************************************** */
ShowDebugMessage("* onTip(tip) Complete");
/* ************************************************** */

};

cb.onTip(function(tip) {
    return onTip(tip);
});
// Chaturbate Tip Handler //


// Chaturbate Welcome Handler //
function onEnter(user) {

/* ************************************************** */
ShowDebugMessage("* onEnter(user)");
/* ************************************************** */

    CurrentUser = user['user'];

    SetModeratorStatus(user);

    if (Settings.MessageOnEntryStatus) {
        if ((UserIs.Gray(user)) && ((!UserIs.ActiveBroadcaster()))) {
            output  = '\n' + ':nograyhammer' + '\n';
            output += "Attention {{0}}, grays have limited chat permissions here, so don't be rude. Just sit back and enjoy the show." + '\n';
            output += '\n' + '{{1}}' + '\n';
            output += 'Your message will be muted and you risk being silenced for violating these rules.' + '\n';
            output  = output.toReplace(CurrentUser, WelcomeMessage);
            SendTo.Special(output, CurrentUser);
        };
    };

    if (UserIs.Author() && (!(UserIs.ActualBroadcaster()))) {
        output = '{{0}} is being used by {{1}}.' + '\n';
        output = output.toReplace(Identification, Broadcaster.Actual);
        SendTo.Special(output, Code.Author.toLowerCase());
    };

/* ************************************************** */
ShowDebugMessage("* onEnter(user) Complete");
/* ************************************************** */

};

cb.onEnter(function(user) {
    return onEnter(user);
});
// Chaturbate Welcome Handler //


// Chaturbate Message Handler //
function onMessage(msg) {

/* ************************************************** */
ShowDebugMessage("* onMessage(msg)");
/* ************************************************** */

    CurrentUser = msg['user'];

    SetModeratorStatus(msg);

    msg['m'] = msg['m'].replace(/\s\s+/g, ' ');

/* ************************************************** */
ShowDebugMessage("msg=" + msg['m']);
/* ************************************************** */

    Utility.CheckForCommand(msg);

    if (Settings.GrayLimiterStatus) { Feature.GrayLimiter(msg); };

/* ************************************************** */
ShowDebugMessage("* onMessage(msg) Complete");
/* ************************************************** */

    return msg;
};

cb.onMessage(function (msg) {
    return onMessage(msg);
});
// Chaturbate Message Handler //


// Startup //
var Startup = {};

    Startup.Message = '\n' + '{{0}} has been activated.' + '\n';
    Startup.Message = Startup.Message.toReplace(Identification);

    Startup.Init = function () {

/* ************************************************** */
ShowDebugMessage("* Startup.Init()");
/* ************************************************** */

        Settings.NotificationStyle.Weight = Settings.NotificationStyle.Weight.toLowerCase();

        SendTo.Default(Startup.Message);

        cb.setTimeout(Startup.Delay, 2000);

/* ************************************************** */
ShowDebugMessage("* Startup.Init() Complete");
/* ************************************************** */

    };

    Startup.Delay = function () {

/* ************************************************** */
ShowDebugMessage('* Startup.Delay()');
/* ************************************************** */

        /* cb.setTimeout(SendTo.ImportantUsers(CommandList), 2000); */

        cb.setTimeout(SendTo.ImportantUsers('\n' + FormatCommand("{{0}}' to see a list of the available commands.".toReplace(Command.Help), false)), 2000);

        WelcomeMessage = Feature.GrayLimiterWelcomeMessage();

/* ************************************************** */
ShowDebugMessage('* Startup.Delay() Complete');
/* ************************************************** */

    };

cb.setTimeout(Startup.Init, 1);
// Startup //