qaema-ui 0.0.1

package/dist/node_modules/react-smooth/es6/configUpdate.js

@@ -0,0 +1,168 @@
+import { getIntersectionKeys as F, mapObject as b } from "./util.js";
+function v(t) {
+  "@babel/helpers - typeof";
+  return v = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(r) {
+    return typeof r;
+  } : function(r) {
+    return r && typeof Symbol == "function" && r.constructor === Symbol && r !== Symbol.prototype ? "symbol" : typeof r;
+  }, v(t);
+}
+function P(t) {
+  return x(t) || q(t) || _(t) || K();
+}
+function K() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function q(t) {
+  if (typeof Symbol < "u" && t[Symbol.iterator] != null || t["@@iterator"] != null) return Array.from(t);
+}
+function x(t) {
+  if (Array.isArray(t)) return A(t);
+}
+function w(t, r) {
+  var e = Object.keys(t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(t);
+    r && (n = n.filter(function(a) {
+      return Object.getOwnPropertyDescriptor(t, a).enumerable;
+    })), e.push.apply(e, n);
+  }
+  return e;
+}
+function i(t) {
+  for (var r = 1; r < arguments.length; r++) {
+    var e = arguments[r] != null ? arguments[r] : {};
+    r % 2 ? w(Object(e), !0).forEach(function(n) {
+      O(t, n, e[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(e)) : w(Object(e)).forEach(function(n) {
+      Object.defineProperty(t, n, Object.getOwnPropertyDescriptor(e, n));
+    });
+  }
+  return t;
+}
+function O(t, r, e) {
+  return r = H(r), r in t ? Object.defineProperty(t, r, { value: e, enumerable: !0, configurable: !0, writable: !0 }) : t[r] = e, t;
+}
+function H(t) {
+  var r = V(t, "string");
+  return v(r) === "symbol" ? r : String(r);
+}
+function V(t, r) {
+  if (v(t) !== "object" || t === null) return t;
+  var e = t[Symbol.toPrimitive];
+  if (e !== void 0) {
+    var n = e.call(t, r);
+    if (v(n) !== "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (r === "string" ? String : Number)(t);
+}
+function W(t, r) {
+  return N(t) || M(t, r) || _(t, r) || L();
+}
+function L() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function _(t, r) {
+  if (t) {
+    if (typeof t == "string") return A(t, r);
+    var e = Object.prototype.toString.call(t).slice(8, -1);
+    if (e === "Object" && t.constructor && (e = t.constructor.name), e === "Map" || e === "Set") return Array.from(t);
+    if (e === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(e)) return A(t, r);
+  }
+}
+function A(t, r) {
+  (r == null || r > t.length) && (r = t.length);
+  for (var e = 0, n = new Array(r); e < r; e++) n[e] = t[e];
+  return n;
+}
+function M(t, r) {
+  var e = t == null ? null : typeof Symbol < "u" && t[Symbol.iterator] || t["@@iterator"];
+  if (e != null) {
+    var n, a, l, o, c = [], f = !0, y = !1;
+    try {
+      if (l = (e = e.call(t)).next, r !== 0) for (; !(f = (n = l.call(e)).done) && (c.push(n.value), c.length !== r); f = !0) ;
+    } catch (m) {
+      y = !0, a = m;
+    } finally {
+      try {
+        if (!f && e.return != null && (o = e.return(), Object(o) !== o)) return;
+      } finally {
+        if (y) throw a;
+      }
+    }
+    return c;
+  }
+}
+function N(t) {
+  if (Array.isArray(t)) return t;
+}
+var S = function(r, e, n) {
+  return r + (e - r) * n;
+}, j = function(r) {
+  var e = r.from, n = r.to;
+  return e !== n;
+}, R = function t(r, e, n) {
+  var a = b(function(l, o) {
+    if (j(o)) {
+      var c = r(o.from, o.to, o.velocity), f = W(c, 2), y = f[0], m = f[1];
+      return i(i({}, o), {}, {
+        from: y,
+        velocity: m
+      });
+    }
+    return o;
+  }, e);
+  return n < 1 ? b(function(l, o) {
+    return j(o) ? i(i({}, o), {}, {
+      velocity: S(o.velocity, a[l].velocity, n),
+      from: S(o.from, a[l].from, n)
+    }) : o;
+  }, e) : t(r, a, n - 1);
+};
+const z = (function(t, r, e, n, a) {
+  var l = F(t, r), o = l.reduce(function(p, u) {
+    return i(i({}, p), {}, O({}, u, [t[u], r[u]]));
+  }, {}), c = l.reduce(function(p, u) {
+    return i(i({}, p), {}, O({}, u, {
+      from: t[u],
+      velocity: 0,
+      to: r[u]
+    }));
+  }, {}), f = -1, y, m, d = function() {
+    return null;
+  }, T = function() {
+    return b(function(u, s) {
+      return s.from;
+    }, c);
+  }, I = function() {
+    return !Object.values(c).filter(j).length;
+  }, C = function(u) {
+    y || (y = u);
+    var s = u - y, h = s / e.dt;
+    c = R(e, c, h), a(i(i(i({}, t), r), T())), y = u, I() || (f = requestAnimationFrame(d));
+  }, U = function(u) {
+    m || (m = u);
+    var s = (u - m) / n, h = b(function(D, g) {
+      return S.apply(void 0, P(g).concat([e(s)]));
+    }, o);
+    if (a(i(i(i({}, t), r), h)), s < 1)
+      f = requestAnimationFrame(d);
+    else {
+      var E = b(function(D, g) {
+        return S.apply(void 0, P(g).concat([e(1)]));
+      }, o);
+      a(i(i(i({}, t), r), E));
+    }
+  };
+  return d = e.isStepper ? C : U, function() {
+    return requestAnimationFrame(d), function() {
+      cancelAnimationFrame(f);
+    };
+  };
+});
+export {
+  z as default
+};

package/dist/node_modules/react-smooth/es6/easing.js

@@ -0,0 +1,154 @@
+import { warn as m } from "./util.js";
+function F(r, t) {
+  return H(r) || O(r, t) || T(r, t) || M();
+}
+function M() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function O(r, t) {
+  var e = r == null ? null : typeof Symbol < "u" && r[Symbol.iterator] || r["@@iterator"];
+  if (e != null) {
+    var i, n, u, a, o = [], f = !0, p = !1;
+    try {
+      if (u = (e = e.call(r)).next, t !== 0) for (; !(f = (i = u.call(e)).done) && (o.push(i.value), o.length !== t); f = !0) ;
+    } catch (s) {
+      p = !0, n = s;
+    } finally {
+      try {
+        if (!f && e.return != null && (a = e.return(), Object(a) !== a)) return;
+      } finally {
+        if (p) throw n;
+      }
+    }
+    return o;
+  }
+}
+function H(r) {
+  if (Array.isArray(r)) return r;
+}
+function R(r) {
+  return Y(r) || W(r) || T(r) || U();
+}
+function U() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function T(r, t) {
+  if (r) {
+    if (typeof r == "string") return w(r, t);
+    var e = Object.prototype.toString.call(r).slice(8, -1);
+    if (e === "Object" && r.constructor && (e = r.constructor.name), e === "Map" || e === "Set") return Array.from(r);
+    if (e === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(e)) return w(r, t);
+  }
+}
+function W(r) {
+  if (typeof Symbol < "u" && r[Symbol.iterator] != null || r["@@iterator"] != null) return Array.from(r);
+}
+function Y(r) {
+  if (Array.isArray(r)) return w(r);
+}
+function w(r, t) {
+  (t == null || t > r.length) && (t = r.length);
+  for (var e = 0, i = new Array(t); e < t; e++) i[e] = r[e];
+  return i;
+}
+var g = 1e-4, E = function(t, e) {
+  return [0, 3 * t, 3 * e - 6 * t, 3 * t - 3 * e + 1];
+}, j = function(t, e) {
+  return t.map(function(i, n) {
+    return i * Math.pow(e, n);
+  }).reduce(function(i, n) {
+    return i + n;
+  });
+}, C = function(t, e) {
+  return function(i) {
+    var n = E(t, e);
+    return j(n, i);
+  };
+}, D = function(t, e) {
+  return function(i) {
+    var n = E(t, e), u = [].concat(R(n.map(function(a, o) {
+      return a * o;
+    }).slice(1)), [0]);
+    return j(u, i);
+  };
+}, I = function() {
+  for (var t = arguments.length, e = new Array(t), i = 0; i < t; i++)
+    e[i] = arguments[i];
+  var n = e[0], u = e[1], a = e[2], o = e[3];
+  if (e.length === 1)
+    switch (e[0]) {
+      case "linear":
+        n = 0, u = 0, a = 1, o = 1;
+        break;
+      case "ease":
+        n = 0.25, u = 0.1, a = 0.25, o = 1;
+        break;
+      case "ease-in":
+        n = 0.42, u = 0, a = 1, o = 1;
+        break;
+      case "ease-out":
+        n = 0.42, u = 0, a = 0.58, o = 1;
+        break;
+      case "ease-in-out":
+        n = 0, u = 0, a = 0.58, o = 1;
+        break;
+      default: {
+        var f = e[0].split("(");
+        if (f[0] === "cubic-bezier" && f[1].split(")")[0].split(",").length === 4) {
+          var p = f[1].split(")")[0].split(",").map(function(c) {
+            return parseFloat(c);
+          }), s = F(p, 4);
+          n = s[0], u = s[1], a = s[2], o = s[3];
+        } else
+          m(!1, "[configBezier]: arguments should be one of oneOf 'linear', 'ease', 'ease-in', 'ease-out', 'ease-in-out','cubic-bezier(x1,y1,x2,y2)', instead received %s", e);
+      }
+    }
+  m([n, a, u, o].every(function(c) {
+    return typeof c == "number" && c >= 0 && c <= 1;
+  }), "[configBezier]: arguments should be x1, y1, x2, y2 of [0, 1] instead received %s", e);
+  var y = C(n, a), l = C(u, o), h = D(n, a), A = function(v) {
+    return v > 1 ? 1 : v < 0 ? 0 : v;
+  }, d = function(v) {
+    for (var z = v > 1 ? 1 : v, b = z, S = 0; S < 8; ++S) {
+      var x = y(b) - z, B = h(b);
+      if (Math.abs(x - z) < g || B < g)
+        return l(b);
+      b = A(b - x / B);
+    }
+    return l(b);
+  };
+  return d.isStepper = !1, d;
+}, L = function() {
+  var t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, e = t.stiff, i = e === void 0 ? 100 : e, n = t.damping, u = n === void 0 ? 8 : n, a = t.dt, o = a === void 0 ? 17 : a, f = function(s, y, l) {
+    var h = -(s - y) * i, A = l * u, d = l + (h - A) * o / 1e3, c = l * o / 1e3 + s;
+    return Math.abs(c - y) < g && Math.abs(d) < g ? [y, 0] : [c, d];
+  };
+  return f.isStepper = !0, f.dt = o, f;
+}, _ = function() {
+  for (var t = arguments.length, e = new Array(t), i = 0; i < t; i++)
+    e[i] = arguments[i];
+  var n = e[0];
+  if (typeof n == "string")
+    switch (n) {
+      case "ease":
+      case "ease-in-out":
+      case "ease-out":
+      case "ease-in":
+      case "linear":
+        return I(n);
+      case "spring":
+        return L();
+      default:
+        if (n.split("(")[0] === "cubic-bezier")
+          return I(n);
+        m(!1, "[configEasing]: first argument should be one of 'ease', 'ease-in', 'ease-out', 'ease-in-out','cubic-bezier(x1,y1,x2,y2)', 'linear' and 'spring', instead  received %s", e);
+    }
+  return typeof n == "function" ? n : (m(!1, "[configEasing]: first argument type should be function or string, instead received %s", e), null);
+};
+export {
+  I as configBezier,
+  _ as configEasing,
+  L as configSpring
+};

package/dist/node_modules/react-smooth/es6/index.js

@@ -0,0 +1,4 @@
+import a from "./Animate.js";
+export {
+  a as default
+};

package/dist/node_modules/react-smooth/es6/setRafTimeout.js

@@ -0,0 +1,12 @@
+function r(t) {
+  typeof requestAnimationFrame < "u" && requestAnimationFrame(t);
+}
+function m(t) {
+  var n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0, e = -1, i = function u(a) {
+    e < 0 && (e = a), a - e > n ? (t(a), e = -1) : r(u);
+  };
+  requestAnimationFrame(i);
+}
+export {
+  m as default
+};

package/dist/node_modules/react-smooth/es6/util.js

@@ -0,0 +1,85 @@
+function i(r) {
+  "@babel/helpers - typeof";
+  return i = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+    return typeof e;
+  } : function(e) {
+    return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+  }, i(r);
+}
+function u(r, e) {
+  var t = Object.keys(r);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(r);
+    e && (n = n.filter(function(o) {
+      return Object.getOwnPropertyDescriptor(r, o).enumerable;
+    })), t.push.apply(t, n);
+  }
+  return t;
+}
+function a(r) {
+  for (var e = 1; e < arguments.length; e++) {
+    var t = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? u(Object(t), !0).forEach(function(n) {
+      f(r, n, t[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(r, Object.getOwnPropertyDescriptors(t)) : u(Object(t)).forEach(function(n) {
+      Object.defineProperty(r, n, Object.getOwnPropertyDescriptor(t, n));
+    });
+  }
+  return r;
+}
+function f(r, e, t) {
+  return e = m(e), e in r ? Object.defineProperty(r, e, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : r[e] = t, r;
+}
+function m(r) {
+  var e = g(r, "string");
+  return i(e) === "symbol" ? e : String(e);
+}
+function g(r, e) {
+  if (i(r) !== "object" || r === null) return r;
+  var t = r[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var n = t.call(r, e);
+    if (i(n) !== "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(r);
+}
+var O = function(e, t) {
+  return [Object.keys(e), Object.keys(t)].reduce(function(n, o) {
+    return n.filter(function(c) {
+      return o.includes(c);
+    });
+  });
+}, w = function(e) {
+  return e;
+}, d = function(e) {
+  return e.replace(/([A-Z])/g, function(t) {
+    return "-".concat(t.toLowerCase());
+  });
+}, j = function(e, t) {
+  return Object.keys(t).reduce(function(n, o) {
+    return a(a({}, n), {}, f({}, o, e(o, t[o])));
+  }, {});
+}, P = function(e, t, n) {
+  return e.map(function(o) {
+    return "".concat(d(o), " ").concat(t, "ms ").concat(n);
+  }).join(",");
+}, v = process.env.NODE_ENV !== "production", S = function(e, t, n, o, c, s, l, p) {
+  if (v && typeof console < "u" && console.warn && (t === void 0 && console.warn("LogUtils requires an error message argument"), !e))
+    if (t === void 0)
+      console.warn("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");
+    else {
+      var y = [n, o, c, s, l, p], b = 0;
+      console.warn(t.replace(/%s/g, function() {
+        return y[b++];
+      }));
+    }
+};
+export {
+  d as getDashCase,
+  O as getIntersectionKeys,
+  P as getTransitionVal,
+  w as identity,
+  j as mapObject,
+  S as warn
+};