@kong/kongponents 9.56.2 → 9.56.3-pr.3225.360dfd9.0

package/dist/kongponents.es328.js

@@ -1,6 +1,47 @@
-import f from "./kongponents.es329.js";
-import t from "./kongponents.es330.js";
-var r = typeof exports == "object" && exports && !exports.nodeType && exports, e = r && typeof module == "object" && module && !module.nodeType && module, u = e && e.exports === r, o = u ? f.Buffer : void 0, p = o ? o.isBuffer : void 0, a = p || t;
+import { defineComponent as d, useCssVars as i, ref as s, computed as u, onMounted as m, onUnmounted as g, openBlock as l, createElementBlock as a, createElementVNode as o, unref as v, normalizeStyle as p, createCommentVNode as f } from "vue";
+import h from "./kongponents.es428.js";
+const I = {
+  class: "fullscreen-loading-container",
+  "data-testid": "full-screen-loader"
+}, _ = ["src"], k = {
+  key: 0,
+  class: "progress"
+}, z = /* @__PURE__ */ d({
+  __name: "FullScreenKongSkeleton",
+  props: {
+    progress: {},
+    hideProgress: { type: Boolean },
+    zIndex: {}
+  },
+  setup(r) {
+    i((t) => ({
+      v4d434712: t.zIndex
+    }));
+    const n = s(0), e = s(0), c = u(() => r.progress !== null ? r.progress : e.value);
+    return m(() => {
+      r.progress || (n.value = setInterval(() => {
+        e.value >= 100 && (clearInterval(n.value), e.value = 100), e.value = Math.min(e.value + Math.ceil(Math.random() * 10 * 30), 100);
+      }, 200));
+    }), g(() => {
+      clearInterval(n.value);
+    }), (t, x) => (l(), a("div", I, [
+      o("div", null, [
+        o("img", {
+          alt: "Loading",
+          src: v(h)
+        }, null, 8, _),
+        r.hideProgress ? f("", !0) : (l(), a("div", k, [
+          o("div", {
+            class: "progress-bar",
+            role: "progressbar",
+            style: p({ width: `${c.value}%` }),
+            title: "Loading"
+          }, null, 4)
+        ]))
+      ])
+    ]));
+  }
+});
 export {
-  a as default
+  z as default
 };

package/dist/kongponents.es330.js

@@ -1,6 +1,43 @@
-function e() {
-  return !1;
-}
+import { defineComponent as u, useCssVars as c, ref as o, computed as v, onMounted as m, onUnmounted as p, openBlock as a, createElementBlock as i, createElementVNode as s, normalizeStyle as g, createCommentVNode as f } from "vue";
+const h = {
+  class: "fullscreen-loading-container",
+  "data-testid": "full-screen-spinner-loader"
+}, I = {
+  key: 0,
+  class: "progress"
+}, y = /* @__PURE__ */ u({
+  __name: "FullScreenGenericSpinner",
+  props: {
+    progress: {},
+    hideProgress: { type: Boolean },
+    zIndex: {}
+  },
+  setup(r) {
+    c((l) => ({
+      v07a3a490: l.zIndex
+    }));
+    const n = o(0), e = o(0), d = v(() => r.progress !== null ? r.progress : e.value);
+    return m(() => {
+      r.progress || (n.value = setInterval(() => {
+        e.value >= 100 && (clearInterval(n.value), e.value = 100), e.value = Math.min(e.value + Math.ceil(Math.random() * 10 * 30), 100);
+      }, 200));
+    }), p(() => {
+      clearInterval(n.value);
+    }), (l, t) => (a(), i("div", h, [
+      s("div", null, [
+        t[0] || (t[0] = s("div", { class: "spinner-loader" }, null, -1)),
+        r.hideProgress ? f("", !0) : (a(), i("div", I, [
+          s("div", {
+            class: "progress-bar",
+            role: "progressbar",
+            style: g({ width: `${d.value}%` }),
+            title: "Loading"
+          }, null, 4)
+        ]))
+      ])
+    ]));
+  }
+});
 export {
-  e as default
+  y as default
 };

package/dist/kongponents.es332.js

@@ -1,9 +1,177 @@
-import t from "./kongponents.es331.js";
-import m from "./kongponents.es323.js";
-var r = "[object Symbol]";
-function i(o) {
-  return typeof o == "symbol" || m(o) && t(o) == r;
-}
+import { defineComponent as J, useModel as I, ref as M, useId as K, computed as k, onMounted as L, watch as V, openBlock as u, createElementBlock as v, createBlock as P, unref as c, mergeProps as B, createElementVNode as d, toDisplayString as R, createCommentVNode as g, withDirectives as A, normalizeClass as S, vModelText as U, Fragment as Q, createVNode as X, Transition as Z, withCtx as _, mergeModels as ee, nextTick as te } from "vue";
+import { DatePicker as Y } from "./kongponents.es431.js";
+import ae from "./kongponents.es420.js";
+import ne from "./kongponents.es425.js";
+import G from "./kongponents.es229.js";
+import le from "./kongponents.es423.js";
+const ie = { class: "calendar-wrapper" }, re = {
+  key: 2,
+  class: "time-wrapper"
+}, ue = { class: "time-inputs-container" }, se = { class: "time-input-column" }, oe = ["for"], de = { key: 0 }, me = { key: 1 }, ve = ["id", "step"], ce = { class: "time-input-column" }, fe = ["for"], ye = { key: 0 }, ge = ["id", "step"], De = {
+  key: 0,
+  class: "help-text"
+}, be = /* @__PURE__ */ J({
+  __name: "CalendarWrapper",
+  props: /* @__PURE__ */ ee({
+    isRange: { type: Boolean },
+    kDatePickerMode: {},
+    maxDate: { default: () => {
+    } },
+    minDate: { default: () => {
+    } },
+    errorMessage: { default: () => {
+    } },
+    timeGranularity: { default: "minutely" },
+    sameDayFullRange: { type: Boolean, default: !1 },
+    customRangeValidation: { type: Function, default: void 0 }
+  }, {
+    modelValue: { required: !0 },
+    modelModifiers: {},
+    error: { type: Boolean, default: !1 },
+    errorModifiers: {}
+  }),
+  emits: ["update:modelValue", "update:error"],
+  setup(t, { expose: $ }) {
+    const l = (n, a) => a === "secondly" ? G(n, "HH:mm:ss") : G(n, "HH:mm"), e = I(t, "modelValue"), f = I(t, "error"), r = M(l(/* @__PURE__ */ new Date(), t.timeGranularity)), s = M(l(/* @__PURE__ */ new Date(), t.timeGranularity)), D = M(!1), m = M({
+      start: l(/* @__PURE__ */ new Date(), t.timeGranularity),
+      end: l(/* @__PURE__ */ new Date(), t.timeGranularity)
+    }), h = K(), N = k(() => t.isRange && o(e.value) ? { year: e.value.start.getFullYear(), month: e.value.start.getMonth() + 1 } : e.value instanceof Date ? { year: e.value.getFullYear(), month: e.value.getMonth() + 1 } : t.maxDate && ae(t.maxDate, ne()) ? { year: t.maxDate.getFullYear(), month: t.maxDate.getMonth() + 1 } : { year: (/* @__PURE__ */ new Date()).getFullYear(), month: (/* @__PURE__ */ new Date()).getMonth() + 1 }), w = k(() => ({
+      borderless: !0,
+      color: "blue",
+      dragAttribute: j,
+      expanded: !0,
+      initialPage: N.value,
+      maxDate: t.maxDate,
+      minDate: t.minDate,
+      mode: "date",
+      modelConfig: W,
+      selectAttribute: q,
+      transparent: !0,
+      trimWeeks: !0
+    })), x = k(() => ["time", "dateTime", "relativeDateTime"].includes(t.kDatePickerMode)), C = k(() => {
+      switch (t.timeGranularity) {
+        case "minutely":
+          return 60;
+        case "secondly":
+          return 1;
+        default:
+          return 60;
+      }
+    }), b = (n, a) => n > a ? !0 : t.customRangeValidation ? t.customRangeValidation(n, a) : !1, o = (n) => !n || typeof n != "object" || !("start" in n) || !("end" in n) ? !1 : n.start instanceof Date && n.end instanceof Date, p = async () => !t.sameDayFullRange || !t.isRange || !o(e.value) || !le(e.value.start, e.value.end) ? !1 : (D.value = !0, r.value = "00:00", s.value = "23:59", e.value.start.setHours(0, 0, 0, 0), e.value.end.setHours(23, 59, 59, 999), await te(), D.value = !1, !0), T = () => {
+      x.value && (t.isRange && o(e.value) ? (r.value = l(e.value.start, t.timeGranularity), s.value = l(e.value.end, t.timeGranularity)) : e.value instanceof Date ? r.value = l(e.value, t.timeGranularity) : r.value = l(/* @__PURE__ */ new Date(), t.timeGranularity));
+    }, F = (n) => {
+      const a = n.split(":"), i = parseInt(a[0] ?? "0", 10), y = parseInt(a[1] ?? "0", 10), O = t.timeGranularity === "secondly" && a[2] ? parseInt(a[2], 10) : 0;
+      return { hours: i, minutes: y, seconds: O };
+    };
+    L(() => {
+      T(), m.value.start = r.value, m.value.end = s.value;
+    });
+    const W = { type: "number" }, j = {
+      key: "select-drag",
+      highlight: {
+        start: { contentClass: "vcal-day-drag-start" },
+        base: { contentClass: "vcal-day-drag-base" },
+        end: { contentClass: "vcal-day-drag-end" }
+      }
+    }, q = {
+      key: "select-calendar",
+      highlight: {
+        start: { contentClass: "vcal-day-start" },
+        base: { contentClass: "vcal-day-base" },
+        end: { contentClass: "vcal-day-end" }
+      }
+    };
+    V(() => r.value, (n) => {
+      if (!n || D.value)
+        return;
+      const { hours: a, minutes: i, seconds: y } = F(n);
+      t.isRange && o(e.value) ? (e.value.start.setHours(a, i, y, 0), f.value = b(e.value.start, e.value.end)) : e.value instanceof Date && e.value.setHours(a, i, y, 0);
+    }), V(() => s.value, (n) => {
+      if (!n || D.value)
+        return;
+      const { hours: a, minutes: i, seconds: y } = F(n);
+      t.isRange && o(e.value) && (e.value.end.setHours(a, i, y, 0), f.value = b(e.value.start, e.value.end));
+    }), V(() => e.value, () => {
+      t.isRange && o(e.value) ? (p() || (r.value = l(e.value.start, t.timeGranularity), s.value = l(e.value.end, t.timeGranularity)), f.value = b(e.value.start, e.value.end)) : e.value instanceof Date && (r.value = l(e.value, t.timeGranularity));
+    }, { immediate: !0, deep: !0 }), V(() => t.timeGranularity, () => {
+      t.isRange && o(e.value) ? (m.value.start = l(e.value.start, t.timeGranularity), m.value.end = l(e.value.end, t.timeGranularity)) : e.value instanceof Date && (m.value.start = l(e.value, t.timeGranularity));
+    });
+    const E = () => t.isRange && o(e.value), z = () => {
+      r.value = m.value.start, s.value = m.value.end;
+    }, H = (n) => {
+      try {
+        return G(n, "EEE MMM d yyyy");
+      } catch (a) {
+        console.warn("Error formatting date:", a);
+      }
+    };
+    return $({
+      resetTime: z,
+      initTimeInputs: T
+    }), (n, a) => (u(), v("div", ie, [
+      t.isRange ? (u(), P(c(Y), B({ key: 0 }, w.value, {
+        modelValue: e.value,
+        "onUpdate:modelValue": a[0] || (a[0] = (i) => e.value = i),
+        modelModifiers: { range: !0 }
+      }), null, 16, ["modelValue"])) : (u(), P(c(Y), B({ key: 1 }, w.value, {
+        modelValue: e.value,
+        "onUpdate:modelValue": a[1] || (a[1] = (i) => e.value = i)
+      }), null, 16, ["modelValue"])),
+      x.value ? (u(), v("div", re, [
+        d("div", ue, [
+          d("div", se, [
+            d("label", {
+              class: "time-input-label",
+              for: `time-input-start-${c(h)}`
+            }, [
+              E() ? (u(), v("span", de, R(H(e.value.start)), 1)) : e.value && e.value instanceof Date ? (u(), v("span", me, R(H(e.value)), 1)) : g("", !0)
+            ], 8, oe),
+            A(d("input", {
+              id: `time-input-start-${c(h)}`,
+              "onUpdate:modelValue": a[2] || (a[2] = (i) => r.value = i),
+              class: S(["time-input-start", { "input-error": f.value }]),
+              "data-testid": "time-input-start",
+              step: C.value,
+              type: "time"
+            }, null, 10, ve), [
+              [U, r.value]
+            ])
+          ]),
+          t.isRange ? (u(), v(Q, { key: 0 }, [
+            a[4] || (a[4] = d("div", { class: "time-input-separator" }, " - ", -1)),
+            d("div", ce, [
+              d("label", {
+                class: "time-input-label",
+                for: `time-input-end-${c(h)}`
+              }, [
+                E() ? (u(), v("span", ye, R(c(G)(e.value.end, "EEE MMM d yyyy")), 1)) : g("", !0)
+              ], 8, fe),
+              A(d("input", {
+                id: `time-input-end-${c(h)}`,
+                "onUpdate:modelValue": a[3] || (a[3] = (i) => s.value = i),
+                class: S(["time-input-end", { "input-error": f.value }]),
+                "data-testid": "time-input-end",
+                step: C.value,
+                type: "time"
+              }, null, 10, ge), [
+                [U, s.value]
+              ])
+            ])
+          ], 64)) : g("", !0)
+        ]),
+        X(Z, {
+          mode: "out-in",
+          name: "kongponents-fade-transition"
+        }, {
+          default: _(() => [
+            f.value && t.errorMessage ? (u(), v("div", De, R(t.errorMessage), 1)) : g("", !0)
+          ]),
+          _: 1
+        })
+      ])) : g("", !0)
+    ]));
+  }
+});
 export {
-  i as default
+  be as default
 };

package/dist/kongponents.es334.js

@@ -1,12 +1,377 @@
-import e from "./kongponents.es331.js";
-import r from "./kongponents.es327.js";
-import o from "./kongponents.es323.js";
-var g = "[object Arguments]", b = "[object Array]", c = "[object Boolean]", j = "[object Date]", n = "[object Error]", T = "[object Function]", i = "[object Map]", y = "[object Number]", p = "[object Object]", A = "[object RegExp]", f = "[object Set]", u = "[object String]", m = "[object WeakMap]", s = "[object ArrayBuffer]", l = "[object DataView]", d = "[object Float32Array]", I = "[object Float64Array]", U = "[object Int8Array]", k = "[object Int16Array]", w = "[object Int32Array]", x = "[object Uint8Array]", B = "[object Uint8ClampedArray]", F = "[object Uint16Array]", M = "[object Uint32Array]", a = {};
-a[d] = a[I] = a[U] = a[k] = a[w] = a[x] = a[B] = a[F] = a[M] = !0;
-a[g] = a[b] = a[s] = a[c] = a[l] = a[j] = a[n] = a[T] = a[i] = a[y] = a[p] = a[A] = a[f] = a[u] = a[m] = !1;
-function E(t) {
-  return o(t) && r(t.length) && !!a[e(t)];
+import { evaluate as j, getSideAxis as T, getSide as L, clamp as X, getOppositePlacement as q, getExpandedPlacements as z, getOppositeAxisPlacements as G, getAlignmentSides as U, placements as I, getAlignment as D, getOppositeAxis as H, getOppositeAlignmentPlacement as J, getAlignmentAxis as K, getPaddingObject as Q, rectToClientRect as Y, getAxisLength as Z } from "./kongponents.es335.js";
+function N(t, i, f) {
+  let {
+    reference: n,
+    floating: e
+  } = t;
+  const o = T(i), s = K(i), l = Z(s), g = L(i), A = o === "y", x = n.x + n.width / 2 - e.width / 2, a = n.y + n.height / 2 - e.height / 2, c = n[l] / 2 - e[l] / 2;
+  let r;
+  switch (g) {
+    case "top":
+      r = {
+        x,
+        y: n.y - e.height
+      };
+      break;
+    case "bottom":
+      r = {
+        x,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      r = {
+        x: n.x + n.width,
+        y: a
+      };
+      break;
+    case "left":
+      r = {
+        x: n.x - e.width,
+        y: a
+      };
+      break;
+    default:
+      r = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (D(i)) {
+    case "start":
+      r[s] -= c * (f && A ? -1 : 1);
+      break;
+    case "end":
+      r[s] += c * (f && A ? -1 : 1);
+      break;
+  }
+  return r;
 }
+async function ee(t, i) {
+  var f;
+  i === void 0 && (i = {});
+  const {
+    x: n,
+    y: e,
+    platform: o,
+    rects: s,
+    elements: l,
+    strategy: g
+  } = t, {
+    boundary: A = "clippingAncestors",
+    rootBoundary: x = "viewport",
+    elementContext: a = "floating",
+    altBoundary: c = !1,
+    padding: r = 0
+  } = j(i, t), m = Q(r), h = l[c ? a === "floating" ? "reference" : "floating" : a], d = Y(await o.getClippingRect({
+    element: (f = await (o.isElement == null ? void 0 : o.isElement(h))) == null || f ? h : h.contextElement || await (o.getDocumentElement == null ? void 0 : o.getDocumentElement(l.floating)),
+    boundary: A,
+    rootBoundary: x,
+    strategy: g
+  })), u = a === "floating" ? {
+    x: n,
+    y: e,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, p = await (o.getOffsetParent == null ? void 0 : o.getOffsetParent(l.floating)), y = await (o.isElement == null ? void 0 : o.isElement(p)) ? await (o.getScale == null ? void 0 : o.getScale(p)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, P = Y(o.convertOffsetParentRelativeRectToViewportRelativeRect ? await o.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: l,
+    rect: u,
+    offsetParent: p,
+    strategy: g
+  }) : u);
+  return {
+    top: (d.top - P.top + m.top) / y.y,
+    bottom: (P.bottom - d.bottom + m.bottom) / y.y,
+    left: (d.left - P.left + m.left) / y.x,
+    right: (P.right - d.right + m.right) / y.x
+  };
+}
+const te = 50, oe = async (t, i, f) => {
+  const {
+    placement: n = "bottom",
+    strategy: e = "absolute",
+    middleware: o = [],
+    platform: s
+  } = f, l = s.detectOverflow ? s : {
+    ...s,
+    detectOverflow: ee
+  }, g = await (s.isRTL == null ? void 0 : s.isRTL(i));
+  let A = await s.getElementRects({
+    reference: t,
+    floating: i,
+    strategy: e
+  }), {
+    x,
+    y: a
+  } = N(A, n, g), c = n, r = 0;
+  const m = {};
+  for (let w = 0; w < o.length; w++) {
+    const h = o[w];
+    if (!h)
+      continue;
+    const {
+      name: d,
+      fn: u
+    } = h, {
+      x: p,
+      y,
+      data: P,
+      reset: O
+    } = await u({
+      x,
+      y: a,
+      initialPlacement: n,
+      placement: c,
+      strategy: e,
+      middlewareData: m,
+      rects: A,
+      platform: l,
+      elements: {
+        reference: t,
+        floating: i
+      }
+    });
+    x = p ?? x, a = y ?? a, m[d] = {
+      ...m[d],
+      ...P
+    }, O && r < te && (r++, typeof O == "object" && (O.placement && (c = O.placement), O.rects && (A = O.rects === !0 ? await s.getElementRects({
+      reference: t,
+      floating: i,
+      strategy: e
+    }) : O.rects), {
+      x,
+      y: a
+    } = N(A, c, g)), w = -1);
+  }
+  return {
+    x,
+    y: a,
+    placement: c,
+    strategy: e,
+    middlewareData: m
+  };
+};
+function ne(t, i, f) {
+  return (t ? [...f.filter((e) => D(e) === t), ...f.filter((e) => D(e) !== t)] : f.filter((e) => L(e) === e)).filter((e) => t ? D(e) === t || (i ? J(e) !== e : !1) : !0);
+}
+const le = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "autoPlacement",
+    options: t,
+    async fn(i) {
+      var f, n, e;
+      const {
+        rects: o,
+        middlewareData: s,
+        placement: l,
+        platform: g,
+        elements: A
+      } = i, {
+        crossAxis: x = !1,
+        alignment: a,
+        allowedPlacements: c = I,
+        autoAlignment: r = !0,
+        ...m
+      } = j(t, i), w = a !== void 0 || c === I ? ne(a || null, r, c) : c, h = await g.detectOverflow(i, m), d = ((f = s.autoPlacement) == null ? void 0 : f.index) || 0, u = w[d];
+      if (u == null)
+        return {};
+      const p = U(u, o, await (g.isRTL == null ? void 0 : g.isRTL(A.floating)));
+      if (l !== u)
+        return {
+          reset: {
+            placement: w[0]
+          }
+        };
+      const y = [h[L(u)], h[p[0]], h[p[1]]], P = [...((n = s.autoPlacement) == null ? void 0 : n.overflows) || [], {
+        placement: u,
+        overflows: y
+      }], O = w[d + 1];
+      if (O)
+        return {
+          data: {
+            index: d + 1,
+            overflows: P
+          },
+          reset: {
+            placement: O
+          }
+        };
+      const B = P.map((v) => {
+        const S = D(v.placement);
+        return [v.placement, S && x ? (
+          // Check along the mainAxis and main crossAxis side.
+          v.overflows.slice(0, 2).reduce((_, $) => _ + $, 0)
+        ) : (
+          // Check only the mainAxis.
+          v.overflows[0]
+        ), v.overflows];
+      }).sort((v, S) => v[1] - S[1]), k = ((e = B.filter((v) => v[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        D(v[0]) ? 2 : 3
+      ).every((S) => S <= 0))[0]) == null ? void 0 : e[0]) || B[0][0];
+      return k !== l ? {
+        data: {
+          index: d + 1,
+          overflows: P
+        },
+        reset: {
+          placement: k
+        }
+      } : {};
+    }
+  };
+}, se = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    async fn(i) {
+      var f, n;
+      const {
+        placement: e,
+        middlewareData: o,
+        rects: s,
+        initialPlacement: l,
+        platform: g,
+        elements: A
+      } = i, {
+        mainAxis: x = !0,
+        crossAxis: a = !0,
+        fallbackPlacements: c,
+        fallbackStrategy: r = "bestFit",
+        fallbackAxisSideDirection: m = "none",
+        flipAlignment: w = !0,
+        ...h
+      } = j(t, i);
+      if ((f = o.arrow) != null && f.alignmentOffset)
+        return {};
+      const d = L(e), u = T(l), p = L(l) === l, y = await (g.isRTL == null ? void 0 : g.isRTL(A.floating)), P = c || (p || !w ? [q(l)] : z(l)), O = m !== "none";
+      !c && O && P.push(...G(l, w, m, y));
+      const B = [l, ...P], M = await g.detectOverflow(i, h), k = [];
+      let v = ((n = o.flip) == null ? void 0 : n.overflows) || [];
+      if (x && k.push(M[d]), a) {
+        const C = U(e, s, y);
+        k.push(M[C[0]], M[C[1]]);
+      }
+      if (v = [...v, {
+        placement: e,
+        overflows: k
+      }], !k.every((C) => C <= 0)) {
+        var S, _;
+        const C = (((S = o.flip) == null ? void 0 : S.index) || 0) + 1, V = B[C];
+        if (V && (!(a === "alignment" ? u !== T(V) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        v.every((b) => T(b.placement) === u ? b.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: C,
+              overflows: v
+            },
+            reset: {
+              placement: V
+            }
+          };
+        let F = (_ = v.filter((E) => E.overflows[0] <= 0).sort((E, b) => E.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _.placement;
+        if (!F)
+          switch (r) {
+            case "bestFit": {
+              var $;
+              const E = ($ = v.filter((b) => {
+                if (O) {
+                  const R = T(b.placement);
+                  return R === u || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  R === "y";
+                }
+                return !0;
+              }).map((b) => [b.placement, b.overflows.filter((R) => R > 0).reduce((R, W) => R + W, 0)]).sort((b, R) => b[1] - R[1])[0]) == null ? void 0 : $[0];
+              E && (F = E);
+              break;
+            }
+            case "initialPlacement":
+              F = l;
+              break;
+          }
+        if (e !== F)
+          return {
+            reset: {
+              placement: F
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, ae = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(i) {
+      const {
+        x: f,
+        y: n,
+        placement: e,
+        platform: o
+      } = i, {
+        mainAxis: s = !0,
+        crossAxis: l = !1,
+        limiter: g = {
+          fn: (d) => {
+            let {
+              x: u,
+              y: p
+            } = d;
+            return {
+              x: u,
+              y: p
+            };
+          }
+        },
+        ...A
+      } = j(t, i), x = {
+        x: f,
+        y: n
+      }, a = await o.detectOverflow(i, A), c = T(L(e)), r = H(c);
+      let m = x[r], w = x[c];
+      if (s) {
+        const d = r === "y" ? "top" : "left", u = r === "y" ? "bottom" : "right", p = m + a[d], y = m - a[u];
+        m = X(p, m, y);
+      }
+      if (l) {
+        const d = c === "y" ? "top" : "left", u = c === "y" ? "bottom" : "right", p = w + a[d], y = w - a[u];
+        w = X(p, w, y);
+      }
+      const h = g.fn({
+        ...i,
+        [r]: m,
+        [c]: w
+      });
+      return {
+        ...h,
+        data: {
+          x: h.x - f,
+          y: h.y - n,
+          enabled: {
+            [r]: s,
+            [c]: l
+          }
+        }
+      };
+    }
+  };
+};
 export {
-  E as default
+  le as autoPlacement,
+  oe as computePosition,
+  ee as detectOverflow,
+  se as flip,
+  Y as rectToClientRect,
+  ae as shift
 };