urfu-ui-kit-react 2.1.2 → 2.1.4

package/dist/vendor/@floating-ui/react/dist/floating-ui.react.js

@@ -0,0 +1,255 @@
+import * as s from "react";
+import { useLayoutEffect as k, useEffect as q } from "react";
+import { jsxs as Q, jsx as O } from "react/jsx-runtime";
+import { isElement$u as F, getComputedStyle$u as Z } from "../../utils/dist/floating-ui.utils.dom.js";
+import { getOverflowAncestors$u as xe } from "../../utils/dist/floating-ui.utils.dom.js";
+import "react-dom";
+import { useFloating$u as z } from "../../react-dom/dist/floating-ui.react-dom.js";
+import { arrow$u as we, flip$u as Ee, offset$u as Se } from "../../react-dom/dist/floating-ui.react-dom.js";
+const $ = {
+  ...s
+}, G = $.useInsertionEffect, J = G || ((t) => t());
+function K(t) {
+  const n = s.useRef(() => {
+    if (process.env.NODE_ENV !== "production")
+      throw new Error("Cannot call an event handler while rendering.");
+  });
+  return J(() => {
+    n.current = t;
+  }), s.useCallback(function() {
+    for (var c = arguments.length, e = new Array(c), o = 0; o < c; o++)
+      e[o] = arguments[o];
+    return n.current == null ? void 0 : n.current(...e);
+  }, []);
+}
+var M = typeof document < "u" ? k : q;
+let y = !1, _ = 0;
+const W = () => (
+  // Ensure the id is unique with multiple independent versions of Floating UI
+  // on <React 18
+  "floating-ui-" + Math.random().toString(36).slice(2, 6) + _++
+);
+function ee() {
+  const [t, n] = s.useState(() => y ? W() : void 0);
+  return M(() => {
+    t == null && n(W());
+  }, []), s.useEffect(() => {
+    y = !0;
+  }, []), t;
+}
+const te = $.useId, B = te || ee;
+let P;
+process.env.NODE_ENV !== "production" && (P = /* @__PURE__ */ new Set());
+function ne() {
+  for (var t, n = arguments.length, c = new Array(n), e = 0; e < n; e++)
+    c[e] = arguments[e];
+  const o = "Floating UI: " + c.join(" ");
+  if (!((t = P) != null && t.has(o))) {
+    var l;
+    (l = P) == null || l.add(o), console.warn(o);
+  }
+}
+function oe() {
+  for (var t, n = arguments.length, c = new Array(n), e = 0; e < n; e++)
+    c[e] = arguments[e];
+  const o = "Floating UI: " + c.join(" ");
+  if (!((t = P) != null && t.has(o))) {
+    var l;
+    (l = P) == null || l.add(o), console.error(o);
+  }
+}
+const pe = /* @__PURE__ */ s.forwardRef(function(n, c) {
+  const {
+    context: {
+      placement: e,
+      elements: {
+        floating: o
+      },
+      middlewareData: {
+        arrow: l,
+        shift: u
+      }
+    },
+    width: i = 14,
+    height: a = 7,
+    tipRadius: I = 0,
+    strokeWidth: d = 0,
+    staticOffset: g,
+    stroke: h,
+    d: r,
+    style: {
+      transform: p,
+      ...R
+    } = {},
+    ...v
+  } = n;
+  process.env.NODE_ENV !== "production" && (c || ne("The `ref` prop is required for `FloatingArrow`."));
+  const x = B(), [E, f] = s.useState(!1);
+  if (M(() => {
+    if (!o) return;
+    Z(o).direction === "rtl" && f(!0);
+  }, [o]), !o)
+    return null;
+  const [m, b] = e.split("-"), D = m === "top" || m === "bottom";
+  let S = g;
+  (D && u != null && u.x || !D && u != null && u.y) && (S = null);
+  const C = d * 2, N = C / 2, A = i / 2 * (I / -8 + 1), T = a / 2 * I / 4, w = !!r, U = S && b === "end" ? "bottom" : "top";
+  let L = S && b === "end" ? "right" : "left";
+  S && E && (L = b === "end" ? "left" : "right");
+  const H = (l == null ? void 0 : l.x) != null ? S || l.x : "", X = (l == null ? void 0 : l.y) != null ? S || l.y : "", V = r || "M0,0" + (" H" + i) + (" L" + (i - A) + "," + (a - T)) + (" Q" + i / 2 + "," + a + " " + A + "," + (a - T)) + " Z", Y = {
+    top: w ? "rotate(180deg)" : "",
+    left: w ? "rotate(90deg)" : "rotate(-90deg)",
+    bottom: w ? "" : "rotate(180deg)",
+    right: w ? "rotate(-90deg)" : "rotate(90deg)"
+  }[m];
+  return /* @__PURE__ */ Q("svg", {
+    ...v,
+    "aria-hidden": !0,
+    ref: c,
+    width: w ? i : i + C,
+    height: i,
+    viewBox: "0 0 " + i + " " + (a > i ? a : i),
+    style: {
+      position: "absolute",
+      pointerEvents: "none",
+      [L]: H,
+      [U]: X,
+      [m]: D || w ? "100%" : "calc(100% - " + C / 2 + "px)",
+      transform: [Y, p].filter((j) => !!j).join(" "),
+      ...R
+    },
+    children: [C > 0 && /* @__PURE__ */ O("path", {
+      clipPath: "url(#" + x + ")",
+      fill: "none",
+      stroke: h,
+      strokeWidth: C + (r ? 0 : 1),
+      d: V
+    }), /* @__PURE__ */ O("path", {
+      stroke: C && !r ? v.fill : "none",
+      d: V
+    }), /* @__PURE__ */ O("clipPath", {
+      id: x,
+      children: /* @__PURE__ */ O("rect", {
+        x: -N,
+        y: N * (w ? -1 : 1),
+        width: i + C,
+        height: i
+      })
+    })]
+  });
+});
+function re() {
+  const t = /* @__PURE__ */ new Map();
+  return {
+    emit(n, c) {
+      var e;
+      (e = t.get(n)) == null || e.forEach((o) => o(c));
+    },
+    on(n, c) {
+      t.set(n, [...t.get(n) || [], c]);
+    },
+    off(n, c) {
+      var e;
+      t.set(n, ((e = t.get(n)) == null ? void 0 : e.filter((o) => o !== c)) || []);
+    }
+  };
+}
+const se = /* @__PURE__ */ s.createContext(null), ce = /* @__PURE__ */ s.createContext(null), le = () => {
+  var t;
+  return ((t = s.useContext(se)) == null ? void 0 : t.id) || null;
+}, ie = () => s.useContext(ce);
+function fe(t) {
+  const {
+    open: n = !1,
+    onOpenChange: c,
+    elements: e
+  } = t, o = B(), l = s.useRef({}), [u] = s.useState(() => re()), i = le() != null;
+  if (process.env.NODE_ENV !== "production") {
+    const r = e.reference;
+    r && !F(r) && oe("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
+  }
+  const [a, I] = s.useState(e.reference), d = K((r, p, R) => {
+    l.current.openEvent = r ? p : void 0, u.emit("openchange", {
+      open: r,
+      event: p,
+      reason: R,
+      nested: i
+    }), c == null || c(r, p, R);
+  }), g = s.useMemo(() => ({
+    setPositionReference: I
+  }), []), h = s.useMemo(() => ({
+    reference: a || e.reference || null,
+    floating: e.floating || null,
+    domReference: e.reference
+  }), [a, e.reference, e.floating]);
+  return s.useMemo(() => ({
+    dataRef: l,
+    open: n,
+    onOpenChange: d,
+    elements: h,
+    events: u,
+    floatingId: o,
+    refs: g
+  }), [n, d, h, u, o, g]);
+}
+function he(t) {
+  t === void 0 && (t = {});
+  const {
+    nodeId: n
+  } = t, c = fe({
+    ...t,
+    elements: {
+      reference: null,
+      floating: null,
+      ...t.elements
+    }
+  }), e = t.rootContext || c, o = e.elements, [l, u] = s.useState(null), [i, a] = s.useState(null), d = (o == null ? void 0 : o.domReference) || l, g = s.useRef(null), h = ie();
+  M(() => {
+    d && (g.current = d);
+  }, [d]);
+  const r = z({
+    ...t,
+    elements: {
+      ...o,
+      ...i && {
+        reference: i
+      }
+    }
+  }), p = s.useCallback((f) => {
+    const m = F(f) ? {
+      getBoundingClientRect: () => f.getBoundingClientRect(),
+      contextElement: f
+    } : f;
+    a(m), r.refs.setReference(m);
+  }, [r.refs]), R = s.useCallback((f) => {
+    (F(f) || f === null) && (g.current = f, u(f)), (F(r.refs.reference.current) || r.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
+    // `null` to support `positionReference` + an unstable `reference`
+    // callback ref.
+    f !== null && !F(f)) && r.refs.setReference(f);
+  }, [r.refs]), v = s.useMemo(() => ({
+    ...r.refs,
+    setReference: R,
+    setPositionReference: p,
+    domReference: g
+  }), [r.refs, R, p]), x = s.useMemo(() => ({
+    ...r.elements,
+    domReference: d
+  }), [r.elements, d]), E = s.useMemo(() => ({
+    ...r,
+    ...e,
+    refs: v,
+    elements: x,
+    nodeId: n
+  }), [r, v, x, n, e]);
+  return M(() => {
+    e.dataRef.current.floatingContext = E;
+    const f = h == null ? void 0 : h.nodesRef.current.find((m) => m.id === n);
+    f && (f.context = E);
+  }), s.useMemo(() => ({
+    ...r,
+    context: E,
+    refs: v,
+    elements: x
+  }), [r, v, x, E]);
+}
+export { pe as FloatingArrow$u, we as arrow$u, Ee as flip$u, xe as getOverflowAncestors$u, Se as offset$u, he as useFloating$u, le as useFloatingParentNodeId$u, fe as useFloatingRootContext$u, ie as useFloatingTree$u, B as useId$u };

package/dist/vendor/@floating-ui/react-dom/dist/floating-ui.react-dom.js

@@ -0,0 +1,183 @@
+import { flip$u as I, offset$u as J, computePosition$u as K, arrow$u as v } from "../../dom/dist/floating-ui.dom.js";
+import { autoUpdate$u as oe, platform$u as se } from "../../dom/dist/floating-ui.dom.js";
+import * as f from "react";
+import { useLayoutEffect as N, useEffect as Q } from "react";
+import * as T from "react-dom";
+var R = typeof document < "u" ? N : Q;
+function h(e, t) {
+  if (e === t)
+    return !0;
+  if (typeof e != typeof t)
+    return !1;
+  if (typeof e == "function" && e.toString() === t.toString())
+    return !0;
+  let n, r, s;
+  if (e && t && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (n = e.length, n !== t.length) return !1;
+      for (r = n; r-- !== 0; )
+        if (!h(e[r], t[r]))
+          return !1;
+      return !0;
+    }
+    if (s = Object.keys(e), n = s.length, n !== Object.keys(t).length)
+      return !1;
+    for (r = n; r-- !== 0; )
+      if (!{}.hasOwnProperty.call(t, s[r]))
+        return !1;
+    for (r = n; r-- !== 0; ) {
+      const p = s[r];
+      if (!(p === "_owner" && e.$$typeof) && !h(e[p], t[p]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function q(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function A(e, t) {
+  const n = q(e);
+  return Math.round(t * n) / n;
+}
+function k(e) {
+  const t = f.useRef(e);
+  return R(() => {
+    t.current = e;
+  }), t;
+}
+function b(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: n = "absolute",
+    middleware: r = [],
+    platform: s,
+    elements: {
+      reference: p,
+      floating: B
+    } = {},
+    transform: D = !0,
+    whileElementsMounted: $,
+    open: x
+  } = e, [u, O] = f.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [M, U] = f.useState(r);
+  h(M, r) || U(r);
+  const [V, W] = f.useState(null), [z, G] = f.useState(null), _ = f.useCallback((o) => {
+    o !== a.current && (a.current = o, W(o));
+  }, []), C = f.useCallback((o) => {
+    o !== d.current && (d.current = o, G(o));
+  }, []), i = p || V, l = B || z, a = f.useRef(null), d = f.useRef(null), y = f.useRef(u), H = $ != null, P = k($), S = k(s), F = k(x), g = f.useCallback(() => {
+    if (!a.current || !d.current)
+      return;
+    const o = {
+      placement: t,
+      strategy: n,
+      middleware: M
+    };
+    S.current && (o.platform = S.current), K(a.current, d.current, o).then((w) => {
+      const m = {
+        ...w,
+        // The floating element's position may be recomputed while it's closed
+        // but still mounted (such as when transitioning out). To ensure
+        // `isPositioned` will be `false` initially on the next open, avoid
+        // setting it to `true` when `open === false` (must be specified).
+        isPositioned: F.current !== !1
+      };
+      E.current && !h(y.current, m) && (y.current = m, T.flushSync(() => {
+        O(m);
+      }));
+    });
+  }, [M, t, n, S, F]);
+  R(() => {
+    x === !1 && y.current.isPositioned && (y.current.isPositioned = !1, O((o) => ({
+      ...o,
+      isPositioned: !1
+    })));
+  }, [x]);
+  const E = f.useRef(!1);
+  R(() => (E.current = !0, () => {
+    E.current = !1;
+  }), []), R(() => {
+    if (i && (a.current = i), l && (d.current = l), i && l) {
+      if (P.current)
+        return P.current(i, l, g);
+      g();
+    }
+  }, [i, l, g, P, H]);
+  const j = f.useMemo(() => ({
+    reference: a,
+    floating: d,
+    setReference: _,
+    setFloating: C
+  }), [_, C]), c = f.useMemo(() => ({
+    reference: i,
+    floating: l
+  }), [i, l]), L = f.useMemo(() => {
+    const o = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!c.floating)
+      return o;
+    const w = A(c.floating, u.x), m = A(c.floating, u.y);
+    return D ? {
+      ...o,
+      transform: "translate(" + w + "px, " + m + "px)",
+      ...q(c.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: n,
+      left: w,
+      top: m
+    };
+  }, [n, D, c.floating, u.x, u.y]);
+  return f.useMemo(() => ({
+    ...u,
+    update: g,
+    refs: j,
+    elements: c,
+    floatingStyles: L
+  }), [u, g, j, c, L]);
+}
+const X = (e) => {
+  function t(n) {
+    return {}.hasOwnProperty.call(n, "current");
+  }
+  return {
+    name: "arrow",
+    options: e,
+    fn(n) {
+      const {
+        element: r,
+        padding: s
+      } = typeof e == "function" ? e(n) : e;
+      return r && t(r) ? r.current != null ? v({
+        element: r.current,
+        padding: s
+      }).fn(n) : {} : r ? v({
+        element: r,
+        padding: s
+      }).fn(n) : {};
+    }
+  };
+}, ee = (e, t) => ({
+  ...J(e),
+  options: [e, t]
+}), te = (e, t) => ({
+  ...I(e),
+  options: [e, t]
+}), ne = (e, t) => ({
+  ...X(e),
+  options: [e, t]
+});
+export { ne as arrow$u, oe as autoUpdate$u, K as computePosition$u, te as flip$u, ee as offset$u, se as platform$u, b as useFloating$u };

package/dist/vendor/@floating-ui/utils/dist/floating-ui.utils.dom.js

@@ -0,0 +1,110 @@
+function c() {
+  return typeof window < "u";
+}
+function s(n) {
+  return p(n) ? (n.nodeName || "").toLowerCase() : "#document";
+}
+function i(n) {
+  var t;
+  return (n == null || (t = n.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function E(n) {
+  var t;
+  return (t = (p(n) ? n.ownerDocument : n.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function p(n) {
+  return c() ? n instanceof Node || n instanceof i(n).Node : !1;
+}
+function m(n) {
+  return c() ? n instanceof Element || n instanceof i(n).Element : !1;
+}
+function w(n) {
+  return c() ? n instanceof HTMLElement || n instanceof i(n).HTMLElement : !1;
+}
+function a(n) {
+  return !c() || typeof ShadowRoot > "u" ? !1 : n instanceof ShadowRoot || n instanceof i(n).ShadowRoot;
+}
+function y(n) {
+  const {
+    overflow: t,
+    overflowX: e,
+    overflowY: o,
+    display: r
+  } = b(n);
+  return /auto|scroll|overlay|hidden|clip/.test(t + o + e) && !["inline", "contents"].includes(r);
+}
+function D(n) {
+  return ["table", "td", "th"].includes(s(n));
+}
+function N(n) {
+  return [":popover-open", ":modal"].some((t) => {
+    try {
+      return n.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+function T(n) {
+  const t = L(), e = m(n) ? b(n) : n;
+  return ["transform", "translate", "scale", "rotate", "perspective"].some((o) => e[o] ? e[o] !== "none" : !1) || (e.containerType ? e.containerType !== "normal" : !1) || !t && (e.backdropFilter ? e.backdropFilter !== "none" : !1) || !t && (e.filter ? e.filter !== "none" : !1) || ["transform", "translate", "scale", "rotate", "perspective", "filter"].some((o) => (e.willChange || "").includes(o)) || ["paint", "layout", "strict", "content"].some((o) => (e.contain || "").includes(o));
+}
+function k(n) {
+  let t = u(n);
+  for (; w(t) && !g(t); ) {
+    if (T(t))
+      return t;
+    if (N(t))
+      return null;
+    t = u(t);
+  }
+  return null;
+}
+function L() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function g(n) {
+  return ["html", "body", "#document"].includes(s(n));
+}
+function b(n) {
+  return i(n).getComputedStyle(n);
+}
+function C(n) {
+  return m(n) ? {
+    scrollLeft: n.scrollLeft,
+    scrollTop: n.scrollTop
+  } : {
+    scrollLeft: n.scrollX,
+    scrollTop: n.scrollY
+  };
+}
+function u(n) {
+  if (s(n) === "html")
+    return n;
+  const t = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    n.assignedSlot || // DOM Element detected.
+    n.parentNode || // ShadowRoot detected.
+    a(n) && n.host || // Fallback.
+    E(n)
+  );
+  return a(t) ? t.host : t;
+}
+function h(n) {
+  const t = u(n);
+  return g(t) ? n.ownerDocument ? n.ownerDocument.body : n.body : w(t) && y(t) ? t : h(t);
+}
+function d(n, t, e) {
+  var o;
+  t === void 0 && (t = []), e === void 0 && (e = !0);
+  const r = h(n), S = r === ((o = n.ownerDocument) == null ? void 0 : o.body), l = i(r);
+  if (S) {
+    const f = v(l);
+    return t.concat(l, l.visualViewport || [], y(r) ? r : [], f && e ? d(f) : []);
+  }
+  return t.concat(r, d(r, [], e));
+}
+function v(n) {
+  return n.parent && Object.getPrototypeOf(n.parent) ? n.frameElement : null;
+}
+export { b as getComputedStyle$u, k as getContainingBlock$u, E as getDocumentElement$u, v as getFrameElement$u, h as getNearestOverflowAncestor$u, s as getNodeName$u, C as getNodeScroll$u, d as getOverflowAncestors$u, u as getParentNode$u, i as getWindow$u, T as isContainingBlock$u, m as isElement$u, w as isHTMLElement$u, g as isLastTraversableNode$u, p as isNode$u, y as isOverflowElement$u, a as isShadowRoot$u, D as isTableElement$u, N as isTopLayer$u, L as isWebKit$u };

package/dist/vendor/@floating-ui/utils/dist/floating-ui.utils.js

@@ -0,0 +1,106 @@
+const l = Math.min, a = Math.max, P = Math.round, M = Math.floor, O = (t) => ({
+  x: t,
+  y: t
+}), m = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, p = {
+  start: "end",
+  end: "start"
+};
+function S(t, n, e) {
+  return a(t, l(n, e));
+}
+function w(t, n) {
+  return typeof t == "function" ? t(n) : t;
+}
+function f(t) {
+  return t.split("-")[0];
+}
+function g(t) {
+  return t.split("-")[1];
+}
+function h(t) {
+  return t === "x" ? "y" : "x";
+}
+function x(t) {
+  return t === "y" ? "height" : "width";
+}
+function b(t) {
+  return ["top", "bottom"].includes(f(t)) ? "y" : "x";
+}
+function d(t) {
+  return h(b(t));
+}
+function j(t, n, e) {
+  e === void 0 && (e = !1);
+  const r = g(t), o = d(t), i = x(o);
+  let c = o === "x" ? r === (e ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return n.reference[i] > n.floating[i] && (c = u(c)), [c, u(c)];
+}
+function C(t) {
+  const n = u(t);
+  return [s(t), n, s(n)];
+}
+function s(t) {
+  return t.replace(/start|end/g, (n) => p[n]);
+}
+function A(t, n, e) {
+  const r = ["left", "right"], o = ["right", "left"], i = ["top", "bottom"], c = ["bottom", "top"];
+  switch (t) {
+    case "top":
+    case "bottom":
+      return e ? n ? o : r : n ? r : o;
+    case "left":
+    case "right":
+      return n ? i : c;
+    default:
+      return [];
+  }
+}
+function L(t, n, e, r) {
+  const o = g(t);
+  let i = A(f(t), e === "start", r);
+  return o && (i = i.map((c) => c + "-" + o), n && (i = i.concat(i.map(s)))), i;
+}
+function u(t) {
+  return t.replace(/left|right|bottom|top/g, (n) => m[n]);
+}
+function y(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function E(t) {
+  return typeof t != "number" ? y(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function R(t) {
+  const {
+    x: n,
+    y: e,
+    width: r,
+    height: o
+  } = t;
+  return {
+    width: r,
+    height: o,
+    top: e,
+    left: n,
+    right: n + r,
+    bottom: e + o,
+    x: n,
+    y: e
+  };
+}
+export { S as clamp$u, O as createCoords$u, w as evaluate$u, y as expandPaddingObject$u, M as floor$u, g as getAlignment$u, d as getAlignmentAxis$u, j as getAlignmentSides$u, x as getAxisLength$u, C as getExpandedPlacements$u, s as getOppositeAlignmentPlacement$u, h as getOppositeAxis$u, L as getOppositeAxisPlacements$u, u as getOppositePlacement$u, E as getPaddingObject$u, f as getSide$u, b as getSideAxis$u, a as max$u, l as min$u, R as rectToClientRect$u, P as round$u };

package/dist/vendor/clsx/dist/clsx.js

@@ -0,0 +1,14 @@
+function i(r) {
+  var f, n, t = "";
+  if (typeof r == "string" || typeof r == "number") t += r;
+  else if (typeof r == "object") if (Array.isArray(r)) {
+    var o = r.length;
+    for (f = 0; f < o; f++) r[f] && (n = i(r[f])) && (t && (t += " "), t += n);
+  } else for (n in r) r[n] && (t && (t += " "), t += n);
+  return t;
+}
+function a() {
+  for (var r, f, n = 0, t = "", o = arguments.length; n < o; n++) (r = arguments[n]) && (f = i(r)) && (t && (t += " "), t += f);
+  return t;
+}
+export { a as clsx$u };

package/dist/vendor/date-fns/_lib/addLeadingZeros.js

@@ -0,0 +1,5 @@
+function r(t, n) {
+  const o = t < 0 ? "-" : "", a = Math.abs(t).toString().padStart(n, "0");
+  return o + a;
+}
+export { r as addLeadingZeros$u };

package/dist/vendor/date-fns/_lib/defaultOptions.js

@@ -0,0 +1,5 @@
+let t = {};
+function e() {
+  return t;
+}
+export { e as getDefaultOptions$u };