@protontech/autofill 0.0.35481761 → 0.0.36026908

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

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

package/utils/credit-card.spec.js

@@ -1,296 +0,0 @@
-import { formatExpirationDate, getExpirationFormat, getInputExpirationMonthFormat, getSelectExpirationMonthFormat, getSelectExpirationYearFormat } from "./credit-card";
-Object.defineProperty(HTMLElement.prototype, "innerText", {
-    get() {
-        return this.textContent;
-    },
-});
-describe("CC Expiration Detection", () => {
-    afterEach(() => {
-        document.body.innerHTML = "";
-    });
-    describe("Pattern Detection", () => {
-        test.each([
-            { pattern: "\\d{2}/\\d{2}", expected: { separator: "/", fullYear: false, monthFirst: true } },
-            { pattern: "[0-9]{2}/[0-9]{2}", expected: { separator: "/", fullYear: false, monthFirst: true } },
-            { pattern: "(0[1-9]|1[0-2])\\/[0-9]{2}", expected: { separator: "/", fullYear: false, monthFirst: true } },
-            { pattern: "\\d{2}/\\d{4}", expected: { separator: "/", fullYear: true, monthFirst: true } },
-            { pattern: "[0-9]{2}/[0-9]{4}", expected: { separator: "/", fullYear: true, monthFirst: true } },
-            { pattern: "(0[1-9]|1[0-2])\\/[0-9]{4}", expected: { separator: "/", fullYear: true, monthFirst: true } },
-            { pattern: "\\d{2}-\\d{2}", expected: { separator: "-", fullYear: false, monthFirst: true } },
-            { pattern: "[0-9]{2}-[0-9]{2}", expected: { separator: "-", fullYear: false, monthFirst: true } },
-            { pattern: "\\d{2}-\\d{4}", expected: { separator: "-", fullYear: true, monthFirst: true } },
-            { pattern: "[0-9]{2}-[0-9]{4}", expected: { separator: "-", fullYear: true, monthFirst: true } },
-            { pattern: "\\d{4}", expected: { separator: "", fullYear: false, monthFirst: true } },
-            { pattern: "[0-9]{4}", expected: { separator: "", fullYear: false, monthFirst: true } },
-            { pattern: "\\d{6}", expected: { separator: "", fullYear: true, monthFirst: true } },
-            { pattern: "[0-9]{6}", expected: { separator: "", fullYear: true, monthFirst: true } },
-            { pattern: "\\d{2}/\\d{2}", expected: { separator: "/", fullYear: false, monthFirst: true } },
-        ])("should detect pattern $pattern", ({ pattern, expected }) => {
-            const input = document.createElement("input");
-            input.pattern = pattern;
-            expect(getExpirationFormat(input)).toEqual(expected);
-        });
-        test.each([{ pattern: "[invalid regex" }, { pattern: "*+?" }, { pattern: "(" }, { pattern: "[" }])("should handle invalid regex pattern: $pattern", ({ pattern }) => {
-            const input = document.createElement("input");
-            input.pattern = pattern;
-            expect(getExpirationFormat(input)).toEqual({ separator: "/", fullYear: false, monthFirst: true });
-        });
-    });
-    describe("MaxLength Detection", () => {
-        test.each([
-            { maxLength: 4, expected: { separator: "", fullYear: false, monthFirst: true } },
-            { maxLength: 5, expected: { separator: "/", fullYear: false, monthFirst: true } },
-            { maxLength: 6, expected: { separator: "", fullYear: true, monthFirst: true } },
-            { maxLength: 7, expected: { separator: "/", fullYear: true, monthFirst: true } },
-        ])("should detect maxLength $maxLength", ({ maxLength, expected }) => {
-            const input = document.createElement("input");
-            input.maxLength = maxLength;
-            const result = getExpirationFormat(input);
-            expect(result).toEqual(expected);
-        });
-        test.each([{ maxLength: 1 }, { maxLength: 2 }, { maxLength: 3 }, { maxLength: 8 }, { maxLength: 10 }])("should return default for unmapped maxLength: $maxLength", ({ maxLength }) => {
-            const input = document.createElement("input");
-            input.maxLength = maxLength;
-            expect(getExpirationFormat(input)).toEqual({ separator: "/", fullYear: false, monthFirst: true });
-        });
-    });
-    describe("Attribute Detection", () => {
-        test.each([
-            { attr: "placeholder", value: "MM/YY", expected: { separator: "/", fullYear: false, monthFirst: true } },
-            { attr: "placeholder", value: "MM/YYYY", expected: { separator: "/", fullYear: true, monthFirst: true } },
-            { attr: "placeholder", value: "MM-YY", expected: { separator: "-", fullYear: false, monthFirst: true } },
-            { attr: "placeholder", value: "MM-YYYY", expected: { separator: "-", fullYear: true, monthFirst: true } },
-            { attr: "placeholder", value: "MM YY", expected: { separator: "", fullYear: false, monthFirst: true } },
-            { attr: "placeholder", value: "MM YYYY", expected: { separator: "", fullYear: true, monthFirst: true } },
-            { attr: "placeholder", value: "MMYY", expected: { separator: "", fullYear: false, monthFirst: true } },
-            { attr: "placeholder", value: "MMYYYY", expected: { separator: "", fullYear: true, monthFirst: true } },
-            { attr: "placeholder", value: "YY/MM", expected: { separator: "/", fullYear: false, monthFirst: false } },
-            { attr: "placeholder", value: "YYYY/MM", expected: { separator: "/", fullYear: true, monthFirst: false } },
-            { attr: "placeholder", value: "YY-MM", expected: { separator: "-", fullYear: false, monthFirst: false } },
-            { attr: "placeholder", value: "YYYY-MM", expected: { separator: "-", fullYear: true, monthFirst: false } },
-            { attr: "placeholder", value: "YY MM", expected: { separator: "", fullYear: false, monthFirst: false } },
-            { attr: "placeholder", value: "YYYY MM", expected: { separator: "", fullYear: true, monthFirst: false } },
-            { attr: "placeholder", value: "YYMM", expected: { separator: "", fullYear: false, monthFirst: false } },
-            { attr: "placeholder", value: "YYYYMM", expected: { separator: "", fullYear: true, monthFirst: false } },
-            { attr: "placeholder", value: "MM/AA", expected: { separator: "/", fullYear: false, monthFirst: true } },
-            { attr: "placeholder", value: "MM/AAAA", expected: { separator: "/", fullYear: true, monthFirst: true } },
-            { attr: "placeholder", value: "AA/MM", expected: { separator: "/", fullYear: false, monthFirst: false } },
-            { attr: "placeholder", value: "AAAA/MM", expected: { separator: "/", fullYear: true, monthFirst: false } },
-            { attr: "name", value: "exp-mm-yyyy", expected: { separator: "-", fullYear: true, monthFirst: true } },
-            { attr: "id", value: "cardExpMmYy", expected: { separator: "", fullYear: false, monthFirst: true } },
-            { attr: "className", value: "exp-field mm/yyyy-format", expected: { separator: "/", fullYear: true, monthFirst: true } },
-        ])('should detect $attr="$value"', ({ attr, value, expected }) => {
-            const input = document.createElement("input");
-            if (attr === "className")
-                input.className = value;
-            else
-                input.setAttribute(attr, value);
-            expect(getExpirationFormat(input)).toEqual(expected);
-        });
-        test.each([{ value: "Enter expiration MM/YY date" }, { value: "Card expires MM/YYYY" }, { value: "exp_field_mm_yyyy_format" }, { value: "EXPIRY DATE (MM/YY)" }, { value: "Please enter MM-YYYY" }])('should detect format in mixed text: "$value"', ({ value }) => {
-            const input = document.createElement("input");
-            input.placeholder = value;
-            const result = getExpirationFormat(input);
-            expect(result === null || result === void 0 ? void 0 : result.separator).toBeDefined();
-            expect(result === null || result === void 0 ? void 0 : result.fullYear).toBeDefined();
-            expect(result === null || result === void 0 ? void 0 : result.monthFirst).toBeDefined();
-        });
-        test.each([{ value: "email@example.com" }, { value: "Enter your name" }, { value: "Phone number" }, { value: "Address line 1" }, { value: "" }, { value: "XYZZYX" }])('should return default for non-expiry text: "$value"', ({ value }) => {
-            const input = document.createElement("input");
-            input.placeholder = value;
-            const result = getExpirationFormat(input);
-            expect(result).toEqual({ separator: "/", fullYear: false, monthFirst: true });
-        });
-    });
-    describe("getExpirationFormat - Priority Order", () => {
-        test("should prioritize attributes over pattern", () => {
-            const input = document.createElement("input");
-            input.placeholder = "MM-YYYY";
-            input.pattern = "\\d{2}/\\d{2}";
-            const result = getExpirationFormat(input);
-            expect(result).toEqual({ separator: "-", fullYear: true, monthFirst: true });
-        });
-        test("should prioritize pattern over maxLength", () => {
-            const input = document.createElement("input");
-            input.pattern = "\\d{2}-\\d{4}";
-            input.maxLength = 5;
-            const result = getExpirationFormat(input);
-            expect(result).toEqual({ separator: "-", fullYear: true, monthFirst: true });
-        });
-        test("should use maxLength when no attributes or pattern", () => {
-            const input = document.createElement("input");
-            input.maxLength = 7;
-            const result = getExpirationFormat(input);
-            expect(result).toEqual({ separator: "/", fullYear: true, monthFirst: true });
-        });
-        test("should use default when no indicators present", () => {
-            const input = document.createElement("input");
-            const result = getExpirationFormat(input);
-            expect(result).toEqual({ separator: "/", fullYear: false, monthFirst: true });
-        });
-        test("should handle outliers", () => {
-            const input = document.createElement("input");
-            input.pattern = "[-+]?[0-9]*[.,]?[0-9]+";
-            input.maxLength = 2;
-            input.autocomplete = "cc-exp-month";
-            input.ariaLabel = "month";
-            const result = getExpirationFormat(input, false);
-            expect(result).toEqual(undefined);
-        });
-        test("coursera.org > cc-exp format", () => {
-            document.body.innerHTML = `<div data-field="expiry" class="p-Field"><label class="p-FieldLabel Label Label--empty" for="Field-expiryInput">Expiration date<span class="FadeWrapper"></span><span class="u-visually-hidden"> MM / YY</span></label><div><div><div class="p-Input"><input dir="ltr" type="text" inputmode="numeric" name="expiry" id="Field-expiryInput" placeholder="MM / YY" autocomplete="cc-exp" aria-invalid="false" aria-describedby="Field-expiryError" aria-required="true" class="p-Input-input p-Fieldset-input Input Input--empty p-Input-input--textRight" value=""></div></div></div><div class="AnimateSinglePresence"></div></div>`;
-            const field = document.querySelector("select, input");
-            expect(getExpirationFormat(field, true)).toEqual({ fullYear: false, monthFirst: true, separator: "/" });
-        });
-    });
-    describe("getInputExpirationMonthFormat", () => {
-        test("tesco.com > padded cc-exp-month", () => {
-            document.body.innerHTML = `<fieldset class="Form__Fieldset-sc-1rpc86b-1 fKhXDo"><legend class="Label-sc-1wdkkfu-0 cEywXb ddl-label has-error">Expiry date</legend><label for="card-expiry-month" hidden="" class="Label-sc-1wdkkfu-0 mZWly sf-hidden">month</label><input type="tel" data-auto="card-expiry-month" name="expiryMonth" id="card-expiry-month" placeholder="MM" maxlength="2" aria-required="true" data-rule="expiryMonthRule" class="Input-sc-gj7hrn-1 expiry-date__ExpiryInput-sc-m6yl5f-0 bSmREw eDVddD has-error" data-errored="true" value="1"><span aria-hidden="true" class="expiry-date__ExpirySeparator-sc-m6yl5f-1 huzqtm">/</span></div></fieldset>`;
-            const field = document.querySelector("select, input");
-            expect(getInputExpirationMonthFormat(field)).toEqual({ padding: true });
-        });
-        test("orange.md > padded cc-exp-month", () => {
-            document.body.innerHTML = `<input name="validMONTH" id="expmonth" class="exp-input numberOnly" maxlength="2" tabindex="1" type="tel" placeholder="LL" required="" style="margin-right:10px" value="">`;
-            const field = document.querySelector("select, input");
-            expect(getInputExpirationMonthFormat(field)).toEqual({ padding: true });
-        });
-        test("iticket.md > padded cc-exp-month", () => {
-            document.body.innerHTML = `<div class="col-xs-6"><input name="validMONTH" id="expmonth" type="text" size="7" maxlength="2" autocomplete="off" pattern="\d*" value="1" placeholder="LL"><div class="image-help" style="display:none"></div></div>`;
-            const field = document.querySelector("select, input");
-            expect(getInputExpirationMonthFormat(field)).toEqual({ padding: true });
-        });
-    });
-    describe("formatExpirationDate", () => {
-        test.each([
-            { month: "01", year: "2025", format: { separator: "/", fullYear: false, monthFirst: true }, expected: "01/25" },
-            { month: "12", year: "2025", format: { separator: "-", fullYear: false, monthFirst: true }, expected: "12-25" },
-            { month: "03", year: "2025", format: { separator: "", fullYear: false, monthFirst: true }, expected: "0325" },
-            { month: "01", year: "2025", format: { separator: "/", fullYear: true, monthFirst: true }, expected: "01/2025" },
-            { month: "12", year: "2025", format: { separator: "-", fullYear: true, monthFirst: true }, expected: "12-2025" },
-            { month: "03", year: "2025", format: { separator: "", fullYear: true, monthFirst: true }, expected: "032025" },
-            { month: "01", year: "2025", format: { separator: "/", fullYear: false, monthFirst: false }, expected: "25/01" },
-            { month: "12", year: "2025", format: { separator: "-", fullYear: false, monthFirst: false }, expected: "25-12" },
-            { month: "03", year: "2025", format: { separator: "", fullYear: false, monthFirst: false }, expected: "2503" },
-            { month: "01", year: "2025", format: { separator: "/", fullYear: true, monthFirst: false }, expected: "2025/01" },
-            { month: "12", year: "2025", format: { separator: "-", fullYear: true, monthFirst: false }, expected: "2025-12" },
-            { month: "03", year: "2025", format: { separator: "", fullYear: true, monthFirst: false }, expected: "202503" },
-        ])('should format month="$month" year="$year" with format=$format.separator$format.yearDigits$format.monthFirst to "$expected"', ({ month, year, format, expected }) => {
-            const result = formatExpirationDate(month, year, format);
-            expect(result).toBe(expected);
-        });
-        test.each([
-            { month: "1", year: "2025", format: { separator: "/", fullYear: false, monthFirst: true }, expected: "01/25" },
-            { month: "2", year: "2025", format: { separator: "/", fullYear: false, monthFirst: true }, expected: "02/25" },
-            { month: "9", year: "2025", format: { separator: "/", fullYear: false, monthFirst: true }, expected: "09/25" },
-            { month: "10", year: "2025", format: { separator: "/", fullYear: false, monthFirst: true }, expected: "10/25" },
-            { month: "11", year: "2025", format: { separator: "/", fullYear: false, monthFirst: true }, expected: "11/25" },
-            { month: "12", year: "2025", format: { separator: "/", fullYear: false, monthFirst: true }, expected: "12/25" },
-        ])('should pad single digit month "$month" to two digits', ({ month, year, format, expected }) => {
-            const result = formatExpirationDate(month, year, format);
-            expect(result).toBe(expected);
-        });
-        test.each([
-            { year: "2020", expected: "20" },
-            { year: "2025", expected: "25" },
-            { year: "2030", expected: "30" },
-            { year: "2099", expected: "99" },
-            { year: "2000", expected: "00" },
-            { year: "2001", expected: "01" },
-        ])('should extract last 2 digits from 4-digit year "$year"', ({ year, expected }) => {
-            const format = { separator: "/", fullYear: false, monthFirst: true };
-            const result = formatExpirationDate("01", year, format);
-            expect(result).toBe(`01/${expected}`);
-        });
-        test.each([
-            { year: "2020", expected: "2020" },
-            { year: "2025", expected: "2025" },
-            { year: "2030", expected: "2030" },
-            { year: "2099", expected: "2099" },
-        ])('should keep all 4 digits for 4-digit year format "$year"', ({ year, expected }) => {
-            const format = { separator: "/", fullYear: true, monthFirst: true };
-            const result = formatExpirationDate("01", year, format);
-            expect(result).toBe(`01/${expected}`);
-        });
-    });
-    describe("Edge Cases and Integration", () => {
-        test("should handle case-insensitive attribute detection", () => {
-            const input = document.createElement("input");
-            input.placeholder = "mm/yyyy";
-            const result = getExpirationFormat(input);
-            expect(result).toEqual({ separator: "/", fullYear: true, monthFirst: true });
-        });
-        test("should combine multiple attributes", () => {
-            const input = document.createElement("input");
-            input.name = "expiry";
-            input.className = "mm-yyyy-format";
-            input.placeholder = "Enter MM-YYYY";
-            const result = getExpirationFormat(input);
-            expect(result === null || result === void 0 ? void 0 : result.separator).toBe("-");
-            expect(result === null || result === void 0 ? void 0 : result.fullYear).toBe(true);
-            expect(result === null || result === void 0 ? void 0 : result.monthFirst).toBe(true);
-        });
-        test("should handle whitespace in attributes", () => {
-            const input = document.createElement("input");
-            input.placeholder = "  MM / YYYY  ";
-            const result = getExpirationFormat(input);
-            expect(result === null || result === void 0 ? void 0 : result.separator).toBe("/");
-        });
-        test("should prefer first match when multiple formats present", () => {
-            const input = document.createElement("input");
-            input.placeholder = "MM/YY or MM-YYYY";
-            const result = getExpirationFormat(input);
-            expect(result === null || result === void 0 ? void 0 : result.separator).toBe("/");
-            expect(result === null || result === void 0 ? void 0 : result.fullYear).toBe(false);
-        });
-    });
-    describe("getSelectExpirationYearFormat", () => {
-        test.each([
-            { options: ["2024", "2025", "2026"], expected: { fullYear: true } },
-            { options: ["2023", "2024", "2025", "2026", "2027"], expected: { fullYear: true } },
-            { options: ["24", "25", "26"], expected: { fullYear: false } },
-            { options: ["23", "24", "25", "26", "27"], expected: { fullYear: false } },
-        ])("should detect format from options $options", ({ options, expected }) => {
-            const select = document.createElement("select");
-            options.forEach((value) => {
-                const option = document.createElement("option");
-                option.value = value;
-                select.appendChild(option);
-            });
-            expect(getSelectExpirationYearFormat(select)).toEqual(expected);
-        });
-        test.each([{ options: [] }, { options: ["", ""] }, { options: ["Select year", "Choose..."] }, { options: ["abc", "def"] }])("should noop for invalid options $options", ({ options }) => {
-            const select = document.createElement("select");
-            options.forEach((value) => {
-                const option = document.createElement("option");
-                option.value = value;
-                select.appendChild(option);
-            });
-            expect(getSelectExpirationYearFormat(select)).toBeUndefined();
-        });
-    });
-    describe("getSelectExpirationMonthFormat", () => {
-        test.each([
-            { options: ["01", "02", "03", "04", "05", "06"], expected: { padding: true } },
-            { options: ["01", "09", "10", "11", "12"], expected: { padding: true } },
-            { options: ["1", "2", "3", "4", "5", "6"], expected: { padding: false } },
-            { options: ["1", "9", "10", "11", "12"], expected: { padding: false } },
-        ])("should detect format from options $options", ({ options, expected }) => {
-            const select = document.createElement("select");
-            options.forEach((value) => {
-                const option = document.createElement("option");
-                option.value = value;
-                select.appendChild(option);
-            });
-            expect(getSelectExpirationMonthFormat(select)).toEqual(expected);
-        });
-        test.each([{ options: [] }, { options: ["", ""] }, { options: ["Select month", "Choose..."] }, { options: ["abc", "def"] }])("should return noop for invalid options $options", ({ options }) => {
-            const select = document.createElement("select");
-            options.forEach((value) => {
-                const option = document.createElement("option");
-                option.value = value;
-                select.appendChild(option);
-            });
-            expect(getSelectExpirationMonthFormat(select)).toBeUndefined();
-        });
-    });
-});

package/utils/identity.samples.spec.d.ts

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

package/utils/identity.samples.spec.js

@@ -1,28 +0,0 @@
-import { IdentityFieldType } from "@protontech/autofill/types";
-import { getIdentityFieldType } from "./identity";
-const fieldTest = (type, samples) => {
-    test.each(samples.map((html) => ({ html, preview: html.substring(0, 42) })))("$preview", ({ html }) => {
-        document.body.innerHTML = html;
-        const field = document.querySelector("input");
-        expect(getIdentityFieldType(field)).toBe(type);
-    });
-};
-Object.defineProperty(HTMLElement.prototype, "innerText", {
-    get() {
-        return this.textContent;
-    },
-});
-describe("Identity field samples", () => {
-    describe("IdentityFieldType.FIRSTNAME", () => {
-        const samples = [
-            `<div class="sc-d9ebd515-0 hLmoFN"><label data-ignore-a11y="true" for="shipping_firstname" id="shipping_firstname-label" class="sc-94eb08bc-0 bfsAop sc-d9ebd515-1 dIGbxh">Nombre</label><input autocomplete="on" name="shipping_firstname" maxlength="50" id="shipping_firstname" type="text" aria-invalid="true" aria-required="false" aria-disabled="false" data-test="shipping_firstname" class="sc-7af5671c-1 boqXeD" value=""></div>`,
-        ];
-        fieldTest(IdentityFieldType.FIRSTNAME, samples);
-    });
-    describe.only("IdentityFieldType.TELEPHONE", () => {
-        const samples = [
-            `<div class="sc-d9ebd515-0 hLmoFN"><label data-ignore-a11y="true" for=":rp:" id=":rp:-label" class="sc-94eb08bc-0 dEnlRJ sc-d9ebd515-1 hfkVHI">Número de teléfono.</label><input name="shipping_phoneNumber" autocomplete="on" id=":rp:" placeholder="" type="tel" aria-invalid="true" aria-required="false" aria-disabled="false" aria-describedby=":rp:-help" data-test="shipping_phoneNumber" class="sc-7af5671c-2 iteJpf" value="+34 "></div>`,
-        ];
-        fieldTest(IdentityFieldType.TELEPHONE, samples);
-    });
-});

package/utils/re.spec.d.ts

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

package/utils/re.spec.js

@@ -1,62 +0,0 @@
-import * as matchers from "./re";
-const getRandomString = (length) => {
-    const charList = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()_+-={}[]|:;\"'<>,.?/~ `";
-    return Array.from({ length }, () => charList.charAt(Math.floor(Math.random() * charList.length))).join("");
-};
-const executionTime = (cb) => {
-    const start = performance.now();
-    cb();
-    return performance.now() - start;
-};
-const STR_TEST_LENGTHS = [25, 50, 100, 250, 500, 1000, 10000, 100000];
-const MAX_EXPECTED_REG_EXEC_TIME = 100;
-const MATCHERS = [
-    "matchCaptcha",
-    "matchConfirmAction",
-    "matchCreateAction",
-    "matchEmail",
-    "matchEmailAttr",
-    "matchEmailValue",
-    "matchHidden",
-    "matchLogin",
-    "matchTwoFa",
-    "matchMFA",
-    "matchMultiStep",
-    "matchNewsletter",
-    "matchNewsletterAttr",
-    "matchOAuth",
-    "matchOtpAttr",
-    "matchOtpOutlier",
-    "matchPasswordConfirm",
-    "matchPasswordCreate",
-    "matchPasswordCreateAttr",
-    "matchPasswordCurrent",
-    "matchPasswordCurrentAttr",
-    "matchPasswordOutlier",
-    "matchPasswordReset",
-    "matchPasswordResetAttr",
-    "matchRecovery",
-    "matchRegister",
-    "matchRememberMe",
-    "matchSearchAction",
-    "matchStepAction",
-    "matchTOS",
-    "matchTel",
-    "matchTelValue",
-    "matchTrouble",
-    "matchUsername",
-    "matchUsernameAttr",
-    "matchUsernameOutlier",
-    "matchUsernameValue",
-];
-describe("regex performance tests", () => {
-    MATCHERS.forEach((matcher) => {
-        describe(`${matcher}`, () => {
-            STR_TEST_LENGTHS.forEach((length) => {
-                test(`string of ${length} chars under 100ms`, () => {
-                    expect(executionTime(() => matchers[matcher](getRandomString(length)))).toBeLessThan(MAX_EXPECTED_REG_EXEC_TIME);
-                });
-            });
-        });
-    });
-});

package/utils/shadow-dom.spec.d.ts

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

package/utils/shadow-dom.spec.js

@@ -1,215 +0,0 @@
-import { isShadowElement, shadowPiercingAncestors, shadowPiercingContains, shallowShadowQuerySelector } from "./shadow-dom";
-class WrapperComponent extends HTMLElement {
-    constructor() {
-        super();
-        const shadow = this.attachShadow({ mode: "open" });
-        shadow.innerHTML = `
-      <div class="wrapper">
-        <slot name="header"></slot>
-        <div class="content">
-          <p class="text">Shadow content</p>
-          <slot></slot>
-        </div>
-      </div>
-    `;
-    }
-}
-class NestedComponent extends HTMLElement {
-    constructor() {
-        super();
-        const shadow = this.attachShadow({ mode: "open" });
-        shadow.innerHTML = `
-      <div class="outer">
-        <wrapper-component>
-          <span class="nested-content">Nested content</span>
-        </wrapper-component>
-      </div>
-    `;
-    }
-}
-class CardComponent extends HTMLElement {
-    constructor() {
-        super();
-        const shadow = this.attachShadow({ mode: "open" });
-        shadow.innerHTML = `
-      <div class="card">
-        <div class="card-header">
-          <slot name="header"></slot>
-        </div>
-        <div class="card-body">
-          <slot></slot>
-        </div>
-      </div>
-    `;
-    }
-}
-class CustomInput extends HTMLElement {
-    constructor() {
-        super();
-        const shadow = this.attachShadow({ mode: "open" });
-        shadow.innerHTML = `
-      <div class="input-wrapper">
-        <input type="text" class="actual-input">
-        <div class="validation-message"></div>
-      </div>
-    `;
-    }
-}
-customElements.define("wrapper-component", WrapperComponent);
-customElements.define("nested-component", NestedComponent);
-customElements.define("custom-input", CustomInput);
-customElements.define("card-component", CardComponent);
-describe("Shadow DOM Utilities", () => {
-    let container;
-    beforeEach(() => {
-        document.body.innerHTML = "";
-        container = document.createElement("div");
-        container.id = "container";
-        document.body.appendChild(container);
-    });
-    describe("`isShadowElement`", () => {
-        test("should detect elements inside custom element shadow DOM", () => {
-            var _a;
-            container.innerHTML = `<wrapper-component></wrapper-component>`;
-            const component = container.querySelector("wrapper-component");
-            const shadowText = (_a = component === null || component === void 0 ? void 0 : component.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(".text");
-            expect(isShadowElement(shadowText)).toBe(true);
-        });
-        test("should return `false` for custom element host", () => {
-            container.innerHTML = `<wrapper-component></wrapper-component>`;
-            const component = container.querySelector("wrapper-component");
-            expect(isShadowElement(component)).toBe(false);
-        });
-    });
-    describe("`shadowPiercingAncestors`", () => {
-        test("should traverse from shadow content to light DOM", () => {
-            var _a;
-            container.innerHTML = `<wrapper-component></wrapper-component>`;
-            const component = container.querySelector("wrapper-component");
-            const shadowText = (_a = component === null || component === void 0 ? void 0 : component.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(".text");
-            const ancestors = Array.from(shadowPiercingAncestors(shadowText));
-            const expected = [HTMLParagraphElement, HTMLDivElement, HTMLDivElement, WrapperComponent, HTMLDivElement, HTMLBodyElement, HTMLHtmlElement];
-            expect(ancestors[0]).toBe(shadowText);
-            expect(ancestors.length).toEqual(expected.length);
-            expected.forEach((instance, idx) => expect(ancestors[idx]).toBeInstanceOf(instance));
-        });
-        test("should handle nested custom elements", () => {
-            var _a, _b;
-            container.innerHTML = `<nested-component></nested-component>`;
-            const outerComponent = container.querySelector("nested-component");
-            const innerComponent = (_a = outerComponent === null || outerComponent === void 0 ? void 0 : outerComponent.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector("wrapper-component");
-            const nestedContent = (_b = innerComponent === null || innerComponent === void 0 ? void 0 : innerComponent.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector(".text");
-            const ancestors = Array.from(shadowPiercingAncestors(nestedContent));
-            const expected = [HTMLParagraphElement, HTMLDivElement, HTMLDivElement, WrapperComponent, HTMLDivElement, NestedComponent, HTMLDivElement, HTMLBodyElement, HTMLHtmlElement];
-            expect(ancestors[0]).toBe(nestedContent);
-            expect(ancestors.length).toEqual(expected.length);
-            expected.forEach((instance, idx) => expect(ancestors[idx]).toBeInstanceOf(instance));
-        });
-        test("should handle slotted content", () => {
-            container.innerHTML = `
-        <wrapper-component>
-          <span class="slotted">Slotted content</span>
-        </wrapper-component>
-      `;
-            const slottedContent = container.querySelector(".slotted");
-            const ancestors = Array.from(shadowPiercingAncestors(slottedContent));
-            const expected = [HTMLSpanElement, WrapperComponent, HTMLDivElement, HTMLBodyElement, HTMLHtmlElement];
-            expect(ancestors[0]).toBe(slottedContent);
-            expect(ancestors.length).toEqual(expected.length);
-            expected.forEach((instance, idx) => expect(ancestors[idx]).toBeInstanceOf(instance));
-        });
-    });
-    describe("`shadowPiercingContains`", () => {
-        test("should find containment across custom element boundaries", () => {
-            var _a;
-            container.innerHTML = `<wrapper-component></wrapper-component>`;
-            const component = container.querySelector("wrapper-component");
-            const shadowText = (_a = component === null || component === void 0 ? void 0 : component.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(".text");
-            expect(shadowPiercingContains(container, shadowText)).toBe(true);
-            expect(shadowPiercingContains(component, shadowText)).toBe(true);
-        });
-        test("should work with nested custom elements", () => {
-            var _a, _b;
-            container.innerHTML = `<nested-component></nested-component>`;
-            const outerComponent = container.querySelector("nested-component");
-            const innerComponent = (_a = outerComponent === null || outerComponent === void 0 ? void 0 : outerComponent.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector("wrapper-component");
-            const deepContent = (_b = innerComponent === null || innerComponent === void 0 ? void 0 : innerComponent.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector(".text");
-            expect(shadowPiercingContains(container, deepContent)).toBe(true);
-            expect(shadowPiercingContains(outerComponent, deepContent)).toBe(true);
-        });
-        test("should handle mixed light/shadow DOM", () => {
-            var _a;
-            container.innerHTML = `
-        <div class="wrapper">
-          <wrapper-component></wrapper-component>
-        </div>
-      `;
-            const wrapper = container.querySelector(".wrapper");
-            const component = wrapper === null || wrapper === void 0 ? void 0 : wrapper.querySelector("wrapper-component");
-            const shadowContent = (_a = component === null || component === void 0 ? void 0 : component.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(".content");
-            expect(shadowPiercingContains(container, shadowContent)).toBe(true);
-            expect(shadowPiercingContains(wrapper, shadowContent)).toBe(true);
-        });
-    });
-    describe("`shallowShadowQuerySelector`", () => {
-        test("should find elements in custom element shadow DOM", () => {
-            var _a;
-            container.innerHTML = `<wrapper-component></wrapper-component>`;
-            const component = container.querySelector("wrapper-component");
-            const result = shallowShadowQuerySelector(component, ".text");
-            const expected = (_a = component === null || component === void 0 ? void 0 : component.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(".text");
-            expect(result).toBe(expected);
-        });
-        test("should prioritize light DOM over shadow DOM in custom elements", () => {
-            container.innerHTML = `
-        <wrapper-component>
-          <p class="text">Light DOM text</p>
-        </wrapper-component>
-      `;
-            const component = container.querySelector("wrapper-component");
-            const result = shallowShadowQuerySelector(component, ".text");
-            expect(result === null || result === void 0 ? void 0 : result.textContent).toBe("Light DOM text");
-        });
-        test("should fall back to shadow DOM when not found in light DOM", () => {
-            var _a;
-            container.innerHTML = `<wrapper-component></wrapper-component>`;
-            const component = container.querySelector("wrapper-component");
-            const result = shallowShadowQuerySelector(component, ".wrapper");
-            const expected = (_a = component === null || component === void 0 ? void 0 : component.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(".wrapper");
-            expect(result).toBe(expected);
-        });
-    });
-    describe("Real-world scenarios", () => {
-        test("should handle form controls with shadow DOM", () => {
-            var _a;
-            container.innerHTML = `
-        <form>
-          <custom-input></custom-input>
-        </form>
-      `;
-            const form = container.querySelector("form");
-            const customInput = form === null || form === void 0 ? void 0 : form.querySelector("custom-input");
-            const actualInput = (_a = customInput === null || customInput === void 0 ? void 0 : customInput.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(".actual-input");
-            expect(shadowPiercingContains(form, actualInput)).toBe(true);
-            expect(shadowPiercingContains(container, actualInput)).toBe(true);
-        });
-        test("should work with component composition", () => {
-            var _a;
-            container.innerHTML = `
-        <card-component>
-          <h2 slot="header">Title</h2>
-          <wrapper-component></wrapper-component>
-        </card-component>
-      `;
-            const card = container.querySelector("card-component");
-            const wrapper = card === null || card === void 0 ? void 0 : card.querySelector("wrapper-component");
-            const shadowText = (_a = wrapper === null || wrapper === void 0 ? void 0 : wrapper.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(".text");
-            const ancestors = Array.from(shadowPiercingAncestors(shadowText));
-            const expected = [HTMLParagraphElement, HTMLDivElement, HTMLDivElement, WrapperComponent, CardComponent, HTMLDivElement, HTMLBodyElement, HTMLHtmlElement];
-            expect(ancestors.length).toEqual(expected.length);
-            expected.forEach((instance, idx) => expect(ancestors[idx]).toBeInstanceOf(instance));
-            expect(shadowPiercingContains(container, shadowText)).toBe(true);
-            expect(shadowPiercingContains(card, shadowText)).toBe(true);
-        });
-    });
-});