lawgic-dev-kit 0.12.4 → 0.12.8

package/dist/dist/node_modules/motion-dom/dist/es/gestures/press/index.js

@@ -0,0 +1,32 @@
+import { isDragActive as E } from "../drag/state/is-active.js";
+import { isNodeOrChild as b } from "../utils/is-node-or-child.js";
+import { isPrimaryPointer as L } from "../utils/is-primary-pointer.js";
+import { setupGesture as g } from "../utils/setup.js";
+import { isElementKeyboardAccessible as h } from "./utils/is-keyboard-accessible.js";
+import { enableKeyboardPress as y } from "./utils/keyboard.js";
+import { isPressing as o } from "./utils/state.js";
+function p(s) {
+  return L(s) && !E();
+}
+function C(s, u, i = {}) {
+  const [f, r, l] = g(s, i), w = (e) => {
+    const t = e.currentTarget;
+    if (!p(e) || o.has(t))
+      return;
+    o.add(t);
+    const a = u(t, e), d = (n, v) => {
+      window.removeEventListener("pointerup", c), window.removeEventListener("pointercancel", m), !(!p(n) || !o.has(t)) && (o.delete(t), typeof a == "function" && a(n, { success: v }));
+    }, c = (n) => {
+      d(n, t === window || t === document || i.useGlobalTarget || b(t, n.target));
+    }, m = (n) => {
+      d(n, !1);
+    };
+    window.addEventListener("pointerup", c, r), window.addEventListener("pointercancel", m, r);
+  };
+  return f.forEach((e) => {
+    (i.useGlobalTarget ? window : e).addEventListener("pointerdown", w, r), e instanceof HTMLElement && (e.addEventListener("focus", (t) => y(t, r)), !h(e) && e.tabIndex === null && (e.tabIndex = 0));
+  }), l;
+}
+export {
+  C as press
+};

package/dist/dist/node_modules/motion-dom/dist/es/gestures/press/utils/is-keyboard-accessible.js

@@ -0,0 +1,13 @@
+const t = /* @__PURE__ */ new Set([
+  "BUTTON",
+  "INPUT",
+  "SELECT",
+  "TEXTAREA",
+  "A"
+]);
+function n(e) {
+  return t.has(e.tagName) || e.tabIndex !== -1;
+}
+export {
+  n as isElementKeyboardAccessible
+};

package/dist/dist/node_modules/motion-dom/dist/es/gestures/press/utils/keyboard.js

@@ -0,0 +1,27 @@
+import { isPressing as a } from "./state.js";
+function i(n) {
+  return (t) => {
+    t.key === "Enter" && n(t);
+  };
+}
+function r(n, t) {
+  n.dispatchEvent(new PointerEvent("pointer" + t, { isPrimary: !0, bubbles: !0 }));
+}
+const c = (n, t) => {
+  const e = n.currentTarget;
+  if (!e)
+    return;
+  const s = i(() => {
+    if (a.has(e))
+      return;
+    r(e, "down");
+    const o = i(() => {
+      r(e, "up");
+    }), d = () => r(e, "cancel");
+    e.addEventListener("keyup", o, t), e.addEventListener("blur", d, t);
+  });
+  e.addEventListener("keydown", s, t), e.addEventListener("blur", () => e.removeEventListener("keydown", s), t);
+};
+export {
+  c as enableKeyboardPress
+};

package/dist/dist/node_modules/motion-dom/dist/es/gestures/press/utils/state.js

@@ -0,0 +1,4 @@
+const e = /* @__PURE__ */ new WeakSet();
+export {
+  e as isPressing
+};

package/dist/dist/node_modules/motion-dom/dist/es/gestures/utils/is-node-or-child.js

@@ -0,0 +1,4 @@
+const s = (e, t) => t ? e === t ? !0 : s(e, t.parentElement) : !1;
+export {
+  s as isNodeOrChild
+};

package/dist/dist/node_modules/motion-dom/dist/es/gestures/utils/is-primary-pointer.js

@@ -0,0 +1,4 @@
+const t = (o) => o.pointerType === "mouse" ? typeof o.button != "number" || o.button <= 0 : o.isPrimary !== !1;
+export {
+  t as isPrimaryPointer
+};

package/dist/dist/node_modules/motion-dom/dist/es/gestures/utils/setup.js

@@ -0,0 +1,12 @@
+import { resolveElements as n } from "../../utils/resolve-elements.js";
+function l(r, t) {
+  const o = n(r), e = new AbortController(), s = {
+    passive: !0,
+    ...t,
+    signal: e.signal
+  };
+  return [o, s, () => e.abort()];
+}
+export {
+  l as setupGesture
+};

package/dist/dist/node_modules/motion-dom/dist/es/utils/is-bezier-definition.js

@@ -0,0 +1,4 @@
+const i = (e) => Array.isArray(e) && typeof e[0] == "number";
+export {
+  i as isBezierDefinition
+};

package/dist/dist/node_modules/motion-dom/dist/es/utils/resolve-elements.js

@@ -0,0 +1,14 @@
+function l(e, o, f) {
+  var t;
+  if (e instanceof EventTarget)
+    return [e];
+  if (typeof e == "string") {
+    let n = document;
+    const r = (t = void 0) !== null && t !== void 0 ? t : n.querySelectorAll(e);
+    return r ? Array.from(r) : [];
+  }
+  return Array.from(e);
+}
+export {
+  l as resolveElements
+};

package/dist/dist/node_modules/motion-dom/dist/es/utils/supports/flags.js

@@ -0,0 +1,6 @@
+const s = {
+  linearEasing: void 0
+};
+export {
+  s as supportsFlags
+};

package/dist/dist/node_modules/motion-dom/dist/es/utils/supports/linear-easing.js

@@ -0,0 +1,12 @@
+import { memoSupports as e } from "./memo.js";
+const r = /* @__PURE__ */ e(() => {
+  try {
+    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
+  } catch {
+    return !1;
+  }
+  return !0;
+}, "linearEasing");
+export {
+  r as supportsLinearEasing
+};

package/dist/dist/node_modules/motion-dom/dist/es/utils/supports/memo.js

@@ -0,0 +1,13 @@
+import "../../../../../motion-utils/dist/es/errors.js";
+import { memo as s } from "../../../../../motion-utils/dist/es/memo.js";
+import { supportsFlags as p } from "./flags.js";
+function e(r, t) {
+  const m = s(r);
+  return () => {
+    var o;
+    return (o = p[t]) !== null && o !== void 0 ? o : m();
+  };
+}
+export {
+  e as memoSupports
+};

package/dist/dist/node_modules/motion-dom/dist/es/utils/supports/scroll-timeline.js

@@ -0,0 +1,6 @@
+import "../../../../../motion-utils/dist/es/errors.js";
+import { memo as o } from "../../../../../motion-utils/dist/es/memo.js";
+const r = /* @__PURE__ */ o(() => window.ScrollTimeline !== void 0);
+export {
+  r as supportsScrollTimeline
+};

package/dist/dist/node_modules/motion-dom/dist/es/value/index.js

@@ -0,0 +1,202 @@
+import "../../../../motion-utils/dist/es/errors.js";
+import { SubscriptionManager as o } from "../../../../motion-utils/dist/es/subscription-manager.js";
+import { velocityPerSecond as c } from "../../../../motion-utils/dist/es/velocity-per-second.js";
+import { warnOnce as p } from "../../../../motion-utils/dist/es/warn-once.js";
+import { frame as u } from "../frameloop/frame.js";
+import { time as n } from "../frameloop/sync-time.js";
+const a = 30, v = (i) => !isNaN(parseFloat(i));
+class d {
+  /**
+   * @param init - The initiating value
+   * @param config - Optional configuration options
+   *
+   * -  `transformer`: A function to transform incoming values with.
+   */
+  constructor(t, e = {}) {
+    this.version = "12.6.1", this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = (s, r = !0) => {
+      const h = n.now();
+      this.updatedAt !== h && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(s), this.current !== this.prev && this.events.change && this.events.change.notify(this.current), r && this.events.renderRequest && this.events.renderRequest.notify(this.current);
+    }, this.hasAnimated = !1, this.setCurrent(t), this.owner = e.owner;
+  }
+  setCurrent(t) {
+    this.current = t, this.updatedAt = n.now(), this.canTrackVelocity === null && t !== void 0 && (this.canTrackVelocity = v(this.current));
+  }
+  setPrevFrameValue(t = this.current) {
+    this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt;
+  }
+  /**
+   * Adds a function that will be notified when the `MotionValue` is updated.
+   *
+   * It returns a function that, when called, will cancel the subscription.
+   *
+   * When calling `onChange` inside a React component, it should be wrapped with the
+   * `useEffect` hook. As it returns an unsubscribe function, this should be returned
+   * from the `useEffect` function to ensure you don't add duplicate subscribers..
+   *
+   * ```jsx
+   * export const MyComponent = () => {
+   *   const x = useMotionValue(0)
+   *   const y = useMotionValue(0)
+   *   const opacity = useMotionValue(1)
+   *
+   *   useEffect(() => {
+   *     function updateOpacity() {
+   *       const maxXY = Math.max(x.get(), y.get())
+   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
+   *       opacity.set(newOpacity)
+   *     }
+   *
+   *     const unsubscribeX = x.on("change", updateOpacity)
+   *     const unsubscribeY = y.on("change", updateOpacity)
+   *
+   *     return () => {
+   *       unsubscribeX()
+   *       unsubscribeY()
+   *     }
+   *   }, [])
+   *
+   *   return <motion.div style={{ x }} />
+   * }
+   * ```
+   *
+   * @param subscriber - A function that receives the latest value.
+   * @returns A function that, when called, will cancel this subscription.
+   *
+   * @deprecated
+   */
+  onChange(t) {
+    return process.env.NODE_ENV !== "production" && p(!1, 'value.onChange(callback) is deprecated. Switch to value.on("change", callback).'), this.on("change", t);
+  }
+  on(t, e) {
+    this.events[t] || (this.events[t] = new o());
+    const s = this.events[t].add(e);
+    return t === "change" ? () => {
+      s(), u.read(() => {
+        this.events.change.getSize() || this.stop();
+      });
+    } : s;
+  }
+  clearListeners() {
+    for (const t in this.events)
+      this.events[t].clear();
+  }
+  /**
+   * Attaches a passive effect to the `MotionValue`.
+   */
+  attach(t, e) {
+    this.passiveEffect = t, this.stopPassiveEffect = e;
+  }
+  /**
+   * Sets the state of the `MotionValue`.
+   *
+   * @remarks
+   *
+   * ```jsx
+   * const x = useMotionValue(0)
+   * x.set(10)
+   * ```
+   *
+   * @param latest - Latest value to set.
+   * @param render - Whether to notify render subscribers. Defaults to `true`
+   *
+   * @public
+   */
+  set(t, e = !0) {
+    !e || !this.passiveEffect ? this.updateAndNotify(t, e) : this.passiveEffect(t, this.updateAndNotify);
+  }
+  setWithVelocity(t, e, s) {
+    this.set(e), this.prev = void 0, this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt - s;
+  }
+  /**
+   * Set the state of the `MotionValue`, stopping any active animations,
+   * effects, and resets velocity to `0`.
+   */
+  jump(t, e = !0) {
+    this.updateAndNotify(t), this.prev = t, this.prevUpdatedAt = this.prevFrameValue = void 0, e && this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+  /**
+   * Returns the latest state of `MotionValue`
+   *
+   * @returns - The latest state of `MotionValue`
+   *
+   * @public
+   */
+  get() {
+    return this.current;
+  }
+  /**
+   * @public
+   */
+  getPrevious() {
+    return this.prev;
+  }
+  /**
+   * Returns the latest velocity of `MotionValue`
+   *
+   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
+   *
+   * @public
+   */
+  getVelocity() {
+    const t = n.now();
+    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || t - this.updatedAt > a)
+      return 0;
+    const e = Math.min(this.updatedAt - this.prevUpdatedAt, a);
+    return c(parseFloat(this.current) - parseFloat(this.prevFrameValue), e);
+  }
+  /**
+   * Registers a new animation to control this `MotionValue`. Only one
+   * animation can drive a `MotionValue` at one time.
+   *
+   * ```jsx
+   * value.start()
+   * ```
+   *
+   * @param animation - A function that starts the provided animation
+   */
+  start(t) {
+    return this.stop(), new Promise((e) => {
+      this.hasAnimated = !0, this.animation = t(e), this.events.animationStart && this.events.animationStart.notify();
+    }).then(() => {
+      this.events.animationComplete && this.events.animationComplete.notify(), this.clearAnimation();
+    });
+  }
+  /**
+   * Stop the currently active animation.
+   *
+   * @public
+   */
+  stop() {
+    this.animation && (this.animation.stop(), this.events.animationCancel && this.events.animationCancel.notify()), this.clearAnimation();
+  }
+  /**
+   * Returns `true` if this value is currently animating.
+   *
+   * @public
+   */
+  isAnimating() {
+    return !!this.animation;
+  }
+  clearAnimation() {
+    delete this.animation;
+  }
+  /**
+   * Destroy and clean up subscribers to this `MotionValue`.
+   *
+   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
+   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
+   * created a `MotionValue` via the `motionValue` function.
+   *
+   * @public
+   */
+  destroy() {
+    this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+}
+function g(i, t) {
+  return new d(i, t);
+}
+export {
+  d as MotionValue,
+  g as motionValue
+};

package/dist/dist/node_modules/motion-utils/dist/es/array.js

@@ -0,0 +1,11 @@
+function t(e, i) {
+  e.indexOf(i) === -1 && e.push(i);
+}
+function d(e, i) {
+  const n = e.indexOf(i);
+  n > -1 && e.splice(n, 1);
+}
+export {
+  t as addUniqueItem,
+  d as removeItem
+};

package/dist/dist/node_modules/motion-utils/dist/es/errors.js

@@ -0,0 +1,12 @@
+import { noop as r } from "./noop.js";
+let e = r, a = r;
+process.env.NODE_ENV !== "production" && (e = (o, n) => {
+  !o && typeof console < "u" && console.warn(n);
+}, a = (o, n) => {
+  if (!o)
+    throw new Error(n);
+});
+export {
+  a as invariant,
+  e as warning
+};

package/dist/dist/node_modules/motion-utils/dist/es/global-config.js

@@ -0,0 +1,6 @@
+const o = {
+  useManualTiming: !1
+};
+export {
+  o as MotionGlobalConfig
+};

package/dist/dist/node_modules/motion-utils/dist/es/memo.js

@@ -0,0 +1,8 @@
+// @__NO_SIDE_EFFECTS__
+function r(o) {
+  let e;
+  return () => (e === void 0 && (e = o()), e);
+}
+export {
+  r as memo
+};

package/dist/dist/node_modules/motion-utils/dist/es/noop.js

@@ -0,0 +1,4 @@
+const n = /* @__NO_SIDE_EFFECTS__ */ (o) => o;
+export {
+  n as noop
+};

package/dist/dist/node_modules/motion-utils/dist/es/progress.js

@@ -0,0 +1,7 @@
+const t = /* @__NO_SIDE_EFFECTS__ */ (r, n, o) => {
+  const s = n - r;
+  return s === 0 ? 1 : (o - r) / s;
+};
+export {
+  t as progress
+};

package/dist/dist/node_modules/motion-utils/dist/es/subscription-manager.js

@@ -0,0 +1,29 @@
+import { removeItem as e, addUniqueItem as c } from "./array.js";
+class p {
+  constructor() {
+    this.subscriptions = [];
+  }
+  add(s) {
+    return c(this.subscriptions, s), () => e(this.subscriptions, s);
+  }
+  notify(s, r, o) {
+    const t = this.subscriptions.length;
+    if (t)
+      if (t === 1)
+        this.subscriptions[0](s, r, o);
+      else
+        for (let i = 0; i < t; i++) {
+          const n = this.subscriptions[i];
+          n && n(s, r, o);
+        }
+  }
+  getSize() {
+    return this.subscriptions.length;
+  }
+  clear() {
+    this.subscriptions.length = 0;
+  }
+}
+export {
+  p as SubscriptionManager
+};

package/dist/dist/node_modules/motion-utils/dist/es/time-conversion.js

@@ -0,0 +1,5 @@
+const o = /* @__NO_SIDE_EFFECTS__ */ (s) => s * 1e3, e = /* @__NO_SIDE_EFFECTS__ */ (s) => s / 1e3;
+export {
+  e as millisecondsToSeconds,
+  o as secondsToMilliseconds
+};

package/dist/dist/node_modules/motion-utils/dist/es/velocity-per-second.js

@@ -0,0 +1,6 @@
+function o(n, e) {
+  return e ? n * (1e3 / e) : 0;
+}
+export {
+  o as velocityPerSecond
+};

package/dist/dist/node_modules/motion-utils/dist/es/warn-once.js

@@ -0,0 +1,7 @@
+const n = /* @__PURE__ */ new Set();
+function t(o, e, a) {
+  o || n.has(e) || (console.warn(e), n.add(e));
+}
+export {
+  t as warnOnce
+};

package/dist/dist/node_modules/object-assign/index.js

@@ -0,0 +1,54 @@
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var u, s;
+function O() {
+  if (s) return u;
+  s = 1;
+  var f = Object.getOwnPropertySymbols, b = Object.prototype.hasOwnProperty, l = Object.prototype.propertyIsEnumerable;
+  function j(n) {
+    if (n == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(n);
+  }
+  function p() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var n = new String("abc");
+      if (n[5] = "de", Object.getOwnPropertyNames(n)[0] === "5")
+        return !1;
+      for (var o = {}, r = 0; r < 10; r++)
+        o["_" + String.fromCharCode(r)] = r;
+      var a = Object.getOwnPropertyNames(o).map(function(t) {
+        return o[t];
+      });
+      if (a.join("") !== "0123456789")
+        return !1;
+      var e = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(t) {
+        e[t] = t;
+      }), Object.keys(Object.assign({}, e)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return u = p() ? Object.assign : function(n, o) {
+    for (var r, a = j(n), e, t = 1; t < arguments.length; t++) {
+      r = Object(arguments[t]);
+      for (var c in r)
+        b.call(r, c) && (a[c] = r[c]);
+      if (f) {
+        e = f(r);
+        for (var i = 0; i < e.length; i++)
+          l.call(r, e[i]) && (a[e[i]] = r[e[i]]);
+      }
+    }
+    return a;
+  }, u;
+}
+export {
+  O as __require
+};

package/dist/dist/node_modules/prop-types/checkPropTypes.js

@@ -0,0 +1,54 @@
+import { __require as E } from "./lib/ReactPropTypesSecret.js";
+import { __require as d } from "./lib/has.js";
+var c, y;
+function O() {
+  if (y) return c;
+  y = 1;
+  var a = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var l = /* @__PURE__ */ E(), i = {}, v = /* @__PURE__ */ d();
+    a = function(r) {
+      var t = "Warning: " + r;
+      typeof console < "u" && console.error(t);
+      try {
+        throw new Error(t);
+      } catch {
+      }
+    };
+  }
+  function f(r, t, n, s, u) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var o in r)
+        if (v(r, o)) {
+          var e;
+          try {
+            if (typeof r[o] != "function") {
+              var p = Error(
+                (s || "React class") + ": " + n + " type `" + o + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof r[o] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw p.name = "Invariant Violation", p;
+            }
+            e = r[o](t, o, s, n, null, l);
+          } catch (m) {
+            e = m;
+          }
+          if (e && !(e instanceof Error) && a(
+            (s || "React class") + ": type specification of " + n + " `" + o + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof e + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), e instanceof Error && !(e.message in i)) {
+            i[e.message] = !0;
+            var h = u ? u() : "";
+            a(
+              "Failed " + n + " type: " + e.message + (h ?? "")
+            );
+          }
+        }
+    }
+  }
+  return f.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (i = {});
+  }, c = f, c;
+}
+export {
+  O as __require
+};

package/dist/dist/node_modules/prop-types/factoryWithThrowingShims.js

@@ -0,0 +1,52 @@
+import { __require as f } from "./lib/ReactPropTypesSecret.js";
+var t, p;
+function g() {
+  if (p) return t;
+  p = 1;
+  var c = /* @__PURE__ */ f();
+  function o() {
+  }
+  function a() {
+  }
+  return a.resetWarningCache = o, t = function() {
+    function e(u, y, l, h, m, s) {
+      if (s !== c) {
+        var i = new Error(
+          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
+        );
+        throw i.name = "Invariant Violation", i;
+      }
+    }
+    e.isRequired = e;
+    function r() {
+      return e;
+    }
+    var n = {
+      array: e,
+      bigint: e,
+      bool: e,
+      func: e,
+      number: e,
+      object: e,
+      string: e,
+      symbol: e,
+      any: e,
+      arrayOf: r,
+      element: e,
+      elementType: e,
+      instanceOf: r,
+      node: e,
+      objectOf: r,
+      oneOf: r,
+      oneOfType: r,
+      shape: r,
+      exact: r,
+      checkPropTypes: a,
+      resetWarningCache: o
+    };
+    return n.PropTypes = n, n;
+  }, t;
+}
+export {
+  g as __require
+};