@protontech/autofill 0.0.22991789 → 0.0.33835493

package/features/v1/abstract.form.js

@@ -0,0 +1,336 @@
+import { kAnchorLinkSelector, kButtonSelector, kCaptchaSelector, kFieldSelector, kLayoutSelector, kPasswordSelector, kSocialSelector } from "@protontech/autofill/constants/selectors";
+import { feature, featureCount, featureScaled, featuresProduct, flattenFeatures, getComputerForFeatures } from "@protontech/autofill/features/feature";
+import { getFormAttributes } from "@protontech/autofill/utils/attributes";
+import { any } from "@protontech/autofill/utils/combinators";
+import { getCCFieldType } from "@protontech/autofill/utils/credit-card";
+import { uniqueNodes } from "@protontech/autofill/utils/dom";
+import { getAllFieldHaystacks, getAllNodeHaystacks, getFormText, getNearestHeadingsText, getNodeAttributes, getPageDescriptionText } from "@protontech/autofill/utils/extract";
+import { safeInt } from "@protontech/autofill/utils/fathom";
+import { isBtnCandidate, isEmailCandidate, isInputField, isMFACandidate, isOAuthCandidate, isSelect, isTextarea, isUsernameCandidate, splitFieldsByVisibility } from "@protontech/autofill/utils/field";
+import { createInputIterator, getFormComplexity, getFormParent } from "@protontech/autofill/utils/form";
+import { getIdentityFieldType } from "@protontech/autofill/utils/identity";
+import { matchAuthenticator, matchLogin, matchMFA, matchMultiStep, matchNewsletter, matchOtpOutlier, matchOtpOutlierAction, matchPasswordConfirmAttr, matchPasswordCreateAttr, matchPasswordReset, matchPasswordResetAttr, matchRecovery, matchRegister, matchRememberMe, matchSearchAction, matchStepAction, matchTOS, matchTrouble, } from "@protontech/autofill/utils/re";
+import { sanitizeString } from "@protontech/autofill/utils/text";
+import { isVisibleEl, isVisibleField } from "@protontech/autofill/utils/visible";
+const form = feature("form", {}, (_, fnode) => fnode.element);
+const parent = feature("parent", { form }, (p) => getFormParent(p.form));
+const doc = feature("doc", { form }, (p) => p.form.ownerDocument);
+const __inputIterator = feature("__inputIterator", {}, (_, fnode) => createInputIterator(fnode.element));
+const fields = feature("fields", { form }, (p) => Array.from(p.form.querySelectorAll(kFieldSelector)));
+const visibleFields = feature("visibleFields", { fields }, (p) => p.fields.filter(isVisibleField));
+const inputs = feature("inputs", { fields }, (p) => p.fields.filter(isInputField));
+const hidden = feature("hidden", { inputs }, (p) => p.inputs.filter((el) => el.type === "hidden"));
+const visibleInputs = feature("visibleInputs", { visibleFields }, (p) => p.visibleFields.filter(isInputField));
+const fieldsets = feature("fieldsets", { form }, (p) => Array.from(p.form.querySelectorAll("fieldset")));
+const textareas = feature("textareas", { fields }, (p) => p.fields.filter(isTextarea));
+const selects = feature("selects", { fields }, (p) => p.fields.filter((el, i, arr) => { var _a; return isSelect(el) && ((_a = arr === null || arr === void 0 ? void 0 : arr[i + 1]) === null || _a === void 0 ? void 0 : _a.type) !== "tel"; }));
+const texts = feature("texts", { inputs }, (p) => p.inputs.filter((el) => el.type === "text"));
+const tels = feature("tels", { inputs }, (p) => p.inputs.filter((el) => el.type === "tel"));
+const readOnly = feature("readOnly", { inputs }, (p) => p.inputs.filter((el) => el.readOnly));
+const radios = feature("radios", { inputs }, (p) => p.inputs.filter((el) => el.type === "radio"));
+const checkboxes = feature("checkboxes", { inputs }, (p) => p.inputs.filter((el) => el.type === "checkbox"));
+const numbers = feature("numbers", { inputs }, (p) => p.inputs.filter((el) => el.type === "number"));
+const dates = feature("dates", { inputs }, (p) => p.inputs.filter((el) => el.type === "date"));
+const files = feature("files", { inputs }, (p) => p.inputs.filter((el) => el.type === "file"));
+const ccInputs = feature("ccInputs", { inputs }, (p) => p.inputs.filter(getCCFieldType));
+const ccSelects = feature("ccSelects", { selects }, (p) => p.selects.filter(getCCFieldType));
+const ccs = feature("ccs", { ccInputs, ccSelects }, (p) => p.ccInputs.concat(p.ccSelects));
+const identities = feature("identities", { inputs, ccs }, (p) => p.inputs.filter((el) => getIdentityFieldType(el) !== undefined));
+const required = feature("required", { visibleInputs }, (p) => p.visibleInputs.filter((el) => el.required || el.ariaRequired));
+const disabled = feature("disabled", { visibleInputs }, (p) => p.visibleInputs.filter((el) => el.disabled || el.ariaDisabled));
+const autofocused = feature("autofocused", { visibleInputs }, (p) => p.visibleInputs.find((el) => el.matches("input[autofocus]:first-of-type")));
+const usernames = feature("usernames", { inputs }, (p) => p.inputs.filter(isUsernameCandidate));
+const emails = feature("emails", { inputs }, (p) => p.inputs.filter(isEmailCandidate));
+const identifiers = feature("identifiers", { usernames, emails }, (p) => uniqueNodes(p.usernames, p.emails));
+const identifiersByVisibility = feature("identifiersByVisibility", { identifiers }, (p) => splitFieldsByVisibility(p.identifiers));
+const visibleIdentifiers = feature("visibleIdentifiers", { identifiersByVisibility }, (p) => p.identifiersByVisibility[0]);
+const hiddenIdentifiers = feature("hiddenIdentifiers", { identifiersByVisibility }, (p) => p.identifiersByVisibility[1]);
+const passwords = feature("passwords", { inputs }, (p) => p.inputs.filter((el) => el.matches(kPasswordSelector)));
+const passwordsByVisibility = feature("passwordsByVisibility", { passwords }, (p) => splitFieldsByVisibility(p.passwords));
+const visiblePasswords = feature("visiblePasswords", { passwordsByVisibility }, (p) => p.passwordsByVisibility[0]);
+const hiddenPasswords = feature("hiddenPasswords", { passwordsByVisibility }, (p) => p.passwordsByVisibility[1]);
+const mfaInputs = feature("mfaInputs", { inputs }, (p) => p.inputs.filter(isMFACandidate));
+const captchas = feature("captchas", { parent }, (p) => Array.from(p.parent.querySelectorAll(kCaptchaSelector)));
+const socials = feature("socials", { parent }, (p) => Array.from(p.parent.querySelectorAll(kSocialSelector)));
+const submits = feature("submits", { visibleFields }, (p) => p.visibleFields.filter((el) => (el === null || el === void 0 ? void 0 : el.type) === "submit"));
+const btns = feature("btns", { form }, (p) => Array.from(p.form.querySelectorAll(kButtonSelector)).filter(isVisibleEl));
+const btnsTypeSubmit = feature("btnsTypeSubmit", { btns }, (p) => p.btns.filter((el) => el.matches('[type="submit"]')));
+const candidateBtns = feature("candidateBtns", { btns }, (p) => p.btns.filter(isBtnCandidate));
+const submitBtns = feature("submitBtns", { btns, btnsTypeSubmit, candidateBtns }, (p) => (p.btnsTypeSubmit.length > 0 ? p.btnsTypeSubmit : p.candidateBtns));
+const anchors = feature("anchors", { form }, (p) => Array.from(p.form.querySelectorAll(kAnchorLinkSelector)).filter(isVisibleEl));
+const oauths = feature("oauths", { socials, candidateBtns }, (p) => p.socials.concat(p.candidateBtns).filter(isOAuthCandidate));
+const layouts = feature("layouts", { form }, (p) => Array.from(p.form.querySelectorAll(kLayoutSelector)));
+const autofocusedIsIdentifier = feature("autofocusedIsIdentifier", { autofocused, visibleIdentifiers }, (p) => Boolean(p.autofocused && p.visibleIdentifiers.includes(p.autofocused)));
+const autofocusedIsPassword = feature("autofocusedIsPassword", { autofocused, visiblePasswords }, (p) => Boolean(p.autofocused && p.visiblePasswords.includes(p.autofocused)));
+const pageDescriptionText = feature("pageDescriptionText", { doc }, (p) => getPageDescriptionText(p.doc));
+const nearestHeadingsText = feature("nearestHeadingsText", { form }, (p) => getNearestHeadingsText(p.form));
+const formTextAttrText = feature("formTextAttrText", { form }, (p) => getFormText(p.form));
+const formAttributes = feature("formAttributes", { form }, (p) => getFormAttributes(p.form));
+const pwHaystack = feature("pwHaystack", { passwords }, (p) => p.passwords.flatMap(getAllFieldHaystacks));
+const identifierHaystack = feature("identifierHaystack", { visibleIdentifiers }, (p) => p.visibleIdentifiers.flatMap(getAllFieldHaystacks));
+const btnHaystack = feature("btnHaystack", { candidateBtns }, (p) => p.candidateBtns.flatMap(getAllFieldHaystacks));
+const submitBtnHaystack = feature("submitBtnHaystack", { submitBtns }, (p) => p.submitBtns.flatMap(getAllFieldHaystacks));
+const checkboxesHaystack = feature("checkboxesHaystack", { checkboxes }, (p) => p.checkboxes.flatMap(getAllFieldHaystacks));
+const anchorsHaystack = feature("anchorsHaystack", { anchors }, (p) => p.anchors.flatMap(getAllNodeHaystacks));
+const mfaInputsHaystack = feature("mfaInputsHaystack", { mfaInputs }, (p) => p.mfaInputs.flatMap(getAllFieldHaystacks));
+const layoutHaystack = feature("layoutHaystack", { layouts }, (p) => p.layouts.map(getNodeAttributes));
+const formTextHaystack = feature("formTextHaystack", { formTextAttrText, nearestHeadingsText }, (p) => [p.formTextAttrText, p.nearestHeadingsText]);
+const pageLogin = feature("pageLogin", { pageDescriptionText }, (p) => matchLogin(p.pageDescriptionText));
+const formTextLogin = feature("formTextLogin", { formTextAttrText }, (p) => matchLogin(p.formTextAttrText));
+const formAttrsLogin = feature("formAttrsLogin", { formAttributes }, (p) => any(matchLogin)(p.formAttributes));
+const headingsLogin = feature("headingsLogin", { nearestHeadingsText }, (p) => matchLogin(p.nearestHeadingsText));
+const layoutLogin = feature("layoutLogin", { layoutHaystack }, (p) => any(matchLogin)(p.layoutHaystack));
+const rememberMeCheckbox = feature("rememberMeCheckbox", { checkboxesHaystack }, (p) => any(matchRememberMe)(p.checkboxesHaystack));
+const submitLogin = feature("submitLogin", { submitBtnHaystack }, (p) => any(matchLogin)(p.submitBtnHaystack));
+const troubleLink = feature("troubleLink", { anchorsHaystack }, (p) => any(matchTrouble)(p.anchorsHaystack));
+const pageRegister = feature("pageRegister", { pageDescriptionText }, (p) => matchRegister(p.pageDescriptionText));
+const formTextRegister = feature("formTextRegister", { formTextAttrText }, (p) => matchRegister(p.formTextAttrText));
+const formAttrsRegister = feature("formAttrsRegister", { formAttributes }, (p) => any(matchRegister)(p.formAttributes));
+const headingsRegister = feature("headingsRegister", { nearestHeadingsText }, (p) => matchRegister(p.nearestHeadingsText));
+const layoutRegister = feature("layoutRegister", { layoutHaystack }, (p) => any(matchRegister)(p.layoutHaystack));
+const TOSRef = feature("TOSRef", { checkboxesHaystack, anchorsHaystack }, (p) => any(matchTOS)(p.checkboxesHaystack.concat(p.anchorsHaystack)));
+const submitRegister = feature("submitRegister", { submitBtnHaystack }, (p) => any(matchRegister)(p.submitBtnHaystack));
+const pwNewRegister = feature("pwNewRegister", { pwHaystack }, (p) => any(matchPasswordCreateAttr)(p.pwHaystack));
+const pwConfirmRegister = feature("pwConfirmRegister", { pwHaystack }, (p) => any(matchPasswordConfirmAttr)(p.pwHaystack));
+const buttonMultistep = feature("buttonMultistep", { submitBtnHaystack }, (p) => any(matchStepAction)(p.submitBtnHaystack));
+const headingsMultistep = feature("headingsMultistep", { nearestHeadingsText }, (p) => matchMultiStep(p.nearestHeadingsText));
+const multistepForm = feature("multistepForm", { buttonMultistep, headingsMultistep }, (p) => p.buttonMultistep || p.headingsMultistep);
+const pageMultiAuth = feature("pageMultiAuth", { pageLogin, pageRegister }, (p) => p.pageLogin && p.pageRegister);
+const submitMultiAuth = feature("submitMultiAuth", { submitRegister, submitLogin, buttonMultistep }, (p) => p.submitRegister && (p.submitLogin || p.buttonMultistep));
+const headingsMultiAuth = feature("headingsMultiAuth", { headingsLogin, headingsRegister }, (p) => p.headingsLogin && p.headingsRegister);
+const multiAuthForm = feature("multiAuthForm", { pageMultiAuth, headingsMultiAuth, submitMultiAuth }, (p) => p.pageMultiAuth || p.headingsMultiAuth || p.submitMultiAuth);
+const pagePwReset = feature("pagePwReset", { pageDescriptionText }, (p) => matchPasswordReset(p.pageDescriptionText));
+const formTextPwReset = feature("formTextPwReset", { formTextAttrText }, (p) => matchPasswordReset(p.formTextAttrText));
+const formAttrsPwReset = feature("formAttrsPwReset", { formAttributes }, (p) => any(matchPasswordResetAttr)(p.formAttributes));
+const headingsPwReset = feature("headingsPwReset", { nearestHeadingsText }, (p) => matchPasswordReset(p.nearestHeadingsText));
+const layoutPwReset = feature("layoutPwReset", { layoutHaystack }, (p) => any(matchPasswordResetAttr)(p.layoutHaystack));
+const pageRecovery = feature("pageRecovery", { pageDescriptionText }, (p) => matchRecovery(p.pageDescriptionText));
+const formTextRecovery = feature("formTextRecovery", { formTextAttrText }, (p) => matchRecovery(p.formTextAttrText));
+const formAttrsRecovery = feature("formAttrsRecovery", { formAttributes }, (p) => any(matchRecovery)(p.formAttributes));
+const headingsRecovery = feature("headingsRecovery", { nearestHeadingsText }, (p) => matchRecovery(p.nearestHeadingsText));
+const layoutRecovery = feature("layoutRecovery", { layoutHaystack }, (p) => any(matchRecovery)(p.layoutHaystack));
+const submitRecovery = feature("submitRecovery", { submitBtnHaystack }, (p) => any(matchRecovery)(p.submitBtnHaystack));
+const identifierRecovery = feature("identifierRecovery", { identifierHaystack }, (p) => any(matchRecovery)(p.identifierHaystack));
+const inputsMFA = feature("inputsMFA", { mfaInputs, mfaInputsHaystack }, (p) => p.mfaInputs.some(({ autocomplete }) => autocomplete.includes("one-time-code")) || any(matchMFA)(p.mfaInputsHaystack));
+const formAttrsMFA = feature("formAttrsMFA", { formAttributes }, (p) => any(matchMFA)(p.formAttributes));
+const formTextMFA = feature("formTextMFA", { formTextHaystack }, (p) => any(matchMFA)(p.formTextHaystack));
+const maybeMFA = feature("maybeMFA", { formTextMFA, formAttrsMFA, inputsMFA }, (p) => p.inputsMFA || p.formAttrsMFA || p.formTextMFA);
+const haystackMFA = feature("haystackMFA", { formTextHaystack, maybeMFA, form }, (p) => [...p.formTextHaystack, maybeMFA ? sanitizeString(p.form.innerText) : ""]);
+const __formTextAuthenticator = feature("__formTextAuthenticator", { haystackMFA }, (p) => any(matchAuthenticator)(p.haystackMFA));
+const __headingsOTPOutlier = feature("__headingsOTPOutlier", { nearestHeadingsText }, (p) => matchOtpOutlier(p.nearestHeadingsText));
+const __formOTPOutlier = feature("__formOTPOutlier", { formAttributes }, (p) => any(matchOtpOutlier)(p.formAttributes));
+const __linkOTPOutlier = feature("__linkOTPOutlier", { anchorsHaystack, btnHaystack }, (p) => any(matchOtpOutlierAction)(p.anchorsHaystack.concat(p.btnHaystack)));
+const __formMFA = feature("__formMFA", { formTextMFA, formAttrsMFA }, (p) => p.formAttrsMFA || p.formAttrsMFA);
+const __formInputMFACandidates = feature("__formInputMFACandidates", { visibleInputs }, (p) => p.visibleInputs.filter(isMFACandidate).length);
+const newsletterForm = feature("newsletterForm", { formTextHaystack }, (p) => any(matchNewsletter)(p.formTextHaystack));
+const searchForm = feature("searchForm", { formTextHaystack }, (p) => any(matchSearchAction)(p.formTextHaystack));
+const formComplexity = featureScaled(feature("formComplexity", { form, fields, visibleFields, hidden, anchors, candidateBtns }, (p) => getFormComplexity(p.form, {
+    fields: p.fields,
+    visibleFields: p.visibleFields.length,
+    hiddenFields: p.hidden.length,
+    nonVisibleFields: p.fields.length - p.visibleFields.length - p.hidden.length,
+    anchors: p.anchors.length,
+    buttons: p.candidateBtns.length,
+})), 0, 50);
+const visibleFieldsCount = featureScaled(featureCount(visibleFields), 1, 5);
+const visibleInputsCount = featureScaled(featureCount(visibleInputs), 1, 5);
+const fieldsetsCount = featureScaled(featureCount(fieldsets), 1, 5);
+const textsCount = featureScaled(featureCount(texts), 0, 3);
+const readOnlyCount = featureScaled(featureCount(readOnly), 0, 3);
+const textareasCount = featureScaled(featureCount(textareas), 0, 2);
+const selectsCount = featureScaled(featureCount(selects), 0, 5);
+const disabledCount = featureScaled(featureCount(disabled), 0, 5);
+const radiosCount = featureScaled(featureCount(radios), 0, 5);
+const visibleIdentifiersCount = featureScaled(featureCount(visibleIdentifiers), 0, 3);
+const hiddenIdentifiersCount = featureScaled(featureCount(hiddenIdentifiers), 0, 2);
+const hiddenCount = featureScaled(featureCount(hidden), 0, 5);
+const visiblePasswordsCount = featureScaled(featureCount(visiblePasswords), 0, 2);
+const hiddenPasswordsCount = featureScaled(featureCount(hiddenPasswords), 0, 2);
+const usernamesCount = featureScaled(featureCount(usernames), 0, 2);
+const emailsCount = featureScaled(featureCount(emails), 0, 2);
+const submitsCount = featureScaled(featureCount(submits), 0, 2);
+const identitiesCount = featureScaled(featureCount(identities), 0, 5);
+const ccsCount = featureScaled(featureCount(ccs), 0, 5);
+const hasTels = feature("hasTels", { tels }, (p) => p.tels.length > 0);
+const hasOAuth = feature("hasOAuth", { oauths }, (p) => p.oauths.length > 0);
+const hasCaptchas = feature("hasCaptchas", { captchas }, (p) => p.captchas.length > 0);
+const hasFiles = feature("hasFiles", { files }, (p) => p.files.length > 0);
+const hasDate = feature("hasDate", { dates }, (p) => p.dates.length > 0);
+const hasNumber = feature("hasNumber", { numbers }, (p) => p.numbers.length > 0);
+const oneVisibleField = feature("oneVisibleField", { visibleInputs }, (p) => p.visibleInputs.length === 1);
+const twoVisibleFields = feature("twoVisibleFields", { visibleInputs }, (p) => p.visibleInputs.length === 2);
+const threeOrMoreVisibleFields = feature("threeOrMoreVisibleFields", { visibleInputs }, (p) => p.visibleInputs.length >= 3);
+const noPasswords = feature("noPasswords", { visiblePasswords }, (p) => p.visiblePasswords.length === 0);
+const onePassword = feature("onePassword", { visiblePasswords }, (p) => p.visiblePasswords.length === 1);
+const twoPasswords = feature("twoPasswords", { visiblePasswords }, (p) => p.visiblePasswords.length === 2);
+const threeOrMorePasswords = feature("threeOrMorePasswords", { visiblePasswords }, (p) => p.visiblePasswords.length >= 3);
+const noIdentifiers = feature("noIdentifiers", { visibleIdentifiers }, (p) => p.visibleIdentifiers.length === 0);
+const oneIdentifier = feature("oneIdentifier", { visibleIdentifiers }, (p) => p.visibleIdentifiers.length === 1);
+const twoIdentifiers = feature("twoIdentifiers", { visibleIdentifiers }, (p) => p.visibleIdentifiers.length === 2);
+const threeOrMoreIdentifiers = feature("threeOrMoreIdentifiers", { visibleIdentifiers }, (p) => p.visibleIdentifiers.length >= 3);
+const inputRatio = feature("inputRatio", { inputs, fields }, (p) => safeInt(p.inputs.length / p.fields.length));
+const hiddenRatio = feature("hiddenRatio", { hidden, fields }, (p) => safeInt(p.hidden.length / p.fields.length));
+const visibleRatio = feature("visibleRatio", { visibleInputs, fields }, (p) => safeInt(p.visibleInputs.length / p.fields.length));
+const checkboxRatio = feature("checkboxRatio", { checkboxes, fields }, (p) => safeInt(p.checkboxes.length / p.fields.length));
+const emailRatio = feature("emailRatio", { emails, fields }, (p) => safeInt(p.emails.length / p.fields.length));
+const usernameRatio = feature("usernameRatio", { usernames, fields }, (p) => safeInt(p.usernames.length / p.fields.length));
+const hiddenIdentifierRatio = feature("hiddenIdentifierRatio", { hiddenIdentifiers, identifiers }, (p) => safeInt(p.hiddenIdentifiers.length / p.identifiers.length));
+const hiddenPasswordRatio = feature("hiddenPasswordRatio", { hiddenPasswords, passwords }, (p) => safeInt(p.hiddenPasswords.length / p.passwords.length));
+const identifierRatio = feature("identifierRatio", { visibleIdentifiers, visibleFields }, (p) => safeInt(p.visibleIdentifiers.length / p.visibleFields.length));
+const passwordRatio = feature("passwordRatio", { visiblePasswords, visibleFields }, (p) => safeInt(p.visiblePasswords.length / p.visibleFields.length));
+const requiredRatio = feature("requiredRatio", { required, visibleFields }, (p) => safeInt(p.required.length / p.visibleFields.length));
+const disabledRatio = feature("disabledRatio", { disabled, visibleFields }, (p) => safeInt(p.disabled.length / p.visibleFields.length));
+const multistepForm_multiAuthForm = featuresProduct(multistepForm, multiAuthForm);
+const visibleRatio_visibleFieldsCount = featuresProduct(visibleRatio, visibleFieldsCount);
+const visibleRatio_visibleIdentifiersCount = featuresProduct(visibleRatio, visibleIdentifiersCount);
+const visibleRatio_visiblePasswordsCount = featuresProduct(visibleRatio, visiblePasswordsCount);
+const visibleRatio_hiddenIdentifiersCount = featuresProduct(visibleRatio, hiddenIdentifiersCount);
+const visibleRatio_hiddenPasswordsCount = featuresProduct(visibleRatio, hiddenPasswordsCount);
+const visibleRatio_multiAuthForm = featuresProduct(visibleRatio, multiAuthForm);
+const visibleRatio_multistepForm = featuresProduct(visibleRatio, multistepForm);
+const identifierRatio_visibleFieldsCount = featuresProduct(identifierRatio, visibleFieldsCount);
+const identifierRatio_visibleIdentifiersCount = featuresProduct(identifierRatio, visibleIdentifiersCount);
+const identifierRatio_visiblePasswordsCount = featuresProduct(identifierRatio, visiblePasswordsCount);
+const identifierRatio_hiddenIdentifiersCount = featuresProduct(identifierRatio, hiddenIdentifiersCount);
+const identifierRatio_hiddenPasswordsCount = featuresProduct(identifierRatio, hiddenPasswordsCount);
+const identifierRatio_multiAuthForm = featuresProduct(identifierRatio, multiAuthForm);
+const identifierRatio_multistepForm = featuresProduct(identifierRatio, multistepForm);
+const passwordRatio_visibleFieldsCount = featuresProduct(passwordRatio, visibleFieldsCount);
+const passwordRatio_visibleIdentifiersCount = featuresProduct(passwordRatio, visibleIdentifiersCount);
+const passwordRatio_visiblePasswordsCount = featuresProduct(passwordRatio, visiblePasswordsCount);
+const passwordRatio_hiddenIdentifiersCount = featuresProduct(passwordRatio, hiddenIdentifiersCount);
+const passwordRatio_hiddenPasswordsCount = featuresProduct(passwordRatio, hiddenPasswordsCount);
+const passwordRatio_multiAuthForm = featuresProduct(passwordRatio, multiAuthForm);
+const passwordRatio_multistepForm = featuresProduct(passwordRatio, multistepForm);
+const requiredRatio_visibleFieldsCount = featuresProduct(requiredRatio, visibleFieldsCount);
+const requiredRatio_visibleIdentifiersCount = featuresProduct(requiredRatio, visibleIdentifiersCount);
+const requiredRatio_visiblePasswordsCount = featuresProduct(requiredRatio, visiblePasswordsCount);
+const requiredRatio_hiddenIdentifiersCount = featuresProduct(requiredRatio, hiddenIdentifiersCount);
+const requiredRatio_hiddenPasswordsCount = featuresProduct(requiredRatio, hiddenPasswordsCount);
+const requiredRatio_multiAuthForm = featuresProduct(requiredRatio, multiAuthForm);
+const requiredRatio_multistepForm = featuresProduct(requiredRatio, multistepForm);
+export const formFeatures = flattenFeatures({
+    __formInputMFACandidates,
+    __formMFA,
+    __formOTPOutlier,
+    __formTextAuthenticator,
+    __headingsOTPOutlier,
+    __inputIterator,
+    __linkOTPOutlier,
+    visibleFieldsCount,
+    visibleInputsCount,
+    fieldsetsCount,
+    textsCount,
+    textareasCount,
+    selectsCount,
+    disabledCount,
+    radiosCount,
+    readOnlyCount,
+    formComplexity,
+    visibleIdentifiersCount,
+    hiddenIdentifiersCount,
+    usernamesCount,
+    emailsCount,
+    hiddenCount,
+    hiddenPasswordsCount,
+    submitsCount,
+    identitiesCount,
+    ccsCount,
+    hasTels,
+    hasOAuth,
+    hasCaptchas,
+    hasFiles,
+    hasDate,
+    hasNumber,
+    oneVisibleField,
+    twoVisibleFields,
+    threeOrMoreVisibleFields,
+    noPasswords,
+    onePassword,
+    twoPasswords,
+    threeOrMorePasswords,
+    noIdentifiers,
+    oneIdentifier,
+    twoIdentifiers,
+    threeOrMoreIdentifiers,
+    autofocusedIsIdentifier,
+    autofocusedIsPassword,
+    visibleRatio,
+    inputRatio,
+    hiddenRatio,
+    identifierRatio,
+    emailRatio,
+    usernameRatio,
+    passwordRatio,
+    disabledRatio,
+    requiredRatio,
+    checkboxRatio,
+    hiddenIdentifierRatio,
+    hiddenPasswordRatio,
+    pageLogin,
+    formTextLogin,
+    formAttrsLogin,
+    headingsLogin,
+    layoutLogin,
+    rememberMeCheckbox,
+    troubleLink,
+    submitLogin,
+    pageRegister,
+    formTextRegister,
+    formAttrsRegister,
+    headingsRegister,
+    layoutRegister,
+    pwNewRegister,
+    pwConfirmRegister,
+    submitRegister,
+    TOSRef,
+    pagePwReset,
+    formTextPwReset,
+    formAttrsPwReset,
+    headingsPwReset,
+    layoutPwReset,
+    pageRecovery,
+    formTextRecovery,
+    formAttrsRecovery,
+    headingsRecovery,
+    layoutRecovery,
+    identifierRecovery,
+    submitRecovery,
+    formTextMFA,
+    formAttrsMFA,
+    inputsMFA,
+    newsletterForm,
+    searchForm,
+    multistepForm,
+    multiAuthForm,
+    multistepForm_multiAuthForm,
+    visibleRatio_visibleFieldsCount,
+    visibleRatio_visibleIdentifiersCount,
+    visibleRatio_visiblePasswordsCount,
+    visibleRatio_hiddenIdentifiersCount,
+    visibleRatio_hiddenPasswordsCount,
+    visibleRatio_multiAuthForm,
+    visibleRatio_multistepForm,
+    identifierRatio_visibleFieldsCount,
+    identifierRatio_visibleIdentifiersCount,
+    identifierRatio_visiblePasswordsCount,
+    identifierRatio_hiddenIdentifiersCount,
+    identifierRatio_hiddenPasswordsCount,
+    identifierRatio_multiAuthForm,
+    identifierRatio_multistepForm,
+    passwordRatio_visibleFieldsCount,
+    passwordRatio_visibleIdentifiersCount,
+    passwordRatio_visiblePasswordsCount,
+    passwordRatio_hiddenIdentifiersCount,
+    passwordRatio_hiddenPasswordsCount,
+    passwordRatio_multiAuthForm,
+    passwordRatio_multistepForm,
+    requiredRatio_visibleFieldsCount,
+    requiredRatio_visibleIdentifiersCount,
+    requiredRatio_visiblePasswordsCount,
+    requiredRatio_hiddenIdentifiersCount,
+    requiredRatio_hiddenPasswordsCount,
+    requiredRatio_multiAuthForm,
+    requiredRatio_multistepForm,
+});
+export const formFeaturesComputer = getComputerForFeatures(formFeatures);

package/features/v1/field.email.d.ts

@@ -0,0 +1,62 @@
+export declare const emailFeatures: {
+    exactAttrEmail: {
+        name: "exactAttrEmail";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    fieldAttrEmail: {
+        name: "attrEmail";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    fieldAutocompleteEmail: {
+        name: "autocompleteEmail";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    fieldAutocompleteOff: {
+        name: "autocompleteOff";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    fieldCC: {
+        name: "fieldCC";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    fieldIdentity: {
+        name: "fieldIdentity";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    fieldSearch: {
+        name: "isSearchField";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    labelEmail: {
+        name: "labelEmail";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    mfaOutlier: {
+        name: "mfaOutlier";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    placeholderEmail: {
+        name: "placeholderEmail";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    textEmail: {
+        name: "textEmail";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    typeEmail: {
+        name: "typeEmail";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+};

package/features/v1/field.email.js

@@ -0,0 +1,27 @@
+import { kEmailSelector } from "@protontech/autofill/constants/selectors";
+import { feature, flattenFeatures } from "@protontech/autofill/features/feature";
+import { field, fieldAttrEmail, fieldAttrs, fieldAutocomplete, fieldAutocompleteEmail, fieldAutocompleteOff, fieldCC, fieldIdentity, fieldLabel, fieldSearch, fieldText, placeholder, type, } from "@protontech/autofill/features/v1/abstract.field";
+import { any } from "@protontech/autofill/utils/combinators";
+import { matchEmail, matchEmailValue, matchMFAAttr } from "@protontech/autofill/utils/re";
+import { sanitizeString } from "@protontech/autofill/utils/text";
+const typeEmail = feature("typeEmail", { fieldType: type }, (p) => p.type === "email");
+const exactAttrEmail = feature("exactAttrEmail", { field }, (p) => p.field.matches(kEmailSelector));
+const textEmail = feature("textEmail", { fieldText }, (p) => matchEmail(p.fieldText));
+const labelEmail = feature("labelEmail", { fieldLabel }, (p) => matchEmail(p.fieldLabel));
+const placeholderEmailValue = feature("placeholderEmailValue", { fieldPlaceholder: placeholder }, (p) => any(matchEmailValue)(p.placeholder.split(" ")));
+const placeholderEmail = feature("placeholderEmail", { placeholderEmailValue, fieldPlaceholder: placeholder }, (p) => p.placeholderEmailValue || matchEmail(sanitizeString(p.placeholder)));
+const mfaOutlier = feature("mfaOutlier", { fieldAttrs, fieldAutocomplete }, (p) => p.fieldAutocomplete === "one-time-code" || any(matchMFAAttr)(p.fieldAttrs));
+export const emailFeatures = flattenFeatures({
+    exactAttrEmail,
+    fieldAttrEmail,
+    fieldAutocompleteEmail,
+    fieldAutocompleteOff,
+    fieldCC,
+    fieldIdentity,
+    fieldSearch,
+    labelEmail,
+    mfaOutlier,
+    placeholderEmail,
+    textEmail,
+    typeEmail,
+});

package/features/v1/field.otp.d.ts

@@ -0,0 +1,142 @@
+export declare const otpFeatures: {
+    attrMFA: {
+        name: "attrMFA";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    attrOTP: {
+        name: "attrOTP";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    autocompleteOTC: {
+        name: "autocompleteOTC";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    fieldCC: {
+        name: "fieldCC";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    fieldIdentity: {
+        name: "fieldIdentity";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    formAuthenticator: {
+        name: "formAuthenticator";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    formComplexity: {
+        name: "formComplexity";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): number;
+    };
+    formMFA: {
+        name: "formMFA";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    idMatch: {
+        name: "idMatch";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    labelAuthenticator: {
+        name: "labelAuthenticator";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    labelMFA: {
+        name: "labelMFA";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    labelOTP: {
+        name: "labelOTP";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    nameMatch: {
+        name: "nameMatch";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    numericMode: {
+        name: "numericMode";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    outlierAutocomplete: {
+        name: "outlierAutocomplete";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    outlierEmailMatchScaled: {
+        name: "outlierEmailMatchScaled";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): number;
+    };
+    outlierField: {
+        name: "outlierField";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    outlierForm: {
+        name: "outlierForm";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    outlierHeadings: {
+        name: "outlierHeadings";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    outlierInputCount: {
+        name: "outlierInputCount";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    outlierLink: {
+        name: "outlierLink";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    outlierMaxLength: {
+        name: "outlierMaxLength";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    outlierSearch: {
+        name: "outlierSearch";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    patternOTP: {
+        name: "patternOTP";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    siblingOfInterest: {
+        name: "siblingOfInterest";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    singleInput: {
+        name: "singleInput";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    textAuthenticator: {
+        name: "textAuthenticator";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    textMFA: {
+        name: "textMFA";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+};