@protontech/autofill 0.0.22991789 → 0.0.33690782

package/models/v1/index.d.ts

@@ -0,0 +1,2 @@
+import type { ModelProviderRegistry } from "../../types";
+export declare const ModelProviders: ModelProviderRegistry;

package/models/v1/index.js

@@ -0,0 +1,35 @@
+import { featureProvider } from "../../features/v1";
+import { getPerceptronForClass } from "../perceptron";
+import { getRandomForestInferrerForClass } from "../random_forest";
+const perceptronModelProvider = {
+    field: { featureComputer: featureProvider.field },
+    form: { featureComputer: featureProvider.form },
+    "new-password": { model: getPerceptronForClass("new-password"), featureComputer: featureProvider["new-password"] },
+    "password-change": { model: getPerceptronForClass("password-change"), featureComputer: featureProvider["password-change"] },
+    "username-hidden": { model: getPerceptronForClass("username-hidden"), featureComputer: featureProvider["username-hidden"] },
+    email: { model: getPerceptronForClass("email"), featureComputer: featureProvider.email },
+    login: { model: getPerceptronForClass("login"), featureComputer: featureProvider.login },
+    otp: { model: getPerceptronForClass("otp"), featureComputer: featureProvider.otp },
+    password: { model: getPerceptronForClass("password"), featureComputer: featureProvider.password },
+    recovery: { model: getPerceptronForClass("recovery"), featureComputer: featureProvider.recovery },
+    register: { model: getPerceptronForClass("register"), featureComputer: featureProvider.register },
+    username: { model: getPerceptronForClass("username"), featureComputer: featureProvider.username },
+};
+const randomForestModelProvider = {
+    field: { featureComputer: featureProvider.field },
+    form: { featureComputer: featureProvider.form },
+    "new-password": { model: getRandomForestInferrerForClass("new-password"), featureComputer: featureProvider["new-password"] },
+    "password-change": { model: getRandomForestInferrerForClass("password-change"), featureComputer: featureProvider["password-change"] },
+    "username-hidden": { model: getRandomForestInferrerForClass("username-hidden"), featureComputer: featureProvider["username-hidden"] },
+    email: { model: getRandomForestInferrerForClass("email"), featureComputer: featureProvider.email },
+    login: { model: getRandomForestInferrerForClass("login"), featureComputer: featureProvider.login },
+    otp: { model: getRandomForestInferrerForClass("otp"), featureComputer: featureProvider.otp },
+    password: { model: getRandomForestInferrerForClass("password"), featureComputer: featureProvider.password },
+    recovery: { model: getRandomForestInferrerForClass("recovery"), featureComputer: featureProvider.recovery },
+    register: { model: getRandomForestInferrerForClass("register"), featureComputer: featureProvider.register },
+    username: { model: getRandomForestInferrerForClass("username"), featureComputer: featureProvider.username },
+};
+export const ModelProviders = {
+    dev_perceptron: perceptronModelProvider,
+    dev_randomForest: randomForestModelProvider,
+};

package/package.json

@@ -1,29 +1,28 @@
 {
   "name": "@protontech/autofill",
-  "version": "0.0.22991789",
+  "version": "0.0.33690782",
   "private": false,
   "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.33690782",
+    "@protontech/ml-inference": "0.0.33690782"
   },
   "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,3 @@
+import type { AnyRule, DetectionClass, FeatureProvider } from "../../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,69 @@
+import { dom, out, rule, type } from "@protontech/fathom";
+import { FEATURE_SEPARATOR } from "../../constants/features";
+import { formCandidateSelector } from "../../constants/selectors";
+import { computeFeatures, FieldType, FormType } from "../../types";
+import { isCCInputField, isCCSelectField } from "../../utils/credit-card";
+import { featureScore, isNoopForm, outRuleWithCache, processFieldEffect, processFormEffect, withFnodeEl } from "../../utils/fathom";
+import { isClassifiableField, maybeEmail, maybeHiddenUsername, maybeOTP, maybePassword, maybeUsername } from "../../utils/field";
+import { isClassifiable } from "../../utils/flags";
+import { isIdentity } from "../../utils/identity";
+import { overrides } from "../../utils/overrides";
+import { isVisibleForm } from "../../utils/visible";
+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,2 @@
-declare const trainees: Map<string, {}>;
-export { trainees };
+import type { ModelProvider } from "./types";
+export declare const rulesetMaker: (modelProvider: ModelProvider) => import("@protontech/fathom").Ruleset;

package/rulesets.js

@@ -1,10 +1,11 @@
-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,
-    });
-});
-export { trainees };
+import { ruleset } from "@protontech/fathom";
+import { detectionClasses } from "./types";
+import { getBaseRules, getRulesProvider } from "./rules/v1";
+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);
+};

package/types/index.d.ts

@@ -1,23 +1,12 @@
-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",
     NOOP = "noop",
@@ -32,7 +21,73 @@ 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 const ccFields: Set<string>;
+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 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 declare const modelNames: readonly ["dev_perceptron", "dev_randomForest"];
+export type ModelName = (typeof modelNames)[number];
+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 declare const formTypes: FormType[];
-export declare const fieldTypes: FieldType[];
+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 declare const computeFeatures: <F extends AbstractFeatures>(featureComputer: FeatureComputer<F>, fnode: Fnode) => ComputedFeatures<F>;
+export type ModelProviderRegistry = Record<ModelName, ModelProvider>;
+export type FeatureProvider = Record<DetectionClass | "field" | "form", FeatureComputer>;
+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 const fieldTypes = Object.values(FieldType);
+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 const ccFields = new Set(Object.values(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 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"];
+export const modelNames = ["dev_perceptron", "dev_randomForest"];
+export const computeFeatures = (featureComputer, fnode) => featureComputer.compute(fnode);

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 {};