@protontech/autofill 0.0.22991789 → 0.0.33835493

package/dictionary/source/dictionary.js

@@ -4,10 +4,10 @@ const dictionary = {
             en: ["login", "signin", "signon", "authenticate", "connect", "new session"],
             fr: ["connexion", "se connecter", "s'identifier", "authentifier", "entrer", "nouvelle session"],
             es: ["introduce", "introducir", "entrar", "iniciar sesión", "acceder", "nueva sesión"],
-            de: ["anmelden", "anmeldung", "anmeldedaten"],
+            de: ["anmelden", "anmeldung", "anmeldedaten", "authentifizierungs"],
             pt: ["iniciar sessão", "conectar", "entrar", "nova sessão"],
             cz: ["přihlásit"],
-            it: ['accedi']
+            nl: ["inloggen"],
         },
     },
     REGISTER: {
@@ -15,14 +15,14 @@ const dictionary = {
             en: ["register", "sign up", "create account", "join", "new account", "get started"],
             fr: ["inscrire", "créer un compte", "rejoindre", "commencer", "nouveau compte", "s'inscrire"],
             es: ["registrarse", "crear cuenta", "unirse", "empezar", "nueva cuenta"],
-            de: ["registrieren", "neues konto", "konto erstellen"],
+            de: ["registrieren", "registrierung", "neues konto", "konto erstellen"],
             pt: ["registrar", "criar conta", "juntar", "começar", "nova conta"],
-            it: ['crea account', 'creare account', 'registrati']
+            it: ["crea account", "creare account", "registrati"],
         },
     },
     RECOVERY: {
         i18n: {
-            en: ["help", "recover", "restore", "reset", "trouble", "problem"],
+            en: ["help", "recover", "restore", "restoring", "reset", "trouble", "problem"],
             fr: ["aide", "récupérer", "restaurer", "réinitialiser"],
             es: ["ayuda", "recuperar", "restaurar", "restablecer"],
             de: ["hilfe", "wiederherstellen", "zurücksetzen"],
@@ -55,6 +55,7 @@ const dictionary = {
             de: ["passwort", "geheimnis", "zugangscode"],
             pt: ["senha", "chave secreta", "de segurança"],
             cz: ["heslo"],
+            nl: ["wachtwoord"],
         },
         attr: {
             values: ["pwd", "pw", "mdp", "pass", "fmt"],
@@ -62,7 +63,7 @@ const dictionary = {
     },
     PASSWORD_OUTLIER: {
         i18n: {
-            en: ["national id", "social security", "userid"],
+            en: ["national id", "social security", "userid", "secAnswer", "answer"],
         },
     },
     USERNAME: {
@@ -71,9 +72,10 @@ const dictionary = {
             fr: ["pseudo", "utilisateur", "identifiant"],
             es: ["usuario", "identificador", "usuari"],
             de: ["nutzername", "anmelde", "benutzer"],
+            nl: ["gebruikersnaam"],
         },
         attr: {
-            values: ["appleid", "identifyemail", "acct", "userid", "accountid", "loginid", "loginname", "customerid"],
+            values: ["appleid", "acct", "userid", "accountid", "loginid", "loginname", "customerid"],
         },
     },
     USERNAME_OUTLIER: {
@@ -106,10 +108,7 @@ const dictionary = {
         },
     },
     CAPTCHA: {
-        i18n: {},
-        attr: {
-            values: ["captcha", "recaptcha", "hcaptcha", "solve-media", "funcaptcha", "keycaptcha"],
-        },
+        attr: { values: ["captcha", "recaptcha", "hcaptcha", "solve-media", "funcaptcha", "keycaptcha"] },
     },
     SUBMIT_ACTION: {
         i18n: {
@@ -127,11 +126,9 @@ const dictionary = {
             es: ["nuevo", "crear"],
             de: ["neu", "erstellen"],
             pt: ["novo", "criar"],
-            it: ['creare']
-        },
-        attr: {
-            endsWith: ["1", "fst"],
+            it: ["creare"],
         },
+        endsWith: ["1", "fst"],
     },
     RESET_ACTION: {
         i18n: {
@@ -150,9 +147,7 @@ const dictionary = {
             de: ["bestätigen", "wiederholen", "verifizieren", "erneut eingeben"],
             pt: ["digitar novamente"],
         },
-        attr: {
-            endsWith: ["2", "bis", "snd"],
-        },
+        endsWith: ["2", "bis", "snd"],
     },
     STEP_ACTION: {
         i18n: {
@@ -174,7 +169,7 @@ const dictionary = {
     },
     SEARCH_ACTION: {
         i18n: {
-            en: ["search", "query"],
+            en: ["search", "query", "find"],
             fr: ["recherche"],
             es: ["buscar"],
             de: ["suche"],
@@ -194,17 +189,13 @@ const dictionary = {
         },
     },
     HIDDEN: {
-        i18n: {},
         attr: {
             values: ["offscreen", "move-offscreen", "sr-only", "display-none", "screen-reader-only", "a11y-hide"],
             exact: ["hidden", "is-hidden"],
         },
     },
     OAUTH: {
-        i18n: {},
-        attr: {
-            values: ["apple", "facebook", "google", "twitch"],
-        },
+        attr: { values: ["apple", "facebook", "google", "twitch"] },
     },
     TOS: {
         i18n: {
@@ -215,47 +206,27 @@ const dictionary = {
             pt: ["termos de uso", "consentimento", "acordo", "política de privacidade"],
         },
     },
-    MFA_ACTION: {
+    TWO_FA: {
         i18n: {
-            en: ["Enter code", "verify", "enter auth code", "confirm"],
-            fr: [],
-            es: [],
-            de: [],
-            pt: [],
-        },
-    },
-    MFA: {
-        i18n: {
-            en: [
-                "2FA",
-                "2step",
-                "multi factor",
-                "two factor",
-                "two step",
-                "auth code",
-                "authenticator",
-                "authentication app",
-                "authentication code",
-                "security code",
-                "verification",
-                "generator app",
-            ],
-            fr: ["2 étapes", "multi-facteur", "double facteur", "double étape", "authentificateur"],
-            es: ["2 pasos", "doble paso", "doble factor", "verificacion", "generadora"],
-            de: ["2-Schritte", "Multi-Faktor", "Zwei-Faktor", "Zwei-Schritte", "Authentifikator", "Authentifizierungs"],
-            pt: ["2 etapas", "autenticador", "dois passos", "dois fatores", "multifator", "verificação", "autenticador"],
+            en: ["2FA", "2step", "multi factor", "two factor", "two step", "auth code", "security code", "verification"],
+            fr: ["2 étapes", "multi-facteur", "double facteur", "double étape"],
+            es: ["2 pasos", "doble paso", "doble factor", "verificacion"],
+            de: ["2-Schritte", "Multi-Faktor", "Zwei-Faktor", "Zwei-Schritte"],
+            pt: ["2 etapas", "dois passos", "dois fatores", "multifator", "verificação"],
         },
         attr: {
-            values: ["twofactor", "twostep", "challenge", "two-factor", "loginCode", "2fa", "twofa", "tfacode", "phone_verification", "approvals_code"],
+            values: ["twofactor", "twostep", "challenge", "two-factor", "loginCode", "2fa", "twofa", "tfacode", "phone_verification", "approvals_code", "authentication code", "emailCode"],
             exact: ["tfa", "mfa"],
         },
     },
-    OTP: {
-        i18n: {},
+    AUTHENTICATOR: {
         attr: {
-            values: ["onetime", "1time", "totp", "otp", "totpPin", "otc"],
+            values: ["authenticator", "authentication app", "generator app", "authentificateur", "Authentifikator", "Authentifizierungs-App", "Authentisierungs-App", "autenticador", "generadora", "application d'authentification"],
         },
     },
+    OTP: {
+        attr: { values: ["onetime", "1time", "totp", "otp", "totpPin", "otc"] },
+    },
     OTP_OUTLIER: {
         i18n: {
             en: ["resend", "new code", "send"],
@@ -265,7 +236,7 @@ const dictionary = {
             pt: ["reenviar", "novo código", "enviar"],
         },
         attr: {
-            values: ["sms", "email", "phone-pin", "tel-pin", "email-pin", "phone_verification_pin"],
+            values: ["sms", "email"],
         },
     },
     NEWSLETTER: {
@@ -278,98 +249,193 @@ const dictionary = {
         },
     },
     IDENTITY_FULLNAME: {
-        i18n: {},
         attr: {
             values: ["full-name", "your-name", "address-name", "address-contact", "contact-person"],
             exact: ["name"],
         },
     },
     IDENTITY_FIRSTNAME: {
-        i18n: {},
         attr: { values: ["first-name", "given-name", "first-n"], exact: ["f-name"] },
     },
     IDENTITY_MIDDLENAME: {
-        i18n: {},
         attr: { values: ["middle-name", "additional-name", "middle-n"], exact: ["m-name"] },
     },
     IDENTITY_LASTNAME: {
-        i18n: {},
         attr: { values: ["last-name", "surname", "family-name", "family-n", "last-n"], exact: ["l-name", "s-name"] },
     },
     IDENTITY_TELEPHONE: {
-        i18n: {},
         attr: {
-            values: ["phone", "mobile", "telephone", "tel-local", "tel-national", "national-number", "contact-number"],
-            exact: ["tel"],
+            values: ["phone", "mobile", "telephone", "national-number", "contact-number"],
+            exact: ["tel", "tel-national", "tel-local"],
         },
     },
-    IDENTITY_TELEPHONE_PREFIX: {
-        i18n: {},
-        attr: { values: ["prefix", "code", "country"] },
+    IDENTITY_TELEPHONE_OUTLIER: {
+        attr: { values: ["prefix", "code", "country", "extension", "security"] },
     },
     IDENTITY_ADDRESS: {
-        i18n: {},
         attr: {
-            values: [
-                "address-line-one",
-                "address-line1",
-                "address-lines",
-                "address1",
-                "bill-addr",
-                "billing-addr",
-                "mailing-addr",
-                "preferred-address",
-                "street-address",
-            ],
+            values: ["address-line-one", "address-line1", "address-lines", "address1", "bill-addr", "billing-addr", "mailing-addr", "preferred-address", "street-address"],
             exact: ["address", "addr", "street", "line1", "mail-addr"],
         },
     },
     IDENTITY_ADDRESS_LINES: {
-        i18n: {},
-        attr: {
-            endsWith: ["line2", "line-two", "line3", "line-three"],
-        },
+        endsWith: ["line2", "line-two", "line3", "line-three"],
     },
     IDENTITY_STATE: {
-        i18n: {},
         attr: {
             values: ["address-level-1", "address-state", "address-province", "state-province"],
             exact: ["state", "province", "region", "county"],
         },
     },
     IDENTITY_CITY: {
-        i18n: {},
         attr: {
             values: ["address-level-2", "address-city", "address-town", "personal-city"],
             exact: ["city", "town", "locality"],
         },
     },
     IDENTITY_ZIPCODE: {
-        i18n: {},
         attr: {
             values: ["zip-code", "postal-code", "post-code", "address-zip", "address-postal", "address-postal-code", "address-zip-code"],
             exact: ["zip"],
         },
     },
     IDENTITY_ORGANIZATION: {
-        i18n: {},
         attr: {
             values: ["company-name", "organization", "organization-name"],
             exact: ["organization"],
         },
     },
     IDENTITY_COUNTRY: {
-        i18n: {},
         attr: {
             values: ["country-name", "address-country", "address-country-name"],
             exact: ["country"],
         },
     },
     IDENTITY_COUNTRY_CODE: {
-        i18n: {},
         attr: {
             values: ["country-code"],
         },
     },
+    CC_PREFIX: {
+        attr: {
+            values: ["creditcard", "cartecredit", "credcard", "card", "payment-card", "payments-card", "vads", "stripe", "new-card", "creditDebit"],
+        },
+    },
+    CC_NUMBER: {
+        attr: {
+            values: ["card-no", "card-num", "card-no", "cc-no", "cb-num", "num-carte", "numero-carte", "numero de carte", "cardnr"],
+            exact: ["cc-number", "card number"],
+        },
+    },
+    CC_OUTLIER: {
+        attr: {
+            values: ["logincard", "certificate", "voucher", "coupon", "promo"],
+        },
+    },
+    CC_CVC: {
+        attr: {
+            values: ["cvv", "cvc", "csc", "ccv", "card-code", "card-verification", "payments-code", "payment-code"],
+            exact: ["cc-csc", "cc-cvv", "cc-code", "cvn"],
+        },
+    },
+    CC_CODE: {
+        attr: {
+            values: ["security code", "pincode", "cardpin"],
+        },
+    },
+    CC_NAME: {
+        attr: {
+            values: ["accountholdername", "holdername", "cardname", "cardholder", "cardholdername", "nameoncard"],
+            exact: ["cc-name"],
+        },
+    },
+    CC_EXP: {
+        attr: {
+            values: ["card-expiration", "expiration-date", "expiration-month-year", "expiry-date", "expiry", "expiration", "card-exp"],
+            exact: ["cc-exp", "cc-expiration", "expiry date"],
+        },
+    },
+    CC_EXP_MONTH: {
+        attr: {
+            values: [
+                "expiry-mo",
+                "expiry-m",
+                "expiry-mm",
+                "expire-mo",
+                "expire-m",
+                "expire-mm",
+                "expiration-mo",
+                "expiration-m",
+                "expiration-mm",
+                "card-mo",
+                "card-m",
+                "card-mm",
+                "exp-mo",
+                "exp-m",
+                "exp-mm",
+                "expiry-date-field-mo",
+                "expiry-date-mo",
+                "expiration-date-mo",
+                "expiration-date-mm",
+                "m-expiration",
+                "mois-exp",
+                "cb-date-mo",
+            ],
+            exact: ["cc-exp-month", "cc-month", "cc-mm"],
+        },
+        endsWith: ["mm", "month", "mo"],
+    },
+    CC_EXP_YEAR: {
+        attr: {
+            values: [
+                "expiry-year",
+                "expiry-y",
+                "expiry-yy",
+                "expiry-yyyy",
+                "expire-year",
+                "expire-y",
+                "expire-yy",
+                "expire-yyyy",
+                "expiration-year",
+                "expiration-y",
+                "expiration-yy",
+                "expiration-yyyy",
+                "card-year",
+                "card-y",
+                "card-yy",
+                "card-yyyy",
+                "exp-year",
+                "exp-y",
+                "exp-yy",
+                "exp-yyyy",
+                "expiry-date-field-year",
+                "expiry-date-year",
+                "expiration-date-year",
+                "expiration-date-yy",
+                "expiration-date-yyyy",
+                "y-expiration",
+                "annee-exp",
+                "ann-exp",
+                "cb-date-ann",
+            ],
+            exact: ["cc-exp-year", "cc-year", "cc-yr", "cc-yy"],
+        },
+        endsWith: ["yy", "year"],
+    },
+    IFRAME_FIELD: {
+        attr: {
+            values: ["field", "input", "control", "form", "pci", "cvv", "cvc", "security", "pbf", "stripeFrame", "expiry"],
+        },
+    },
+    PAYMENT: {
+        attr: {
+            values: ["payment", "checkout", "cart", "card"],
+        },
+    },
+    DOCUMENT: {
+        attr: {
+            values: ["contract", "idcard", "insurance", "licence", "license", "membership", "nationalid", "passeport", "passport", "permit", "social security", "subscription"],
+        },
+    },
 };
 export default dictionary;

package/dictionary/source/patterns.js

@@ -1,3 +1,3 @@
-export const EMAIL_VALUE_RE = /^[\w\-\.]+@([\w-]+\.)+[\w-]{2,5}$/;
+export const EMAIL_VALUE_RE = /^[\w\-.]+@([\w-]+\.)+[\w-]{2,5}$/;
 export const TEL_VALUE_RE = /^[\d()+-]{6,25}$/;
-export const USERNAME_VALUE_RE = /^[\w\-\.]{7,30}$/;
+export const USERNAME_VALUE_RE = /^[\w\-.]{7,30}$/;

package/features/feature.d.ts

@@ -0,0 +1,18 @@
+import type { AbstractFeature, AbstractFeatures, Feature, FeatureComputer, InferFeatureName, InferFeatureReturnType, InferParentComputeType } from "@protontech/autofill/types";
+import type { Fnode } from "@protontech/fathom";
+export declare const feature: <N extends string, R, P extends AbstractFeatures>(name: N, parents: P, compute: (parents: InferParentComputeType<P>, fnode: Fnode) => R) => Feature<N, R, P>;
+export declare const featureCount: <N extends string, R extends unknown[], P extends AbstractFeatures>(feat: Feature<N, R, P>) => Feature<`${N}Count`, number, {
+    [x: string]: Feature<N, R, P>;
+}>;
+export declare const featureScaled: <N extends string, P extends AbstractFeatures>(feat: Feature<N, number, P>, min: number, max: number) => Feature<`${N}Scaled`, number, Record<N, Feature<N, number, P>>>;
+export declare const featuresInnerProduct: <F1 extends AbstractFeature, F2 extends AbstractFeature, P extends Record<InferFeatureName<F1>, F1> & Record<InferFeatureName<F2>, F2>>(feat1: F1, feat2: F2) => Feature<`${InferFeatureName<F1>},${InferFeatureName<F2>}`, number, P>;
+export declare const featuresProduct: <F1 extends AbstractFeature, F2 extends AbstractFeature, P extends Record<InferFeatureName<F1>, F1> & Record<InferFeatureName<F2>, F2>>(feat1: F1, feat2: F2) => Feature<`${InferFeatureName<F1>},${InferFeatureName<F2>}`, number, P>;
+type FlatFeature<F extends AbstractFeature> = Feature<InferFeatureName<F>, InferFeatureReturnType<F>, AbstractFeatures>;
+type FlatFeatures<F extends AbstractFeatures> = {
+    [K in keyof F]: FlatFeature<F[K]>;
+};
+export declare const flattenFeatures: <F extends AbstractFeatures>(features: F) => FlatFeatures<F>;
+export declare const getComputerForFeatures: <F extends AbstractFeatures>(features: F) => FeatureComputer<FlatFeatures<F>>;
+export declare const topologicalSort: (features: AbstractFeatures) => AbstractFeature<unknown>[];
+export declare const computeFeatures: <F extends AbstractFeatures>(featureComputer: FeatureComputer<F>, fnode: Fnode) => import("@protontech/autofill/types").ComputedFeatures<F>;
+export {};

package/features/feature.js

@@ -0,0 +1,79 @@
+import { utils } from "@protontech/fathom";
+const { linearScale } = utils;
+export const feature = (name, parents, compute) => ({
+    name,
+    parents,
+    compute,
+});
+export const featureCount = (feat) => feature(`${feat.name}Count`, { [feat.name]: feat }, (parents) => parents[feat.name].length);
+export const featureScaled = (feat, min, max) => feature(`${feat.name}Scaled`, { [feat.name]: feat }, (parents) => linearScale(parents[feat.name], min, max));
+export const featuresInnerProduct = (feat1, feat2) => feature(`${feat1.name},${feat2.name}`, {
+    [feat1.name]: feat1,
+    [feat2.name]: feat2,
+}, (parents) => Math.sqrt(Number(parents[feat1.name]) * Number(parents[feat2.name])));
+export const featuresProduct = (feat1, feat2) => feature(`${feat1.name},${feat2.name}`, {
+    [feat1.name]: feat1,
+    [feat2.name]: feat2,
+}, (parents) => Number(parents[feat1.name]) * Number(parents[feat2.name]));
+export const flattenFeatures = (features) => features;
+export const getComputerForFeatures = (features) => {
+    const sorted = topologicalSort(features);
+    return {
+        compute: (fnode) => {
+            const computed_parents = {};
+            sorted.forEach((feature) => {
+                const feature_val = feature.compute(computed_parents, fnode);
+                computed_parents[feature.name] = feature_val;
+            });
+            return Object.fromEntries(Object.values(features).map(({ name }) => [name, computed_parents[name]]));
+        },
+        features: Array.from(Object.values(features)).filter((feat) => !feat.name.startsWith("__")),
+    };
+};
+export const topologicalSort = (features) => {
+    var _a;
+    const parentToChildren = new Map();
+    const childToParents = new Map();
+    const to_remove = new Array();
+    const to_visit = Array.from(Object.values(features));
+    const seen = new Set(to_visit);
+    while (to_visit.length > 0) {
+        const node = to_visit.pop();
+        if (Object.keys(node.parents).length === 0) {
+            to_remove.push(node);
+        }
+        else {
+            Object.values(node.parents).forEach((parent) => {
+                var _a, _b, _c, _d;
+                if (!seen.has(parent))
+                    to_visit.push(parent);
+                (_b = (_a = childToParents.get(node)) === null || _a === void 0 ? void 0 : _a.add(parent)) !== null && _b !== void 0 ? _b : childToParents.set(node, new Set([parent]));
+                (_d = (_c = parentToChildren.get(parent)) === null || _c === void 0 ? void 0 : _c.add(node)) !== null && _d !== void 0 ? _d : parentToChildren.set(parent, new Set([node]));
+            });
+        }
+        seen.add(node);
+    }
+    const sorted = new Array();
+    while (to_remove.length > 0) {
+        const node = to_remove.pop();
+        (_a = parentToChildren.get(node)) === null || _a === void 0 ? void 0 : _a.forEach((child) => {
+            const parents = childToParents.get(child);
+            parents === null || parents === void 0 ? void 0 : parents.delete(node);
+            if ((parents === null || parents === void 0 ? void 0 : parents.size) === 0) {
+                to_remove.unshift(child);
+                childToParents.delete(child);
+            }
+        });
+        sorted.push(node);
+    }
+    if (childToParents.size > 0) {
+        throw new Error(`loop detected with elements:\n  ${Array.from(childToParents.entries().map(([child, parents]) => `${child.name} -> {${Array.from(parents)
+            .map((parent) => parent.name)
+            .sort()
+            .join(", ")}}`))
+            .sort()
+            .join("\n  ")}`);
+    }
+    return sorted;
+};
+export const computeFeatures = (featureComputer, fnode) => featureComputer.compute(fnode);

package/features/feature.spec.d.ts

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

package/features/feature.spec.js

@@ -0,0 +1,55 @@
+import { feature, featuresProduct, getComputerForFeatures, topologicalSort } from "./feature";
+function doNothing() {
+}
+describe("topological sort", () => {
+    test("it works", () => {
+        const A = feature("A", {}, doNothing);
+        const B = feature("B", { A }, doNothing);
+        const C = feature("C", { A }, doNothing);
+        const D = feature("D", { B, C }, doNothing);
+        const E = feature("E", { B }, doNothing);
+        const F = feature("F", {}, doNothing);
+        const G = feature("G", { E, F }, doNothing);
+        const H = feature("H", {}, doNothing);
+        const features = { D, G, H };
+        const sorted = topologicalSort(features);
+        const nodeNames = sorted.map((feat) => feat.name);
+        expect(nodeNames.slice(0, 3).sort()).toEqual(["A", "F", "H"]);
+        expect(nodeNames.slice(3, 5).sort()).toEqual(["B", "C"]);
+        expect(nodeNames[5]).toEqual("E");
+        expect(nodeNames.slice(6, 8).sort()).toEqual(["D", "G"]);
+    });
+    test("it fails if there is a loop", () => {
+        const A = feature("A", {}, doNothing);
+        const B = feature("B", { A }, doNothing);
+        const C = feature("C", { A }, doNothing);
+        const D = feature("D", { B, C }, doNothing);
+        const E = feature("E", { B }, doNothing);
+        const F = feature("F", {}, doNothing);
+        const G = feature("G", { E, F }, doNothing);
+        const H = feature("H", {}, doNothing);
+        A.parents = { D };
+        const features = { A, B, C, D, E, F, G, H };
+        expect(() => topologicalSort(features)).toThrow(`loop detected with elements:
+  A -> {D}
+  B -> {A}
+  C -> {A}
+  D -> {B, C}
+  E -> {B}
+  G -> {E}`);
+    });
+});
+describe("Feature engineering", () => {
+    test("featureProduct", () => {
+        const A = feature("A", {}, () => 2);
+        const B = feature("B", { A }, () => 4);
+        const C = featuresProduct(A, B);
+        expect(getComputerForFeatures({ A, B, C }).compute({})).toStrictEqual({ A: 2, B: 4, "A,B": 8 });
+    });
+    test("feature name re-mapping", () => {
+        const A = feature("A", {}, () => 2);
+        const B = feature("_B", { A }, () => 4);
+        const C = feature("C", { A, B }, (p) => p.A + p._B);
+        expect(getComputerForFeatures({ A, B, C }).compute({})).toStrictEqual({ A: 2, _B: 4, C: 6 });
+    });
+});