@protontech/autofill 0.0.35481761 → 0.0.36026908

package/utils/credit-card.js

@@ -7,7 +7,7 @@ import { matchCCExp, matchCCExpMonth, matchCCExpYear, matchCCFirstName, matchCCL
 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"];
+export const CC_INPUT_TYPES = ["tel", "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)/;
@@ -212,8 +212,7 @@ export const getCCFieldType = (field) => {
     const cachedSubType = getCachedCCSubtype(field);
     if (cachedSubType)
         return cachedSubType;
-    const type = field.getAttribute("type");
-    if (field.tagName === "INPUT" && type && !CC_INPUT_TYPES.includes(type))
+    if (field.tagName === "INPUT" && !CC_INPUT_TYPES.includes(field.type))
         return;
     const haystack = getCCHaystack(field);
     const autocompletes = getAutocompletes(field);
@@ -234,12 +233,6 @@ export const matchCCFieldCandidate = (input, { visible }) => {
         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))

package/utils/field.d.ts

@@ -7,11 +7,10 @@ export declare const isSelect: (el: HTMLElement) => el is HTMLSelectElement;
 export declare const isTextarea: (el: HTMLElement) => el is HTMLTextAreaElement;
 export declare const splitFieldsByVisibility: (els: HTMLElement[]) => [HTMLElement[], HTMLElement[]];
 export declare const fType: (type: FieldType) => (fnode: Fnode) => boolean;
-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 fInput: (types: string[]) => (fnode: Fnode) => boolean;
+export declare const fMatch: (selector: string) => (fnode: Fnode) => boolean;
+export declare const fMode: (mode: string) => (fnode: Fnode) => boolean;
+export declare const fList: (fnode: Fnode) => boolean;
 export declare const isUsernameCandidate: (el: HTMLInputElement) => boolean;
 export declare const isEmailCandidate: (el: HTMLInputElement) => boolean;
 export declare const isOAuthCandidate: (el: HTMLElement) => boolean;

package/utils/field.js

@@ -1,6 +1,6 @@
 import { MIN_AREA_SUBMIT_BTN } from "@protontech/autofill/constants/heuristics";
-import { inputCandidateSelector, kPasswordSelector, kUsernameSelector } from "@protontech/autofill/constants/selectors";
-import { and, any, not, or } from "./combinators";
+import { inputCandidateSelector } from "@protontech/autofill/constants/selectors";
+import { any } from "./combinators";
 import { getAllFieldHaystacks } from "./extract";
 import { getParentFormFnode } from "./fathom";
 import { isClassifiable, isHidden, isProcessed } from "./flags";
@@ -14,11 +14,6 @@ export const isInputField = (el) => {
 };
 export const isSelect = (el) => el.tagName === "SELECT";
 export const isTextarea = (el) => el.tagName === "TEXTAREA";
-const isActiveFieldFNode = (fnode) => {
-    const el = fnode.element;
-    const { visible } = fnode.noteFor("field");
-    return visible && !el.readOnly && !el.disabled;
-};
 export const splitFieldsByVisibility = (els) => {
     return els.reduce((acc, el) => {
         if (isVisibleField(el))
@@ -29,16 +24,10 @@ export const splitFieldsByVisibility = (els) => {
     }, [[], []]);
 };
 export const fType = (type) => (fnode) => fnode.hasType(type);
-const fInput = (types) => (fnode) => types.includes(fnode.element.type);
-const fMatch = (selector) => (fnode) => fnode.element.matches(selector);
-const fMode = (mode) => (fnode) => fnode.element.inputMode === mode;
-const fActive = (fnode) => isActiveFieldFNode(fnode);
-const fList = (fnode) => fnode.element.getAttribute("aria-autocomplete") === "list" || fnode.element.role === "combobox";
-export const maybeEmail = and(not(fList), or(fInput(["email", "text"]), fMode("email")), fActive);
-export const maybePassword = and(not(fList), fMatch(kPasswordSelector), fActive);
-export const maybeOTP = and(fInput(["text", "number", "tel"]), fActive, not(fList));
-export const maybeUsername = and(not(fList), or(and(not(fMode("email")), fInput(["text", "tel"])), fMatch(kUsernameSelector)), fActive);
-export const maybeHiddenUsername = and(not(fList), fInput(["email", "text", "hidden"]), not(fActive));
+export const fInput = (types) => (fnode) => types.includes(fnode.element.type);
+export const fMatch = (selector) => (fnode) => fnode.element.matches(selector);
+export const fMode = (mode) => (fnode) => fnode.element.inputMode === mode;
+export const fList = (fnode) => fnode.element.getAttribute("aria-autocomplete") === "list" || fnode.element.role === "combobox";
 export const isUsernameCandidate = (el) => el.type === "text" || (el.type === "tel" && any(matchUsername)(getAllFieldHaystacks(el)));
 export const isEmailCandidate = (el) => el.type === "email" || (el.type === "text" && any(matchEmail)(getAllFieldHaystacks(el)));
 export const isOAuthCandidate = (el) => any(matchOAuth)(getAllFieldHaystacks(el));

package/utils/identity.d.ts

@@ -1,4 +1,3 @@
-import type { Fnode } from "@protontech/fathom";
 import { IdentityFieldType } from "@protontech/autofill/types";
 import type { FormClassification } from "./fathom";
 type IdentityFieldMatchParams = {
@@ -11,5 +10,4 @@ export declare const getCachedIdentitySubType: (el: HTMLElement) => IdentityFiel
 export declare const getIdentityHaystack: (input: HTMLInputElement) => string;
 export declare const getIdentityFieldType: (input: HTMLInputElement) => IdentityFieldType | undefined;
 export declare const matchIdentityField: (input: HTMLInputElement, { visible }: IdentityFieldMatchParams) => boolean;
-export declare const isIdentity: (fnode: Fnode) => boolean;
 export {};

package/utils/identity.js

@@ -24,7 +24,7 @@ const IDENTITY_MATCHERS = [
     [IdentityFieldType.ADDRESS, guard({ autocompletes: ["street-address", "address-line1"] }, matchAddress)],
 ];
 const IDENTITY_ATTRIBUTES = ["autocomplete", "name", "id", "data-bhw"];
-const IDENTITY_INPUT_TYPES = ["tel", "phone", "text", "number"];
+const IDENTITY_INPUT_TYPES = ["tel", "text", "number"];
 export const getCachedIdentitySubType = (el) => {
     const subType = getCachedSubType(el);
     if (subType && identityFields.has(subType))
@@ -41,8 +41,7 @@ export const getIdentityFieldType = (input) => {
         return cachedSubType;
     if (getCachedSubType(input) !== undefined)
         return;
-    const type = input.getAttribute("type");
-    if (type && !IDENTITY_INPUT_TYPES.includes(type))
+    if (!IDENTITY_INPUT_TYPES.includes(input.type))
         return;
     if ((_a = input.getAttribute("autocomplete")) === null || _a === void 0 ? void 0 : _a.includes("email"))
         return;
@@ -55,7 +54,6 @@ export const getIdentityFieldType = (input) => {
         return identityType;
     }
 };
-const isAutocompleteListInput = (el) => el.getAttribute("aria-autocomplete") === "list" || el.role === "combobox";
 export const matchIdentityField = (input, { visible }) => {
     if (!visible)
         return false;
@@ -67,22 +65,3 @@ export const matchIdentityField = (input, { visible }) => {
     setCachedSubType(input, identityType);
     return true;
 };
-export const isIdentity = (fnode) => {
-    const input = fnode.element;
-    const { isIdentity, isCC, searchField, isFormLogin, isFormRecovery, visible } = fnode.noteFor("field");
-    if (!visible)
-        return false;
-    if (isCC || !isIdentity)
-        return false;
-    const identityType = getIdentityFieldType(input);
-    if (!identityType)
-        return false;
-    const outlierForm = isFormLogin || isFormRecovery;
-    if (outlierForm)
-        return false;
-    if (isAutocompleteListInput(input))
-        return [IdentityFieldType.ADDRESS, IdentityFieldType.ZIPCODE].includes(identityType);
-    if (searchField)
-        return [IdentityFieldType.ADDRESS, IdentityFieldType.ZIPCODE, IdentityFieldType.CITY].includes(identityType);
-    return true;
-};

package/dictionary/generate.d.ts

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

package/dictionary/generate.js

@@ -1,51 +0,0 @@
-import { sanitizeString, sanitizeStringWithSpaces } from "@protontech/autofill/utils/text";
-import fs from "node:fs";
-import path from "node:path";
-import regexgen from "regexgen";
-import dictionary from "./source/dictionary";
-const generateRegexes = () => {
-    let output = "";
-    output += "/* Regular expressions auto-generated using `source/dictionary.ts`\n";
-    output += " * Simplified & optimised using `regexgen` for performance. \n";
-    output += " * `TYPE_RE`: i18n regexp for text matches\n";
-    output += " * `TYPE_ATTR_RE`: regexp for node attributes\n";
-    output += " * `TYPE_ATTR_END`: attr ending constraint regexp */\n\n";
-    Object.entries(dictionary).forEach(([name, definition]) => {
-        var _a, _b, _c, _d, _e, _f, _g;
-        const i18n = Object.values((_a = definition.i18n) !== null && _a !== void 0 ? _a : {})
-            .flat()
-            .map(sanitizeString);
-        const attrs = ((_c = (_b = definition === null || definition === void 0 ? void 0 : definition.attr) === null || _b === void 0 ? void 0 : _b.values) !== null && _c !== void 0 ? _c : []).map(sanitizeString);
-        const prefixes = ((_e = (_d = definition === null || definition === void 0 ? void 0 : definition.attr) === null || _d === void 0 ? void 0 : _d.prefixes) !== null && _e !== void 0 ? _e : []).map(sanitizeString);
-        const attrsExact = ((_g = (_f = definition === null || definition === void 0 ? void 0 : definition.attr) === null || _f === void 0 ? void 0 : _f.exact) !== null && _g !== void 0 ? _g : []).map(sanitizeStringWithSpaces);
-        if (i18n.length > 0) {
-            output += `export const ${name}_RE = ${regexgen(i18n, "")}i;\n`;
-        }
-        if (attrs.length > 0 || attrsExact.length > 0) {
-            const regAttrs = attrs.length > 0 ? regexgen(attrs, "").source : null;
-            const regExact = attrsExact.length > 0 ? `\\b(${regexgen(attrsExact, "").source})\\b` : null;
-            const regPrefixes = prefixes.length > 0 ? regexgen(prefixes, "").source : null;
-            const withPrefixes = (re) => (regPrefixes ? `(?:${regPrefixes})${re}` : re);
-            const re = (() => {
-                if (regAttrs && !regExact)
-                    return withPrefixes(regAttrs);
-                else if (!regAttrs && regExact)
-                    return regExact;
-                else if (regAttrs && regExact)
-                    return `${withPrefixes(regAttrs)}|${regExact}`;
-                return "";
-            })();
-            output += `export const ${name}_ATTR_RE = /${re}/i;\n`;
-        }
-        if (definition === null || definition === void 0 ? void 0 : definition.startsWith) {
-            const startWithRe = regexgen(definition.startsWith.map(sanitizeString), "");
-            output += `export const ${name}_ATTR_START_RE = /\\b(?:${startWithRe.source})\\S+/i;\n`;
-        }
-        if (definition === null || definition === void 0 ? void 0 : definition.endsWith) {
-            const endWordsRe = regexgen(definition.endsWith.map(sanitizeString), "");
-            output += `export const ${name}_ATTR_END_RE= /\\b\\S*(?:${endWordsRe.source})\\b/i;\n`;
-        }
-    });
-    fs.writeFileSync(path.resolve(__dirname, "./generated/dictionary.ts"), output);
-};
-generateRegexes();

package/features/feature.spec.d.ts

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

package/features/feature.spec.js

@@ -1,108 +0,0 @@
-import { feature, featuresProduct, getComputerForFeatures, topologicalSort, validateComputerInputs } from "./feature";
-function doNothing() {
-}
-describe("topological sort", () => {
-    test("it works", () => {
-        const A = feature("A", {}, doNothing);
-        const B = feature("B", { A }, doNothing);
-        const C = feature("C", { A }, doNothing);
-        const D = feature("D", { B, C }, doNothing);
-        const E = feature("E", { B }, doNothing);
-        const F = feature("F", {}, doNothing);
-        const G = feature("G", { E, F }, doNothing);
-        const H = feature("H", {}, doNothing);
-        const features = { D, G, H };
-        const sorted = topologicalSort(features);
-        const nodeNames = sorted.map((feat) => feat.name);
-        expect(nodeNames.slice(0, 3).sort()).toEqual(["A", "F", "H"]);
-        expect(nodeNames.slice(3, 5).sort()).toEqual(["B", "C"]);
-        expect(nodeNames[5]).toEqual("E");
-        expect(nodeNames.slice(6, 8).sort()).toEqual(["D", "G"]);
-    });
-    test("a node reachable from multiple paths appears only once", () => {
-        const X = feature("X", {}, doNothing);
-        const Y = feature("Y", { X }, doNothing);
-        const A = feature("A", { X, Y }, doNothing);
-        const sorted = topologicalSort({ A });
-        expect(sorted.length).toBe(new Set(sorted).size);
-        const pos = new Map(sorted.map((f, i) => [f, i]));
-        expect(pos.get(X)).toBeLessThan(pos.get(Y));
-        expect(pos.get(Y)).toBeLessThan(pos.get(A));
-    });
-    test("it fails if there is a loop", () => {
-        const A = feature("A", {}, doNothing);
-        const B = feature("B", { A }, doNothing);
-        const C = feature("C", { A }, doNothing);
-        const D = feature("D", { B, C }, doNothing);
-        const E = feature("E", { B }, doNothing);
-        const F = feature("F", {}, doNothing);
-        const G = feature("G", { E, F }, doNothing);
-        const H = feature("H", {}, doNothing);
-        A.parents = { D };
-        const features = { A, B, C, D, E, F, G, H };
-        expect(() => topologicalSort(features)).toThrow(`loop detected with elements:
-  A -> {D}
-  B -> {A}
-  C -> {A}
-  D -> {B, C}
-  E -> {B}
-  G -> {E}`);
-    });
-});
-const buildComputer = (outputs) => getComputerForFeatures({
-    sorted: topologicalSort(outputs),
-    features: Object.values(outputs)
-        .filter((f) => !f.private)
-        .map((f) => f.name),
-    private: Object.values(outputs)
-        .filter((f) => f.private)
-        .map((f) => f.name),
-});
-describe("Feature engineering", () => {
-    test("featureProduct", () => {
-        const A = feature("A", {}, () => 2);
-        const B = feature("B", { A }, () => 4);
-        const C = featuresProduct(A, B);
-        expect(buildComputer({ A, B, C }).compute({})).toMatchObject({ A: 2, B: 4, "A,B": 8 });
-    });
-    test("feature name re-mapping", () => {
-        const A = feature("A", {}, () => 2);
-        const B = feature("_B", { A }, () => 4);
-        const C = feature("C", { A, B }, (p) => p.A + p._B);
-        expect(buildComputer({ A, B, C }).compute({})).toMatchObject({ A: 2, _B: 4, C: 6 });
-    });
-    describe("validateComputerInputs (gen-time guards)", () => {
-        const A = feature("A", {}, () => 1);
-        const B = feature("B", { A }, () => 2);
-        test("throws on a duplicate feature name in sorted", () => {
-            const Adup = feature("A", {}, () => 9);
-            expect(() => validateComputerInputs({ sorted: [A, Adup], features: ["A"], private: [] })).toThrow("duplicate feature 'A' in sorted DAG");
-        });
-        test("throws when a parent is ordered after its child", () => {
-            expect(() => validateComputerInputs({ sorted: [B, A], features: ["A", "B"], private: [] })).toThrow("feature 'B' precedes its parent 'A' in sorted DAG");
-        });
-        test("throws when an output name is absent from the DAG", () => {
-            expect(() => validateComputerInputs({ sorted: [A], features: ["A", "ghost"], private: [] })).toThrow("output 'ghost' missing from sorted DAG");
-            expect(() => validateComputerInputs({ sorted: [A], features: ["A"], private: ["secret"] })).toThrow("output 'secret' missing from sorted DAG");
-        });
-        test("accepts a well-formed, topologically sorted DAG", () => {
-            expect(() => validateComputerInputs({ sorted: [A, B], features: ["A", "B"], private: [] })).not.toThrow();
-        });
-    });
-    describe("private outputs", () => {
-        const Trans = feature("Trans", {}, () => 10);
-        const Priv = feature("Priv", { Trans }, (p) => p.Trans + 1, { private: true });
-        const Pub = feature("Pub", { Priv }, (p) => p.Priv + 1);
-        const computer = buildComputer({ Pub, Priv });
-        const result = computer.compute({});
-        test(".features lists only non-private outputs", () => {
-            expect(computer.features).toEqual(["Pub"]);
-        });
-        test("compute() result includes private outputs ", () => {
-            expect(result).toEqual({ Pub: 12, Priv: 11 });
-        });
-        test("compute() result excludes transients ", () => {
-            expect(result).not.toHaveProperty("Trans");
-        });
-    });
-});

package/features/v1/index.spec.d.ts

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

package/features/v1/index.spec.js

@@ -1,44 +0,0 @@
-import { topologicalSort } from "@protontech/autofill/features/feature";
-import { fieldFeatures } from "./abstract.field";
-import { formFeatures } from "./abstract.form";
-import { emailFeatures } from "./field.email";
-import { otpFeatures } from "./field.otp";
-import { passwordFeatures } from "./field.password";
-import { usernameFeatures } from "./field.username";
-import { usernameHiddenFeatures } from "./field.username-hidden";
-const groups = {
-    fieldFeatures,
-    formFeatures,
-    emailFeatures,
-    otpFeatures,
-    passwordFeatures,
-    usernameFeatures,
-    usernameHiddenFeatures,
-};
-const walkDAG = (outputs) => {
-    const seen = new Set();
-    const visit = (f) => {
-        if (seen.has(f))
-            return;
-        seen.add(f);
-        Object.values(f.parents).forEach(visit);
-    };
-    Object.values(outputs).forEach(visit);
-    return [...seen];
-};
-const findNameCollisions = (features) => {
-    var _a;
-    var _b;
-    const byName = {};
-    for (const f of features)
-        ((_a = byName[_b = f.name]) !== null && _a !== void 0 ? _a : (byName[_b] = [])).push(f);
-    return Object.fromEntries(Object.entries(byName).filter(([, fs]) => fs.length > 1));
-};
-describe.each(Object.entries(groups))("%s", (_name, outputs) => {
-    test("topo-sorts without throwing", () => {
-        expect(() => topologicalSort(outputs)).not.toThrow();
-    });
-    test("every Feature object has a unique .name", () => {
-        expect(findNameCollisions(walkDAG(outputs))).toEqual({});
-    });
-});

package/scripts/gen-sorted-features.d.ts

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

package/scripts/gen-sorted-features.js

@@ -1,128 +0,0 @@
-import { topologicalSort, validateComputerInputs } from "@protontech/autofill/features/feature";
-import * as abstractField from "@protontech/autofill/features/v1/abstract.field";
-import * as abstractForm from "@protontech/autofill/features/v1/abstract.form";
-import * as fieldEmail from "@protontech/autofill/features/v1/field.email";
-import * as fieldOtp from "@protontech/autofill/features/v1/field.otp";
-import * as fieldPassword from "@protontech/autofill/features/v1/field.password";
-import * as fieldUsername from "@protontech/autofill/features/v1/field.username";
-import * as fieldUsernameHidden from "@protontech/autofill/features/v1/field.username-hidden";
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-const sources = [
-    ["./abstract.form", abstractForm],
-    ["./abstract.field", abstractField],
-    ["./field.email", fieldEmail],
-    ["./field.otp", fieldOtp],
-    ["./field.password", fieldPassword],
-    ["./field.username", fieldUsername],
-    ["./field.username-hidden", fieldUsernameHidden],
-];
-const isFeature = (v) => typeof v === "object" && v !== null && typeof v.compute === "function";
-const buildFeatureRefs = (sources) => {
-    const refs = new Map();
-    for (const [src, mod] of sources) {
-        for (const [id, val] of Object.entries(mod)) {
-            if (isFeature(val) && !refs.has(val))
-                refs.set(val, { id, src, path: [] });
-        }
-    }
-    for (const [src, mod] of sources) {
-        for (const [id, val] of Object.entries(mod)) {
-            if (!isFeature(val))
-                continue;
-            const walk = (node, path) => {
-                for (const [key, parent] of Object.entries(node.parents)) {
-                    if (refs.has(parent))
-                        continue;
-                    const next = [...path, key];
-                    refs.set(parent, { id, src, path: next });
-                    walk(parent, next);
-                }
-            };
-            walk(val, []);
-        }
-    }
-    return refs;
-};
-const featureRefs = buildFeatureRefs(sources);
-const refOf = (f) => {
-    const ref = featureRefs.get(f);
-    if (!ref)
-        throw new Error(`feature '${f.name}' has no exported declaration.`);
-    return ref;
-};
-const buildComputer = (name, recordSrc, record) => {
-    const outputs = Object.values(record);
-    const computer = {
-        name,
-        recordSrc,
-        sorted: topologicalSort(record),
-        features: outputs.filter((f) => !f.private).map((f) => f.name),
-        private: outputs.filter((f) => f.private).map((f) => f.name),
-    };
-    validateComputerInputs(computer);
-    return computer;
-};
-const BANNER = `// Generated by \`bazel run //pass_ml/js/autofill:write_sorted_features\`. Do not edit.\n\n`;
-const RUNTIME_IMPORT = `import { getComputerForFeatures } from "@protontech/autofill/features/feature";`;
-const fmtImportSpec = (id, alias) => (alias === id ? id : `${id} as ${alias}`);
-const fmtImportLine = (prefix, src, specs) => `${prefix} { ${specs.join(", ")} } from "${src}";`;
-const fmtNameList = (names) => names.map((n) => `"${n}"`).join(", ");
-const fmtComputerExport = (name, recordType, sortedRefs, features, privateOutputs) => `export const ${name}Computer = getComputerForFeatures<typeof ${recordType}>({
-      sorted: [${sortedRefs.map((r) => `    ${r},`).join("\n")}],
-      features: [${fmtNameList(features)}],
-      private: [${fmtNameList(privateOutputs)}],
-});`;
-const fmtFile = (imports, exports) => `${BANNER}\n${imports}\n\n${exports}\n`;
-const render = (computers) => {
-    const valueImports = {};
-    const typeImports = {};
-    const srcsById = {};
-    const track = (bucket, src, id) => {
-        var _a, _b;
-        ((_a = bucket[src]) !== null && _a !== void 0 ? _a : (bucket[src] = new Set())).add(id);
-        ((_b = srcsById[id]) !== null && _b !== void 0 ? _b : (srcsById[id] = new Set())).add(src);
-    };
-    for (const c of computers) {
-        track(typeImports, c.recordSrc, c.name);
-        for (const f of c.sorted) {
-            const { src, id } = refOf(f);
-            track(valueImports, src, id);
-        }
-    }
-    const importAlias = (src, id) => {
-        var _a;
-        if (srcsById[id].size === 1)
-            return id;
-        return `${id}_${(_a = src.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(/[.-]/g, "_")}`;
-    };
-    const importLinesFor = (bucket, prefix) => Object.entries(bucket).map(([src, ids]) => {
-        const specs = [...ids].map((id) => fmtImportSpec(id, importAlias(src, id)));
-        return fmtImportLine(prefix, src, specs);
-    });
-    const imports = [RUNTIME_IMPORT, ...importLinesFor(valueImports, "import"), ...importLinesFor(typeImports, "import type")].join("\n");
-    const refExpr = (f) => {
-        const { src, id, path } = refOf(f);
-        return path.reduce((acc, key) => `${acc}.parents.${key}`, importAlias(src, id));
-    };
-    const exports = computers.map((c) => fmtComputerExport(c.name, importAlias(c.recordSrc, c.name), c.sorted.map(refExpr), c.features, c.private)).join("\n\n");
-    return fmtFile(imports, exports);
-};
-const writeOut = (path, content) => {
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, content);
-};
-const [, , formsOut, fieldsOut] = process.argv;
-if (!formsOut || !fieldsOut)
-    throw new Error("usage: gen-sorted-features <forms-out.ts> <fields-out.ts>");
-const formComputers = [buildComputer("formFeatures", "./abstract.form", abstractForm.formFeatures)];
-const fieldComputers = [
-    buildComputer("fieldFeatures", "./abstract.field", abstractField.fieldFeatures),
-    buildComputer("emailFeatures", "./field.email", fieldEmail.emailFeatures),
-    buildComputer("otpFeatures", "./field.otp", fieldOtp.otpFeatures),
-    buildComputer("passwordFeatures", "./field.password", fieldPassword.passwordFeatures),
-    buildComputer("usernameFeatures", "./field.username", fieldUsername.usernameFeatures),
-    buildComputer("usernameHiddenFeatures", "./field.username-hidden", fieldUsernameHidden.usernameHiddenFeatures),
-];
-writeOut(formsOut, render(formComputers));
-writeOut(fieldsOut, render(fieldComputers));

package/utils/credit-card.samples.spec.d.ts

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