@rededor/cura 2.0.0-alpha.12 → 2.0.0-alpha.13

package/dist/cjs/index.cjs.js

@@ -4,6 +4,1146 @@ var curaThemeModule = require('./cura-theme-module-Dg1d3VUN.js');
 require('./theme-legacy-default-COE-hjD7.js');
 require('./static-DHz-FA_O.js');
 
+/**
+ * This file contains the WeakMaps used throughout this project. The WeakMaps exist to tie
+ * objects together without polluting the objects themselves with references we'd rather keep
+ * hidden. This allows the polyfill to work as transparently as possible.
+ */
+/** Use an ElementInternals instance to get a reference to the element it is attached to */
+const refMap = new WeakMap();
+/** Usee an ElementsInternals instance to get its ValidityState object */
+const validityMap = new WeakMap();
+/** Use an ElementInternals instance to get its attached input[type="hidden"] */
+const hiddenInputMap = new WeakMap();
+/** Use a custom element to get its attached ElementInternals instance */
+const internalsMap = new WeakMap();
+/** Use an ElementInternals instance to get the attached validation message */
+const validationMessageMap = new WeakMap();
+/** Use a form element to get attached custom elements and ElementInternals instances */
+const formsMap = new WeakMap();
+/** Use a custom element or other object to get their associated MutationObservers */
+const shadowHostsMap = new WeakMap();
+/** Use a form element to get a set of attached custom elements */
+const formElementsMap = new WeakMap();
+/** Use an ElementInternals instance to get a reference to an element's value */
+const refValueMap = new WeakMap();
+/** Elements that need to be upgraded once added to the DOM */
+const upgradeMap = new WeakMap();
+/** Save references to shadow roots for inclusion in internals instance */
+const shadowRootMap = new WeakMap();
+/** Save a reference to the internals' validation anchor */
+const validationAnchorMap = new WeakMap();
+/** Map DocumentFragments to their MutationObservers so we can disconnect once elements are removed */
+const documentFragmentMap = new WeakMap();
+/** Whether connectedCallback has already been called. */
+const connectedCallbackMap = new WeakMap();
+/** Save a reference to validity state for elements that need to upgrade after being connected */
+const validityUpgradeMap = new WeakMap();
+
+/**
+ * Set attribute if its value differs from existing one.
+ *
+ * In comparison to other attribute modification methods (removeAttribute and
+ * toggleAttribute), setAttribute always triggers attributeChangedCallback
+ * even if the actual value has not changed.
+ *
+ * This polyfill relies heavily on attributes to pass aria information to
+ * screen readers. This behaviour differs from native implementation which does
+ * not change attributes.
+ *
+ * To limit this difference we only set attribute value when it is different
+ * from the current state.
+ *
+ * @param {ICustomElement | Element} ref - The custom element instance
+ * @param {string} name - The attribute name
+ * @param {string} value - The attribute value
+ * @returns
+ */
+const setAttribute = (ref, name, value) => {
+    if (ref.getAttribute(name) === value) {
+        return;
+    }
+    ref.setAttribute(name, value);
+};
+/**
+ * Toggle's the disabled state (attributes & callback) on the given element
+ * @param {HTMLElement} ref - The custom element instance
+ * @param {boolean} disabled - The disabled state
+ */
+const setDisabled = (ref, disabled) => {
+    ref.toggleAttribute("internals-disabled", disabled);
+    if (disabled) {
+        setAttribute(ref, "aria-disabled", "true");
+    }
+    else {
+        ref.removeAttribute("aria-disabled");
+    }
+    if (ref.formDisabledCallback) {
+        ref.formDisabledCallback.apply(ref, [disabled]);
+    }
+};
+/**
+ * Removes all hidden inputs for the given element internals instance
+ * @param {ElementInternals} internals - The element internals instance
+ * @return {void}
+ */
+const removeHiddenInputs = (internals) => {
+    const hiddenInputs = hiddenInputMap.get(internals);
+    hiddenInputs.forEach((hiddenInput) => {
+        hiddenInput.remove();
+    });
+    hiddenInputMap.set(internals, []);
+};
+/**
+ * Creates a hidden input for the given ref
+ * @param {HTMLElement} ref - The element to watch
+ * @param {ElementInternals} internals - The element internals instance for the ref
+ * @return {HTMLInputElement} The hidden input
+ */
+const createHiddenInput = (ref, internals) => {
+    const input = document.createElement("input");
+    input.type = "hidden";
+    input.name = ref.getAttribute("name");
+    ref.after(input);
+    hiddenInputMap.get(internals).push(input);
+    return input;
+};
+/**
+ * Set up labels for the ref
+ * @param {HTMLElement} ref - The ref to add labels to
+ * @param {NodeList} labels - A list of the labels
+ * @return {void}
+ */
+const initLabels = (ref, labels) => {
+    if (labels.length) {
+        const labelList = Array.from(labels);
+        labelList.forEach((label) => label.addEventListener("click", ref.click.bind(ref)));
+        const [firstLabel] = labelList;
+        let firstLabelId = firstLabel.id;
+        if (!firstLabel.id) {
+            firstLabelId = `${firstLabel.htmlFor}_Label`;
+            firstLabel.id = firstLabelId;
+        }
+        setAttribute(ref, "aria-labelledby", firstLabelId);
+    }
+};
+/**
+ * Sets the internals-valid and internals-invalid attributes
+ * based on form validity.
+ * @param {HTMLFormElement} - The target form
+ * @return {void}
+ */
+const setFormValidity = (form) => {
+    const nativeControlValidity = Array.from(form.elements)
+        .filter((element) => !element.tagName.includes("-") && element.validity)
+        .map((element) => element.validity.valid);
+    const polyfilledElements = formElementsMap.get(form) || [];
+    const polyfilledValidity = Array.from(polyfilledElements)
+        .filter((control) => control.isConnected)
+        .map((control) => internalsMap.get(control).validity.valid);
+    const hasInvalid = [...nativeControlValidity, ...polyfilledValidity].includes(false);
+    form.toggleAttribute("internals-invalid", hasInvalid);
+    form.toggleAttribute("internals-valid", !hasInvalid);
+};
+/**
+ * The global form input callback. Updates the form's validity
+ * attributes on input.
+ * @param {Event} - The form input event
+ * @return {void}
+ */
+const formInputCallback = (event) => {
+    setFormValidity(findParentForm(event.target));
+};
+/**
+ * The global form change callback. Updates the form's validity
+ * attributes on change.
+ * @param {Event} - The form change event
+ * @return {void}
+ */
+const formChangeCallback = (event) => {
+    setFormValidity(findParentForm(event.target));
+};
+/**
+ * The global form submit callback. We need to cancel any submission
+ * if a nested internals is invalid.
+ * @param {HTMLFormElement} - The form element
+ * @return {void}
+ */
+const wireSubmitLogic = (form) => {
+    const submitButtonSelector = [
+        "button[type=submit]",
+        "input[type=submit]",
+        "button:not([type])",
+    ]
+        .map((sel) => `${sel}:not([disabled])`)
+        .map((sel) => `${sel}:not([form])${form.id ? `,${sel}[form='${form.id}']` : ""}`)
+        .join(",");
+    form.addEventListener("click", (event) => {
+        const target = event.target;
+        if (target.closest(submitButtonSelector)) {
+            // validate
+            const elements = formElementsMap.get(form);
+            /**
+             * If this form does not validate then we're done
+             */
+            if (form.noValidate) {
+                return;
+            }
+            /** If the Set has items, continue */
+            if (elements.size) {
+                const nodes = Array.from(elements);
+                /** Check the internals.checkValidity() of all nodes */
+                const validityList = nodes.reverse().map((node) => {
+                    const internals = internalsMap.get(node);
+                    return internals.reportValidity();
+                });
+                /** If any node is false, stop the event */
+                if (validityList.includes(false)) {
+                    event.preventDefault();
+                }
+            }
+        }
+    });
+};
+/**
+ * The global form reset callback. This will loop over added
+ * inputs and call formResetCallback if applicable
+ * @return {void}
+ */
+const formResetCallback = (event) => {
+    /** Get the Set of elements attached to this form */
+    const elements = formElementsMap.get(event.target);
+    /** Some forms won't contain form associated custom elements */
+    if (elements && elements.size) {
+        /** Loop over the elements and call formResetCallback if applicable */
+        elements.forEach((element) => {
+            if (element.constructor.formAssociated &&
+                element.formResetCallback) {
+                element.formResetCallback.apply(element);
+            }
+        });
+    }
+};
+/**
+ * Initialize the form. We will need to add submit and reset listeners
+ * if they don't already exist. If they do, just add the new ref to the form.
+ * @param {HTMLElement} ref - The element ref that includes internals
+ * @param {HTMLFormElement} form - The form the ref belongs to
+ * @param {ElementInternals} internals - The internals for ref
+ * @return {void}
+ */
+const initForm = (ref, form, internals) => {
+    if (form) {
+        /** This will be a WeakMap<HTMLFormElement, Set<HTMLElement> */
+        const formElements = formElementsMap.get(form);
+        if (formElements) {
+            /** If formElements exists, add to it */
+            formElements.add(ref);
+        }
+        else {
+            /** If formElements doesn't exist, create it and add to it */
+            const initSet = new Set();
+            initSet.add(ref);
+            formElementsMap.set(form, initSet);
+            /** Add listeners to emulate validation and reset behavior */
+            wireSubmitLogic(form);
+            form.addEventListener("reset", formResetCallback);
+            form.addEventListener("input", formInputCallback);
+            form.addEventListener("change", formChangeCallback);
+        }
+        formsMap.set(form, { ref, internals });
+        /** Call formAssociatedCallback if applicable */
+        if (ref.constructor["formAssociated"] && ref.formAssociatedCallback) {
+            setTimeout(() => {
+                ref.formAssociatedCallback.apply(ref, [form]);
+            }, 0);
+        }
+        setFormValidity(form);
+    }
+};
+/**
+ * Recursively look for an element's parent form
+ * @param {Element} elem - The element to look for a parent form
+ * @return {HTMLFormElement|null} - The parent form, if one exists
+ */
+const findParentForm = (elem) => {
+    let parent = elem.parentNode;
+    if (parent && parent.tagName !== "FORM") {
+        parent = findParentForm(parent);
+    }
+    return parent;
+};
+/**
+ * Throw an error if the element ref is not form associated
+ * @param ref {HTMLElement} - The element to check if it is form associated
+ * @param message {string} - The error message to throw
+ * @param ErrorType {any} - The error type to throw, defaults to DOMException
+ */
+const throwIfNotFormAssociated = (ref, message, ErrorType = DOMException) => {
+    if (!ref.constructor["formAssociated"]) {
+        throw new ErrorType(message);
+    }
+};
+/**
+ * Called for each HTMLFormElement.checkValidity|reportValidity
+ * will loop over a form's added components and call the respective
+ * method modifying the default return value if needed
+ * @param form {HTMLFormElement} - The form element to run the method on
+ * @param returnValue {boolean} - The initial result of the original method
+ * @param method {'checkValidity'|'reportValidity'} - The original method
+ * @returns {boolean} The form's validity state
+ */
+const overrideFormMethod = (form, returnValue, method) => {
+    const elements = formElementsMap.get(form);
+    /** Some forms won't contain form associated custom elements */
+    if (elements && elements.size) {
+        elements.forEach((element) => {
+            const internals = internalsMap.get(element);
+            const valid = internals[method]();
+            if (!valid) {
+                returnValue = false;
+            }
+        });
+    }
+    return returnValue;
+};
+/**
+ * Will upgrade an ElementInternals instance by initializing the
+ * instance's form and labels. This is called when the element is
+ * either constructed or appended from a DocumentFragment
+ * @param ref {HTMLElement} - The custom element to upgrade
+ */
+const upgradeInternals = (ref) => {
+    let attached = false;
+    if (ref.constructor["formAssociated"]) {
+        let internals = internalsMap.get(ref);
+        // we might have cases where the internals are not set
+        if (internals === undefined) {
+            ref.attachInternals();
+            internals = internalsMap.get(ref);
+            attached = true;
+        }
+        const { labels, form } = internals;
+        initLabels(ref, labels);
+        initForm(ref, form, internals);
+    }
+    return attached;
+};
+/**
+ * Check to see if MutationObserver exists in the current
+ * execution context. Will likely return false on the server
+ * @returns {boolean}
+ */
+function mutationObserverExists() {
+    return typeof MutationObserver !== "undefined";
+}
+
+const aom = {
+    ariaAtomic: "aria-atomic",
+    ariaAutoComplete: "aria-autocomplete",
+    ariaBrailleLabel: "aria-braillelabel",
+    ariaBrailleRoleDescription: "aria-brailleroledescription",
+    ariaBusy: "aria-busy",
+    ariaChecked: "aria-checked",
+    ariaColCount: "aria-colcount",
+    ariaColIndex: "aria-colindex",
+    ariaColIndexText: "aria-colindextext",
+    ariaColSpan: "aria-colspan",
+    ariaCurrent: "aria-current",
+    ariaDescription: "aria-description",
+    ariaDisabled: "aria-disabled",
+    ariaExpanded: "aria-expanded",
+    ariaHasPopup: "aria-haspopup",
+    ariaHidden: "aria-hidden",
+    ariaInvalid: "aria-invalid",
+    ariaKeyShortcuts: "aria-keyshortcuts",
+    ariaLabel: "aria-label",
+    ariaLevel: "aria-level",
+    ariaLive: "aria-live",
+    ariaModal: "aria-modal",
+    ariaMultiLine: "aria-multiline",
+    ariaMultiSelectable: "aria-multiselectable",
+    ariaOrientation: "aria-orientation",
+    ariaPlaceholder: "aria-placeholder",
+    ariaPosInSet: "aria-posinset",
+    ariaPressed: "aria-pressed",
+    ariaReadOnly: "aria-readonly",
+    ariaRelevant: "aria-relevant",
+    ariaRequired: "aria-required",
+    ariaRoleDescription: "aria-roledescription",
+    ariaRowCount: "aria-rowcount",
+    ariaRowIndex: "aria-rowindex",
+    ariaRowIndexText: "aria-rowindextext",
+    ariaRowSpan: "aria-rowspan",
+    ariaSelected: "aria-selected",
+    ariaSetSize: "aria-setsize",
+    ariaSort: "aria-sort",
+    ariaValueMax: "aria-valuemax",
+    ariaValueMin: "aria-valuemin",
+    ariaValueNow: "aria-valuenow",
+    ariaValueText: "aria-valuetext",
+    role: "role",
+};
+const initAom = (ref, internals) => {
+    for (let key in aom) {
+        internals[key] = null;
+        let closureValue = null;
+        const attributeName = aom[key];
+        Object.defineProperty(internals, key, {
+            get() {
+                return closureValue;
+            },
+            set(value) {
+                closureValue = value;
+                if (ref.isConnected) {
+                    setAttribute(ref, attributeName, value);
+                }
+                else {
+                    upgradeMap.set(ref, internals);
+                }
+            },
+        });
+    }
+};
+
+/**
+ * Initialize a ref by setting up an attribute observe on it
+ * looking for changes to disabled
+ * @param {HTMLElement} ref - The element to watch
+ * @param {ElementInternals} internals - The element internals instance for the ref
+ * @return {void}
+ */
+const initRef = (ref, internals) => {
+    hiddenInputMap.set(internals, []);
+    disabledOrNameObserver.observe?.(ref, disabledOrNameObserverConfig);
+};
+function initNode(node) {
+    const internals = internalsMap.get(node);
+    const { form } = internals;
+    initForm(node, form, internals);
+    initLabels(node, internals.labels);
+}
+/**
+ * If a fieldset's disabled state is toggled, the formDisabledCallback
+ * on any child form-associated cusotm elements.
+ */
+const walkFieldset = (node, firstRender = false) => {
+    const walker = document.createTreeWalker(node, NodeFilter.SHOW_ELEMENT, {
+        acceptNode(node) {
+            return internalsMap.has(node) ?
+                NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+        }
+    });
+    let current = walker.nextNode();
+    /**
+     * We don't need to call anything on first render if
+     * the element isn't disabled
+     */
+    const isCallNecessary = (!firstRender || node.disabled);
+    while (current) {
+        if (current.formDisabledCallback && isCallNecessary) {
+            setDisabled(current, node.disabled);
+        }
+        current = walker.nextNode();
+    }
+};
+const disabledOrNameObserverConfig = { attributes: true, attributeFilter: ['disabled', 'name'] };
+const disabledOrNameObserver = mutationObserverExists() ? new MutationObserver((mutationsList) => {
+    for (const mutation of mutationsList) {
+        const target = mutation.target;
+        /** Manage changes to the ref's disabled state */
+        if (mutation.attributeName === 'disabled') {
+            if (target.constructor['formAssociated']) {
+                setDisabled(target, target.hasAttribute('disabled'));
+            }
+            else if (target.localName === 'fieldset') {
+                /**
+                 * Repurpose the observer for fieldsets which need
+                 * to be walked whenever the disabled attribute is set
+                 */
+                walkFieldset(target);
+            }
+        }
+        /** Manage changes to the ref's name */
+        if (mutation.attributeName === 'name') {
+            if (target.constructor['formAssociated']) {
+                const internals = internalsMap.get(target);
+                const value = refValueMap.get(target);
+                internals.setFormValue(value);
+            }
+        }
+    }
+}) : {};
+function observerCallback(mutationList) {
+    mutationList.forEach(mutationRecord => {
+        const { addedNodes, removedNodes } = mutationRecord;
+        const added = Array.from(addedNodes);
+        const removed = Array.from(removedNodes);
+        added.forEach(node => {
+            /** Allows for dynamic addition of elements to forms */
+            if (internalsMap.has(node) && node.constructor['formAssociated']) {
+                initNode(node);
+            }
+            /** Upgrade the accessibility information on any previously connected */
+            if (upgradeMap.has(node)) {
+                const internals = upgradeMap.get(node);
+                const aomKeys = Object.keys(aom);
+                aomKeys
+                    .filter(key => internals[key] !== null)
+                    .forEach(key => {
+                    setAttribute(node, aom[key], internals[key]);
+                });
+                upgradeMap.delete(node);
+            }
+            /** Upgrade the validity state when the element is connected */
+            if (validityUpgradeMap.has(node)) {
+                const internals = validityUpgradeMap.get(node);
+                setAttribute(node, 'internals-valid', internals.validity.valid.toString());
+                setAttribute(node, 'internals-invalid', (!internals.validity.valid).toString());
+                setAttribute(node, 'aria-invalid', (!internals.validity.valid).toString());
+                validityUpgradeMap.delete(node);
+            }
+            /** If the node that's added is a form, check the validity */
+            if (node.localName === 'form') {
+                const formElements = formElementsMap.get(node);
+                const walker = document.createTreeWalker(node, NodeFilter.SHOW_ELEMENT, {
+                    acceptNode(node) {
+                        return (internalsMap.has(node) && node.constructor['formAssociated'] && !(formElements && formElements.has(node))) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+                    }
+                });
+                let current = walker.nextNode();
+                while (current) {
+                    initNode(current);
+                    current = walker.nextNode();
+                }
+            }
+            if (node.localName === 'fieldset') {
+                disabledOrNameObserver.observe?.(node, disabledOrNameObserverConfig);
+                walkFieldset(node, true);
+            }
+        });
+        removed.forEach(node => {
+            const internals = internalsMap.get(node);
+            /** Clean up any hidden input elements left after an element is disconnected */
+            if (internals && hiddenInputMap.get(internals)) {
+                removeHiddenInputs(internals);
+            }
+            /** Disconnect any unneeded MutationObservers */
+            if (shadowHostsMap.has(node)) {
+                const observer = shadowHostsMap.get(node);
+                observer.disconnect();
+            }
+        });
+    });
+}
+/**
+ * This observer callback is just for document fragments
+ * it will upgrade an ElementInternals instance if was appended
+ * from a document fragment.
+ */
+function fragmentObserverCallback(mutationList) {
+    mutationList.forEach(mutation => {
+        const { removedNodes } = mutation;
+        removedNodes.forEach(node => {
+            const observer = documentFragmentMap.get(mutation.target);
+            if (internalsMap.has(node)) {
+                upgradeInternals(node);
+            }
+            observer.disconnect();
+        });
+    });
+}
+/**
+ * Defer the upgrade of nodes withing a DocumentFragment
+ * @param fragment {DocumentFragment}
+ */
+const deferUpgrade = (fragment) => {
+    const observer = new MutationObserver(fragmentObserverCallback);
+    // is this using shady DOM and is not actually a DocumentFragment?
+    if (window?.ShadyDOM?.inUse &&
+        fragment.mode &&
+        fragment.host) {
+        // using shady DOM polyfill. Best to just observe the host.
+        fragment = fragment.host;
+    }
+    observer.observe?.(fragment, { childList: true });
+    documentFragmentMap.set(fragment, observer);
+};
+mutationObserverExists() ? new MutationObserver(observerCallback) : {};
+const observerConfig = {
+    childList: true,
+    subtree: true
+};
+
+/** Emulate the browser's default ValidityState object */
+class ValidityState {
+    constructor() {
+        this.badInput = false;
+        this.customError = false;
+        this.patternMismatch = false;
+        this.rangeOverflow = false;
+        this.rangeUnderflow = false;
+        this.stepMismatch = false;
+        this.tooLong = false;
+        this.tooShort = false;
+        this.typeMismatch = false;
+        this.valid = true;
+        this.valueMissing = false;
+        Object.seal(this);
+    }
+}
+/**
+ * Reset a ValidityState object back to valid
+ * @param {ValidityState} validityObject - The object to modify
+ * @return {ValidityState} - The modified ValidityStateObject
+ */
+const setValid = (validityObject) => {
+    validityObject.badInput = false;
+    validityObject.customError = false;
+    validityObject.patternMismatch = false;
+    validityObject.rangeOverflow = false;
+    validityObject.rangeUnderflow = false;
+    validityObject.stepMismatch = false;
+    validityObject.tooLong = false;
+    validityObject.tooShort = false;
+    validityObject.typeMismatch = false;
+    validityObject.valid = true;
+    validityObject.valueMissing = false;
+    return validityObject;
+};
+/**
+ * Reconcile a ValidityState object with a new state object
+ * @param {ValidityState} - The base object to reconcile with new state
+ * @param {Object} - A partial ValidityState object to override the original
+ * @return {ValidityState} - The updated ValidityState object
+ */
+const reconcileValidity = (validityObject, newState, form) => {
+    validityObject.valid = isValid(newState);
+    Object.keys(newState).forEach(key => validityObject[key] = newState[key]);
+    if (form) {
+        setFormValidity(form);
+    }
+    return validityObject;
+};
+/**
+ * Check if a partial ValidityState object should be valid
+ * @param {Object} - A partial ValidityState object
+ * @return {Boolean} - Should the new object be valid
+ */
+const isValid = (validityState) => {
+    let valid = true;
+    for (let key in validityState) {
+        if (key !== 'valid' && validityState[key] !== false) {
+            valid = false;
+        }
+    }
+    return valid;
+};
+
+/** Save a reference to the ref for the CustomStateSet */
+const customStateMap = new WeakMap();
+function addState(ref, stateName) {
+    ref.toggleAttribute(stateName, true);
+    if (ref.part) {
+        ref.part.add(stateName);
+    }
+}
+class CustomStateSet extends Set {
+    static get isPolyfilled() {
+        return true;
+    }
+    constructor(ref) {
+        super();
+        if (!ref || !ref.tagName || ref.tagName.indexOf("-") === -1) {
+            throw new TypeError("Illegal constructor");
+        }
+        customStateMap.set(this, ref);
+    }
+    add(state) {
+        if (!/^--/.test(state) || typeof state !== "string") {
+            throw new DOMException(`Failed to execute 'add' on 'CustomStateSet': The specified value ${state} must start with '--'.`);
+        }
+        const result = super.add(state);
+        const ref = customStateMap.get(this);
+        const stateName = `state${state}`;
+        /**
+         * Only add the state immediately if the ref is connected to the DOM;
+         * otherwise, wait a tick because the element is likely being constructed
+         * by document.createElement and would throw otherwise.
+         */
+        if (ref.isConnected) {
+            addState(ref, stateName);
+        }
+        else {
+            setTimeout(() => {
+                addState(ref, stateName);
+            });
+        }
+        return result;
+    }
+    clear() {
+        for (let [entry] of this.entries()) {
+            this.delete(entry);
+        }
+        super.clear();
+    }
+    delete(state) {
+        const result = super.delete(state);
+        const ref = customStateMap.get(this);
+        /**
+         * Only toggle the state/attr immediately if the ref is connected to the DOM;
+         * otherwise, wait a tick because the element is likely being constructed
+         * by document.createElement and would throw otherwise.
+         */
+        if (ref.isConnected) {
+            ref.toggleAttribute(`state${state}`, false);
+            if (ref.part) {
+                ref.part.remove(`state${state}`);
+            }
+        }
+        else {
+            setTimeout(() => {
+                ref.toggleAttribute(`state${state}`, false);
+                if (ref.part) {
+                    ref.part.remove(`state${state}`);
+                }
+            });
+        }
+        return result;
+    }
+}
+
+var __classPrivateFieldSet = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _HTMLFormControlsCollection_elements;
+class HTMLFormControlsCollection {
+    constructor(elements) {
+        _HTMLFormControlsCollection_elements.set(this, void 0);
+        __classPrivateFieldSet(this, _HTMLFormControlsCollection_elements, elements, "f");
+        for (let i = 0; i < elements.length; i++) {
+            let element = elements[i];
+            this[i] = element;
+            if (element.hasAttribute('name')) {
+                this[element.getAttribute('name')] = element;
+            }
+        }
+        Object.freeze(this);
+    }
+    get length() {
+        return __classPrivateFieldGet(this, _HTMLFormControlsCollection_elements, "f").length;
+    }
+    [(_HTMLFormControlsCollection_elements = new WeakMap(), Symbol.iterator)]() {
+        return __classPrivateFieldGet(this, _HTMLFormControlsCollection_elements, "f")[Symbol.iterator]();
+    }
+    item(i) {
+        return this[i] == null ? null : this[i];
+    }
+    namedItem(name) {
+        return this[name] == null ? null : this[name];
+    }
+}
+
+/**
+ * Patch the HTMLElement prototype
+ *
+ * This function patches checkValidity, reportValidity and elements
+ */
+function patchFormPrototype() {
+    const checkValidity = HTMLFormElement.prototype.checkValidity;
+    HTMLFormElement.prototype.checkValidity = checkValidityOverride;
+    const reportValidity = HTMLFormElement.prototype.reportValidity;
+    HTMLFormElement.prototype.reportValidity = reportValidityOverride;
+    function checkValidityOverride(...args) {
+        let returnValue = checkValidity.apply(this, args);
+        return overrideFormMethod(this, returnValue, 'checkValidity');
+    }
+    function reportValidityOverride(...args) {
+        let returnValue = reportValidity.apply(this, args);
+        return overrideFormMethod(this, returnValue, 'reportValidity');
+    }
+    const { get } = Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, 'elements');
+    Object.defineProperty(HTMLFormElement.prototype, 'elements', {
+        get(...args) {
+            const elements = get.call(this, ...args);
+            const polyfilledElements = Array.from(formElementsMap.get(this) || []);
+            // If there are no polyfilled elements, return the native elements collection
+            if (polyfilledElements.length === 0) {
+                return elements;
+            }
+            // Merge the native elements with the polyfilled elements
+            // and order them by their position in the DOM
+            const orderedElements = Array.from(elements).concat(polyfilledElements).sort((a, b) => {
+                if (a.compareDocumentPosition) {
+                    return a.compareDocumentPosition(b) & 2 ? 1 : -1;
+                }
+                return 0;
+            });
+            return new HTMLFormControlsCollection(orderedElements);
+        },
+    });
+}
+
+class ElementInternals {
+    static get isPolyfilled() {
+        return true;
+    }
+    constructor(ref) {
+        if (!ref || !ref.tagName || ref.tagName.indexOf("-") === -1) {
+            throw new TypeError("Illegal constructor");
+        }
+        const rootNode = ref.getRootNode();
+        const validity = new ValidityState();
+        this.states = new CustomStateSet(ref);
+        refMap.set(this, ref);
+        validityMap.set(this, validity);
+        internalsMap.set(ref, this);
+        initAom(ref, this);
+        initRef(ref, this);
+        Object.seal(this);
+        /**
+         * If appended from a DocumentFragment, wait until it is connected
+         * before attempting to upgrade the internals instance
+         */
+        if (rootNode instanceof DocumentFragment) {
+            deferUpgrade(rootNode);
+        }
+    }
+    /**
+     * Will return true if the element is in a valid state
+     */
+    checkValidity() {
+        const ref = refMap.get(this);
+        throwIfNotFormAssociated(ref, `Failed to execute 'checkValidity' on 'ElementInternals': The target element is not a form-associated custom element.`);
+        /** If the element will not validate, it is necessarily valid by default */
+        if (!this.willValidate) {
+            return true;
+        }
+        const validity = validityMap.get(this);
+        if (!validity.valid) {
+            const validityEvent = new Event("invalid", {
+                bubbles: false,
+                cancelable: true,
+                composed: false,
+            });
+            ref.dispatchEvent(validityEvent);
+        }
+        return validity.valid;
+    }
+    /** The form element the custom element is associated with */
+    get form() {
+        const ref = refMap.get(this);
+        throwIfNotFormAssociated(ref, `Failed to read the 'form' property from 'ElementInternals': The target element is not a form-associated custom element.`);
+        let form;
+        if (ref.constructor["formAssociated"] === true) {
+            form = findParentForm(ref);
+        }
+        return form;
+    }
+    /** A list of all relative form labels for this element */
+    get labels() {
+        const ref = refMap.get(this);
+        throwIfNotFormAssociated(ref, `Failed to read the 'labels' property from 'ElementInternals': The target element is not a form-associated custom element.`);
+        const id = ref.getAttribute("id");
+        const hostRoot = ref.getRootNode();
+        if (hostRoot && id) {
+            return hostRoot.querySelectorAll(`[for="${id}"]`);
+        }
+        return [];
+    }
+    /** Will report the elements validity state */
+    reportValidity() {
+        const ref = refMap.get(this);
+        throwIfNotFormAssociated(ref, `Failed to execute 'reportValidity' on 'ElementInternals': The target element is not a form-associated custom element.`);
+        /** If the element will not validate, it is valid by default */
+        if (!this.willValidate) {
+            return true;
+        }
+        const valid = this.checkValidity();
+        const anchor = validationAnchorMap.get(this);
+        if (anchor && !ref.constructor["formAssociated"]) {
+            throw new DOMException(`Failed to execute 'reportValidity' on 'ElementInternals': The target element is not a form-associated custom element.`);
+        }
+        if (!valid && anchor) {
+            ref.focus();
+            anchor.focus();
+        }
+        return valid;
+    }
+    /** Sets the element's value within the form */
+    setFormValue(value) {
+        const ref = refMap.get(this);
+        throwIfNotFormAssociated(ref, `Failed to execute 'setFormValue' on 'ElementInternals': The target element is not a form-associated custom element.`);
+        removeHiddenInputs(this);
+        if (value != null && !(value instanceof FormData)) {
+            if (ref.getAttribute("name")) {
+                const hiddenInput = createHiddenInput(ref, this);
+                hiddenInput.value = value;
+            }
+        }
+        else if (value != null && value instanceof FormData) {
+            Array.from(value)
+                .reverse()
+                .forEach(([formDataKey, formDataValue]) => {
+                if (typeof formDataValue === "string") {
+                    const hiddenInput = createHiddenInput(ref, this);
+                    hiddenInput.name = formDataKey;
+                    hiddenInput.value = formDataValue;
+                }
+            });
+        }
+        refValueMap.set(ref, value);
+    }
+    /**
+     * Sets the element's validity. The first argument is a partial ValidityState object
+     * reflecting the changes to be made to the element's validity. If the element is invalid,
+     * the second argument sets the element's validation message.
+     *
+     * If the field is valid and a message is specified, the method will throw a TypeError.
+     */
+    setValidity(validityChanges, validationMessage, anchor) {
+        const ref = refMap.get(this);
+        throwIfNotFormAssociated(ref, `Failed to execute 'setValidity' on 'ElementInternals': The target element is not a form-associated custom element.`);
+        if (!validityChanges) {
+            throw new TypeError("Failed to execute 'setValidity' on 'ElementInternals': 1 argument required, but only 0 present.");
+        }
+        validationAnchorMap.set(this, anchor);
+        const validity = validityMap.get(this);
+        const validityChangesObj = {};
+        for (const key in validityChanges) {
+            validityChangesObj[key] = validityChanges[key];
+        }
+        if (Object.keys(validityChangesObj).length === 0) {
+            setValid(validity);
+        }
+        const check = { ...validity, ...validityChangesObj };
+        delete check.valid;
+        const { valid } = reconcileValidity(validity, check, this.form);
+        if (!valid && !validationMessage) {
+            throw new DOMException(`Failed to execute 'setValidity' on 'ElementInternals': The second argument should not be empty if one or more flags in the first argument are true.`);
+        }
+        validationMessageMap.set(this, valid ? "" : validationMessage);
+        // check to make sure the host element is connected before adding attributes
+        // because safari doesnt allow elements to have attributes added in the constructor
+        if (ref.isConnected) {
+            ref.toggleAttribute("internals-invalid", !valid);
+            ref.toggleAttribute("internals-valid", valid);
+            setAttribute(ref, "aria-invalid", `${!valid}`);
+        }
+        else {
+            validityUpgradeMap.set(ref, this);
+        }
+    }
+    get shadowRoot() {
+        const ref = refMap.get(this);
+        const shadowRoot = shadowRootMap.get(ref);
+        if (shadowRoot) {
+            return shadowRoot;
+        }
+        return null;
+    }
+    /** The element's validation message set during a call to ElementInternals.setValidity */
+    get validationMessage() {
+        const ref = refMap.get(this);
+        throwIfNotFormAssociated(ref, `Failed to read the 'validationMessage' property from 'ElementInternals': The target element is not a form-associated custom element.`);
+        return validationMessageMap.get(this);
+    }
+    /** The current validity state of the object */
+    get validity() {
+        const ref = refMap.get(this);
+        throwIfNotFormAssociated(ref, `Failed to read the 'validity' property from 'ElementInternals': The target element is not a form-associated custom element.`);
+        const validity = validityMap.get(this);
+        return validity;
+    }
+    /** If true the element will participate in a form's constraint validation. */
+    get willValidate() {
+        const ref = refMap.get(this);
+        throwIfNotFormAssociated(ref, `Failed to read the 'willValidate' property from 'ElementInternals': The target element is not a form-associated custom element.`);
+        if (ref.matches(":disabled") ||
+            ref["disabled"] ||
+            ref.hasAttribute("disabled") ||
+            ref.hasAttribute("readonly")) {
+            return false;
+        }
+        return true;
+    }
+}
+function isElementInternalsSupported() {
+    if (typeof window === "undefined" ||
+        !window.ElementInternals ||
+        !HTMLElement.prototype.attachInternals) {
+        return false;
+    }
+    class ElementInternalsFeatureDetection extends HTMLElement {
+        constructor() {
+            super();
+            this.internals = this.attachInternals();
+        }
+    }
+    const randomName = `element-internals-feature-detection-${Math.random()
+        .toString(36)
+        .replace(/[^a-z]+/g, "")}`;
+    customElements.define(randomName, ElementInternalsFeatureDetection);
+    const featureDetectionElement = new ElementInternalsFeatureDetection();
+    return [
+        "shadowRoot",
+        "form",
+        "willValidate",
+        "validity",
+        "validationMessage",
+        "labels",
+        "setFormValue",
+        "setValidity",
+        "checkValidity",
+        "reportValidity",
+    ].every((prop) => prop in featureDetectionElement.internals);
+}
+let hasElementInternalsPolyfillBeenApplied = false;
+let hasCustomStateSetPolyfillBeenApplied = false;
+/**
+ * Forcibly applies the polyfill for CustomStateSet.
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/API/CustomStateSet
+ */
+function forceCustomStateSetPolyfill(attachInternals) {
+    if (hasCustomStateSetPolyfillBeenApplied) {
+        return;
+    }
+    hasCustomStateSetPolyfillBeenApplied = true;
+    /** @ts-expect-error These types won't match because this is a polyfill */
+    window.CustomStateSet = CustomStateSet;
+    if (attachInternals) {
+        HTMLElement.prototype.attachInternals = function (...args) {
+            const internals = attachInternals.call(this, args);
+            internals.states = new CustomStateSet(this);
+            return internals;
+        };
+    }
+}
+/**
+ * Forcibly applies the polyfill for ElementInternals. Useful for situations
+ * like Chrome extensions where Chrome supports ElementInternals, but the
+ * CustomElements polyfill is required.
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/API/ElementInternals
+ *
+ * @param forceCustomStateSet Optional: when true, forces the
+ * [CustomStateSet](https://developer.mozilla.org/en-US/docs/Web/API/CustomStateSet)
+ * polyfill as well.
+ */
+function forceElementInternalsPolyfill(forceCustomStateSet = true) {
+    /**
+     * This is a flag to prevent a DOMException from being thrown when
+     * attachInternals is called in upgradeInternals.
+     */
+    let attachedFlag = false;
+    if (hasElementInternalsPolyfillBeenApplied) {
+        return;
+    }
+    hasElementInternalsPolyfillBeenApplied = true;
+    if (typeof window !== "undefined") {
+        /** @ts-expect-error: we need to replace the default ElementInternals */
+        window.ElementInternals = ElementInternals;
+    }
+    if (typeof CustomElementRegistry !== "undefined") {
+        const define = CustomElementRegistry.prototype.define;
+        CustomElementRegistry.prototype.define = function (name, constructor, options) {
+            if (constructor.formAssociated) {
+                const connectedCallback = constructor.prototype.connectedCallback;
+                constructor.prototype.connectedCallback = function () {
+                    if (!connectedCallbackMap.has(this)) {
+                        connectedCallbackMap.set(this, true);
+                        if (this.hasAttribute("disabled")) {
+                            setDisabled(this, true);
+                        }
+                    }
+                    if (connectedCallback != null) {
+                        connectedCallback.apply(this);
+                    }
+                    // always upgradeInternals in connectedCallback instead of constructor
+                    attachedFlag = upgradeInternals(this);
+                };
+            }
+            define.call(this, name, constructor, options);
+        };
+    }
+    /**
+     * Attaches an ElementInternals instance to a custom element. Calling this method
+     * on a built-in element will throw an error.
+     */
+    if (typeof HTMLElement !== "undefined") {
+        HTMLElement.prototype.attachInternals = function () {
+            if (!this.tagName) {
+                /** This happens in the LitSSR environment. Here we can generally ignore internals for now */
+                return {};
+            }
+            else if (this.tagName.indexOf("-") === -1) {
+                throw new Error(`Failed to execute 'attachInternals' on 'HTMLElement': Unable to attach ElementInternals to non-custom elements.`);
+            }
+            if (internalsMap.has(this) && !attachedFlag) {
+                throw new DOMException(`DOMException: Failed to execute 'attachInternals' on 'HTMLElement': ElementInternals for the specified element was already attached.`);
+            }
+            return new ElementInternals(this);
+        };
+    }
+    if (typeof Element !== "undefined") {
+        function attachShadowObserver(...args) {
+            const shadowRoot = attachShadow.apply(this, args);
+            shadowRootMap.set(this, shadowRoot);
+            if (mutationObserverExists()) {
+                const observer = new MutationObserver(observerCallback);
+                if (window.ShadyDOM) {
+                    observer.observe(this, observerConfig);
+                }
+                else {
+                    observer.observe(shadowRoot, observerConfig);
+                }
+                shadowHostsMap.set(this, observer);
+            }
+            return shadowRoot;
+        }
+        const attachShadow = Element.prototype.attachShadow;
+        Element.prototype.attachShadow = attachShadowObserver;
+    }
+    if (mutationObserverExists() && typeof document !== "undefined") {
+        const documentObserver = new MutationObserver(observerCallback);
+        documentObserver.observe(document.documentElement, observerConfig);
+    }
+    /**
+     * Keeps the polyfill from throwing in environments where HTMLFormElement
+     * is undefined like in a server environment
+     */
+    if (typeof HTMLFormElement !== "undefined") {
+        patchFormPrototype();
+    }
+    if (forceCustomStateSet ||
+        (typeof window !== "undefined" && !window.CustomStateSet)) {
+        forceCustomStateSetPolyfill();
+    }
+}
+
+// Deteermine whether the webcomponents polyfill has been applied.
+const isCePolyfill = !!customElements.polyfillWrapFlushCallback;
+// custom elements polyfill is on. Do not auto-apply. User should determine
+// whether to force or not.
+if (!isCePolyfill) {
+    if (!isElementInternalsSupported()) {
+        forceElementInternalsPolyfill(false);
+    }
+    else if (typeof window !== "undefined" && !window.CustomStateSet) {
+        forceCustomStateSetPolyfill(HTMLElement.prototype.attachInternals);
+    }
+}
+
+/* Polyfill para suporte a Safari -16.5 */
 function CuraInit(options, w = window) {
     w.CuraInit = options;
 }