@protontech/autofill 0.0.22991789 → 0.0.33835493

package/package.json

@@ -1,29 +1,31 @@
 {
   "name": "@protontech/autofill",
-  "version": "0.0.22991789",
+  "version": "0.0.33835493",
   "private": false,
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
   "dependencies": {
-    "@protontech/fathom": "0.0.22991789",
-    "@types/node": "^22.13.4",
-    "@types/regexgen": "^1.3.3",
-    "commander": "^13.1.0",
-    "prettier": "^3.5.1",
-    "regexgen": "^1.3.0"
+    "@protontech/fathom": "0.0.33835493",
+    "@protontech/ml-inference": "0.0.33835493"
   },
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^28.0.2",
-    "@rollup/plugin-node-resolve": "^16.0.0",
-    "@rollup/plugin-terser": "^0.4.4",
-    "@rollup/plugin-typescript": "^12.1.2",
     "@types/jest": "^29.5.14",
-    "jest": "^29.7.0",
-    "rollup": "^4.34.6",
-    "rollup-plugin-dts": "^6.0.2",
+    "@types/node": "^22.13.4",
+    "@types/regexgen": "^1.3.3",
+    "jest-cli": "^30.2.0",
+    "jest-environment-jsdom": "^30.2.0",
+    "jest-junit": "^16.0.0",
+    "prettier": "^3.5.1",
+    "regexgen": "^1.3.0",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
     "tslib": "^2.8.1"
   },
   "license": "MPL-2.0",
   "author": "Edvin Candon <edvin.candon@proton.ch>",
   "contributors": [
     "Guðmundur Heimisson <gudmundur.heimisson@proton.ch>"
-  ]
+  ],
+  "type": "module"
 }

package/rules/v1/index.d.ts

@@ -0,0 +1,4 @@
+import type { FeatureProvider } from "@protontech/autofill/features/v1";
+import type { AnyRule, DetectionClass } from "@protontech/autofill/types";
+export declare const getBaseRules: (featureProvider: FeatureProvider) => readonly [import("@protontech/fathom").OutwardRule | import("@protontech/fathom").InwardRule, import("@protontech/fathom").OutwardRule | import("@protontech/fathom").InwardRule, ...(import("@protontech/fathom").OutwardRule | import("@protontech/fathom").InwardRule)[], import("@protontech/fathom").OutwardRule | import("@protontech/fathom").InwardRule];
+export declare const getRulesProvider: (featureProvider: FeatureProvider) => Record<DetectionClass, readonly AnyRule[]>;

package/rules/v1/index.js

@@ -0,0 +1,66 @@
+import { FEATURE_SEPARATOR } from "@protontech/autofill/constants/features";
+import { formCandidateSelector } from "@protontech/autofill/constants/selectors";
+import { computeFeatures } from "@protontech/autofill/features/feature";
+import { FieldType, FormType } from "@protontech/autofill/types";
+import { isCCInputField, isCCSelectField } from "@protontech/autofill/utils/credit-card";
+import { featureScore, isNoopForm, outRuleWithCache, processFieldEffect, processFormEffect, withFnodeEl } from "@protontech/autofill/utils/fathom";
+import { isClassifiableField, maybeEmail, maybeHiddenUsername, maybeOTP, maybePassword, maybeUsername } from "@protontech/autofill/utils/field";
+import { isClassifiable } from "@protontech/autofill/utils/flags";
+import { isIdentity } from "@protontech/autofill/utils/identity";
+import { overrides } from "@protontech/autofill/utils/overrides";
+import { isVisibleForm } from "@protontech/autofill/utils/visible";
+import { dom, out, rule, type } from "@protontech/fathom";
+const getRulesForFieldClass = (klass, featureComputer) => [
+    rule(type(`${klass}-field`), type(klass), {}),
+    ...featureComputer.features.map((feat) => rule(type(klass), featureScore(`${klass}-field`, feat), { name: `${klass}${FEATURE_SEPARATOR}${feat.name}` })),
+    ...outRuleWithCache("field-candidate", klass),
+];
+const getRulesForFormClass = (klass, featureComputer) => [
+    rule(type("form"), type(klass), {}),
+    ...featureComputer.features.map((feat) => rule(type(klass), featureScore("form", feat), { name: `${klass}${FEATURE_SEPARATOR}${feat.name}` })),
+    ...outRuleWithCache("form-candidate", klass),
+];
+const noopRules = [
+    rule(type("form").when(isNoopForm), type(FormType.NOOP), {}),
+    ...outRuleWithCache("form-candidate", FormType.NOOP, () => () => true),
+];
+const identityRules = [rule(type("field").when(isIdentity), type("identity-field"), {}), rule(type("identity-field"), type(FieldType.IDENTITY), {}), ...outRuleWithCache("field-candidate", FieldType.IDENTITY, () => () => true)];
+const ccRules = [
+    rule(type("field").when(isCCInputField), type("cc-field"), {}),
+    rule(type("field-candidate").when(isCCSelectField), type("cc-field"), {}),
+    rule(type("cc-field"), type(FieldType.CREDIT_CARD), {}),
+    ...outRuleWithCache("field-candidate", FieldType.CREDIT_CARD, () => () => true),
+];
+export const getBaseRules = (featureProvider) => [
+    rule(dom(formCandidateSelector), type("form-candidate"), {}),
+    rule(dom("input"), type("field-candidate"), {}),
+    ...overrides,
+    rule(type("form-candidate").when(withFnodeEl(isClassifiable)), type("form-element"), {}),
+    rule(type("form-element").when(withFnodeEl(isVisibleForm)), type("form").note((fnode) => computeFeatures(featureProvider.form, fnode)), {}),
+    rule(type("form-element"), out("form").through(processFormEffect), {}),
+    ...noopRules,
+    rule(type("field-candidate").when(isClassifiableField), type("field").note((fnode) => computeFeatures(featureProvider.field, fnode)), {}),
+    rule(type("field").when(maybeUsername), type("username-field").note((fnode) => computeFeatures(featureProvider.username, fnode)), {}),
+    rule(type("field").when(maybeHiddenUsername), type("username-hidden-field").note((fnode) => computeFeatures(featureProvider["username-hidden"], fnode)), {}),
+    rule(type("field").when(maybeEmail), type("email-field").note((fnode) => computeFeatures(featureProvider.email, fnode)), {}),
+    rule(type("field").when(maybePassword), type("password-field").note((fnode) => computeFeatures(featureProvider.password, fnode)), {}),
+    rule(type("field").when(maybePassword), type("new-password-field").note((fnode) => computeFeatures(featureProvider["new-password"], fnode)), {}),
+    rule(type("field").when(maybeOTP), type("otp-field").note((fnode) => computeFeatures(featureProvider.otp, fnode)), {}),
+    ...identityRules,
+    ...ccRules,
+    rule(type("field"), out("field").through(processFieldEffect), {}),
+];
+export const getRulesProvider = (featureProvider) => {
+    return {
+        email: getRulesForFieldClass("email", featureProvider.email),
+        otp: getRulesForFieldClass("otp", featureProvider.otp),
+        password: getRulesForFieldClass("password", featureProvider.password),
+        "new-password": getRulesForFieldClass("new-password", featureProvider["new-password"]),
+        "username-hidden": getRulesForFieldClass("username-hidden", featureProvider["username-hidden"]),
+        username: getRulesForFieldClass("username", featureProvider.username),
+        login: getRulesForFormClass("login", featureProvider.login),
+        "password-change": getRulesForFormClass("password-change", featureProvider["password-change"]),
+        recovery: getRulesForFormClass("recovery", featureProvider.recovery),
+        register: getRulesForFormClass("register", featureProvider.register),
+    };
+};

package/rulesets.d.ts

@@ -1,2 +1,9 @@
-declare const trainees: Map<string, {}>;
-export { trainees };
+import type { Ruleset } from "@protontech/fathom";
+import type { ModelName, ModelProvider } from "./types";
+type RulesetRegistry<T extends ModelName = string> = {
+    providers: Record<T, ModelProvider>;
+    make: (key: T) => Ruleset;
+};
+export declare const rulesetMaker: (modelProvider: ModelProvider) => Ruleset;
+export declare const createRulesetRegistry: <T extends ModelName>(providers: Record<T, ModelProvider>) => RulesetRegistry<T>;
+export {};

package/rulesets.js

@@ -1,10 +1,15 @@
-import definitions, { rulesetMaker } from "./trainees";
-const trainees = new Map();
-definitions.forEach((definition) => {
-    trainees.set(definition.name, {
-        coeffs: new Map(definition.coeffs),
-        viewportSize: { width: 1200, height: 860 },
-        rulesetMaker,
-    });
+import { ruleset } from "@protontech/fathom";
+import { getBaseRules, getRulesProvider } from "./rules/v1";
+import { detectionClasses } from "./types";
+import { prepass } from "./utils/prepass";
+export const rulesetMaker = (modelProvider) => {
+    const featureProvider = Object.fromEntries(Object.keys(modelProvider).map((klass) => [klass, modelProvider[klass].featureComputer]));
+    const rulesProvider = getRulesProvider(featureProvider);
+    const rules = [...getBaseRules(featureProvider), ...detectionClasses.flatMap((klass) => rulesProvider[klass])];
+    const models = new Map(detectionClasses.map((klass) => [klass, modelProvider[klass].model]));
+    return ruleset(rules, models, prepass);
+};
+export const createRulesetRegistry = (providers) => ({
+    providers,
+    make: (key) => rulesetMaker(providers[key]),
 });
-export { trainees };

package/types/index.d.ts

@@ -1,22 +1,10 @@
-import { rule, ruleset } from "@protontech/fathom";
+import type { Fnode, rule } from "@protontech/fathom";
+import type { Features, Inferrer } from "@protontech/ml-inference";
 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 = {
+export type PerceptronParams = {
     coeffs: Coeff[];
     bias: number;
-    cutoff: number;
-};
-export type Trainee = TrainingResults & {
-    name: string;
-    getRules: () => AnyRule[];
 };
 export declare enum FormType {
     LOGIN = "login",
@@ -32,7 +20,72 @@ export declare enum FieldType {
     PASSWORD_CURRENT = "password",
     PASSWORD_NEW = "new-password",
     USERNAME = "username",
-    USERNAME_HIDDEN = "username-hidden"
+    USERNAME_HIDDEN = "username-hidden",
+    CREDIT_CARD = "credit-card"
+}
+export declare enum CCFieldType {
+    NAME = "cc:name",
+    FIRSTNAME = "cc:firstname",
+    LASTNAME = "cc:lastname",
+    NUMBER = "cc:number",
+    CSC = "cc:cvc",
+    EXP = "cc:exp",
+    EXP_YEAR = "cc:exp-year",
+    EXP_MONTH = "cc:exp-month"
+}
+export declare enum IdentityFieldType {
+    FULLNAME = "id:fullname",
+    FIRSTNAME = "id:firstname",
+    MIDDLENAME = "id:middlname",
+    LASTNAME = "id:lastname",
+    TELEPHONE = "id:tel",
+    ADDRESS = "id:address",
+    STATE = "id:state",
+    CITY = "id:city",
+    ZIPCODE = "id:zipcode",
+    ORGANIZATION = "id:org",
+    COUNTRY = "id:country",
+    EMAIL = "id:email"
 }
-export declare const formTypes: FormType[];
 export declare const fieldTypes: FieldType[];
+export declare const formTypes: FormType[];
+export declare const ccFields: Set<string>;
+export declare const identityFields: Set<string>;
+export declare const fieldClasses: readonly ["email", "otp", "password", "new-password", "username", "username-hidden"];
+export declare const formClasses: readonly ["login", "password-change", "recovery", "register"];
+export declare const detectionClasses: readonly ["email", "otp", "password", "new-password", "username", "username-hidden", "login", "password-change", "recovery", "register"];
+export declare const abstractDetectionClasses: readonly ["field", "form"];
+export type FormClass = (typeof formClasses)[number];
+export type FieldClass = (typeof fieldClasses)[number];
+export type DetectionClass = (typeof detectionClasses)[number];
+export type HeuristicDetectionClass = (typeof abstractDetectionClasses)[number];
+export type AbstractFeatures<T = unknown> = Record<string, AbstractFeature<T>>;
+export interface AbstractFeature<T = unknown> extends Feature<string, T, AbstractFeatures> {
+}
+export type InferParentComputeType<P extends AbstractFeatures> = {
+    [K in keyof P as P[K]["name"]]: ReturnType<P[K]["compute"]>;
+};
+export type InferFeatureName<F extends AbstractFeature> = F extends Feature<infer N, unknown, AbstractFeatures> ? N : never;
+export type InferFeatureReturnType<F extends AbstractFeature> = F extends Feature<string, infer R, AbstractFeatures> ? R : never;
+export type Feature<N extends string, R, P extends AbstractFeatures> = {
+    name: N;
+    parents: P;
+    compute(parents: InferParentComputeType<P>, fnode: Fnode): R;
+};
+export type ComputedFeatures<F extends AbstractFeatures> = {
+    [K in keyof F as F[K]["name"]]: ReturnType<F[K]["compute"]>;
+};
+export interface FeatureComputer<F extends AbstractFeatures = AbstractFeatures> {
+    compute(fnode: Fnode): ComputedFeatures<F>;
+    features: AbstractFeature[];
+}
+export type ModelProviderRegistry = Record<ModelName, ModelProvider>;
+export type ModelName = string;
+export type ModelProvider = {
+    [Klass in DetectionClass | HeuristicDetectionClass]: Klass extends HeuristicDetectionClass ? {
+        featureComputer: FeatureComputer;
+    } : {
+        featureComputer: FeatureComputer;
+        model: Inferrer<Features, number>;
+    };
+};

package/types/index.js

@@ -15,6 +15,39 @@ export var FieldType;
     FieldType["PASSWORD_NEW"] = "new-password";
     FieldType["USERNAME"] = "username";
     FieldType["USERNAME_HIDDEN"] = "username-hidden";
+    FieldType["CREDIT_CARD"] = "credit-card";
 })(FieldType || (FieldType = {}));
-export const formTypes = Object.values(FormType);
+export var CCFieldType;
+(function (CCFieldType) {
+    CCFieldType["NAME"] = "cc:name";
+    CCFieldType["FIRSTNAME"] = "cc:firstname";
+    CCFieldType["LASTNAME"] = "cc:lastname";
+    CCFieldType["NUMBER"] = "cc:number";
+    CCFieldType["CSC"] = "cc:cvc";
+    CCFieldType["EXP"] = "cc:exp";
+    CCFieldType["EXP_YEAR"] = "cc:exp-year";
+    CCFieldType["EXP_MONTH"] = "cc:exp-month";
+})(CCFieldType || (CCFieldType = {}));
+export var IdentityFieldType;
+(function (IdentityFieldType) {
+    IdentityFieldType["FULLNAME"] = "id:fullname";
+    IdentityFieldType["FIRSTNAME"] = "id:firstname";
+    IdentityFieldType["MIDDLENAME"] = "id:middlname";
+    IdentityFieldType["LASTNAME"] = "id:lastname";
+    IdentityFieldType["TELEPHONE"] = "id:tel";
+    IdentityFieldType["ADDRESS"] = "id:address";
+    IdentityFieldType["STATE"] = "id:state";
+    IdentityFieldType["CITY"] = "id:city";
+    IdentityFieldType["ZIPCODE"] = "id:zipcode";
+    IdentityFieldType["ORGANIZATION"] = "id:org";
+    IdentityFieldType["COUNTRY"] = "id:country";
+    IdentityFieldType["EMAIL"] = "id:email";
+})(IdentityFieldType || (IdentityFieldType = {}));
 export const fieldTypes = Object.values(FieldType);
+export const formTypes = Object.values(FormType);
+export const ccFields = new Set(Object.values(CCFieldType));
+export const identityFields = new Set(Object.values(IdentityFieldType));
+export const fieldClasses = ["email", "otp", "password", "new-password", "username", "username-hidden"];
+export const formClasses = ["login", "password-change", "recovery", "register"];
+export const detectionClasses = [...fieldClasses, ...formClasses];
+export const abstractDetectionClasses = ["field", "form"];

package/utils/attributes.js

@@ -1,5 +1,5 @@
 import { sanitizeStringWithSpaces } from "./text";
-export const TEXT_ATTRIBUTES = ["title", "label", "aria-label", "aria-labelledby", "aria-describedby", "placeholder", "autocomplete", "legend"];
+export const TEXT_ATTRIBUTES = ["title", "aria-label", "aria-labelledby", "aria-describedby", "placeholder", "legend", "label"];
 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();

package/utils/clustering.js

@@ -1,10 +1,12 @@
 import { clusters as clustering } from "@protontech/fathom";
-import { buttonSelector, inputCandidateSelector, kButtonSubmitSelector, kDomGroupSelector, kFieldSelector } from "../constants/selectors";
+import { inputCandidateSelector, kButtonSelector, kButtonSubmitSelector, kDomClusterSelector, kFieldSelector } from "../constants/selectors";
 import { findStackedParents, getCommonAncestor, getRectMinDistance, pruneNested, uniqueNodes, walkUpWhile } from "./dom";
 import { isBtnCandidate } from "./field";
 import { isVisibleField } from "./visible";
+import { isTopFrame } from "./exclusion";
 import { flagCluster, isClassifiable } from "./flags";
 import { selectFormCandidates } from "./form";
+import { isIFrameField } from "./iframe";
 const { clusters } = clustering;
 const CLUSTER_MAX_X_DIST = 50;
 const CLUSTER_MAX_Y_DIST = 275;
@@ -42,7 +44,13 @@ const compare = (elA, elB) => {
 };
 const handleSingletonCluster = (cluster) => {
     const node = cluster[0];
-    return walkUpWhile(node, 5)((_, candidate) => candidate === node || candidate.querySelectorAll(buttonSelector).length === 0);
+    return walkUpWhile(node, 5)((parent, candidate) => {
+        if (parent.tagName === "HTML")
+            return false;
+        if (candidate === node)
+            return true;
+        return candidate.querySelectorAll(kButtonSelector).length === 0;
+    });
 };
 export const resolveFormClusters = (doc) => {
     const forms = selectFormCandidates(doc);
@@ -52,11 +60,12 @@ export const resolveFormClusters = (doc) => {
     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 domGroups = Array.from(doc.querySelectorAll(kDomClusterSelector)).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);
+    const iframes = clusterable(Array.from(doc.querySelectorAll("iframe")).filter(isIFrameField));
+    const candidates = uniqueNodes(fieldsOfInterest, buttons, iframes);
     if (candidates.length > CLUSTER_MAX_ELEMENTS)
         return [];
     const groupByInput = new WeakMap(candidates.map((el) => [el, groups.find((group) => group.contains(el))]));
@@ -73,7 +82,11 @@ export const resolveFormClusters = (doc) => {
     });
     const ancestors = theClusters
         .map((cluster) => (cluster.length === 1 ? handleSingletonCluster(cluster) : cluster.reduce(getCommonAncestor)))
-        .filter((ancestor) => document.body !== ancestor && ancestor.querySelectorAll(inputCandidateSelector).length > 0);
+        .filter((ancestor) => {
+        if (isTopFrame() && document.body === ancestor)
+            return false;
+        return ancestor.querySelectorAll(inputCandidateSelector).length > 0;
+    });
     const result = pruneNested(ancestors);
     result.forEach(flagCluster);
     context.cache = new WeakMap();

package/utils/credit-card.d.ts

@@ -0,0 +1,32 @@
+import { CCFieldType } from "@protontech/autofill/types";
+import type { Fnode } from "@protontech/fathom";
+export type CCFieldElement = HTMLInputElement | HTMLSelectElement;
+export type CCExpirationMonthFormat = {
+    padding: boolean;
+};
+export type CCExpirationYearFormat = {
+    fullYear: boolean;
+};
+export type CCExpirationFormat = {
+    separator: string;
+    fullYear: boolean;
+    monthFirst: boolean;
+};
+type CCFieldMatchParams = {
+    visible: boolean;
+};
+export declare const CC_ATTRIBUTES: string[];
+export declare const CC_INPUT_TYPES: string[];
+export declare const getExpirationFormat: (field: HTMLElement, allowFallback?: boolean) => CCExpirationFormat | undefined;
+export declare const formatExpirationDate: (month: string, year: string, { fullYear, separator, monthFirst }: CCExpirationFormat) => string;
+export declare const getInputExpirationMonthFormat: (input: HTMLInputElement) => CCExpirationMonthFormat;
+export declare const getInputExpirationYearFormat: (input: HTMLInputElement) => CCExpirationYearFormat;
+export declare const getSelectExpirationYearFormat: (select: HTMLSelectElement) => CCExpirationYearFormat | undefined;
+export declare const getSelectExpirationMonthFormat: (select: HTMLSelectElement) => CCExpirationMonthFormat | undefined;
+export declare const getCCHaystack: (field: HTMLElement) => string;
+export declare const getCachedCCSubtype: (el: HTMLElement) => CCFieldType | undefined;
+export declare const getCCFieldType: (field: CCFieldElement) => CCFieldType | undefined;
+export declare const matchCCFieldCandidate: (input: HTMLInputElement, { visible }: CCFieldMatchParams) => boolean;
+export declare const isCCInputField: (fnode: Fnode) => boolean;
+export declare const isCCSelectField: (fnode: Fnode) => boolean;
+export {};

package/utils/credit-card.js

@@ -0,0 +1,259 @@
+import { ccFields, CCFieldType } from "@protontech/autofill/types";
+import { not, or } from "./combinators";
+import { getLabelFor } from "./dom";
+import { getAutocompletes } from "./extract";
+import { getCachedSubType, isClassifiable, setCachedSubType } from "./flags";
+import { matchCCExp, matchCCExpMonth, matchCCExpYear, matchCCFirstName, matchCCLastName, matchCCName, matchCCNumber, matchCCOutlier, matchCCSecurityCode, matchCCV } from "./re";
+import { sanitizeString, sanitizeStringWithSpaces } from "./text";
+import { isVisible } from "./visible";
+export const CC_ATTRIBUTES = ["autocomplete", "name", "id", "class", "form", "aria-label", "aria-labelledby", "placeholder", "data-testid", "data-stripe", "data-recurly", "data-encrypted-name"];
+export const CC_INPUT_TYPES = ["tel", "phone", "text", "number", "password"];
+const CC_EXP_YEAR_FORMAT = ["YYYY", "AAAA", "YY", "AA"];
+const CC_EXP_MONTH_FORMAT = ["MM", "LL"];
+const CC_EXP_FULL_RE = /(mmyy|mmaa|yymm|aamm)/;
+const CC_EXP_SEPARATOR = ["", "/", "-"];
+const CC_EXP_DEFAULT_FORMAT = { separator: "/", fullYear: false, monthFirst: true };
+const CC_EXP_FORMATS = [
+    { fullYear: true, monthFirst: true },
+    { fullYear: false, monthFirst: true },
+    { fullYear: true, monthFirst: false },
+    { fullYear: false, monthFirst: false },
+];
+const MAX_LENGTH_FORMAT_MAP = {
+    4: { separator: "", fullYear: false, monthFirst: true },
+    5: { separator: "/", fullYear: false, monthFirst: true },
+    6: { separator: "", fullYear: true, monthFirst: true },
+    7: { separator: "/", fullYear: true, monthFirst: true },
+};
+const YEAR_OPTION = (new Date().getFullYear() + 1).toString();
+const generateExpirationString = ({ fullYear, separator, monthFirst }) => {
+    const month = "01";
+    const year = fullYear ? "2025" : "25";
+    return monthFirst ? `${month}${separator}${year}` : `${year}${separator}${month}`;
+};
+const getExpirationFormatFromPattern = (pattern) => {
+    try {
+        const regex = new RegExp(`^${pattern}$`);
+        for (const format of CC_EXP_FORMATS) {
+            for (const separator of CC_EXP_SEPARATOR) {
+                const testString = generateExpirationString({ ...format, separator });
+                if (regex.test(testString)) {
+                    return {
+                        separator,
+                        fullYear: format.fullYear,
+                        monthFirst: format.monthFirst,
+                    };
+                }
+            }
+        }
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
+const getCCFormatHaystack = (input) => {
+    var _a;
+    const { placeholder, className, id, name } = input;
+    const ariaLabel = input.getAttribute("aria-label");
+    const label = (_a = getLabelFor(input)) === null || _a === void 0 ? void 0 : _a.innerText;
+    return [className, id, name, ariaLabel, placeholder.replace(/\s/g, ""), label === null || label === void 0 ? void 0 : label.replace(/\s/g, "")].filter(Boolean).join(" ").toUpperCase();
+};
+const getExpirationFormatFromMaxLength = (maxLength) => MAX_LENGTH_FORMAT_MAP[maxLength];
+const getExpirationFormatFromAttributes = (input) => {
+    const haystack = getCCFormatHaystack(input);
+    for (const separator of CC_EXP_SEPARATOR) {
+        for (const year of CC_EXP_YEAR_FORMAT) {
+            for (const monthFirst of [true, false]) {
+                if (haystack.includes(monthFirst ? `MM${separator}${year}` : `${year}${separator}MM`)) {
+                    return {
+                        separator,
+                        fullYear: year.length === 4,
+                        monthFirst,
+                    };
+                }
+            }
+        }
+    }
+};
+export const getExpirationFormat = (field, allowFallback = true) => {
+    if (field instanceof HTMLInputElement) {
+        const validMaxLength = field.maxLength >= 4;
+        const validPattern = field.pattern && (field.maxLength === -1 || validMaxLength);
+        return (getExpirationFormatFromAttributes(field) ||
+            (validPattern && getExpirationFormatFromPattern(field.pattern)) ||
+            (validMaxLength && getExpirationFormatFromMaxLength(field.maxLength)) ||
+            (allowFallback ? CC_EXP_DEFAULT_FORMAT : undefined));
+    }
+};
+export const formatExpirationDate = (month, year, { fullYear, separator, monthFirst }) => {
+    const formattedYear = fullYear ? year.slice(0, 4) : year.slice(-2);
+    const formattedMonth = month.padStart(2, "0");
+    const components = monthFirst ? [formattedMonth, formattedYear] : [formattedYear, formattedMonth];
+    return components.join(separator);
+};
+const getSelectOptions = (el) => Array.from(el.options)
+    .map((opt) => opt.value)
+    .filter(Boolean);
+export const getInputExpirationMonthFormat = (input) => {
+    const haystack = getCCFormatHaystack(input);
+    if (CC_EXP_MONTH_FORMAT.some((pattern) => haystack.includes(pattern)))
+        return { padding: true };
+    return { padding: input.minLength === 2 || input.maxLength === 2 };
+};
+export const getInputExpirationYearFormat = (input) => {
+    if (input.minLength === 4)
+        return { fullYear: true };
+    const haystack = getCCFormatHaystack(input);
+    for (const year of CC_EXP_YEAR_FORMAT) {
+        if (haystack.includes(year))
+            return { fullYear: year.length === 4 };
+    }
+    return { fullYear: false };
+};
+export const getSelectExpirationYearFormat = (select) => {
+    const options = getSelectOptions(select);
+    if (options.some((value) => /^\d{4}$/.test(value)))
+        return { fullYear: true };
+    if (options.some((value) => /^\d{2}$/.test(value)))
+        return { fullYear: false };
+};
+export const getSelectExpirationMonthFormat = (select) => {
+    const options = getSelectOptions(select);
+    if (options.some((value) => /^0[1-9]$/.test(value)))
+        return { padding: true };
+    if (options.some((value) => /^([1-9]|1[0-2])$/.test(value)))
+        return { padding: false };
+};
+const AUTOCOMPLETE_OUTLIERS = ["given-name", "additional-name", "family-name", "name"];
+const guard = (options, predicate) => (field, autocompletes, haystack) => {
+    if (!options.password && field.getAttribute("type") === "password")
+        return false;
+    if (autocompletes.includes(options.autocomplete))
+        return true;
+    if (autocompletes.some((autocomplete) => AUTOCOMPLETE_OUTLIERS.includes(autocomplete)))
+        return false;
+    return predicate(field, autocompletes, haystack) && not(matchCCOutlier)(haystack);
+};
+const notCCIdentityOutlier = (autocompletes) => {
+    if (autocompletes.includes("billing"))
+        return false;
+    if (autocompletes.includes("shipping"))
+        return false;
+    return true;
+};
+const isCCFirstName = (_, autocompletes, haystack) => matchCCFirstName(haystack) && notCCIdentityOutlier(autocompletes);
+const isCCLastName = (_, autocompletes, haystack) => matchCCLastName(haystack) && notCCIdentityOutlier(autocompletes);
+const isCCName = (_, autocomplete, haystack) => matchCCName(haystack) && notCCIdentityOutlier(autocomplete);
+const isCCSecurityCode = (_, _auto, haystack) => or(matchCCV, matchCCSecurityCode)(haystack);
+const isCCNumber = (_, __, haystack) => matchCCNumber(haystack);
+const isCCExp = (field, _, haystack) => field instanceof HTMLInputElement && matchCCExp(haystack);
+const isCCExpMonth = (field, autocompletes, haystack) => {
+    if (autocompletes.includes("cc-exp"))
+        return false;
+    if (CC_EXP_FULL_RE.test(haystack))
+        return false;
+    if (matchCCExpMonth(haystack))
+        return true;
+    if (field instanceof HTMLSelectElement && matchCCExp(haystack)) {
+        return field.options.length >= 12 && field.options.length <= 14;
+    }
+    return false;
+};
+const isCCExpYear = (field, autocompletes, haystack) => {
+    if (autocompletes.includes("cc-exp"))
+        return false;
+    if (CC_EXP_FULL_RE.test(haystack))
+        return false;
+    if (matchCCExpYear(haystack))
+        return true;
+    if (field instanceof HTMLSelectElement && matchCCExp(haystack)) {
+        for (const option of field.options) {
+            if (option.innerText === YEAR_OPTION)
+                return true;
+            if (option.value === YEAR_OPTION)
+                return true;
+        }
+    }
+    return false;
+};
+const CC_MATCHERS = [
+    [CCFieldType.FIRSTNAME, guard({ autocomplete: "cc-given-name" }, isCCFirstName)],
+    [CCFieldType.LASTNAME, guard({ autocomplete: "cc-family-name" }, isCCLastName)],
+    [CCFieldType.NAME, guard({ autocomplete: "cc-name" }, isCCName)],
+    [CCFieldType.EXP_YEAR, guard({ autocomplete: "cc-exp-year" }, isCCExpYear)],
+    [CCFieldType.EXP_MONTH, guard({ autocomplete: "cc-exp-month" }, isCCExpMonth)],
+    [CCFieldType.EXP, guard({ autocomplete: "cc-exp" }, isCCExp)],
+    [CCFieldType.CSC, guard({ autocomplete: "cc-csc", password: true }, isCCSecurityCode)],
+    [CCFieldType.NUMBER, guard({ autocomplete: "cc-number", password: true }, isCCNumber)],
+];
+export const getCCHaystack = (field) => {
+    const attrs = CC_ATTRIBUTES.map((attr) => { var _a; return (_a = field === null || field === void 0 ? void 0 : field.getAttribute(attr)) !== null && _a !== void 0 ? _a : ""; });
+    const labelEl = getLabelFor(field);
+    const label = sanitizeString((() => {
+        if (!labelEl)
+            return "";
+        if (labelEl.innerText)
+            return labelEl.innerText;
+        if (labelEl.childElementCount === 0)
+            return "";
+        return Array.from(labelEl.children)
+            .map((el) => { var _a; return (_a = el === null || el === void 0 ? void 0 : el.innerText) !== null && _a !== void 0 ? _a : ""; })
+            .join(" ");
+    })());
+    return sanitizeStringWithSpaces(attrs.join(" ")) + " " + label;
+};
+export const getCachedCCSubtype = (el) => {
+    const subType = getCachedSubType(el);
+    if (subType && ccFields.has(subType))
+        return subType;
+};
+export const getCCFieldType = (field) => {
+    var _a;
+    const cachedSubType = getCachedCCSubtype(field);
+    if (cachedSubType)
+        return cachedSubType;
+    const type = field.getAttribute("type");
+    if (field.tagName === "INPUT" && type && !CC_INPUT_TYPES.includes(type))
+        return;
+    const haystack = getCCHaystack(field);
+    const autocompletes = getAutocompletes(field);
+    if (haystack) {
+        const ccType = (_a = CC_MATCHERS.find(([, test]) => test(field, autocompletes, haystack))) === null || _a === void 0 ? void 0 : _a[0];
+        if (ccType)
+            setCachedSubType(field, ccType);
+        return ccType;
+    }
+};
+export const matchCCFieldCandidate = (input, { visible }) => {
+    if (getCachedCCSubtype(input))
+        return true;
+    if (!visible)
+        return false;
+    const ccType = getCCFieldType(input);
+    if (ccType)
+        setCachedSubType(input, ccType);
+    return ccType !== undefined;
+};
+export const isCCInputField = (fnode) => {
+    const { isCC, visible } = fnode.noteFor("field");
+    if (!visible)
+        return false;
+    return isCC;
+};
+export const isCCSelectField = (fnode) => {
+    const select = fnode.element;
+    if (!(select instanceof HTMLSelectElement))
+        return false;
+    if (getCachedCCSubtype(select))
+        return true;
+    const visible = isVisible(select, { opacity: false });
+    if (!visible)
+        return false;
+    const isProcessable = isClassifiable(select);
+    if (!isProcessable)
+        return false;
+    const ccType = getCCFieldType(select);
+    if (ccType)
+        setCachedSubType(select, ccType);
+    return ccType !== undefined;
+};