@koralabs/kora-labs-common 1.2.0 → 2.0.0

package/lib/handles/interfaces.d.ts

@@ -243,4 +243,32 @@ export interface OAuthToken {
     token: string;
     social: OAuthSocial;
 }
+export interface ProtectedWord {
+    word: string;
+    algorithms: ('modifier' | 'badword' | 'suggestive' | 'hatespeech' | 'vulnerable')[];
+    modType?: ('modifier' | 'suggestive' | 'hatespeech')[];
+    canBePositive?: boolean;
+    position?: 'exact' | 'any' | 'beginswith';
+    exceptions?: string[];
+}
+export declare enum AvailabilityResponseCode {
+    AVAILABLE = 200,
+    NOT_AVAILABLE_FOR_LEGAL_REASONS = 451,
+    NOT_ACCEPTABLE = 406,
+    LOCKED = 423
+}
+export interface AvailabilityResponse {
+    available: boolean;
+    handle: string;
+    message?: string;
+    type?: 'notallowed' | 'invalid';
+    link?: string;
+    reason?: string;
+    duration?: number;
+    code: AvailabilityResponseCode;
+}
+export interface ReservedOrProtected {
+    reserved?: string[];
+    protected: ProtectedWord[];
+}
 export {};

package/lib/handles/interfaces.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OAuthSocial = exports.AssetNameLabel = exports.Rarity = void 0;
+exports.AvailabilityResponseCode = exports.OAuthSocial = exports.AssetNameLabel = exports.Rarity = void 0;
 var Rarity;
 (function (Rarity) {
     Rarity["basic"] = "basic";
@@ -44,3 +44,10 @@ var OAuthSocial;
     OAuthSocial[OAuthSocial["soundcloud"] = 17] = "soundcloud";
     OAuthSocial[OAuthSocial["paypal"] = 18] = "paypal";
 })(OAuthSocial = exports.OAuthSocial || (exports.OAuthSocial = {}));
+var AvailabilityResponseCode;
+(function (AvailabilityResponseCode) {
+    AvailabilityResponseCode[AvailabilityResponseCode["AVAILABLE"] = 200] = "AVAILABLE";
+    AvailabilityResponseCode[AvailabilityResponseCode["NOT_AVAILABLE_FOR_LEGAL_REASONS"] = 451] = "NOT_AVAILABLE_FOR_LEGAL_REASONS";
+    AvailabilityResponseCode[AvailabilityResponseCode["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+    AvailabilityResponseCode[AvailabilityResponseCode["LOCKED"] = 423] = "LOCKED";
+})(AvailabilityResponseCode = exports.AvailabilityResponseCode || (exports.AvailabilityResponseCode = {}));

package/lib/index.d.ts

@@ -3,3 +3,5 @@ export { Environment, ComputeEnvironment } from "./environment";
 export * from "./handles/interfaces";
 export * from "./handles/constants";
 export { checkHandlePattern } from "./handles/validation";
+export * from "./utils";
+export { ProtectedWords } from "./protectedWords";

package/lib/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkHandlePattern = exports.ComputeEnvironment = exports.Environment = exports.LogCategory = exports.Logger = void 0;
+exports.ProtectedWords = exports.checkHandlePattern = exports.ComputeEnvironment = exports.Environment = exports.LogCategory = exports.Logger = void 0;
 var logger_1 = require("./logger");
 Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
 Object.defineProperty(exports, "LogCategory", { enumerable: true, get: function () { return logger_1.LogCategory; } });
@@ -25,3 +25,6 @@ __exportStar(require("./handles/interfaces"), exports);
 __exportStar(require("./handles/constants"), exports);
 var validation_1 = require("./handles/validation");
 Object.defineProperty(exports, "checkHandlePattern", { enumerable: true, get: function () { return validation_1.checkHandlePattern; } });
+__exportStar(require("./utils"), exports);
+var protectedWords_1 = require("./protectedWords");
+Object.defineProperty(exports, "ProtectedWords", { enumerable: true, get: function () { return protectedWords_1.ProtectedWords; } });

package/lib/logger/index.test.js

@@ -22,6 +22,7 @@ describe('Logger Tests', () => {
             dimensions: ['taco'],
             event: 'test.log',
             message: 'burritos',
+            network: "UNSET",
             milliseconds: now,
             timestamp: expect.stringMatching(/[0-9\-]+T[0-9\:\.]+Z/)
         });

package/lib/protectedWords/index.d.ts

@@ -0,0 +1,33 @@
+import { AvailabilityResponse, ReservedOrProtected } from '../handles/interfaces';
+declare global {
+    interface String {
+        includesSingularOrPlural(word: string): boolean;
+        replaceSingularOrPlural(word: string, replacement: string): string;
+    }
+}
+export declare class ProtectedWords {
+    static protectedHandles: ReservedOrProtected;
+    static readLock: boolean;
+    static cacheResetTime: number;
+    static checkAvailability(handle: string): Promise<AvailabilityResponse>;
+    static setSingular(handle: string): {
+        plural: string;
+        singular: string;
+    };
+    static isNumberReplacementsProtected(handle: string, checkIfMatches?: (h: string) => {
+        protected: boolean;
+        words?: string[];
+    }): {
+        protected: boolean;
+        words?: string[];
+    };
+    static isProtected(handle: string): {
+        protected: boolean;
+        words?: string[];
+    };
+    static isBadWord(handle: string): {
+        badword: boolean;
+        words?: string[];
+    };
+    static trimChars(handle: string, chars: string): string;
+}

package/lib/protectedWords/index.js

@@ -0,0 +1,363 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtectedWords = void 0;
+const pluralize_1 = __importDefault(require("pluralize"));
+const protectedWords_1 = require("./protectedWords");
+const utils_1 = require("../utils");
+const interfaces_1 = require("../handles/interfaces");
+const constants_1 = require("../handles/constants");
+String.prototype.includesSingularOrPlural = function (word) {
+    const singPlur = ProtectedWords.setSingular(word);
+    return this.includes(singPlur.singular) || this.includes(singPlur.plural);
+};
+String.prototype.replaceSingularOrPlural = function (word, replacement) {
+    const singPlur = ProtectedWords.setSingular(word);
+    return this.replace(singPlur.singular, replacement).replace(singPlur.plural, replacement);
+};
+class ProtectedWords {
+    static checkAvailability(handle) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, utils_1.delay)(0); // This has to be here to allow early Promise return
+            const startTime = Date.now();
+            handle = handle.toLowerCase();
+            const notAllowedResponse = {
+                available: false,
+                handle,
+                type: 'notallowed',
+                code: interfaces_1.AvailabilityResponseCode.NOT_AVAILABLE_FOR_LEGAL_REASONS
+            };
+            const allowedResponse = {
+                available: true,
+                handle,
+                code: interfaces_1.AvailabilityResponseCode.AVAILABLE
+            };
+            // if it is all numbers or non-alphas, we don't care
+            if (handle.match(/^[0-9@_.-]{1,28}$/)) {
+                allowedResponse.duration = Date.now() - startTime;
+                return allowedResponse;
+            }
+            let handleMatches = handle.match(constants_1.REGEX_SPLIT_ON_CHARS);
+            if (handleMatches) {
+                for (let i = 0; i < (handleMatches === null || handleMatches === void 0 ? void 0 : handleMatches.length); i++) {
+                    const match = handleMatches[i];
+                    let listed = this.isProtected(match);
+                    // This will get `my.shit.stinks`, `_my-shits_stink`, `my.shitz.stink`, and `-my_shit5_stink-`
+                    if (listed.protected) {
+                        notAllowedResponse.reason = `Protected word match on '${(_a = listed.words) === null || _a === void 0 ? void 0 : _a.join(',')}'`;
+                        notAllowedResponse.duration = Date.now() - startTime;
+                        return notAllowedResponse;
+                    }
+                    // This will get `my.5h1t.stinks`, `_my-shi7s_stink`, `my_sh1tz.stink`, and `-my_5hit5_stink`
+                    listed = this.isNumberReplacementsProtected(match);
+                    if (listed.protected) {
+                        notAllowedResponse.reason = `Number replacement match on '${(_b = listed.words) === null || _b === void 0 ? void 0 : _b.join(',')}'`;
+                        notAllowedResponse.duration = Date.now() - startTime;
+                        return notAllowedResponse;
+                    }
+                    // This will get `my.123shit456`, `0shits0.stink`, `11shitz11.you`
+                    let handleTrimmed = this.trimChars(match, '0123456789');
+                    listed = this.isProtected(handleTrimmed);
+                    if (listed.protected) {
+                        notAllowedResponse.reason = `Number trim match on '${(_c = listed.words) === null || _c === void 0 ? void 0 : _c.join(',')}'`;
+                        notAllowedResponse.duration = Date.now() - startTime;
+                        return notAllowedResponse;
+                    }
+                    // This will get `1xshitx1`, `xxxshitsxxx`, `0x0shitz0x0`
+                    handleTrimmed = this.trimChars(match, 'x0123456789');
+                    listed = this.isProtected(handleTrimmed);
+                    if (listed.protected) {
+                        notAllowedResponse.reason = `Number and 'x' trim match on '${(_d = listed.words) === null || _d === void 0 ? void 0 : _d.join(',')}'`;
+                        notAllowedResponse.duration = Date.now() - startTime;
+                        return notAllowedResponse;
+                    }
+                }
+            }
+            // This will get `.s.h.i.7.`, sh.1_7s`, `5.h-1-t__z`, and `sh1.t5`
+            handle = handle.replace(/[_.-]/g, '');
+            const listed = this.isNumberReplacementsProtected(handle);
+            if (listed.protected) {
+                notAllowedResponse.reason = `Protected word match (with stripped characters) on '${(_e = listed.words) === null || _e === void 0 ? void 0 : _e.join(',')}'`;
+                notAllowedResponse.duration = Date.now() - startTime;
+                return notAllowedResponse;
+            }
+            handleMatches = handle.match(constants_1.REGEX_SPLIT_ON_NUMS);
+            if (handleMatches) {
+                for (let i = 0; i < (handleMatches === null || handleMatches === void 0 ? void 0 : handleMatches.length); i++) {
+                    const match = handleMatches[i];
+                    // This will get `my1shit1stinks`, `0my1shits2stink`, `my3shitz4stink`, and `5my1shit5stink-`
+                    const listed = this.isProtected(match);
+                    if (listed.protected) {
+                        notAllowedResponse.reason = `Split on numbers match for '${(_f = listed.words) === null || _f === void 0 ? void 0 : _f.join(',')}'`;
+                        notAllowedResponse.duration = Date.now() - startTime;
+                        return notAllowedResponse;
+                    }
+                }
+            }
+            // anywhere in the string and beginswith lookups
+            // this will get `allmyshitsucks`, `eatsh17anddie`, `shithead`
+            let matchResult = this.isNumberReplacementsProtected(handle, (h) => {
+                let foundWord = '';
+                // First check the 'any' list - anywhere in the string is bad
+                if (ProtectedWords.protectedHandles.protected.some((entry) => {
+                    var _a;
+                    foundWord = entry.word;
+                    return (entry.position == 'any' &&
+                        !((_a = entry.exceptions) === null || _a === void 0 ? void 0 : _a.some((exc) => h.includes(exc))) &&
+                        h.includesSingularOrPlural(entry.word));
+                })) {
+                    return { protected: true, words: [foundWord] };
+                }
+                // Then check 'beginswith', a little note that "beginswith" works better when the next
+                // character is a consonant. This will let a few badwords through, but will greatly reduce
+                // false positives.
+                if (ProtectedWords.protectedHandles.protected.some((entry) => {
+                    var _a, _b;
+                    foundWord = entry.word;
+                    return (entry.position == 'beginswith' &&
+                        h.startsWith(entry.word) &&
+                        !'aeiou'.includes((_a = h.replaceSingularOrPlural(entry.word, '')) === null || _a === void 0 ? void 0 : _a.charAt(0)) &&
+                        !((_b = entry.exceptions) === null || _b === void 0 ? void 0 : _b.some((exc) => h.includes(exc))));
+                })) {
+                    return { protected: true, words: [foundWord] };
+                }
+                return { protected: false };
+            });
+            if (matchResult.protected) {
+                notAllowedResponse.reason = `In string match found for '${(_g = matchResult.words) === null || _g === void 0 ? void 0 : _g.join(',')}'`;
+                notAllowedResponse.duration = Date.now() - startTime;
+                return notAllowedResponse;
+            }
+            // "vulnerable" targets are slightly different than "hatespeech" targets, but we can combine them here for speed.
+            const hatespeechEntries = ProtectedWords.protectedHandles.protected.filter((entry) => entry.algorithms.includes('hatespeech') || entry.algorithms.includes('vulnerable'));
+            const hatespeechWords = ProtectedWords.protectedHandles.protected.filter((entry) => { var _a; return (_a = entry.modType) === null || _a === void 0 ? void 0 : _a.includes('hatespeech'); });
+            // hatespeech lookups
+            matchResult = this.isNumberReplacementsProtected(handle, (h) => {
+                let foundWords = '';
+                if (hatespeechEntries.some((entry) => {
+                    var _a;
+                    return (h.includesSingularOrPlural(entry.word) &&
+                        // It's a hatespeech target and includes a hatespeech modifier (check exceptions)
+                        !((_a = entry.exceptions) === null || _a === void 0 ? void 0 : _a.some((exc) => h.includes(exc))) &&
+                        hatespeechWords.some((hateWord) => {
+                            var _a;
+                            foundWords = `${entry.word},${hateWord.word}`;
+                            return (h.replaceSingularOrPlural(entry.word, ' ').includes(hateWord.word) &&
+                                !((_a = hateWord.exceptions) === null || _a === void 0 ? void 0 : _a.some((exc) => h.includes(exc))) &&
+                                // If it's a vulnerable target, a positive word is fine
+                                !(entry.algorithms.includes('vulnerable') && hateWord.canBePositive) &&
+                                // If it's not a bad word and it is a hatespeech target then a positive word is fine
+                                !(!entry.algorithms.includes('badword') &&
+                                    entry.algorithms.includes('hatespeech') &&
+                                    hateWord.canBePositive));
+                        }));
+                })) {
+                    return { protected: true, words: foundWords.split(',') };
+                }
+                return { protected: false };
+            });
+            if (matchResult.protected) {
+                notAllowedResponse.reason = `Hatespeech match found for ${(_h = matchResult.words) === null || _h === void 0 ? void 0 : _h.join(',')}`;
+                notAllowedResponse.duration = Date.now() - startTime;
+                return notAllowedResponse;
+            }
+            // 'pp' can make some pretty bad phrases, but can't be dealt with normally since it is in so many "good" words
+            // just combine with modifiers for now
+            const specialCaseVulnWords = ['pp'];
+            const modifiers = ProtectedWords.protectedHandles.protected.filter((entry) => { var _a; return (_a = entry.modType) === null || _a === void 0 ? void 0 : _a.includes('modifier'); });
+            // suggestive & vulnerable lookups - 'lickmyd1ck`, `s3xmyp3n1s`
+            const suggestiveWords = ProtectedWords.protectedHandles.protected.filter((entry) => { var _a; return (_a = entry.modType) === null || _a === void 0 ? void 0 : _a.includes('suggestive'); });
+            const vulnerableEntries = ProtectedWords.protectedHandles.protected.filter((entry) => entry.algorithms.includes('vulnerable'));
+            const suggestiveEntries = ProtectedWords.protectedHandles.protected.filter((entry) => entry.algorithms.includes('suggestive'));
+            matchResult = this.isNumberReplacementsProtected(handle, (h) => {
+                let foundWords = '';
+                if ([...suggestiveEntries, ...vulnerableEntries].some((entry) => {
+                    var _a;
+                    // is combined with a suggestive word, or another suggestive entry (from the same badwords list), or it's a modifier + `pp`
+                    return (h.includesSingularOrPlural(entry.word) &&
+                        !((_a = entry.exceptions) === null || _a === void 0 ? void 0 : _a.some((exc) => h.includes(exc))) &&
+                        (suggestiveWords.some((s) => {
+                            var _a;
+                            // is combined with a suggestive word (check exceptions)
+                            foundWords = `${entry.word},${s.word}`;
+                            return (h.replaceSingularOrPlural(entry.word, ' ').includes(s.word) &&
+                                !((_a = s.exceptions) === null || _a === void 0 ? void 0 : _a.some((exc) => h.includes(exc))) &&
+                                !(entry.algorithms.includes('vulnerable') && s.canBePositive));
+                        }) ||
+                            suggestiveEntries.some((s) => {
+                                var _a;
+                                // is combined with another suggestive entry from the badwords list (check exceptions)
+                                foundWords = `${entry.word},${s.word}`;
+                                return (s != entry &&
+                                    h.replaceSingularOrPlural(entry.word, ' ').includesSingularOrPlural(s.word) &&
+                                    !((_a = s.exceptions) === null || _a === void 0 ? void 0 : _a.some((exc) => h.includes(exc))));
+                            }) ||
+                            modifiers.some((mod) => h.replaceSingularOrPlural(entry.word, ' ').includes(mod.word) &&
+                                // If it can be a positive modifier, like "love", then vulnerable targets are OK
+                                !(entry.algorithms.includes('vulnerable') &&
+                                    mod.canBePositive &&
+                                    !specialCaseVulnWords.some((spec) => {
+                                        // it's a modifier + `pp` - This is a hint that it's not a good phrase like "tinypreteenpp"
+                                        foundWords = `${entry.word},${mod.word},${spec}`;
+                                        return h
+                                            .replaceSingularOrPlural(entry.word, ' ')
+                                            .replaceSingularOrPlural(mod.word, ' ')
+                                            .includes(spec);
+                                    })) &&
+                                specialCaseVulnWords.some((spec) => {
+                                    // it's a modifier + `pp` - This is a hint that it's not a good phrase like "tinypreteenpp"
+                                    foundWords = `${entry.word},${mod.word},${spec}`;
+                                    return h
+                                        .replaceSingularOrPlural(entry.word, ' ')
+                                        .replaceSingularOrPlural(mod.word, ' ')
+                                        .includes(spec);
+                                }))));
+                })) {
+                    return { protected: true, words: foundWords.split(',') };
+                }
+                return { protected: false };
+            });
+            if (matchResult.protected) {
+                notAllowedResponse.reason = `Suggestive language match found for ${(_j = matchResult.words) === null || _j === void 0 ? void 0 : _j.join(',')}`;
+                notAllowedResponse.duration = Date.now() - startTime;
+                return notAllowedResponse;
+            }
+            allowedResponse.duration = Date.now() - startTime;
+            return allowedResponse;
+        });
+    }
+    static setSingular(handle) {
+        let singular = handle;
+        let plural = handle;
+        if (pluralize_1.default.isPlural(handle)) {
+            singular = pluralize_1.default.singular(handle);
+        }
+        else {
+            plural = (0, pluralize_1.default)(handle);
+        }
+        return { plural, singular };
+    }
+    static isNumberReplacementsProtected(handle, checkIfMatches) {
+        // 8's can be problematic (because they are replaced with 'ate' or 'ait').
+        // When combined with multiple numbers they are probably not a bad word anyway
+        let handleReplacedTemp = handle;
+        // it's about 5x faster to check the includes first than it is to just call replace directly
+        if (handleReplacedTemp.includes('8'))
+            handleReplacedTemp = handleReplacedTemp.replace(/(8[0-9])|([0-9]8){2,}/g, '');
+        if (handleReplacedTemp.includes('0'))
+            handleReplacedTemp = handleReplacedTemp.replace(/0/g, 'o');
+        if (handleReplacedTemp.includes('2'))
+            handleReplacedTemp = handleReplacedTemp.replace(/2/g, 'z');
+        if (handleReplacedTemp.includes('3'))
+            handleReplacedTemp = handleReplacedTemp.replace(/3/g, 'e');
+        if (handleReplacedTemp.includes('4'))
+            handleReplacedTemp = handleReplacedTemp.replace(/4/g, 'a');
+        if (handleReplacedTemp.includes('5'))
+            handleReplacedTemp = handleReplacedTemp.replace(/5/g, 's');
+        if (handleReplacedTemp.includes('6'))
+            handleReplacedTemp = handleReplacedTemp.replace(/6/g, 'g');
+        if (handleReplacedTemp.includes('7'))
+            handleReplacedTemp = handleReplacedTemp.replace(/7/g, 't');
+        if (handleReplacedTemp.includes('9'))
+            handleReplacedTemp = handleReplacedTemp.replace(/9/g, 'g');
+        if (handleReplacedTemp.includes('@'))
+            handleReplacedTemp = handleReplacedTemp.replace(/@/g, 'a');
+        if (handleReplacedTemp.includes('1') || handleReplacedTemp.includes('8')) {
+            // ones and eights have two replaceable chars each
+            // This logic isn't quite right. It should check each individual instance with either replacement
+            // possible improvement needed here to catch more words
+            // letting it slide for now since number replacements are less obvious
+            // and this is the slowest part of the algorithm
+            for (const one of ['i', 'l']) {
+                for (const eight of ['ate', 'ait']) {
+                    const handleReplaced = handleReplacedTemp.replace(/1/g, one).replace(/8/g, eight);
+                    const listed = this.isProtected(handleReplaced);
+                    if (listed.protected)
+                        return { protected: true, words: listed.words };
+                    if (checkIfMatches) {
+                        const matches = checkIfMatches(handleReplaced);
+                        if (matches.protected)
+                            return { protected: true, words: matches.words };
+                    }
+                }
+            }
+        }
+        const listed = this.isProtected(handleReplacedTemp);
+        if (listed.protected)
+            return { protected: true, words: listed.words };
+        if (checkIfMatches) {
+            const matches = checkIfMatches(handleReplacedTemp);
+            if (matches.protected)
+                return { protected: true, words: matches.words };
+        }
+        return { protected: false };
+    }
+    static isProtected(handle) {
+        let { singular } = this.setSingular(handle);
+        let bad = this.isBadWord(singular);
+        if (bad.badword) {
+            return { protected: true, words: bad.words };
+        }
+        const pluralz = handle.replace(/[z5]$/, 's');
+        if (pluralz != handle) {
+            ({ singular } = this.setSingular(handle));
+            bad = this.isBadWord(singular);
+            if (bad.badword) {
+                return { protected: true, words: bad.words };
+            }
+        }
+        return { protected: false };
+    }
+    static isBadWord(handle) {
+        const protectedWords = ProtectedWords.protectedHandles.protected;
+        const modifiers = ProtectedWords.protectedHandles.protected.filter((entry) => { var _a; return (_a = entry.modType) === null || _a === void 0 ? void 0 : _a.includes('modifier'); });
+        const found = protectedWords.find((x) => x.word == handle && x.algorithms.includes('badword'));
+        if (found)
+            return { badword: true, words: [found.word] };
+        let foundWords = '';
+        if (modifiers.some((m) => protectedWords.some((entry) => {
+            var _a, _b;
+            foundWords = `${entry.word},${m.word}`;
+            // If there is a badword modifier word, then it's a hint that the phrase is bad (check exceptions)
+            return (entry.algorithms.includes('badword') &&
+                !((_a = entry.exceptions) === null || _a === void 0 ? void 0 : _a.some((exc) => handle.includes(exc))) &&
+                !((_b = m.exceptions) === null || _b === void 0 ? void 0 : _b.some((exc) => handle.includes(exc))) &&
+                // small modifiers (<3 chars) can increase false positives, so just check to see if they are at the beginning or end of the word
+                ((m.word.length <= 3 &&
+                    entry.word == handle.replace(new RegExp(`(^${m.word})|(${m.word}$)`), '')) ||
+                    // if over 3 chars, check anywhere in the word
+                    (m.word.length > 3 &&
+                        handle.includes(entry.word) &&
+                        handle.replaceSingularOrPlural(entry.word, ' ').includes(m.word))));
+        }))) {
+            return { badword: true, words: foundWords.split(',') };
+        }
+        return { badword: false };
+    }
+    static trimChars(handle, chars) {
+        let startIndex = 0;
+        let lastIndex = handle.length - 1;
+        while (chars.includes(handle[startIndex])) {
+            startIndex++;
+        }
+        while (chars.includes(handle[lastIndex])) {
+            lastIndex--;
+        }
+        return handle.substring(startIndex, lastIndex + 1);
+    }
+}
+exports.ProtectedWords = ProtectedWords;
+ProtectedWords.protectedHandles = { protected: protectedWords_1.words };
+ProtectedWords.readLock = false;

package/lib/protectedWords/index.test.d.ts

@@ -0,0 +1 @@
+export {};