@protontech/autofill 0.0.22991789 → 0.0.33690782

package/utils/field.js

@@ -1,14 +1,23 @@
-import { MIN_AREA_SUBMIT_BTN } from "../constants/heuristics";
-import { inputCandidateSelector, kPasswordSelector, kUsernameSelector, otpSelector } from "../constants/selectors";
+import { MIN_AREA_SUBMIT_BTN } from "@protontech/autofill/constants/heuristics";
+import { inputCandidateSelector, kPasswordSelector, kUsernameSelector } from "@protontech/autofill/constants/selectors";
 import { and, any, not, or } from "./combinators";
 import { getAllFieldHaystacks } from "./extract";
 import { getParentFormFnode } from "./fathom";
 import { isClassifiable, isHidden, isProcessed } from "./flags";
 import { matchEmail, matchOAuth, matchUsername } from "./re";
 import { isVisible, isVisibleField } from "./visible";
+export const isInput = (el) => el.tagName === "INPUT";
+export const isInputField = (el) => {
+    if (!isInput(el))
+        return false;
+    return el.type !== "button" && el.type !== "submit";
+};
+export const isSelect = (el) => el.tagName === "SELECT";
+export const isTextarea = (el) => el.tagName === "TEXTAREA";
 const isActiveFieldFNode = (fnode) => {
-    const { visible, readonly, disabled } = fnode.noteFor("field");
-    return visible && !readonly && !disabled;
+    const el = fnode.element;
+    const { visible } = fnode.noteFor("field");
+    return visible && !el.readOnly && !el.disabled;
 };
 export const splitFieldsByVisibility = (els) => {
     return els.reduce((acc, el) => {
@@ -19,19 +28,21 @@ export const splitFieldsByVisibility = (els) => {
         return acc;
     }, [[], []]);
 };
-const fType = (types) => (fnode) => types.includes(fnode.element.type);
+export const fType = (type) => (fnode) => fnode.hasType(type);
+const fInput = (types) => (fnode) => types.includes(fnode.element.type);
 const fMatch = (selector) => (fnode) => fnode.element.matches(selector);
-const fInputMode = (inputMode) => (fnode) => fnode.element.inputMode === inputMode;
+const fMode = (mode) => (fnode) => fnode.element.inputMode === mode;
 const fActive = (fnode) => isActiveFieldFNode(fnode);
 const fList = (fnode) => fnode.element.getAttribute("aria-autocomplete") === "list" || fnode.element.role === "combobox";
-export const maybeEmail = and(not(fList), or(fType(["email", "text"]), fInputMode("email")), fActive);
-export const maybePassword = and(fMatch(kPasswordSelector), fActive);
-export const maybeOTP = and(not(fList), fMatch(otpSelector), fActive);
-export const maybeUsername = and(not(fList), or(and(not(fInputMode("email")), fType(["text", "tel"])), fMatch(kUsernameSelector)), fActive);
-export const maybeHiddenUsername = and(not(fList), fType(["email", "text", "hidden"]), not(fActive));
-export const isUsernameCandidate = (el) => !el.matches('input[type="email"]') && any(matchUsername)(getAllFieldHaystacks(el));
-export const isEmailCandidate = (el) => el.matches('input[type="email"]') || any(matchEmail)(getAllFieldHaystacks(el));
+export const maybeEmail = and(not(fList), or(fInput(["email", "text"]), fMode("email")), fActive);
+export const maybePassword = and(not(fList), fMatch(kPasswordSelector), fActive);
+export const maybeOTP = and(fInput(["text", "number", "tel"]), fActive, not(fList));
+export const maybeUsername = and(not(fList), or(and(not(fMode("email")), fInput(["text", "tel"])), fMatch(kUsernameSelector)), fActive);
+export const maybeHiddenUsername = and(not(fList), fInput(["email", "text", "hidden"]), not(fActive));
+export const isUsernameCandidate = (el) => el.type === "text" || (el.type === "tel" && any(matchUsername)(getAllFieldHaystacks(el)));
+export const isEmailCandidate = (el) => el.type === "email" || (el.type === "text" && any(matchEmail)(getAllFieldHaystacks(el)));
 export const isOAuthCandidate = (el) => any(matchOAuth)(getAllFieldHaystacks(el));
+export const isMFACandidate = (el) => ["text", "number", "tel"].includes(el.type);
 export const isBtnCandidate = (btn) => {
     if (btn.getAttribute("type") === "submit")
         return true;
@@ -46,5 +57,5 @@ export const isProcessableField = (input) => {
     const hidden = isHidden(input);
     return (!processed || hidden) && isVisibleField(input) && isVisible(input, { opacity: false });
 };
-export const isClassifiableField = (fnode) => isClassifiable(fnode.element) && getParentFormFnode(fnode) !== null;
+export const isClassifiableField = (fnode) => fnode.element.tagName === "INPUT" && isClassifiable(fnode.element) && getParentFormFnode(fnode) !== null;
 export const selectInputCandidates = (target = document) => Array.from(target.querySelectorAll(inputCandidateSelector)).filter(isClassifiable);

package/utils/flags.d.ts

@@ -1,4 +1,4 @@
-import { Fnode } from "@protontech/fathom";
+import type { Fnode } from "@protontech/fathom";
 export declare const isCluster: (el: HTMLElement) => boolean;
 export declare const flagCluster: (el: HTMLElement) => void;
 export declare const isHidden: (el: HTMLElement) => boolean;
@@ -14,12 +14,18 @@ export declare const isProcessed: (el: HTMLElement) => boolean;
 export declare const flagAsProcessed: (el: HTMLElement) => boolean;
 export declare const removeProcessedFlag: (el: HTMLElement) => boolean;
 export declare const isPrediction: (el: HTMLElement) => boolean;
-export declare const removePredictionFlag: (el: HTMLElement) => boolean;
+export declare const removePredictionFlag: (el: HTMLElement) => void;
 export declare const getParentFormPrediction: (el?: HTMLElement) => HTMLElement | null;
+export declare const setCachedSubType: (_el: HTMLElement, subType: string) => void;
+export declare const getCachedSubType: (el: HTMLElement) => string | undefined;
+export declare const matchPredictedType: (type: string) => (str: string) => boolean;
 export declare const setCachedPredictionScore: (_el: HTMLElement, type: string, score: number) => void;
 export declare const getCachedPredictionScore: (type: string) => (fnode: Fnode) => number;
 export declare const isPredictedType: (type: string) => (fnode: Fnode) => boolean;
+export declare const isPredictedForm: (value: Fnode) => boolean;
+export declare const isPredictedField: (value: Fnode) => boolean;
 export declare const isClassifiable: (el: HTMLElement) => boolean;
-export declare const removeClassifierFlags: (el: HTMLElement, options: {
+export declare const removeClassifierFlags: (target: HTMLElement, options: {
     preserveIgnored: boolean;
+    fields?: HTMLElement[];
 }) => void;

package/utils/flags.js

@@ -1,4 +1,6 @@
 import { FORM_CLUSTER_ATTR, kFieldSelector } from "../constants/selectors";
+import { FieldType, FormType } from "../types";
+import { or } from "./combinators";
 import { closestParent } from "./dom";
 export const isCluster = (el) => el.getAttribute(FORM_CLUSTER_ATTR) !== null;
 export const flagCluster = (el) => el.setAttribute(FORM_CLUSTER_ATTR, "");
@@ -18,10 +20,19 @@ export const isProcessed = (el) => el.__PP_SEEN__ === true;
 export const flagAsProcessed = (el) => (el.__PP_SEEN__ = true);
 export const removeProcessedFlag = (el) => delete el.__PP_SEEN__;
 export const isPrediction = (el) => el.__PP_TYPE__ !== undefined;
-export const removePredictionFlag = (el) => delete el.__PP_TYPE__;
+export const removePredictionFlag = (el) => {
+    delete el.__PP_TYPE__;
+    delete el.__PP_SUBTYPE__;
+};
 export const getParentFormPrediction = (el) => (el ? closestParent(el, isPrediction) : null);
 const TYPE_SEPARATOR = ",";
 const SCORE_SEPARATOR = ":";
+export const setCachedSubType = (_el, subType) => {
+    const el = _el;
+    el.__PP_SUBTYPE__ = subType;
+};
+export const getCachedSubType = (el) => el.__PP_SUBTYPE__;
+export const matchPredictedType = (type) => (str) => { var _a; return ((_a = str.split(SCORE_SEPARATOR)) === null || _a === void 0 ? void 0 : _a[0]) === type; };
 export const setCachedPredictionScore = (_el, type, score) => {
     const el = _el;
     const currentType = el.__PP_TYPE__;
@@ -31,7 +42,7 @@ export const setCachedPredictionScore = (_el, type, score) => {
         return;
     }
     const types = currentType.split(TYPE_SEPARATOR);
-    const existingIndex = types.findIndex((pred) => pred.startsWith(type));
+    const existingIndex = types.findIndex(matchPredictedType(type));
     if (existingIndex !== -1)
         types[existingIndex] = flag;
     else
@@ -42,7 +53,7 @@ export const getCachedPredictionScore = (type) => (fnode) => {
     const types = fnode.element.__PP_TYPE__;
     if (!types)
         return -1;
-    const predForType = types.split(TYPE_SEPARATOR).find((pred) => pred.startsWith(type));
+    const predForType = types.split(TYPE_SEPARATOR).find(matchPredictedType(type));
     if (!predForType)
         return -1;
     const [, scoreStr] = predForType.split(SCORE_SEPARATOR);
@@ -50,11 +61,18 @@ export const getCachedPredictionScore = (type) => (fnode) => {
     return Number.isFinite(score) ? score : -1;
 };
 export const isPredictedType = (type) => (fnode) => getCachedPredictionScore(type)(fnode) !== -1;
+export const isPredictedForm = or(...Object.values(FormType).map((type) => isPredictedType(type)));
+export const isPredictedField = or(...Object.values(FieldType).map((type) => isPredictedType(type)));
 export const isClassifiable = (el) => !(isPrediction(el) || isIgnored(el) || attrIgnored(el));
-export const removeClassifierFlags = (el, options) => {
-    removeProcessedFlag(el);
-    removePredictionFlag(el);
-    if (!options.preserveIgnored)
-        removeIgnoredFlag(el);
-    el.querySelectorAll(kFieldSelector).forEach((el) => removeClassifierFlags(el, options));
+export const removeClassifierFlags = (target, options) => {
+    var _a;
+    const clean = (el) => {
+        removeProcessedFlag(el);
+        removePredictionFlag(el);
+        if (!options.preserveIgnored)
+            removeIgnoredFlag(el);
+    };
+    clean(target);
+    target.querySelectorAll(kFieldSelector).forEach(clean);
+    (_a = options.fields) === null || _a === void 0 ? void 0 : _a.forEach(clean);
 };

package/utils/form.d.ts

@@ -1,7 +1,18 @@
+import type { HTMLFieldElement } from "./field";
 export declare const getFormParent: (form: HTMLElement) => HTMLElement;
-export type FormInputIterator = ReturnType<typeof createInputIterator>;
-export declare const createInputIterator: (form: HTMLElement) => {
-    prev(input: HTMLElement): HTMLElement | null;
-    next(input: HTMLElement): HTMLElement | null;
-};
+export interface FormInputIterator {
+    prev: (el: HTMLElement, tagNameFilter?: string) => HTMLElement | null;
+    next: (el: HTMLElement, tagNameFilter?: string) => HTMLElement | null;
+}
+export declare const createInputIterator: (form: HTMLElement) => FormInputIterator;
 export declare const selectFormCandidates: (root?: Document | HTMLElement) => HTMLElement[];
+type FormComplexityOptions = {
+    fields: HTMLFieldElement[];
+    visibleFields: number;
+    nonVisibleFields: number;
+    hiddenFields: number;
+    buttons: number;
+    anchors: number;
+};
+export declare const getFormComplexity: (form: HTMLElement, options: FormComplexityOptions) => number;
+export {};

package/utils/form.js

@@ -1,25 +1,46 @@
-import { MAX_FORM_FIELD_WALK_UP } from "../constants/heuristics";
-import { formCandidateSelector, inputCandidateSelector } from "../constants/selectors";
+import { MAX_FORM_FIELD_WALK_UP } from "@protontech/autofill/constants/heuristics";
+import { formCandidateSelector, kInputIteratorSelector } from "@protontech/autofill/constants/selectors";
 import { walkUpWhile } from "./dom";
 import { attrIgnored, isIgnored } from "./flags";
 import { isVisibleField } from "./visible";
 export const getFormParent = (form) => walkUpWhile(form, MAX_FORM_FIELD_WALK_UP)((el) => el.querySelectorAll(formCandidateSelector).length <= 1);
 export const createInputIterator = (form) => {
-    const formEls = Array.from(form.querySelectorAll(inputCandidateSelector)).filter(isVisibleField);
-    return {
-        prev(input) {
-            var _a;
-            const idx = formEls.indexOf(input);
-            return idx === -1 ? null : (_a = formEls === null || formEls === void 0 ? void 0 : formEls[idx - 1]) !== null && _a !== void 0 ? _a : null;
-        },
-        next(input) {
-            var _a;
-            const idx = formEls.indexOf(input);
-            return idx === -1 ? null : (_a = formEls === null || formEls === void 0 ? void 0 : formEls[idx + 1]) !== null && _a !== void 0 ? _a : null;
-        },
+    const formEls = Array.from(form.querySelectorAll(kInputIteratorSelector)).filter(isVisibleField);
+    const getAdjacent = (el, offset, tagNameFilter) => {
+        var _a;
+        const idx = formEls.indexOf(el);
+        const res = idx === -1 ? null : ((_a = formEls === null || formEls === void 0 ? void 0 : formEls[idx + offset]) !== null && _a !== void 0 ? _a : null);
+        return res && tagNameFilter && (res === null || res === void 0 ? void 0 : res.tagName) !== tagNameFilter ? getAdjacent(res, offset, tagNameFilter) : res;
     };
+    const iterator = {
+        prev: (el, tagNameFilter) => getAdjacent(el, -1, tagNameFilter),
+        next: (el, tagNameFilter) => getAdjacent(el, 1, tagNameFilter),
+    };
+    return iterator;
 };
 export const selectFormCandidates = (root = document) => {
     const candidates = Array.from(root.querySelectorAll(formCandidateSelector));
     return candidates.filter((form) => !isIgnored(form) && !attrIgnored(form));
 };
+export const getFormComplexity = (form, options) => {
+    const types = new Set();
+    let score = 0;
+    score += options.visibleFields * 2;
+    score += options.buttons * 1;
+    score += options.anchors * 0.5;
+    score += options.nonVisibleFields * 0.25;
+    score += options.hiddenFields * 0.1;
+    for (const field of options.fields) {
+        const type = field.tagName === "INPUT" ? field.type : field.tagName;
+        if (!types.has(type)) {
+            score += 0.2;
+            types.add(type);
+        }
+    }
+    score += form.querySelectorAll("fieldset, [role='group'], [role='radiogroup']").length * 0.2;
+    for (const el of form.querySelectorAll("div, section")) {
+        if (el.children.length > 1)
+            score += 0.2;
+    }
+    return score;
+};

package/utils/identity.d.ts

@@ -1,24 +1,15 @@
-import { Fnode } from "@protontech/fathom";
-export declare enum IdentityFieldType {
-    FULLNAME = 1,
-    FIRSTNAME = 2,
-    MIDDLENAME = 3,
-    LASTNAME = 4,
-    TELEPHONE = 5,
-    ADDRESS = 6,
-    STATE = 7,
-    CITY = 8,
-    ZIPCODE = 9,
-    ORGANIZATION = 10,
-    COUNTRY = 11,
-    EMAIL = 12
-}
-export declare const getIdentityHaystack: (input: HTMLInputElement) => string;
-export declare const getIdentityFieldType: (input: HTMLInputElement) => IdentityFieldType | undefined;
-export declare const maybeIdentity: (fnode: Fnode) => boolean;
-export declare const matchesIdentityField: (input: HTMLInputElement, options: {
-    isFormLogin: boolean;
+import type { Fnode } from "@protontech/fathom";
+import { IdentityFieldType } from "@protontech/autofill/types";
+import type { FormClassification } from "./fathom";
+type IdentityFieldMatchParams = {
+    form: FormClassification;
     searchField: boolean;
     type: string | null;
     visible: boolean;
-}) => boolean;
+};
+export declare const getCachedIdentitySubType: (el: HTMLElement) => IdentityFieldType | undefined;
+export declare const getIdentityHaystack: (input: HTMLInputElement) => string;
+export declare const getIdentityFieldType: (input: HTMLInputElement) => IdentityFieldType | undefined;
+export declare const matchIdentityField: (input: HTMLInputElement, { visible }: IdentityFieldMatchParams) => boolean;
+export declare const isIdentity: (fnode: Fnode) => boolean;
+export {};

package/utils/identity.js

@@ -1,63 +1,88 @@
-import { matchAddress, matchCity, matchCountry, matchFirstName, matchFullName, matchLastName, matchMiddleName, matchOrganization, matchState, matchTelephone, matchZipCode, } from "./re";
+import { IdentityFieldType, identityFields } from "@protontech/autofill/types";
+import { getAutocompletes } from "./extract";
+import { getCachedSubType, setCachedSubType } from "./flags";
+import { matchAddress, matchCity, matchCountry, matchFirstName, matchFullName, matchLastName, matchMiddleName, matchOrganization, matchState, matchTelephone, matchZipCode } from "./re";
 import { sanitizeStringWithSpaces } from "./text";
-export var IdentityFieldType;
-(function (IdentityFieldType) {
-    IdentityFieldType[IdentityFieldType["FULLNAME"] = 1] = "FULLNAME";
-    IdentityFieldType[IdentityFieldType["FIRSTNAME"] = 2] = "FIRSTNAME";
-    IdentityFieldType[IdentityFieldType["MIDDLENAME"] = 3] = "MIDDLENAME";
-    IdentityFieldType[IdentityFieldType["LASTNAME"] = 4] = "LASTNAME";
-    IdentityFieldType[IdentityFieldType["TELEPHONE"] = 5] = "TELEPHONE";
-    IdentityFieldType[IdentityFieldType["ADDRESS"] = 6] = "ADDRESS";
-    IdentityFieldType[IdentityFieldType["STATE"] = 7] = "STATE";
-    IdentityFieldType[IdentityFieldType["CITY"] = 8] = "CITY";
-    IdentityFieldType[IdentityFieldType["ZIPCODE"] = 9] = "ZIPCODE";
-    IdentityFieldType[IdentityFieldType["ORGANIZATION"] = 10] = "ORGANIZATION";
-    IdentityFieldType[IdentityFieldType["COUNTRY"] = 11] = "COUNTRY";
-    IdentityFieldType[IdentityFieldType["EMAIL"] = 12] = "EMAIL";
-})(IdentityFieldType || (IdentityFieldType = {}));
-const IDENTITY_RE_MAP = [
-    [IdentityFieldType.FIRSTNAME, matchFirstName],
-    [IdentityFieldType.MIDDLENAME, matchMiddleName],
-    [IdentityFieldType.LASTNAME, matchLastName],
-    [IdentityFieldType.FULLNAME, matchFullName],
-    [IdentityFieldType.TELEPHONE, matchTelephone],
-    [IdentityFieldType.ORGANIZATION, matchOrganization],
-    [IdentityFieldType.CITY, matchCity],
-    [IdentityFieldType.ZIPCODE, matchZipCode],
-    [IdentityFieldType.STATE, matchState],
-    [IdentityFieldType.COUNTRY, matchCountry],
-    [IdentityFieldType.ADDRESS, matchAddress],
+const guard = (options, predicate) => (field, autocompletes, haystack) => {
+    if (!options.number && field.getAttribute("type") === "number")
+        return false;
+    if (options.autocompletes.some((match) => autocompletes.includes(match)))
+        return true;
+    return predicate(haystack);
+};
+const IDENTITY_MATCHERS = [
+    [IdentityFieldType.FIRSTNAME, guard({ autocompletes: ["given-name"] }, matchFirstName)],
+    [IdentityFieldType.MIDDLENAME, guard({ autocompletes: ["additional-name"] }, matchMiddleName)],
+    [IdentityFieldType.LASTNAME, guard({ autocompletes: ["family-name"] }, matchLastName)],
+    [IdentityFieldType.FULLNAME, guard({ autocompletes: ["name"] }, matchFullName)],
+    [IdentityFieldType.TELEPHONE, guard({ autocompletes: ["tel", "tel-national", "tel-local"], number: true }, matchTelephone)],
+    [IdentityFieldType.ORGANIZATION, guard({ autocompletes: ["organization"] }, matchOrganization)],
+    [IdentityFieldType.CITY, guard({ autocompletes: ["address-level2"] }, matchCity)],
+    [IdentityFieldType.ZIPCODE, guard({ autocompletes: ["postal-code"], number: true }, matchZipCode)],
+    [IdentityFieldType.STATE, guard({ autocompletes: ["address-level1"] }, matchState)],
+    [IdentityFieldType.COUNTRY, guard({ autocompletes: ["country-name"] }, matchCountry)],
+    [IdentityFieldType.ADDRESS, guard({ autocompletes: ["street-address", "address-line1"] }, matchAddress)],
 ];
 const IDENTITY_ATTRIBUTES = ["autocomplete", "name", "id", "data-bhw"];
 const IDENTITY_INPUT_TYPES = ["tel", "phone", "text", "number"];
+export const getCachedIdentitySubType = (el) => {
+    const subType = getCachedSubType(el);
+    if (subType && identityFields.has(subType))
+        return subType;
+};
 export const getIdentityHaystack = (input) => {
     const attrs = IDENTITY_ATTRIBUTES.map((attr) => { var _a; return (_a = input === null || input === void 0 ? void 0 : input.getAttribute(attr)) !== null && _a !== void 0 ? _a : ""; });
     return sanitizeStringWithSpaces(attrs.join(" "));
 };
 export const getIdentityFieldType = (input) => {
-    var _a;
+    var _a, _b;
+    const cachedSubType = getCachedIdentitySubType(input);
+    if (cachedSubType)
+        return cachedSubType;
+    if (getCachedSubType(input) !== undefined)
+        return;
+    const type = input.getAttribute("type");
+    if (type && !IDENTITY_INPUT_TYPES.includes(type))
+        return;
+    if ((_a = input.getAttribute("autocomplete")) === null || _a === void 0 ? void 0 : _a.includes("email"))
+        return;
     const haystack = getIdentityHaystack(input);
-    if (haystack)
-        return (_a = IDENTITY_RE_MAP.find(([, test]) => test(haystack))) === null || _a === void 0 ? void 0 : _a[0];
+    const autocompletes = getAutocompletes(input);
+    if (haystack) {
+        const identityType = (_b = IDENTITY_MATCHERS.find(([, test]) => test(input, autocompletes, haystack))) === null || _b === void 0 ? void 0 : _b[0];
+        if (identityType)
+            setCachedSubType(input, identityType);
+        return identityType;
+    }
 };
 const isAutocompleteListInput = (el) => el.getAttribute("aria-autocomplete") === "list" || el.role === "combobox";
-export const maybeIdentity = (fnode) => {
-    var _a;
-    const fieldFeatures = fnode.noteFor("field");
-    return (_a = fieldFeatures === null || fieldFeatures === void 0 ? void 0 : fieldFeatures.identityField) !== null && _a !== void 0 ? _a : false;
+export const matchIdentityField = (input, { visible }) => {
+    if (!visible)
+        return false;
+    if (getCachedIdentitySubType(input))
+        return true;
+    const identityType = getIdentityFieldType(input);
+    if (!identityType)
+        return false;
+    setCachedSubType(input, identityType);
+    return true;
 };
-export const matchesIdentityField = (input, options) => {
-    const { visible, isFormLogin, type, searchField } = options;
-    if ((type && !IDENTITY_INPUT_TYPES.includes(type)) || !visible || isFormLogin)
+export const isIdentity = (fnode) => {
+    const input = fnode.element;
+    const { isIdentity, isCC, searchField, isFormLogin, isFormRecovery, visible } = fnode.noteFor("field");
+    if (!visible)
+        return false;
+    if (isCC || !isIdentity)
         return false;
     const identityType = getIdentityFieldType(input);
     if (!identityType)
         return false;
+    const outlierForm = isFormLogin || isFormRecovery;
+    if (outlierForm)
+        return false;
     if (isAutocompleteListInput(input))
         return [IdentityFieldType.ADDRESS, IdentityFieldType.ZIPCODE].includes(identityType);
-    if (type === "number")
-        return [IdentityFieldType.TELEPHONE, IdentityFieldType.ZIPCODE].includes(identityType);
     if (searchField)
-        return [IdentityFieldType.ADDRESS, IdentityFieldType.ZIPCODE, identityType === IdentityFieldType.CITY].includes(identityType);
+        return [IdentityFieldType.ADDRESS, IdentityFieldType.ZIPCODE, IdentityFieldType.CITY].includes(identityType);
     return true;
 };

package/utils/identity.samples.spec.d.ts

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

package/utils/identity.samples.spec.js

@@ -0,0 +1,28 @@
+import { IdentityFieldType } from "@protontech/autofill/types";
+import { getIdentityFieldType } from "./identity";
+const fieldTest = (type, samples) => {
+    test.each(samples.map((html) => ({ html, preview: html.substring(0, 42) })))("$preview", ({ html }) => {
+        document.body.innerHTML = html;
+        const field = document.querySelector("input");
+        expect(getIdentityFieldType(field)).toBe(type);
+    });
+};
+Object.defineProperty(HTMLElement.prototype, "innerText", {
+    get() {
+        return this.textContent;
+    },
+});
+describe("Identity field samples", () => {
+    describe("IdentityFieldType.FIRSTNAME", () => {
+        const samples = [
+            `<div class="sc-d9ebd515-0 hLmoFN"><label data-ignore-a11y="true" for="shipping_firstname" id="shipping_firstname-label" class="sc-94eb08bc-0 bfsAop sc-d9ebd515-1 dIGbxh">Nombre</label><input autocomplete="on" name="shipping_firstname" maxlength="50" id="shipping_firstname" type="text" aria-invalid="true" aria-required="false" aria-disabled="false" data-test="shipping_firstname" class="sc-7af5671c-1 boqXeD" value=""></div>`,
+        ];
+        fieldTest(IdentityFieldType.FIRSTNAME, samples);
+    });
+    describe.only("IdentityFieldType.TELEPHONE", () => {
+        const samples = [
+            `<div class="sc-d9ebd515-0 hLmoFN"><label data-ignore-a11y="true" for=":rp:" id=":rp:-label" class="sc-94eb08bc-0 dEnlRJ sc-d9ebd515-1 hfkVHI">Número de teléfono.</label><input name="shipping_phoneNumber" autocomplete="on" id=":rp:" placeholder="" type="tel" aria-invalid="true" aria-required="false" aria-disabled="false" aria-describedby=":rp:-help" data-test="shipping_phoneNumber" class="sc-7af5671c-2 iteJpf" value="+34 "></div>`,
+        ];
+        fieldTest(IdentityFieldType.TELEPHONE, samples);
+    });
+});

package/utils/iframe.d.ts

@@ -0,0 +1,2 @@
+export declare const isIFrameField: (iframe: HTMLIFrameElement) => boolean;
+export declare const isEditorFrame: () => boolean;

package/utils/iframe.js

@@ -0,0 +1,22 @@
+import { kEditorSelector } from "@protontech/autofill/constants/selectors";
+import { matchIFrameField } from "./re";
+import { sanitizeStringWithSpaces } from "./text";
+export const isIFrameField = (iframe) => {
+    var _a, _b, _c;
+    const title = (_a = iframe.getAttribute("title")) !== null && _a !== void 0 ? _a : "";
+    const name = (_b = iframe.getAttribute("name")) !== null && _b !== void 0 ? _b : "";
+    const ariaLabel = (_c = iframe.getAttribute("aria-label")) !== null && _c !== void 0 ? _c : "";
+    const id = iframe.id;
+    const src = iframe.src.substring(0, 150);
+    const className = iframe.className.substring(0, 150);
+    const haystack = sanitizeStringWithSpaces(`${title} ${name} ${ariaLabel} ${id} ${src} ${className}`);
+    return matchIFrameField(haystack);
+};
+export const isEditorFrame = () => {
+    var _a;
+    if (document.designMode === "on")
+        return true;
+    if ((_a = document.body) === null || _a === void 0 ? void 0 : _a.isContentEditable)
+        return true;
+    return document.querySelector(kEditorSelector) !== null;
+};

package/utils/overrides.d.ts

@@ -0,0 +1,19 @@
+import type { AnyRule } from "@protontech/autofill/types";
+type Override = {
+    form: HTMLElement;
+    formType: string;
+    fields: {
+        field: HTMLElement;
+        fieldType: string;
+    }[];
+};
+export declare const OVERRIDE_FORMS: Set<HTMLElement>;
+export declare const OVERRIDE_FIELDS: Set<HTMLElement>;
+export declare const addFormOverride: (el: HTMLElement) => Set<HTMLElement>;
+export declare const addFieldOverride: (el: HTMLElement) => Set<HTMLElement>;
+export declare const clearOverrides: () => void;
+export declare const getOverridableForms: () => HTMLElement[];
+export declare const getOverridableFields: () => HTMLElement[];
+export declare const overrides: AnyRule[];
+export declare const flagOverride: ({ form, formType, fields }: Override) => void;
+export {};

package/utils/overrides.js

@@ -0,0 +1,40 @@
+import { domQuery, rule, type } from "@protontech/fathom";
+import { flagCluster, isPredictedField, isPredictedForm, removePredictionFlag, setCachedPredictionScore } from "./flags";
+import { isShadowElement } from "./shadow-dom";
+import { isVisibleField, isVisibleForm } from "./visible";
+export const OVERRIDE_FORMS = new Set();
+export const OVERRIDE_FIELDS = new Set();
+export const addFormOverride = (el) => OVERRIDE_FORMS.add(el);
+export const addFieldOverride = (el) => OVERRIDE_FIELDS.add(el);
+export const clearOverrides = () => {
+    OVERRIDE_FORMS.clear();
+    OVERRIDE_FIELDS.clear();
+};
+export const getOverridableForms = () => Array.from(OVERRIDE_FORMS);
+export const getOverridableFields = () => Array.from(OVERRIDE_FIELDS);
+const matchFormOverrides = () => domQuery(getOverridableForms);
+const matchFieldOverrides = () => domQuery(getOverridableFields);
+const acceptFormOverride = (fnode) => isPredictedForm(fnode) && isVisibleForm(fnode.element);
+const acceptFieldOverride = (fnode) => isPredictedField(fnode) && isVisibleField(fnode.element);
+export const overrides = [
+    rule(matchFormOverrides(), type("override-form"), {}),
+    rule(matchFieldOverrides(), type("override-field"), {}),
+    rule(type("override-form").when(acceptFormOverride), type("form-candidate"), {}),
+    rule(type("override-field").when(acceptFieldOverride), type("field-candidate"), {}),
+];
+export const flagOverride = ({ form, formType, fields }) => {
+    if (isVisibleForm(form)) {
+        removePredictionFlag(form);
+        setCachedPredictionScore(form, formType, 1);
+        if (isShadowElement(form))
+            addFormOverride(form);
+        else if (form.tagName !== "FORM")
+            flagCluster(form);
+        fields.forEach(({ field, fieldType }) => {
+            removePredictionFlag(field);
+            setCachedPredictionScore(field, fieldType, 1);
+            if (isShadowElement(field))
+                addFieldOverride(field);
+        });
+    }
+};

package/utils/prepass.js

@@ -3,6 +3,7 @@ import { excludeClusterableNodes, excludeFields, excludeForms } from "./exclusio
 import { isProcessableField, selectInputCandidates } from "./field";
 import { isProcessed, removeClassifierFlags, removeHiddenFlag } from "./flags";
 import { selectFormCandidates } from "./form";
+import { getOverridableFields, getOverridableForms } from "./overrides";
 import { isVisibleForm } from "./visible";
 export const prepass = (doc = document) => {
     excludeForms(doc);
@@ -11,7 +12,8 @@ export const prepass = (doc = document) => {
     resolveFormClusters(doc);
 };
 export const shouldRunClassifier = () => {
-    const runForForms = selectFormCandidates().reduce((runDetection, form) => {
+    const formCandidates = getOverridableForms().concat(selectFormCandidates());
+    const shouldRunForForms = formCandidates.reduce((runDetection, form) => {
         if (isProcessed(form)) {
             const unprocessedFields = selectInputCandidates(form).some(isProcessableField);
             if (unprocessedFields)
@@ -24,8 +26,8 @@ export const shouldRunClassifier = () => {
         }
         return runDetection;
     }, false);
-    if (runForForms)
+    if (shouldRunForForms)
         return true;
-    const runForFields = selectInputCandidates().some(isProcessableField);
-    return runForFields;
+    const fieldCandidates = getOverridableFields().concat(selectInputCandidates());
+    return fieldCandidates.some(isProcessableField);
 };

package/utils/re.d.ts

@@ -37,11 +37,14 @@ export declare const matchPasswordCurrent: (value: string) => boolean;
 export declare const matchPasswordCurrentAttr: (value: string) => boolean;
 export declare const matchPasswordOutlier: (str: string) => boolean;
 export declare const matchHidden: (str: string) => boolean;
-export declare const matchMfaAction: (str: string) => boolean;
-export declare const matchMfa: (str: string) => boolean;
-export declare const matchMfaAttr: (str: string) => boolean;
+export declare const matchTwoFa: (value: string) => boolean;
 export declare const matchOtpAttr: (str: string) => boolean;
-export declare const matchOtpOutlier: (value: string) => boolean;
+export declare const matchOtpOutlier: (str: string) => boolean;
+export declare const matchOtpFieldOutlier: (value: string) => boolean;
+export declare const matchOtpOutlierAction: (str: string) => boolean;
+export declare const matchAuthenticator: (str: string) => boolean;
+export declare const matchMFAAttr: (str: string) => boolean;
+export declare const matchMFA: (value: string) => boolean;
 export declare const matchNewsletter: (str: string) => boolean;
 export declare const matchNewsletterAttr: (value: string) => boolean;
 export declare const matchFullName: (value: string) => boolean;
@@ -55,4 +58,16 @@ export declare const matchZipCode: (str: string) => boolean;
 export declare const matchState: (str: string) => boolean;
 export declare const matchCountry: (value: string) => boolean;
 export declare const matchAddress: (value: string) => boolean;
+export declare const matchCCName: (str: string) => boolean;
+export declare const matchCCFirstName: (value: string) => boolean;
+export declare const matchCCLastName: (value: string) => boolean;
+export declare const matchCCNumber: (str: string) => boolean;
+export declare const matchCCSecurityCode: (value: string) => boolean;
+export declare const matchCCV: (str: string) => boolean;
+export declare const matchCCOutlier: (value: string) => boolean;
+export declare const matchCCExp: (value: string) => boolean;
+export declare const matchCCExpMonth: (value: string) => boolean;
+export declare const matchCCExpYear: (value: string) => boolean;
+export declare const matchPayment: (str: string) => boolean;
+export declare const matchIFrameField: (value: string) => boolean;
 export {};