lawgic-dev-kit 0.2.4 → 0.3.4

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

@@ -0,0 +1,586 @@
+import * as c from "react";
+import { useLayoutEffect as De, useEffect as Se, useRef as xe } from "react";
+import { isMouseLikePointerType as oe, getDocument as re, isTypeableElement as Te, getTarget as W, isReactEvent as ke, isRootElement as Ie, contains as se, isEventTargetWithin as q } from "./floating-ui.react.utils.js";
+import "../../../../_virtual/jsx-runtime.js";
+import { isElement as M, getOverflowAncestors as Z, isHTMLElement as pe, isWebKit as Me, isLastTraversableNode as G, getParentNode as _e, getComputedStyle as Oe } from "../../utils/dist/floating-ui.utils.dom.js";
+import "react-dom";
+import { useFloating as Ke } from "../../react-dom/dist/floating-ui.react-dom.js";
+import { arrow as dt, flip as mt, offset as pt, shift as gt, size as vt } from "../../react-dom/dist/floating-ui.react-dom.js";
+const ge = {
+  ...c
+}, Ae = ge.useInsertionEffect, Le = Ae || ((e) => e());
+function F(e) {
+  const o = c.useRef(() => {
+    if (process.env.NODE_ENV !== "production")
+      throw new Error("Cannot call an event handler while rendering.");
+  });
+  return Le(() => {
+    o.current = e;
+  }), c.useCallback(function() {
+    for (var r = arguments.length, t = new Array(r), n = 0; n < r; n++)
+      t[n] = arguments[n];
+    return o.current == null ? void 0 : o.current(...t);
+  }, []);
+}
+var B = typeof document < "u" ? De : Se;
+let ce = !1, Ne = 0;
+const ie = () => (
+  // Ensure the id is unique with multiple independent versions of Floating UI
+  // on <React 18
+  "floating-ui-" + Math.random().toString(36).slice(2, 6) + Ne++
+);
+function $e() {
+  const [e, o] = c.useState(() => ce ? ie() : void 0);
+  return B(() => {
+    e == null && o(ie());
+  }, []), c.useEffect(() => {
+    ce = !0;
+  }, []), e;
+}
+const Fe = ge.useId, Be = Fe || $e;
+let z;
+process.env.NODE_ENV !== "production" && (z = /* @__PURE__ */ new Set());
+function He() {
+  for (var e, o = arguments.length, r = new Array(o), t = 0; t < o; t++)
+    r[t] = arguments[t];
+  const n = "Floating UI: " + r.join(" ");
+  if (!((e = z) != null && e.has(n))) {
+    var a;
+    (a = z) == null || a.add(n), console.error(n);
+  }
+}
+function Ue() {
+  const e = /* @__PURE__ */ new Map();
+  return {
+    emit(o, r) {
+      var t;
+      (t = e.get(o)) == null || t.forEach((n) => n(r));
+    },
+    on(o, r) {
+      e.set(o, [...e.get(o) || [], r]);
+    },
+    off(o, r) {
+      var t;
+      e.set(o, ((t = e.get(o)) == null ? void 0 : t.filter((n) => n !== r)) || []);
+    }
+  };
+}
+const We = /* @__PURE__ */ c.createContext(null), Ve = /* @__PURE__ */ c.createContext(null), je = () => {
+  var e;
+  return ((e = c.useContext(We)) == null ? void 0 : e.id) || null;
+}, ve = () => c.useContext(Ve);
+function Ye(e) {
+  return "data-floating-ui-" + e;
+}
+function j(e) {
+  const o = xe(e);
+  return B(() => {
+    o.current = e;
+  }), o;
+}
+function J(e, o) {
+  let r = e.filter((n) => {
+    var a;
+    return n.parentId === o && ((a = n.context) == null ? void 0 : a.open);
+  }), t = r;
+  for (; t.length; )
+    t = e.filter((n) => {
+      var a;
+      return (a = t) == null ? void 0 : a.some((u) => {
+        var s;
+        return n.parentId === u.id && ((s = n.context) == null ? void 0 : s.open);
+      });
+    }), r = r.concat(t);
+  return r;
+}
+const Xe = "data-floating-ui-focusable";
+function ue(e) {
+  return pe(e.target) && e.target.tagName === "BUTTON";
+}
+function le(e) {
+  return Te(e);
+}
+function st(e, o) {
+  o === void 0 && (o = {});
+  const {
+    open: r,
+    onOpenChange: t,
+    dataRef: n,
+    elements: {
+      domReference: a
+    }
+  } = e, {
+    enabled: u = !0,
+    event: s = "click",
+    toggle: p = !0,
+    ignoreMouse: l = !1,
+    keyboardHandlers: g = !0,
+    stickIfOpen: R = !0
+  } = o, E = c.useRef(), f = c.useRef(!1), b = c.useMemo(() => ({
+    onPointerDown(i) {
+      E.current = i.pointerType;
+    },
+    onMouseDown(i) {
+      const y = E.current;
+      i.button === 0 && s !== "click" && (oe(y) && l || (r && p && (!(n.current.openEvent && R) || n.current.openEvent.type === "mousedown") ? t(!1, i.nativeEvent, "click") : (i.preventDefault(), t(!0, i.nativeEvent, "click"))));
+    },
+    onClick(i) {
+      const y = E.current;
+      if (s === "mousedown" && E.current) {
+        E.current = void 0;
+        return;
+      }
+      oe(y) && l || (r && p && (!(n.current.openEvent && R) || n.current.openEvent.type === "click") ? t(!1, i.nativeEvent, "click") : t(!0, i.nativeEvent, "click"));
+    },
+    onKeyDown(i) {
+      E.current = void 0, !(i.defaultPrevented || !g || ue(i)) && (i.key === " " && !le(a) && (i.preventDefault(), f.current = !0), i.key === "Enter" && t(!(r && p), i.nativeEvent, "click"));
+    },
+    onKeyUp(i) {
+      i.defaultPrevented || !g || ue(i) || le(a) || i.key === " " && f.current && (f.current = !1, t(!(r && p), i.nativeEvent, "click"));
+    }
+  }), [n, a, s, l, g, t, r, R, p]);
+  return c.useMemo(() => u ? {
+    reference: b
+  } : {}, [u, b]);
+}
+const qe = {
+  pointerdown: "onPointerDown",
+  mousedown: "onMouseDown",
+  click: "onClick"
+}, Ze = {
+  pointerdown: "onPointerDownCapture",
+  mousedown: "onMouseDownCapture",
+  click: "onClickCapture"
+}, ae = (e) => {
+  var o, r;
+  return {
+    escapeKey: typeof e == "boolean" ? e : (o = e == null ? void 0 : e.escapeKey) != null ? o : !1,
+    outsidePress: typeof e == "boolean" ? e : (r = e == null ? void 0 : e.outsidePress) != null ? r : !0
+  };
+};
+function ct(e, o) {
+  o === void 0 && (o = {});
+  const {
+    open: r,
+    onOpenChange: t,
+    elements: n,
+    dataRef: a
+  } = e, {
+    enabled: u = !0,
+    escapeKey: s = !0,
+    outsidePress: p = !0,
+    outsidePressEvent: l = "pointerdown",
+    referencePress: g = !1,
+    referencePressEvent: R = "pointerdown",
+    ancestorScroll: E = !1,
+    bubbles: f,
+    capture: b
+  } = o, i = ve(), y = F(typeof p == "function" ? p : () => !1), h = typeof p == "function" ? y : p, T = c.useRef(!1), v = c.useRef(!1), {
+    escapeKey: I,
+    outsidePress: L
+  } = ae(f), {
+    escapeKey: A,
+    outsidePress: _
+  } = ae(b), N = c.useRef(!1), C = F((d) => {
+    var w;
+    if (!r || !u || !s || d.key !== "Escape" || N.current)
+      return;
+    const k = (w = a.current.floatingContext) == null ? void 0 : w.nodeId, D = i ? J(i.nodesRef.current, k) : [];
+    if (!I && (d.stopPropagation(), D.length > 0)) {
+      let m = !0;
+      if (D.forEach((P) => {
+        var S;
+        if ((S = P.context) != null && S.open && !P.context.dataRef.current.__escapeKeyBubbles) {
+          m = !1;
+          return;
+        }
+      }), !m)
+        return;
+    }
+    t(!1, ke(d) ? d.nativeEvent : d, "escape-key");
+  }), H = F((d) => {
+    var w;
+    const k = () => {
+      var D;
+      C(d), (D = W(d)) == null || D.removeEventListener("keydown", k);
+    };
+    (w = W(d)) == null || w.addEventListener("keydown", k);
+  }), V = F((d) => {
+    var w;
+    const k = T.current;
+    T.current = !1;
+    const D = v.current;
+    if (v.current = !1, l === "click" && D || k || typeof h == "function" && !h(d))
+      return;
+    const m = W(d), P = "[" + Ye("inert") + "]", S = re(n.floating).querySelectorAll(P);
+    let K = M(m) ? m : null;
+    for (; K && !G(K); ) {
+      const x = _e(K);
+      if (G(x) || !M(x))
+        break;
+      K = x;
+    }
+    if (S.length && M(m) && !Ie(m) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
+    !se(m, n.floating) && // If the target root element contains none of the markers, then the
+    // element was injected after the floating element rendered.
+    Array.from(S).every((x) => !se(K, x)))
+      return;
+    if (pe(m) && X) {
+      const x = G(m), O = Oe(m), U = /auto|scroll/, Re = x || U.test(O.overflowX), ye = x || U.test(O.overflowY), be = Re && m.clientWidth > 0 && m.scrollWidth > m.clientWidth, Ce = ye && m.clientHeight > 0 && m.scrollHeight > m.clientHeight, he = O.direction === "rtl", we = Ce && (he ? d.offsetX <= m.offsetWidth - m.clientWidth : d.offsetX > m.clientWidth), Pe = be && d.offsetY > m.clientHeight;
+      if (we || Pe)
+        return;
+    }
+    const te = (w = a.current.floatingContext) == null ? void 0 : w.nodeId, Ee = i && J(i.nodesRef.current, te).some((x) => {
+      var O;
+      return q(d, (O = x.context) == null ? void 0 : O.elements.floating);
+    });
+    if (q(d, n.floating) || q(d, n.domReference) || Ee)
+      return;
+    const ne = i ? J(i.nodesRef.current, te) : [];
+    if (ne.length > 0) {
+      let x = !0;
+      if (ne.forEach((O) => {
+        var U;
+        if ((U = O.context) != null && U.open && !O.context.dataRef.current.__outsidePressBubbles) {
+          x = !1;
+          return;
+        }
+      }), !x)
+        return;
+    }
+    t(!1, d, "outside-press");
+  }), Y = F((d) => {
+    var w;
+    const k = () => {
+      var D;
+      V(d), (D = W(d)) == null || D.removeEventListener(l, k);
+    };
+    (w = W(d)) == null || w.addEventListener(l, k);
+  });
+  c.useEffect(() => {
+    if (!r || !u)
+      return;
+    a.current.__escapeKeyBubbles = I, a.current.__outsidePressBubbles = L;
+    let d = -1;
+    function w(S) {
+      t(!1, S, "ancestor-scroll");
+    }
+    function k() {
+      window.clearTimeout(d), N.current = !0;
+    }
+    function D() {
+      d = window.setTimeout(
+        () => {
+          N.current = !1;
+        },
+        // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.
+        // Only apply to WebKit for the test to remain 0ms.
+        Me() ? 5 : 0
+      );
+    }
+    const m = re(n.floating);
+    s && (m.addEventListener("keydown", A ? H : C, A), m.addEventListener("compositionstart", k), m.addEventListener("compositionend", D)), h && m.addEventListener(l, _ ? Y : V, _);
+    let P = [];
+    return E && (M(n.domReference) && (P = Z(n.domReference)), M(n.floating) && (P = P.concat(Z(n.floating))), !M(n.reference) && n.reference && n.reference.contextElement && (P = P.concat(Z(n.reference.contextElement)))), P = P.filter((S) => {
+      var K;
+      return S !== ((K = m.defaultView) == null ? void 0 : K.visualViewport);
+    }), P.forEach((S) => {
+      S.addEventListener("scroll", w, {
+        passive: !0
+      });
+    }), () => {
+      s && (m.removeEventListener("keydown", A ? H : C, A), m.removeEventListener("compositionstart", k), m.removeEventListener("compositionend", D)), h && m.removeEventListener(l, _ ? Y : V, _), P.forEach((S) => {
+        S.removeEventListener("scroll", w);
+      }), window.clearTimeout(d);
+    };
+  }, [a, n, s, h, l, r, t, E, u, I, L, C, A, H, V, _, Y]), c.useEffect(() => {
+    T.current = !1;
+  }, [h, l]);
+  const ee = c.useMemo(() => ({
+    onKeyDown: C,
+    ...g && {
+      [qe[R]]: (d) => {
+        t(!1, d.nativeEvent, "reference-press");
+      },
+      ...R !== "click" && {
+        onClick(d) {
+          t(!1, d.nativeEvent, "reference-press");
+        }
+      }
+    }
+  }), [C, t, g, R]), X = c.useMemo(() => ({
+    onKeyDown: C,
+    onMouseDown() {
+      v.current = !0;
+    },
+    onMouseUp() {
+      v.current = !0;
+    },
+    [Ze[l]]: () => {
+      T.current = !0;
+    }
+  }), [C, l]);
+  return c.useMemo(() => u ? {
+    reference: ee,
+    floating: X
+  } : {}, [u, ee, X]);
+}
+function Ge(e) {
+  const {
+    open: o = !1,
+    onOpenChange: r,
+    elements: t
+  } = e, n = Be(), a = c.useRef({}), [u] = c.useState(() => Ue()), s = je() != null;
+  if (process.env.NODE_ENV !== "production") {
+    const f = t.reference;
+    f && !M(f) && He("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
+  }
+  const [p, l] = c.useState(t.reference), g = F((f, b, i) => {
+    a.current.openEvent = f ? b : void 0, u.emit("openchange", {
+      open: f,
+      event: b,
+      reason: i,
+      nested: s
+    }), r == null || r(f, b, i);
+  }), R = c.useMemo(() => ({
+    setPositionReference: l
+  }), []), E = c.useMemo(() => ({
+    reference: p || t.reference || null,
+    floating: t.floating || null,
+    domReference: t.reference
+  }), [p, t.reference, t.floating]);
+  return c.useMemo(() => ({
+    dataRef: a,
+    open: o,
+    onOpenChange: g,
+    elements: E,
+    events: u,
+    floatingId: n,
+    refs: R
+  }), [o, g, E, u, n, R]);
+}
+function it(e) {
+  e === void 0 && (e = {});
+  const {
+    nodeId: o
+  } = e, r = Ge({
+    ...e,
+    elements: {
+      reference: null,
+      floating: null,
+      ...e.elements
+    }
+  }), t = e.rootContext || r, n = t.elements, [a, u] = c.useState(null), [s, p] = c.useState(null), g = (n == null ? void 0 : n.domReference) || a, R = c.useRef(null), E = ve();
+  B(() => {
+    g && (R.current = g);
+  }, [g]);
+  const f = Ke({
+    ...e,
+    elements: {
+      ...n,
+      ...s && {
+        reference: s
+      }
+    }
+  }), b = c.useCallback((v) => {
+    const I = M(v) ? {
+      getBoundingClientRect: () => v.getBoundingClientRect(),
+      contextElement: v
+    } : v;
+    p(I), f.refs.setReference(I);
+  }, [f.refs]), i = c.useCallback((v) => {
+    (M(v) || v === null) && (R.current = v, u(v)), (M(f.refs.reference.current) || f.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.
+    v !== null && !M(v)) && f.refs.setReference(v);
+  }, [f.refs]), y = c.useMemo(() => ({
+    ...f.refs,
+    setReference: i,
+    setPositionReference: b,
+    domReference: R
+  }), [f.refs, i, b]), h = c.useMemo(() => ({
+    ...f.elements,
+    domReference: g
+  }), [f.elements, g]), T = c.useMemo(() => ({
+    ...f,
+    ...t,
+    refs: y,
+    elements: h,
+    nodeId: o
+  }), [f, y, h, o, t]);
+  return B(() => {
+    t.dataRef.current.floatingContext = T;
+    const v = E == null ? void 0 : E.nodesRef.current.find((I) => I.id === o);
+    v && (v.context = T);
+  }), c.useMemo(() => ({
+    ...f,
+    context: T,
+    refs: y,
+    elements: h
+  }), [f, y, h, T]);
+}
+const fe = "active", de = "selected";
+function Q(e, o, r) {
+  const t = /* @__PURE__ */ new Map(), n = r === "item";
+  let a = e;
+  if (n && e) {
+    const {
+      [fe]: u,
+      [de]: s,
+      ...p
+    } = e;
+    a = p;
+  }
+  return {
+    ...r === "floating" && {
+      tabIndex: -1,
+      [Xe]: ""
+    },
+    ...a,
+    ...o.map((u) => {
+      const s = u ? u[r] : null;
+      return typeof s == "function" ? e ? s(e) : null : s;
+    }).concat(e).reduce((u, s) => (s && Object.entries(s).forEach((p) => {
+      let [l, g] = p;
+      if (!(n && [fe, de].includes(l)))
+        if (l.indexOf("on") === 0) {
+          if (t.has(l) || t.set(l, []), typeof g == "function") {
+            var R;
+            (R = t.get(l)) == null || R.push(g), u[l] = function() {
+              for (var E, f = arguments.length, b = new Array(f), i = 0; i < f; i++)
+                b[i] = arguments[i];
+              return (E = t.get(l)) == null ? void 0 : E.map((y) => y(...b)).find((y) => y !== void 0);
+            };
+          }
+        } else
+          u[l] = g;
+    }), u), {})
+  };
+}
+function ut(e) {
+  e === void 0 && (e = []);
+  const o = e.map((s) => s == null ? void 0 : s.reference), r = e.map((s) => s == null ? void 0 : s.floating), t = e.map((s) => s == null ? void 0 : s.item), n = c.useCallback(
+    (s) => Q(s, e, "reference"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    o
+  ), a = c.useCallback(
+    (s) => Q(s, e, "floating"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    r
+  ), u = c.useCallback(
+    (s) => Q(s, e, "item"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  );
+  return c.useMemo(() => ({
+    getReferenceProps: n,
+    getFloatingProps: a,
+    getItemProps: u
+  }), [n, a, u]);
+}
+const me = (e) => e.replace(/[A-Z]+(?![a-z])|[A-Z]/g, (o, r) => (r ? "-" : "") + o.toLowerCase());
+function $(e, o) {
+  return typeof e == "function" ? e(o) : e;
+}
+function Je(e, o) {
+  const [r, t] = c.useState(e);
+  return e && !r && t(!0), c.useEffect(() => {
+    if (!e && r) {
+      const n = setTimeout(() => t(!1), o);
+      return () => clearTimeout(n);
+    }
+  }, [e, r, o]), r;
+}
+function Qe(e, o) {
+  o === void 0 && (o = {});
+  const {
+    open: r,
+    elements: {
+      floating: t
+    }
+  } = e, {
+    duration: n = 250
+  } = o, u = (typeof n == "number" ? n : n.close) || 0, [s, p] = c.useState("unmounted"), l = Je(r, u);
+  return !l && s === "close" && p("unmounted"), B(() => {
+    if (t) {
+      if (r) {
+        p("initial");
+        const g = requestAnimationFrame(() => {
+          p("open");
+        });
+        return () => {
+          cancelAnimationFrame(g);
+        };
+      }
+      p("close");
+    }
+  }, [r, t]), {
+    isMounted: l,
+    status: s
+  };
+}
+function lt(e, o) {
+  o === void 0 && (o = {});
+  const {
+    initial: r = {
+      opacity: 0
+    },
+    open: t,
+    close: n,
+    common: a,
+    duration: u = 250
+  } = o, s = e.placement, p = s.split("-")[0], l = c.useMemo(() => ({
+    side: p,
+    placement: s
+  }), [p, s]), g = typeof u == "number", R = (g ? u : u.open) || 0, E = (g ? u : u.close) || 0, [f, b] = c.useState(() => ({
+    ...$(a, l),
+    ...$(r, l)
+  })), {
+    isMounted: i,
+    status: y
+  } = Qe(e, {
+    duration: u
+  }), h = j(r), T = j(t), v = j(n), I = j(a);
+  return B(() => {
+    const L = $(h.current, l), A = $(v.current, l), _ = $(I.current, l), N = $(T.current, l) || Object.keys(L).reduce((C, H) => (C[H] = "", C), {});
+    if (y === "initial" && b((C) => ({
+      transitionProperty: C.transitionProperty,
+      ..._,
+      ...L
+    })), y === "open" && b({
+      transitionProperty: Object.keys(N).map(me).join(","),
+      transitionDuration: R + "ms",
+      ..._,
+      ...N
+    }), y === "close") {
+      const C = A || L;
+      b({
+        transitionProperty: Object.keys(C).map(me).join(","),
+        transitionDuration: E + "ms",
+        ..._,
+        ...C
+      });
+    }
+  }, [E, v, h, T, I, R, y, l]), {
+    isMounted: i,
+    styles: f
+  };
+}
+export {
+  dt as arrow,
+  mt as flip,
+  Z as getOverflowAncestors,
+  pt as offset,
+  gt as shift,
+  vt as size,
+  st as useClick,
+  ct as useDismiss,
+  it as useFloating,
+  je as useFloatingParentNodeId,
+  Ge as useFloatingRootContext,
+  ve as useFloatingTree,
+  Be as useId,
+  ut as useInteractions,
+  Qe as useTransitionStatus,
+  lt as useTransitionStyles
+};

package/dist/node_modules/@floating-ui/react/dist/floating-ui.react.utils.js

@@ -0,0 +1,55 @@
+import { isHTMLElement as i, isShadowRoot as r } from "../../utils/dist/floating-ui.utils.dom.js";
+function a(t, e) {
+  if (!t || !e)
+    return !1;
+  const n = e.getRootNode == null ? void 0 : e.getRootNode();
+  if (t.contains(e))
+    return !0;
+  if (n && r(n)) {
+    let o = e;
+    for (; o; ) {
+      if (t === o)
+        return !0;
+      o = o.parentNode || o.host;
+    }
+  }
+  return !1;
+}
+function c(t, e) {
+  return ["mouse", "pen"].includes(t);
+}
+function l(t) {
+  return "nativeEvent" in t;
+}
+function f(t) {
+  return t.matches("html,body");
+}
+function d(t) {
+  return (t == null ? void 0 : t.ownerDocument) || document;
+}
+function m(t, e) {
+  if (e == null)
+    return !1;
+  if ("composedPath" in t)
+    return t.composedPath().includes(e);
+  const n = t;
+  return n.target != null && e.contains(n.target);
+}
+function p(t) {
+  return "composedPath" in t ? t.composedPath()[0] : t.target;
+}
+const u = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+function E(t) {
+  return i(t) && t.matches(u);
+}
+export {
+  u as TYPEABLE_SELECTOR,
+  a as contains,
+  d as getDocument,
+  p as getTarget,
+  m as isEventTargetWithin,
+  c as isMouseLikePointerType,
+  l as isReactEvent,
+  f as isRootElement,
+  E as isTypeableElement
+};