lawgic-dev-kit 0.12.4 → 0.12.8

package/dist/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/dist/node_modules/framer-motion/dist/es/render/svg/use-props.js

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

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

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

package/dist/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/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/dist/node_modules/framer-motion/dist/es/render/svg/utils/is-svg-tag.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/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 s } from "./compare-by-depth.js";
+class c {
+  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(s), this.isDirty = !1, this.children.forEach(i);
+  }
+}
+export {
+  c as FlatTree
+};

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

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

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

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

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

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

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

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

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

package/dist/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 i } from "../../../../../motion-dom/dist/es/value/index.js";
+import { resolveFinalValueInKeyframes as l } from "../../utils/resolve-value.js";
+import { resolveVariant as m } from "./resolve-dynamic-variants.js";
+function f(a, t, e) {
+  a.hasValue(t) ? a.getValue(t).set(e) : a.addValue(t, i(e));
+}
+function d(a, t) {
+  const e = m(a, t);
+  let { transitionEnd: r = {}, transition: u = {}, ...n } = e || {};
+  n = { ...n, ...r };
+  for (const o in n) {
+    const s = l(n[o]);
+    f(a, o, s);
+  }
+}
+export {
+  d as setTarget
+};

package/dist/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/dist/node_modules/framer-motion/dist/es/utils/clamp.js

@@ -0,0 +1,4 @@
+const o = (c, n, a) => a > n ? n : a < c ? c : a;
+export {
+  o as clamp
+};

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

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

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

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

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

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

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

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