@protontech/autofill 0.0.22991789

package/README.md

@@ -0,0 +1 @@
+Model weights used by the Proton fork of Fathom.

package/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env ts-node-script
+export {};

package/cli.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env ts-node-script
+import { exec } from "child_process";
+import { Command } from "commander";
+import fs from "fs/promises";
+import path from "path";
+import prettier from "prettier";
+import { FORM_FEATURES } from "./features/abstract.form";
+import { EMAIL_FIELD_FEATURES } from "./features/field.email";
+import { OTP_FIELD_FEATURES } from "./features/field.otp";
+import { PW_FIELD_FEATURES } from "./features/field.password";
+import { USERNAME_FIELD_FEATURES } from "./features/field.username";
+import { HIDDEN_USER_FIELD_FEATURES } from "./features/field.username-hidden";
+const program = new Command();
+const FEATURE_MAP = {
+    login: FORM_FEATURES,
+    register: FORM_FEATURES,
+    "password-change": FORM_FEATURES,
+    recovery: FORM_FEATURES,
+    username: USERNAME_FIELD_FEATURES,
+    "username-hidden": HIDDEN_USER_FIELD_FEATURES,
+    email: EMAIL_FIELD_FEATURES,
+    password: PW_FIELD_FEATURES,
+    "new-password": PW_FIELD_FEATURES,
+    otp: OTP_FIELD_FEATURES,
+};
+program.version("0.0.1").description("CLI utilities for ProtonPass fathom");
+program
+    .command("get-vector [id]")
+    .description("Gets a human readable vector for a specific dataset entry")
+    .requiredOption("--trainee <trainee>")
+    .action(async (id, options) => {
+    try {
+        const file = await fs.readFile(`./dist/vectors/training_${options.trainee}.json`, "utf8");
+        const training = JSON.parse(file).pages;
+        const entry = training.find(({ filename }) => filename.startsWith(id));
+        if (entry === undefined) {
+            console.log("No entry found");
+        }
+        const featureSet = FEATURE_MAP[options.trainee];
+        if (featureSet === undefined)
+            throw new Error(`unknown feature set for trainee ${options.trainee}`);
+        entry === null || entry === void 0 ? void 0 : entry.nodes.forEach(({ features, markup, isTarget }) => {
+            console.log(`${markup} ${isTarget ? "✅" : "❌"}`);
+            features.forEach((value, i) => {
+                var _a;
+                console.log(`↳ ${(_a = featureSet === null || featureSet === void 0 ? void 0 : featureSet[i]) !== null && _a !== void 0 ? _a : "unknown"} = ${value}`);
+            });
+            console.log("\n");
+        });
+    }
+    catch (e) {
+        console.warn("Could not read file - try training your trainee first", e);
+    }
+});
+const buildCommand = (trainee) => `yarn train -- ${trainee} --delay 12 --iterations 5000 --learning-rate 0.5 --tabs 20`;
+const extractResults = (stdout) => {
+    const jsonRegex = /{[\s\S]+}/;
+    const jsonMatch = stdout.match(jsonRegex);
+    if (!(jsonMatch === null || jsonMatch === void 0 ? void 0 : jsonMatch[0]))
+        throw new Error("Could not parse weights");
+    return JSON.parse(jsonMatch[0]);
+};
+const extractCutoff = (stdout) => {
+    const cutoffRegex = /Optimal cutoff: (\d+(\.\d+)?)/;
+    const cutoffMatch = stdout.match(cutoffRegex);
+    if (!cutoffMatch)
+        throw new Error("Could not parse cutoff");
+    return parseFloat(cutoffMatch[1]);
+};
+const extractSummary = (stdout) => {
+    const dataRegex = /Training precision:(?:.|\n)+?(?=Training per-tag results)/s;
+    const ansiColorRegex = /\x1b\[[0-9;]*m/g;
+    const dataMatch = stdout.match(dataRegex);
+    if (!(dataMatch === null || dataMatch === void 0 ? void 0 : dataMatch[0]))
+        throw new Error("Could not parse results");
+    return dataMatch[0].replace(ansiColorRegex, "");
+};
+const train = async (trainee) => {
+    const basePath = path.resolve(__dirname, "trainees/results");
+    const id = trainee.toUpperCase();
+    console.info(`\n[${id}]: Start training`);
+    console.time(`[${id}]`);
+    return new Promise((resolve) => {
+        exec(buildCommand(trainee), async (error, stdout) => {
+            console.timeEnd(`[${id}]`);
+            if (error) {
+                console.error(`[${id}]: Error during training: ${error.message}`);
+                resolve();
+            }
+            const results = extractResults(stdout);
+            results.cutoff = extractCutoff(stdout);
+            const summary = extractSummary(stdout);
+            console.log(summary);
+            let output = `// ${trainee.toUpperCase()} (trained on ${new Date().toDateString()})\n`;
+            output += summary
+                .split("\n")
+                .filter(Boolean)
+                .map((line) => `// ${line}`)
+                .join("\n");
+            output += `\n\nimport { TrainingResults } from "src/types";\n\n`;
+            output += `export const results: TrainingResults = ${JSON.stringify(results)};`;
+            await fs.writeFile(path.resolve(basePath, `result.${trainee}.ts`), await prettier.format(output, {
+                tabWidth: 2,
+                useTabs: false,
+                printWidth: 160,
+                parser: "babel-ts",
+            }));
+            resolve();
+        });
+    });
+};
+program.command("train [trainee]").description("trains a specific trainee").action(train);
+program
+    .command("train-all")
+    .description("Sequentially trains all models and updates scores between each run")
+    .option("--type <type>")
+    .action(async (options) => {
+    const type = options === null || options === void 0 ? void 0 : options.type;
+    const formTrainees = !type || type === "form" ? ["login", "register", "password-change", "recovery"] : [];
+    const fieldTrainees = !type || type === "field" ? ["username", "username-hidden", "email", "password", "new-password", "otp"] : [];
+    for (const form of formTrainees) {
+        await train(form);
+    }
+    for (const field of fieldTrainees) {
+        await train(field);
+    }
+});
+program.parse(process.argv);

package/constants/heuristics.d.ts

@@ -0,0 +1,15 @@
+export declare const MAX_FORM_FIELD_WALK_UP = 3;
+export declare const MAX_FORM_HEADING_WALK_UP = 3;
+export declare const MAX_HEADING_HORIZONTAL_DIST = 75;
+export declare const MAX_HEADING_VERTICAL_DIST = 150;
+export declare const MAX_CLUSTER_SPLIT_DISTANCE = 400;
+export declare const MAX_VISIBILITY_WALK_UP = 1;
+export declare const MIN_AREA_SUBMIT_BTN = 3500;
+export declare const MIN_FIELD_HEIGHT = 15;
+export declare const MIN_FIELD_WIDTH = 30;
+export declare const MAX_INPUTS_PER_FORM = 40;
+export declare const MAX_FIELDS_PER_FORM = 60;
+export declare const MAX_HIDDEN_FIELD_VALUE_LENGTH = 320;
+export declare const HIDDEN_FIELD_IGNORE_VALUES: string[];
+export declare const OTP_PATTERNS: [number, string][];
+export declare const VALID_INPUT_TYPES: string[];

package/constants/heuristics.js

@@ -0,0 +1,21 @@
+export const MAX_FORM_FIELD_WALK_UP = 3;
+export const MAX_FORM_HEADING_WALK_UP = 3;
+export const MAX_HEADING_HORIZONTAL_DIST = 75;
+export const MAX_HEADING_VERTICAL_DIST = 150;
+export const MAX_CLUSTER_SPLIT_DISTANCE = 400;
+export const MAX_VISIBILITY_WALK_UP = 1;
+export const MIN_AREA_SUBMIT_BTN = 3500;
+export const MIN_FIELD_HEIGHT = 15;
+export const MIN_FIELD_WIDTH = 30;
+export const MAX_INPUTS_PER_FORM = 40;
+export const MAX_FIELDS_PER_FORM = 60;
+export const MAX_HIDDEN_FIELD_VALUE_LENGTH = 320;
+export const HIDDEN_FIELD_IGNORE_VALUES = ["0", "1", "true", "false"];
+export const OTP_PATTERNS = [
+    [1, "d*"],
+    [6, "d{6}"],
+    [1, "[0-9]*"],
+    [6, "[0-9]{6}"],
+    [5, "([0-9a-fA-F]{5}-?[0-9a-fA-F]{5})"],
+];
+export const VALID_INPUT_TYPES = ["text", "email", "number", "tel", "password", "hidden", "search"];

package/constants/selectors.d.ts

@@ -0,0 +1,18 @@
+export declare const FORM_CLUSTER_ATTR = "data-protonpass-form";
+export declare const kFieldSelector = "input, select, textarea";
+export declare const kEmailSelector = "input[name=\"email\"], input[id=\"email\"]";
+export declare const kPasswordSelector = "input[type=\"password\"], input[type=\"text\"][id=\"password\"]";
+export declare const kCaptchaSelector = "[class*=\"captcha\"], [id*=\"captcha\"], [name*=\"captcha\"]";
+export declare const kSocialSelector = "[class*=social], [aria-label*=with]";
+export declare const kEditorSelector = "div[class*=\"editor\" i], div[id*=\"editor\" i], div[class*=\"composer\" i], div[id*=\"composer\" i]";
+export declare const kDomGroupSelector = "[role=\"dialog\"], [role=\"tabpanel\"], [role=\"group\"], [role=\"form\"], [id*=\"modal\"], [class*=\"modal\"], header, section, nav, footer, aside";
+export declare const kUsernameSelector: string;
+export declare const kHiddenUsernameSelector: string;
+export declare const kHeadingSelector: string;
+export declare const kButtonSubmitSelector: string;
+export declare const kLayoutSelector = "div, section, aside, main, nav";
+export declare const kAnchorLinkSelector = "a, span[role=\"button\"]";
+export declare const formCandidateSelector = "form, [data-protonpass-form]";
+export declare const inputCandidateSelector = "input:not([type=\"hidden\"]):not([type=\"submit\"]):not([type=\"button\"]):not([type=\"image\"]):not([type=\"checkbox\"])";
+export declare const buttonSelector: string;
+export declare const otpSelector = "[type=\"tel\"], [type=\"number\"], [type=\"text\"], input:not([type])";

package/constants/selectors.js

@@ -0,0 +1,52 @@
+export const FORM_CLUSTER_ATTR = "data-protonpass-form";
+export const kFieldSelector = "input, select, textarea";
+export const kEmailSelector = 'input[name="email"], input[id="email"]';
+export const kPasswordSelector = 'input[type="password"], input[type="text"][id="password"]';
+export const kCaptchaSelector = `[class*="captcha"], [id*="captcha"], [name*="captcha"]`;
+export const kSocialSelector = `[class*=social], [aria-label*=with]`;
+export const kEditorSelector = 'div[class*="editor" i], div[id*="editor" i], div[class*="composer" i], div[id*="composer" i]';
+export const kDomGroupSelector = `[role="dialog"], [role="tabpanel"], [role="group"], [role="form"], [id*="modal"], [class*="modal"], header, section, nav, footer, aside`;
+export const kUsernameSelector = [
+    'input[type="login"]',
+    'input[type="username"]',
+    'input[type="search"][name="loginName"]',
+    'input[type="password"][name="userID"]',
+    'input[type="password"][name="USERNAME"]',
+    'input[name="account"]',
+    'input[name="quickconnect-id"]',
+].join(",");
+export const kHiddenUsernameSelector = [
+    '[name*="user" i]',
+    '[id*="user" i]',
+    '[name*="login" i]',
+    '[id*="login" i]',
+    '[name*="email" i]',
+    '[id*="email" i]',
+    '[name*="identifier" i]',
+    '[id*="identifier" i]',
+].join(",");
+export const kHeadingSelector = [
+    ...[1, 2, 3, 4, 5].flatMap((level) => [`h${level}, [aria-level="${level}"]`]),
+    '[role="heading"]',
+    '[class*="title"]',
+    '[class*="header"]',
+    '[name="title"]',
+    'div[style*="font-size: 2"]',
+    'div[style*="font-size: 3"]',
+].join(",");
+export const kButtonSubmitSelector = [
+    'input[type="submit"]',
+    'button[id*="password" i]',
+    'button[type="submit"]',
+    'button[type="button"]',
+    'button[name="submit"]',
+    'a[role="submit"]',
+    'div[role="button"]',
+    'div[role="submit"]',
+].join(",");
+export const kLayoutSelector = `div, section, aside, main, nav`;
+export const kAnchorLinkSelector = `a, span[role="button"]`;
+export const formCandidateSelector = `form, [${FORM_CLUSTER_ATTR}]`;
+export const inputCandidateSelector = 'input:not([type="hidden"]):not([type="submit"]):not([type="button"]):not([type="image"]):not([type="checkbox"])';
+export const buttonSelector = `button:not([type]), a[role="button"], ${kButtonSubmitSelector}`;
+export const otpSelector = '[type="tel"], [type="number"], [type="text"], input:not([type])';

package/debug.d.ts

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

package/debug.js

@@ -0,0 +1,17 @@
+import * as visibilityUtils from "./utils/visible";
+import * as clusteringUtils from "./utils/clustering";
+import * as formUtils from "./utils/form";
+import * as fieldRules from "./utils/field";
+import * as trainees from "./trainees";
+import * as exclusions from "./utils/exclusion";
+import * as prepass from "./utils/prepass";
+window.PROTON_PASS_FATHOM_DEBUG = {
+    createMockFnode: (element) => ({ element }),
+    ...clusteringUtils,
+    ...visibilityUtils,
+    ...formUtils,
+    ...fieldRules,
+    ...trainees,
+    ...exclusions,
+    ...prepass,
+};

package/dictionary/generate.d.ts

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

package/dictionary/generate.js

@@ -0,0 +1,42 @@
+import fs from "fs";
+import path from "path";
+import regexgen from "regexgen";
+import { sanitizeString } from "../utils/text";
+import dictionary from "./source/dictionary";
+const generateRegexes = () => {
+    let output = "";
+    output += "/* Regular expressions auto-generated using `source/dictionary.ts`\n";
+    output += " * Simplified & optimised using `regexgen` for performance. \n";
+    output += " * `TYPE_RE`: i18n regexp for text matches\n";
+    output += " * `TYPE_ATTR_RE`: regexp for node attributes\n";
+    output += " * `TYPE_ATTR_END`: attr ending constraint regexp */\n\n";
+    Object.entries(dictionary).forEach(([name, definition]) => {
+        var _a, _b, _c, _d, _e, _f;
+        const words = Object.values(definition.i18n).flat().map(sanitizeString);
+        const attrs = ((_b = (_a = definition === null || definition === void 0 ? void 0 : definition.attr) === null || _a === void 0 ? void 0 : _a.values) !== null && _b !== void 0 ? _b : []).map(sanitizeString);
+        const attrsExact = ((_d = (_c = definition === null || definition === void 0 ? void 0 : definition.attr) === null || _c === void 0 ? void 0 : _c.exact) !== null && _d !== void 0 ? _d : []).map(sanitizeString);
+        if (words.length > 0) {
+            output += `export const ${name}_RE = ${regexgen(words, "")}i;\n`;
+        }
+        if (attrs.length > 0 || attrsExact.length > 0) {
+            const regAttrs = attrs.length > 0 ? regexgen(attrs, "").source : null;
+            const regExact = attrsExact.length > 0 ? `\\b(${regexgen(attrsExact, "").source})\\b` : null;
+            if (regAttrs && !regExact)
+                output += `export const ${name}_ATTR_RE = /${regAttrs}/i;\n`;
+            else if (!regAttrs && regExact)
+                output += `export const ${name}_ATTR_RE = /${regExact}/i;\n`;
+            else if (regAttrs && regExact)
+                output += `export const ${name}_ATTR_RE = /${regAttrs}|${regExact}/i;\n`;
+        }
+        if ((_e = definition.attr) === null || _e === void 0 ? void 0 : _e.startsWith) {
+            const startWithRe = regexgen(definition.attr.startsWith.map(sanitizeString), "");
+            output += `export const ${name}_ATTR_START_RE = /^(?:${startWithRe.source}).*\\b/i;\n`;
+        }
+        if ((_f = definition.attr) === null || _f === void 0 ? void 0 : _f.endsWith) {
+            const endWordsRe = regexgen(definition.attr.endsWith.map(sanitizeString), "");
+            output += `export const ${name}_ATTR_END_RE= /\\b.*(?:${endWordsRe.source})$/i;\n`;
+        }
+    });
+    fs.writeFileSync(path.resolve(__dirname, "./generated/dictionary.ts"), output);
+};
+generateRegexes();

package/dictionary/generated/dictionary.d.ts

@@ -0,0 +1,51 @@
+export declare const LOGIN_RE: RegExp;
+export declare const REGISTER_RE: RegExp;
+export declare const RECOVERY_RE: RegExp;
+export declare const MULTI_STEP_RE: RegExp;
+export declare const TROUBLE_RE: RegExp;
+export declare const PASSWORD_RE: RegExp;
+export declare const PASSWORD_ATTR_RE: RegExp;
+export declare const PASSWORD_OUTLIER_RE: RegExp;
+export declare const USERNAME_RE: RegExp;
+export declare const USERNAME_ATTR_RE: RegExp;
+export declare const USERNAME_OUTLIER_RE: RegExp;
+export declare const EMAIL_RE: RegExp;
+export declare const EMAIL_ATTR_RE: RegExp;
+export declare const TEL_RE: RegExp;
+export declare const CAPTCHA_ATTR_RE: RegExp;
+export declare const SUBMIT_ACTION_RE: RegExp;
+export declare const CREATE_ACTION_RE: RegExp;
+export declare const CREATE_ACTION_ATTR_END_RE: RegExp;
+export declare const RESET_ACTION_RE: RegExp;
+export declare const CONFIRM_ACTION_RE: RegExp;
+export declare const CONFIRM_ACTION_ATTR_END_RE: RegExp;
+export declare const STEP_ACTION_RE: RegExp;
+export declare const REMEMBER_ACTION_RE: RegExp;
+export declare const SEARCH_ACTION_RE: RegExp;
+export declare const CURRENT_VALUE_RE: RegExp;
+export declare const CURRENT_VALUE_ATTR_RE: RegExp;
+export declare const HIDDEN_ATTR_RE: RegExp;
+export declare const OAUTH_ATTR_RE: RegExp;
+export declare const TOS_RE: RegExp;
+export declare const MFA_ACTION_RE: RegExp;
+export declare const MFA_RE: RegExp;
+export declare const MFA_ATTR_RE: RegExp;
+export declare const OTP_ATTR_RE: RegExp;
+export declare const OTP_OUTLIER_RE: RegExp;
+export declare const OTP_OUTLIER_ATTR_RE: RegExp;
+export declare const NEWSLETTER_RE: RegExp;
+export declare const NEWSLETTER_ATTR_RE: RegExp;
+export declare const IDENTITY_FULLNAME_ATTR_RE: RegExp;
+export declare const IDENTITY_FIRSTNAME_ATTR_RE: RegExp;
+export declare const IDENTITY_MIDDLENAME_ATTR_RE: RegExp;
+export declare const IDENTITY_LASTNAME_ATTR_RE: RegExp;
+export declare const IDENTITY_TELEPHONE_ATTR_RE: RegExp;
+export declare const IDENTITY_TELEPHONE_PREFIX_ATTR_RE: RegExp;
+export declare const IDENTITY_ADDRESS_ATTR_RE: RegExp;
+export declare const IDENTITY_ADDRESS_LINES_ATTR_END_RE: RegExp;
+export declare const IDENTITY_STATE_ATTR_RE: RegExp;
+export declare const IDENTITY_CITY_ATTR_RE: RegExp;
+export declare const IDENTITY_ZIPCODE_ATTR_RE: RegExp;
+export declare const IDENTITY_ORGANIZATION_ATTR_RE: RegExp;
+export declare const IDENTITY_COUNTRY_ATTR_RE: RegExp;
+export declare const IDENTITY_COUNTRY_CODE_ATTR_RE: RegExp;

package/dictionary/generated/dictionary.js

@@ -0,0 +1,51 @@
+export const LOGIN_RE = /(?:(?:n(?:ouvelleses|uevase|ewses)s|iniciarses|connex)io|anmeldedate|sign[io])n|in(?:iciarsessao|troduce)|a(?:uthenticate|nmeld(?:ung|en)|ccedi)|authentifier|s(?:econnect|identifi)er|novasessao|(?:introduci|conecta|accede|entr[ae])r|prihlasit|connect|login/i;
+export const REGISTER_RE = /kontoerstellen|cr(?:ea(?:reaccount|teaccount|rcuenta|account)|iarconta)|(?:nouveaucompt|creeruncompt|s?inscrir|unirs)e|re(?:gist(?:r(?:ieren|a(?:rse|ti)|ar)|er)|joindre)|nuevacuenta|getstarted|neueskonto|newaccount|novaconta|(?:com(?:mence|eca)|(?:empez|junt)a)r|signup|join/i;
+export const RECOVERY_RE = /(?:wiederherstell|zurucksetz)en|re(?:(?:initialis|stablec)er|(?:defini|staur[ae])r|c(?:uper[ae]|ove)r|set)|problem|(?:troubl|restor|aid)e|a[jy]uda|h(?:ilfe|elp)/i;
+export const MULTI_STEP_RE = /p(?:rogres(?:s(?:ion|o)|o)|aso)|fortschritt|progress|s(?:chritt|t(?:age|ep))|etap[ae]|phase/i;
+export const TROUBLE_RE = /schwierigkeit|(?:difficult|troubl|oubli|hilf)e|i(?:nciden(?:cia|t)|ssue)|vergessen|esquecido|olvidado|needhelp|questao|problem|forgot|ayuda/i;
+export const PASSWORD_RE = /p(?:hrasesecrete|ass(?:(?:phras|cod)e|wor[dt]))|(?:c(?:havesecret|lavesecret|ontrasen)|deseguranc)a|(?:(?:zugangs|secret)cod|clesecret)e|codesecret|motdepasse|geheimnis|secret|heslo|senha|key/i;
+export const PASSWORD_ATTR_RE = /p(?:ass|wd?)|fmt|mdp/i;
+export const PASSWORD_OUTLIER_RE = /socialsecurity|nationalid|userid/i;
+export const USERNAME_RE = /(?:identifi(?:cado|e)|benutze)r|identi(?:fiant|ty)|u(?:tilisateur|s(?:ername|uario?))|(?:screen|nick)name|nutzername|(?:anmeld|handl)e|pseudo/i;
+export const USERNAME_ATTR_RE = /identifyemail|(?:custom|us)erid|loginname|a(?:cc(?:ountid|t)|ppleid)|loginid/i;
+export const USERNAME_OUTLIER_RE = /(?:nom(?:defamill|br)|tit[lr])e|(?:primeiro|sobre)nome|(?:company|middle|nach|vor)name|firstname|apellido|lastname|prenom/i;
+export const EMAIL_RE = /co(?:urriel|rrei?o)|email/i;
+export const EMAIL_ATTR_RE = /usermail/i;
+export const TEL_RE = /numerodetel|phonenumber|cellnumber|cellphone|tele(?:phone|fon[eo]?)|celular|mo(?:bile|vil)|mobil/i;
+export const CAPTCHA_ATTR_RE = /(?:solvemedi|(?:key|fun|re|h)?captch)a/i;
+export const SUBMIT_ACTION_RE = /(?:valide|envia)r|s(?:enden|ubmit)|go/i;
+export const CREATE_ACTION_RE = /erstellen|n(?:o(?:uveau|vo)|uevo|e[uw])|cr(?:e(?:a[rt]e|er)|iar)|crear|set/i;
+export const CREATE_ACTION_ATTR_END_RE = /\b.*(?:fst|1)$/i;
+export const RESET_ACTION_RE = /(?:a(?:ktualisiere|nder)|zurucksetze)n|(?:re(?:initialise|stablece|defini)|mettreajou)r|a(?:ctualiz|tualiz|lter)ar|c(?:ambiar|hange)|update|reset/i;
+export const CONFIRM_ACTION_RE = /digitarnovamente|v(?:olveraescribi|erifi(?:ca|e))r|saisiranouveau|(?:erneuteingeb|wiederhol|bestatig)en|verif(?:izieren|y)|re(?:pe(?:t[ei]r|at)|type)|confirm|again/i;
+export const CONFIRM_ACTION_ATTR_END_RE = /\b.*(?:snd|bis|2)$/i;
+export const STEP_ACTION_RE = /(?:f(?:ertigstell|ortfahr)|abschlie)en|getstarted|siguiente|(?:preceden|suivan|accep)t|(?:finaliza|termin[ae]|anterio|weite)r|co(?:mplet(?:ar|e)|ntinu(?:ar|e))|pro(?:c(?:hain|eed)|ximo)|finish|zuruck|back|next/i;
+export const REMEMBER_ACTION_RE = /angemeldetbleiben|lembrardemim|micherinnern|sesouvenirde|re(?:cordarme|member|ster)|manterme|mantener|stay|keep/i;
+export const SEARCH_ACTION_RE = /recherche|buscar|s(?:earch|uche)|query/i;
+export const CURRENT_VALUE_RE = /(?:be(?:stehend|for)|vorherig|aktuell)e|exist(?:ente|ing)|pre(?:cedent|vious)|a(?:n(?:t(?:erior|igo)|cien)|ctu[ae]l|tual)|existant|dernier|current|(?:ultim|viej)o|(?:letz|al)te|last|old/i;
+export const CURRENT_VALUE_ATTR_RE = /prev|curr/i;
+export const HIDDEN_ATTR_RE = /s(?:creenreade)?ronly|(?:move)?offscreen|(?:displaynon|a11yhid)e|\b((?:is)?hidden)\b/i;
+export const OAUTH_ATTR_RE = /facebook|twitch|google|apple/i;
+export const TOS_RE = /(?:datenschutzrichtlini|politicadeprivacidad|confidentialit|a(?:cknowledg|gre))e|nutzungsbedingungen|(?:consentimi?ent|ac(?:ue|o)rd)o|(?:einwillig|zustimm)ung|consentement|condi(?:cione|tion)s|term(?:osdeuso|inos|sof)|(?:privacida|understan)d|guideline|consent|p(?:riva|oli)cy|accord/i;
+export const MFA_ACTION_RE = /enter(?:auth)?code|confirm|verify/i;
+export const MFA_RE = /(?:authentifizierung|doisfatore|doispasso)s|(?:auth(?:entication)?cod|securitycod|doubleetap)e|(?:authentication|generator)app|(?:(?:authentifica|doublefac)teu|(?:(?:authentifika|doblefac|zweifak|twofac)t|aut(?:henticat|enticad))o)r|verifica(?:c(?:ion|ao)|tion)|multifa(?:ct(?:eu|o)|k?to)r|zweischritte|generadora|doblepaso|2(?:s(?:chritte|tep)|(?:etap[ae]|paso)s|fa)|twostep/i;
+export const MFA_ATTR_RE = /phoneverification|(?:approvals|login)code|challenge|t(?:wo(?:fa(?:ctor)?|step)|facode)|2fa|\b([mt]fa)\b/i;
+export const OTP_ATTR_RE = /totp(?:pin)?|o(?:netime|t[cp])|1time/i;
+export const OTP_OUTLIER_RE = /n(?:(?:ue|o)vocodigo|ouveaucode|e(?:usenden|(?:uer|w)code))|re(?:enviar|send)|envoyer|senden|enviar|send/i;
+export const OTP_OUTLIER_ATTR_RE = /(?:phone(?:verification)?|email|tel)pin|email|sms/i;
+export const NEWSLETTER_RE = /newsletter|b(?:ul|o)letin|mailing/i;
+export const NEWSLETTER_ATTR_RE = /subscription|mailinglist|newsletter|emailform/i;
+export const IDENTITY_FULLNAME_ATTR_RE = /addresscontact|contactperson|addressname|yourname|fullname|\b(name)\b/i;
+export const IDENTITY_FIRSTNAME_ATTR_RE = /givenname|firstn(?:ame)?|\b(fname)\b/i;
+export const IDENTITY_MIDDLENAME_ATTR_RE = /additionalname|middlen(?:ame)?|\b(mname)\b/i;
+export const IDENTITY_LASTNAME_ATTR_RE = /familyn(?:ame)?|lastn(?:ame)?|surname|\b([ls]name)\b/i;
+export const IDENTITY_TELEPHONE_ATTR_RE = /(?:national|contact)number|tel(?:nation|loc)al|(?:tele)?phone|mobile|\b(tel)\b/i;
+export const IDENTITY_TELEPHONE_PREFIX_ATTR_RE = /co(?:untry|de)|prefix/i;
+export const IDENTITY_ADDRESS_ATTR_RE = /(?:preferred|street)address|address(?:line(?:one|[1s])|1)|mailingaddr|bill(?:ing)?addr|\b(mailaddr|addr(?:ess)?|street|line1)\b/i;
+export const IDENTITY_ADDRESS_LINES_ATTR_END_RE = /\b.*(?:line(?:t(?:hree|wo)|[23]))$/i;
+export const IDENTITY_STATE_ATTR_RE = /address(?:(?:provinc|stat)e|level1)|stateprovince|\b(province|county|region|state)\b/i;
+export const IDENTITY_CITY_ATTR_RE = /address(?:level2|town|city)|personalcity|\b((?:local|c)ity|town)\b/i;
+export const IDENTITY_ZIPCODE_ATTR_RE = /(?:address(?:postal|zip)|post)code|address(?:postal|zip)|postalcode|zipcode|\b(zip)\b/i;
+export const IDENTITY_ORGANIZATION_ATTR_RE = /organization(?:name)?|companyname|\b(organization)\b/i;
+export const IDENTITY_COUNTRY_ATTR_RE = /addresscountry(?:name)?|countryname|\b(country)\b/i;
+export const IDENTITY_COUNTRY_CODE_ATTR_RE = /countrycode/i;

package/dictionary/source/dictionary.d.ts

@@ -0,0 +1,11 @@
+type DictionaryEntry = {
+    i18n: Record<string, string[]>;
+    attr?: {
+        values?: string[];
+        exact?: string[];
+        endsWith?: string[];
+        startsWith?: string[];
+    };
+};
+declare const dictionary: Record<string, DictionaryEntry>;
+export default dictionary;