@protontech/autofill 0.0.22991789

package/utils/flags.d.ts

@@ -0,0 +1,25 @@
+import { 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;
+export declare const flagAsHidden: (el: HTMLElement) => boolean;
+export declare const removeHiddenFlag: (el: HTMLElement) => boolean;
+export declare const attrIgnored: (el: HTMLElement) => boolean;
+export declare const isIgnored: (el: HTMLElement) => boolean;
+export declare const getIgnoredParent: (el?: HTMLElement) => HTMLElement | null;
+export declare const flagAsIgnored: (el: HTMLElement) => boolean;
+export declare const removeIgnoredFlag: (el: HTMLElement) => boolean;
+export declare const flagSubtreeAsIgnored: (el: HTMLElement) => void;
+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 getParentFormPrediction: (el?: HTMLElement) => HTMLElement | null;
+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 isClassifiable: (el: HTMLElement) => boolean;
+export declare const removeClassifierFlags: (el: HTMLElement, options: {
+    preserveIgnored: boolean;
+}) => void;

package/utils/flags.js

@@ -0,0 +1,60 @@
+import { FORM_CLUSTER_ATTR, kFieldSelector } from "../constants/selectors";
+import { closestParent } from "./dom";
+export const isCluster = (el) => el.getAttribute(FORM_CLUSTER_ATTR) !== null;
+export const flagCluster = (el) => el.setAttribute(FORM_CLUSTER_ATTR, "");
+export const isHidden = (el) => el.__PP_HIDDEN__ === true;
+export const flagAsHidden = (el) => (el.__PP_HIDDEN__ = true);
+export const removeHiddenFlag = (el) => delete el.__PP_HIDDEN__;
+export const attrIgnored = (el) => el.getAttribute("data-protonpass-ignore") !== null;
+export const isIgnored = (el) => el.__PP_SKIP__ === true;
+export const getIgnoredParent = (el) => (el ? closestParent(el, isIgnored) : null);
+export const flagAsIgnored = (el) => (el.__PP_SKIP__ = true);
+export const removeIgnoredFlag = (el) => delete el.__PP_SKIP__;
+export const flagSubtreeAsIgnored = (el) => {
+    flagAsIgnored(el);
+    el.querySelectorAll(kFieldSelector).forEach(flagAsIgnored);
+};
+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 getParentFormPrediction = (el) => (el ? closestParent(el, isPrediction) : null);
+const TYPE_SEPARATOR = ",";
+const SCORE_SEPARATOR = ":";
+export const setCachedPredictionScore = (_el, type, score) => {
+    const el = _el;
+    const currentType = el.__PP_TYPE__;
+    const flag = `${type}${SCORE_SEPARATOR}${score.toFixed(2)}`;
+    if (!currentType) {
+        el.__PP_TYPE__ = flag;
+        return;
+    }
+    const types = currentType.split(TYPE_SEPARATOR);
+    const existingIndex = types.findIndex((pred) => pred.startsWith(type));
+    if (existingIndex !== -1)
+        types[existingIndex] = flag;
+    else
+        types.push(flag);
+    el.__PP_TYPE__ = types.join(TYPE_SEPARATOR);
+};
+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));
+    if (!predForType)
+        return -1;
+    const [, scoreStr] = predForType.split(SCORE_SEPARATOR);
+    const score = parseFloat(scoreStr);
+    return Number.isFinite(score) ? score : -1;
+};
+export const isPredictedType = (type) => (fnode) => getCachedPredictionScore(type)(fnode) !== -1;
+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));
+};

package/utils/form.d.ts

@@ -0,0 +1,7 @@
+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 declare const selectFormCandidates: (root?: Document | HTMLElement) => HTMLElement[];

package/utils/form.js

@@ -0,0 +1,25 @@
+import { MAX_FORM_FIELD_WALK_UP } from "../constants/heuristics";
+import { formCandidateSelector, inputCandidateSelector } from "../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;
+        },
+    };
+};
+export const selectFormCandidates = (root = document) => {
+    const candidates = Array.from(root.querySelectorAll(formCandidateSelector));
+    return candidates.filter((form) => !isIgnored(form) && !attrIgnored(form));
+};

package/utils/identity.d.ts

@@ -0,0 +1,24 @@
+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;
+    searchField: boolean;
+    type: string | null;
+    visible: boolean;
+}) => boolean;

package/utils/identity.js

@@ -0,0 +1,63 @@
+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 IDENTITY_ATTRIBUTES = ["autocomplete", "name", "id", "data-bhw"];
+const IDENTITY_INPUT_TYPES = ["tel", "phone", "text", "number"];
+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;
+    const haystack = getIdentityHaystack(input);
+    if (haystack)
+        return (_a = IDENTITY_RE_MAP.find(([, test]) => test(haystack))) === null || _a === void 0 ? void 0 : _a[0];
+};
+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 matchesIdentityField = (input, options) => {
+    const { visible, isFormLogin, type, searchField } = options;
+    if ((type && !IDENTITY_INPUT_TYPES.includes(type)) || !visible || isFormLogin)
+        return false;
+    const identityType = getIdentityFieldType(input);
+    if (!identityType)
+        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 true;
+};

package/utils/memoize.d.ts

@@ -0,0 +1,5 @@
+type Memoised<F extends (arg: any) => any> = F & {
+    clearCache: () => void;
+};
+export declare const memoize: <F extends (arg: any) => any>(fn: F) => Memoised<F>;
+export {};

package/utils/memoize.js

@@ -0,0 +1,12 @@
+export const memoize = (fn) => {
+    let cache = new WeakMap();
+    const memoisedFn = ((arg) => {
+        if (cache.has(arg))
+            return cache.get(arg);
+        const result = fn(arg);
+        cache.set(arg, result);
+        return result;
+    });
+    memoisedFn.clearCache = () => (cache = new WeakMap());
+    return memoisedFn;
+};

package/utils/prepass.d.ts

@@ -0,0 +1,2 @@
+export declare const prepass: (doc?: Document) => void;
+export declare const shouldRunClassifier: () => boolean;

package/utils/prepass.js

@@ -0,0 +1,31 @@
+import { resolveFormClusters } from "./clustering";
+import { excludeClusterableNodes, excludeFields, excludeForms } from "./exclusion";
+import { isProcessableField, selectInputCandidates } from "./field";
+import { isProcessed, removeClassifierFlags, removeHiddenFlag } from "./flags";
+import { selectFormCandidates } from "./form";
+import { isVisibleForm } from "./visible";
+export const prepass = (doc = document) => {
+    excludeForms(doc);
+    excludeClusterableNodes(doc);
+    excludeFields(doc);
+    resolveFormClusters(doc);
+};
+export const shouldRunClassifier = () => {
+    const runForForms = selectFormCandidates().reduce((runDetection, form) => {
+        if (isProcessed(form)) {
+            const unprocessedFields = selectInputCandidates(form).some(isProcessableField);
+            if (unprocessedFields)
+                removeClassifierFlags(form, { preserveIgnored: false });
+            return runDetection || unprocessedFields;
+        }
+        if (isVisibleForm(form)) {
+            removeHiddenFlag(form);
+            return true;
+        }
+        return runDetection;
+    }, false);
+    if (runForForms)
+        return true;
+    const runForFields = selectInputCandidates().some(isProcessableField);
+    return runForFields;
+};

package/utils/re.d.ts

@@ -0,0 +1,58 @@
+export type ReTest = (str: string) => boolean;
+type ReSanityOptions = {
+    maxLength?: number;
+    minLength?: number;
+};
+export declare const reSanityCheck: (cb: (str: string) => boolean, options: ReSanityOptions) => (str: string) => boolean;
+export declare const test: (re: RegExp, options?: ReSanityOptions) => (str: string) => boolean;
+export declare const matchLogin: (str: string) => boolean;
+export declare const matchRegister: (str: string) => boolean;
+export declare const matchUsername: (str: string) => boolean;
+export declare const matchUsernameAttr: (value: string) => boolean;
+export declare const matchUsernameValue: (str: string) => boolean;
+export declare const matchUsernameOutlier: (str: string) => boolean;
+export declare const matchEmailAttr: (value: string) => boolean;
+export declare const matchEmailValue: (str: string) => boolean;
+export declare const matchEmail: (value: string) => boolean;
+export declare const matchTel: (str: string) => boolean;
+export declare const matchTelValue: (str: string) => boolean;
+export declare const matchRememberMe: (str: string) => boolean;
+export declare const matchTOS: (str: string) => boolean;
+export declare const matchTrouble: (str: string) => boolean;
+export declare const matchRecovery: (value: string) => boolean;
+export declare const matchMultiStep: (str: string) => boolean;
+export declare const matchStepAction: (value: string) => boolean;
+export declare const matchCreateAction: (str: string) => boolean;
+export declare const matchConfirmAction: (str: string) => boolean;
+export declare const matchOAuth: (str: string) => boolean;
+export declare const matchCaptcha: (str: string) => boolean;
+export declare const matchSearchAction: (str: string) => boolean;
+export declare const matchPasswordReset: (value: string) => boolean;
+export declare const matchPasswordResetAttr: (value: string) => boolean;
+export declare const matchPasswordCreate: (value: string) => boolean;
+export declare const matchPasswordCreateAttr: (value: string) => boolean;
+export declare const matchPasswordConfirm: (value: string) => boolean;
+export declare const matchPasswordConfirmAttr: (value: string) => boolean;
+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 matchOtpAttr: (str: string) => boolean;
+export declare const matchOtpOutlier: (value: string) => boolean;
+export declare const matchNewsletter: (str: string) => boolean;
+export declare const matchNewsletterAttr: (value: string) => boolean;
+export declare const matchFullName: (value: string) => boolean;
+export declare const matchFirstName: (str: string) => boolean;
+export declare const matchMiddleName: (str: string) => boolean;
+export declare const matchLastName: (str: string) => boolean;
+export declare const matchTelephone: (value: string) => boolean;
+export declare const matchOrganization: (str: string) => boolean;
+export declare const matchCity: (str: string) => boolean;
+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 {};

package/utils/re.js

@@ -0,0 +1,64 @@
+import { CAPTCHA_ATTR_RE, CONFIRM_ACTION_ATTR_END_RE, CONFIRM_ACTION_RE, CREATE_ACTION_ATTR_END_RE, CREATE_ACTION_RE, CURRENT_VALUE_RE, EMAIL_ATTR_RE, EMAIL_RE, HIDDEN_ATTR_RE, IDENTITY_ADDRESS_ATTR_RE, IDENTITY_ADDRESS_LINES_ATTR_END_RE, IDENTITY_CITY_ATTR_RE, IDENTITY_COUNTRY_ATTR_RE, IDENTITY_COUNTRY_CODE_ATTR_RE, IDENTITY_FIRSTNAME_ATTR_RE, IDENTITY_FULLNAME_ATTR_RE, IDENTITY_LASTNAME_ATTR_RE, IDENTITY_MIDDLENAME_ATTR_RE, IDENTITY_ORGANIZATION_ATTR_RE, IDENTITY_STATE_ATTR_RE, IDENTITY_TELEPHONE_ATTR_RE, IDENTITY_TELEPHONE_PREFIX_ATTR_RE, IDENTITY_ZIPCODE_ATTR_RE, LOGIN_RE, MFA_ACTION_RE, MFA_ATTR_RE, MFA_RE, MULTI_STEP_RE, NEWSLETTER_ATTR_RE, NEWSLETTER_RE, OAUTH_ATTR_RE, OTP_ATTR_RE, OTP_OUTLIER_ATTR_RE, OTP_OUTLIER_RE, PASSWORD_OUTLIER_RE, PASSWORD_RE, RECOVERY_RE, REGISTER_RE, REMEMBER_ACTION_RE, RESET_ACTION_RE, SEARCH_ACTION_RE, STEP_ACTION_RE, TEL_RE, TOS_RE, TROUBLE_RE, USERNAME_ATTR_RE, USERNAME_OUTLIER_RE, USERNAME_RE, } from "../dictionary/generated/dictionary";
+import { EMAIL_VALUE_RE, TEL_VALUE_RE, USERNAME_VALUE_RE } from "../dictionary/source/patterns";
+import { and, or } from "./combinators";
+export const reSanityCheck = (cb, options) => (str) => {
+    if (options.maxLength && str.length > options.maxLength)
+        return false;
+    if (options.minLength && str.length < options.minLength)
+        return false;
+    return cb(str);
+};
+export const test = (re, options) => reSanityCheck((str) => re.test(str), options !== null && options !== void 0 ? options : { maxLength: 5000, minLength: 2 });
+const notRe = (reg, options) => (str) => !test(reg, options)(str);
+const andRe = (reg, options) => and(...reg.map((re) => test(re, options)));
+const orRe = (reg, options) => or(...reg.map((re) => test(re, options)));
+export const matchLogin = test(LOGIN_RE);
+export const matchRegister = test(REGISTER_RE);
+export const matchUsername = test(USERNAME_RE);
+export const matchUsernameAttr = orRe([USERNAME_ATTR_RE, USERNAME_RE]);
+export const matchUsernameValue = test(USERNAME_VALUE_RE);
+export const matchUsernameOutlier = test(USERNAME_OUTLIER_RE);
+export const matchEmailAttr = orRe([EMAIL_ATTR_RE, EMAIL_RE]);
+export const matchEmailValue = test(EMAIL_VALUE_RE, { maxLength: 230, minLength: 5 });
+export const matchEmail = or(test(EMAIL_RE), matchEmailValue);
+export const matchTel = test(TEL_RE);
+export const matchTelValue = test(TEL_VALUE_RE, { maxLength: 25, minLength: 6 });
+export const matchRememberMe = test(REMEMBER_ACTION_RE);
+export const matchTOS = test(TOS_RE);
+export const matchTrouble = test(TROUBLE_RE);
+export const matchRecovery = orRe([RECOVERY_RE, TROUBLE_RE]);
+export const matchMultiStep = test(MULTI_STEP_RE);
+export const matchStepAction = orRe([STEP_ACTION_RE, MULTI_STEP_RE]);
+export const matchCreateAction = test(CREATE_ACTION_RE);
+export const matchConfirmAction = test(CONFIRM_ACTION_RE);
+export const matchOAuth = test(OAUTH_ATTR_RE);
+export const matchCaptcha = test(CAPTCHA_ATTR_RE);
+export const matchSearchAction = test(SEARCH_ACTION_RE);
+export const matchPasswordReset = and(andRe([PASSWORD_RE, RESET_ACTION_RE]), notRe(CONFIRM_ACTION_RE));
+export const matchPasswordResetAttr = and(matchPasswordReset, notRe(CONFIRM_ACTION_ATTR_END_RE));
+export const matchPasswordCreate = and(andRe([PASSWORD_RE, CREATE_ACTION_RE]), notRe(CONFIRM_ACTION_RE));
+export const matchPasswordCreateAttr = and(matchPasswordCreate, notRe(CONFIRM_ACTION_ATTR_END_RE));
+export const matchPasswordConfirm = andRe([PASSWORD_RE, CONFIRM_ACTION_RE]);
+export const matchPasswordConfirmAttr = and(andRe([PASSWORD_RE, CONFIRM_ACTION_RE]), notRe(CREATE_ACTION_ATTR_END_RE));
+export const matchPasswordCurrent = and(andRe([PASSWORD_RE, CURRENT_VALUE_RE]), notRe(CONFIRM_ACTION_RE));
+export const matchPasswordCurrentAttr = and(matchPasswordCurrent, notRe(CONFIRM_ACTION_ATTR_END_RE));
+export const matchPasswordOutlier = test(PASSWORD_OUTLIER_RE);
+export const matchHidden = test(HIDDEN_ATTR_RE);
+export const matchMfaAction = test(MFA_ACTION_RE);
+export const matchMfa = test(MFA_RE);
+export const matchMfaAttr = test(MFA_ATTR_RE);
+export const matchOtpAttr = test(OTP_ATTR_RE);
+export const matchOtpOutlier = orRe([OTP_OUTLIER_ATTR_RE, OTP_OUTLIER_RE]);
+export const matchNewsletter = test(NEWSLETTER_RE);
+export const matchNewsletterAttr = orRe([NEWSLETTER_RE, NEWSLETTER_ATTR_RE]);
+export const matchFullName = and(test(IDENTITY_FULLNAME_ATTR_RE), (str) => !str.includes("[name]"));
+export const matchFirstName = test(IDENTITY_FIRSTNAME_ATTR_RE);
+export const matchMiddleName = test(IDENTITY_MIDDLENAME_ATTR_RE);
+export const matchLastName = test(IDENTITY_LASTNAME_ATTR_RE);
+export const matchTelephone = and(test(IDENTITY_TELEPHONE_ATTR_RE), notRe(IDENTITY_TELEPHONE_PREFIX_ATTR_RE));
+export const matchOrganization = test(IDENTITY_ORGANIZATION_ATTR_RE);
+export const matchCity = test(IDENTITY_CITY_ATTR_RE);
+export const matchZipCode = test(IDENTITY_ZIPCODE_ATTR_RE);
+export const matchState = test(IDENTITY_STATE_ATTR_RE);
+export const matchCountry = and(test(IDENTITY_COUNTRY_ATTR_RE), notRe(IDENTITY_COUNTRY_CODE_ATTR_RE));
+export const matchAddress = and(test(IDENTITY_ADDRESS_ATTR_RE), notRe(IDENTITY_ADDRESS_LINES_ATTR_END_RE));

package/utils/text.d.ts

@@ -0,0 +1,3 @@
+export declare const normalizeString: (str: string, allowedChars?: string) => string;
+export declare const sanitizeString: (str: string) => string;
+export declare const sanitizeStringWithSpaces: (str: string) => string;

package/utils/text.js

@@ -0,0 +1,8 @@
+export const normalizeString = (str, allowedChars = "") => str
+    .trim()
+    .toLowerCase()
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .replace(new RegExp(`[^a-zA-Z0-9${allowedChars}]`, "g"), "");
+export const sanitizeString = (str) => normalizeString(str, "\\[\\]");
+export const sanitizeStringWithSpaces = (str) => normalizeString(str, "\\s\\[\\]");

package/utils/visible.d.ts

@@ -0,0 +1,13 @@
+import { Fnode } from "@protontech/fathom";
+type VisibilityCache = WeakMap<HTMLElement, boolean>;
+type IsVisibleOptions = {
+    opacity: boolean;
+};
+export declare const cacheContext: Record<string, VisibilityCache>;
+export declare const getVisibilityCache: (key: string) => VisibilityCache;
+export declare const clearVisibilityCache: () => void;
+export declare const isVisible: (fnodeOrElement: Fnode | HTMLElement, options: IsVisibleOptions) => boolean;
+export declare const isVisibleEl: (el: HTMLElement) => boolean;
+export declare const isVisibleForm: (form: HTMLElement) => boolean;
+export declare const isVisibleField: (field: HTMLElement) => boolean;
+export {};

package/utils/visible.js

@@ -0,0 +1,143 @@
+import { utils } from "@protontech/fathom";
+import { MIN_FIELD_HEIGHT, MIN_FIELD_WIDTH } from "../constants/heuristics";
+import { inputCandidateSelector } from "../constants/selectors";
+import { any } from "./combinators";
+import { flagAsHidden } from "./flags";
+import { matchHidden } from "./re";
+import { sanitizeStringWithSpaces } from "./text";
+export const cacheContext = {};
+export const getVisibilityCache = (key) => { var _a; return (cacheContext[key] = (_a = cacheContext[key]) !== null && _a !== void 0 ? _a : new WeakMap()); };
+export const clearVisibilityCache = () => Object.keys(cacheContext).forEach((key) => delete cacheContext[key]);
+const SCROLLBAR_WIDTH = 16;
+const getCachedVisbility = (el, options) => {
+    var _a;
+    const opacityCache = getVisibilityCache("visibility:op");
+    const cache = getVisibilityCache("visibility");
+    if (options.opacity)
+        return (_a = opacityCache.get(el)) !== null && _a !== void 0 ? _a : cache.get(el);
+    else
+        return cache.get(el);
+};
+const setCachedVisibility = (cacheMap) => (els, visible) => els.forEach((el) => cacheMap.set(el, visible));
+const containedInAncestor = (rect, ancestorRect) => rect.top <= ancestorRect.bottom && rect.bottom >= ancestorRect.top && rect.left <= ancestorRect.right && rect.right >= ancestorRect.left;
+const isNegligibleRect = (rect) => rect.width <= 1 || rect.height <= 1;
+export const isVisible = (fnodeOrElement, options) => {
+    const element = utils.toDomElement(fnodeOrElement);
+    const seen = [];
+    let transparent = false;
+    const cache = getVisibilityCache(options.opacity ? "visibility:op" : "visibility");
+    const cachedVisibility = getCachedVisbility(element, options);
+    if (cachedVisibility !== undefined)
+        return cachedVisibility;
+    const win = utils.windowForElement(element);
+    const doc = win.document;
+    const viewportWidth = win.innerWidth || doc.documentElement.clientWidth;
+    const viewportHeight = win.innerHeight || doc.documentElement.clientHeight;
+    const scrollWidth = Math.max(viewportWidth, doc.documentElement.scrollWidth, doc.body.scrollWidth);
+    const scrollHeight = Math.max(viewportHeight, doc.documentElement.scrollHeight, doc.body.scrollHeight);
+    const { scrollX, scrollY } = win;
+    const isOnScreen = ({ x, y, width, height }) => {
+        const left = x + scrollX;
+        const right = x + scrollX + width;
+        const top = y + scrollY;
+        const bottom = y + scrollY + height;
+        return right >= 0 && left <= scrollWidth - SCROLLBAR_WIDTH && bottom >= 0 && top <= scrollHeight - SCROLLBAR_WIDTH;
+    };
+    const check = () => {
+        var _a;
+        let prevRef = null;
+        for (const ancestor of utils.ancestors(element)) {
+            let rect = null;
+            const getRect = () => (rect = rect !== null && rect !== void 0 ? rect : ancestor.getBoundingClientRect());
+            if (ancestor === doc.body)
+                return (prevRef === null || prevRef === void 0 ? void 0 : prevRef.absolute) ? isOnScreen(prevRef.rect) : true;
+            const cachedVisibility = getCachedVisbility(ancestor, options);
+            if (cachedVisibility !== undefined)
+                return cachedVisibility;
+            const { opacity, display, position, overflow, visibility } = win.getComputedStyle(ancestor);
+            seen.push(ancestor);
+            if (opacity === "0" && options.opacity) {
+                transparent = true;
+                return false;
+            }
+            if (visibility === "hidden")
+                return false;
+            if (overflow === "hidden") {
+                if ((prevRef === null || prevRef === void 0 ? void 0 : prevRef.rect) && !containedInAncestor(prevRef.rect, getRect()))
+                    return false;
+                if (isNegligibleRect(getRect()))
+                    return false;
+            }
+            if ((prevRef === null || prevRef === void 0 ? void 0 : prevRef.absolute) && position === "static") {
+                seen.pop();
+                continue;
+            }
+            if (position === "absolute" && !isOnScreen(getRect()))
+                return false;
+            if (position === "fixed")
+                return isOnScreen((_a = prevRef === null || prevRef === void 0 ? void 0 : prevRef.rect) !== null && _a !== void 0 ? _a : getRect());
+            if (display === "contents") {
+                prevRef = null;
+                continue;
+            }
+            prevRef = prevRef !== null && prevRef !== void 0 ? prevRef : { rect: getRect() };
+            prevRef.rect = getRect();
+            prevRef.absolute = position === "absolute";
+            continue;
+        }
+        return true;
+    };
+    const visible = check();
+    if (options.opacity) {
+        if (visible || !transparent)
+            setCachedVisibility(getVisibilityCache("visibility"))(seen, visible);
+        else
+            setCachedVisibility(getVisibilityCache("visibility"))(seen.slice(0, -1), visible);
+    }
+    setCachedVisibility(cache)(seen, visible);
+    return visible;
+};
+const quickVisibilityCheck = (el, options) => {
+    const cache = getVisibilityCache(`${options.minWidth}:${options.minHeight}`);
+    if (cache.has(el))
+        return cache.get(el);
+    const check = () => {
+        const rect = el.getClientRects();
+        if (rect.length === 0)
+            return false;
+        const classList = Array.from(el.classList).map(sanitizeStringWithSpaces);
+        if (any(matchHidden)(classList))
+            return false;
+        const { visibility, display, maxHeight } = getComputedStyle(el);
+        if (visibility === "hidden" || display === "none" || maxHeight === "0px")
+            return false;
+        if (el.offsetHeight === 0 || el.offsetWidth === 0)
+            return false;
+        if (el.offsetHeight < options.minHeight || el.offsetWidth < options.minWidth)
+            return false;
+        return true;
+    };
+    const visible = check();
+    setCachedVisibility(cache)([el], visible);
+    return visible;
+};
+export const isVisibleEl = (el) => quickVisibilityCheck(el, { minHeight: 0, minWidth: 0 });
+export const isVisibleForm = (form) => {
+    const visible = (() => {
+        if (!isVisible(form, { opacity: true }))
+            return false;
+        const inputs = Array.from(form.querySelectorAll(inputCandidateSelector)).filter((field) => !field.disabled);
+        return inputs.length > 0 && inputs.some((input) => isVisible(input, { opacity: false }));
+    })();
+    if (!visible)
+        flagAsHidden(form);
+    return visible;
+};
+export const isVisibleField = (field) => {
+    if (field instanceof HTMLInputElement) {
+        const { type, disabled, readOnly } = field;
+        if (type === "hidden" || disabled || readOnly || field.getAttribute("aria-hidden") === "true")
+            return false;
+    }
+    return quickVisibilityCheck(field, { minHeight: MIN_FIELD_HEIGHT, minWidth: MIN_FIELD_WIDTH });
+};