@protontech/autofill 0.0.22991789 → 0.0.33835493

package/features/v1/field.otp.js

@@ -0,0 +1,105 @@
+import { OTP_PATTERNS } from "@protontech/autofill/constants/heuristics";
+import { feature, featureScaled, flattenFeatures } from "@protontech/autofill/features/feature";
+import { field, fieldAttrs, fieldAutocomplete, fieldCC, fieldForm, fieldFormFeats, fieldIdentity, fieldLabel, fieldNext, fieldPrev, fieldSearch, fieldText, maxLength, pattern, placeholder, type, } from "@protontech/autofill/features/v1/abstract.field";
+import { any } from "@protontech/autofill/utils/combinators";
+import { getNodeRect } from "@protontech/autofill/utils/dom";
+import { matchAuthenticator, matchOtpAttr, matchOtpFieldOutlier, matchTwoFa } from "@protontech/autofill/utils/re";
+const matchSibling = (sibling, match) => {
+    if (!sibling)
+        return false;
+    if ((sibling === null || sibling === void 0 ? void 0 : sibling.getAttribute("type")) !== match.type)
+        return false;
+    const maxLen = sibling.getAttribute("maxlength");
+    if (maxLen && parseInt(maxLen, 10) > 1)
+        return false;
+    const minLen = sibling.getAttribute("minlength");
+    if (minLen && parseInt(minLen) > 1)
+        return false;
+    const { top, bottom, width, area } = getNodeRect(sibling);
+    if (width >= 100)
+        return false;
+    const topMatch = Math.abs(match.rect.top - top) <= 2;
+    const bottomMatch = Math.abs(match.rect.bottom - bottom) <= 2;
+    const aligned = topMatch && bottomMatch;
+    if (!aligned)
+        return false;
+    const areaMatch = Math.abs(match.rect.area - area) < 16;
+    if (!areaMatch)
+        return false;
+    return true;
+};
+const searchForm = feature("searchForm", { fieldFormFeats }, (p) => { var _a; return Boolean((_a = p.fieldFormFeats) === null || _a === void 0 ? void 0 : _a.searchForm); });
+const formComplexity = feature("formComplexity", { fieldFormFeats }, (p) => { var _a, _b; return (_b = (_a = p.fieldFormFeats) === null || _a === void 0 ? void 0 : _a.formComplexityScaled) !== null && _b !== void 0 ? _b : 0; });
+const formMFA = feature("formMFA", { fieldFormFeats }, (p) => { var _a; return Boolean((_a = p.fieldFormFeats) === null || _a === void 0 ? void 0 : _a.__formMFA); });
+const formAuthenticator = feature("formAuthenticator", { fieldFormFeats }, (p) => { var _a; return Boolean((_a = p.fieldFormFeats) === null || _a === void 0 ? void 0 : _a.__formTextAuthenticator); });
+const mfaCandidates = feature("mfaCandidates", { fieldFormFeats }, (p) => { var _a, _b; return (_b = (_a = p.fieldFormFeats) === null || _a === void 0 ? void 0 : _a.__formInputMFACandidates) !== null && _b !== void 0 ? _b : 0; });
+const outlierForm = feature("outlierForm", { fieldFormFeats }, (p) => { var _a; return Boolean((_a = p.fieldFormFeats) === null || _a === void 0 ? void 0 : _a.__formOTPOutlier); });
+const outlierLink = feature("outlierLink", { fieldFormFeats }, (p) => { var _a; return Boolean((_a = p.fieldFormFeats) === null || _a === void 0 ? void 0 : _a.__linkOTPOutlier); });
+const outlierHeadings = feature("outlierHeadings", { fieldFormFeats }, (p) => { var _a; return Boolean((_a = p.fieldFormFeats) === null || _a === void 0 ? void 0 : _a.__headingsOTPOutlier); });
+const numericMode = feature("numericMode", { field }, (p) => p.field.inputMode === "numeric");
+const patternOTP = feature("patternOTP", { fieldPattern: pattern, numericMode }, (p) => !numericMode && OTP_PATTERNS.some((pattern) => { var _a; return ((_a = p.pattern) === null || _a === void 0 ? void 0 : _a.trim()) === pattern; }));
+const nameMatch = feature("nameMatch", { field }, (p) => ["code", "token", "otp", "otc", "totp"].some((match) => p.field.name === match));
+const idMatch = feature("idMatch", { field }, (p) => ["code", "token", "otp", "otc", "totp"].some((match) => p.field.id === match));
+const autocompleteOff = feature("autocompleteOff", { fieldAutocomplete }, (p) => p.fieldAutocomplete !== undefined && (p.fieldAutocomplete === "off" || p.fieldAutocomplete === "false"));
+const autocompleteOTC = feature("autocompleteOTC", { fieldAutocomplete }, (p) => { var _a, _b; return (_b = (_a = p.fieldAutocomplete) === null || _a === void 0 ? void 0 : _a.includes("one-time-code")) !== null && _b !== void 0 ? _b : false; });
+const maxLen = feature("maxLen", { fieldMaxLength: maxLength }, (p) => (p.maxLength ? parseInt(p.maxLength, 10) : null));
+const singleInput = feature("singleInput", { mfaCandidates }, (p) => p.mfaCandidates === 1);
+const rect = feature("rect", { field }, (p) => getNodeRect(p.field));
+const similarBefore = feature("similarBefore", { type, fieldPrev, rect }, (p) => matchSibling(p.fieldPrev, p));
+const similarAfter = feature("similarAfter", { type, fieldNext, rect }, (p) => matchSibling(p.fieldNext, p));
+const siblingOfInterest = feature("siblingOfInterest", { similarBefore, similarAfter }, (p) => p.similarBefore || p.similarAfter);
+const attrOTP = feature("attrOTP", { fieldAttrs }, (p) => any(matchOtpAttr)(p.fieldAttrs));
+const attrMFA = feature("attrMFA", { fieldAttrs }, (p) => any(matchTwoFa)(p.fieldAttrs));
+const attrOutlier = feature("attrOutlier", { fieldAttrs }, (p) => any(matchOtpFieldOutlier)(p.fieldAttrs));
+const textOTP = feature("textOTP", { fieldText }, (p) => matchOtpAttr(p.fieldText));
+const textMFA = feature("textMFA", { fieldText }, (p) => matchTwoFa(p.fieldText));
+const textAuthenticator = feature("textAuthenticator", { fieldText }, (p) => matchAuthenticator(p.fieldText));
+const labelOTP = feature("labelOTP", { fieldLabel }, (p) => matchOtpAttr(p.fieldLabel));
+const labelMFA = feature("labelMFA", { fieldLabel }, (p) => matchTwoFa(p.fieldLabel));
+const labelAuthenticator = feature("labelAuthenticator", { fieldLabel }, (p) => matchAuthenticator(p.fieldLabel));
+const labelOutlier = feature("labelOutlier", { fieldLabel }, (p) => matchOtpFieldOutlier(p.fieldLabel));
+const mfa = feature("mfa", { formMFA, labelMFA, textMFA, attrMFA }, (p) => p.formMFA || p.labelMFA || p.textMFA || p.attrMFA);
+const otp = feature("otp", { attrOTP, textOTP, labelOTP }, (p) => p.attrOTP || p.textOTP || p.labelOTP);
+const outlierCandidate = feature("outlierCandidate", { mfa, otp }, (p) => p.mfa || p.otp);
+const outlierMaxLength = feature("outlierMaxLength", { maxLen }, (p) => Boolean(p.maxLen && (p.maxLen > 20 || (p.maxLen > 1 && p.maxLen < 5))));
+const outlierInputCount = feature("outlierInputCount", { mfaCandidates }, (p) => !(p.mfaCandidates === 1 || p.mfaCandidates === 6 || p.mfaCandidates === 5));
+const outlierEmailMatchRaw = feature("outlierEmailMatch", { outlierCandidate, fieldForm }, (p) => {
+    var _a, _b, _c, _d;
+    if (!outlierCandidate)
+        return 0;
+    return (_d = (_c = ((_b = (_a = p.fieldForm) === null || _a === void 0 ? void 0 : _a.element.innerText) !== null && _b !== void 0 ? _b : "").match(/[a-z0-9*._-]@/gi)) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0;
+});
+const outlierEmailMatchScaled = featureScaled(outlierEmailMatchRaw, 0, 2);
+const outlierField = feature("outlierField", { attrOutlier, labelOutlier, fieldPlaceholder: placeholder }, (p) => p.attrOutlier || p.labelOutlier || p.placeholder.includes("://"));
+const outlierSearch = feature("outlierSearch", { isSearchField: fieldSearch, searchForm }, (p) => p.isSearchField || p.searchForm);
+const outlierAutocomplete = feature("outlierAutocomplete", { outlierCandidate, autocompleteOff, autocompleteOTC, fieldAutocomplete }, (p) => p.outlierCandidate && p.fieldAutocomplete !== undefined && !p.autocompleteOff && !p.autocompleteOTC);
+export const otpFeatures = flattenFeatures({
+    attrMFA,
+    attrOTP,
+    autocompleteOTC,
+    fieldCC,
+    fieldIdentity,
+    formAuthenticator,
+    formComplexity,
+    formMFA,
+    idMatch,
+    labelAuthenticator,
+    labelMFA,
+    labelOTP,
+    nameMatch,
+    numericMode,
+    outlierAutocomplete,
+    outlierEmailMatchScaled,
+    outlierField,
+    outlierForm,
+    outlierHeadings,
+    outlierInputCount,
+    outlierLink,
+    outlierMaxLength,
+    outlierSearch,
+    patternOTP,
+    siblingOfInterest,
+    singleInput,
+    textAuthenticator,
+    textMFA,
+});

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

@@ -0,0 +1,162 @@
+export declare const passwordFeatures: {
+    attrConfirm: {
+        name: "attrConfirm";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    attrCreate: {
+        name: "attrCreate";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    attrCurrent: {
+        name: "attrCurrent";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    attrReset: {
+        name: "attrReset";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    autocompleteCurrent: {
+        name: "autocompleteCurrent";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    autocompleteNew: {
+        name: "autocompleteNew";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    autocompleteOTP: {
+        name: "autocompleteOTP";
+        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;
+    };
+    fieldExotic: {
+        name: "fieldExotic";
+        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;
+    };
+    fieldLogin: {
+        name: "fieldLogin";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    fieldRegister: {
+        name: "fieldRegister";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    labelConfirm: {
+        name: "labelConfirm";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    labelCreate: {
+        name: "labelCreate";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    labelCurrent: {
+        name: "labelCurrent";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    nextPwConfirm: {
+        name: "nextPwConfirm";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    nextPwCurrent: {
+        name: "nextPwCurrent";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    nextPwField: {
+        name: "nextPwField";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    nextPwNew: {
+        name: "nextPwNew";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    passwordOutlier: {
+        name: "passwordOutlier";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    prevPwCurrent: {
+        name: "prevPwCurrent";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    prevPwField: {
+        name: "prevPwField";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    prevPwNew: {
+        name: "prevPwNew";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    textConfirm: {
+        name: "textConfirm";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    textCreate: {
+        name: "textCreate";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    textCurrent: {
+        name: "textCurrent";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    fieldLogin_autocompleteNew: {
+        name: "fieldLogin,autocompleteNew";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): number;
+    };
+    fieldLogin_maybeNew: {
+        name: "fieldLogin,maybeNew";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): number;
+    };
+    fieldRegister_autocompleteCurrent: {
+        name: "fieldRegister,autocompleteCurrent";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): number;
+    };
+    fieldRegister_maybeCurrent: {
+        name: "fieldRegister,maybeCurrent";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): number;
+    };
+    prevPwCurrent_nextPwNew: {
+        name: "prevPwCurrent,nextPwNew";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): number;
+    };
+};

package/features/v1/field.password.js

@@ -0,0 +1,81 @@
+import { feature, featuresProduct, flattenFeatures } from "@protontech/autofill/features/feature";
+import { fieldAttrs, fieldAutocomplete, fieldAutocompleteOff, fieldCC, fieldExotic, fieldIdentity, fieldLabel, fieldLogin, fieldNext, fieldPrev, fieldRegister, fieldText } from "@protontech/autofill/features/v1/abstract.field";
+import { any } from "@protontech/autofill/utils/combinators";
+import { getAllFieldHaystacks } from "@protontech/autofill/utils/extract";
+import { matchPasswordConfirm, matchPasswordConfirmAttr, matchPasswordCreate, matchPasswordCreateAttr, matchPasswordCurrent, matchPasswordCurrentAttr, matchPasswordOutlier, matchPasswordReset, matchPasswordResetAttr, } from "@protontech/autofill/utils/re";
+const passwordOutlier = feature("passwordOutlier", { fieldAttrs, fieldText, fieldLabel }, (p) => any(matchPasswordOutlier)(p.fieldAttrs.concat(p.fieldLabel, p.fieldText)));
+const outlier = feature("outlier", { fieldCC, fieldIdentity, passwordOutlier }, (p) => p.fieldCC || p.fieldIdentity || p.passwordOutlier);
+const autocompleteGated = feature("autocompleteGated", { fieldAutocomplete, outlier }, (p) => { var _a; return (p.outlier ? "" : ((_a = p.fieldAutocomplete) !== null && _a !== void 0 ? _a : "")); });
+const autocompleteNew = feature("autocompleteNew", { autocompleteGated }, (p) => p.autocompleteGated === "new-password");
+const autocompleteCurrent = feature("autocompleteCurrent", { autocompleteGated }, (p) => p.autocompleteGated === "current-password");
+const autocompleteOTP = feature("autocompleteOTP", { autocompleteGated }, (p) => p.autocompleteGated.includes("one-time-code"));
+const attrCurrent = feature("attrCurrent", { fieldAttrs }, (p) => any(matchPasswordCurrentAttr)(p.fieldAttrs));
+const textCurrent = feature("textCurrent", { fieldText }, (p) => matchPasswordCurrent(p.fieldText));
+const labelCurrent = feature("labelCurrent", { fieldLabel }, (p) => matchPasswordCurrent(p.fieldLabel));
+const current = feature("current", { attrCurrent, textCurrent, labelCurrent }, (p) => p.attrCurrent || p.textCurrent || p.labelCurrent);
+const attrCreate = feature("attrCreate", { fieldAttrs }, (p) => any(matchPasswordCreateAttr)(p.fieldAttrs));
+const textCreate = feature("textCreate", { fieldText }, (p) => matchPasswordCreate(p.fieldText));
+const labelCreate = feature("labelCreate", { fieldLabel }, (p) => matchPasswordCreate(p.fieldLabel));
+const create = feature("create", { attrCreate, textCreate, labelCreate }, (p) => p.attrCreate || p.textCreate || p.labelCreate);
+const attrConfirm = feature("attrConfirm", { fieldAttrs }, (p) => any(matchPasswordConfirmAttr)(p.fieldAttrs));
+const textConfirm = feature("textConfirm", { fieldText }, (p) => matchPasswordConfirm(p.fieldText));
+const labelConfirm = feature("labelConfirm", { fieldLabel }, (p) => matchPasswordConfirm(p.fieldLabel));
+const confirm = feature("confirm", { attrConfirm, textConfirm, labelConfirm }, (p) => p.attrConfirm || p.textConfirm || p.labelConfirm);
+const attrReset = feature("attrReset", { fieldAttrs }, (p) => any(matchPasswordResetAttr)(p.fieldAttrs));
+const textReset = feature("textReset", { fieldText }, (p) => matchPasswordReset(p.fieldText));
+const labelReset = feature("labelReset", { fieldLabel }, (p) => matchPasswordReset(p.fieldLabel));
+const reset = feature("reset", { attrReset, textReset, labelReset }, (p) => p.attrReset || p.textReset || p.labelReset);
+const maybeCurrent = feature("maybeCurrent", { current }, (p) => p.current);
+const maybeNew = feature("maybeNew", { create, confirm, reset }, (p) => p.create || p.confirm || p.reset);
+const prevPwFieldEl = feature("prevPwFieldEl", { fieldPrev }, (p) => { var _a; return (((_a = p.fieldPrev) === null || _a === void 0 ? void 0 : _a.getAttribute("type")) === "password" ? p.fieldPrev : null); });
+const prevPwField = feature("prevPwField", { prevPwFieldEl }, (p) => p.prevPwFieldEl !== null);
+const prevPwHaystack = feature("prevPwHaystack", { prevPwFieldEl }, (p) => (p.prevPwFieldEl ? getAllFieldHaystacks(p.prevPwFieldEl) : []));
+const prevPwAutocomplete = feature("prevPwAutocomplete", { prevPwFieldEl }, (p) => { var _a, _b; return (_b = (_a = p.prevPwFieldEl) === null || _a === void 0 ? void 0 : _a.getAttribute("autocomplete")) !== null && _b !== void 0 ? _b : null; });
+const prevPwNew = feature("prevPwNew", { prevPwAutocomplete, prevPwHaystack }, (p) => p.prevPwAutocomplete === "new-password" || any(matchPasswordCreate)(p.prevPwHaystack));
+const prevPwCurrent = feature("prevPwCurrent", { prevPwAutocomplete, prevPwHaystack }, (p) => p.prevPwAutocomplete === "current-password" || any(matchPasswordCurrent)(p.prevPwHaystack));
+const nextPwFieldEl = feature("nextPwFieldEl", { fieldNext }, (p) => { var _a; return (((_a = p.fieldNext) === null || _a === void 0 ? void 0 : _a.getAttribute("type")) === "password" ? p.fieldNext : null); });
+const nextPwField = feature("nextPwField", { nextPwFieldEl }, (p) => p.nextPwFieldEl !== null);
+const nextPwHaystack = feature("nextPwHaystack", { nextPwFieldEl }, (p) => (p.nextPwFieldEl ? getAllFieldHaystacks(p.nextPwFieldEl) : []));
+const nextPwAutocomplete = feature("nextPwAutocomplete", { nextPwFieldEl }, (p) => { var _a, _b; return (_b = (_a = p.nextPwFieldEl) === null || _a === void 0 ? void 0 : _a.getAttribute("autocomplete")) !== null && _b !== void 0 ? _b : null; });
+const nextPwNew = feature("nextPwNew", { nextPwAutocomplete, nextPwHaystack }, (p) => p.nextPwAutocomplete === "new-password" || any(matchPasswordCreate)(p.nextPwHaystack));
+const nextPwConfirm = feature("nextPwConfirm", { nextPwHaystack }, (p) => any(matchPasswordConfirm)(p.nextPwHaystack));
+const nextPwCurrent = feature("nextPwCurrent", { nextPwAutocomplete, nextPwHaystack }, (p) => p.nextPwAutocomplete === "current-password" || any(matchPasswordCurrent)(p.nextPwHaystack));
+const fieldLogin_autocompleteNew = featuresProduct(fieldLogin, autocompleteNew);
+const fieldLogin_maybeNew = featuresProduct(fieldLogin, maybeNew);
+const fieldRegister_autocompleteCurrent = featuresProduct(fieldRegister, autocompleteCurrent);
+const fieldRegister_maybeCurrent = featuresProduct(fieldRegister, maybeCurrent);
+const prevPwCurrent_nextPwNew = featuresProduct(prevPwCurrent, nextPwNew);
+export const passwordFeatures = flattenFeatures({
+    attrConfirm,
+    attrCreate,
+    attrCurrent,
+    attrReset,
+    autocompleteCurrent,
+    autocompleteNew,
+    autocompleteOTP,
+    fieldAutocompleteOff,
+    fieldCC,
+    fieldExotic,
+    fieldIdentity,
+    fieldLogin,
+    fieldRegister,
+    labelConfirm,
+    labelCreate,
+    labelCurrent,
+    nextPwConfirm,
+    nextPwCurrent,
+    nextPwField,
+    nextPwNew,
+    passwordOutlier,
+    prevPwCurrent,
+    prevPwField,
+    prevPwNew,
+    textConfirm,
+    textCreate,
+    textCurrent,
+    fieldLogin_autocompleteNew,
+    fieldLogin_maybeNew,
+    fieldRegister_autocompleteCurrent,
+    fieldRegister_maybeCurrent,
+    prevPwCurrent_nextPwNew,
+});

package/features/v1/field.username-hidden.d.ts

@@ -0,0 +1,62 @@
+export declare const usernameHiddenFeatures: {
+    attrMatch: {
+        name: "attrMatch";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    autocompleteUsername: {
+        name: "autocompleteUsername";
+        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;
+    };
+    fieldAttrUsername: {
+        name: "attrUsername";
+        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;
+    };
+    fieldCC: {
+        name: "fieldCC";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    fieldExotic: {
+        name: "fieldExotic";
+        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;
+    };
+    valueEmail: {
+        name: "valueEmail";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    valueTel: {
+        name: "valueTel";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    valueUsername: {
+        name: "valueUsername";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    visibleReadonly: {
+        name: "visibleReadonly";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+};

package/features/v1/field.username-hidden.js

@@ -0,0 +1,25 @@
+import { feature, flattenFeatures } from "@protontech/autofill/features/feature";
+import { field, fieldAttrEmail, fieldAttrUsername, fieldAutocomplete, fieldAutocompleteEmail, fieldCC, fieldExotic, fieldIdentity, readonly, typeValid, value } from "@protontech/autofill/features/v1/abstract.field";
+import { matchEmailValue, matchTelValue, matchUsernameValue } from "@protontech/autofill/utils/re";
+import { isVisible } from "@protontech/autofill/utils/visible";
+const visibleReadonly = feature("visibleReadonly", { field, typeValid, readonly }, (p) => p.readonly && p.typeValid && isVisible(p.field, { opacity: true }));
+const attrMatch = feature("attrMatch", { field }, (p) => p.field.matches('[name="username"],[id="username"],[name="account"]'));
+const autocompleteUsername = feature("autocompleteUsername", { fieldAutocomplete }, (p) => { var _a; return Boolean((_a = p.fieldAutocomplete) === null || _a === void 0 ? void 0 : _a.includes("username")); });
+const valueCandidate = feature("valueCandidate", { fieldValue: value }, (p) => p.value.length < 100);
+const valueEmail = feature("valueEmail", { valueCandidate, fieldValue: value }, (p) => p.valueCandidate && matchEmailValue(p.value));
+const valueTel = feature("valueTel", { valueCandidate, fieldValue: value }, (p) => p.valueCandidate && matchTelValue(p.value));
+const valueUsername = feature("valueUsername", { valueCandidate, fieldValue: value }, (p) => p.valueCandidate && matchUsernameValue(p.value));
+export const usernameHiddenFeatures = flattenFeatures({
+    attrMatch,
+    autocompleteUsername,
+    fieldAttrEmail,
+    fieldAttrUsername,
+    fieldAutocompleteEmail,
+    fieldCC,
+    fieldExotic,
+    fieldIdentity,
+    valueEmail,
+    valueTel,
+    valueUsername,
+    visibleReadonly,
+});

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

@@ -0,0 +1,72 @@
+export declare const usernameFeatures: {
+    fieldAttrUsername: {
+        name: "attrUsername";
+        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;
+    };
+    fieldAutocompleteUsername: {
+        name: "autocompleteUsername";
+        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;
+    };
+    firstLoginFormField: {
+        name: "firstLoginFormField";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    labelUsername: {
+        name: "labelUsername";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    outlierAttrs: {
+        name: "outlierAttrs";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    outlierEmail: {
+        name: "outlierEmail";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    outlierLabel: {
+        name: "outlierLabel";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    outlierText: {
+        name: "outlierText";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+    textUsername: {
+        name: "textUsername";
+        parents: import("../..").AbstractFeatures;
+        compute(parents: import("../..").InferParentComputeType<import("../..").AbstractFeatures>, fnode: import("@protontech/fathom").Fnode): boolean;
+    };
+};

package/features/v1/field.username.js

@@ -0,0 +1,31 @@
+import { feature, flattenFeatures } from "@protontech/autofill/features/feature";
+import { fieldAttrs, fieldAttrUsername, fieldAutocompleteEmail, fieldAutocompleteOff, fieldAutocompleteUsername, fieldCC, fieldEmailMatch, fieldFeats, fieldIdentity, fieldLabel, fieldPrevInput, fieldSearch, fieldText, } from "@protontech/autofill/features/v1/abstract.field";
+import { any } from "@protontech/autofill/utils/combinators";
+import { matchUsername, matchUsernameOutlier } from "@protontech/autofill/utils/re";
+const textUsername = feature("textUsername", { fieldText }, (p) => matchUsername(p.fieldText));
+const labelUsername = feature("labelUsername", { fieldLabel }, (p) => matchUsername(p.fieldLabel));
+const username = feature("username", { fieldAttrUsername, textUsername, labelUsername }, (p) => p.attrUsername || p.textUsername || p.labelUsername);
+const outlierAttrs = feature("outlierAttrs", { fieldAttrs }, (p) => any(matchUsernameOutlier)(p.fieldAttrs));
+const outlierText = feature("outlierText", { fieldText }, (p) => matchUsernameOutlier(p.fieldText));
+const outlierLabel = feature("outlierLabel", { fieldLabel }, (p) => matchUsernameOutlier(p.fieldLabel));
+const outlierEmail = feature("outlierEmail", { username, emailMatch: fieldEmailMatch }, (p) => !p.username && p.emailMatch);
+const outlier = feature("outlier", { outlierAttrs, outlierText, outlierLabel, outlierEmail }, (p) => p.outlierAttrs || p.outlierText || p.outlierLabel || p.outlierEmail);
+const maybeCandidate = feature("maybeCandidate", { outlier, username }, (p) => !(p.outlier || p.username));
+const firstFormField = feature("firstFormField", { fieldPrevInput }, (p) => p.fieldPrevInput === null);
+const firstLoginFormField = feature("firstLoginFormField", { fieldFeats, firstFormField, maybeCandidate }, (p) => p.fieldFeats.isFormLogin && p.firstFormField && p.maybeCandidate);
+export const usernameFeatures = flattenFeatures({
+    fieldAttrUsername,
+    fieldAutocompleteEmail,
+    fieldAutocompleteOff,
+    fieldAutocompleteUsername,
+    fieldCC,
+    fieldIdentity,
+    fieldSearch,
+    firstLoginFormField,
+    labelUsername,
+    outlierAttrs,
+    outlierEmail,
+    outlierLabel,
+    outlierText,
+    textUsername,
+});