@oslokommune/punkt-elements 14.3.0 → 14.5.2

package/dist/input-element-DVZhYDJ_.js

@@ -0,0 +1,840 @@
+import { P as Ft, s as g, n as c } from "./element-BXsf_NlG.js";
+import { r as Tt } from "./state-DgnkjP0q.js";
+import { u as xt } from "./utils-DznhwRXm.js";
+import { b as It } from "./booleanish-C9R0tdXH.js";
+import { s as Rt } from "./input-wrapper-CDgenrYA.js";
+var ct = {}, dt;
+function Lt() {
+  return dt || (dt = 1, (function() {
+    (function(p) {
+      const a = /* @__PURE__ */ new WeakMap(), r = /* @__PURE__ */ new WeakMap(), f = /* @__PURE__ */ new WeakMap(), u = /* @__PURE__ */ new WeakMap(), w = /* @__PURE__ */ new WeakMap(), V = /* @__PURE__ */ new WeakMap(), A = /* @__PURE__ */ new WeakMap(), v = /* @__PURE__ */ new WeakMap(), S = /* @__PURE__ */ new WeakMap(), C = /* @__PURE__ */ new WeakMap(), F = /* @__PURE__ */ new WeakMap(), T = /* @__PURE__ */ new WeakMap(), K = /* @__PURE__ */ new WeakMap(), j = /* @__PURE__ */ new WeakMap(), I = /* @__PURE__ */ new WeakMap(), R = {
+        ariaAtomic: "aria-atomic",
+        ariaAutoComplete: "aria-autocomplete",
+        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"
+      }, ut = (e, t) => {
+        for (let i in R) {
+          t[i] = null;
+          let s = null;
+          const n = R[i];
+          Object.defineProperty(t, i, {
+            get() {
+              return s;
+            },
+            set(d) {
+              s = d, e.isConnected ? k(e, n, d) : C.set(e, t);
+            }
+          });
+        }
+      };
+      function G(e) {
+        const t = u.get(e), { form: i } = t;
+        tt(e, i, t), Z(e, t.labels);
+      }
+      const J = (e, t = !1) => {
+        const i = document.createTreeWalker(e, NodeFilter.SHOW_ELEMENT, {
+          acceptNode(d) {
+            return u.has(d) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+          }
+        });
+        let s = i.nextNode();
+        const n = !t || e.disabled;
+        for (; s; )
+          s.formDisabledCallback && n && H(s, e.disabled), s = i.nextNode();
+      }, Q = { attributes: !0, attributeFilter: ["disabled", "name"] }, L = D() ? new MutationObserver((e) => {
+        for (const t of e) {
+          const i = t.target;
+          if (t.attributeName === "disabled" && (i.constructor.formAssociated ? H(i, i.hasAttribute("disabled")) : i.localName === "fieldset" && J(i)), t.attributeName === "name" && i.constructor.formAssociated) {
+            const s = u.get(i), n = S.get(i);
+            s.setFormValue(n);
+          }
+        }
+      }) : {};
+      function B(e) {
+        e.forEach((t) => {
+          const { addedNodes: i, removedNodes: s } = t, n = Array.from(i), d = Array.from(s);
+          n.forEach((h) => {
+            var y;
+            if (u.has(h) && h.constructor.formAssociated && G(h), C.has(h)) {
+              const m = C.get(h);
+              Object.keys(R).filter((b) => m[b] !== null).forEach((b) => {
+                k(h, R[b], m[b]);
+              }), C.delete(h);
+            }
+            if (I.has(h)) {
+              const m = I.get(h);
+              k(h, "internals-valid", m.validity.valid.toString()), k(h, "internals-invalid", (!m.validity.valid).toString()), k(h, "aria-invalid", (!m.validity.valid).toString()), I.delete(h);
+            }
+            if (h.localName === "form") {
+              const m = v.get(h), M = document.createTreeWalker(h, NodeFilter.SHOW_ELEMENT, {
+                acceptNode(U) {
+                  return u.has(U) && U.constructor.formAssociated && !(m && m.has(U)) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+                }
+              });
+              let b = M.nextNode();
+              for (; b; )
+                G(b), b = M.nextNode();
+            }
+            h.localName === "fieldset" && ((y = L.observe) === null || y === void 0 || y.call(L, h, Q), J(h, !0));
+          }), d.forEach((h) => {
+            const y = u.get(h);
+            y && f.get(y) && X(y), A.has(h) && A.get(h).disconnect();
+          });
+        });
+      }
+      function ft(e) {
+        e.forEach((t) => {
+          const { removedNodes: i } = t;
+          i.forEach((s) => {
+            const n = K.get(t.target);
+            u.has(s) && it(s), n.disconnect();
+          });
+        });
+      }
+      const pt = (e) => {
+        var t, i;
+        const s = new MutationObserver(ft);
+        !((t = window == null ? void 0 : window.ShadyDOM) === null || t === void 0) && t.inUse && e.mode && e.host && (e = e.host), (i = s.observe) === null || i === void 0 || i.call(s, e, { childList: !0 }), K.set(e, s);
+      };
+      D() && new MutationObserver(B);
+      const _ = {
+        childList: !0,
+        subtree: !0
+      }, k = (e, t, i) => {
+        e.getAttribute(t) !== i && e.setAttribute(t, i);
+      }, H = (e, t) => {
+        e.toggleAttribute("internals-disabled", t), t ? k(e, "aria-disabled", "true") : e.removeAttribute("aria-disabled"), e.formDisabledCallback && e.formDisabledCallback.apply(e, [t]);
+      }, X = (e) => {
+        f.get(e).forEach((i) => {
+          i.remove();
+        }), f.set(e, []);
+      }, Y = (e, t) => {
+        const i = document.createElement("input");
+        return i.type = "hidden", i.name = e.getAttribute("name"), e.after(i), f.get(t).push(i), i;
+      }, mt = (e, t) => {
+        var i;
+        f.set(t, []), (i = L.observe) === null || i === void 0 || i.call(L, e, Q);
+      }, Z = (e, t) => {
+        if (t.length) {
+          Array.from(t).forEach((s) => s.addEventListener("click", e.click.bind(e)));
+          let i = t[0].id;
+          t[0].id || (i = `${t[0].htmlFor}_Label`, t[0].id = i), k(e, "aria-labelledby", i);
+        }
+      }, N = (e) => {
+        const t = Array.from(e.elements).filter((d) => !d.tagName.includes("-") && d.validity).map((d) => d.validity.valid), i = v.get(e) || [], s = Array.from(i).filter((d) => d.isConnected).map((d) => u.get(d).validity.valid), n = [...t, ...s].includes(!1);
+        e.toggleAttribute("internals-invalid", n), e.toggleAttribute("internals-valid", !n);
+      }, yt = (e) => {
+        N(O(e.target));
+      }, gt = (e) => {
+        N(O(e.target));
+      }, vt = (e) => {
+        const t = ["button[type=submit]", "input[type=submit]", "button:not([type])"].map((i) => `${i}:not([disabled])`).map((i) => `${i}:not([form])${e.id ? `,${i}[form='${e.id}']` : ""}`).join(",");
+        e.addEventListener("click", (i) => {
+          if (i.target.closest(t)) {
+            const n = v.get(e);
+            if (e.noValidate)
+              return;
+            n.size && Array.from(n).reverse().map((y) => u.get(y).reportValidity()).includes(!1) && i.preventDefault();
+          }
+        });
+      }, bt = (e) => {
+        const t = v.get(e.target);
+        t && t.size && t.forEach((i) => {
+          i.constructor.formAssociated && i.formResetCallback && i.formResetCallback.apply(i);
+        });
+      }, tt = (e, t, i) => {
+        if (t) {
+          const s = v.get(t);
+          if (s)
+            s.add(e);
+          else {
+            const n = /* @__PURE__ */ new Set();
+            n.add(e), v.set(t, n), vt(t), t.addEventListener("reset", bt), t.addEventListener("input", yt), t.addEventListener("change", gt);
+          }
+          V.set(t, { ref: e, internals: i }), e.constructor.formAssociated && e.formAssociatedCallback && setTimeout(() => {
+            e.formAssociatedCallback.apply(e, [t]);
+          }, 0), N(t);
+        }
+      }, O = (e) => {
+        let t = e.parentNode;
+        return t && t.tagName !== "FORM" && (t = O(t)), t;
+      }, E = (e, t, i = DOMException) => {
+        if (!e.constructor.formAssociated)
+          throw new i(t);
+      }, et = (e, t, i) => {
+        const s = v.get(e);
+        return s && s.size && s.forEach((n) => {
+          u.get(n)[i]() || (t = !1);
+        }), t;
+      }, it = (e) => {
+        if (e.constructor.formAssociated) {
+          const t = u.get(e), { labels: i, form: s } = t;
+          Z(e, i), tt(e, s, t);
+        }
+      };
+      function D() {
+        return typeof MutationObserver < "u";
+      }
+      class wt {
+        constructor() {
+          this.badInput = !1, this.customError = !1, this.patternMismatch = !1, this.rangeOverflow = !1, this.rangeUnderflow = !1, this.stepMismatch = !1, this.tooLong = !1, this.tooShort = !1, this.typeMismatch = !1, this.valid = !0, this.valueMissing = !1, Object.seal(this);
+        }
+      }
+      const Et = (e) => (e.badInput = !1, e.customError = !1, e.patternMismatch = !1, e.rangeOverflow = !1, e.rangeUnderflow = !1, e.stepMismatch = !1, e.tooLong = !1, e.tooShort = !1, e.typeMismatch = !1, e.valid = !0, e.valueMissing = !1, e), Mt = (e, t, i) => (e.valid = kt(t), Object.keys(t).forEach((s) => e[s] = t[s]), i && N(i), e), kt = (e) => {
+        let t = !0;
+        for (let i in e)
+          i !== "valid" && e[i] !== !1 && (t = !1);
+        return t;
+      }, W = /* @__PURE__ */ new WeakMap();
+      function at(e, t) {
+        e.toggleAttribute(t, !0), e.part && e.part.add(t);
+      }
+      class q extends Set {
+        static get isPolyfilled() {
+          return !0;
+        }
+        constructor(t) {
+          if (super(), !t || !t.tagName || t.tagName.indexOf("-") === -1)
+            throw new TypeError("Illegal constructor");
+          W.set(this, t);
+        }
+        add(t) {
+          if (!/^--/.test(t) || typeof t != "string")
+            throw new DOMException(`Failed to execute 'add' on 'CustomStateSet': The specified value ${t} must start with '--'.`);
+          const i = super.add(t), s = W.get(this), n = `state${t}`;
+          return s.isConnected ? at(s, n) : setTimeout(() => {
+            at(s, n);
+          }), i;
+        }
+        clear() {
+          for (let [t] of this.entries())
+            this.delete(t);
+          super.clear();
+        }
+        delete(t) {
+          const i = super.delete(t), s = W.get(this);
+          return s.isConnected ? (s.toggleAttribute(`state${t}`, !1), s.part && s.part.remove(`state${t}`)) : setTimeout(() => {
+            s.toggleAttribute(`state${t}`, !1), s.part && s.part.remove(`state${t}`);
+          }), i;
+        }
+      }
+      function st(e, t, i, s) {
+        if (typeof t == "function" ? e !== t || !s : !t.has(e)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+        return i === "m" ? s : i === "a" ? s.call(e) : s ? s.value : t.get(e);
+      }
+      function Vt(e, t, i, s, n) {
+        if (typeof t == "function" ? e !== t || !0 : !t.has(e)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+        return t.set(e, i), i;
+      }
+      var x;
+      class Ct {
+        constructor(t) {
+          x.set(this, void 0), Vt(this, x, t);
+          for (let i = 0; i < t.length; i++) {
+            let s = t[i];
+            this[i] = s, s.hasAttribute("name") && (this[s.getAttribute("name")] = s);
+          }
+          Object.freeze(this);
+        }
+        get length() {
+          return st(this, x, "f").length;
+        }
+        [(x = /* @__PURE__ */ new WeakMap(), Symbol.iterator)]() {
+          return st(this, x, "f")[Symbol.iterator]();
+        }
+        item(t) {
+          return this[t] == null ? null : this[t];
+        }
+        namedItem(t) {
+          return this[t] == null ? null : this[t];
+        }
+      }
+      function At() {
+        const e = HTMLFormElement.prototype.checkValidity;
+        HTMLFormElement.prototype.checkValidity = i;
+        const t = HTMLFormElement.prototype.reportValidity;
+        HTMLFormElement.prototype.reportValidity = s;
+        function i(...d) {
+          let h = e.apply(this, d);
+          return et(this, h, "checkValidity");
+        }
+        function s(...d) {
+          let h = t.apply(this, d);
+          return et(this, h, "reportValidity");
+        }
+        const { get: n } = Object.getOwnPropertyDescriptor(HTMLFormElement.prototype, "elements");
+        Object.defineProperty(HTMLFormElement.prototype, "elements", {
+          get(...d) {
+            const h = n.call(this, ...d), y = Array.from(v.get(this) || []);
+            if (y.length === 0)
+              return h;
+            const m = Array.from(h).concat(y).sort((M, b) => M.compareDocumentPosition ? M.compareDocumentPosition(b) & 2 ? 1 : -1 : 0);
+            return new Ct(m);
+          }
+        });
+      }
+      class rt {
+        static get isPolyfilled() {
+          return !0;
+        }
+        constructor(t) {
+          if (!t || !t.tagName || t.tagName.indexOf("-") === -1)
+            throw new TypeError("Illegal constructor");
+          const i = t.getRootNode(), s = new wt();
+          this.states = new q(t), a.set(this, t), r.set(this, s), u.set(t, this), ut(t, this), mt(t, this), Object.seal(this), i instanceof DocumentFragment && pt(i);
+        }
+        checkValidity() {
+          const t = a.get(this);
+          if (E(t, "Failed to execute 'checkValidity' on 'ElementInternals': The target element is not a form-associated custom element."), !this.willValidate)
+            return !0;
+          const i = r.get(this);
+          if (!i.valid) {
+            const s = new Event("invalid", {
+              bubbles: !1,
+              cancelable: !0,
+              composed: !1
+            });
+            t.dispatchEvent(s);
+          }
+          return i.valid;
+        }
+        get form() {
+          const t = a.get(this);
+          E(t, "Failed to read the 'form' property from 'ElementInternals': The target element is not a form-associated custom element.");
+          let i;
+          return t.constructor.formAssociated === !0 && (i = O(t)), i;
+        }
+        get labels() {
+          const t = a.get(this);
+          E(t, "Failed to read the 'labels' property from 'ElementInternals': The target element is not a form-associated custom element.");
+          const i = t.getAttribute("id"), s = t.getRootNode();
+          return s && i ? s.querySelectorAll(`[for="${i}"]`) : [];
+        }
+        reportValidity() {
+          const t = a.get(this);
+          if (E(t, "Failed to execute 'reportValidity' on 'ElementInternals': The target element is not a form-associated custom element."), !this.willValidate)
+            return !0;
+          const i = this.checkValidity(), s = T.get(this);
+          if (s && !t.constructor.formAssociated)
+            throw new DOMException("Failed to execute 'reportValidity' on 'ElementInternals': The target element is not a form-associated custom element.");
+          return !i && s && (t.focus(), s.focus()), i;
+        }
+        setFormValue(t) {
+          const i = a.get(this);
+          if (E(i, "Failed to execute 'setFormValue' on 'ElementInternals': The target element is not a form-associated custom element."), X(this), t != null && !(t instanceof FormData)) {
+            if (i.getAttribute("name")) {
+              const s = Y(i, this);
+              s.value = t;
+            }
+          } else t != null && t instanceof FormData && Array.from(t).reverse().forEach(([s, n]) => {
+            if (typeof n == "string") {
+              const d = Y(i, this);
+              d.name = s, d.value = n;
+            }
+          });
+          S.set(i, t);
+        }
+        setValidity(t, i, s) {
+          const n = a.get(this);
+          if (E(n, "Failed to execute 'setValidity' on 'ElementInternals': The target element is not a form-associated custom element."), !t)
+            throw new TypeError("Failed to execute 'setValidity' on 'ElementInternals': 1 argument required, but only 0 present.");
+          T.set(this, s);
+          const d = r.get(this), h = {};
+          for (const M in t)
+            h[M] = t[M];
+          Object.keys(h).length === 0 && Et(d);
+          const y = Object.assign(Object.assign({}, d), h);
+          delete y.valid;
+          const { valid: m } = Mt(d, y, this.form);
+          if (!m && !i)
+            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.");
+          w.set(this, m ? "" : i), n.isConnected ? (n.toggleAttribute("internals-invalid", !m), n.toggleAttribute("internals-valid", m), k(n, "aria-invalid", `${!m}`)) : I.set(n, this);
+        }
+        get shadowRoot() {
+          const t = a.get(this), i = F.get(t);
+          return i || null;
+        }
+        get validationMessage() {
+          const t = a.get(this);
+          return E(t, "Failed to read the 'validationMessage' property from 'ElementInternals': The target element is not a form-associated custom element."), w.get(this);
+        }
+        get validity() {
+          const t = a.get(this);
+          return E(t, "Failed to read the 'validity' property from 'ElementInternals': The target element is not a form-associated custom element."), r.get(this);
+        }
+        get willValidate() {
+          const t = a.get(this);
+          return E(t, "Failed to read the 'willValidate' property from 'ElementInternals': The target element is not a form-associated custom element."), !(t.disabled || t.hasAttribute("disabled") || t.hasAttribute("readonly"));
+        }
+      }
+      function St() {
+        if (typeof window > "u" || !window.ElementInternals || !HTMLElement.prototype.attachInternals)
+          return !1;
+        class e extends HTMLElement {
+          constructor() {
+            super(), this.internals = this.attachInternals();
+          }
+        }
+        const t = `element-internals-feature-detection-${Math.random().toString(36).replace(/[^a-z]+/g, "")}`;
+        customElements.define(t, e);
+        const i = new e();
+        return [
+          "shadowRoot",
+          "form",
+          "willValidate",
+          "validity",
+          "validationMessage",
+          "labels",
+          "setFormValue",
+          "setValidity",
+          "checkValidity",
+          "reportValidity"
+        ].every((s) => s in i.internals);
+      }
+      let nt = !1, ot = !1;
+      function $(e) {
+        ot || (ot = !0, window.CustomStateSet = q, e && (HTMLElement.prototype.attachInternals = function(...t) {
+          const i = e.call(this, t);
+          return i.states = new q(this), i;
+        }));
+      }
+      function lt(e = !0) {
+        if (!nt) {
+          if (nt = !0, typeof window < "u" && (window.ElementInternals = rt), typeof CustomElementRegistry < "u") {
+            const t = CustomElementRegistry.prototype.define;
+            CustomElementRegistry.prototype.define = function(i, s, n) {
+              if (s.formAssociated) {
+                const d = s.prototype.connectedCallback;
+                s.prototype.connectedCallback = function() {
+                  j.has(this) || (j.set(this, !0), this.hasAttribute("disabled") && H(this, !0)), d != null && d.apply(this), it(this);
+                };
+              }
+              t.call(this, i, s, n);
+            };
+          }
+          if (typeof HTMLElement < "u" && (HTMLElement.prototype.attachInternals = function() {
+            if (this.tagName) {
+              if (this.tagName.indexOf("-") === -1)
+                throw new Error("Failed to execute 'attachInternals' on 'HTMLElement': Unable to attach ElementInternals to non-custom elements.");
+            } else return {};
+            if (u.has(this))
+              throw new DOMException("DOMException: Failed to execute 'attachInternals' on 'HTMLElement': ElementInternals for the specified element was already attached.");
+            return new rt(this);
+          }), typeof Element < "u") {
+            let t = function(...s) {
+              const n = i.apply(this, s);
+              if (F.set(this, n), D()) {
+                const d = new MutationObserver(B);
+                window.ShadyDOM ? d.observe(this, _) : d.observe(n, _), A.set(this, d);
+              }
+              return n;
+            };
+            const i = Element.prototype.attachShadow;
+            Element.prototype.attachShadow = t;
+          }
+          D() && typeof document < "u" && new MutationObserver(B).observe(document.documentElement, _), typeof HTMLFormElement < "u" && At(), (e || typeof window < "u" && !window.CustomStateSet) && $();
+        }
+      }
+      return !!customElements.polyfillWrapFlushCallback || (St() ? typeof window < "u" && !window.CustomStateSet && $(HTMLElement.prototype.attachInternals) : lt(!1)), p.forceCustomStateSetPolyfill = $, p.forceElementInternalsPolyfill = lt, Object.defineProperty(p, "__esModule", { value: !0 }), p;
+    })({});
+  })()), ct;
+}
+Lt();
+var Nt = Object.defineProperty, o = (p, a, r, f) => {
+  for (var u = void 0, w = p.length - 1, V; w >= 0; w--)
+    (V = p[w]) && (u = V(a, r, u) || u);
+  return u && Nt(a, r, u), u;
+};
+const ht = "on", z = "--checked", P = ",";
+class l extends Ft {
+  constructor() {
+    super(), this.defaultValue = null, this.disabled = !1, this.readonly = !1, this.required = !1, this.max = null, this.maxlength = null, this.min = null, this.minlength = null, this.step = null, this.ariaDescribedBy = null, this.ariaLabelledby = null, this.name = "", this.pattern = null, this.placeholder = null, this.id = xt(), this.counter = !1, this.hasError = !1, this.inline = !1, this.hasFieldset = !1, this.optionalTag = !1, this.requiredTag = !1, this.skipForwardTestid = !1, this.useWrapper = !0, this.fullwidth = !1, this.counterMaxLength = 0, this.errorMessage = "", this.helptext = "", this.helptextDropdown = "", this.helptextDropdownButton = Rt.props.helptextDropdownButton.default, this.label = null, this.optionalText = g.forms.labels.optional, this.requiredText = g.forms.labels.required, this.tagText = null, this.dataTestid = "", this.touched = !1, this.internals = this.attachInternals();
+  }
+  static get formAssociated() {
+    return !0;
+  }
+  /**
+   * Manages form validation state based on input validity
+   * Called automatically by onChange, but can be called manually if needed
+   *
+   * @param input - The input element to validate (optional)
+   * @protected
+   */
+  manageValidity(a) {
+    var r, f, u, w, V, A, v, S, C, F, T;
+    if (!a) {
+      console.warn("manageValidity called without valid input element");
+      return;
+    }
+    this.required && !this.value ? this.internals.setValidity({ valueMissing: !0 }, g.forms.messages.required, a) : (r = a.validity) != null && r.typeMismatch || (f = a.validity) != null && f.badInput ? this.internals.setValidity({ typeMismatch: !0 }, g.forms.messages.invalid, a) : (u = a.validity) != null && u.patternMismatch ? this.internals.setValidity(
+      { patternMismatch: !0 },
+      g.forms.messages.invalidPattern,
+      a
+    ) : (w = a.validity) != null && w.tooShort || this.minlength && this.minlength > 0 && this.value.length < this.minlength ? this.internals.setValidity({ tooShort: !0 }, g.forms.messages.tooShort, a) : (V = a.validity) != null && V.tooLong || this.maxlength && this.maxlength > 0 && this.value.length > this.maxlength ? this.internals.setValidity({ tooLong: !0 }, g.forms.messages.tooLong, a) : (A = a.validity) != null && A.rangeUnderflow ? this.internals.setValidity(
+      { rangeUnderflow: !0 },
+      this.min ? g.forms.messages.rangeUnderflowMin.replace("{min}", (v = this.min) == null ? void 0 : v.toString()) : g.forms.messages.rangeUnderflow,
+      a
+    ) : (S = a.validity) != null && S.stepMismatch ? this.internals.setValidity({ stepMismatch: !0 }, g.forms.messages.invalid, a) : (C = a.validity) != null && C.rangeOverflow ? this.internals.setValidity(
+      { rangeOverflow: !0 },
+      this.max ? g.forms.messages.rangeOverflowMax.replace("{max}", (F = this.max) == null ? void 0 : F.toString()) : g.forms.messages.rangeOverflow,
+      a
+    ) : (T = a.validity) != null && T.customError ? this.internals.setValidity({ customError: !0 }, a.validationMessage, a) : this.internals.setValidity({});
+  }
+  /**
+   * Updates the form value for this input
+   * Handles both single values and arrays (for multi-select)
+   *
+   * @param value - The value(s) to set in the form
+   * @protected
+   */
+  setFormValue(a) {
+    if (this.internals)
+      if (Array.isArray(a)) {
+        const r = new FormData();
+        a.forEach((f) => {
+          r.append(this.name, f);
+        }), this.internals.setFormValue(r);
+      } else
+        this.internals.setFormValue(a);
+  }
+  /**
+   * Coordinates radio button group by unchecking other radios with the same name
+   * Only affects radio inputs within the same form
+   *
+   * @protected
+   */
+  coordinateRadioGroup() {
+    if (!this.form || !this.name || this.type !== "radio") return;
+    const a = `pkt-radiobutton[name="${this.name}"], input[type=radio][name="${this.name}"]`;
+    this.form.querySelectorAll(a).forEach((r) => {
+      var f;
+      if (r !== this && r.getAttribute("name") === this.name && r.getAttribute("value") !== this.value) {
+        const u = r;
+        u.checked && (u.checked = !1, u.internals && (u.internals.setFormValue(null), (f = u.internals.states) == null || f.delete(z)));
+      }
+    });
+  }
+  /**
+   * Updates checked state and form value for checkbox and radio inputs
+   * Triggers this when you want to set the value of the radio or checkbox input to the form
+   * Do not use valueChanged or onChange for radios and checkboxes!
+   *
+   * @param value - The checked state (string 'true'/'false', or boolean)
+   * @protected
+   */
+  valueChecked(a) {
+    if (!this.touched) return;
+    const r = this.internals.form || this.closest("form"), f = r ? new FormData(r) : null;
+    if (this.type === "radio" && this.coordinateRadioGroup(), typeof a == "string" ? (this.checked = a === "true", this.internals.ariaChecked = String(a === "true")) : typeof a == "boolean" && (this.checked = a, this.internals.ariaChecked = String(a)), this.checked) {
+      const u = (typeof this.value == "string" ? this.value : "") || ht;
+      this.internals.setFormValue(u), f && f.append(this.name, u), this.internals.states.add(z);
+    } else
+      this.internals.setFormValue(null), f && f.delete(this.name), this.internals.states.delete(z);
+    this.dispatchChangeEvents(this.checked), this.internals.reportValidity();
+  }
+  /**
+   * Called when value changes (text inputs, select, etc.)
+   * Subclasses can override to add custom value transformation logic
+   *
+   * @param value - The new value
+   * @param _old - The previous value
+   * @protected
+   * @example
+   * ```typescript
+   * protected valueChanged(value: string, old: string): void {
+   *   const transformed = this.transformValue(value)
+   *   super.valueChanged(transformed, old)
+   * }
+   * ```
+   */
+  valueChanged(a, r) {
+    (r !== this.value || r !== this._value) && (typeof a == "string" ? ((this.multiple || this.range) && a.includes(P) && (a = a.split(P)), this.value = a, this._value = Array.isArray(a) ? a : [a]) : Array.isArray(a) ? (this.value = this.multiple || this.range ? a : a[0], this._value = a) : (this.value = "", this._value = []), (!this.value || this.value.length === 0) && r && r.length !== 0 ? this.clearInputValue() : this.value && this.value.toString() !== (r == null ? void 0 : r.toString()) && this.onChange(this.value), this.updateComplete.then(() => this.requestUpdate()));
+  }
+  /**
+   * Dispatches change and value-change events
+   *
+   * @param value - The value to include in the event detail
+   * @protected
+   */
+  dispatchChangeEvents(a) {
+    this.dispatchEvent(new Event("change", { bubbles: !0, composed: !0 })), this.dispatchEvent(
+      new CustomEvent("value-change", {
+        detail: a,
+        bubbles: !0,
+        composed: !0
+      })
+    );
+  }
+  /**
+   * When input goes from content to no content
+   * @protected
+   */
+  clearInputValue() {
+    const a = this.multiple || this.range ? [] : "";
+    this.value = a, this.setFormValue(a), this.dispatchChangeEvents(a);
+  }
+  /**
+   * When user enters the input, dispatch focus event
+   * @protected
+   */
+  onFocus() {
+    this.dispatchEvent(new FocusEvent("focus", { bubbles: !0, composed: !0 }));
+  }
+  /**
+   * When user leaves the input, dispatch blur event
+   * @protected
+   */
+  onBlur() {
+    this.dispatchEvent(new FocusEvent("blur", { bubbles: !0, composed: !0 }));
+  }
+  /**
+   * Trigger this when user types in the input
+   * @protected
+   */
+  onInput() {
+    this.dispatchEvent(new InputEvent("input", { bubbles: !0, composed: !0 }));
+  }
+  /**
+   * Normalizes value format based on multiple/range settings
+   *
+   * @param value - The value to normalize
+   * @returns Normalized value (array if multiple/range, string otherwise)
+   * @private
+   */
+  normalizeValue(a) {
+    return (this.range || this.multiple) && typeof a == "string" && a.includes(P) ? a.split(P) : !this.multiple && !this.range && Array.isArray(a) ? a[0] || "" : a;
+  }
+  /**
+   * Validates the input element(s)
+   * @private
+   */
+  validate() {
+    var a, r;
+    (a = this.inputRef) != null && a.value && this.manageValidity(this.inputRef.value), (r = this.inputRefTo) != null && r.value && this.manageValidity(this.inputRefTo.value);
+  }
+  /**
+   * Trigger this when you want to set the value of the input out to the form
+   * Handles value normalization, form updates, validation, and event dispatching
+   *
+   * @param value - The value to set
+   * @protected
+   */
+  onChange(a) {
+    if (!this.touched) {
+      this.touched = !0, a && this.setFormValue(a);
+      return;
+    }
+    if (typeof a != "string" && !Array.isArray(a))
+      return;
+    const r = this.normalizeValue(a);
+    this.setFormValue(r), this.validate(), this.dispatchChangeEvents(r);
+  }
+  /**
+   * Called when the form is reset
+   * Resets the input to its default state
+   * @protected
+   */
+  formResetCallback() {
+    var a;
+    if (this.touched = !1, this._options && this._options.length && this._options.forEach((r) => {
+      "selected" in r && (r.selected = !1);
+    }), this.checked !== void 0)
+      this.checked = !1, this.internals.ariaChecked = "false", this.internals.setFormValue(""), (a = this.inputRef) != null && a.value && "checked" in this.inputRef.value && (this.inputRef.value.checked = !1), this.valueChecked(this.checked);
+    else {
+      this.internals.setFormValue("");
+      const r = this.defaultValue || (this.multiple || this.range ? [] : "");
+      this.value = r, this._value = Array.isArray(r) ? r : [r], this.valueChanged(this.value, null);
+    }
+    this.internals.ariaInvalid = "false";
+  }
+  updated(a) {
+    super.updated(a), a.has("dataTestid") && this.dataTestid && this.inputRef.value && (this.skipForwardTestid ? this.hasAttribute("data-testid") || this.setAttribute("data-testid", this.dataTestid) : (this.inputRef.value.dataset.testid = this.dataTestid, this.removeAttribute("data-testid")));
+  }
+  firstUpdated(a) {
+    if (super.firstUpdated(a), !this.form) {
+      const r = this.internals.form || this.closest("form");
+      this.form = r;
+    }
+    if (this.value && this.defaultValue !== null && (this.defaultValue = this.value), this.defaultValue !== null && !this.value && this.valueChanged(this.defaultValue, null), this.defaultChecked && (this.internals.ariaChecked = "true", this.checked = !0), this.required && (this.internals.ariaRequired = "true"), this.disabled && (this.internals.ariaDisabled = "true"), this.id && !this.name && (this.name = this.id), this.checked !== void 0) {
+      const r = this.checked === "" || this.checked === "true" || this.checked === !0;
+      this.internals.ariaChecked = String(r);
+      const f = r ? (typeof this.value == "string" ? this.value : "") || ht : null;
+      this.internals.setFormValue(f);
+    } else
+      this.setFormValue(this.value);
+    this.inputRef && this.inputRef.value && (this.inputRef.value.setAttribute("form", ""), this.manageValidity(this.inputRef.value)), this.inputRefTo && this.inputRefTo.value && (this.inputRefTo.value.setAttribute("form", ""), this.manageValidity(this.inputRefTo.value));
+  }
+}
+o([
+  c({ type: Boolean, reflect: !0 })
+], l.prototype, "checked");
+o([
+  c({ type: Boolean })
+], l.prototype, "defaultChecked");
+o([
+  c({ type: Boolean })
+], l.prototype, "multiple");
+o([
+  c({ type: Boolean })
+], l.prototype, "range");
+o([
+  c({ type: String, reflect: !0 })
+], l.prototype, "type");
+o([
+  c()
+], l.prototype, "defaultValue");
+o([
+  c({ type: Boolean, reflect: !0 })
+], l.prototype, "disabled");
+o([
+  c({ type: Boolean, reflect: !0 })
+], l.prototype, "readonly");
+o([
+  c({ type: Boolean, reflect: !0 })
+], l.prototype, "required");
+o([
+  c({
+    reflect: !0,
+    converter: {
+      fromAttribute: (p) => p,
+      toAttribute: (p) => (p == null ? void 0 : p.toString()) ?? null
+    }
+  })
+], l.prototype, "max");
+o([
+  c({ type: Number, reflect: !0 })
+], l.prototype, "maxlength");
+o([
+  c({
+    reflect: !0,
+    converter: {
+      fromAttribute: (p) => p,
+      toAttribute: (p) => (p == null ? void 0 : p.toString()) ?? null
+    }
+  })
+], l.prototype, "min");
+o([
+  c({ type: Number, reflect: !0 })
+], l.prototype, "minlength");
+o([
+  c({ type: Number, reflect: !0 })
+], l.prototype, "step");
+o([
+  c({ type: String })
+], l.prototype, "ariaDescribedBy");
+o([
+  c({ type: String })
+], l.prototype, "ariaLabelledby");
+o([
+  c({ type: String, reflect: !0 })
+], l.prototype, "name");
+o([
+  c({ type: String, reflect: !0 })
+], l.prototype, "pattern");
+o([
+  c({ type: String, reflect: !0 })
+], l.prototype, "placeholder");
+o([
+  c({ type: String, reflect: !0 })
+], l.prototype, "id");
+o([
+  c({ type: Boolean })
+], l.prototype, "counter");
+o([
+  c({ type: Boolean })
+], l.prototype, "hasError");
+o([
+  c({ type: Boolean })
+], l.prototype, "inline");
+o([
+  c({ type: Boolean })
+], l.prototype, "hasFieldset");
+o([
+  c({ type: Boolean })
+], l.prototype, "optionalTag");
+o([
+  c({ type: Boolean })
+], l.prototype, "requiredTag");
+o([
+  c({ type: Boolean })
+], l.prototype, "skipForwardTestid");
+o([
+  c({ type: Boolean, reflect: !0, converter: It })
+], l.prototype, "useWrapper");
+o([
+  c({ type: Boolean, reflect: !0 })
+], l.prototype, "fullwidth");
+o([
+  c({ type: Number })
+], l.prototype, "counterMaxLength");
+o([
+  c({ type: String })
+], l.prototype, "errorMessage");
+o([
+  c({ type: String })
+], l.prototype, "helptext");
+o([
+  c({ type: String })
+], l.prototype, "helptextDropdown");
+o([
+  c({ type: String, reflect: !1 })
+], l.prototype, "helptextDropdownButton");
+o([
+  c({ type: String })
+], l.prototype, "label");
+o([
+  c({ type: String, reflect: !1 })
+], l.prototype, "optionalText");
+o([
+  c({ type: String, reflect: !1 })
+], l.prototype, "requiredText");
+o([
+  c({ type: String, reflect: !1 })
+], l.prototype, "tagText");
+o([
+  c({ type: String, attribute: "data-testid" })
+], l.prototype, "dataTestid");
+o([
+  Tt()
+], l.prototype, "touched");
+export {
+  l as P
+};