@govbr-ds/webcomponents 2.0.0-next.62 → 2.0.0-next.64

package/dist/{webcomponents/p-B4au_byv.js → components/p-k0WZfTfL.js}

@@ -2,40 +2,39 @@
  * Construído por SERPRO
  * © https://serpro.gov.br/ - MIT License.
  */
-import { _ as t } from "./p-DIPMDb5E.js";
-
 /**
  * Custom positioning reference element.
  * @see https://floating-ui.com/docs/virtual-elements
- */ const e = [ "top", "right", "bottom", "left" ];
+ */
+const t = [ "top", "right", "bottom", "left" ];
 
-const n = Math.min;
+const e = Math.min;
 
-const o = Math.max;
+const n = Math.max;
 
-const i = Math.round;
+const o = Math.round;
 
-const s = Math.floor;
+const i = Math.floor;
 
 const createCoords = t => ({
   x: t,
   y: t
 });
 
-const r = {
+const s = {
   left: "right",
   right: "left",
   bottom: "top",
   top: "bottom"
 };
 
-const c = {
+const r = {
   start: "end",
   end: "start"
 };
 
-function clamp(t, e, i) {
-  return o(t, n(e, i));
+function clamp(t, o, i) {
+  return n(t, e(o, i));
 }
 
 function evaluate(t, e) {
@@ -58,10 +57,10 @@ function getAxisLength(t) {
   return t === "y" ? "height" : "width";
 }
 
-const l =  new Set([ "top", "bottom" ]);
+const c =  new Set([ "top", "bottom" ]);
 
 function getSideAxis(t) {
-  return l.has(getSide(t)) ? "y" : "x";
+  return c.has(getSide(t)) ? "y" : "x";
 }
 
 function getAlignmentAxis(t) {
@@ -88,27 +87,27 @@ function getExpandedPlacements(t) {
 }
 
 function getOppositeAlignmentPlacement(t) {
-  return t.replace(/start|end/g, (t => c[t]));
+  return t.replace(/start|end/g, (t => r[t]));
 }
 
-const a = [ "left", "right" ];
+const l = [ "left", "right" ];
 
-const f = [ "right", "left" ];
+const a = [ "right", "left" ];
 
-const u = [ "top", "bottom" ];
+const f = [ "top", "bottom" ];
 
-const g = [ "bottom", "top" ];
+const u = [ "bottom", "top" ];
 
 function getSideList(t, e, n) {
   switch (t) {
    case "top":
    case "bottom":
-    if (n) return e ? f : a;
-    return e ? a : f;
+    if (n) return e ? a : l;
+    return e ? l : a;
 
    case "left":
    case "right":
-    return e ? u : g;
+    return e ? f : u;
 
    default:
     return [];
@@ -128,7 +127,7 @@ function getOppositeAxisPlacements(t, e, n, o) {
 }
 
 function getOppositePlacement(t) {
-  return t.replace(/left|right|bottom|top/g, (t => r[t]));
+  return t.replace(/left|right|bottom|top/g, (t => s[t]));
 }
 
 function expandPaddingObject(t) {
@@ -355,10 +354,10 @@ function computeCoordsFromPlacement(t, e, n) {
  */ const arrow$1 = t => ({
   name: "arrow",
   options: t,
-  async fn(e) {
-    const {x: o, y: i, placement: s, rects: r, platform: c, elements: l, middlewareData: a} = e;
+  async fn(n) {
+    const {x: o, y: i, placement: s, rects: r, platform: c, elements: l, middlewareData: a} = n;
     // Since `element` is required, we don't Partial<> the type.
-        const {element: f, padding: u = 0} = evaluate(t, e) || {};
+        const {element: f, padding: u = 0} = evaluate(t, n) || {};
     if (f == null) {
       return {};
     }
@@ -386,30 +385,30 @@ function computeCoordsFromPlacement(t, e, n) {
     // If the padding is large enough that it causes the arrow to no longer be
     // centered, modify the padding so that it is centered.
         const E = O / 2 - h[p] / 2 - 1;
-    const P = n(g[y], E);
-    const R = n(g[v], E);
+    const R = e(g[y], E);
+    const P = e(g[v], E);
     // Make sure the arrow doesn't overflow the floating element if the center
     // point is outside the floating element's bounds.
-        const T = P;
-    const L = O - h[p] - R;
+        const T = R;
+    const L = O - h[p] - P;
     const N = O / 2 - h[p] / 2 + C;
     const F = clamp(T, N, L);
     // If the reference is small enough that the arrow's padding causes it to
     // to point to nothing for an aligned placement, adjust the offset of the
     // floating element itself. To ensure `shift()` continues to take action,
     // a single reset is performed when this is true.
-        const D = !a.arrow && getAlignment(s) != null && N !== F && r.reference[p] / 2 - (N < T ? P : R) - h[p] / 2 < 0;
-    const W = D ? N < T ? N - T : N - L : 0;
+        const W = !a.arrow && getAlignment(s) != null && N !== F && r.reference[p] / 2 - (N < T ? R : P) - h[p] / 2 < 0;
+    const B = W ? N < T ? N - T : N - L : 0;
     return {
-      [m]: d[m] + W,
+      [m]: d[m] + B,
       data: {
         [m]: F,
-        centerOffset: N - F - W,
-        ...D && {
-          alignmentOffset: W
+        centerOffset: N - F - B,
+        ...W && {
+          alignmentOffset: B
         }
       },
-      reset: D
+      reset: W
     };
   }
 })
@@ -464,8 +463,8 @@ const flip$1 = function(t) {
       } ];
       // One or more sides is overflowing.
             if (!C.every((t => t <= 0))) {
-        var P, R;
-        const t = (((P = s.flip) == null ? void 0 : P.index) || 0) + 1;
+        var R, P;
+        const t = (((R = s.flip) == null ? void 0 : R.index) || 0) + 1;
         const e = A[t];
         if (e) {
           const n = u === "alignment" ? y !== getSideAxis(e) : false;
@@ -487,7 +486,7 @@ const flip$1 = function(t) {
         }
         // First, find the candidates that fit on the mainAxis side of overflow,
         // then find the placement that fits the best on the main crossAxis side.
-                let n = (R = E.filter((t => t.overflows[0] <= 0)).sort(((t, e) => t.overflows[1] - e.overflows[1]))[0]) == null ? void 0 : R.placement;
+                let n = (P = E.filter((t => t.overflows[0] <= 0)).sort(((t, e) => t.overflows[1] - e.overflows[1]))[0]) == null ? void 0 : P.placement;
         // Otherwise fallback.
                 if (!n) {
           switch (d) {
@@ -537,8 +536,8 @@ function getSideOffsets(t, e) {
   };
 }
 
-function isAnySideFullyClipped(t) {
-  return e.some((e => t[e] >= 0));
+function isAnySideFullyClipped(e) {
+  return t.some((t => e[t] >= 0));
 }
 
 /**
@@ -595,7 +594,7 @@ function isAnySideFullyClipped(t) {
   };
 };
 
-const d =  new Set([ "left", "top" ]);
+const g =  new Set([ "left", "top" ]);
 
 // For type backwards-compatibility, the `OffsetOptions` type was also
 // Derivable.
@@ -605,11 +604,11 @@ async function convertValueToCoords(t, e) {
   const r = getSide(n);
   const c = getAlignment(n);
   const l = getSideAxis(n) === "y";
-  const a = d.has(r) ? -1 : 1;
+  const a = g.has(r) ? -1 : 1;
   const f = s && l ? -1 : 1;
   const u = evaluate(e, t);
   // eslint-disable-next-line prefer-const
-    let {mainAxis: g, crossAxis: m, alignmentAxis: p} = typeof u === "number" ? {
+    let {mainAxis: d, crossAxis: m, alignmentAxis: p} = typeof u === "number" ? {
     mainAxis: u,
     crossAxis: 0,
     alignmentAxis: null
@@ -623,9 +622,9 @@ async function convertValueToCoords(t, e) {
   }
   return l ? {
     x: m * f,
-    y: g * a
+    y: d * a
   } : {
-    x: g * a,
+    x: d * a,
     y: m * f
   };
 }
@@ -781,23 +780,23 @@ function isShadowRoot(t) {
   return t instanceof ShadowRoot || t instanceof getWindow(t).ShadowRoot;
 }
 
-const m =  new Set([ "inline", "contents" ]);
+const d =  new Set([ "inline", "contents" ]);
 
 function isOverflowElement(t) {
   const {overflow: e, overflowX: n, overflowY: o, display: i} = getComputedStyle$1(t);
-  return /auto|scroll|overlay|hidden|clip/.test(e + o + n) && !m.has(i);
+  return /auto|scroll|overlay|hidden|clip/.test(e + o + n) && !d.has(i);
 }
 
-const p =  new Set([ "table", "td", "th" ]);
+const m =  new Set([ "table", "td", "th" ]);
 
 function isTableElement(t) {
-  return p.has(getNodeName(t));
+  return m.has(getNodeName(t));
 }
 
-const h = [ ":popover-open", ":modal" ];
+const p = [ ":popover-open", ":modal" ];
 
 function isTopLayer(t) {
-  return h.some((e => {
+  return p.some((e => {
     try {
       return t.matches(e);
     } catch (t) {
@@ -806,18 +805,18 @@ function isTopLayer(t) {
   }));
 }
 
-const w = [ "transform", "translate", "scale", "rotate", "perspective" ];
+const h = [ "transform", "translate", "scale", "rotate", "perspective" ];
 
-const y = [ "transform", "translate", "scale", "rotate", "perspective", "filter" ];
+const w = [ "transform", "translate", "scale", "rotate", "perspective", "filter" ];
 
-const v = [ "paint", "layout", "strict", "content" ];
+const y = [ "paint", "layout", "strict", "content" ];
 
 function isContainingBlock(t) {
   const e = isWebKit();
   const n = isElement(t) ? getComputedStyle$1(t) : t;
   // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
   // https://drafts.csswg.org/css-transforms-2/#individual-transforms
-    return w.some((t => n[t] ? n[t] !== "none" : false)) || (n.containerType ? n.containerType !== "normal" : false) || !e && (n.backdropFilter ? n.backdropFilter !== "none" : false) || !e && (n.filter ? n.filter !== "none" : false) || y.some((t => (n.willChange || "").includes(t))) || v.some((t => (n.contain || "").includes(t)));
+    return h.some((t => n[t] ? n[t] !== "none" : false)) || (n.containerType ? n.containerType !== "normal" : false) || !e && (n.backdropFilter ? n.backdropFilter !== "none" : false) || !e && (n.filter ? n.filter !== "none" : false) || w.some((t => (n.willChange || "").includes(t))) || y.some((t => (n.contain || "").includes(t)));
 }
 
 function getContainingBlock(t) {
@@ -838,10 +837,10 @@ function isWebKit() {
   return CSS.supports("-webkit-backdrop-filter", "none");
 }
 
-const x =  new Set([ "html", "body", "#document" ]);
+const v =  new Set([ "html", "body", "#document" ]);
 
 function isLastTraversableNode(t) {
-  return x.has(getNodeName(t));
+  return v.has(getNodeName(t));
 }
 
 function getComputedStyle$1(t) {
@@ -915,18 +914,18 @@ function getCssDimensions(t) {
   // In testing environments, the `width` and `height` properties are empty
   // strings for SVG elements, returning NaN. Fallback to `0` in this case.
     let n = parseFloat(e.width) || 0;
-  let o = parseFloat(e.height) || 0;
+  let i = parseFloat(e.height) || 0;
   const s = isHTMLElement(t);
   const r = s ? t.offsetWidth : n;
-  const c = s ? t.offsetHeight : o;
-  const l = i(n) !== r || i(o) !== c;
+  const c = s ? t.offsetHeight : i;
+  const l = o(n) !== r || o(i) !== c;
   if (l) {
     n = r;
-    o = c;
+    i = c;
   }
   return {
     width: n,
-    height: o,
+    height: i,
     $: l
   };
 }
@@ -941,9 +940,9 @@ function getScale(t) {
     return createCoords(1);
   }
   const n = e.getBoundingClientRect();
-  const {width: o, height: s, $: r} = getCssDimensions(e);
-  let c = (r ? i(n.width) : n.width) / o;
-  let l = (r ? i(n.height) : n.height) / s;
+  const {width: i, height: s, $: r} = getCssDimensions(e);
+  let c = (r ? o(n.width) : n.width) / i;
+  let l = (r ? o(n.height) : n.height) / s;
   // 0, NaN, or Infinity should always fallback to 1.
     if (!c || !Number.isFinite(c)) {
     c = 1;
@@ -957,12 +956,12 @@ function getScale(t) {
   };
 }
 
-const b =  createCoords(0);
+const x =  createCoords(0);
 
 function getVisualOffsets(t) {
   const e = getWindow(t);
   if (!isWebKit() || !e.visualViewport) {
-    return b;
+    return x;
   }
   return {
     x: e.visualViewport.offsetLeft,
@@ -1096,14 +1095,14 @@ function getClientRects(t) {
 // of the `<html>` and `<body>` rect bounds if horizontally scrollable.
 function getDocumentRect(t) {
   const e = getDocumentElement(t);
-  const n = getNodeScroll(t);
+  const o = getNodeScroll(t);
   const i = t.ownerDocument.body;
-  const s = o(e.scrollWidth, e.clientWidth, i.scrollWidth, i.clientWidth);
-  const r = o(e.scrollHeight, e.clientHeight, i.scrollHeight, i.clientHeight);
-  let c = -n.scrollLeft + getWindowScrollBarX(t);
-  const l = -n.scrollTop;
+  const s = n(e.scrollWidth, e.clientWidth, i.scrollWidth, i.clientWidth);
+  const r = n(e.scrollHeight, e.clientHeight, i.scrollHeight, i.clientHeight);
+  let c = -o.scrollLeft + getWindowScrollBarX(t);
+  const l = -o.scrollTop;
   if (getComputedStyle$1(i).direction === "rtl") {
-    c += o(e.clientWidth, i.clientWidth) - s;
+    c += n(e.clientWidth, i.clientWidth) - s;
   }
   return {
     width: s,
@@ -1116,7 +1115,7 @@ function getDocumentRect(t) {
 // Safety check: ensure the scrollbar space is reasonable in case this
 // calculation is affected by unusual styles.
 // Most scrollbars leave 15-18px of space.
-const S = 25;
+const b = 25;
 
 function getViewportRect(t, e) {
   const n = getWindow(t);
@@ -1145,10 +1144,10 @@ function getViewportRect(t, e) {
     const n = getComputedStyle(e);
     const i = t.compatMode === "CSS1Compat" ? parseFloat(n.marginLeft) + parseFloat(n.marginRight) || 0 : 0;
     const r = Math.abs(o.clientWidth - e.clientWidth - i);
-    if (r <= S) {
+    if (r <= b) {
       s -= r;
     }
-  } else if (a <= S) {
+  } else if (a <= b) {
     // If the <body> scrollbar is on the left, the width needs to be extended
     // by the scrollbar amount so there isn't extra space on the right.
     s += a;
@@ -1161,7 +1160,7 @@ function getViewportRect(t, e) {
   };
 }
 
-const A =  new Set([ "absolute", "fixed" ]);
+const S =  new Set([ "absolute", "fixed" ]);
 
 // Returns the inner client rect, subtracting scrollbars if present.
 function getInnerBoundingClientRect(t, e) {
@@ -1228,7 +1227,7 @@ function getClippingElementAncestors(t, e) {
     if (!n && e.position === "fixed") {
       i = null;
     }
-    const c = s ? !n && !i : !n && e.position === "static" && !!i && A.has(i.position) || isOverflowElement(r) && !n && hasFixedPositionAncestor(t, r);
+    const c = s ? !n && !i : !n && e.position === "static" && !!i && S.has(i.position) || isOverflowElement(r) && !n && hasFixedPositionAncestor(t, r);
     if (c) {
       // Drop non-containing blocks.
       o = o.filter((t => t !== r));
@@ -1245,18 +1244,18 @@ function getClippingElementAncestors(t, e) {
 // Gets the maximum area that the element is visible in due to any number of
 // clipping ancestors.
 function getClippingRect(t) {
-  let {element: e, boundary: i, rootBoundary: s, strategy: r} = t;
-  const c = i === "clippingAncestors" ? isTopLayer(e) ? [] : getClippingElementAncestors(e, this._c) : [].concat(i);
+  let {element: o, boundary: i, rootBoundary: s, strategy: r} = t;
+  const c = i === "clippingAncestors" ? isTopLayer(o) ? [] : getClippingElementAncestors(o, this._c) : [].concat(i);
   const l = [ ...c, s ];
   const a = l[0];
   const f = l.reduce(((t, i) => {
-    const s = getClientRectFromClippingAncestor(e, i, r);
-    t.top = o(s.top, t.top);
-    t.right = n(s.right, t.right);
-    t.bottom = n(s.bottom, t.bottom);
-    t.left = o(s.left, t.left);
+    const s = getClientRectFromClippingAncestor(o, i, r);
+    t.top = n(s.top, t.top);
+    t.right = e(s.right, t.right);
+    t.bottom = e(s.bottom, t.bottom);
+    t.left = n(s.left, t.left);
     return t;
-  }), getClientRectFromClippingAncestor(e, a, r));
+  }), getClientRectFromClippingAncestor(o, a, r));
   return {
     width: f.right - f.left,
     height: f.bottom - f.top,
@@ -1382,7 +1381,7 @@ function isRTL(t) {
   return getComputedStyle$1(t).direction === "rtl";
 }
 
-const O = {
+const A = {
   convertOffsetParentRelativeRectToViewportRelativeRect,
   getDocumentElement,
   getClippingRect,
@@ -1400,15 +1399,15 @@ function rectsAreEqual(t, e) {
 }
 
 // https://samthor.au/2021/observing-dom/
-function observeMove(t, e) {
-  let i = null;
+function observeMove(t, o) {
+  let s = null;
   let r;
   const c = getDocumentElement(t);
   function cleanup() {
     var t;
     clearTimeout(r);
-    (t = i) == null || t.disconnect();
-    i = null;
+    (t = s) == null || t.disconnect();
+    s = null;
   }
   function refresh(l, a) {
     if (l === void 0) {
@@ -1421,19 +1420,19 @@ function observeMove(t, e) {
     const f = t.getBoundingClientRect();
     const {left: u, top: g, width: d, height: m} = f;
     if (!l) {
-      e();
+      o();
     }
     if (!d || !m) {
       return;
     }
-    const p = s(g);
-    const h = s(c.clientWidth - (u + d));
-    const w = s(c.clientHeight - (g + m));
-    const y = s(u);
+    const p = i(g);
+    const h = i(c.clientWidth - (u + d));
+    const w = i(c.clientHeight - (g + m));
+    const y = i(u);
     const v = -p + "px " + -h + "px " + -w + "px " + -y + "px";
     const x = {
       rootMargin: v,
-      threshold: o(0, n(1, a)) || 1
+      threshold: n(0, e(1, a)) || 1
     };
     let b = true;
     function handleObserve(e) {
@@ -1467,15 +1466,15 @@ function observeMove(t, e) {
     // Older browsers don't support a `document` as the root and will throw an
     // error.
         try {
-      i = new IntersectionObserver(handleObserve, {
+      s = new IntersectionObserver(handleObserve, {
         ...x,
         // Handle <iframe>s
         root: c.ownerDocument
       });
     } catch (t) {
-      i = new IntersectionObserver(handleObserve, x);
+      s = new IntersectionObserver(handleObserve, x);
     }
-    i.observe(t);
+    s.observe(t);
   }
   refresh(true);
   return cleanup;
@@ -1559,20 +1558,20 @@ function observeMove(t, e) {
  * A number (shorthand for `mainAxis` or distance), or an axes configuration
  * object may be passed.
  * @see https://floating-ui.com/docs/offset
- */ const C = offset$1;
+ */ const O = offset$1;
 
 /**
  * Optimizes the visibility of the floating element by shifting it in order to
  * keep it in view when it will overflow the clipping boundary.
  * @see https://floating-ui.com/docs/shift
- */ const E = shift$1;
+ */ const C = shift$1;
 
 /**
  * Optimizes the visibility of the floating element by flipping the `placement`
  * in order to keep it in view when the preferred placement(s) will overflow the
  * clipping boundary. Alternative to `autoPlacement`.
  * @see https://floating-ui.com/docs/flip
- */ const P = flip$1;
+ */ const E = flip$1;
 
 /**
  * Provides data to hide the floating element in applicable situations, such as
@@ -1584,7 +1583,7 @@ function observeMove(t, e) {
  * Provides data to position an inner element of the floating element so that it
  * appears centered to the reference element.
  * @see https://floating-ui.com/docs/arrow
- */ const T = arrow$1;
+ */ const P = arrow$1;
 
 /**
  * Computes the `x` and `y` coordinates that will place the floating element
@@ -1595,7 +1594,7 @@ function observeMove(t, e) {
   // single call. If other functions become expensive, we can add them as well.
   const o = new Map;
   const i = {
-    platform: O,
+    platform: A,
     ...n
   };
   const s = {
@@ -1612,7 +1611,7 @@ function observeMove(t, e) {
  * FloatingUIManager é uma classe utilitária que gerencia o posicionamento de elementos flutuantes
  * como tooltips ou popovers em relação a um elemento de disparo (trigger).
  * Ela utiliza a biblioteca Floating UI para calcular posições e lidar com atualizações.
- */ class L {
+ */ class T {
   constructor(t) {
     var e;
     this.triggerElement = t.triggerElement;
@@ -1639,18 +1638,16 @@ function observeMove(t, e) {
      * Também atualiza a posição da seta, se fornecida.
      * Além disso, define o atributo de dados `data-placement` no elemento de conteúdo para refletir a posição atual.
      * @returns {Promise<void>} Uma promessa que resolve quando a posição é atualizada.
-     */  updatePosition() {
-    return t(this, void 0, void 0, (function*() {
-      var t;
-      const e = yield computePosition(this.triggerElement, this.contentElement, {
-        placement: this.placement,
-        middleware: this.buildMiddleware()
-      });
-      this.updateTooltipPosition(e);
-      this.updateArrowPosition(e);
-      this.setPlacementDataAttribute(e);
-      (t = this.onUpdate) === null || t === void 0 ? void 0 : t.call(this, e);
-    }));
+     */  async updatePosition() {
+    var t;
+    const e = await computePosition(this.triggerElement, this.contentElement, {
+      placement: this.placement,
+      middleware: this.buildMiddleware()
+    });
+    this.updateTooltipPosition(e);
+    this.updateArrowPosition(e);
+    this.setPlacementDataAttribute(e);
+    (t = this.onUpdate) === null || t === void 0 ? void 0 : t.call(this, e);
   }
   /**
      * Constrói os middlewares necessários para o Floating UI.
@@ -1658,11 +1655,11 @@ function observeMove(t, e) {
      * incluindo offset, flip, shift e hide. Se uma seta for fornecida, o middleware de seta também é adicionado.
      * @returns {Middleware[]} Retorna um array de middlewares configurados para o Floating UI.
      */  buildMiddleware() {
-    const t = [ C(8), P(), E({
+    const t = [ O(8), E(), C({
       padding: 5
     }), R() ];
     if (this.arrowElement != null) {
-      t.push(T({
+      t.push(P({
         element: this.arrowElement
       }));
     }
@@ -1716,6 +1713,6 @@ function observeMove(t, e) {
   }
 }
 
-export { L as F };
-//# sourceMappingURL=p-B4au_byv.js.map
-//# sourceMappingURL=p-B4au_byv.js.map
+export { T as F };
+//# sourceMappingURL=p-k0WZfTfL.js.map
+//# sourceMappingURL=p-k0WZfTfL.js.map