@wtfalch/auth 0.15.0 → 0.19.0

package/dist/names.js

@@ -0,0 +1,146 @@
+import { DataSet, RegExpMatcher, collapseDuplicatesTransformer, englishDataset, englishRecommendedTransformers, parseRawPattern, resolveConfusablesTransformer, resolveLeetSpeakTransformer, skipNonAlphabeticTransformer, toAsciiLowerCaseTransformer, } from 'obscenity';
+import reservedUsernames from 'reserved-usernames' with { type: 'json' };
+import { NUMERIC, PHRASES, WHITELIST } from './names.list.js';
+import { PEOPLE, SYSTEM } from './names.reserved.js';
+export const DEFAULT_RULES = {
+    minLength: 3,
+    maxLength: 30,
+    pattern: /^[A-Za-z0-9][A-Za-z0-9._-]*$/,
+};
+const spellings = (entry) => [entry.word, ...(entry.also ?? [])];
+/**
+ * Obscenity collapses repeated letters in the INPUT and matches the patterns
+ * as written, so a pattern has to be written the way its word looks after
+ * collapsing: `fitte` is met as `fite`. The English set allows two of a few
+ * letters (ni_gg_er, a_ss_); the loose matcher allows one of anything.
+ */
+function collapsed(word, twice) {
+    return word.replace(/(.)\1+/g, (run, letter) => twice.includes(letter) ? run.slice(0, 2) : letter);
+}
+const ENGLISH_TWICE = 'beolsg';
+/** Obscenity's English words and ours, with the boundaries each asks for. */
+const strictWords = new DataSet().addAll(englishDataset);
+for (const entry of PHRASES) {
+    strictWords.addPhrase((phrase) => {
+        phrase.setMetadata({ originalWord: entry.word });
+        for (const word of spellings(entry)) {
+            const written = collapsed(word, ENGLISH_TWICE);
+            phrase.addPattern(parseRawPattern(entry.anywhere ? written : `|${written}|`));
+        }
+        return phrase;
+    });
+}
+strictWords.addPhrase((phrase) => {
+    for (const term of WHITELIST)
+        phrase.addWhitelistedTerm(term);
+    return phrase;
+});
+const strict = new RegExpMatcher({ ...strictWords.build(), ...englishRecommendedTransformers });
+/** Only the words that are slurs wherever they appear, read with everything between the letters skipped. */
+const looseWords = new DataSet();
+for (const entry of [
+    ...PHRASES.filter((entry) => entry.anywhere),
+    { word: 'nigger', also: ['nigga'] },
+    { word: 'kike' },
+    { word: 'retard' },
+    { word: 'tranny' },
+]) {
+    looseWords.addPhrase((phrase) => {
+        phrase.setMetadata({ originalWord: entry.word });
+        for (const word of spellings(entry))
+            phrase.addPattern(parseRawPattern(collapsed(word, '')));
+        return phrase;
+    });
+}
+const loose = new RegExpMatcher({
+    ...looseWords.build(),
+    blacklistMatcherTransformers: [
+        resolveConfusablesTransformer(),
+        resolveLeetSpeakTransformer(),
+        toAsciiLowerCaseTransformer(),
+        skipNonAlphabeticTransformer(),
+        collapseDuplicatesTransformer({ defaultThreshold: 1 }),
+    ],
+});
+/** What a digit or symbol stands for when it is standing for a letter. */
+const LETTERS = {
+    '0': ['o'],
+    '1': ['i', 'l'],
+    '!': ['i', 'l'],
+    '|': ['i', 'l'],
+    '2': ['z'],
+    '3': ['e'],
+    '4': ['a'],
+    '@': ['a'],
+    '5': ['s'],
+    $: ['s'],
+    '6': ['g', 'b'],
+    '7': ['t'],
+    '8': ['b'],
+    '9': ['g'],
+};
+/**
+ * Lowercase letters with the digits read as letters and nothing else, runs
+ * collapsed. Every reading, since `1` may be an `i` or an `l`; the first is
+ * the one a list entry is stored under.
+ */
+function flattenings(name) {
+    let forms = [''];
+    for (const char of name.toLowerCase()) {
+        const readings = /[a-z]/.test(char) ? [char] : (LETTERS[char] ?? []);
+        if (readings.length === 0)
+            continue;
+        // Bounded: a name of nothing but `1`s would otherwise double at every one.
+        const next = forms.length * readings.length > 64 ? readings.slice(0, 1) : readings;
+        forms = forms.flatMap((form) => next.map((letter) => form + letter));
+    }
+    return [...new Set(forms.map((form) => form.replace(/(.)\1+/g, '$1')))];
+}
+const reserved = new Set([...reservedUsernames, ...SYSTEM, ...PEOPLE].map((entry) => flattenings(entry)[0]));
+/** The name in the shapes a word might hide in. */
+function shapes(name) {
+    const parts = name.split(/[^A-Za-z0-9æøåÆØÅ]+/).filter(Boolean);
+    return [
+        name,
+        name.replace(/([a-zæøå])([A-ZÆØÅ])/g, '$1 $2'),
+        parts.map((part) => part.replace(/^\d+|\d+$/g, '')).join(' '),
+        parts.join(''),
+    ];
+}
+/** The refusal as a sentence the person can act on. */
+export function explain(reason, rules = DEFAULT_RULES) {
+    switch (reason) {
+        case 'too_short':
+            return `A username needs at least ${rules.minLength} characters.`;
+        case 'too_long':
+            return `A username can have at most ${rules.maxLength} characters.`;
+        case 'characters':
+            return 'A username is letters, digits, dots, dashes and underscores, and starts with a letter or digit.';
+        case 'reserved':
+            return 'That username is reserved.';
+        case 'disallowed':
+            return 'That username is not allowed.';
+    }
+}
+export function checkName(name, rules = DEFAULT_RULES) {
+    const typed = name.trim();
+    if (typed.length < rules.minLength)
+        return { ok: false, reason: 'too_short' };
+    if (typed.length > rules.maxLength)
+        return { ok: false, reason: 'too_long' };
+    if (!rules.pattern.test(typed))
+        return { ok: false, reason: 'characters' };
+    const digitsKept = typed.toLowerCase().replace(/[^a-z0-9]/g, '');
+    if (NUMERIC.some((entry) => digitsKept.includes(entry)))
+        return { ok: false, reason: 'disallowed' };
+    if (loose.hasMatch(typed))
+        return { ok: false, reason: 'disallowed' };
+    if (shapes(typed).some((shape) => strict.hasMatch(shape))) {
+        return { ok: false, reason: 'disallowed' };
+    }
+    // Last, so that a number that means something (`14.88` reads as `lab`) is refused for what it is.
+    if (flattenings(typed).some((form) => reserved.has(form))) {
+        return { ok: false, reason: 'reserved' };
+    }
+    return { ok: true };
+}

package/dist/names.list.d.ts

@@ -0,0 +1,19 @@
+/**
+ * What obscenity's English set does not know, and what is ours. Edit freely.
+ *
+ * `anywhere` words are refused wherever they appear, however spelled -- so
+ * only words with no innocent containing word belong there; `coon` (raccoon)
+ * and `paki` (Pakistan) do not. The rest are refused as a whole name or as a
+ * part of one split at separators and case changes: `nazi` and `big_nazi`
+ * are out, `ashkenazi` is not. `also` lists other spellings of the same word.
+ */
+export interface Entry {
+    word: string;
+    anywhere?: boolean;
+    also?: string[];
+}
+export declare const PHRASES: Entry[];
+/** Innocent names obscenity's English patterns would otherwise catch. */
+export declare const WHITELIST: string[];
+/** Read on the name with its digits kept, for the things that are numbers. */
+export declare const NUMERIC: string[];

package/dist/names.list.js

@@ -0,0 +1,42 @@
+export const PHRASES = [
+    // en, beyond obscenity's set
+    { word: 'faggot', anywhere: true },
+    { word: 'chink', anywhere: true },
+    { word: 'wetback', anywhere: true },
+    { word: 'raghead', anywhere: true },
+    { word: 'towelhead', anywhere: true },
+    { word: 'hitler', anywhere: true },
+    { word: 'gook' },
+    { word: 'spic' },
+    { word: 'coon' },
+    { word: 'paki' },
+    { word: 'nazi' },
+    { word: 'pedo', also: ['paedo', 'pedophile', 'paedophile'] },
+    { word: 'rapist' },
+    { word: 'homo' },
+    // no
+    { word: 'neger', anywhere: true },
+    { word: 'svarting', anywhere: true },
+    { word: 'sotrør', anywhere: true, also: ['sotror'] },
+    { word: 'morraknuller', anywhere: true },
+    { word: 'morrapuler', anywhere: true },
+    { word: 'pakkis' }, // collapsed to `pakis`, it would hide in pakistan; whole word only
+    { word: 'faen' },
+    { word: 'fitte' },
+    { word: 'kuk' },
+    { word: 'pikk' },
+    { word: 'hore' },
+    { word: 'ræva', also: ['raeva', 'reva'] },
+    { word: 'helvete' },
+    { word: 'jævla', also: ['jaevla', 'jevla', 'jævlig', 'jaevlig', 'jevlig'] },
+    { word: 'drittsekk' },
+    { word: 'soper' },
+    { word: 'homse' },
+    { word: 'mongo', also: ['mongis'] },
+    { word: 'tater' },
+    { word: 'sigøyner', also: ['sigoyner'] },
+];
+/** Innocent names obscenity's English patterns would otherwise catch. */
+export const WHITELIST = ['shiitake', 'fager'];
+/** Read on the name with its digits kept, for the things that are numbers. */
+export const NUMERIC = ['kkk', '1488'];

package/dist/names.reserved.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Names nobody may choose. Edit freely; order and duplicates do not matter.
+ *
+ * Both lists are compared on a flattened form: lower case, digits and symbols
+ * read as the letters they stand for, repeated letters collapsed. So `adm1n`,
+ * `Admin`, `a.d.m.i.n` and `aadmin` are all `admin`, and `K4i` is `kai`.
+ *
+ * SYSTEM is every name that would let somebody pass as us, as the software,
+ * as a mailbox that means something, or as a path an app is likely to have.
+ * The `reserved-usernames` package is applied as well, so this list is the
+ * one we can read and vouch for rather than the only one.
+ *
+ * PEOPLE are names held for particular people. They are refused like the
+ * system ones, so the person they are held for gets them by being given
+ * them, not by racing for them.
+ */
+export declare const SYSTEM: string[];
+export declare const PEOPLE: string[];