@cronocode/react-box 2.0.2 → 2.0.5

package/core.mjs

@@ -1,72 +1,72 @@
-import { useMemo as X, useLayoutEffect as se, useEffect as ae } from "react";
-import { O as Y } from "./utils.mjs";
-var e;
-((a) => {
-  ((u) => {
-    function t(o, m) {
-      return `${o}${m.replace("/", "-")}`;
+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("/", "-")}`;
     }
-    u.fraction = t;
-    function n(o) {
-      return [`${o} path`, `${o} circle`, `${o} rect`, `${o} line`];
+    o.fraction = t;
+    function m(e) {
+      return [`${e} path`, `${e} circle`, `${e} rect`, `${e} line`];
     }
-    u.svg = n;
-  })(a.ClassName || (a.ClassName = {})), ((u) => {
-    function t(l, s) {
-      return `${s / 4}rem`;
+    o.svg = m;
+  })(u.ClassName || (u.ClassName = {})), ((o) => {
+    function t(p, h) {
+      return `${h / 4}rem`;
     }
-    u.rem = t;
-    function n(l, s) {
-      return `${s}px`;
+    o.rem = t;
+    function m(p, h) {
+      return `${h}px`;
     }
-    u.px = n;
-    function o(l, s) {
-      const [r, i] = s.split("/");
-      return `${+r / +i * 100}%`;
+    o.px = m;
+    function e(p, h) {
+      const [b, x] = h.split("/");
+      return `${+b / +x * 100}%`;
     }
-    u.fraction = o;
-    function m(l, s) {
-      switch (s) {
+    o.fraction = e;
+    function O(p, h) {
+      switch (h) {
         case "fit":
           return "100%";
         case "fit-screen":
-          return l.toLocaleLowerCase().includes("height") ? "100vh" : "100vw";
+          return p.toLocaleLowerCase().includes("height") ? "100vh" : "100vw";
         default:
-          return s;
+          return h;
       }
     }
-    u.widthHeight = m;
-    function N(l) {
-      return (s, r) => `var(--${l}${r});`;
+    o.widthHeight = O;
+    function q(p) {
+      return (h, b) => `var(--${p}${b});`;
     }
-    u.variables = N;
-    function T(l) {
-      return (s, r) => `var(--${l}${r});`;
+    o.variables = q;
+    function H(p) {
+      return (h, b) => `var(--${p}${b});`;
     }
-    u.svgVariables = T;
-    function S(l, s) {
-      return `repeat(${s},minmax(0,1fr))`;
+    o.svgVariables = H;
+    function L(p, h) {
+      return `repeat(${h},minmax(0,1fr))`;
     }
-    u.gridColumns = S;
-    function c(l, s) {
-      return s === "full-row" ? "1/-1" : `span ${s}/span ${s}`;
+    o.gridColumns = L;
+    function G(p, h) {
+      return h === "full-row" ? "1/-1" : `span ${h}/span ${h}`;
     }
-    u.gridColumn = c;
-    function f(l, s) {
-      return `${s}ms`;
+    o.gridColumn = G;
+    function y(p, h) {
+      return `${h}ms`;
     }
-    u.ms = f;
-    function b(l, s) {
-      return `${s}deg`;
+    o.ms = y;
+    function j(p, h) {
+      return `${h}deg`;
     }
-    u.rotate = b;
-    function d(l, s) {
-      return s === "xAxis" ? "-1 1" : "1 -1";
+    o.rotate = j;
+    function C(p, h) {
+      return h === "xAxis" ? "-1 1" : "1 -1";
     }
-    u.flip = d;
-  })(a.Value || (a.Value = {}));
-})(e || (e = {}));
-const v = [
+    o.flip = C;
+  })(u.Value || (u.Value = {}));
+})(d || (d = {}));
+const M = [
   0,
   1,
   2,
@@ -139,7 +139,7 @@ const v = [
   350,
   384,
   400
-], le = [
+], Oe = [
   -1,
   -2,
   -3,
@@ -185,7 +185,7 @@ const v = [
   -92,
   -96,
   -100
-], h = [...v, ...le], F = ["solid", "dashed", "dotted", "double", "groove", "ridge", "inset", "outset", "none", "hidden"], G = ["auto", "hidden", "scroll", "visible"], E = [
+], T = [...M, ...Oe], fe = ["solid", "dashed", "dotted", "double", "groove", "ridge", "inset", "outset", "none", "hidden"], re = ["auto", "hidden", "scroll", "visible"], _ = [
   "1/2",
   "1/3",
   "2/3",
@@ -212,7 +212,7 @@ const v = [
   "9/12",
   "10/12",
   "11/12"
-], z = ["fit", "fit-screen", "auto", "fit-content", "max-content", "min-content"], L = ["auto", "flex-start", "flex-end", "center", "baseline", "stretch"], ue = {
+], ee = ["fit", "fit-screen", "auto", "fit-content", "max-content", "min-content"], me = ["auto", "flex-start", "flex-end", "center", "baseline", "stretch"], Ce = {
   /** 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 v = [
   },
   width: {
     cssNames: ["width"],
-    values1: { values: z, formatValue: e.Value.widthHeight },
-    values2: { values: v, formatValue: e.Value.rem },
+    values1: { values: ee, formatValue: d.Value.widthHeight },
+    values2: { values: M, formatValue: d.Value.rem },
     values3: {
-      values: E,
-      formatValue: e.Value.fraction
+      values: _,
+      formatValue: d.Value.fraction
       // formatClassName: BoxStylesFormatters.ClassName.fraction,
     }
   },
   minWidth: {
     cssNames: ["min-width"],
-    values1: { values: z, formatValue: e.Value.widthHeight },
-    values2: { values: v, formatValue: e.Value.rem },
+    values1: { values: ee, formatValue: d.Value.widthHeight },
+    values2: { values: M, formatValue: d.Value.rem },
     values3: {
-      values: E,
-      formatValue: e.Value.fraction
+      values: _,
+      formatValue: d.Value.fraction
       // formatClassName: BoxStylesFormatters.ClassName.fraction,
     }
   },
   maxWidth: {
     cssNames: ["max-width"],
-    values1: { values: z, formatValue: e.Value.widthHeight },
-    values2: { values: v, formatValue: e.Value.rem },
+    values1: { values: ee, formatValue: d.Value.widthHeight },
+    values2: { values: M, formatValue: d.Value.rem },
     values3: {
-      values: E,
-      formatValue: e.Value.fraction
+      values: _,
+      formatValue: d.Value.fraction
       // formatClassName: BoxStylesFormatters.ClassName.fraction,
     }
   },
   height: {
     cssNames: ["height"],
-    values1: { values: z, formatValue: e.Value.widthHeight },
-    values2: { values: v, formatValue: e.Value.rem },
+    values1: { values: ee, formatValue: d.Value.widthHeight },
+    values2: { values: M, formatValue: d.Value.rem },
     values3: {
-      values: E,
-      formatValue: e.Value.fraction
+      values: _,
+      formatValue: d.Value.fraction
       // formatClassName: BoxStylesFormatters.ClassName.fraction,
     }
   },
   minHeight: {
     cssNames: ["min-height"],
-    values1: { values: z, formatValue: e.Value.widthHeight },
-    values2: { values: v, formatValue: e.Value.rem },
+    values1: { values: ee, formatValue: d.Value.widthHeight },
+    values2: { values: M, formatValue: d.Value.rem },
     values3: {
-      values: E,
-      formatValue: e.Value.fraction
+      values: _,
+      formatValue: d.Value.fraction
       // formatClassName: BoxStylesFormatters.ClassName.fraction,
     }
   },
   maxHeight: {
     cssNames: ["max-height"],
-    values1: { values: z, formatValue: e.Value.widthHeight },
-    values2: { values: v, formatValue: e.Value.rem },
+    values1: { values: ee, formatValue: d.Value.widthHeight },
+    values2: { values: M, formatValue: d.Value.rem },
     values3: {
-      values: E,
-      formatValue: e.Value.fraction
+      values: _,
+      formatValue: d.Value.fraction
       // formatClassName: BoxStylesFormatters.ClassName.fraction,
     }
   },
@@ -302,217 +302,217 @@ const v = [
   },
   top: {
     cssNames: ["top"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   right: {
     cssNames: ["right"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   bottom: {
     cssNames: ["bottom"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   left: {
     cssNames: ["left"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   inset: {
     cssNames: ["inset"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   m: {
     cssNames: ["margin"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: ["auto"] },
     values3: { values: [] }
   },
   mx: {
     cssNames: ["margin-inline"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: ["auto"] },
     values3: { values: [] }
   },
   my: {
     cssNames: ["margin-block"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: ["auto"] },
     values3: { values: [] }
   },
   mt: {
     cssNames: ["margin-top"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: ["auto"] },
     values3: { values: [] }
   },
   mr: {
     cssNames: ["margin-right"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: ["auto"] },
     values3: { values: [] }
   },
   mb: {
     cssNames: ["margin-bottom"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: ["auto"] },
     values3: { values: [] }
   },
   ml: {
     cssNames: ["margin-left"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: ["auto"] },
     values3: { values: [] }
   },
   p: {
     cssNames: ["padding"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   px: {
     cssNames: ["padding-inline"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   py: {
     cssNames: ["padding-block"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   pt: {
     cssNames: ["padding-top"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   pr: {
     cssNames: ["padding-right"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   pb: {
     cssNames: ["padding-bottom"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   pl: {
     cssNames: ["padding-left"],
-    values1: { values: h, formatValue: e.Value.rem },
+    values1: { values: T, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   b: {
     cssNames: ["border-width"],
-    values1: { values: v, formatValue: e.Value.px },
+    values1: { values: M, formatValue: d.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   bx: {
     cssNames: ["border-inline-width"],
-    values1: { values: h, formatValue: e.Value.px },
+    values1: { values: T, formatValue: d.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   by: {
     cssNames: ["border-block-width"],
-    values1: { values: h, formatValue: e.Value.px },
+    values1: { values: T, formatValue: d.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   bt: {
     cssNames: ["border-top-width"],
-    values1: { values: h, formatValue: e.Value.px },
+    values1: { values: T, formatValue: d.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   br: {
     cssNames: ["border-right-width"],
-    values1: { values: h, formatValue: e.Value.px },
+    values1: { values: T, formatValue: d.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   bb: {
     cssNames: ["border-bottom-width"],
-    values1: { values: h, formatValue: e.Value.px },
+    values1: { values: T, formatValue: d.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   bl: {
     cssNames: ["border-left-width"],
-    values1: { values: h, formatValue: e.Value.px },
+    values1: { values: T, formatValue: d.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderStyle: {
     cssNames: ["border-style"],
-    values1: { values: F },
+    values1: { values: fe },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadius: {
     cssNames: ["border-radius"],
-    values1: { values: v, formatValue: e.Value.rem },
+    values1: { values: M, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusTop: {
     cssNames: ["border-top-left-radius", "border-top-right-radius"],
-    values1: { values: v, formatValue: e.Value.rem },
+    values1: { values: M, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusRight: {
     cssNames: ["border-top-right-radius", "border-bottom-right-radius"],
-    values1: { values: v, formatValue: e.Value.rem },
+    values1: { values: M, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusBottom: {
     cssNames: ["border-bottom-left-radius", "border-bottom-right-radius"],
-    values1: { values: v, formatValue: e.Value.rem },
+    values1: { values: M, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusLeft: {
     cssNames: ["border-top-left-radius", "border-bottom-left-radius"],
-    values1: { values: v, formatValue: e.Value.rem },
+    values1: { values: M, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusTopLeft: {
     cssNames: ["border-top-left-radius"],
-    values1: { values: v, formatValue: e.Value.rem },
+    values1: { values: M, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusTopRight: {
     cssNames: ["border-top-right-radius"],
-    values1: { values: v, formatValue: e.Value.rem },
+    values1: { values: M, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusBottomLeft: {
     cssNames: ["border-bottom-left-radius"],
-    values1: { values: v, formatValue: e.Value.rem },
+    values1: { values: M, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   borderRadiusBottomRight: {
     cssNames: ["border-bottom-right-radius"],
-    values1: { values: v, formatValue: e.Value.rem },
+    values1: { values: M, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
@@ -571,19 +571,19 @@ const v = [
   },
   overflow: {
     cssNames: ["overflow"],
-    values1: { values: G },
+    values1: { values: re },
     values2: { values: [] },
     values3: { values: [] }
   },
   overflowX: {
     cssNames: ["overflow-x"],
-    values1: { values: G },
+    values1: { values: re },
     values2: { values: [] },
     values3: { values: [] }
   },
   overflowY: {
     cssNames: ["overflow-y"],
-    values1: { values: G },
+    values1: { values: re },
     values2: { values: [] },
     values3: { values: [] }
   },
@@ -595,7 +595,7 @@ const v = [
   },
   fontSize: {
     cssNames: ["font-size"],
-    values1: { values: v, formatValue: e.Value.px },
+    values1: { values: M, formatValue: d.Value.px },
     values2: { values: ["inherit"] },
     values3: { values: [] }
   },
@@ -613,13 +613,13 @@ const v = [
   },
   letterSpacing: {
     cssNames: ["letter-spacing"],
-    values1: { values: v, formatValue: e.Value.px },
+    values1: { values: M, formatValue: d.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   lineHeight: {
     cssNames: ["line-height"],
-    values1: { values: v, formatValue: e.Value.px },
+    values1: { values: M, formatValue: d.Value.px },
     values2: { values: ["font-size"], formatValue: () => "1" },
     values3: { values: [] }
   },
@@ -708,91 +708,91 @@ const v = [
   },
   gap: {
     cssNames: ["gap"],
-    values1: { values: v, formatValue: e.Value.rem },
+    values1: { values: M, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   rowGap: {
     cssNames: ["row-gap"],
-    values1: { values: v, formatValue: e.Value.rem },
+    values1: { values: M, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   columnGap: {
     cssNames: ["column-gap"],
-    values1: { values: v, formatValue: e.Value.rem },
+    values1: { values: M, formatValue: d.Value.rem },
     values2: { values: [] },
     values3: { values: [] }
   },
   order: {
     cssNames: ["order"],
-    values1: { values: v },
+    values1: { values: M },
     values2: { values: [] },
     values3: { values: [] }
   },
   flexGrow: {
     cssNames: ["flex-grow"],
-    values1: { values: v },
+    values1: { values: M },
     values2: { values: [] },
     values3: { values: [] }
   },
   flexShrink: {
     cssNames: ["flex-shrink"],
-    values1: { values: v },
+    values1: { values: M },
     values2: { values: [] },
     values3: { values: [] }
   },
   alignSelf: {
     cssNames: ["align-self"],
-    values1: { values: L },
+    values1: { values: me },
     values2: { values: [] },
     values3: { values: [] }
   },
   justifySelf: {
     cssNames: ["justify-self"],
-    values1: { values: L },
+    values1: { values: me },
     values2: { values: [] },
     values3: { values: [] }
   },
   gridColumns: {
     cssNames: ["grid-template-columns"],
-    values1: { values: v, formatValue: e.Value.gridColumns },
+    values1: { values: M, formatValue: d.Value.gridColumns },
     values2: { values: [] },
     values3: { values: [] }
   },
   colSpan: {
     cssNames: ["grid-column"],
-    values1: { values: v, formatValue: e.Value.gridColumn },
-    values2: { values: ["full-row"], formatValue: e.Value.gridColumn },
+    values1: { values: M, formatValue: d.Value.gridColumn },
+    values2: { values: ["full-row"], formatValue: d.Value.gridColumn },
     values3: { values: [] }
   },
   colStart: {
     cssNames: ["grid-column-start"],
-    values1: { values: v },
+    values1: { values: M },
     values2: { values: [] },
     values3: { values: [] }
   },
   colEnd: {
     cssNames: ["grid-column-end"],
-    values1: { values: v },
+    values1: { values: M },
     values2: { values: [] },
     values3: { values: [] }
   },
   outline: {
     cssNames: ["outline-width"],
-    values1: { values: v, formatValue: e.Value.px },
+    values1: { values: M, formatValue: d.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
   outlineStyle: {
     cssNames: ["outline-style"],
-    values1: { values: F },
+    values1: { values: fe },
     values2: { values: [] },
     values3: { values: [] }
   },
   outlineOffset: {
     cssNames: ["outline-offset"],
-    values1: { values: v, formatValue: e.Value.px },
+    values1: { values: M, formatValue: d.Value.px },
     values2: { values: [] },
     values3: { values: [] }
   },
@@ -806,7 +806,7 @@ const v = [
     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: e.Value.ms
+      formatValue: d.Value.ms
     },
     values2: { values: [] },
     values3: { values: [] }
@@ -819,7 +819,7 @@ const v = [
   },
   appearance: {
     cssNames: ["appearance"],
-    values1: { values: ["none"] },
+    values1: { values: ["none", "auto", "menulist-button", "textfield", "button", "checkbox"] },
     values2: { values: [] },
     values3: { values: [] }
   },
@@ -843,188 +843,224 @@ const v = [
   },
   rotate: {
     cssNames: ["rotate"],
-    values1: { values: [0, 90, 180, 270, -90, -180, -270], formatValue: e.Value.rotate },
+    values1: { values: [0, 90, 180, 270, -90, -180, -270], formatValue: d.Value.rotate },
     values2: { values: [] },
     values3: { values: [] }
   },
   flip: {
     cssNames: ["scale"],
-    values1: { values: ["xAxis", "yAxis"], formatValue: e.Value.flip },
+    values1: { values: ["xAxis", "yAxis"], formatValue: d.Value.flip },
+    values2: { values: [] },
+    values3: { values: [] }
+  },
+  visibility: {
+    cssNames: ["visibility"],
+    values1: { values: ["visible", "hidden", "collapse"] },
+    values2: { values: [] },
+    values3: { values: [] }
+  },
+  resize: {
+    cssNames: ["resize"],
+    values1: { values: ["none", "both", "horizontal", "vertical", "block", "inline"] },
     values2: { values: [] },
     values3: { values: [] }
   }
-}, W = {
-  shadow: { cssNames: ["box-shadow"], formatValue: e.Value.variables("shadow") },
-  background: { cssNames: ["background"], formatValue: e.Value.variables("background") },
-  backgroundImage: { cssNames: ["background-image"], formatValue: e.Value.variables("backgroundImage") },
-  color: { cssNames: ["color"], formatValue: e.Value.variables("color") },
-  bgColor: { cssNames: ["background-color"], formatValue: e.Value.variables("color") },
-  borderColor: { cssNames: ["border-color"], formatValue: e.Value.variables("color") },
-  outlineColor: { cssNames: ["outline-color"], formatValue: e.Value.variables("color") }
-}, K = {
+}, 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 = {
   fill: {
     cssNames: ["fill"],
-    formatValue: e.Value.svgVariables("color"),
-    formatSelector: e.ClassName.svg
+    formatValue: d.Value.svgVariables("color"),
+    formatSelector: d.ClassName.svg
   },
   stroke: {
     cssNames: ["stroke"],
-    formatValue: e.Value.svgVariables("color"),
-    formatSelector: e.ClassName.svg
+    formatValue: d.Value.svgVariables("color"),
+    formatSelector: d.ClassName.svg
   }
-}, P = [
-  "Hover",
-  "Focus",
-  "Active",
-  "Checked",
-  "Indeterminate",
-  "Valid",
-  "Invalid",
-  "Required",
-  "Optional",
-  "Disabled"
-], A = ["sm", "md", "lg", "xl", "xxl"], te = {
+}, Ee = ["disabledGroup", "hoverGroup", "focusGroup", "activeGroup"], le = [
+  "hover",
+  "focus",
+  "hasFocus",
+  "active",
+  "checked",
+  "hasChecked",
+  "indeterminate",
+  "valid",
+  "hasValid",
+  "invalid",
+  "hasInvalid",
+  "required",
+  "optional",
+  "disabled",
+  "hasDisabled"
+], te = ["sm", "md", "lg", "xl", "xxl"], $e = {
   sm: 640,
   md: 768,
   lg: 1024,
   xl: 1280,
   xxl: 1536
 };
-function J() {
-  const a = { ...ue };
-  Object.keys(W).forEach((t) => {
-    a[t] = W[t], a[t].isThemeStyle = !0;
-  }), Object.keys(K).forEach((t) => {
-    a[t] = K[t], a[t].isThemeStyle = !0;
+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;
   });
-  let u = Object.keys(a);
-  return P.forEach((t) => {
-    u.forEach((n) => {
-      a[`${n}${t}`] = { ...a[n], pseudoSuffix: t };
+  let o = Object.keys(u);
+  return le.forEach((t) => {
+    o.forEach((m) => {
+      u[`${m}${t}`] = { ...u[m], pseudoSuffix: t };
     });
-  }), u = Object.keys(a), A.forEach((t) => {
-    u.forEach((n) => {
-      a[`${t}${n}`] = { ...a[n], breakpoint: t };
+  }), o = Object.keys(u), te.forEach((t) => {
+    o.forEach((m) => {
+      u[`${t}${m}`] = { ...u[m], breakpoint: t };
     });
-  }), a;
+  }), u;
 }
-let C = J();
-function oe() {
-  C = J();
+let U = ye();
+function Te() {
+  U = ye();
 }
-function re(a, u, t) {
-  const n = Object.entries(C).filter(
-    ([o, m]) => m.pseudoSuffix === a && !m.customPseudoSuffix && !(`${o}${u}` in C)
-  ).map(([o]) => o);
-  return n.forEach((o) => {
-    C[`${o}${u}`] = {
-      ...C[o],
-      customPseudoSuffix: t + u
+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
     };
-  }), n.map((o) => `${o}${u}`);
+  }), m.map((e) => `${e}${o}`);
 }
-class ne {
+class ke {
   constructor() {
     this._index = 0, this._cache = {};
   }
-  getIdentity(u) {
-    return this._cache[u] || (this._cache[u] = this.getByIndex(this._index++)), this._cache[u];
+  getIdentity(o) {
+    return this._cache[o] || (this._cache[o] = this.getByIndex(this._index++)), this._cache[o];
   }
-  getByIndex(u) {
-    const { first: t, next: n } = ve, o = u - t.length;
-    if (o < 0)
-      return t[u];
-    const m = Math.floor(o / n.length), N = o - m * n.length;
-    return this.getByIndex(m) + n[N];
+  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];
   }
 }
-const ve = {
+const Pe = {
   first: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
   next: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
 };
-var D;
-((a) => {
-  a.boxClassName = "_box", a.svgClassName = "_svg", a.cronoStylesElementId = "crono-styles";
-  const u = `: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 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;}}
 html{font-size: 16px;font-family: Arial, sans-serif;}
 body{margin: 0;line-height: var(--lineHeight);font-size: var(--fontSize);}
 a,ul{all: unset;}
-.${a.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;}
-.${a.svgClassName}{transition: all var(--svgTransitionTime);}.${a.svgClassName} path,.${a.svgClassName} circle,.${a.svgClassName} rect,.${a.svgClassName} line {transition: all var(--svgTransitionTime);}
-`, t = new ne();
-  let n = !0, o = {};
-  T();
-  function m(l, s, r) {
-    if (l in C)
-      return c(l, s, r);
-    if (["disabledGroup", "hoverGroup", "focusGroup", "activeGroup"].includes(l))
-      return l + s;
+.${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;
   }
-  a.get = m;
-  function N() {
-    if (n) {
-      let l = f([u]);
-      P.forEach((r) => {
-        l = f(l, r);
-      }), A.forEach((r) => {
-        l.push(`@media(min-width: ${te[r]}px){`), l = f(l, void 0, r), P.forEach((i) => {
-          l = f(l, i, r);
-        }), l.push("}");
+  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("}");
       });
-      const s = d();
-      s.innerHTML = l.join(""), n = !1;
+      const b = p();
+      b.innerHTML = h.join(""), m = !1;
     }
   }
-  a.flush = N;
-  function T() {
-    oe(), o = Object.keys(C).reduce(
-      (s, r) => (s[r] = /* @__PURE__ */ new Set(), s),
+  u.flush = q;
+  function H() {
+    Te(), e = Object.keys(U).reduce(
+      (b, x) => (b[x] = /* @__PURE__ */ new Set(), b),
       {}
     );
   }
-  a.clear = T;
-  function S(l, s, r) {
-    re(l, s, r).forEach((p) => {
-      o[p] = /* @__PURE__ */ new Set();
+  u.clear = H;
+  function L(h, b, x) {
+    Se(h, b, x).forEach((k) => {
+      e[k] = /* @__PURE__ */ new Set();
     });
   }
-  a.addCustomPseudoClass = S;
-  function c(l, s, r) {
-    const i = (r ?? "") + l;
-    o[i].has(s) || (n = !0, o[i].add(s));
-    const p = `${i}${s}`;
-    return process.env.NODE_ENV === "test" ? p : t.getIdentity(p);
+  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);
   }
-  function f(l, s, r) {
-    return Object.entries(o).filter(
-      ([p, k]) => {
-        var w, $;
-        return ((w = C[p]) == null ? void 0 : w.pseudoSuffix) === s && (($ = C[p]) == null ? void 0 : $.breakpoint) === r && k.size > 0;
+  const y = {
+    hover: "hover",
+    focus: "focus-within",
+    hasFocus: "has(:focus-within)",
+    active: "active",
+    checked: "checked",
+    hasChecked: "has(:checked)",
+    indeterminate: "indeterminate",
+    valid: "user-valid",
+    hasValid: "has(:valid)",
+    invalid: "user-invalid",
+    hasInvalid: "has(:user-invalid)",
+    required: "required",
+    optional: "optional",
+    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;
       }
-    ).reduce((p, [k, w]) => (w.forEach(($) => {
-      var q;
-      const g = C[k], y = b(g, $), j = `.${c(k, $)}`;
-      let x = [];
-      s ? s === "Hover" ? x = i(j, g, y, "hover") : s === "Focus" ? x = i(j, g, y, "focus-within") : s === "Active" ? x = i(j, g, y, "active") : s === "Checked" ? x = i(j, g, y, "checked") : s === "Indeterminate" ? x = i(j, g, y, "indeterminate") : s === "Valid" ? x = i(j, g, y, "valid") : s === "Invalid" ? x = i(j, g, y, "invalid") : s === "Required" ? x = i(j, g, y, "required") : s === "Optional" ? x = i(j, g, y, "optional") : s === "Disabled" && (x = i(j, g, y, "disabled")) : x = i(j, g, y);
-      const V = ((q = y.formatValue) == null ? void 0 : q.call(y, k, $)) ?? $, Z = C[k].cssNames.map((ee) => `${ee}:${V};`).join("");
-      p.push(`${x.join(",")}{${Z}}`);
-    }), p), l);
-    function i(p, k, w, $) {
-      let g = p;
-      return $ && (g = k.customPseudoSuffix ? `.${k.customPseudoSuffix}:${$} ${p}` : `${p}:${$}`), w.formatSelector ? w.formatSelector(g) : [g];
+    ).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];
     }
   }
-  function b(l, s) {
-    return l.isThemeStyle ? l : l.values1.values.includes(s) ? l.values1 : l.values2.values.includes(s) ? l.values2 : l.values3;
+  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 d() {
-    const s = typeof window < "u" && typeof window.document < "u" ? window.document : global.document;
-    let r = s.getElementById(a.cronoStylesElementId);
-    return r || (r = s.createElement("style"), r.setAttribute("id", a.cronoStylesElementId), r.setAttribute("type", "text/css"), s.head.insertBefore(r, s.head.firstChild)), r;
+  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;
   }
-  a.getElement = d;
-})(D || (D = {}));
-const I = D, H = {
+  u.getElement = p;
+})(ue || (ue = {}));
+const se = ue, ze = {
   button: {
     styles: {
       display: "inline-block",
@@ -1065,41 +1101,30 @@ const I = D, H = {
       borderRadius: 1
     }
   }
-}, ie = {
-  Hover: "hover",
-  Focus: "focus",
-  Active: "active",
-  Checked: "checked",
-  Indeterminate: "indeterminate",
-  Valid: "valid",
-  Invalid: "invalid",
-  Required: "required",
-  Optional: "optional",
-  Disabled: "disabled"
 };
-var _;
-((a) => {
-  a.Styles = {};
-  function u(c) {
-    a.Styles = o(H), a.Styles = n(c);
+var ce;
+((u) => {
+  u.Styles = {};
+  function o(y) {
+    u.Styles = e(ze), m(y);
   }
-  a.setup = u;
-  function t(c, f) {
-    const { colors: b = {}, shadows: d = {}, backgrounds: l = {}, backgroundImages: s = {} } = c;
-    b.none = "none", d.none = "none", l.none = "none", s.none = "none";
-    const r = Object.entries(b).map(([V, O]) => `--color${V}: ${O};`).join(`
-  `), i = Object.entries(d).map(([V, O]) => `--shadow${V}: ${O};`).join(`
-  `), p = Object.entries(l).map(([V, O]) => `--background${V}: ${O};`).join(`
-  `), k = Object.entries(s).map(([V, O]) => `--backgroundImage${V}: ${O};`).join(`
-  `), w = [":root {"];
-    r && w.push(`  ${r}`), i && w.push(`  ${i}`), p && w.push(`  ${p}`), k && w.push(`  ${k}`), w.push("}");
-    const $ = Object.keys(b).map((V) => `'${V}'`).join(" | "), g = Object.keys(l).map((V) => `'${V}'`).join(" | "), y = Object.keys(s).map((V) => `'${V}'`).join(" | "), j = Object.keys(d).map((V) => `'${V}'`).join(" | "), x = `import '@cronocode/react-box';
+  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';
   
-  declare module '${(f == null ? void 0 : f.namespacePath) ?? "@cronocode/react-box/core/types"}' {
-    type ColorType = ${$};
-    type BackgroundType = ${g};
-    type BackgroundImageType = ${y};
-    type ShadowType = ${j};
+  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};
   
     namespace Augmented {
       interface BoxProps {
@@ -1120,129 +1145,970 @@ var _;
   }
   `;
     return {
-      variables: w.join(`
+      variables: D.join(`
 `),
-      boxDts: x
+      boxDts: X
     };
   }
-  a.setupAugmentedProps = t;
-  function n(c) {
-    const f = o(c);
-    return Object.keys(H).forEach((d) => {
-      const l = f[d], s = H[d];
-      l ? l.styles = { ...s.styles, ...l.styles } : f[d] = H[d];
-    }), f;
+  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;
   }
-  function o(c) {
-    return m(c), T(c), c;
+  function e(y) {
+    return O(y), q(y), L(y), y;
   }
-  function m(c) {
-    if (!c.components)
+  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 q(y) {
+    if (!y.components)
       return;
-    const f = Object.keys(c.components);
-    for (const b of f) {
-      const d = c.components[b], l = N(b, d);
-      delete d.children;
-      for (const s of l) {
-        const [r, i] = s;
-        c.components[r] = i;
+    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;
       }
     }
   }
-  function N(c, f) {
-    if (!f.children)
+  function H(y, j) {
+    if (!j.children)
       return [];
-    const b = Object.keys(f.children), d = [];
-    for (const l of b) {
-      const s = `${c}.${l}`, r = f.children[l], i = N(s, r);
-      d.push(...i), delete r.children, d.push([s, r]);
+    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]);
     }
-    return d;
+    return p;
   }
-  function T(c) {
-    const { components: f, ...b } = c, d = Object.values(b);
-    f && d.push(...Object.values(f));
-    for (const l of d)
-      S(l.styles), A.forEach((s) => {
-        if (s in l.styles) {
-          const r = l.styles[s];
-          S(r);
+  function L(y) {
+    if (!y.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);
         }
-      }), l.themes && Object.values(l.themes).forEach((s) => {
-        S(s), A.forEach((r) => {
-          if (r in s) {
-            const i = s[r];
-            S(i);
+      }), C.themes && Object.values(C.themes).forEach((p) => {
+        G(p), te.forEach((h) => {
+          if (h in p) {
+            const b = p[h];
+            G(b);
           }
         });
       });
   }
-  function S(c) {
-    Object.entries(ie).forEach(([f, b]) => {
-      if (b in c) {
-        const d = c[b];
-        Object.entries(d).map(([l, s]) => {
-          c[`${l}${f}`] = s;
-        }), delete c[b];
+  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];
       }
     });
   }
-})(_ || (_ = {}));
-const M = _;
-function ce(a) {
-  const { clean: u, theme: t, component: n } = a;
-  return X(() => {
-    var m, N;
-    if (u)
-      return;
-    let o = M.Styles[n] ?? ((m = M.Styles.components) == null ? void 0 : m[n]);
+})(ce || (ce = {}));
+const qe = ce;
+function De(u) {
+  const { clean: o, theme: t, component: m } = u;
+  return xe(() => {
+    var O, q;
     if (o)
-      return t ? { ...o.styles, ...(N = o.themes) == null ? void 0 : N[t] } : o.styles;
-  }, [n, u, t]);
+      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]);
 }
-const me = typeof window < "u" && typeof window.document < "u", fe = me ? se : ae;
-function ge(a, u) {
-  const t = ce(a);
-  return fe(I.flush, [a]), X(() => {
-    const n = [u ? I.svgClassName : I.boxClassName], o = t ? { ...t, ...a } : { ...a };
-    return U(o), Object.entries(o).forEach(([m, N]) => {
-      n.push(I.get(m, N));
-    }), A.forEach((m) => {
-      if (m in o) {
-        const N = o[m];
-        U(N), Object.entries(N).forEach(([T, S]) => {
-          n.push(I.get(T, S, m));
-        }), delete o[m];
+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];
       }
-    }), n;
-  }, [a, t]);
+    }), m;
+  }, [u, t]);
 }
-function U(a) {
-  B(a, "hover", "Hover"), B(a, "focus", "Focus"), B(a, "active", "Active"), B(a, "disabled", "Disabled"), R(a, "hoverGroup", "Hover"), R(a, "focusGroup", "Focus"), R(a, "activeGroup", "Active"), R(a, "disabledGroup", "Disabled");
+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 B(a, u, t) {
-  u in a && Q(a, u, t, a[u]);
+function R(u, o, t) {
+  o in u && Ve(u, o, t, u[o]);
 }
-function R(a, u, t) {
-  u in a && Y.isObject(a[u]) && Object.entries(a[u]).forEach(([n, o]) => {
-    I.addCustomPseudoClass(t, n, u), Q(a, u, t + n, o);
+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 Q(a, u, t, n) {
-  Array.isArray(n) ? (Object.entries(n[1]).forEach(([o, m]) => {
-    a[`${o}${t}`] = m;
-  }), a[u] = n[0]) : Y.isObject(n) && (Object.entries(n).forEach(([o, m]) => {
-    a[`${o}${t}`] = m;
-  }), delete a[u]);
+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 de(...a) {
-  return a.reduce((u, t) => t ? typeof t == "string" ? (u.push(t), u) : Array.isArray(t) ? (u.push(...de(...t)), u) : (Object.entries(t).forEach(([n, o]) => {
-    o && u.push(n);
-  }), u) : u, []);
+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, []);
 }
+/*!
+ * 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 {
-  I as S,
-  M as T,
-  de as c,
-  ge as u
+  se as S,
+  qe as T,
+  Fe as a,
+  Be as c,
+  Ge as u
 };