lawgic-dev-kit 0.2.4 → 0.3.4

package/dist/node_modules/framer-motion/dist/es/render/svg/lowercase-elements.js

@@ -0,0 +1,30 @@
+const e = [
+  "animate",
+  "circle",
+  "defs",
+  "desc",
+  "ellipse",
+  "g",
+  "image",
+  "line",
+  "filter",
+  "marker",
+  "mask",
+  "metadata",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "rect",
+  "stop",
+  "switch",
+  "symbol",
+  "svg",
+  "text",
+  "tspan",
+  "use",
+  "view"
+];
+export {
+  e as lowercaseSVGElements
+};

package/dist/node_modules/framer-motion/dist/es/render/svg/use-props.js

@@ -0,0 +1,22 @@
+import { useMemo as m } from "react";
+import { copyRawValuesOnly as i } from "../html/use-props.js";
+import { buildSVGAttrs as l } from "./utils/build-attrs.js";
+import { createSvgRenderState as a } from "./utils/create-render-state.js";
+import { isSVGTag as n } from "./utils/is-svg-tag.js";
+function V(e, s, y, o) {
+  const r = m(() => {
+    const t = a();
+    return l(t, s, n(o), e.transformTemplate), {
+      ...t.attrs,
+      style: { ...t.style }
+    };
+  }, [s]);
+  if (e.style) {
+    const t = {};
+    i(t, e.style, e), r.style = { ...t, ...r.style };
+  }
+  return r;
+}
+export {
+  V as useSVGProps
+};

package/dist/node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.js

@@ -0,0 +1,26 @@
+import { buildHTMLStyles as b } from "../../html/utils/build-styles.js";
+import { buildSVGPath as p } from "./path.js";
+import { calcSVGTransformOrigin as v } from "./transform-origin.js";
+function S(f, {
+  attrX: o,
+  attrY: s,
+  attrScale: m,
+  originX: i,
+  originY: e,
+  pathLength: u,
+  pathSpacing: l = 1,
+  pathOffset: t = 0,
+  // This is object creation, which we try to avoid per-frame.
+  ...y
+}, x, c) {
+  if (b(f, y, c), x) {
+    f.style.viewBox && (f.attrs.viewBox = f.style.viewBox);
+    return;
+  }
+  f.attrs = f.style, f.style = {};
+  const { attrs: n, style: r, dimensions: d } = f;
+  n.transform && (d && (r.transform = n.transform), delete n.transform), d && (i !== void 0 || e !== void 0 || r.transform) && (r.transformOrigin = v(d, i !== void 0 ? i : 0.5, e !== void 0 ? e : 0.5)), o !== void 0 && (n.x = o), s !== void 0 && (n.y = s), m !== void 0 && (n.scale = m), u !== void 0 && p(n, u, l, t, !1);
+}
+export {
+  S as buildSVGAttrs
+};

package/dist/node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.js

@@ -0,0 +1,28 @@
+const e = /* @__PURE__ */ new Set([
+  "baseFrequency",
+  "diffuseConstant",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "keySplines",
+  "keyTimes",
+  "limitingConeAngle",
+  "markerHeight",
+  "markerWidth",
+  "numOctaves",
+  "targetX",
+  "targetY",
+  "surfaceScale",
+  "specularConstant",
+  "specularExponent",
+  "stdDeviation",
+  "tableValues",
+  "viewBox",
+  "gradientTransform",
+  "pathLength",
+  "startOffset",
+  "textLength",
+  "lengthAdjust"
+]);
+export {
+  e as camelCaseAttributes
+};

package/dist/node_modules/framer-motion/dist/es/render/svg/utils/create-render-state.js

@@ -0,0 +1,8 @@
+import { createHtmlRenderState as t } from "../../html/utils/create-render-state.js";
+const r = () => ({
+  ...t(),
+  attrs: {}
+});
+export {
+  r as createSvgRenderState
+};

package/dist/node_modules/framer-motion/dist/es/render/svg/utils/is-svg-tag.js

@@ -0,0 +1,4 @@
+const s = (o) => typeof o == "string" && o.toLowerCase() === "svg";
+export {
+  s as isSVGTag
+};

package/dist/node_modules/framer-motion/dist/es/render/svg/utils/measure.js

@@ -0,0 +1,15 @@
+function e(i, o) {
+  try {
+    o.dimensions = typeof i.getBBox == "function" ? i.getBBox() : i.getBoundingClientRect();
+  } catch {
+    o.dimensions = {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    };
+  }
+}
+export {
+  e as updateSVGDimensions
+};

package/dist/node_modules/framer-motion/dist/es/render/svg/utils/path.js

@@ -0,0 +1,18 @@
+import { px as t } from "../../../value/types/numbers/units.js";
+const c = {
+  offset: "stroke-dashoffset",
+  array: "stroke-dasharray"
+}, y = {
+  offset: "strokeDashoffset",
+  array: "strokeDasharray"
+};
+function m(s, r, o = 1, e = 0, f = !0) {
+  s.pathLength = 1;
+  const a = f ? c : y;
+  s[a.offset] = t.transform(-e);
+  const n = t.transform(r), h = t.transform(o);
+  s[a.array] = `${n} ${h}`;
+}
+export {
+  m as buildSVGPath
+};

package/dist/node_modules/framer-motion/dist/es/render/svg/utils/render.js

@@ -0,0 +1,11 @@
+import { camelToDash as i } from "../../dom/utils/camel-to-dash.js";
+import { renderHTML as m } from "../../html/utils/render.js";
+import { camelCaseAttributes as e } from "./camel-case-attrs.js";
+function c(o, t, f, s) {
+  m(o, t, void 0, s);
+  for (const r in t.attrs)
+    o.setAttribute(e.has(r) ? r : i(r), t.attrs[r]);
+}
+export {
+  c as renderSVG
+};

package/dist/node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.js

@@ -0,0 +1,15 @@
+import { isMotionValue as n } from "../../../value/utils/is-motion-value.js";
+import { transformPropOrder as i } from "../../html/utils/keys-transform.js";
+import { scrapeMotionValuesFromProps as m } from "../../html/utils/scrape-motion-values.js";
+function l(r, t, s) {
+  const e = m(r, t, s);
+  for (const o in r)
+    if (n(r[o]) || n(t[o])) {
+      const a = i.indexOf(o) !== -1 ? "attr" + o.charAt(0).toUpperCase() + o.substring(1) : o;
+      e[a] = r[o];
+    }
+  return e;
+}
+export {
+  l as scrapeMotionValuesFromProps
+};

package/dist/node_modules/framer-motion/dist/es/render/svg/utils/transform-origin.js

@@ -0,0 +1,11 @@
+import { px as o } from "../../../value/types/numbers/units.js";
+function n(r, t, c) {
+  return typeof r == "string" ? r : o.transform(t + c * r);
+}
+function a(r, t, c) {
+  const f = n(t, r.x, r.width), p = n(c, r.y, r.height);
+  return `${f} ${p}`;
+}
+export {
+  a as calcSVGTransformOrigin
+};

package/dist/node_modules/framer-motion/dist/es/render/utils/KeyframesResolver.js

@@ -0,0 +1,77 @@
+import "../../../../../motion-utils/dist/es/errors.js";
+import { frame as u } from "../../../../../motion-dom/dist/es/frameloop/frame.js";
+import { removeNonTranslationalTransform as y } from "../dom/utils/unit-conversion.js";
+const n = /* @__PURE__ */ new Set();
+let d = !1, m = !1;
+function h() {
+  if (m) {
+    const r = Array.from(n).filter((e) => e.needsMeasurement), s = new Set(r.map((e) => e.element)), i = /* @__PURE__ */ new Map();
+    s.forEach((e) => {
+      const t = y(e);
+      t.length && (i.set(e, t), e.render());
+    }), r.forEach((e) => e.measureInitialState()), s.forEach((e) => {
+      e.render();
+      const t = i.get(e);
+      t && t.forEach(([a, l]) => {
+        var o;
+        (o = e.getValue(a)) === null || o === void 0 || o.set(l);
+      });
+    }), r.forEach((e) => e.measureEndState()), r.forEach((e) => {
+      e.suspendedScrollY !== void 0 && window.scrollTo(0, e.suspendedScrollY);
+    });
+  }
+  m = !1, d = !1, n.forEach((r) => r.complete()), n.clear();
+}
+function c() {
+  n.forEach((r) => {
+    r.readKeyframes(), r.needsMeasurement && (m = !0);
+  });
+}
+function S() {
+  c(), h();
+}
+class E {
+  constructor(s, i, e, t, a, l = !1) {
+    this.isComplete = !1, this.isAsync = !1, this.needsMeasurement = !1, this.isScheduled = !1, this.unresolvedKeyframes = [...s], this.onComplete = i, this.name = e, this.motionValue = t, this.element = a, this.isAsync = l;
+  }
+  scheduleResolve() {
+    this.isScheduled = !0, this.isAsync ? (n.add(this), d || (d = !0, u.read(c), u.resolveKeyframes(h))) : (this.readKeyframes(), this.complete());
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: s, name: i, element: e, motionValue: t } = this;
+    for (let a = 0; a < s.length; a++)
+      if (s[a] === null)
+        if (a === 0) {
+          const l = t == null ? void 0 : t.get(), o = s[s.length - 1];
+          if (l !== void 0)
+            s[0] = l;
+          else if (e && i) {
+            const f = e.readValue(i, o);
+            f != null && (s[0] = f);
+          }
+          s[0] === void 0 && (s[0] = o), t && l === void 0 && t.set(s[0]);
+        } else
+          s[a] = s[a - 1];
+  }
+  setFinalKeyframe() {
+  }
+  measureInitialState() {
+  }
+  renderEndStyles() {
+  }
+  measureEndState() {
+  }
+  complete() {
+    this.isComplete = !0, this.onComplete(this.unresolvedKeyframes, this.finalKeyframe), n.delete(this);
+  }
+  cancel() {
+    this.isComplete || (this.isScheduled = !1, n.delete(this));
+  }
+  resume() {
+    this.isComplete || this.scheduleResolve();
+  }
+}
+export {
+  E as KeyframeResolver,
+  S as flushKeyframeResolvers
+};

package/dist/node_modules/framer-motion/dist/es/render/utils/animation-state.js

@@ -0,0 +1,128 @@
+import { animateVisualElement as j } from "../../animation/interfaces/visual-element.js";
+import { isAnimationControls as q } from "../../animation/utils/is-animation-controls.js";
+import { isKeyframesTarget as D } from "../../animation/utils/is-keyframes-target.js";
+import { shallowCompare as k } from "../../utils/shallow-compare.js";
+import { getVariantContext as G } from "./get-variant-context.js";
+import { isVariantLabel as J } from "./is-variant-label.js";
+import { resolveVariant as L } from "./resolve-dynamic-variants.js";
+import { variantPriorityOrder as B } from "./variant-props.js";
+const N = [...B].reverse(), Q = B.length;
+function U(e) {
+  return (f) => Promise.all(f.map(({ animation: c, options: v }) => j(e, c, v)));
+}
+function oe(e) {
+  let f = U(e), c = _(), v = !0;
+  const F = (s) => (t, p) => {
+    var l;
+    const r = L(e, p, s === "exit" ? (l = e.presenceContext) === null || l === void 0 ? void 0 : l.custom : void 0);
+    if (r) {
+      const { transition: u, transitionEnd: y, ...g } = r;
+      t = { ...t, ...g, ...y };
+    }
+    return t;
+  };
+  function H(s) {
+    f = s(e);
+  }
+  function K(s) {
+    const { props: t } = e, p = G(e.parent) || {}, l = [], r = /* @__PURE__ */ new Set();
+    let u = {}, y = 1 / 0;
+    for (let d = 0; d < Q; d++) {
+      const i = N[d], n = c[i], o = t[i] !== void 0 ? t[i] : p[i], w = J(o), P = i === s ? n.isActive : null;
+      P === !1 && (y = d);
+      let V = o === p[i] && o !== t[i] && w;
+      if (V && v && e.manuallyAnimateOnMount && (V = !1), n.protectedKeys = { ...u }, // If it isn't active and hasn't *just* been set as inactive
+      !n.isActive && P === null || // If we didn't and don't have any defined prop for this animation type
+      !o && !n.prevProp || // Or if the prop doesn't define an animation
+      q(o) || typeof o == "boolean")
+        continue;
+      const b = W(n.prevProp, o);
+      let C = b || // If we're making this variant active, we want to always make it active
+      i === s && n.isActive && !V && w || // If we removed a higher-priority variant (i is in reverse order)
+      d > y && w, I = !1;
+      const R = Array.isArray(o) ? o : [o];
+      let h = R.reduce(F(i), {});
+      P === !1 && (h = {});
+      const { prevResolvedValues: x = {} } = n, z = {
+        ...x,
+        ...h
+      }, O = (a) => {
+        C = !0, r.has(a) && (I = !0, r.delete(a)), n.needsAnimating[a] = !0;
+        const m = e.getValue(a);
+        m && (m.liveStyle = !1);
+      };
+      for (const a in z) {
+        const m = h[a], S = x[a];
+        if (u.hasOwnProperty(a))
+          continue;
+        let T = !1;
+        D(m) && D(S) ? T = !k(m, S) : T = m !== S, T ? m != null ? O(a) : r.add(a) : m !== void 0 && r.has(a) ? O(a) : n.protectedKeys[a] = !0;
+      }
+      n.prevProp = o, n.prevResolvedValues = h, n.isActive && (u = { ...u, ...h }), v && e.blockInitialAnimation && (C = !1), C && (!(V && b) || I) && l.push(...R.map((a) => ({
+        animation: a,
+        options: { type: i }
+      })));
+    }
+    if (r.size) {
+      const d = {};
+      if (typeof t.initial != "boolean") {
+        const i = L(e, Array.isArray(t.initial) ? t.initial[0] : t.initial);
+        i && i.transition && (d.transition = i.transition);
+      }
+      r.forEach((i) => {
+        const n = e.getBaseTarget(i), o = e.getValue(i);
+        o && (o.liveStyle = !0), d[i] = n ?? null;
+      }), l.push({ animation: d });
+    }
+    let g = !!l.length;
+    return v && (t.initial === !1 || t.initial === t.animate) && !e.manuallyAnimateOnMount && (g = !1), v = !1, g ? f(l) : Promise.resolve();
+  }
+  function M(s, t) {
+    var p;
+    if (c[s].isActive === t)
+      return Promise.resolve();
+    (p = e.variantChildren) === null || p === void 0 || p.forEach((r) => {
+      var u;
+      return (u = r.animationState) === null || u === void 0 ? void 0 : u.setActive(s, t);
+    }), c[s].isActive = t;
+    const l = K(s);
+    for (const r in c)
+      c[r].protectedKeys = {};
+    return l;
+  }
+  return {
+    animateChanges: K,
+    setActive: M,
+    setAnimateFunction: H,
+    getState: () => c,
+    reset: () => {
+      c = _(), v = !0;
+    }
+  };
+}
+function W(e, f) {
+  return typeof f == "string" ? f !== e : Array.isArray(f) ? !k(f, e) : !1;
+}
+function A(e = !1) {
+  return {
+    isActive: e,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function _() {
+  return {
+    animate: A(!0),
+    whileInView: A(),
+    whileHover: A(),
+    whileTap: A(),
+    whileDrag: A(),
+    whileFocus: A(),
+    exit: A()
+  };
+}
+export {
+  W as checkVariantsDidChange,
+  oe as createAnimationState
+};

package/dist/node_modules/framer-motion/dist/es/render/utils/compare-by-depth.js

@@ -0,0 +1,4 @@
+const t = (e, p) => e.depth - p.depth;
+export {
+  t as compareByDepth
+};

package/dist/node_modules/framer-motion/dist/es/render/utils/flat-tree.js

@@ -0,0 +1,20 @@
+import { addUniqueItem as t, removeItem as r } from "../../../../../motion-utils/dist/es/array.js";
+import "../../../../../motion-utils/dist/es/errors.js";
+import { compareByDepth as e } from "./compare-by-depth.js";
+class m {
+  constructor() {
+    this.children = [], this.isDirty = !1;
+  }
+  add(i) {
+    t(this.children, i), this.isDirty = !0;
+  }
+  remove(i) {
+    r(this.children, i), this.isDirty = !0;
+  }
+  forEach(i) {
+    this.isDirty && this.children.sort(e), this.isDirty = !1, this.children.forEach(i);
+  }
+}
+export {
+  m as FlatTree
+};

package/dist/node_modules/framer-motion/dist/es/render/utils/get-variant-context.js

@@ -0,0 +1,20 @@
+import { isVariantLabel as a } from "./is-variant-label.js";
+import { variantProps as p } from "./variant-props.js";
+const f = p.length;
+function c(n) {
+  if (!n)
+    return;
+  if (!n.isControllingVariants) {
+    const r = n.parent ? c(n.parent) || {} : {};
+    return n.props.initial !== void 0 && (r.initial = n.props.initial), r;
+  }
+  const o = {};
+  for (let r = 0; r < f; r++) {
+    const i = p[r], t = n.props[i];
+    (a(t) || t === !1) && (o[i] = t);
+  }
+  return o;
+}
+export {
+  c as getVariantContext
+};

package/dist/node_modules/framer-motion/dist/es/render/utils/is-controlling-variants.js

@@ -0,0 +1,13 @@
+import { isAnimationControls as o } from "../../animation/utils/is-animation-controls.js";
+import { isVariantLabel as r } from "./is-variant-label.js";
+import { variantProps as t } from "./variant-props.js";
+function a(i) {
+  return o(i.animate) || t.some((n) => r(i[n]));
+}
+function f(i) {
+  return !!(a(i) || i.variants);
+}
+export {
+  a as isControllingVariants,
+  f as isVariantNode
+};

package/dist/node_modules/framer-motion/dist/es/render/utils/is-variant-label.js

@@ -0,0 +1,6 @@
+function t(r) {
+  return typeof r == "string" || Array.isArray(r);
+}
+export {
+  t as isVariantLabel
+};

package/dist/node_modules/framer-motion/dist/es/render/utils/motion-values.js

@@ -0,0 +1,27 @@
+import "../../../../../motion-utils/dist/es/errors.js";
+import { warnOnce as f } from "../../../../../motion-utils/dist/es/warn-once.js";
+import { motionValue as n } from "../../../../../motion-dom/dist/es/value/index.js";
+import { isMotionValue as u } from "../../value/utils/is-motion-value.js";
+function c(i, a, s) {
+  for (const o in a) {
+    const e = a[o], r = s[o];
+    if (u(e))
+      i.addValue(o, e), process.env.NODE_ENV === "development" && f(e.version === "12.6.2", `Attempting to mix Motion versions ${e.version} with 12.6.2 may not work as expected.`);
+    else if (u(r))
+      i.addValue(o, n(e, { owner: i }));
+    else if (r !== e)
+      if (i.hasValue(o)) {
+        const t = i.getValue(o);
+        t.liveStyle === !0 ? t.jump(e) : t.hasAnimated || t.set(e);
+      } else {
+        const t = i.getStaticValue(o);
+        i.addValue(o, n(t !== void 0 ? t : e, { owner: i }));
+      }
+  }
+  for (const o in s)
+    a[o] === void 0 && i.removeValue(o);
+  return a;
+}
+export {
+  c as updateMotionValuesFromProps
+};

package/dist/node_modules/framer-motion/dist/es/render/utils/resolve-dynamic-variants.js

@@ -0,0 +1,8 @@
+import { resolveVariantFromProps as t } from "./resolve-variants.js";
+function s(r, n, o) {
+  const e = r.getProps();
+  return t(e, n, o !== void 0 ? o : e.custom, r);
+}
+export {
+  s as resolveVariant
+};

package/dist/node_modules/framer-motion/dist/es/render/utils/resolve-variants.js

@@ -0,0 +1,20 @@
+function o(r) {
+  const t = [{}, {}];
+  return r == null || r.values.forEach((c, u) => {
+    t[0][u] = c.get(), t[1][u] = c.getVelocity();
+  }), t;
+}
+function y(r, t, c, u) {
+  if (typeof t == "function") {
+    const [a, e] = o(u);
+    t = t(c !== void 0 ? c : r.custom, a, e);
+  }
+  if (typeof t == "string" && (t = r.variants && r.variants[t]), typeof t == "function") {
+    const [a, e] = o(u);
+    t = t(c !== void 0 ? c : r.custom, a, e);
+  }
+  return t;
+}
+export {
+  y as resolveVariantFromProps
+};

package/dist/node_modules/framer-motion/dist/es/render/utils/setters.js

@@ -0,0 +1,19 @@
+import "../../../../../motion-utils/dist/es/errors.js";
+import { motionValue as s } from "../../../../../motion-dom/dist/es/value/index.js";
+import { resolveFinalValueInKeyframes as f } from "../../utils/resolve-value.js";
+import { resolveVariant as V } from "./resolve-dynamic-variants.js";
+function l(o, t, r) {
+  o.hasValue(t) ? o.getValue(t).set(r) : o.addValue(t, s(r));
+}
+function g(o, t) {
+  const r = V(o, t);
+  let { transitionEnd: a = {}, transition: m = {}, ...e } = r || {};
+  e = { ...e, ...a };
+  for (const n in e) {
+    const i = f(e[n]);
+    l(o, n, i);
+  }
+}
+export {
+  g as setTarget
+};

package/dist/node_modules/framer-motion/dist/es/render/utils/variant-props.js

@@ -0,0 +1,13 @@
+const i = [
+  "animate",
+  "whileInView",
+  "whileFocus",
+  "whileHover",
+  "whileTap",
+  "whileDrag",
+  "exit"
+], e = ["initial", ...i];
+export {
+  i as variantPriorityOrder,
+  e as variantProps
+};

package/dist/node_modules/framer-motion/dist/es/utils/clamp.js

@@ -0,0 +1,4 @@
+const n = (t, e, r) => r > e ? e : r < t ? t : r;
+export {
+  n as clamp
+};

package/dist/node_modules/framer-motion/dist/es/utils/delay.js

@@ -0,0 +1,13 @@
+import "../../../../motion-utils/dist/es/errors.js";
+import { frame as m, cancelFrame as o } from "../../../../motion-dom/dist/es/frameloop/frame.js";
+import { time as p } from "../../../../motion-dom/dist/es/frameloop/sync-time.js";
+function d(a, e) {
+  const c = p.now(), r = ({ timestamp: n }) => {
+    const t = n - c;
+    t >= e && (o(r), a(t - e));
+  };
+  return m.read(r, !0), () => o(r);
+}
+export {
+  d as delay
+};

package/dist/node_modules/framer-motion/dist/es/utils/distance.js

@@ -0,0 +1,9 @@
+const s = (t, n) => Math.abs(t - n);
+function e(t, n) {
+  const a = s(t.x, n.x), c = s(t.y, n.y);
+  return Math.sqrt(a ** 2 + c ** 2);
+}
+export {
+  s as distance,
+  e as distance2D
+};

package/dist/node_modules/framer-motion/dist/es/utils/get-context-window.js

@@ -0,0 +1,4 @@
+const t = ({ current: e }) => e ? e.ownerDocument.defaultView : null;
+export {
+  t as getContextWindow
+};

package/dist/node_modules/framer-motion/dist/es/utils/hsla-to-rgba.js

@@ -0,0 +1,22 @@
+function c(e, f, r) {
+  return r < 0 && (r += 1), r > 1 && (r -= 1), r < 1 / 6 ? e + (f - e) * 6 * r : r < 1 / 2 ? f : r < 2 / 3 ? e + (f - e) * (2 / 3 - r) * 6 : e;
+}
+function R({ hue: e, saturation: f, lightness: r, alpha: M }) {
+  e /= 360, f /= 100, r /= 100;
+  let o = 0, u = 0, d = 0;
+  if (!f)
+    o = u = d = r;
+  else {
+    const n = r < 0.5 ? r * (1 + f) : r + f - r * f, b = 2 * r - n;
+    o = c(b, n, e + 1 / 3), u = c(b, n, e), d = c(b, n, e - 1 / 3);
+  }
+  return {
+    red: Math.round(o * 255),
+    green: Math.round(u * 255),
+    blue: Math.round(d * 255),
+    alpha: M
+  };
+}
+export {
+  R as hslaToRgba
+};