@protontech/autofill 0.0.22991789

package/types/index.d.ts

@@ -0,0 +1,38 @@
+import { rule, ruleset } from "@protontech/fathom";
+export type AnyRule = ReturnType<typeof rule>;
+export type Ruleset = ReturnType<typeof ruleset>;
+export type BoundRuleset = ReturnType<Ruleset["against"]>;
+export type Coeff = [string, number];
+export type Bias = [string, number];
+export type RulesetAggregation = {
+    rules: AnyRule[];
+    coeffs: Coeff[];
+    biases: Bias[];
+};
+export type TrainingResults = {
+    coeffs: Coeff[];
+    bias: number;
+    cutoff: number;
+};
+export type Trainee = TrainingResults & {
+    name: string;
+    getRules: () => AnyRule[];
+};
+export declare enum FormType {
+    LOGIN = "login",
+    NOOP = "noop",
+    PASSWORD_CHANGE = "password-change",
+    RECOVERY = "recovery",
+    REGISTER = "register"
+}
+export declare enum FieldType {
+    EMAIL = "email",
+    IDENTITY = "identity",
+    OTP = "otp",
+    PASSWORD_CURRENT = "password",
+    PASSWORD_NEW = "new-password",
+    USERNAME = "username",
+    USERNAME_HIDDEN = "username-hidden"
+}
+export declare const formTypes: FormType[];
+export declare const fieldTypes: FieldType[];

package/types/index.js

@@ -0,0 +1,20 @@
+export var FormType;
+(function (FormType) {
+    FormType["LOGIN"] = "login";
+    FormType["NOOP"] = "noop";
+    FormType["PASSWORD_CHANGE"] = "password-change";
+    FormType["RECOVERY"] = "recovery";
+    FormType["REGISTER"] = "register";
+})(FormType || (FormType = {}));
+export var FieldType;
+(function (FieldType) {
+    FieldType["EMAIL"] = "email";
+    FieldType["IDENTITY"] = "identity";
+    FieldType["OTP"] = "otp";
+    FieldType["PASSWORD_CURRENT"] = "password";
+    FieldType["PASSWORD_NEW"] = "new-password";
+    FieldType["USERNAME"] = "username";
+    FieldType["USERNAME_HIDDEN"] = "username-hidden";
+})(FieldType || (FieldType = {}));
+export const formTypes = Object.values(FormType);
+export const fieldTypes = Object.values(FieldType);

package/utils/attributes.d.ts

@@ -0,0 +1,9 @@
+export declare const TEXT_ATTRIBUTES: string[];
+export declare const EL_ATTRIBUTES: string[];
+export declare const FORM_ATTRIBUTES: string[];
+export declare const FIELD_ATTRIBUTES: string[];
+export declare const getAttributes: (attributes: string[]) => (el: HTMLElement) => string[];
+export declare const getBaseAttributes: (el: HTMLElement) => string[];
+export declare const getTextAttributes: (el: HTMLElement) => string[];
+export declare const getFieldAttributes: (el: HTMLElement) => string[];
+export declare const getFormAttributes: (el: HTMLElement) => string[];

package/utils/attributes.js

@@ -0,0 +1,13 @@
+import { sanitizeStringWithSpaces } from "./text";
+export const TEXT_ATTRIBUTES = ["title", "label", "aria-label", "aria-labelledby", "aria-describedby", "placeholder", "autocomplete", "legend"];
+export const EL_ATTRIBUTES = ["id", "class", "role", "jsaction", "ng-controller", "data-bind", "ng-model", "v-model", "v-bind", "data-testid", "href"];
+export const FORM_ATTRIBUTES = [EL_ATTRIBUTES, "name", "action"].flat();
+export const FIELD_ATTRIBUTES = [EL_ATTRIBUTES, "name", "inputmode"].flat();
+export const getAttributes = (attributes) => (el) => attributes
+    .filter((key) => key !== "data-fathom")
+    .map((attr) => el.getAttribute(attr))
+    .filter(Boolean).map(sanitizeStringWithSpaces);
+export const getBaseAttributes = getAttributes(EL_ATTRIBUTES);
+export const getTextAttributes = getAttributes(TEXT_ATTRIBUTES);
+export const getFieldAttributes = getAttributes(FIELD_ATTRIBUTES);
+export const getFormAttributes = getAttributes(FORM_ATTRIBUTES);

package/utils/clustering.d.ts

@@ -0,0 +1 @@
+export declare const resolveFormClusters: (doc: Document) => HTMLElement[];

package/utils/clustering.js

@@ -0,0 +1,81 @@
+import { clusters as clustering } from "@protontech/fathom";
+import { buttonSelector, inputCandidateSelector, kButtonSubmitSelector, kDomGroupSelector, kFieldSelector } from "../constants/selectors";
+import { findStackedParents, getCommonAncestor, getRectMinDistance, pruneNested, uniqueNodes, walkUpWhile } from "./dom";
+import { isBtnCandidate } from "./field";
+import { isVisibleField } from "./visible";
+import { flagCluster, isClassifiable } from "./flags";
+import { selectFormCandidates } from "./form";
+const { clusters } = clustering;
+const CLUSTER_MAX_X_DIST = 50;
+const CLUSTER_MAX_Y_DIST = 275;
+const CLUSTER_ALIGNMENT_TOLERANCE = 0.05;
+const CLUSTER_MAX_ELEMENTS = 50;
+const context = { cache: new WeakMap() };
+const getElementData = (el) => {
+    var _a;
+    const data = (_a = context.cache.get(el)) !== null && _a !== void 0 ? _a : {
+        isField: el.matches(kFieldSelector) && el.matches(':not([type="submit"])'),
+        rect: el.getBoundingClientRect(),
+    };
+    context.cache.set(el, data);
+    return data;
+};
+const compare = (elA, elB) => {
+    const a = getElementData(elA);
+    const b = getElementData(elB);
+    const maxDx = CLUSTER_MAX_X_DIST;
+    const maxDy = CLUSTER_MAX_Y_DIST / (a.isField && b.isField ? 2 : 1);
+    const { dx, dy } = getRectMinDistance(a.rect, b.rect);
+    const leftRatio = Math.abs(a.rect.left / b.rect.left);
+    const topRatio = Math.abs(a.rect.top / b.rect.top);
+    const xAlign = leftRatio > 1 - CLUSTER_ALIGNMENT_TOLERANCE && leftRatio < 1 + CLUSTER_ALIGNMENT_TOLERANCE;
+    const yAlign = topRatio > 1 - CLUSTER_ALIGNMENT_TOLERANCE && topRatio < 1 + CLUSTER_ALIGNMENT_TOLERANCE;
+    if (xAlign && yAlign)
+        return true;
+    if (xAlign && dy < maxDy)
+        return true;
+    if (yAlign && dx < maxDx)
+        return true;
+    if (dx < maxDx && dy < maxDy)
+        return true;
+    return false;
+};
+const handleSingletonCluster = (cluster) => {
+    const node = cluster[0];
+    return walkUpWhile(node, 5)((_, candidate) => candidate === node || candidate.querySelectorAll(buttonSelector).length === 0);
+};
+export const resolveFormClusters = (doc) => {
+    const forms = selectFormCandidates(doc);
+    const clusterable = (els) => els.filter((el) => !forms.some((ex) => ex.contains(el)) && isVisibleField(el));
+    const fields = Array.from(doc.querySelectorAll(kFieldSelector));
+    const fieldsOfInterest = clusterable(fields.filter((el) => isClassifiable(el) && el.getAttribute("type") !== "hidden"));
+    const inputs = fieldsOfInterest.filter((field) => field.matches(inputCandidateSelector));
+    if (inputs.length === 0 || inputs.length > CLUSTER_MAX_ELEMENTS)
+        return [];
+    const domGroups = Array.from(doc.querySelectorAll(kDomGroupSelector)).filter((el) => el !== document.body);
+    const positionedEls = findStackedParents(inputs, 20);
+    const groups = pruneNested(domGroups.filter((el) => !positionedEls.some((stack) => el.contains(stack))).concat(positionedEls));
+    const buttons = clusterable(Array.from(document.querySelectorAll(kButtonSubmitSelector)).filter(isBtnCandidate));
+    const candidates = uniqueNodes(fieldsOfInterest, buttons);
+    if (candidates.length > CLUSTER_MAX_ELEMENTS)
+        return [];
+    const groupByInput = new WeakMap(candidates.map((el) => [el, groups.find((group) => group.contains(el))]));
+    const theClusters = clusters(candidates, 1, (a, b) => {
+        if (a.parentElement === b.parentElement)
+            return 0;
+        const groupA = groupByInput.get(a);
+        const groupB = groupByInput.get(b);
+        if (groupA !== groupB)
+            return Number.MAX_SAFE_INTEGER;
+        if (groupA && groupA === groupB)
+            return 0;
+        return compare(a, b) ? 0 : Number.MAX_SAFE_INTEGER;
+    });
+    const ancestors = theClusters
+        .map((cluster) => (cluster.length === 1 ? handleSingletonCluster(cluster) : cluster.reduce(getCommonAncestor)))
+        .filter((ancestor) => document.body !== ancestor && ancestor.querySelectorAll(inputCandidateSelector).length > 0);
+    const result = pruneNested(ancestors);
+    result.forEach(flagCluster);
+    context.cache = new WeakMap();
+    return result;
+};

package/utils/combinators.d.ts

@@ -0,0 +1,6 @@
+type Predicate<T> = (value: T) => boolean;
+export declare const and: <T>(...predicates: Predicate<T>[]) => Predicate<T>;
+export declare const or: <T>(...predicates: Predicate<T>[]) => Predicate<T>;
+export declare const not: <T>(predicate: Predicate<T>) => Predicate<T>;
+export declare const any: <T>(predicate: Predicate<T>) => (values: T[]) => boolean;
+export {};

package/utils/combinators.js

@@ -0,0 +1,4 @@
+export const and = (...predicates) => (value) => predicates.every((pred) => pred(value));
+export const or = (...predicates) => (value) => predicates.some((pred) => pred(value));
+export const not = (predicate) => (value) => !predicate(value);
+export const any = (predicate) => (values) => values.some(predicate);

package/utils/dom.d.ts

@@ -0,0 +1,25 @@
+export declare const closestParent: (start: HTMLElement, match: (el: HTMLElement) => boolean) => HTMLElement | null;
+export declare const closest: (start: HTMLElement, match: (parent: HTMLElement) => HTMLElement | null, maxIterations?: number) => HTMLElement | null;
+export declare const walkUpWhile: (start: HTMLElement, maxIterations: number) => (check: (parent: HTMLElement, candidate: HTMLElement) => boolean) => HTMLElement;
+export declare const getNthParent: (el: HTMLElement) => (n: number) => HTMLElement;
+export declare const uniqueNodes: (...nodes: HTMLElement[][]) => HTMLElement[];
+export declare const getNodeRect: (el: HTMLElement) => {
+    height: number;
+    width: number;
+    top: number;
+    bottom: number;
+    area: number;
+};
+export declare const getSiblingWith: (el: Element, match: (el: Element) => boolean) => Element | null;
+export declare const getLabelFor: (el: HTMLElement) => HTMLElement | null;
+export declare const getRectCenter: (rect: DOMRect) => {
+    x: number;
+    y: number;
+};
+export declare const getRectMinDistance: (rectA: DOMRect, rectB: DOMRect) => {
+    dx: number;
+    dy: number;
+};
+export declare const pruneNested: (els: HTMLElement[]) => HTMLElement[];
+export declare const getCommonAncestor: (elementA: HTMLElement, elementB: HTMLElement) => HTMLElement;
+export declare const findStackedParents: (els: HTMLElement[], maxIterations: number) => HTMLElement[];

package/utils/dom.js

@@ -0,0 +1,104 @@
+export const closestParent = (start, match) => {
+    const parent = start.parentElement;
+    if (!parent)
+        return null;
+    return match(parent) ? parent : closestParent(parent, match);
+};
+export const closest = (start, match, maxIterations = 1) => {
+    const parent = start === null || start === void 0 ? void 0 : start.parentElement;
+    if (!parent)
+        return null;
+    const result = match(parent);
+    return result || maxIterations <= 0 ? result : closest(parent, match, maxIterations - 1);
+};
+export const walkUpWhile = (start, maxIterations) => (check) => {
+    const parent = start.parentElement;
+    if (maxIterations <= 0 || parent === null)
+        return start;
+    return check(parent, start) ? walkUpWhile(parent, maxIterations - 1)(check) : start;
+};
+export const getNthParent = (el) => (n) => {
+    const parent = el.parentElement;
+    return parent === null || n === 0 ? el : getNthParent(parent)(n - 1);
+};
+export const uniqueNodes = (...nodes) => Array.from(new Set(nodes.flat()));
+export const getNodeRect = (el) => {
+    const { height, width, top, bottom } = el.getBoundingClientRect();
+    const area = height * width;
+    return { height, width, top, bottom, area };
+};
+export const getSiblingWith = (el, match) => {
+    const prevEl = el.previousElementSibling;
+    if (prevEl === null)
+        return null;
+    if (match(prevEl))
+        return prevEl;
+    return getSiblingWith(prevEl, match);
+};
+export const getLabelFor = (el) => {
+    var _a;
+    const forId = (_a = el.getAttribute("id")) !== null && _a !== void 0 ? _a : el.getAttribute("name");
+    const label = document.querySelector(`label[for="${forId}"]`);
+    if (label)
+        return label;
+    const parentLabel = el.closest("label");
+    if (parentLabel)
+        return parentLabel;
+    const closestLabel = closest(el, (parent) => parent.querySelector("label, [class*=\"label\"]"), 1);
+    if (closestLabel)
+        return closestLabel;
+    const textNodeAbove = getSiblingWith(el, (el) => el instanceof HTMLElement && el.innerText.trim().length > 0);
+    if (textNodeAbove)
+        return textNodeAbove;
+    return null;
+};
+export const getRectCenter = (rect) => ({
+    x: rect.left + rect.width / 2,
+    y: rect.top + rect.height / 2,
+});
+export const getRectMinDistance = (rectA, rectB) => {
+    const centerA = getRectCenter(rectA);
+    const centerB = getRectCenter(rectB);
+    const dx = Math.abs(centerA.x - centerB.x) - (rectA.width + rectB.width) / 2;
+    const dy = Math.abs(centerA.y - centerB.y) - (rectA.height + rectB.height) / 2;
+    return { dx, dy };
+};
+export const pruneNested = (els) => {
+    return els.reduce((acc, el) => {
+        for (let i = 0; i <= acc.length - 1; i++) {
+            if (acc[i] === el)
+                continue;
+            if (acc[i].contains(el))
+                return acc;
+            if (el.contains(acc[i])) {
+                acc[i] = el;
+                return acc;
+            }
+        }
+        acc.push(el);
+        return acc;
+    }, []);
+};
+export const getCommonAncestor = (elementA, elementB) => {
+    if (elementA === elementB)
+        return elementA;
+    return elementA.contains(elementB) ? elementA : elementA.parentElement ? getCommonAncestor(elementA.parentElement, elementB) : elementA;
+};
+const findStackedParent = (el, cache = [], maxIterations) => {
+    if (cache.some((group) => group.contains(el)))
+        return null;
+    const parent = el.parentElement;
+    if (maxIterations === 0 || !parent)
+        return null;
+    const computedStyle = getComputedStyle(parent);
+    const position = computedStyle.getPropertyValue("position");
+    if (position === "fixed" || position === "absolute") {
+        cache.push(parent);
+        return parent;
+    }
+    return findStackedParent(parent, cache, maxIterations - 1);
+};
+export const findStackedParents = (els, maxIterations) => {
+    const cache = [];
+    return els.map((input) => findStackedParent(input, cache, maxIterations)).filter((el) => Boolean(el));
+};

package/utils/exclusion.d.ts

@@ -0,0 +1,3 @@
+export declare const excludeForms: (doc?: Document) => void;
+export declare const excludeClusterableNodes: (doc?: Document) => void;
+export declare const excludeFields: (doc?: Document) => void;

package/utils/exclusion.js

@@ -0,0 +1,59 @@
+import { HIDDEN_FIELD_IGNORE_VALUES, MAX_FIELDS_PER_FORM, MAX_HIDDEN_FIELD_VALUE_LENGTH, MAX_INPUTS_PER_FORM, VALID_INPUT_TYPES, } from "../constants/heuristics";
+import { inputCandidateSelector, kEditorSelector, kFieldSelector, kHiddenUsernameSelector } from "../constants/selectors";
+import { getNodeRect } from "../utils/dom";
+import { flagAsIgnored, flagSubtreeAsIgnored, isClassifiable } from "../utils/flags";
+const TABLE_MAX_COLS = 3;
+const TABLE_MAX_AREA = 150000;
+const nodeOfInterest = (el) => isClassifiable(el) && el.querySelector("input") !== null;
+export const excludeForms = (doc = document) => {
+    const bodyElCount = document.body.querySelectorAll("*").length;
+    return doc.querySelectorAll("form").forEach((form) => {
+        if (nodeOfInterest(form)) {
+            const fieldCount = form.querySelectorAll(kFieldSelector).length;
+            const inputCount = form.querySelectorAll(inputCandidateSelector).length;
+            const invalidFieldCount = inputCount === 0 || inputCount > MAX_INPUTS_PER_FORM || fieldCount > MAX_FIELDS_PER_FORM;
+            const pageForm = form.matches("body > form");
+            const formElCount = form.querySelectorAll("*").length;
+            const invalidPageForm = pageForm && formElCount >= bodyElCount * 0.8;
+            const invalidCount = invalidFieldCount || invalidPageForm;
+            if (invalidCount && !pageForm)
+                return flagSubtreeAsIgnored(form);
+            if (invalidCount && pageForm)
+                return flagAsIgnored(form);
+            if (form.matches("table form") && form.closest("table").querySelectorAll("form").length > 2)
+                return flagAsIgnored(form);
+        }
+    });
+};
+export const excludeClusterableNodes = (doc = document) => {
+    doc.querySelectorAll("table").forEach((table) => {
+        if (nodeOfInterest(table) && !table.querySelector("table") && table.closest("form") === null) {
+            const nestedForms = table.querySelectorAll("form");
+            if (nestedForms.length > 2)
+                return flagSubtreeAsIgnored(table);
+            if (!nestedForms.length) {
+                if (table.querySelector("thead") !== null)
+                    return flagSubtreeAsIgnored(table);
+                const cellCount = Math.max(...Array.from(table.rows).map((row) => row.cells.length));
+                if (cellCount > TABLE_MAX_COLS || getNodeRect(table).area > TABLE_MAX_AREA)
+                    return flagSubtreeAsIgnored(table);
+            }
+        }
+    });
+    doc.querySelectorAll(kEditorSelector).forEach(flagSubtreeAsIgnored);
+};
+export const excludeFields = (doc = document) => {
+    doc.querySelectorAll("input").forEach((input) => {
+        if (!isClassifiable(input))
+            return;
+        const invalidType = !VALID_INPUT_TYPES.includes(input.type);
+        if (invalidType)
+            return flagAsIgnored(input);
+        if (input.type === "hidden") {
+            const value = input.value.trim();
+            const invalidValueLength = !value.length || value.length > MAX_HIDDEN_FIELD_VALUE_LENGTH;
+            if (invalidValueLength || HIDDEN_FIELD_IGNORE_VALUES.includes(value) || !input.matches(kHiddenUsernameSelector))
+                return flagAsIgnored(input);
+        }
+    });
+};

package/utils/extract.d.ts

@@ -0,0 +1,13 @@
+export declare const getPageDescriptionText: (doc: Document) => string;
+export declare const getNodeText: (node: HTMLElement) => string;
+export declare const getNodeAttributes: (node: HTMLElement) => string;
+export declare const getAllNodeHaystacks: (node: HTMLElement) => string[];
+export declare const getFormText: (form: HTMLElement) => string;
+export declare const getFieldLabelText: (field: HTMLElement) => string;
+export declare const getFieldHaystacks: (field: HTMLElement) => {
+    fieldAttrs: string[];
+    fieldText: string;
+    labelText: string;
+};
+export declare const getAllFieldHaystacks: (field: HTMLElement) => string[];
+export declare const getNearestHeadingsText: (el: HTMLElement) => string;

package/utils/extract.js

@@ -0,0 +1,59 @@
+import { getBaseAttributes, getFieldAttributes, getTextAttributes } from "./attributes";
+import { MAX_FORM_HEADING_WALK_UP, MAX_HEADING_HORIZONTAL_DIST, MAX_HEADING_VERTICAL_DIST } from "../constants/heuristics";
+import { kDomGroupSelector, kHeadingSelector } from "../constants/selectors";
+import { getLabelFor, getRectMinDistance, getSiblingWith, walkUpWhile } from "./dom";
+import { sanitizeString, sanitizeStringWithSpaces } from "./text";
+export const getPageDescriptionText = (doc) => {
+    var _a;
+    const pageTitle = doc.title;
+    const metaDescription = doc.querySelector('meta[name="description"]');
+    const descriptionContent = (_a = metaDescription === null || metaDescription === void 0 ? void 0 : metaDescription.getAttribute("content")) !== null && _a !== void 0 ? _a : "";
+    return sanitizeString(`${pageTitle} ${descriptionContent}`);
+};
+export const getNodeText = (node) => {
+    const textAttrs = getTextAttributes(node).join("");
+    return sanitizeString(`${node.innerText}${textAttrs}`);
+};
+export const getNodeAttributes = (node) => sanitizeStringWithSpaces(getBaseAttributes(node).join(""));
+export const getAllNodeHaystacks = (node) => [getNodeText(node), getNodeAttributes(node)];
+export const getFormText = (form) => {
+    const textAttrs = getTextAttributes(form).join("");
+    const fieldsets = Array.from(form.querySelectorAll("fieldset"));
+    return sanitizeString(`${textAttrs}${fieldsets.reduce((text, fieldset) => text.concat(getTextAttributes(fieldset).join("")), "")}`);
+};
+export const getFieldLabelText = (field) => {
+    const label = getLabelFor(field);
+    return label ? getNodeText(label) : "";
+};
+export const getFieldHaystacks = (field) => {
+    const isHiddenInput = field instanceof HTMLInputElement && field.type === "hidden";
+    const checkLabel = field instanceof HTMLInputElement && ["text", "email", "tel", "password"].includes(field.type);
+    const fieldAttrs = getFieldAttributes(field);
+    const fieldText = isHiddenInput ? "" : getNodeText(field);
+    const labelText = checkLabel && !isHiddenInput ? getFieldLabelText(field) : "";
+    return { fieldAttrs, fieldText, labelText };
+};
+export const getAllFieldHaystacks = (field) => {
+    const { fieldAttrs, fieldText, labelText } = getFieldHaystacks(field);
+    return [fieldText, labelText, ...fieldAttrs];
+};
+export const getNearestHeadingsText = (el) => {
+    var _a, _b;
+    const originRect = el.getBoundingClientRect();
+    const parent = walkUpWhile(el, MAX_FORM_HEADING_WALK_UP)((parentEl, candidate) => {
+        if (parentEl === document.body)
+            return false;
+        if (candidate.matches(kDomGroupSelector))
+            return false;
+        return true;
+    });
+    const headings = Array.from(parent.querySelectorAll(kHeadingSelector)).filter((heading) => {
+        if (el.contains(heading))
+            return true;
+        const headingRect = heading.getBoundingClientRect();
+        const { dx, dy } = getRectMinDistance(originRect, headingRect);
+        return dx < MAX_HEADING_HORIZONTAL_DIST && dy < MAX_HEADING_VERTICAL_DIST;
+    });
+    const textAbove = (_b = (_a = (headings.length === 0 ? getSiblingWith(el, (el) => el instanceof HTMLElement && el.innerText.trim().length > 0) : null)) === null || _a === void 0 ? void 0 : _a.innerText) !== null && _b !== void 0 ? _b : "";
+    return sanitizeString(textAbove + headings.map((el) => el.innerText).join(""));
+};

package/utils/fathom.d.ts

@@ -0,0 +1,38 @@
+import { Fnode } from "@protontech/fathom";
+import { FormFeatures } from "../features/abstract.form";
+import { EmailFieldFeatures } from "../features/field.email";
+import { OTPFieldFeatures } from "../features/field.otp";
+import { PasswordFieldFeatures } from "../features/field.password";
+import { UsernameFieldFeatures } from "../features/field.username";
+import { HiddenUserFieldFeatures } from "../features/field.username-hidden";
+type FeatureType = "form" | "password-field" | "username-field" | "username-hidden-field" | "email-field" | "otp-field";
+type FeatureKey<T extends FeatureType> = {
+    form: FormFeatures;
+    "password-field": PasswordFieldFeatures;
+    "username-field": UsernameFieldFeatures;
+    "username-hidden-field": HiddenUserFieldFeatures;
+    "email-field": EmailFieldFeatures;
+    "otp-field": OTPFieldFeatures;
+}[T];
+export declare const TOLERANCE_LEVEL = 0.5;
+export declare const boolInt: (val: boolean) => number;
+export declare const safeInt: (val: number, fallback?: number) => number;
+export declare const typeEffect: (type: string) => (fnode: Fnode) => Fnode;
+export declare const processFormEffect: (fnode: Fnode) => Fnode;
+export declare const processFieldEffect: (fnode: Fnode) => Fnode;
+export declare const featureScore: <T extends FeatureType, K = FeatureKey<T>>(noteFor: T, key: keyof K | (keyof K)[]) => any;
+export declare const getParentFormFnode: (fieldFnode: Fnode) => Fnode | null;
+export declare const typeScoreToleranceTest: (type: string) => (fnode: Fnode) => boolean;
+export declare const getTypeScore: (node: Fnode | null, type: string) => any;
+export declare const outRuleWithCache: (candidateType: string, predictionType: string, typeScoreTest?: (predictionType: string) => (fnode: Fnode) => boolean) => any[];
+export declare const combineFeatures: <T>(arr1: T[], arr2: T[]) => [T, T][];
+export declare const withFnodeEl: <T extends HTMLElement>(fn: (el: T) => any) => (fnode: Fnode) => any;
+export declare const getFormClassification: (formFnode: Fnode | null) => {
+    login: boolean;
+    register: boolean;
+    pwChange: boolean;
+    recovery: boolean;
+    noop: boolean;
+};
+export declare const isNoopForm: (formFnode: Fnode) => boolean;
+export {};

package/utils/fathom.js

@@ -0,0 +1,68 @@
+import { out, rule, score, type } from "@protontech/fathom";
+import { FormType } from "../types";
+import { flagAsProcessed, getCachedPredictionScore, getParentFormPrediction, isPredictedType, setCachedPredictionScore } from "./flags";
+export const TOLERANCE_LEVEL = 0.5;
+export const boolInt = (val) => Number(val);
+export const safeInt = (val, fallback = 0) => (Number.isFinite(val) ? val : fallback);
+const throughEffect = (effect) => (fnode) => {
+    effect(fnode);
+    return fnode;
+};
+export const typeEffect = (type) => throughEffect((fnode) => {
+    flagAsProcessed(fnode.element);
+    if (!fnode.hasNoteFor(`${type}-prediction`)) {
+        setCachedPredictionScore(fnode.element, type, getTypeScore(fnode, type));
+    }
+});
+export const processFormEffect = throughEffect((fnode) => flagAsProcessed(fnode.element));
+export const processFieldEffect = throughEffect((fnode) => {
+    const { visible, type } = fnode.noteFor("field");
+    if (visible || type === "hidden")
+        flagAsProcessed(fnode.element);
+});
+export const featureScore = (noteFor, key) => score((fnode) => {
+    const features = fnode.noteFor(noteFor);
+    if (Array.isArray(key))
+        return key.map((k) => features[k]).reduce((a, b) => a * b);
+    return features[key];
+});
+export const getParentFormFnode = (fieldFnode) => {
+    const field = fieldFnode.element;
+    const ruleset = fieldFnode._ruleset;
+    const parentForms = ruleset.get(type("form"));
+    const form = parentForms.find(({ element }) => element.contains(field));
+    if (form)
+        return form;
+    const preDetectedForm = getParentFormPrediction(field);
+    if (preDetectedForm)
+        return ruleset.get(preDetectedForm);
+    return null;
+};
+export const typeScoreToleranceTest = (type) => (fnode) => fnode.scoreFor(type) > TOLERANCE_LEVEL;
+export const getTypeScore = (node, type) => {
+    var _a;
+    if (!node)
+        return 0;
+    if (node.hasNoteFor(`${type}-prediction`))
+        return (_a = node.noteFor(`${type}-prediction`)) !== null && _a !== void 0 ? _a : 0;
+    return node.scoreFor(type);
+};
+export const outRuleWithCache = (candidateType, predictionType, typeScoreTest = typeScoreToleranceTest) => [
+    rule(type(candidateType).when(isPredictedType(predictionType)), type(`${predictionType}-prediction`).note(getCachedPredictionScore(predictionType)), {}),
+    rule(type(predictionType).when(typeScoreTest(predictionType)), type(`${predictionType}-prediction`), {}),
+    rule(type(`${predictionType}-prediction`), out(predictionType).through(typeEffect(predictionType)), {}),
+];
+export const combineFeatures = (arr1, arr2) => {
+    return arr1.flatMap((item1) => arr2.map((item2) => [item1, item2]));
+};
+export const withFnodeEl = (fn) => (fnode) => fn(fnode.element);
+export const getFormClassification = (formFnode) => {
+    const login = getTypeScore(formFnode, FormType.LOGIN) > 0.5;
+    const register = getTypeScore(formFnode, FormType.REGISTER) > 0.5;
+    const pwChange = getTypeScore(formFnode, FormType.PASSWORD_CHANGE) > 0.5;
+    const recovery = getTypeScore(formFnode, FormType.RECOVERY) > 0.5;
+    const detectionResults = [login, register, pwChange, recovery];
+    const noop = detectionResults.every((detected) => !detected);
+    return { login, register, pwChange, recovery, noop };
+};
+export const isNoopForm = (formFnode) => getFormClassification(formFnode).noop;

package/utils/field.d.ts

@@ -0,0 +1,14 @@
+import { Fnode } from "@protontech/fathom";
+export declare const splitFieldsByVisibility: (els: HTMLElement[]) => [HTMLElement[], HTMLElement[]];
+export declare const maybeEmail: (value: Fnode) => boolean;
+export declare const maybePassword: (value: Fnode) => boolean;
+export declare const maybeOTP: (value: Fnode) => boolean;
+export declare const maybeUsername: (value: Fnode) => boolean;
+export declare const maybeHiddenUsername: (value: Fnode) => boolean;
+export declare const isUsernameCandidate: (el: HTMLElement) => boolean;
+export declare const isEmailCandidate: (el: HTMLElement) => boolean;
+export declare const isOAuthCandidate: (el: HTMLElement) => boolean;
+export declare const isBtnCandidate: (btn: HTMLElement) => boolean;
+export declare const isProcessableField: (input: HTMLInputElement) => boolean;
+export declare const isClassifiableField: (fnode: Fnode) => boolean;
+export declare const selectInputCandidates: (target?: Document | HTMLElement) => HTMLInputElement[];

package/utils/field.js

@@ -0,0 +1,50 @@
+import { MIN_AREA_SUBMIT_BTN } from "../constants/heuristics";
+import { inputCandidateSelector, kPasswordSelector, kUsernameSelector, otpSelector } from "../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";
+const isActiveFieldFNode = (fnode) => {
+    const { visible, readonly, disabled } = fnode.noteFor("field");
+    return visible && !readonly && !disabled;
+};
+export const splitFieldsByVisibility = (els) => {
+    return els.reduce((acc, el) => {
+        if (isVisibleField(el))
+            acc[0].push(el);
+        else
+            acc[1].push(el);
+        return acc;
+    }, [[], []]);
+};
+const fType = (types) => (fnode) => types.includes(fnode.element.type);
+const fMatch = (selector) => (fnode) => fnode.element.matches(selector);
+const fInputMode = (inputMode) => (fnode) => fnode.element.inputMode === inputMode;
+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 isOAuthCandidate = (el) => any(matchOAuth)(getAllFieldHaystacks(el));
+export const isBtnCandidate = (btn) => {
+    if (btn.getAttribute("type") === "submit")
+        return true;
+    if (btn.innerText.trim().length <= 1)
+        return false;
+    const height = btn.offsetHeight;
+    const width = btn.offsetWidth;
+    return height * width > MIN_AREA_SUBMIT_BTN;
+};
+export const isProcessableField = (input) => {
+    const processed = isProcessed(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 selectInputCandidates = (target = document) => Array.from(target.querySelectorAll(inputCandidateSelector)).filter(isClassifiable);