@cronocode/react-box 2.0.5 → 2.0.7

package/core.mjs

@@ -1,72 +1,72 @@
-import { useMemo as xe, useLayoutEffect as je, useEffect as Me } from "react";
-import { O as we } from "./utils.mjs";
-var d;
-((u) => {
-  ((o) => {
-    function t(e, O) {
-      return `${e}${O.replace("/", "-")}`;
+import { useMemo as U, useLayoutEffect as ee, useEffect as se } from "react";
+import { O as X } from "./utils.mjs";
+var s;
+((e) => {
+  ((l) => {
+    function u(t, d) {
+      return `${t}${d.replace("/", "-")}`;
     }
-    o.fraction = t;
-    function m(e) {
-      return [`${e} path`, `${e} circle`, `${e} rect`, `${e} line`];
+    l.fraction = u;
+    function n(t) {
+      return [`${t} path`, `${t} circle`, `${t} rect`, `${t} line`];
     }
-    o.svg = m;
-  })(u.ClassName || (u.ClassName = {})), ((o) => {
-    function t(p, h) {
-      return `${h / 4}rem`;
+    l.svg = n;
+  })(e.ClassName || (e.ClassName = {})), ((l) => {
+    function u(r, a) {
+      return `${a / 4}rem`;
     }
-    o.rem = t;
-    function m(p, h) {
-      return `${h}px`;
+    l.rem = u;
+    function n(r, a) {
+      return `${a}px`;
     }
-    o.px = m;
-    function e(p, h) {
-      const [b, x] = h.split("/");
-      return `${+b / +x * 100}%`;
+    l.px = n;
+    function t(r, a) {
+      const [o, v] = a.split("/");
+      return `${+o / +v * 100}%`;
     }
-    o.fraction = e;
-    function O(p, h) {
-      switch (h) {
+    l.fraction = t;
+    function d(r, a) {
+      switch (a) {
         case "fit":
           return "100%";
         case "fit-screen":
-          return p.toLocaleLowerCase().includes("height") ? "100vh" : "100vw";
+          return r.toLocaleLowerCase().includes("height") ? "100vh" : "100vw";
         default:
-          return h;
+          return a;
       }
     }
-    o.widthHeight = O;
-    function q(p) {
-      return (h, b) => `var(--${p}${b});`;
+    l.widthHeight = d;
+    function p(r) {
+      return (a, o) => `var(--${r}${o});`;
     }
-    o.variables = q;
-    function H(p) {
-      return (h, b) => `var(--${p}${b});`;
+    l.variables = p;
+    function k(r) {
+      return (a, o) => `var(--${r}${o});`;
     }
-    o.svgVariables = H;
-    function L(p, h) {
-      return `repeat(${h},minmax(0,1fr))`;
+    l.svgVariables = k;
+    function E(r, a) {
+      return `repeat(${a},minmax(0,1fr))`;
     }
-    o.gridColumns = L;
-    function G(p, h) {
-      return h === "full-row" ? "1/-1" : `span ${h}/span ${h}`;
+    l.gridColumns = E;
+    function C(r, a) {
+      return a === "full-row" ? "1/-1" : `span ${a}/span ${a}`;
     }
-    o.gridColumn = G;
-    function y(p, h) {
-      return `${h}ms`;
+    l.gridColumn = C;
+    function i(r, a) {
+      return `${a}ms`;
     }
-    o.ms = y;
-    function j(p, h) {
-      return `${h}deg`;
+    l.ms = i;
+    function m(r, a) {
+      return `${a}deg`;
     }
-    o.rotate = j;
-    function C(p, h) {
-      return h === "xAxis" ? "-1 1" : "1 -1";
+    l.rotate = m;
+    function f(r, a) {
+      return a === "xAxis" ? "-1 1" : "1 -1";
     }
-    o.flip = C;
-  })(u.Value || (u.Value = {}));
-})(d || (d = {}));
-const M = [
+    l.flip = f;
+  })(e.Value || (e.Value = {}));
+})(s || (s = {}));
+const c = [
   0,
   1,
   2,
@@ -139,7 +139,7 @@ const M = [
   350,
   384,
   400
-], Oe = [
+], ae = [
   -1,
   -2,
   -3,
@@ -185,7 +185,7 @@ const M = [
   -92,
   -96,
   -100
-], T = [...M, ...Oe], fe = ["solid", "dashed", "dotted", "double", "groove", "ridge", "inset", "outset", "none", "hidden"], re = ["auto", "hidden", "scroll", "visible"], _ = [
+], h = [...c, ...ae], W = ["solid", "dashed", "dotted", "double", "groove", "ridge", "inset", "outset", "none", "hidden"], R = ["auto", "hidden", "scroll", "visible"], T = [
   "1/2",
   "1/3",
   "2/3",
@@ -212,7 +212,7 @@ const M = [
   "9/12",
   "10/12",
   "11/12"
-], ee = ["fit", "fit-screen", "auto", "fit-content", "max-content", "min-content"], me = ["auto", "flex-start", "flex-end", "center", "baseline", "stretch"], Ce = {
+], O = ["fit", "fit-screen", "auto", "fit-content", "max-content", "min-content"], F = ["auto", "flex-start", "flex-end", "center", "baseline", "stretch"], le = {
   /** The `display` CSS property sets whether an element is treated as a block or inline box and the layout used for its children, such as flow layout, grid or flex. */
   display: {
     cssNames: ["display"],
@@ -236,61 +236,61 @@ const M = [
   },
   width: {
     cssNames: ["width"],
-    values1: { values: ee, formatValue: d.Value.widthHeight },
-    values2: { values: M, formatValue: d.Value.rem },
+    values1: { values: O, formatValue: s.Value.widthHeight },
+    values2: { values: c, formatValue: s.Value.rem },
     values3: {
-      values: _,
-      formatValue: d.Value.fraction
+      values: T,
+      formatValue: s.Value.fraction
       // formatClassName: BoxStylesFormatters.ClassName.fraction,
     }
   },
   minWidth: {
     cssNames: ["min-width"],
-    values1: { values: ee, formatValue: d.Value.widthHeight },
-    values2: { values: M, formatValue: d.Value.rem },
+    values1: { values: O, formatValue: s.Value.widthHeight },
+    values2: { values: c, formatValue: s.Value.rem },
     values3: {
-      values: _,
-      formatValue: d.Value.fraction
+      values: T,
+      formatValue: s.Value.fraction
       // formatClassName: BoxStylesFormatters.ClassName.fraction,
     }
   },
   maxWidth: {
     cssNames: ["max-width"],
-    values1: { values: ee, formatValue: d.Value.widthHeight },
-    values2: { values: M, formatValue: d.Value.rem },
+    values1: { values: O, formatValue: s.Value.widthHeight },
+    values2: { values: c, formatValue: s.Value.rem },
     values3: {
-      values: _,
-      formatValue: d.Value.fraction
+      values: T,
+      formatValue: s.Value.fraction
       // formatClassName: BoxStylesFormatters.ClassName.fraction,
     }
   },
   height: {
     cssNames: ["height"],
-    values1: { values: ee, formatValue: d.Value.widthHeight },
-    values2: { values: M, formatValue: d.Value.rem },
+    values1: { values: O, formatValue: s.Value.widthHeight },
+    values2: { values: c, formatValue: s.Value.rem },
     values3: {
-      values: _,
-      formatValue: d.Value.fraction
+      values: T,
+      formatValue: s.Value.fraction
       // formatClassName: BoxStylesFormatters.ClassName.fraction,
     }
   },
   minHeight: {
     cssNames: ["min-height"],
-    values1: { values: ee, formatValue: d.Value.widthHeight },
-    values2: { values: M, formatValue: d.Value.rem },
+    values1: { values: O, formatValue: s.Value.widthHeight },
+    values2: { values: c, formatValue: s.Value.rem },
     values3: {
-      values: _,
-      formatValue: d.Value.fraction
+      values: T,
+      formatValue: s.Value.fraction
       // formatClassName: BoxStylesFormatters.ClassName.fraction,
     }
   },
   maxHeight: {
     cssNames: ["max-height"],
-    values1: { values: ee, formatValue: d.Value.widthHeight },
-    values2: { values: M, formatValue: d.Value.rem },
+    values1: { values: O, formatValue: s.Value.widthHeight },
+    values2: { values: c, formatValue: s.Value.rem },
     values3: {
-      values: _,
-      formatValue: d.Value.fraction
+      values: T,
+      formatValue: s.Value.fraction
       // formatClassName: BoxStylesFormatters.ClassName.fraction,
     }
   },
@@ -302,217 +302,217 @@ const M = [
   },
   top: {
     cssNames: ["top"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   right: {
     cssNames: ["right"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   bottom: {
     cssNames: ["bottom"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   left: {
     cssNames: ["left"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   inset: {
     cssNames: ["inset"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   m: {
     cssNames: ["margin"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: ["auto"] },
     values3: { values: [] }
   },
   mx: {
     cssNames: ["margin-inline"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: ["auto"] },
     values3: { values: [] }
   },
   my: {
     cssNames: ["margin-block"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: ["auto"] },
     values3: { values: [] }
   },
   mt: {
     cssNames: ["margin-top"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: ["auto"] },
     values3: { values: [] }
   },
   mr: {
     cssNames: ["margin-right"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: ["auto"] },
     values3: { values: [] }
   },
   mb: {
     cssNames: ["margin-bottom"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: ["auto"] },
     values3: { values: [] }
   },
   ml: {
     cssNames: ["margin-left"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: ["auto"] },
     values3: { values: [] }
   },
   p: {
     cssNames: ["padding"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   px: {
     cssNames: ["padding-inline"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   py: {
     cssNames: ["padding-block"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   pt: {
     cssNames: ["padding-top"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   pr: {
     cssNames: ["padding-right"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   pb: {
     cssNames: ["padding-bottom"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   pl: {
     cssNames: ["padding-left"],
-    values1: { values: T, formatValue: d.Value.rem },
+    values1: { values: h, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   b: {
     cssNames: ["border-width"],
-    values1: { values: M, formatValue: d.Value.px },
+    values1: { values: c, formatValue: s.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   bx: {
     cssNames: ["border-inline-width"],
-    values1: { values: T, formatValue: d.Value.px },
+    values1: { values: h, formatValue: s.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   by: {
     cssNames: ["border-block-width"],
-    values1: { values: T, formatValue: d.Value.px },
+    values1: { values: h, formatValue: s.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   bt: {
     cssNames: ["border-top-width"],
-    values1: { values: T, formatValue: d.Value.px },
+    values1: { values: h, formatValue: s.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   br: {
     cssNames: ["border-right-width"],
-    values1: { values: T, formatValue: d.Value.px },
+    values1: { values: h, formatValue: s.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   bb: {
     cssNames: ["border-bottom-width"],
-    values1: { values: T, formatValue: d.Value.px },
+    values1: { values: h, formatValue: s.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   bl: {
     cssNames: ["border-left-width"],
-    values1: { values: T, formatValue: d.Value.px },
+    values1: { values: h, formatValue: s.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderStyle: {
     cssNames: ["border-style"],
-    values1: { values: fe },
+    values1: { values: W },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadius: {
     cssNames: ["border-radius"],
-    values1: { values: M, formatValue: d.Value.rem },
+    values1: { values: c, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusTop: {
     cssNames: ["border-top-left-radius", "border-top-right-radius"],
-    values1: { values: M, formatValue: d.Value.rem },
+    values1: { values: c, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusRight: {
     cssNames: ["border-top-right-radius", "border-bottom-right-radius"],
-    values1: { values: M, formatValue: d.Value.rem },
+    values1: { values: c, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusBottom: {
     cssNames: ["border-bottom-left-radius", "border-bottom-right-radius"],
-    values1: { values: M, formatValue: d.Value.rem },
+    values1: { values: c, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusLeft: {
     cssNames: ["border-top-left-radius", "border-bottom-left-radius"],
-    values1: { values: M, formatValue: d.Value.rem },
+    values1: { values: c, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusTopLeft: {
     cssNames: ["border-top-left-radius"],
-    values1: { values: M, formatValue: d.Value.rem },
+    values1: { values: c, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusTopRight: {
     cssNames: ["border-top-right-radius"],
-    values1: { values: M, formatValue: d.Value.rem },
+    values1: { values: c, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusBottomLeft: {
     cssNames: ["border-bottom-left-radius"],
-    values1: { values: M, formatValue: d.Value.rem },
+    values1: { values: c, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusBottomRight: {
     cssNames: ["border-bottom-right-radius"],
-    values1: { values: M, formatValue: d.Value.rem },
+    values1: { values: c, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
@@ -571,19 +571,19 @@ const M = [
   },
   overflow: {
     cssNames: ["overflow"],
-    values1: { values: re },
+    values1: { values: R },
     values2: { values: [] },
     values3: { values: [] }
   },
   overflowX: {
     cssNames: ["overflow-x"],
-    values1: { values: re },
+    values1: { values: R },
     values2: { values: [] },
     values3: { values: [] }
   },
   overflowY: {
     cssNames: ["overflow-y"],
-    values1: { values: re },
+    values1: { values: R },
     values2: { values: [] },
     values3: { values: [] }
   },
@@ -595,7 +595,7 @@ const M = [
   },
   fontSize: {
     cssNames: ["font-size"],
-    values1: { values: M, formatValue: d.Value.px },
+    values1: { values: c, formatValue: s.Value.px },
     values2: { values: ["inherit"] },
     values3: { values: [] }
   },
@@ -613,13 +613,13 @@ const M = [
   },
   letterSpacing: {
     cssNames: ["letter-spacing"],
-    values1: { values: M, formatValue: d.Value.px },
+    values1: { values: c, formatValue: s.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   lineHeight: {
     cssNames: ["line-height"],
-    values1: { values: M, formatValue: d.Value.px },
+    values1: { values: c, formatValue: s.Value.px },
     values2: { values: ["font-size"], formatValue: () => "1" },
     values3: { values: [] }
   },
@@ -708,91 +708,91 @@ const M = [
   },
   gap: {
     cssNames: ["gap"],
-    values1: { values: M, formatValue: d.Value.rem },
+    values1: { values: c, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   rowGap: {
     cssNames: ["row-gap"],
-    values1: { values: M, formatValue: d.Value.rem },
+    values1: { values: c, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   columnGap: {
     cssNames: ["column-gap"],
-    values1: { values: M, formatValue: d.Value.rem },
+    values1: { values: c, formatValue: s.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   order: {
     cssNames: ["order"],
-    values1: { values: M },
+    values1: { values: c },
     values2: { values: [] },
     values3: { values: [] }
   },
   flexGrow: {
     cssNames: ["flex-grow"],
-    values1: { values: M },
+    values1: { values: c },
     values2: { values: [] },
     values3: { values: [] }
   },
   flexShrink: {
     cssNames: ["flex-shrink"],
-    values1: { values: M },
+    values1: { values: c },
     values2: { values: [] },
     values3: { values: [] }
   },
   alignSelf: {
     cssNames: ["align-self"],
-    values1: { values: me },
+    values1: { values: F },
     values2: { values: [] },
     values3: { values: [] }
   },
   justifySelf: {
     cssNames: ["justify-self"],
-    values1: { values: me },
+    values1: { values: F },
     values2: { values: [] },
     values3: { values: [] }
   },
   gridColumns: {
     cssNames: ["grid-template-columns"],
-    values1: { values: M, formatValue: d.Value.gridColumns },
+    values1: { values: c, formatValue: s.Value.gridColumns },
     values2: { values: [] },
     values3: { values: [] }
   },
   colSpan: {
     cssNames: ["grid-column"],
-    values1: { values: M, formatValue: d.Value.gridColumn },
-    values2: { values: ["full-row"], formatValue: d.Value.gridColumn },
+    values1: { values: c, formatValue: s.Value.gridColumn },
+    values2: { values: ["full-row"], formatValue: s.Value.gridColumn },
     values3: { values: [] }
   },
   colStart: {
     cssNames: ["grid-column-start"],
-    values1: { values: M },
+    values1: { values: c },
     values2: { values: [] },
     values3: { values: [] }
   },
   colEnd: {
     cssNames: ["grid-column-end"],
-    values1: { values: M },
+    values1: { values: c },
     values2: { values: [] },
     values3: { values: [] }
   },
   outline: {
     cssNames: ["outline-width"],
-    values1: { values: M, formatValue: d.Value.px },
+    values1: { values: c, formatValue: s.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   outlineStyle: {
     cssNames: ["outline-style"],
-    values1: { values: fe },
+    values1: { values: W },
     values2: { values: [] },
     values3: { values: [] }
   },
   outlineOffset: {
     cssNames: ["outline-offset"],
-    values1: { values: M, formatValue: d.Value.px },
+    values1: { values: c, formatValue: s.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
@@ -806,7 +806,7 @@ const M = [
     cssNames: ["transition-duration"],
     values1: {
       values: [50, 100, 150, 200, 250, 300, 350, 400, 450, 500, 550, 600, 650, 700, 750, 800, 850, 900, 950, 1e3],
-      formatValue: d.Value.ms
+      formatValue: s.Value.ms
     },
     values2: { values: [] },
     values3: { values: [] }
@@ -843,13 +843,13 @@ const M = [
   },
   rotate: {
     cssNames: ["rotate"],
-    values1: { values: [0, 90, 180, 270, -90, -180, -270], formatValue: d.Value.rotate },
+    values1: { values: [0, 90, 180, 270, -90, -180, -270], formatValue: s.Value.rotate },
     values2: { values: [] },
     values3: { values: [] }
   },
   flip: {
     cssNames: ["scale"],
-    values1: { values: ["xAxis", "yAxis"], formatValue: d.Value.flip },
+    values1: { values: ["xAxis", "yAxis"], formatValue: s.Value.flip },
     values2: { values: [] },
     values3: { values: [] }
   },
@@ -865,26 +865,26 @@ const M = [
     values2: { values: [] },
     values3: { values: [] }
   }
-}, be = {
-  shadow: { cssNames: ["box-shadow"], formatValue: d.Value.variables("shadow") },
-  background: { cssNames: ["background"], formatValue: d.Value.variables("background") },
-  backgroundImage: { cssNames: ["background-image"], formatValue: d.Value.variables("backgroundImage") },
-  color: { cssNames: ["color"], formatValue: d.Value.variables("color") },
-  bgColor: { cssNames: ["background-color"], formatValue: d.Value.variables("color") },
-  borderColor: { cssNames: ["border-color"], formatValue: d.Value.variables("color") },
-  outlineColor: { cssNames: ["outline-color"], formatValue: d.Value.variables("color") }
-}, pe = {
+}, q = {
+  shadow: { cssNames: ["box-shadow"], formatValue: s.Value.variables("shadow") },
+  background: { cssNames: ["background"], formatValue: s.Value.variables("background") },
+  backgroundImage: { cssNames: ["background-image"], formatValue: s.Value.variables("backgroundImage") },
+  color: { cssNames: ["color"], formatValue: s.Value.variables("color") },
+  bgColor: { cssNames: ["background-color"], formatValue: s.Value.variables("color") },
+  borderColor: { cssNames: ["border-color"], formatValue: s.Value.variables("color") },
+  outlineColor: { cssNames: ["outline-color"], formatValue: s.Value.variables("color") }
+}, K = {
   fill: {
     cssNames: ["fill"],
-    formatValue: d.Value.svgVariables("color"),
-    formatSelector: d.ClassName.svg
+    formatValue: s.Value.svgVariables("color"),
+    formatSelector: s.ClassName.svg
   },
   stroke: {
     cssNames: ["stroke"],
-    formatValue: d.Value.svgVariables("color"),
-    formatSelector: d.ClassName.svg
+    formatValue: s.Value.svgVariables("color"),
+    formatSelector: s.ClassName.svg
   }
-}, Ee = ["disabledGroup", "hoverGroup", "focusGroup", "activeGroup"], le = [
+}, ue = ["disabledGroup", "hoverGroup", "focusGroup", "activeGroup"], H = [
   "hover",
   "focus",
   "hasFocus",
@@ -900,119 +900,119 @@ const M = [
   "optional",
   "disabled",
   "hasDisabled"
-], te = ["sm", "md", "lg", "xl", "xxl"], $e = {
+], B = ["sm", "md", "lg", "xl", "xxl"], te = {
   sm: 640,
   md: 768,
   lg: 1024,
   xl: 1280,
   xxl: 1536
 };
-function ye() {
-  const u = { ...Ce };
-  Object.keys(be).forEach((t) => {
-    u[t] = be[t], u[t].isThemeStyle = !0;
-  }), Object.keys(pe).forEach((t) => {
-    u[t] = pe[t], u[t].isThemeStyle = !0;
+function Y() {
+  const e = { ...le };
+  Object.keys(q).forEach((u) => {
+    e[u] = q[u], e[u].isThemeStyle = !0;
+  }), Object.keys(K).forEach((u) => {
+    e[u] = K[u], e[u].isThemeStyle = !0;
   });
-  let o = Object.keys(u);
-  return le.forEach((t) => {
-    o.forEach((m) => {
-      u[`${m}${t}`] = { ...u[m], pseudoSuffix: t };
+  let l = Object.keys(e);
+  return H.forEach((u) => {
+    l.forEach((n) => {
+      e[`${n}${u}`] = { ...e[n], pseudoSuffix: u };
     });
-  }), o = Object.keys(u), te.forEach((t) => {
-    o.forEach((m) => {
-      u[`${t}${m}`] = { ...u[m], breakpoint: t };
+  }), l = Object.keys(e), B.forEach((u) => {
+    l.forEach((n) => {
+      e[`${u}${n}`] = { ...e[n], breakpoint: u };
     });
-  }), u;
+  }), e;
 }
-let U = ye();
-function Te() {
-  U = ye();
+let $ = Y();
+function oe() {
+  $ = Y();
 }
-function Se(u, o, t) {
-  const m = Object.entries(U).filter(
-    ([e, O]) => O.pseudoSuffix === u && !O.customPseudoSuffix && !(`${e}${o}` in U)
-  ).map(([e]) => e);
-  return m.forEach((e) => {
-    U[`${e}${o}`] = {
-      ...U[e],
-      customPseudoSuffix: t + o
+function re(e, l, u) {
+  const n = Object.entries($).filter(
+    ([t, d]) => d.pseudoSuffix === e && !d.customPseudoSuffix && !(`${t}${l}` in $)
+  ).map(([t]) => t);
+  return n.forEach((t) => {
+    $[`${t}${l}`] = {
+      ...$[t],
+      customPseudoSuffix: u + l
     };
-  }), m.map((e) => `${e}${o}`);
+  }), n.map((t) => `${t}${l}`);
 }
-class ke {
+class ne {
   constructor() {
     this._index = 0, this._cache = {};
   }
-  getIdentity(o) {
-    return this._cache[o] || (this._cache[o] = this.getByIndex(this._index++)), this._cache[o];
+  getIdentity(l) {
+    return this._cache[l] || (this._cache[l] = this.getByIndex(this._index++)), this._cache[l];
   }
-  getByIndex(o) {
-    const { first: t, next: m } = Pe, e = o - t.length;
-    if (e < 0)
-      return t[o];
-    const O = Math.floor(e / m.length), q = e - O * m.length;
-    return this.getByIndex(O) + m[q];
+  getByIndex(l) {
+    const { first: u, next: n } = ve, t = l - u.length;
+    if (t < 0)
+      return u[l];
+    const d = Math.floor(t / n.length), p = t - d * n.length;
+    return this.getByIndex(d) + n[p];
   }
 }
-const Pe = {
+const ve = {
   first: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
   next: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
 };
-var ue;
-((u) => {
-  u.boxClassName = "_box", u.svgClassName = "_svg", u.cronoStylesElementId = "crono-styles";
-  const o = `:root{--borderColor: black;--outlineColor: black;--lineHeight: 1.2;--fontSize: 14px;--transitionTime: 0.25s;--svgTransitionTime: 0.3s;#crono-box {position: absolute;top: 0;left: 0;height: 0;}}
+var _;
+((e) => {
+  e.boxClassName = "_box", e.svgClassName = "_svg", e.cronoStylesElementId = "crono-styles";
+  const l = `:root{--borderColor: black;--outlineColor: black;--lineHeight: 1.2;--fontSize: 14px;--transitionTime: 0.25s;--svgTransitionTime: 0.3s;#crono-box {position: absolute;top: 0;left: 0;height: 0;}}
 html{font-size: 16px;font-family: Arial, sans-serif;}
 body{margin: 0;line-height: var(--lineHeight);font-size: var(--fontSize);}
 a,ul{all: unset;}
-.${u.boxClassName}{display: block;border: 0 solid var(--borderColor);outline: 0px solid var(--outlineColor);margin: 0;padding: 0;background-color: initial;transition: all var(--transitionTime);box-sizing: border-box;font-family: inherit;font-size: inherit;}
-.${u.svgClassName}{display: block;border: 0 solid var(--borderColor);outline: 0px solid var(--outlineColor);margin: 0;padding: 0;transition: all var(--svgTransitionTime);}.${u.svgClassName} path,.${u.svgClassName} circle,.${u.svgClassName} rect,.${u.svgClassName} line {transition: all var(--svgTransitionTime);}
-`, t = new ke();
-  let m = !0, e = {};
-  H();
-  function O(h, b, x) {
-    if (h in U)
-      return G(h, b, x);
-    if (Ee.includes(h))
-      return h + b;
+.${e.boxClassName}{display: block;border: 0 solid var(--borderColor);outline: 0px solid var(--outlineColor);margin: 0;padding: 0;background-color: initial;transition: all var(--transitionTime);box-sizing: border-box;font-family: inherit;font-size: inherit;}
+.${e.svgClassName}{display: block;border: 0 solid var(--borderColor);outline: 0px solid var(--outlineColor);margin: 0;padding: 0;transition: all var(--svgTransitionTime);}.${e.svgClassName} path,.${e.svgClassName} circle,.${e.svgClassName} rect,.${e.svgClassName} line {transition: all var(--svgTransitionTime);}
+`, u = new ne();
+  let n = !0, t = {};
+  k();
+  function d(a, o, v) {
+    if (a in $)
+      return C(a, o, v);
+    if (ue.includes(a))
+      return a + o;
   }
-  u.get = O;
-  function q() {
-    if (m) {
-      let h = j([o]);
-      le.forEach((x) => {
-        h = j(h, x);
-      }), te.forEach((x) => {
-        h.push(`@media(min-width: ${$e[x]}px){`), h = j(h, void 0, x), le.forEach((z) => {
-          h = j(h, z, x);
-        }), h.push("}");
+  e.get = d;
+  function p() {
+    if (n) {
+      let a = m([l]);
+      H.forEach((v) => {
+        a = m(a, v);
+      }), B.forEach((v) => {
+        a.push(`@media(min-width: ${te[v]}px){`), a = m(a, void 0, v), H.forEach((V) => {
+          a = m(a, V, v);
+        }), a.push("}");
       });
-      const b = p();
-      b.innerHTML = h.join(""), m = !1;
+      const o = r();
+      o.innerHTML = a.join(""), n = !1;
     }
   }
-  u.flush = q;
-  function H() {
-    Te(), e = Object.keys(U).reduce(
-      (b, x) => (b[x] = /* @__PURE__ */ new Set(), b),
+  e.flush = p;
+  function k() {
+    oe(), t = Object.keys($).reduce(
+      (o, v) => (o[v] = /* @__PURE__ */ new Set(), o),
       {}
     );
   }
-  u.clear = H;
-  function L(h, b, x) {
-    Se(h, b, x).forEach((k) => {
-      e[k] = /* @__PURE__ */ new Set();
+  e.clear = k;
+  function E(a, o, v) {
+    re(a, o, v).forEach((b) => {
+      t[b] = /* @__PURE__ */ new Set();
     });
   }
-  u.addCustomPseudoClass = L;
-  function G(h, b, x) {
-    const z = (x ?? "") + h;
-    e[z].has(b) || (m = !0, e[z].add(b));
-    const k = `${z}${b}`;
-    return process.env.NODE_ENV === "test" ? k : t.getIdentity(k);
+  e.addCustomPseudoClass = E;
+  function C(a, o, v) {
+    const V = (v ?? "") + a;
+    t[V].has(o) || (n = !0, t[V].add(o));
+    const b = `${V}${o}`;
+    return process.env.NODE_ENV === "test" ? b : u.getIdentity(b);
   }
-  const y = {
+  const i = {
     hover: "hover",
     focus: "focus-within",
     hasFocus: "has(:focus-within)",
@@ -1029,38 +1029,38 @@ a,ul{all: unset;}
     disabled: "disabled",
     hasDisabled: "has(:disabled)"
   };
-  function j(h, b, x) {
-    return Object.entries(e).filter(
-      ([k, I]) => {
-        var D, A;
-        return ((D = U[k]) == null ? void 0 : D.pseudoSuffix) === b && ((A = U[k]) == null ? void 0 : A.breakpoint) === x && I.size > 0;
+  function m(a, o, v) {
+    return Object.entries(t).filter(
+      ([b, y]) => {
+        var N, x;
+        return ((N = $[b]) == null ? void 0 : N.pseudoSuffix) === o && ((x = $[b]) == null ? void 0 : x.breakpoint) === v && y.size > 0;
       }
-    ).reduce((k, [I, D]) => (D.forEach((A) => {
-      var oe;
-      const W = U[I], Y = C(W, A), J = `.${G(I, A)}`, X = z(
-        J,
-        W,
-        Y,
-        b ? y[b] : void 0
-      ), P = ((oe = Y.formatValue) == null ? void 0 : oe.call(Y, I, A)) ?? A, ae = U[I].cssNames.map((ne) => `${ne}:${P};`).join("");
-      k.push(`${X.join(",")}{${ae}}`);
-    }), k), h);
-    function z(k, I, D, A) {
-      let W = k;
-      return A && (W = I.customPseudoSuffix ? `.${I.customPseudoSuffix}:${A} ${k}` : `${k}:${A}`), D.formatSelector ? D.formatSelector(W) : [W];
+    ).reduce((b, [y, N]) => (N.forEach((x) => {
+      var L;
+      const S = $[y], z = f(S, x), P = `.${C(y, x)}`, G = V(
+        P,
+        S,
+        z,
+        o ? i[o] : void 0
+      ), g = ((L = z.formatValue) == null ? void 0 : L.call(z, y, x)) ?? x, Q = $[y].cssNames.map((Z) => `${Z}:${g};`).join("");
+      b.push(`${G.join(",")}{${Q}}`);
+    }), b), a);
+    function V(b, y, N, x) {
+      let S = b;
+      return x && (S = y.customPseudoSuffix ? `.${y.customPseudoSuffix}:${x} ${b}` : `${b}:${x}`), N.formatSelector ? N.formatSelector(S) : [S];
     }
   }
-  function C(h, b) {
-    return h.isThemeStyle ? h : h.values1.values.includes(b) ? h.values1 : h.values2.values.includes(b) ? h.values2 : h.values3;
+  function f(a, o) {
+    return a.isThemeStyle ? a : a.values1.values.includes(o) ? a.values1 : a.values2.values.includes(o) ? a.values2 : a.values3;
   }
-  function p() {
-    const b = typeof window < "u" && typeof window.document < "u" ? window.document : global.document;
-    let x = b.getElementById(u.cronoStylesElementId);
-    return x || (x = b.createElement("style"), x.setAttribute("id", u.cronoStylesElementId), x.setAttribute("type", "text/css"), b.head.insertBefore(x, b.head.firstChild)), x;
+  function r() {
+    const o = typeof window < "u" && typeof window.document < "u" ? window.document : global.document;
+    let v = o.getElementById(e.cronoStylesElementId);
+    return v || (v = o.createElement("style"), v.setAttribute("id", e.cronoStylesElementId), v.setAttribute("type", "text/css"), o.head.insertBefore(v, o.head.firstChild)), v;
   }
-  u.getElement = p;
-})(ue || (ue = {}));
-const se = ue, ze = {
+  e.getElement = r;
+})(_ || (_ = {}));
+const I = _, ie = {
   button: {
     styles: {
       display: "inline-block",
@@ -1102,29 +1102,29 @@ const se = ue, ze = {
     }
   }
 };
-var ce;
-((u) => {
-  u.Styles = {};
-  function o(y) {
-    u.Styles = e(ze), m(y);
+var D;
+((e) => {
+  e.Styles = {};
+  function l(i) {
+    e.Styles = t(ie), n(i);
   }
-  u.setup = o;
-  function t(y, j) {
-    const { colors: C = {}, shadows: p = {}, backgrounds: h = {}, backgroundImages: b = {} } = y;
-    C.none = "none", p.none = "none", h.none = "none", b.none = "none";
-    const x = Object.entries(C).map(([P, K]) => `--color${P}: ${K};`).join(`
-  `), z = Object.entries(p).map(([P, K]) => `--shadow${P}: ${K};`).join(`
-  `), k = Object.entries(h).map(([P, K]) => `--background${P}: ${K};`).join(`
-  `), I = Object.entries(b).map(([P, K]) => `--backgroundImage${P}: ${K};`).join(`
-  `), D = [":root {"];
-    x && D.push(`  ${x}`), z && D.push(`  ${z}`), k && D.push(`  ${k}`), I && D.push(`  ${I}`), D.push("}");
-    const A = Object.keys(C).map((P) => `'${P}'`).join(" | "), W = Object.keys(h).map((P) => `'${P}'`).join(" | "), Y = Object.keys(b).map((P) => `'${P}'`).join(" | "), J = Object.keys(p).map((P) => `'${P}'`).join(" | "), X = `import '@cronocode/react-box';
+  e.setup = l;
+  function u(i, m) {
+    const { colors: f = {}, shadows: r = {}, backgrounds: a = {}, backgroundImages: o = {} } = i;
+    f.none = "none", r.none = "none", a.none = "none", o.none = "none";
+    const v = Object.entries(f).map(([g, j]) => `--color${g}: ${j};`).join(`
+  `), V = Object.entries(r).map(([g, j]) => `--shadow${g}: ${j};`).join(`
+  `), b = Object.entries(a).map(([g, j]) => `--background${g}: ${j};`).join(`
+  `), y = Object.entries(o).map(([g, j]) => `--backgroundImage${g}: ${j};`).join(`
+  `), N = [":root {"];
+    v && N.push(`  ${v}`), V && N.push(`  ${V}`), b && N.push(`  ${b}`), y && N.push(`  ${y}`), N.push("}");
+    const x = Object.keys(f).map((g) => `'${g}'`).join(" | "), S = Object.keys(a).map((g) => `'${g}'`).join(" | "), z = Object.keys(o).map((g) => `'${g}'`).join(" | "), P = Object.keys(r).map((g) => `'${g}'`).join(" | "), G = `import '@cronocode/react-box';
   
-  declare module '${(j == null ? void 0 : j.namespacePath) ?? "@cronocode/react-box/core/types"}' {
-    type ColorType = ${A};
-    type BackgroundType = ${W};
-    type BackgroundImageType = ${Y};
-    type ShadowType = ${J};
+  declare module '${(m == null ? void 0 : m.namespacePath) ?? "@cronocode/react-box/core/types"}' {
+    type ColorType = ${x};
+    type BackgroundType = ${S};
+    type BackgroundImageType = ${z};
+    type ShadowType = ${P};
   
     namespace Augmented {
       interface BoxProps {
@@ -1145,970 +1145,140 @@ var ce;
   }
   `;
     return {
-      variables: D.join(`
+      variables: N.join(`
 `),
-      boxDts: X
+      boxDts: G
     };
   }
-  u.setupAugmentedProps = t;
-  function m(y) {
-    const j = e(y);
-    if (j.components)
-      return Object.entries(j.components).forEach(([C, p]) => {
-        var b;
-        const h = (b = u.Styles.components) == null ? void 0 : b[C];
-        h ? u.Styles.components[C].styles = { ...h.styles, ...p.styles } : u.Styles.components[C] = p;
-      }), j;
+  e.setupAugmentedProps = u;
+  function n(i) {
+    const m = t(i);
+    if (m.components)
+      return Object.entries(m.components).forEach(([f, r]) => {
+        var o;
+        const a = (o = e.Styles.components) == null ? void 0 : o[f];
+        a ? (e.Styles.components[f].styles = { ...a.styles, ...r.styles }, e.Styles.components[f].themes = r.themes) : e.Styles.components[f] = r;
+      }), m;
   }
-  function e(y) {
-    return O(y), q(y), L(y), y;
+  function t(i) {
+    return d(i), p(i), E(i), i;
   }
-  function O(y) {
-    const { components: j, ...C } = y, p = Object.entries(C);
-    p.length && !y.components && (y.components = {});
-    for (const h of p) {
-      const [b, x] = h;
-      y.components[b] = x, delete y[b];
+  function d(i) {
+    const { components: m, ...f } = i, r = Object.entries(f);
+    r.length && !i.components && (i.components = {});
+    for (const a of r) {
+      const [o, v] = a;
+      i.components[o] = v, delete i[o];
     }
   }
-  function q(y) {
-    if (!y.components)
+  function p(i) {
+    if (!i.components)
       return;
-    const j = Object.keys(y.components);
-    for (const C of j) {
-      const p = y.components[C], h = H(C, p);
-      delete p.children;
-      for (const b of h) {
-        const [x, z] = b;
-        y.components[x] = z;
+    const m = Object.keys(i.components);
+    for (const f of m) {
+      const r = i.components[f], a = k(f, r);
+      delete r.children;
+      for (const o of a) {
+        const [v, V] = o;
+        i.components[v] = V;
       }
     }
   }
-  function H(y, j) {
-    if (!j.children)
+  function k(i, m) {
+    if (!m.children)
       return [];
-    const C = Object.keys(j.children), p = [];
-    for (const h of C) {
-      const b = `${y}.${h}`, x = j.children[h], z = H(b, x);
-      p.push(...z), delete x.children, p.push([b, x]);
+    const f = Object.keys(m.children), r = [];
+    for (const a of f) {
+      const o = `${i}.${a}`, v = m.children[a], V = k(o, v);
+      r.push(...V), delete v.children, r.push([o, v]);
     }
-    return p;
+    return r;
   }
-  function L(y) {
-    if (!y.components)
+  function E(i) {
+    if (!i.components)
       return;
-    const j = Object.values(y.components);
-    for (const C of j)
-      G(C.styles), te.forEach((p) => {
-        if (p in C.styles) {
-          const h = C.styles[p];
-          G(h);
+    const m = Object.values(i.components);
+    for (const f of m)
+      C(f.styles), B.forEach((r) => {
+        if (r in f.styles) {
+          const a = f.styles[r];
+          C(a);
         }
-      }), C.themes && Object.values(C.themes).forEach((p) => {
-        G(p), te.forEach((h) => {
-          if (h in p) {
-            const b = p[h];
-            G(b);
+      }), f.themes && Object.values(f.themes).forEach((r) => {
+        C(r), B.forEach((a) => {
+          if (a in r) {
+            const o = r[a];
+            C(o);
           }
         });
       });
   }
-  function G(y) {
-    le.forEach((j) => {
-      if (j in y) {
-        const C = y[j];
-        Object.entries(C).map(([p, h]) => {
-          y[`${p}${j}`] = h;
-        }), delete y[j];
+  function C(i) {
+    H.forEach((m) => {
+      if (m in i) {
+        const f = i[m];
+        Object.entries(f).map(([r, a]) => {
+          i[`${r}${m}`] = a;
+        }), delete i[m];
       }
     });
   }
-})(ce || (ce = {}));
-const qe = ce;
-function De(u) {
-  const { clean: o, theme: t, component: m } = u;
-  return xe(() => {
-    var O, q;
-    if (o)
+})(D || (D = {}));
+const ce = D;
+function me(e) {
+  const { clean: l, theme: u, component: n } = e;
+  return U(() => {
+    var d, p;
+    if (l)
       return;
-    let e = (O = qe.Styles.components) == null ? void 0 : O[m];
-    if (e)
-      return t ? { ...e.styles, ...(q = e.themes) == null ? void 0 : q[t] } : e.styles;
-  }, [m, o, t]);
+    let t = (d = ce.Styles.components) == null ? void 0 : d[n];
+    if (t)
+      return u ? { ...t.styles, ...(p = t.themes) == null ? void 0 : p[u] } : t.styles;
+  }, [n, l, u]);
 }
-const Ae = typeof window < "u" && typeof window.document < "u", Ie = Ae ? je : Me;
-function Ge(u, o) {
-  const t = De(u);
-  return Ie(se.flush, [u]), xe(() => {
-    const m = [o ? se.svgClassName : se.boxClassName], e = t ? { ...t, ...u } : { ...u };
-    return ge(e), Object.entries(e).forEach(([O, q]) => {
-      m.push(se.get(O, q));
-    }), te.forEach((O) => {
-      if (O in e) {
-        const q = e[O];
-        ge(q), Object.entries(q).forEach(([H, L]) => {
-          m.push(se.get(H, L, O));
-        }), delete e[O];
+const de = typeof window < "u" && typeof window.document < "u", fe = de ? ee : se;
+function pe(e, l) {
+  const u = me(e);
+  return fe(I.flush, [e]), U(() => {
+    const n = [l ? I.svgClassName : I.boxClassName], t = u ? { ...u, ...e } : { ...e };
+    return M(t), Object.entries(t).forEach(([d, p]) => {
+      n.push(I.get(d, p));
+    }), B.forEach((d) => {
+      if (d in t) {
+        const p = t[d];
+        M(p), Object.entries(p).forEach(([k, E]) => {
+          n.push(I.get(k, E, d));
+        }), delete t[d];
       }
-    }), m;
-  }, [u, t]);
+    }), n;
+  }, [e, u]);
 }
-function ge(u) {
-  R(u, "hover", "hover"), R(u, "focus", "focus"), R(u, "hasFocus", "hasFocus"), R(u, "active", "active"), R(u, "disabled", "disabled"), R(u, "hasDisabled", "hasDisabled"), R(u, "checked", "checked"), R(u, "hasChecked", "hasChecked"), R(u, "valid", "valid"), R(u, "hasValid", "hasValid"), R(u, "invalid", "invalid"), R(u, "hasInvalid", "hasInvalid"), ie(u, "hoverGroup", "hover"), ie(u, "focusGroup", "focus"), ie(u, "activeGroup", "active"), ie(u, "disabledGroup", "disabled");
+function M(e) {
+  w(e, "hover", "hover"), w(e, "focus", "focus"), w(e, "hasFocus", "hasFocus"), w(e, "active", "active"), w(e, "disabled", "disabled"), w(e, "hasDisabled", "hasDisabled"), w(e, "checked", "checked"), w(e, "hasChecked", "hasChecked"), w(e, "valid", "valid"), w(e, "hasValid", "hasValid"), w(e, "invalid", "invalid"), w(e, "hasInvalid", "hasInvalid"), A(e, "hoverGroup", "hover"), A(e, "focusGroup", "focus"), A(e, "activeGroup", "active"), A(e, "disabledGroup", "disabled");
 }
-function R(u, o, t) {
-  o in u && Ve(u, o, t, u[o]);
+function w(e, l, u) {
+  l in e && J(e, l, u, e[l]);
 }
-function ie(u, o, t) {
-  o in u && we.isObject(u[o]) && Object.entries(u[o]).forEach(([m, e]) => {
-    se.addCustomPseudoClass(t, m, o), Ve(u, o, t + m, e);
+function A(e, l, u) {
+  l in e && X.isObject(e[l]) && Object.entries(e[l]).forEach(([n, t]) => {
+    I.addCustomPseudoClass(u, n, l), J(e, l, u + n, t);
   });
 }
-function Ve(u, o, t, m) {
-  Array.isArray(m) ? (Object.entries(m[1]).forEach(([e, O]) => {
-    u[`${e}${t}`] = O;
-  }), u[o] = m[0]) : we.isObject(m) && (Object.entries(m).forEach(([e, O]) => {
-    u[`${e}${t}`] = O;
-  }), delete u[o]);
+function J(e, l, u, n) {
+  Array.isArray(n) ? (Object.entries(n[1]).forEach(([t, d]) => {
+    e[`${t}${u}`] = d;
+  }), e[l] = n[0]) : X.isObject(n) && (Object.entries(n).forEach(([t, d]) => {
+    e[`${t}${u}`] = d;
+  }), delete e[l]);
 }
-function Be(...u) {
-  return u.reduce((o, t) => t ? typeof t == "string" ? (o.push(t), o) : Array.isArray(t) ? (o.push(...Be(...t)), o) : (Object.entries(t).forEach(([m, e]) => {
-    e && o.push(m);
-  }), o) : o, []);
+function he(...e) {
+  return e.reduce((l, u) => u ? typeof u == "string" ? (l.push(u), l) : Array.isArray(u) ? (l.push(...he(...u)), l) : (Object.entries(u).forEach(([n, t]) => {
+    t && l.push(n);
+  }), l) : l, []);
 }
-/*!
- * chai
- * http://chaijs.com
- * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
- * MIT Licensed
- */
-var Fe = function(u, o) {
-  var t = u.Assertion, m = u.AssertionError, e = o.flag;
-  [
-    "to",
-    "be",
-    "been",
-    "is",
-    "and",
-    "has",
-    "have",
-    "with",
-    "that",
-    "which",
-    "at",
-    "of",
-    "same",
-    "but",
-    "does",
-    "still",
-    "also"
-  ].forEach(function(s) {
-    t.addProperty(s);
-  }), t.addProperty("not", function() {
-    e(this, "negate", !0);
-  }), t.addProperty("deep", function() {
-    e(this, "deep", !0);
-  }), t.addProperty("nested", function() {
-    e(this, "nested", !0);
-  }), t.addProperty("own", function() {
-    e(this, "own", !0);
-  }), t.addProperty("ordered", function() {
-    e(this, "ordered", !0);
-  }), t.addProperty("any", function() {
-    e(this, "any", !0), e(this, "all", !1);
-  }), t.addProperty("all", function() {
-    e(this, "all", !0), e(this, "any", !1);
-  });
-  function O(s, a) {
-    a && e(this, "message", a), s = s.toLowerCase();
-    var l = e(this, "object"), n = ~["a", "e", "i", "o", "u"].indexOf(s.charAt(0)) ? "an " : "a ";
-    this.assert(
-      s === o.type(l).toLowerCase(),
-      "expected #{this} to be " + n + s,
-      "expected #{this} not to be " + n + s
-    );
-  }
-  t.addChainableMethod("an", O), t.addChainableMethod("a", O);
-  function q(s, a) {
-    return o.isNaN(s) && o.isNaN(a) || s === a;
-  }
-  function H() {
-    e(this, "contains", !0);
-  }
-  function L(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "object"), n = o.type(l).toLowerCase(), c = e(this, "message"), v = e(this, "negate"), r = e(this, "ssfi"), i = e(this, "deep"), f = i ? "deep " : "", g = i ? e(this, "eql") : q;
-    c = c ? c + ": " : "";
-    var w = !1;
-    switch (n) {
-      case "string":
-        w = l.indexOf(s) !== -1;
-        break;
-      case "weakset":
-        if (i)
-          throw new m(
-            c + "unable to use .deep.include with WeakSet",
-            void 0,
-            r
-          );
-        w = l.has(s);
-        break;
-      case "map":
-        l.forEach(function(E) {
-          w = w || g(E, s);
-        });
-        break;
-      case "set":
-        i ? l.forEach(function(E) {
-          w = w || g(E, s);
-        }) : w = l.has(s);
-        break;
-      case "array":
-        i ? w = l.some(function(E) {
-          return g(E, s);
-        }) : w = l.indexOf(s) !== -1;
-        break;
-      default:
-        if (s !== Object(s))
-          throw new m(
-            c + "the given combination of arguments (" + n + " and " + o.type(s).toLowerCase() + ") is invalid for this assertion. You can use an array, a map, an object, a set, a string, or a weakset instead of a " + o.type(s).toLowerCase(),
-            void 0,
-            r
-          );
-        var $ = Object.keys(s), N = null, V = 0;
-        if ($.forEach(function(E) {
-          var S = new t(l);
-          if (o.transferFlags(this, S, !0), e(S, "lockSsfi", !0), !v || $.length === 1) {
-            S.property(E, s[E]);
-            return;
-          }
-          try {
-            S.property(E, s[E]);
-          } catch (B) {
-            if (!o.checkError.compatibleConstructor(B, m))
-              throw B;
-            N === null && (N = B), V++;
-          }
-        }, this), v && $.length > 1 && V === $.length)
-          throw N;
-        return;
-    }
-    this.assert(
-      w,
-      "expected #{this} to " + f + "include " + o.inspect(s),
-      "expected #{this} to not " + f + "include " + o.inspect(s)
-    );
-  }
-  t.addChainableMethod("include", L, H), t.addChainableMethod("contain", L, H), t.addChainableMethod("contains", L, H), t.addChainableMethod("includes", L, H), t.addProperty("ok", function() {
-    this.assert(
-      e(this, "object"),
-      "expected #{this} to be truthy",
-      "expected #{this} to be falsy"
-    );
-  }), t.addProperty("true", function() {
-    this.assert(
-      e(this, "object") === !0,
-      "expected #{this} to be true",
-      "expected #{this} to be false",
-      !e(this, "negate")
-    );
-  }), t.addProperty("false", function() {
-    this.assert(
-      e(this, "object") === !1,
-      "expected #{this} to be false",
-      "expected #{this} to be true",
-      !!e(this, "negate")
-    );
-  }), t.addProperty("null", function() {
-    this.assert(
-      e(this, "object") === null,
-      "expected #{this} to be null",
-      "expected #{this} not to be null"
-    );
-  }), t.addProperty("undefined", function() {
-    this.assert(
-      e(this, "object") === void 0,
-      "expected #{this} to be undefined",
-      "expected #{this} not to be undefined"
-    );
-  }), t.addProperty("NaN", function() {
-    this.assert(
-      o.isNaN(e(this, "object")),
-      "expected #{this} to be NaN",
-      "expected #{this} not to be NaN"
-    );
-  });
-  function G() {
-    var s = e(this, "object");
-    this.assert(
-      s != null,
-      "expected #{this} to exist",
-      "expected #{this} to not exist"
-    );
-  }
-  t.addProperty("exist", G), t.addProperty("exists", G), t.addProperty("empty", function() {
-    var s = e(this, "object"), a = e(this, "ssfi"), l = e(this, "message"), n;
-    switch (l = l ? l + ": " : "", o.type(s).toLowerCase()) {
-      case "array":
-      case "string":
-        n = s.length;
-        break;
-      case "map":
-      case "set":
-        n = s.size;
-        break;
-      case "weakmap":
-      case "weakset":
-        throw new m(
-          l + ".empty was passed a weak collection",
-          void 0,
-          a
-        );
-      case "function":
-        var c = l + ".empty was passed a function " + o.getName(s);
-        throw new m(c.trim(), void 0, a);
-      default:
-        if (s !== Object(s))
-          throw new m(
-            l + ".empty was passed non-string primitive " + o.inspect(s),
-            void 0,
-            a
-          );
-        n = Object.keys(s).length;
-    }
-    this.assert(
-      n === 0,
-      "expected #{this} to be empty",
-      "expected #{this} not to be empty"
-    );
-  });
-  function y() {
-    var s = e(this, "object"), a = o.type(s);
-    this.assert(
-      a === "Arguments",
-      "expected #{this} to be arguments but got " + a,
-      "expected #{this} to not be arguments"
-    );
-  }
-  t.addProperty("arguments", y), t.addProperty("Arguments", y);
-  function j(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "object");
-    if (e(this, "deep")) {
-      var n = e(this, "lockSsfi");
-      e(this, "lockSsfi", !0), this.eql(s), e(this, "lockSsfi", n);
-    } else
-      this.assert(
-        s === l,
-        "expected #{this} to equal #{exp}",
-        "expected #{this} to not equal #{exp}",
-        s,
-        this._obj,
-        !0
-      );
-  }
-  t.addMethod("equal", j), t.addMethod("equals", j), t.addMethod("eq", j);
-  function C(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "eql");
-    this.assert(
-      l(s, e(this, "object")),
-      "expected #{this} to deeply equal #{exp}",
-      "expected #{this} to not deeply equal #{exp}",
-      s,
-      this._obj,
-      !0
-    );
-  }
-  t.addMethod("eql", C), t.addMethod("eqls", C);
-  function p(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "object"), n = e(this, "doLength"), c = e(this, "message"), v = c ? c + ": " : "", r = e(this, "ssfi"), i = o.type(l).toLowerCase(), f = o.type(s).toLowerCase(), g, w = !0;
-    if (n && i !== "map" && i !== "set" && new t(l, c, r, !0).to.have.property("length"), !n && i === "date" && f !== "date")
-      g = v + "the argument to above must be a date";
-    else if (f !== "number" && (n || i === "number"))
-      g = v + "the argument to above must be a number";
-    else if (!n && i !== "date" && i !== "number") {
-      var $ = i === "string" ? "'" + l + "'" : l;
-      g = v + "expected " + $ + " to be a number or a date";
-    } else
-      w = !1;
-    if (w)
-      throw new m(g, void 0, r);
-    if (n) {
-      var N = "length", V;
-      i === "map" || i === "set" ? (N = "size", V = l.size) : V = l.length, this.assert(
-        V > s,
-        "expected #{this} to have a " + N + " above #{exp} but got #{act}",
-        "expected #{this} to not have a " + N + " above #{exp}",
-        s,
-        V
-      );
-    } else
-      this.assert(
-        l > s,
-        "expected #{this} to be above #{exp}",
-        "expected #{this} to be at most #{exp}",
-        s
-      );
-  }
-  t.addMethod("above", p), t.addMethod("gt", p), t.addMethod("greaterThan", p);
-  function h(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "object"), n = e(this, "doLength"), c = e(this, "message"), v = c ? c + ": " : "", r = e(this, "ssfi"), i = o.type(l).toLowerCase(), f = o.type(s).toLowerCase(), g, w = !0;
-    if (n && i !== "map" && i !== "set" && new t(l, c, r, !0).to.have.property("length"), !n && i === "date" && f !== "date")
-      g = v + "the argument to least must be a date";
-    else if (f !== "number" && (n || i === "number"))
-      g = v + "the argument to least must be a number";
-    else if (!n && i !== "date" && i !== "number") {
-      var $ = i === "string" ? "'" + l + "'" : l;
-      g = v + "expected " + $ + " to be a number or a date";
-    } else
-      w = !1;
-    if (w)
-      throw new m(g, void 0, r);
-    if (n) {
-      var N = "length", V;
-      i === "map" || i === "set" ? (N = "size", V = l.size) : V = l.length, this.assert(
-        V >= s,
-        "expected #{this} to have a " + N + " at least #{exp} but got #{act}",
-        "expected #{this} to have a " + N + " below #{exp}",
-        s,
-        V
-      );
-    } else
-      this.assert(
-        l >= s,
-        "expected #{this} to be at least #{exp}",
-        "expected #{this} to be below #{exp}",
-        s
-      );
-  }
-  t.addMethod("least", h), t.addMethod("gte", h), t.addMethod("greaterThanOrEqual", h);
-  function b(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "object"), n = e(this, "doLength"), c = e(this, "message"), v = c ? c + ": " : "", r = e(this, "ssfi"), i = o.type(l).toLowerCase(), f = o.type(s).toLowerCase(), g, w = !0;
-    if (n && i !== "map" && i !== "set" && new t(l, c, r, !0).to.have.property("length"), !n && i === "date" && f !== "date")
-      g = v + "the argument to below must be a date";
-    else if (f !== "number" && (n || i === "number"))
-      g = v + "the argument to below must be a number";
-    else if (!n && i !== "date" && i !== "number") {
-      var $ = i === "string" ? "'" + l + "'" : l;
-      g = v + "expected " + $ + " to be a number or a date";
-    } else
-      w = !1;
-    if (w)
-      throw new m(g, void 0, r);
-    if (n) {
-      var N = "length", V;
-      i === "map" || i === "set" ? (N = "size", V = l.size) : V = l.length, this.assert(
-        V < s,
-        "expected #{this} to have a " + N + " below #{exp} but got #{act}",
-        "expected #{this} to not have a " + N + " below #{exp}",
-        s,
-        V
-      );
-    } else
-      this.assert(
-        l < s,
-        "expected #{this} to be below #{exp}",
-        "expected #{this} to be at least #{exp}",
-        s
-      );
-  }
-  t.addMethod("below", b), t.addMethod("lt", b), t.addMethod("lessThan", b);
-  function x(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "object"), n = e(this, "doLength"), c = e(this, "message"), v = c ? c + ": " : "", r = e(this, "ssfi"), i = o.type(l).toLowerCase(), f = o.type(s).toLowerCase(), g, w = !0;
-    if (n && i !== "map" && i !== "set" && new t(l, c, r, !0).to.have.property("length"), !n && i === "date" && f !== "date")
-      g = v + "the argument to most must be a date";
-    else if (f !== "number" && (n || i === "number"))
-      g = v + "the argument to most must be a number";
-    else if (!n && i !== "date" && i !== "number") {
-      var $ = i === "string" ? "'" + l + "'" : l;
-      g = v + "expected " + $ + " to be a number or a date";
-    } else
-      w = !1;
-    if (w)
-      throw new m(g, void 0, r);
-    if (n) {
-      var N = "length", V;
-      i === "map" || i === "set" ? (N = "size", V = l.size) : V = l.length, this.assert(
-        V <= s,
-        "expected #{this} to have a " + N + " at most #{exp} but got #{act}",
-        "expected #{this} to have a " + N + " above #{exp}",
-        s,
-        V
-      );
-    } else
-      this.assert(
-        l <= s,
-        "expected #{this} to be at most #{exp}",
-        "expected #{this} to be above #{exp}",
-        s
-      );
-  }
-  t.addMethod("most", x), t.addMethod("lte", x), t.addMethod("lessThanOrEqual", x), t.addMethod("within", function(s, a, l) {
-    l && e(this, "message", l);
-    var n = e(this, "object"), c = e(this, "doLength"), v = e(this, "message"), r = v ? v + ": " : "", i = e(this, "ssfi"), f = o.type(n).toLowerCase(), g = o.type(s).toLowerCase(), w = o.type(a).toLowerCase(), $, N = !0, V = g === "date" && w === "date" ? s.toISOString() + ".." + a.toISOString() : s + ".." + a;
-    if (c && f !== "map" && f !== "set" && new t(n, v, i, !0).to.have.property("length"), !c && f === "date" && (g !== "date" || w !== "date"))
-      $ = r + "the arguments to within must be dates";
-    else if ((g !== "number" || w !== "number") && (c || f === "number"))
-      $ = r + "the arguments to within must be numbers";
-    else if (!c && f !== "date" && f !== "number") {
-      var E = f === "string" ? "'" + n + "'" : n;
-      $ = r + "expected " + E + " to be a number or a date";
-    } else
-      N = !1;
-    if (N)
-      throw new m($, void 0, i);
-    if (c) {
-      var S = "length", B;
-      f === "map" || f === "set" ? (S = "size", B = n.size) : B = n.length, this.assert(
-        B >= s && B <= a,
-        "expected #{this} to have a " + S + " within " + V,
-        "expected #{this} to not have a " + S + " within " + V
-      );
-    } else
-      this.assert(
-        n >= s && n <= a,
-        "expected #{this} to be within " + V,
-        "expected #{this} to not be within " + V
-      );
-  });
-  function z(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "object"), n = e(this, "ssfi"), c = e(this, "message");
-    try {
-      var v = l instanceof s;
-    } catch (i) {
-      throw i instanceof TypeError ? (c = c ? c + ": " : "", new m(
-        c + "The instanceof assertion needs a constructor but " + o.type(s) + " was given.",
-        void 0,
-        n
-      )) : i;
-    }
-    var r = o.getName(s);
-    r === null && (r = "an unnamed constructor"), this.assert(
-      v,
-      "expected #{this} to be an instance of " + r,
-      "expected #{this} to not be an instance of " + r
-    );
-  }
-  t.addMethod("instanceof", z), t.addMethod("instanceOf", z);
-  function k(s, a, l) {
-    l && e(this, "message", l);
-    var n = e(this, "nested"), c = e(this, "own"), v = e(this, "message"), r = e(this, "object"), i = e(this, "ssfi"), f = typeof s;
-    if (v = v ? v + ": " : "", n) {
-      if (f !== "string")
-        throw new m(
-          v + "the argument to property must be a string when using nested syntax",
-          void 0,
-          i
-        );
-    } else if (f !== "string" && f !== "number" && f !== "symbol")
-      throw new m(
-        v + "the argument to property must be a string, number, or symbol",
-        void 0,
-        i
-      );
-    if (n && c)
-      throw new m(
-        v + 'The "nested" and "own" flags cannot be combined.',
-        void 0,
-        i
-      );
-    if (r == null)
-      throw new m(
-        v + "Target cannot be null or undefined.",
-        void 0,
-        i
-      );
-    var g = e(this, "deep"), w = e(this, "negate"), $ = n ? o.getPathInfo(r, s) : null, N = n ? $.value : r[s], V = g ? e(this, "eql") : (B, Q) => B === Q, E = "";
-    g && (E += "deep "), c && (E += "own "), n && (E += "nested "), E += "property ";
-    var S;
-    c ? S = Object.prototype.hasOwnProperty.call(r, s) : n ? S = $.exists : S = o.hasProperty(r, s), (!w || arguments.length === 1) && this.assert(
-      S,
-      "expected #{this} to have " + E + o.inspect(s),
-      "expected #{this} to not have " + E + o.inspect(s)
-    ), arguments.length > 1 && this.assert(
-      S && V(a, N),
-      "expected #{this} to have " + E + o.inspect(s) + " of #{exp}, but got #{act}",
-      "expected #{this} to not have " + E + o.inspect(s) + " of #{act}",
-      a,
-      N
-    ), e(this, "object", N);
-  }
-  t.addMethod("property", k);
-  function I(s, a, l) {
-    e(this, "own", !0), k.apply(this, arguments);
-  }
-  t.addMethod("ownProperty", I), t.addMethod("haveOwnProperty", I);
-  function D(s, a, l) {
-    typeof a == "string" && (l = a, a = null), l && e(this, "message", l);
-    var n = e(this, "object"), c = Object.getOwnPropertyDescriptor(Object(n), s), v = e(this, "eql");
-    c && a ? this.assert(
-      v(a, c),
-      "expected the own property descriptor for " + o.inspect(s) + " on #{this} to match " + o.inspect(a) + ", got " + o.inspect(c),
-      "expected the own property descriptor for " + o.inspect(s) + " on #{this} to not match " + o.inspect(a),
-      a,
-      c,
-      !0
-    ) : this.assert(
-      c,
-      "expected #{this} to have an own property descriptor for " + o.inspect(s),
-      "expected #{this} to not have an own property descriptor for " + o.inspect(s)
-    ), e(this, "object", c);
-  }
-  t.addMethod("ownPropertyDescriptor", D), t.addMethod("haveOwnPropertyDescriptor", D);
-  function A() {
-    e(this, "doLength", !0);
-  }
-  function W(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "object"), n = o.type(l).toLowerCase(), c = e(this, "message"), v = e(this, "ssfi"), r = "length", i;
-    switch (n) {
-      case "map":
-      case "set":
-        r = "size", i = l.size;
-        break;
-      default:
-        new t(l, c, v, !0).to.have.property("length"), i = l.length;
-    }
-    this.assert(
-      i == s,
-      "expected #{this} to have a " + r + " of #{exp} but got #{act}",
-      "expected #{this} to not have a " + r + " of #{act}",
-      s,
-      i
-    );
-  }
-  t.addChainableMethod("length", W, A), t.addChainableMethod("lengthOf", W, A);
-  function Y(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "object");
-    this.assert(
-      s.exec(l),
-      "expected #{this} to match " + s,
-      "expected #{this} not to match " + s
-    );
-  }
-  t.addMethod("match", Y), t.addMethod("matches", Y), t.addMethod("string", function(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "object"), n = e(this, "message"), c = e(this, "ssfi");
-    new t(l, n, c, !0).is.a("string"), this.assert(
-      ~l.indexOf(s),
-      "expected #{this} to contain " + o.inspect(s),
-      "expected #{this} to not contain " + o.inspect(s)
-    );
-  });
-  function J(s) {
-    var a = e(this, "object"), l = o.type(a), n = o.type(s), c = e(this, "ssfi"), v = e(this, "deep"), r, i = "", f, g = !0, w = e(this, "message");
-    w = w ? w + ": " : "";
-    var $ = w + "when testing keys against an object or an array you must give a single Array|Object|String argument or multiple String arguments";
-    if (l === "Map" || l === "Set")
-      i = v ? "deeply " : "", f = [], a.forEach(function(F, Z) {
-        f.push(Z);
-      }), n !== "Array" && (s = Array.prototype.slice.call(arguments));
-    else {
-      switch (f = o.getOwnEnumerableProperties(a), n) {
-        case "Array":
-          if (arguments.length > 1)
-            throw new m($, void 0, c);
-          break;
-        case "Object":
-          if (arguments.length > 1)
-            throw new m($, void 0, c);
-          s = Object.keys(s);
-          break;
-        default:
-          s = Array.prototype.slice.call(arguments);
-      }
-      s = s.map(function(F) {
-        return typeof F == "symbol" ? F : String(F);
-      });
-    }
-    if (!s.length)
-      throw new m(w + "keys required", void 0, c);
-    var N = s.length, V = e(this, "any"), E = e(this, "all"), S = s, B = v ? e(this, "eql") : (F, Z) => F === Z;
-    if (!V && !E && (E = !0), V && (g = S.some(function(F) {
-      return f.some(function(Z) {
-        return B(F, Z);
-      });
-    })), E && (g = S.every(function(F) {
-      return f.some(function(Z) {
-        return B(F, Z);
-      });
-    }), e(this, "contains") || (g = g && s.length == f.length)), N > 1) {
-      s = s.map(function(F) {
-        return o.inspect(F);
-      });
-      var Q = s.pop();
-      E && (r = s.join(", ") + ", and " + Q), V && (r = s.join(", ") + ", or " + Q);
-    } else
-      r = o.inspect(s[0]);
-    r = (N > 1 ? "keys " : "key ") + r, r = (e(this, "contains") ? "contain " : "have ") + r, this.assert(
-      g,
-      "expected #{this} to " + i + r,
-      "expected #{this} to not " + i + r,
-      S.slice(0).sort(o.compareByInspect),
-      f.sort(o.compareByInspect),
-      !0
-    );
-  }
-  t.addMethod("keys", J), t.addMethod("key", J);
-  function X(s, a, l) {
-    l && e(this, "message", l);
-    var n = e(this, "object"), c = e(this, "ssfi"), v = e(this, "message"), r = e(this, "negate") || !1;
-    new t(n, v, c, !0).is.a("function"), (s instanceof RegExp || typeof s == "string") && (a = s, s = null);
-    var i;
-    try {
-      n();
-    } catch (Q) {
-      i = Q;
-    }
-    var f = s === void 0 && a === void 0, g = !!(s && a), w = !1, $ = !1;
-    if (f || !f && !r) {
-      var N = "an error";
-      s instanceof Error ? N = "#{exp}" : s && (N = o.checkError.getConstructorName(s)), this.assert(
-        i,
-        "expected #{this} to throw " + N,
-        "expected #{this} to not throw an error but #{act} was thrown",
-        s && s.toString(),
-        i instanceof Error ? i.toString() : typeof i == "string" ? i : i && o.checkError.getConstructorName(i)
-      );
-    }
-    if (s && i) {
-      if (s instanceof Error) {
-        var V = o.checkError.compatibleInstance(i, s);
-        V === r && (g && r ? w = !0 : this.assert(
-          r,
-          "expected #{this} to throw #{exp} but #{act} was thrown",
-          "expected #{this} to not throw #{exp}" + (i && !r ? " but #{act} was thrown" : ""),
-          s.toString(),
-          i.toString()
-        ));
-      }
-      var E = o.checkError.compatibleConstructor(i, s);
-      E === r && (g && r ? w = !0 : this.assert(
-        r,
-        "expected #{this} to throw #{exp} but #{act} was thrown",
-        "expected #{this} to not throw #{exp}" + (i ? " but #{act} was thrown" : ""),
-        s instanceof Error ? s.toString() : s && o.checkError.getConstructorName(s),
-        i instanceof Error ? i.toString() : i && o.checkError.getConstructorName(i)
-      ));
-    }
-    if (i && a !== void 0 && a !== null) {
-      var S = "including";
-      a instanceof RegExp && (S = "matching");
-      var B = o.checkError.compatibleMessage(i, a);
-      B === r && (g && r ? $ = !0 : this.assert(
-        r,
-        "expected #{this} to throw error " + S + " #{exp} but got #{act}",
-        "expected #{this} to throw error not " + S + " #{exp}",
-        a,
-        o.checkError.getMessage(i)
-      ));
-    }
-    w && $ && this.assert(
-      r,
-      "expected #{this} to throw #{exp} but #{act} was thrown",
-      "expected #{this} to not throw #{exp}" + (i ? " but #{act} was thrown" : ""),
-      s instanceof Error ? s.toString() : s && o.checkError.getConstructorName(s),
-      i instanceof Error ? i.toString() : i && o.checkError.getConstructorName(i)
-    ), e(this, "object", i);
-  }
-  t.addMethod("throw", X), t.addMethod("throws", X), t.addMethod("Throw", X);
-  function P(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "object"), n = e(this, "itself"), c = typeof l == "function" && !n ? l.prototype[s] : l[s];
-    this.assert(
-      typeof c == "function",
-      "expected #{this} to respond to " + o.inspect(s),
-      "expected #{this} to not respond to " + o.inspect(s)
-    );
-  }
-  t.addMethod("respondTo", P), t.addMethod("respondsTo", P), t.addProperty("itself", function() {
-    e(this, "itself", !0);
-  });
-  function K(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "object"), n = s(l);
-    this.assert(
-      n,
-      "expected #{this} to satisfy " + o.objDisplay(s),
-      "expected #{this} to not satisfy" + o.objDisplay(s),
-      !e(this, "negate"),
-      n
-    );
-  }
-  t.addMethod("satisfy", K), t.addMethod("satisfies", K);
-  function ae(s, a, l) {
-    l && e(this, "message", l);
-    var n = e(this, "object"), c = e(this, "message"), v = e(this, "ssfi");
-    if (new t(n, c, v, !0).is.a("number"), typeof s != "number" || typeof a != "number") {
-      c = c ? c + ": " : "";
-      var r = a === void 0 ? ", and a delta is required" : "";
-      throw new m(
-        c + "the arguments to closeTo or approximately must be numbers" + r,
-        void 0,
-        v
-      );
-    }
-    this.assert(
-      Math.abs(n - s) <= a,
-      "expected #{this} to be close to " + s + " +/- " + a,
-      "expected #{this} not to be close to " + s + " +/- " + a
-    );
-  }
-  t.addMethod("closeTo", ae), t.addMethod("approximately", ae);
-  function oe(s, a, l, n, c) {
-    if (!n) {
-      if (s.length !== a.length)
-        return !1;
-      a = a.slice();
-    }
-    return s.every(function(v, r) {
-      if (c)
-        return l ? l(v, a[r]) : v === a[r];
-      if (!l) {
-        var i = a.indexOf(v);
-        return i === -1 ? !1 : (n || a.splice(i, 1), !0);
-      }
-      return a.some(function(f, g) {
-        return l(v, f) ? (n || a.splice(g, 1), !0) : !1;
-      });
-    });
-  }
-  t.addMethod("members", function(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "object"), n = e(this, "message"), c = e(this, "ssfi");
-    new t(l, n, c, !0).to.be.an("array"), new t(s, n, c, !0).to.be.an("array");
-    var v = e(this, "contains"), r = e(this, "ordered"), i, f, g;
-    v ? (i = r ? "an ordered superset" : "a superset", f = "expected #{this} to be " + i + " of #{exp}", g = "expected #{this} to not be " + i + " of #{exp}") : (i = r ? "ordered members" : "members", f = "expected #{this} to have the same " + i + " as #{exp}", g = "expected #{this} to not have the same " + i + " as #{exp}");
-    var w = e(this, "deep") ? e(this, "eql") : void 0;
-    this.assert(
-      oe(s, l, w, v, r),
-      f,
-      g,
-      s,
-      l,
-      !0
-    );
-  });
-  function ne(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "object"), n = e(this, "message"), c = e(this, "ssfi"), v = e(this, "contains"), r = e(this, "deep"), i = e(this, "eql");
-    new t(s, n, c, !0).to.be.an("array"), v ? this.assert(
-      s.some(function(f) {
-        return l.indexOf(f) > -1;
-      }),
-      "expected #{this} to contain one of #{exp}",
-      "expected #{this} to not contain one of #{exp}",
-      s,
-      l
-    ) : r ? this.assert(
-      s.some(function(f) {
-        return i(l, f);
-      }),
-      "expected #{this} to deeply equal one of #{exp}",
-      "expected #{this} to deeply equal one of #{exp}",
-      s,
-      l
-    ) : this.assert(
-      s.indexOf(l) > -1,
-      "expected #{this} to be one of #{exp}",
-      "expected #{this} to not be one of #{exp}",
-      s,
-      l
-    );
-  }
-  t.addMethod("oneOf", ne);
-  function de(s, a, l) {
-    l && e(this, "message", l);
-    var n = e(this, "object"), c = e(this, "message"), v = e(this, "ssfi");
-    new t(n, c, v, !0).is.a("function");
-    var r;
-    a ? (new t(s, c, v, !0).to.have.property(a), r = s[a]) : (new t(s, c, v, !0).is.a("function"), r = s()), n();
-    var i = a == null ? s() : s[a], f = a == null ? r : "." + a;
-    e(this, "deltaMsgObj", f), e(this, "initialDeltaValue", r), e(this, "finalDeltaValue", i), e(this, "deltaBehavior", "change"), e(this, "realDelta", i !== r), this.assert(
-      r !== i,
-      "expected " + f + " to change",
-      "expected " + f + " to not change"
-    );
-  }
-  t.addMethod("change", de), t.addMethod("changes", de);
-  function he(s, a, l) {
-    l && e(this, "message", l);
-    var n = e(this, "object"), c = e(this, "message"), v = e(this, "ssfi");
-    new t(n, c, v, !0).is.a("function");
-    var r;
-    a ? (new t(s, c, v, !0).to.have.property(a), r = s[a]) : (new t(s, c, v, !0).is.a("function"), r = s()), new t(r, c, v, !0).is.a("number"), n();
-    var i = a == null ? s() : s[a], f = a == null ? r : "." + a;
-    e(this, "deltaMsgObj", f), e(this, "initialDeltaValue", r), e(this, "finalDeltaValue", i), e(this, "deltaBehavior", "increase"), e(this, "realDelta", i - r), this.assert(
-      i - r > 0,
-      "expected " + f + " to increase",
-      "expected " + f + " to not increase"
-    );
-  }
-  t.addMethod("increase", he), t.addMethod("increases", he);
-  function ve(s, a, l) {
-    l && e(this, "message", l);
-    var n = e(this, "object"), c = e(this, "message"), v = e(this, "ssfi");
-    new t(n, c, v, !0).is.a("function");
-    var r;
-    a ? (new t(s, c, v, !0).to.have.property(a), r = s[a]) : (new t(s, c, v, !0).is.a("function"), r = s()), new t(r, c, v, !0).is.a("number"), n();
-    var i = a == null ? s() : s[a], f = a == null ? r : "." + a;
-    e(this, "deltaMsgObj", f), e(this, "initialDeltaValue", r), e(this, "finalDeltaValue", i), e(this, "deltaBehavior", "decrease"), e(this, "realDelta", r - i), this.assert(
-      i - r < 0,
-      "expected " + f + " to decrease",
-      "expected " + f + " to not decrease"
-    );
-  }
-  t.addMethod("decrease", ve), t.addMethod("decreases", ve);
-  function Ne(s, a) {
-    a && e(this, "message", a);
-    var l = e(this, "deltaMsgObj"), n = e(this, "initialDeltaValue"), c = e(this, "finalDeltaValue"), v = e(this, "deltaBehavior"), r = e(this, "realDelta"), i;
-    v === "change" ? i = Math.abs(c - n) === Math.abs(s) : i = r === Math.abs(s), this.assert(
-      i,
-      "expected " + l + " to " + v + " by " + s,
-      "expected " + l + " to not " + v + " by " + s
-    );
-  }
-  t.addMethod("by", Ne), t.addProperty("extensible", function() {
-    var s = e(this, "object"), a = s === Object(s) && Object.isExtensible(s);
-    this.assert(
-      a,
-      "expected #{this} to be extensible",
-      "expected #{this} to not be extensible"
-    );
-  }), t.addProperty("sealed", function() {
-    var s = e(this, "object"), a = s === Object(s) ? Object.isSealed(s) : !0;
-    this.assert(
-      a,
-      "expected #{this} to be sealed",
-      "expected #{this} to not be sealed"
-    );
-  }), t.addProperty("frozen", function() {
-    var s = e(this, "object"), a = s === Object(s) ? Object.isFrozen(s) : !0;
-    this.assert(
-      a,
-      "expected #{this} to be frozen",
-      "expected #{this} to not be frozen"
-    );
-  }), t.addProperty("finite", function(s) {
-    var a = e(this, "object");
-    this.assert(
-      typeof a == "number" && isFinite(a),
-      "expected #{this} to be a finite number",
-      "expected #{this} to not be a finite number"
-    );
-  });
-};
 export {
-  se as S,
-  qe as T,
-  Fe as a,
-  Be as c,
-  Ge as u
+  I as S,
+  ce as T,
+  he as c,
+  pe as u
 };