@kvell-group/ui 1.8.2 → 1.9.0

package/dist/components/CardInput/CardInput.js

@@ -0,0 +1,3924 @@
+import { jsx as j, jsxs as He } from "react/jsx-runtime";
+import * as tt from "react";
+import ce, { createContext as Vt, useContext as Pt, useState as Lt, forwardRef as Nt, Fragment as jt, createElement as $t } from "react";
+import { c as Ut } from "../../Text.module-R-XLggXY.js";
+import { useCardLogo as zt } from "./useCardLogo.js";
+import { r as qt, i as Yt, p as We, u as Z, a as ge, c as ke, h as gt, e as qe, f as ye, B as ve, b as me, j as kt } from "../../polymorphic-factory-Bvt8Is5k.js";
+import { u as Ht, r as _e } from "../../MantineThemeProvider-kHsOfZUW.js";
+import { U as Wt } from "../../UnstyledButton-D2QHft3M.js";
+import { u as Kt } from "../../use-isomorphic-effect-TT0F1lfC.js";
+import '../../assets/CardInput.css';function yt(n = null) {
+  const e = Vt(n);
+  return [({ children: i, value: r }) => /* @__PURE__ */ j(e.Provider, { value: r, children: i }), () => Pt(e)];
+}
+function Gt(n = "mantine-") {
+  return `${n}${Math.random().toString(36).slice(2, 11)}`;
+}
+const Zt = ce.useId || (() => {
+});
+function Xt() {
+  const n = Zt();
+  return n ? `mantine-${n.replace(/:/g, "")}` : "";
+}
+function Jt(n) {
+  const e = Xt(), [t, s] = Lt(e);
+  return Kt(() => {
+    s(Gt());
+  }, []), typeof n == "string" ? n : typeof window > "u" ? e : t;
+}
+function Qt({
+  classNames: n,
+  styles: e,
+  props: t,
+  stylesCtx: s
+}) {
+  const i = Ht();
+  return {
+    resolvedClassNames: Yt({
+      theme: i,
+      classNames: n,
+      props: t,
+      stylesCtx: s || void 0
+    }),
+    resolvedStyles: qt({
+      theme: i,
+      styles: e,
+      props: t,
+      stylesCtx: s || void 0
+    })
+  };
+}
+const Et = Nt(
+  ({ size: n = "var(--cb-icon-size, 70%)", style: e, ...t }, s) => /* @__PURE__ */ j(
+    "svg",
+    {
+      viewBox: "0 0 15 15",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      style: { ...e, width: n, height: n },
+      ref: s,
+      ...t,
+      children: /* @__PURE__ */ j(
+        "path",
+        {
+          d: "M11.7816 4.03157C12.0062 3.80702 12.0062 3.44295 11.7816 3.2184C11.5571 2.99385 11.193 2.99385 10.9685 3.2184L7.50005 6.68682L4.03164 3.2184C3.80708 2.99385 3.44301 2.99385 3.21846 3.2184C2.99391 3.44295 2.99391 3.80702 3.21846 4.03157L6.68688 7.49999L3.21846 10.9684C2.99391 11.193 2.99391 11.557 3.21846 11.7816C3.44301 12.0061 3.80708 12.0061 4.03164 11.7816L7.50005 8.31316L10.9685 11.7816C11.193 12.0061 11.5571 12.0061 11.7816 11.7816C12.0062 11.557 12.0062 11.193 11.7816 10.9684L8.31322 7.49999L11.7816 4.03157Z",
+          fill: "currentColor",
+          fillRule: "evenodd",
+          clipRule: "evenodd"
+        }
+      )
+    }
+  )
+);
+Et.displayName = "@mantine/core/CloseIcon";
+var Ct = { root: "m_86a44da5", "root--subtle": "m_220c80f2" };
+const es = {
+  variant: "subtle"
+}, ts = ke((n, { size: e, radius: t, iconSize: s }) => ({
+  root: {
+    "--cb-size": qe(e, "cb-size"),
+    "--cb-radius": t === void 0 ? void 0 : gt(t),
+    "--cb-icon-size": _e(s)
+  }
+})), Ke = We((n, e) => {
+  const t = Z("CloseButton", es, n), {
+    iconSize: s,
+    children: i,
+    vars: r,
+    radius: a,
+    className: u,
+    classNames: o,
+    style: l,
+    styles: p,
+    unstyled: d,
+    "data-disabled": k,
+    disabled: E,
+    variant: I,
+    icon: y,
+    mod: F,
+    __staticSelector: N,
+    ...L
+  } = t, A = ge({
+    name: N || "CloseButton",
+    props: t,
+    className: u,
+    style: l,
+    classes: Ct,
+    classNames: o,
+    styles: p,
+    unstyled: d,
+    vars: r,
+    varsResolver: ts
+  });
+  return /* @__PURE__ */ He(
+    Wt,
+    {
+      ref: e,
+      ...L,
+      unstyled: d,
+      variant: I,
+      disabled: E,
+      mod: [{ disabled: E || k }, F],
+      ...A("root", { variant: I, active: !E && !k }),
+      children: [
+        y || /* @__PURE__ */ j(Et, {}),
+        i
+      ]
+    }
+  );
+});
+Ke.classes = Ct;
+Ke.displayName = "@mantine/core/CloseButton";
+const [ss, is] = yt({
+  size: "sm"
+}), rs = {}, bt = ye((n, e) => {
+  const t = Z("InputClearButton", rs, n), { size: s, variant: i, vars: r, classNames: a, styles: u, ...o } = t, l = is(), { resolvedClassNames: p, resolvedStyles: d } = Qt({
+    classNames: a,
+    styles: u,
+    props: t
+  });
+  return /* @__PURE__ */ j(
+    Ke,
+    {
+      variant: i || "transparent",
+      ref: e,
+      size: s || (l == null ? void 0 : l.size) || "sm",
+      classNames: p,
+      styles: d,
+      __staticSelector: "InputClearButton",
+      ...o
+    }
+  );
+});
+bt.displayName = "@mantine/core/InputClearButton";
+const [ns, Ie] = yt({
+  offsetBottom: !1,
+  offsetTop: !1,
+  describedBy: void 0,
+  getStyles: null,
+  inputId: void 0,
+  labelId: void 0
+});
+var J = { wrapper: "m_6c018570", input: "m_8fb7ebe7", section: "m_82577fc2", placeholder: "m_88bacfd0", root: "m_46b77525", label: "m_8fdc1311", required: "m_78a94662", error: "m_8f816625", description: "m_fe47ce59" };
+const st = {}, as = ke((n, { size: e }) => ({
+  description: {
+    "--input-description-size": e === void 0 ? void 0 : `calc(${me(e)} - ${_e(2)})`
+  }
+})), Te = ye((n, e) => {
+  const t = Z("InputDescription", st, n), {
+    classNames: s,
+    className: i,
+    style: r,
+    styles: a,
+    unstyled: u,
+    vars: o,
+    size: l,
+    __staticSelector: p,
+    __inheritStyles: d = !0,
+    variant: k,
+    ...E
+  } = Z("InputDescription", st, t), I = Ie(), y = ge({
+    name: ["InputWrapper", p],
+    props: t,
+    classes: J,
+    className: i,
+    style: r,
+    classNames: s,
+    styles: a,
+    unstyled: u,
+    rootSelector: "description",
+    vars: o,
+    varsResolver: as
+  }), F = d && (I == null ? void 0 : I.getStyles) || y;
+  return /* @__PURE__ */ j(
+    ve,
+    {
+      component: "p",
+      ref: e,
+      variant: k,
+      size: l,
+      ...F("description", I != null && I.getStyles ? { className: i, style: r } : void 0),
+      ...E
+    }
+  );
+});
+Te.classes = J;
+Te.displayName = "@mantine/core/InputDescription";
+const us = {}, os = ke((n, { size: e }) => ({
+  error: {
+    "--input-error-size": e === void 0 ? void 0 : `calc(${me(e)} - ${_e(2)})`
+  }
+})), we = ye((n, e) => {
+  const t = Z("InputError", us, n), {
+    classNames: s,
+    className: i,
+    style: r,
+    styles: a,
+    unstyled: u,
+    vars: o,
+    size: l,
+    __staticSelector: p,
+    __inheritStyles: d = !0,
+    variant: k,
+    ...E
+  } = t, I = ge({
+    name: ["InputWrapper", p],
+    props: t,
+    classes: J,
+    className: i,
+    style: r,
+    classNames: s,
+    styles: a,
+    unstyled: u,
+    rootSelector: "error",
+    vars: o,
+    varsResolver: os
+  }), y = Ie(), F = d && (y == null ? void 0 : y.getStyles) || I;
+  return /* @__PURE__ */ j(
+    ve,
+    {
+      component: "p",
+      ref: e,
+      variant: k,
+      size: l,
+      ...F("error", y != null && y.getStyles ? { className: i, style: r } : void 0),
+      ...E
+    }
+  );
+});
+we.classes = J;
+we.displayName = "@mantine/core/InputError";
+const it = {
+  labelElement: "label"
+}, ls = ke((n, { size: e }) => ({
+  label: {
+    "--input-label-size": me(e),
+    "--input-asterisk-color": void 0
+  }
+})), Re = ye((n, e) => {
+  const t = Z("InputLabel", it, n), {
+    classNames: s,
+    className: i,
+    style: r,
+    styles: a,
+    unstyled: u,
+    vars: o,
+    labelElement: l,
+    size: p,
+    required: d,
+    htmlFor: k,
+    onMouseDown: E,
+    children: I,
+    __staticSelector: y,
+    variant: F,
+    mod: N,
+    ...L
+  } = Z("InputLabel", it, t), A = ge({
+    name: ["InputWrapper", y],
+    props: t,
+    classes: J,
+    className: i,
+    style: r,
+    classNames: s,
+    styles: a,
+    unstyled: u,
+    rootSelector: "label",
+    vars: o,
+    varsResolver: ls
+  }), D = Ie(), c = (D == null ? void 0 : D.getStyles) || A;
+  return /* @__PURE__ */ He(
+    ve,
+    {
+      ...c("label", D != null && D.getStyles ? { className: i, style: r } : void 0),
+      component: l,
+      variant: F,
+      size: p,
+      ref: e,
+      htmlFor: l === "label" ? k : void 0,
+      mod: [{ required: d }, N],
+      onMouseDown: ($) => {
+        E == null || E($), !$.defaultPrevented && $.detail > 1 && $.preventDefault();
+      },
+      ...L,
+      children: [
+        I,
+        d && /* @__PURE__ */ j("span", { ...c("required"), "aria-hidden": !0, children: " *" })
+      ]
+    }
+  );
+});
+Re.classes = J;
+Re.displayName = "@mantine/core/InputLabel";
+const rt = {}, Ge = ye((n, e) => {
+  const t = Z("InputPlaceholder", rt, n), {
+    classNames: s,
+    className: i,
+    style: r,
+    styles: a,
+    unstyled: u,
+    vars: o,
+    __staticSelector: l,
+    variant: p,
+    error: d,
+    mod: k,
+    ...E
+  } = Z("InputPlaceholder", rt, t), I = ge({
+    name: ["InputPlaceholder", l],
+    props: t,
+    classes: J,
+    className: i,
+    style: r,
+    classNames: s,
+    styles: a,
+    unstyled: u,
+    rootSelector: "placeholder"
+  });
+  return /* @__PURE__ */ j(
+    ve,
+    {
+      ...I("placeholder"),
+      mod: [{ error: !!d }, k],
+      component: "span",
+      variant: p,
+      ref: e,
+      ...E
+    }
+  );
+});
+Ge.classes = J;
+Ge.displayName = "@mantine/core/InputPlaceholder";
+function hs(n, { hasDescription: e, hasError: t }) {
+  const s = n.findIndex((o) => o === "input"), i = n.slice(0, s), r = n.slice(s + 1), a = e && i.includes("description") || t && i.includes("error");
+  return { offsetBottom: e && r.includes("description") || t && r.includes("error"), offsetTop: a };
+}
+const cs = {
+  labelElement: "label",
+  inputContainer: (n) => n,
+  inputWrapperOrder: ["label", "description", "input", "error"]
+}, ps = ke((n, { size: e }) => ({
+  label: {
+    "--input-label-size": me(e),
+    "--input-asterisk-color": void 0
+  },
+  error: {
+    "--input-error-size": e === void 0 ? void 0 : `calc(${me(e)} - ${_e(2)})`
+  },
+  description: {
+    "--input-description-size": e === void 0 ? void 0 : `calc(${me(e)} - ${_e(2)})`
+  }
+})), Ze = ye((n, e) => {
+  const t = Z("InputWrapper", cs, n), {
+    classNames: s,
+    className: i,
+    style: r,
+    styles: a,
+    unstyled: u,
+    vars: o,
+    size: l,
+    variant: p,
+    __staticSelector: d,
+    inputContainer: k,
+    inputWrapperOrder: E,
+    label: I,
+    error: y,
+    description: F,
+    labelProps: N,
+    descriptionProps: L,
+    errorProps: A,
+    labelElement: D,
+    children: c,
+    withAsterisk: $,
+    id: Q,
+    required: ee,
+    __stylesApiProps: he,
+    mod: re,
+    ...ne
+  } = t, te = ge({
+    name: ["InputWrapper", d],
+    props: he || t,
+    classes: J,
+    className: i,
+    style: r,
+    classNames: s,
+    styles: a,
+    unstyled: u,
+    vars: o,
+    varsResolver: ps
+  }), W = {
+    size: l,
+    variant: p,
+    __staticSelector: d
+  }, U = Jt(Q), de = typeof $ == "boolean" ? $ : ee, Y = (A == null ? void 0 : A.id) || `${U}-error`, G = (L == null ? void 0 : L.id) || `${U}-description`, ae = U, ue = !!y && typeof y != "boolean", h = !!F, m = `${ue ? Y : ""} ${h ? G : ""}`, w = m.trim().length > 0 ? m.trim() : void 0, g = (N == null ? void 0 : N.id) || `${U}-label`, b = I && /* @__PURE__ */ j(
+    Re,
+    {
+      labelElement: D,
+      id: g,
+      htmlFor: ae,
+      required: de,
+      ...W,
+      ...N,
+      children: I
+    },
+    "label"
+  ), R = h && /* @__PURE__ */ j(
+    Te,
+    {
+      ...L,
+      ...W,
+      size: (L == null ? void 0 : L.size) || W.size,
+      id: (L == null ? void 0 : L.id) || G,
+      children: F
+    },
+    "description"
+  ), x = /* @__PURE__ */ j(jt, { children: k(c) }, "input"), S = ue && /* @__PURE__ */ $t(
+    we,
+    {
+      ...A,
+      ...W,
+      size: (A == null ? void 0 : A.size) || W.size,
+      key: "error",
+      id: (A == null ? void 0 : A.id) || Y
+    },
+    y
+  ), B = E.map((O) => {
+    switch (O) {
+      case "label":
+        return b;
+      case "input":
+        return x;
+      case "description":
+        return R;
+      case "error":
+        return S;
+      default:
+        return null;
+    }
+  });
+  return /* @__PURE__ */ j(
+    ns,
+    {
+      value: {
+        getStyles: te,
+        describedBy: w,
+        inputId: ae,
+        labelId: g,
+        ...hs(E, { hasDescription: h, hasError: ue })
+      },
+      children: /* @__PURE__ */ j(
+        ve,
+        {
+          ref: e,
+          variant: p,
+          size: l,
+          mod: [{ error: !!y }, re],
+          ...te("root"),
+          ...ne,
+          children: B
+        }
+      )
+    }
+  );
+});
+Ze.classes = J;
+Ze.displayName = "@mantine/core/InputWrapper";
+const ds = {
+  variant: "default",
+  leftSectionPointerEvents: "none",
+  rightSectionPointerEvents: "none",
+  withAria: !0,
+  withErrorStyles: !0
+}, fs = ke((n, e, t) => ({
+  wrapper: {
+    "--input-margin-top": t.offsetTop ? "calc(var(--mantine-spacing-xs) / 2)" : void 0,
+    "--input-margin-bottom": t.offsetBottom ? "calc(var(--mantine-spacing-xs) / 2)" : void 0,
+    "--input-height": qe(e.size, "input-height"),
+    "--input-fz": me(e.size),
+    "--input-radius": e.radius === void 0 ? void 0 : gt(e.radius),
+    "--input-left-section-width": e.leftSectionWidth !== void 0 ? _e(e.leftSectionWidth) : void 0,
+    "--input-right-section-width": e.rightSectionWidth !== void 0 ? _e(e.rightSectionWidth) : void 0,
+    "--input-padding-y": e.multiline ? qe(e.size, "input-padding-y") : void 0,
+    "--input-left-section-pointer-events": e.leftSectionPointerEvents,
+    "--input-right-section-pointer-events": e.rightSectionPointerEvents
+  }
+})), X = We((n, e) => {
+  const t = Z("Input", ds, n), {
+    classNames: s,
+    className: i,
+    style: r,
+    styles: a,
+    unstyled: u,
+    required: o,
+    __staticSelector: l,
+    __stylesApiProps: p,
+    size: d,
+    wrapperProps: k,
+    error: E,
+    disabled: I,
+    leftSection: y,
+    leftSectionProps: F,
+    leftSectionWidth: N,
+    rightSection: L,
+    rightSectionProps: A,
+    rightSectionWidth: D,
+    rightSectionPointerEvents: c,
+    leftSectionPointerEvents: $,
+    variant: Q,
+    vars: ee,
+    pointer: he,
+    multiline: re,
+    radius: ne,
+    id: te,
+    withAria: W,
+    withErrorStyles: U,
+    mod: de,
+    inputSize: Y,
+    __clearSection: G,
+    __clearable: ae,
+    __defaultRightSection: ue,
+    ...h
+  } = t, { styleProps: m, rest: w } = kt(h), g = Ie(), b = { offsetBottom: g == null ? void 0 : g.offsetBottom, offsetTop: g == null ? void 0 : g.offsetTop }, R = ge({
+    name: ["Input", l],
+    props: p || t,
+    classes: J,
+    className: i,
+    style: r,
+    classNames: s,
+    styles: a,
+    unstyled: u,
+    stylesCtx: b,
+    rootSelector: "wrapper",
+    vars: ee,
+    varsResolver: fs
+  }), x = W ? {
+    required: o,
+    disabled: I,
+    "aria-invalid": !!E,
+    "aria-describedby": g == null ? void 0 : g.describedBy,
+    id: (g == null ? void 0 : g.inputId) || te
+  } : {}, S = L || ae && G || ue;
+  return /* @__PURE__ */ j(ss, { value: { size: d || "sm" }, children: /* @__PURE__ */ He(
+    ve,
+    {
+      ...R("wrapper"),
+      ...m,
+      ...k,
+      mod: [
+        {
+          error: !!E && U,
+          pointer: he,
+          disabled: I,
+          multiline: re,
+          "data-with-right-section": !!S,
+          "data-with-left-section": !!y
+        },
+        de
+      ],
+      variant: Q,
+      size: d,
+      children: [
+        y && /* @__PURE__ */ j(
+          "div",
+          {
+            ...F,
+            "data-position": "left",
+            ...R("section", {
+              className: F == null ? void 0 : F.className,
+              style: F == null ? void 0 : F.style
+            }),
+            children: y
+          }
+        ),
+        /* @__PURE__ */ j(
+          ve,
+          {
+            component: "input",
+            ...w,
+            ...x,
+            ref: e,
+            required: o,
+            mod: { disabled: I, error: !!E && U },
+            variant: Q,
+            __size: Y,
+            ...R("input")
+          }
+        ),
+        S && /* @__PURE__ */ j(
+          "div",
+          {
+            ...A,
+            "data-position": "right",
+            ...R("section", {
+              className: A == null ? void 0 : A.className,
+              style: A == null ? void 0 : A.style
+            }),
+            children: S
+          }
+        )
+      ]
+    }
+  ) });
+});
+X.classes = J;
+X.Wrapper = Ze;
+X.Label = Re;
+X.Error = we;
+X.Description = Te;
+X.Placeholder = Ge;
+X.ClearButton = bt;
+X.displayName = "@mantine/core/Input";
+function ms(n, e, t) {
+  const s = Z(n, e, t), {
+    label: i,
+    description: r,
+    error: a,
+    required: u,
+    classNames: o,
+    styles: l,
+    className: p,
+    unstyled: d,
+    __staticSelector: k,
+    __stylesApiProps: E,
+    errorProps: I,
+    labelProps: y,
+    descriptionProps: F,
+    wrapperProps: N,
+    id: L,
+    size: A,
+    style: D,
+    inputContainer: c,
+    inputWrapperOrder: $,
+    withAsterisk: Q,
+    variant: ee,
+    vars: he,
+    mod: re,
+    ...ne
+  } = s, { styleProps: te, rest: W } = kt(ne), U = {
+    label: i,
+    description: r,
+    error: a,
+    required: u,
+    classNames: o,
+    className: p,
+    __staticSelector: k,
+    __stylesApiProps: E || s,
+    errorProps: I,
+    labelProps: y,
+    descriptionProps: F,
+    unstyled: d,
+    styles: l,
+    size: A,
+    style: D,
+    inputContainer: c,
+    inputWrapperOrder: $,
+    withAsterisk: Q,
+    variant: ee,
+    id: L,
+    mod: re,
+    ...N
+  };
+  return {
+    ...W,
+    classNames: o,
+    styles: l,
+    unstyled: d,
+    wrapperProps: { ...U, ...te },
+    inputProps: {
+      required: u,
+      classNames: o,
+      styles: l,
+      unstyled: d,
+      size: A,
+      __staticSelector: k,
+      __stylesApiProps: E || s,
+      error: a,
+      variant: ee,
+      id: L
+    }
+  };
+}
+const vs = {
+  __staticSelector: "InputBase",
+  withAria: !0
+}, Xe = We((n, e) => {
+  const { inputProps: t, wrapperProps: s, ...i } = ms("InputBase", vs, n);
+  return /* @__PURE__ */ j(X.Wrapper, { ...s, children: /* @__PURE__ */ j(X, { ...t, ...i, ref: e }) });
+});
+Xe.classes = { ...X.classes, ...X.Wrapper.classes };
+Xe.displayName = "@mantine/core/InputBase";
+function pe(n) {
+  return typeof n == "string" || n instanceof String;
+}
+function nt(n) {
+  var e;
+  return typeof n == "object" && n != null && (n == null || (e = n.constructor) == null ? void 0 : e.name) === "Object";
+}
+function At(n, e) {
+  return Array.isArray(e) ? At(n, (t, s) => e.includes(s)) : Object.entries(n).reduce((t, s) => {
+    let [i, r] = s;
+    return e(r, i) && (t[i] = r), t;
+  }, {});
+}
+const _ = {
+  NONE: "NONE",
+  LEFT: "LEFT",
+  FORCE_LEFT: "FORCE_LEFT",
+  RIGHT: "RIGHT",
+  FORCE_RIGHT: "FORCE_RIGHT"
+};
+function _s(n) {
+  switch (n) {
+    case _.LEFT:
+      return _.FORCE_LEFT;
+    case _.RIGHT:
+      return _.FORCE_RIGHT;
+    default:
+      return n;
+  }
+}
+function Ve(n) {
+  return n.replace(/([.*+?^=!:${}()|[\]/\\])/g, "\\$1");
+}
+function Fe(n, e) {
+  if (e === n) return !0;
+  const t = Array.isArray(e), s = Array.isArray(n);
+  let i;
+  if (t && s) {
+    if (e.length != n.length) return !1;
+    for (i = 0; i < e.length; i++) if (!Fe(e[i], n[i])) return !1;
+    return !0;
+  }
+  if (t != s) return !1;
+  if (e && n && typeof e == "object" && typeof n == "object") {
+    const r = e instanceof Date, a = n instanceof Date;
+    if (r && a) return e.getTime() == n.getTime();
+    if (r != a) return !1;
+    const u = e instanceof RegExp, o = n instanceof RegExp;
+    if (u && o) return e.toString() == n.toString();
+    if (u != o) return !1;
+    const l = Object.keys(e);
+    for (i = 0; i < l.length; i++) if (!Object.prototype.hasOwnProperty.call(n, l[i])) return !1;
+    for (i = 0; i < l.length; i++) if (!Fe(n[l[i]], e[l[i]])) return !1;
+    return !0;
+  } else if (e && n && typeof e == "function" && typeof n == "function")
+    return e.toString() === n.toString();
+  return !1;
+}
+class gs {
+  /** Current input value */
+  /** Current cursor position */
+  /** Old input value */
+  /** Old selection */
+  constructor(e) {
+    for (Object.assign(this, e); this.value.slice(0, this.startChangePos) !== this.oldValue.slice(0, this.startChangePos); )
+      --this.oldSelection.start;
+    if (this.insertedCount)
+      for (; this.value.slice(this.cursorPos) !== this.oldValue.slice(this.oldSelection.end); )
+        this.value.length - this.cursorPos < this.oldValue.length - this.oldSelection.end ? ++this.oldSelection.end : ++this.cursorPos;
+  }
+  /** Start changing position */
+  get startChangePos() {
+    return Math.min(this.cursorPos, this.oldSelection.start);
+  }
+  /** Inserted symbols count */
+  get insertedCount() {
+    return this.cursorPos - this.startChangePos;
+  }
+  /** Inserted symbols */
+  get inserted() {
+    return this.value.substr(this.startChangePos, this.insertedCount);
+  }
+  /** Removed symbols count */
+  get removedCount() {
+    return Math.max(this.oldSelection.end - this.startChangePos || // for Delete
+    this.oldValue.length - this.value.length, 0);
+  }
+  /** Removed symbols */
+  get removed() {
+    return this.oldValue.substr(this.startChangePos, this.removedCount);
+  }
+  /** Unchanged head symbols */
+  get head() {
+    return this.value.substring(0, this.startChangePos);
+  }
+  /** Unchanged tail symbols */
+  get tail() {
+    return this.value.substring(this.startChangePos + this.insertedCount);
+  }
+  /** Remove direction */
+  get removeDirection() {
+    return !this.removedCount || this.insertedCount ? _.NONE : (this.oldSelection.end === this.cursorPos || this.oldSelection.start === this.cursorPos) && // if not range removed (event with backspace)
+    this.oldSelection.end === this.oldSelection.start ? _.RIGHT : _.LEFT;
+  }
+}
+function C(n, e) {
+  return new C.InputMask(n, e);
+}
+function St(n) {
+  if (n == null) throw new Error("mask property should be defined");
+  return n instanceof RegExp ? C.MaskedRegExp : pe(n) ? C.MaskedPattern : n === Date ? C.MaskedDate : n === Number ? C.MaskedNumber : Array.isArray(n) || n === Array ? C.MaskedDynamic : C.Masked && n.prototype instanceof C.Masked ? n : C.Masked && n instanceof C.Masked ? n.constructor : n instanceof Function ? C.MaskedFunction : (console.warn("Mask not found for mask", n), C.Masked);
+}
+function Ee(n) {
+  if (!n) throw new Error("Options in not defined");
+  if (C.Masked) {
+    if (n.prototype instanceof C.Masked) return {
+      mask: n
+    };
+    const {
+      mask: e = void 0,
+      ...t
+    } = n instanceof C.Masked ? {
+      mask: n
+    } : nt(n) && n.mask instanceof C.Masked ? n : {};
+    if (e) {
+      const s = e.mask;
+      return {
+        ...At(e, (i, r) => !r.startsWith("_")),
+        mask: e.constructor,
+        _mask: s,
+        ...t
+      };
+    }
+  }
+  return nt(n) ? {
+    ...n
+  } : {
+    mask: n
+  };
+}
+function le(n) {
+  if (C.Masked && n instanceof C.Masked) return n;
+  const e = Ee(n), t = St(e.mask);
+  if (!t) throw new Error("Masked class is not found for provided mask " + e.mask + ", appropriate module needs to be imported manually before creating mask.");
+  return e.mask === t && delete e.mask, e._mask && (e.mask = e._mask, delete e._mask), new t(e);
+}
+C.createMask = le;
+class Je {
+  /** */
+  /** */
+  /** */
+  /** Safely returns selection start */
+  get selectionStart() {
+    let e;
+    try {
+      e = this._unsafeSelectionStart;
+    } catch {
+    }
+    return e ?? this.value.length;
+  }
+  /** Safely returns selection end */
+  get selectionEnd() {
+    let e;
+    try {
+      e = this._unsafeSelectionEnd;
+    } catch {
+    }
+    return e ?? this.value.length;
+  }
+  /** Safely sets element selection */
+  select(e, t) {
+    if (!(e == null || t == null || e === this.selectionStart && t === this.selectionEnd))
+      try {
+        this._unsafeSelect(e, t);
+      } catch {
+      }
+  }
+  /** */
+  get isActive() {
+    return !1;
+  }
+  /** */
+  /** */
+  /** */
+}
+C.MaskElement = Je;
+const at = 90, ks = 89;
+class Be extends Je {
+  /** HTMLElement to use mask on */
+  constructor(e) {
+    super(), this.input = e, this._onKeydown = this._onKeydown.bind(this), this._onInput = this._onInput.bind(this), this._onBeforeinput = this._onBeforeinput.bind(this), this._onCompositionEnd = this._onCompositionEnd.bind(this);
+  }
+  get rootElement() {
+    var e, t, s;
+    return (e = (t = (s = this.input).getRootNode) == null ? void 0 : t.call(s)) != null ? e : document;
+  }
+  /** Is element in focus */
+  get isActive() {
+    return this.input === this.rootElement.activeElement;
+  }
+  /** Binds HTMLElement events to mask internal events */
+  bindEvents(e) {
+    this.input.addEventListener("keydown", this._onKeydown), this.input.addEventListener("input", this._onInput), this.input.addEventListener("beforeinput", this._onBeforeinput), this.input.addEventListener("compositionend", this._onCompositionEnd), this.input.addEventListener("drop", e.drop), this.input.addEventListener("click", e.click), this.input.addEventListener("focus", e.focus), this.input.addEventListener("blur", e.commit), this._handlers = e;
+  }
+  _onKeydown(e) {
+    if (this._handlers.redo && (e.keyCode === at && e.shiftKey && (e.metaKey || e.ctrlKey) || e.keyCode === ks && e.ctrlKey))
+      return e.preventDefault(), this._handlers.redo(e);
+    if (this._handlers.undo && e.keyCode === at && (e.metaKey || e.ctrlKey))
+      return e.preventDefault(), this._handlers.undo(e);
+    e.isComposing || this._handlers.selectionChange(e);
+  }
+  _onBeforeinput(e) {
+    if (e.inputType === "historyUndo" && this._handlers.undo)
+      return e.preventDefault(), this._handlers.undo(e);
+    if (e.inputType === "historyRedo" && this._handlers.redo)
+      return e.preventDefault(), this._handlers.redo(e);
+  }
+  _onCompositionEnd(e) {
+    this._handlers.input(e);
+  }
+  _onInput(e) {
+    e.isComposing || this._handlers.input(e);
+  }
+  /** Unbinds HTMLElement events to mask internal events */
+  unbindEvents() {
+    this.input.removeEventListener("keydown", this._onKeydown), this.input.removeEventListener("input", this._onInput), this.input.removeEventListener("beforeinput", this._onBeforeinput), this.input.removeEventListener("compositionend", this._onCompositionEnd), this.input.removeEventListener("drop", this._handlers.drop), this.input.removeEventListener("click", this._handlers.click), this.input.removeEventListener("focus", this._handlers.focus), this.input.removeEventListener("blur", this._handlers.commit), this._handlers = {};
+  }
+}
+C.HTMLMaskElement = Be;
+class ys extends Be {
+  /** InputElement to use mask on */
+  constructor(e) {
+    super(e), this.input = e;
+  }
+  /** Returns InputElement selection start */
+  get _unsafeSelectionStart() {
+    return this.input.selectionStart != null ? this.input.selectionStart : this.value.length;
+  }
+  /** Returns InputElement selection end */
+  get _unsafeSelectionEnd() {
+    return this.input.selectionEnd;
+  }
+  /** Sets InputElement selection */
+  _unsafeSelect(e, t) {
+    this.input.setSelectionRange(e, t);
+  }
+  get value() {
+    return this.input.value;
+  }
+  set value(e) {
+    this.input.value = e;
+  }
+}
+C.HTMLMaskElement = Be;
+class Ft extends Be {
+  /** Returns HTMLElement selection start */
+  get _unsafeSelectionStart() {
+    const e = this.rootElement, t = e.getSelection && e.getSelection(), s = t && t.anchorOffset, i = t && t.focusOffset;
+    return i == null || s == null || s < i ? s : i;
+  }
+  /** Returns HTMLElement selection end */
+  get _unsafeSelectionEnd() {
+    const e = this.rootElement, t = e.getSelection && e.getSelection(), s = t && t.anchorOffset, i = t && t.focusOffset;
+    return i == null || s == null || s > i ? s : i;
+  }
+  /** Sets HTMLElement selection */
+  _unsafeSelect(e, t) {
+    if (!this.rootElement.createRange) return;
+    const s = this.rootElement.createRange();
+    s.setStart(this.input.firstChild || this.input, e), s.setEnd(this.input.lastChild || this.input, t);
+    const i = this.rootElement, r = i.getSelection && i.getSelection();
+    r && (r.removeAllRanges(), r.addRange(s));
+  }
+  /** HTMLElement value */
+  get value() {
+    return this.input.textContent || "";
+  }
+  set value(e) {
+    this.input.textContent = e;
+  }
+}
+C.HTMLContenteditableMaskElement = Ft;
+class Me {
+  constructor() {
+    this.states = [], this.currentIndex = 0;
+  }
+  get currentState() {
+    return this.states[this.currentIndex];
+  }
+  get isEmpty() {
+    return this.states.length === 0;
+  }
+  push(e) {
+    this.currentIndex < this.states.length - 1 && (this.states.length = this.currentIndex + 1), this.states.push(e), this.states.length > Me.MAX_LENGTH && this.states.shift(), this.currentIndex = this.states.length - 1;
+  }
+  go(e) {
+    return this.currentIndex = Math.min(Math.max(this.currentIndex + e, 0), this.states.length - 1), this.currentState;
+  }
+  undo() {
+    return this.go(-1);
+  }
+  redo() {
+    return this.go(1);
+  }
+  clear() {
+    this.states.length = 0, this.currentIndex = 0;
+  }
+}
+Me.MAX_LENGTH = 100;
+class Es {
+  /**
+    View element
+  */
+  /** Internal {@link Masked} model */
+  constructor(e, t) {
+    this.el = e instanceof Je ? e : e.isContentEditable && e.tagName !== "INPUT" && e.tagName !== "TEXTAREA" ? new Ft(e) : new ys(e), this.masked = le(t), this._listeners = {}, this._value = "", this._unmaskedValue = "", this._rawInputValue = "", this.history = new Me(), this._saveSelection = this._saveSelection.bind(this), this._onInput = this._onInput.bind(this), this._onChange = this._onChange.bind(this), this._onDrop = this._onDrop.bind(this), this._onFocus = this._onFocus.bind(this), this._onClick = this._onClick.bind(this), this._onUndo = this._onUndo.bind(this), this._onRedo = this._onRedo.bind(this), this.alignCursor = this.alignCursor.bind(this), this.alignCursorFriendly = this.alignCursorFriendly.bind(this), this._bindEvents(), this.updateValue(), this._onChange();
+  }
+  maskEquals(e) {
+    var t;
+    return e == null || ((t = this.masked) == null ? void 0 : t.maskEquals(e));
+  }
+  /** Masked */
+  get mask() {
+    return this.masked.mask;
+  }
+  set mask(e) {
+    if (this.maskEquals(e)) return;
+    if (!(e instanceof C.Masked) && this.masked.constructor === St(e)) {
+      this.masked.updateOptions({
+        mask: e
+      });
+      return;
+    }
+    const t = e instanceof C.Masked ? e : le({
+      mask: e
+    });
+    t.unmaskedValue = this.masked.unmaskedValue, this.masked = t;
+  }
+  /** Raw value */
+  get value() {
+    return this._value;
+  }
+  set value(e) {
+    this.value !== e && (this.masked.value = e, this.updateControl("auto"));
+  }
+  /** Unmasked value */
+  get unmaskedValue() {
+    return this._unmaskedValue;
+  }
+  set unmaskedValue(e) {
+    this.unmaskedValue !== e && (this.masked.unmaskedValue = e, this.updateControl("auto"));
+  }
+  /** Raw input value */
+  get rawInputValue() {
+    return this._rawInputValue;
+  }
+  set rawInputValue(e) {
+    this.rawInputValue !== e && (this.masked.rawInputValue = e, this.updateControl(), this.alignCursor());
+  }
+  /** Typed unmasked value */
+  get typedValue() {
+    return this.masked.typedValue;
+  }
+  set typedValue(e) {
+    this.masked.typedValueEquals(e) || (this.masked.typedValue = e, this.updateControl("auto"));
+  }
+  /** Display value */
+  get displayValue() {
+    return this.masked.displayValue;
+  }
+  /** Starts listening to element events */
+  _bindEvents() {
+    this.el.bindEvents({
+      selectionChange: this._saveSelection,
+      input: this._onInput,
+      drop: this._onDrop,
+      click: this._onClick,
+      focus: this._onFocus,
+      commit: this._onChange,
+      undo: this._onUndo,
+      redo: this._onRedo
+    });
+  }
+  /** Stops listening to element events */
+  _unbindEvents() {
+    this.el && this.el.unbindEvents();
+  }
+  /** Fires custom event */
+  _fireEvent(e, t) {
+    const s = this._listeners[e];
+    s && s.forEach((i) => i(t));
+  }
+  /** Current selection start */
+  get selectionStart() {
+    return this._cursorChanging ? this._changingCursorPos : this.el.selectionStart;
+  }
+  /** Current cursor position */
+  get cursorPos() {
+    return this._cursorChanging ? this._changingCursorPos : this.el.selectionEnd;
+  }
+  set cursorPos(e) {
+    !this.el || !this.el.isActive || (this.el.select(e, e), this._saveSelection());
+  }
+  /** Stores current selection */
+  _saveSelection() {
+    this.displayValue !== this.el.value && console.warn("Element value was changed outside of mask. Syncronize mask using `mask.updateValue()` to work properly."), this._selection = {
+      start: this.selectionStart,
+      end: this.cursorPos
+    };
+  }
+  /** Syncronizes model value from view */
+  updateValue() {
+    this.masked.value = this.el.value, this._value = this.masked.value, this._unmaskedValue = this.masked.unmaskedValue, this._rawInputValue = this.masked.rawInputValue;
+  }
+  /** Syncronizes view from model value, fires change events */
+  updateControl(e) {
+    const t = this.masked.unmaskedValue, s = this.masked.value, i = this.masked.rawInputValue, r = this.displayValue, a = this.unmaskedValue !== t || this.value !== s || this._rawInputValue !== i;
+    this._unmaskedValue = t, this._value = s, this._rawInputValue = i, this.el.value !== r && (this.el.value = r), e === "auto" ? this.alignCursor() : e != null && (this.cursorPos = e), a && this._fireChangeEvents(), !this._historyChanging && (a || this.history.isEmpty) && this.history.push({
+      unmaskedValue: t,
+      selection: {
+        start: this.selectionStart,
+        end: this.cursorPos
+      }
+    });
+  }
+  /** Updates options with deep equal check, recreates {@link Masked} model if mask type changes */
+  updateOptions(e) {
+    const {
+      mask: t,
+      ...s
+    } = e, i = !this.maskEquals(t), r = this.masked.optionsIsChanged(s);
+    i && (this.mask = t), r && this.masked.updateOptions(s), (i || r) && this.updateControl();
+  }
+  /** Updates cursor */
+  updateCursor(e) {
+    e != null && (this.cursorPos = e, this._delayUpdateCursor(e));
+  }
+  /** Delays cursor update to support mobile browsers */
+  _delayUpdateCursor(e) {
+    this._abortUpdateCursor(), this._changingCursorPos = e, this._cursorChanging = setTimeout(() => {
+      this.el && (this.cursorPos = this._changingCursorPos, this._abortUpdateCursor());
+    }, 10);
+  }
+  /** Fires custom events */
+  _fireChangeEvents() {
+    this._fireEvent("accept", this._inputEvent), this.masked.isComplete && this._fireEvent("complete", this._inputEvent);
+  }
+  /** Aborts delayed cursor update */
+  _abortUpdateCursor() {
+    this._cursorChanging && (clearTimeout(this._cursorChanging), delete this._cursorChanging);
+  }
+  /** Aligns cursor to nearest available position */
+  alignCursor() {
+    this.cursorPos = this.masked.nearestInputPos(this.masked.nearestInputPos(this.cursorPos, _.LEFT));
+  }
+  /** Aligns cursor only if selection is empty */
+  alignCursorFriendly() {
+    this.selectionStart === this.cursorPos && this.alignCursor();
+  }
+  /** Adds listener on custom event */
+  on(e, t) {
+    return this._listeners[e] || (this._listeners[e] = []), this._listeners[e].push(t), this;
+  }
+  /** Removes custom event listener */
+  off(e, t) {
+    if (!this._listeners[e]) return this;
+    if (!t)
+      return delete this._listeners[e], this;
+    const s = this._listeners[e].indexOf(t);
+    return s >= 0 && this._listeners[e].splice(s, 1), this;
+  }
+  /** Handles view input event */
+  _onInput(e) {
+    this._inputEvent = e, this._abortUpdateCursor();
+    const t = new gs({
+      // new state
+      value: this.el.value,
+      cursorPos: this.cursorPos,
+      // old state
+      oldValue: this.displayValue,
+      oldSelection: this._selection
+    }), s = this.masked.rawInputValue, i = this.masked.splice(t.startChangePos, t.removed.length, t.inserted, t.removeDirection, {
+      input: !0,
+      raw: !0
+    }).offset, r = s === this.masked.rawInputValue ? t.removeDirection : _.NONE;
+    let a = this.masked.nearestInputPos(t.startChangePos + i, r);
+    r !== _.NONE && (a = this.masked.nearestInputPos(a, _.NONE)), this.updateControl(a), delete this._inputEvent;
+  }
+  /** Handles view change event and commits model value */
+  _onChange() {
+    this.displayValue !== this.el.value && this.updateValue(), this.masked.doCommit(), this.updateControl(), this._saveSelection();
+  }
+  /** Handles view drop event, prevents by default */
+  _onDrop(e) {
+    e.preventDefault(), e.stopPropagation();
+  }
+  /** Restore last selection on focus */
+  _onFocus(e) {
+    this.alignCursorFriendly();
+  }
+  /** Restore last selection on focus */
+  _onClick(e) {
+    this.alignCursorFriendly();
+  }
+  _onUndo() {
+    this._applyHistoryState(this.history.undo());
+  }
+  _onRedo() {
+    this._applyHistoryState(this.history.redo());
+  }
+  _applyHistoryState(e) {
+    e && (this._historyChanging = !0, this.unmaskedValue = e.unmaskedValue, this.el.select(e.selection.start, e.selection.end), this._saveSelection(), this._historyChanging = !1);
+  }
+  /** Unbind view events and removes element reference */
+  destroy() {
+    this._unbindEvents(), this._listeners.length = 0, delete this.el;
+  }
+}
+C.InputMask = Es;
+class T {
+  /** Inserted symbols */
+  /** Additional offset if any changes occurred before tail */
+  /** Raw inserted is used by dynamic mask */
+  /** Can skip chars */
+  static normalize(e) {
+    return Array.isArray(e) ? e : [e, new T()];
+  }
+  constructor(e) {
+    Object.assign(this, {
+      inserted: "",
+      rawInserted: "",
+      tailShift: 0,
+      skip: !1
+    }, e);
+  }
+  /** Aggregate changes */
+  aggregate(e) {
+    return this.inserted += e.inserted, this.rawInserted += e.rawInserted, this.tailShift += e.tailShift, this.skip = this.skip || e.skip, this;
+  }
+  /** Total offset considering all changes */
+  get offset() {
+    return this.tailShift + this.inserted.length;
+  }
+  get consumed() {
+    return !!this.rawInserted || this.skip;
+  }
+  equals(e) {
+    return this.inserted === e.inserted && this.tailShift === e.tailShift && this.rawInserted === e.rawInserted && this.skip === e.skip;
+  }
+}
+C.ChangeDetails = T;
+class ie {
+  /** Tail value as string */
+  /** Tail start position */
+  /** Start position */
+  constructor(e, t, s) {
+    e === void 0 && (e = ""), t === void 0 && (t = 0), this.value = e, this.from = t, this.stop = s;
+  }
+  toString() {
+    return this.value;
+  }
+  extend(e) {
+    this.value += String(e);
+  }
+  appendTo(e) {
+    return e.append(this.toString(), {
+      tail: !0
+    }).aggregate(e._appendPlaceholder());
+  }
+  get state() {
+    return {
+      value: this.value,
+      from: this.from,
+      stop: this.stop
+    };
+  }
+  set state(e) {
+    Object.assign(this, e);
+  }
+  unshift(e) {
+    if (!this.value.length || e != null && this.from >= e) return "";
+    const t = this.value[0];
+    return this.value = this.value.slice(1), t;
+  }
+  shift() {
+    if (!this.value.length) return "";
+    const e = this.value[this.value.length - 1];
+    return this.value = this.value.slice(0, -1), e;
+  }
+}
+class z {
+  /** */
+  /** */
+  /** Transforms value before mask processing */
+  /** Transforms each char before mask processing */
+  /** Validates if value is acceptable */
+  /** Does additional processing at the end of editing */
+  /** Format typed value to string */
+  /** Parse string to get typed value */
+  /** Enable characters overwriting */
+  /** */
+  /** */
+  /** */
+  /** */
+  constructor(e) {
+    this._value = "", this._update({
+      ...z.DEFAULTS,
+      ...e
+    }), this._initialized = !0;
+  }
+  /** Sets and applies new options */
+  updateOptions(e) {
+    this.optionsIsChanged(e) && this.withValueRefresh(this._update.bind(this, e));
+  }
+  /** Sets new options */
+  _update(e) {
+    Object.assign(this, e);
+  }
+  /** Mask state */
+  get state() {
+    return {
+      _value: this.value,
+      _rawInputValue: this.rawInputValue
+    };
+  }
+  set state(e) {
+    this._value = e._value;
+  }
+  /** Resets value */
+  reset() {
+    this._value = "";
+  }
+  get value() {
+    return this._value;
+  }
+  set value(e) {
+    this.resolve(e, {
+      input: !0
+    });
+  }
+  /** Resolve new value */
+  resolve(e, t) {
+    t === void 0 && (t = {
+      input: !0
+    }), this.reset(), this.append(e, t, ""), this.doCommit();
+  }
+  get unmaskedValue() {
+    return this.value;
+  }
+  set unmaskedValue(e) {
+    this.resolve(e, {});
+  }
+  get typedValue() {
+    return this.parse ? this.parse(this.value, this) : this.unmaskedValue;
+  }
+  set typedValue(e) {
+    this.format ? this.value = this.format(e, this) : this.unmaskedValue = String(e);
+  }
+  /** Value that includes raw user input */
+  get rawInputValue() {
+    return this.extractInput(0, this.displayValue.length, {
+      raw: !0
+    });
+  }
+  set rawInputValue(e) {
+    this.resolve(e, {
+      raw: !0
+    });
+  }
+  get displayValue() {
+    return this.value;
+  }
+  get isComplete() {
+    return !0;
+  }
+  get isFilled() {
+    return this.isComplete;
+  }
+  /** Finds nearest input position in direction */
+  nearestInputPos(e, t) {
+    return e;
+  }
+  totalInputPositions(e, t) {
+    return e === void 0 && (e = 0), t === void 0 && (t = this.displayValue.length), Math.min(this.displayValue.length, t - e);
+  }
+  /** Extracts value in range considering flags */
+  extractInput(e, t, s) {
+    return e === void 0 && (e = 0), t === void 0 && (t = this.displayValue.length), this.displayValue.slice(e, t);
+  }
+  /** Extracts tail in range */
+  extractTail(e, t) {
+    return e === void 0 && (e = 0), t === void 0 && (t = this.displayValue.length), new ie(this.extractInput(e, t), e);
+  }
+  /** Appends tail */
+  appendTail(e) {
+    return pe(e) && (e = new ie(String(e))), e.appendTo(this);
+  }
+  /** Appends char */
+  _appendCharRaw(e, t) {
+    return e ? (this._value += e, new T({
+      inserted: e,
+      rawInserted: e
+    })) : new T();
+  }
+  /** Appends char */
+  _appendChar(e, t, s) {
+    t === void 0 && (t = {});
+    const i = this.state;
+    let r;
+    if ([e, r] = this.doPrepareChar(e, t), e && (r = r.aggregate(this._appendCharRaw(e, t)), !r.rawInserted && this.autofix === "pad")) {
+      const a = this.state;
+      this.state = i;
+      let u = this.pad(t);
+      const o = this._appendCharRaw(e, t);
+      u = u.aggregate(o), o.rawInserted || u.equals(r) ? r = u : this.state = a;
+    }
+    if (r.inserted) {
+      let a, u = this.doValidate(t) !== !1;
+      if (u && s != null) {
+        const o = this.state;
+        if (this.overwrite === !0) {
+          a = s.state;
+          for (let p = 0; p < r.rawInserted.length; ++p)
+            s.unshift(this.displayValue.length - r.tailShift);
+        }
+        let l = this.appendTail(s);
+        if (u = l.rawInserted.length === s.toString().length, !(u && l.inserted) && this.overwrite === "shift") {
+          this.state = o, a = s.state;
+          for (let p = 0; p < r.rawInserted.length; ++p)
+            s.shift();
+          l = this.appendTail(s), u = l.rawInserted.length === s.toString().length;
+        }
+        u && l.inserted && (this.state = o);
+      }
+      u || (r = new T(), this.state = i, s && a && (s.state = a));
+    }
+    return r;
+  }
+  /** Appends optional placeholder at the end */
+  _appendPlaceholder() {
+    return new T();
+  }
+  /** Appends optional eager placeholder at the end */
+  _appendEager() {
+    return new T();
+  }
+  /** Appends symbols considering flags */
+  append(e, t, s) {
+    if (!pe(e)) throw new Error("value should be string");
+    const i = pe(s) ? new ie(String(s)) : s;
+    t != null && t.tail && (t._beforeTailState = this.state);
+    let r;
+    [e, r] = this.doPrepare(e, t);
+    for (let a = 0; a < e.length; ++a) {
+      const u = this._appendChar(e[a], t, i);
+      if (!u.rawInserted && !this.doSkipInvalid(e[a], t, i)) break;
+      r.aggregate(u);
+    }
+    return (this.eager === !0 || this.eager === "append") && t != null && t.input && e && r.aggregate(this._appendEager()), i != null && (r.tailShift += this.appendTail(i).tailShift), r;
+  }
+  remove(e, t) {
+    return e === void 0 && (e = 0), t === void 0 && (t = this.displayValue.length), this._value = this.displayValue.slice(0, e) + this.displayValue.slice(t), new T();
+  }
+  /** Calls function and reapplies current value */
+  withValueRefresh(e) {
+    if (this._refreshing || !this._initialized) return e();
+    this._refreshing = !0;
+    const t = this.rawInputValue, s = this.value, i = e();
+    return this.rawInputValue = t, this.value && this.value !== s && s.indexOf(this.value) === 0 && (this.append(s.slice(this.displayValue.length), {}, ""), this.doCommit()), delete this._refreshing, i;
+  }
+  runIsolated(e) {
+    if (this._isolated || !this._initialized) return e(this);
+    this._isolated = !0;
+    const t = this.state, s = e(this);
+    return this.state = t, delete this._isolated, s;
+  }
+  doSkipInvalid(e, t, s) {
+    return !!this.skipInvalid;
+  }
+  /** Prepares string before mask processing */
+  doPrepare(e, t) {
+    return t === void 0 && (t = {}), T.normalize(this.prepare ? this.prepare(e, this, t) : e);
+  }
+  /** Prepares each char before mask processing */
+  doPrepareChar(e, t) {
+    return t === void 0 && (t = {}), T.normalize(this.prepareChar ? this.prepareChar(e, this, t) : e);
+  }
+  /** Validates if value is acceptable */
+  doValidate(e) {
+    return (!this.validate || this.validate(this.value, this, e)) && (!this.parent || this.parent.doValidate(e));
+  }
+  /** Does additional processing at the end of editing */
+  doCommit() {
+    this.commit && this.commit(this.value, this);
+  }
+  splice(e, t, s, i, r) {
+    s === void 0 && (s = ""), i === void 0 && (i = _.NONE), r === void 0 && (r = {
+      input: !0
+    });
+    const a = e + t, u = this.extractTail(a), o = this.eager === !0 || this.eager === "remove";
+    let l;
+    o && (i = _s(i), l = this.extractInput(0, a, {
+      raw: !0
+    }));
+    let p = e;
+    const d = new T();
+    if (i !== _.NONE && (p = this.nearestInputPos(e, t > 1 && e !== 0 && !o ? _.NONE : i), d.tailShift = p - e), d.aggregate(this.remove(p)), o && i !== _.NONE && l === this.rawInputValue)
+      if (i === _.FORCE_LEFT) {
+        let k;
+        for (; l === this.rawInputValue && (k = this.displayValue.length); )
+          d.aggregate(new T({
+            tailShift: -1
+          })).aggregate(this.remove(k - 1));
+      } else i === _.FORCE_RIGHT && u.unshift();
+    return d.aggregate(this.append(s, r, u));
+  }
+  maskEquals(e) {
+    return this.mask === e;
+  }
+  optionsIsChanged(e) {
+    return !Fe(this, e);
+  }
+  typedValueEquals(e) {
+    const t = this.typedValue;
+    return e === t || z.EMPTY_VALUES.includes(e) && z.EMPTY_VALUES.includes(t) || (this.format ? this.format(e, this) === this.format(this.typedValue, this) : !1);
+  }
+  pad(e) {
+    return new T();
+  }
+}
+z.DEFAULTS = {
+  skipInvalid: !0
+};
+z.EMPTY_VALUES = [void 0, null, ""];
+C.Masked = z;
+class fe {
+  /** */
+  constructor(e, t) {
+    e === void 0 && (e = []), t === void 0 && (t = 0), this.chunks = e, this.from = t;
+  }
+  toString() {
+    return this.chunks.map(String).join("");
+  }
+  extend(e) {
+    if (!String(e)) return;
+    e = pe(e) ? new ie(String(e)) : e;
+    const t = this.chunks[this.chunks.length - 1], s = t && // if stops are same or tail has no stop
+    (t.stop === e.stop || e.stop == null) && // if tail chunk goes just after last chunk
+    e.from === t.from + t.toString().length;
+    if (e instanceof ie)
+      s ? t.extend(e.toString()) : this.chunks.push(e);
+    else if (e instanceof fe) {
+      if (e.stop == null) {
+        let i;
+        for (; e.chunks.length && e.chunks[0].stop == null; )
+          i = e.chunks.shift(), i.from += e.from, this.extend(i);
+      }
+      e.toString() && (e.stop = e.blockIndex, this.chunks.push(e));
+    }
+  }
+  appendTo(e) {
+    if (!(e instanceof C.MaskedPattern))
+      return new ie(this.toString()).appendTo(e);
+    const t = new T();
+    for (let s = 0; s < this.chunks.length; ++s) {
+      const i = this.chunks[s], r = e._mapPosToBlock(e.displayValue.length), a = i.stop;
+      let u;
+      if (a != null && // if block not found or stop is behind lastBlock
+      (!r || r.index <= a) && ((i instanceof fe || // for continuous block also check if stop is exist
+      e._stops.indexOf(a) >= 0) && t.aggregate(e._appendPlaceholder(a)), u = i instanceof fe && e._blocks[a]), u) {
+        const o = u.appendTail(i);
+        t.aggregate(o);
+        const l = i.toString().slice(o.rawInserted.length);
+        l && t.aggregate(e.append(l, {
+          tail: !0
+        }));
+      } else
+        t.aggregate(e.append(i.toString(), {
+          tail: !0
+        }));
+    }
+    return t;
+  }
+  get state() {
+    return {
+      chunks: this.chunks.map((e) => e.state),
+      from: this.from,
+      stop: this.stop,
+      blockIndex: this.blockIndex
+    };
+  }
+  set state(e) {
+    const {
+      chunks: t,
+      ...s
+    } = e;
+    Object.assign(this, s), this.chunks = t.map((i) => {
+      const r = "chunks" in i ? new fe() : new ie();
+      return r.state = i, r;
+    });
+  }
+  unshift(e) {
+    if (!this.chunks.length || e != null && this.from >= e) return "";
+    const t = e != null ? e - this.from : e;
+    let s = 0;
+    for (; s < this.chunks.length; ) {
+      const i = this.chunks[s], r = i.unshift(t);
+      if (i.toString()) {
+        if (!r) break;
+        ++s;
+      } else
+        this.chunks.splice(s, 1);
+      if (r) return r;
+    }
+    return "";
+  }
+  shift() {
+    if (!this.chunks.length) return "";
+    let e = this.chunks.length - 1;
+    for (; 0 <= e; ) {
+      const t = this.chunks[e], s = t.shift();
+      if (t.toString()) {
+        if (!s) break;
+        --e;
+      } else
+        this.chunks.splice(e, 1);
+      if (s) return s;
+    }
+    return "";
+  }
+}
+class Cs {
+  constructor(e, t) {
+    this.masked = e, this._log = [];
+    const {
+      offset: s,
+      index: i
+    } = e._mapPosToBlock(t) || (t < 0 ? (
+      // first
+      {
+        index: 0,
+        offset: 0
+      }
+    ) : (
+      // last
+      {
+        index: this.masked._blocks.length,
+        offset: 0
+      }
+    ));
+    this.offset = s, this.index = i, this.ok = !1;
+  }
+  get block() {
+    return this.masked._blocks[this.index];
+  }
+  get pos() {
+    return this.masked._blockStartPos(this.index) + this.offset;
+  }
+  get state() {
+    return {
+      index: this.index,
+      offset: this.offset,
+      ok: this.ok
+    };
+  }
+  set state(e) {
+    Object.assign(this, e);
+  }
+  pushState() {
+    this._log.push(this.state);
+  }
+  popState() {
+    const e = this._log.pop();
+    return e && (this.state = e), e;
+  }
+  bindBlock() {
+    this.block || (this.index < 0 && (this.index = 0, this.offset = 0), this.index >= this.masked._blocks.length && (this.index = this.masked._blocks.length - 1, this.offset = this.block.displayValue.length));
+  }
+  _pushLeft(e) {
+    for (this.pushState(), this.bindBlock(); 0 <= this.index; --this.index, this.offset = ((t = this.block) == null ? void 0 : t.displayValue.length) || 0) {
+      var t;
+      if (e()) return this.ok = !0;
+    }
+    return this.ok = !1;
+  }
+  _pushRight(e) {
+    for (this.pushState(), this.bindBlock(); this.index < this.masked._blocks.length; ++this.index, this.offset = 0)
+      if (e()) return this.ok = !0;
+    return this.ok = !1;
+  }
+  pushLeftBeforeFilled() {
+    return this._pushLeft(() => {
+      if (!(this.block.isFixed || !this.block.value) && (this.offset = this.block.nearestInputPos(this.offset, _.FORCE_LEFT), this.offset !== 0))
+        return !0;
+    });
+  }
+  pushLeftBeforeInput() {
+    return this._pushLeft(() => {
+      if (!this.block.isFixed)
+        return this.offset = this.block.nearestInputPos(this.offset, _.LEFT), !0;
+    });
+  }
+  pushLeftBeforeRequired() {
+    return this._pushLeft(() => {
+      if (!(this.block.isFixed || this.block.isOptional && !this.block.value))
+        return this.offset = this.block.nearestInputPos(this.offset, _.LEFT), !0;
+    });
+  }
+  pushRightBeforeFilled() {
+    return this._pushRight(() => {
+      if (!(this.block.isFixed || !this.block.value) && (this.offset = this.block.nearestInputPos(this.offset, _.FORCE_RIGHT), this.offset !== this.block.value.length))
+        return !0;
+    });
+  }
+  pushRightBeforeInput() {
+    return this._pushRight(() => {
+      if (!this.block.isFixed)
+        return this.offset = this.block.nearestInputPos(this.offset, _.NONE), !0;
+    });
+  }
+  pushRightBeforeRequired() {
+    return this._pushRight(() => {
+      if (!(this.block.isFixed || this.block.isOptional && !this.block.value))
+        return this.offset = this.block.nearestInputPos(this.offset, _.NONE), !0;
+    });
+  }
+}
+class xt {
+  /** */
+  /** */
+  /** */
+  /** */
+  /** */
+  /** */
+  constructor(e) {
+    Object.assign(this, e), this._value = "", this.isFixed = !0;
+  }
+  get value() {
+    return this._value;
+  }
+  get unmaskedValue() {
+    return this.isUnmasking ? this.value : "";
+  }
+  get rawInputValue() {
+    return this._isRawInput ? this.value : "";
+  }
+  get displayValue() {
+    return this.value;
+  }
+  reset() {
+    this._isRawInput = !1, this._value = "";
+  }
+  remove(e, t) {
+    return e === void 0 && (e = 0), t === void 0 && (t = this._value.length), this._value = this._value.slice(0, e) + this._value.slice(t), this._value || (this._isRawInput = !1), new T();
+  }
+  nearestInputPos(e, t) {
+    t === void 0 && (t = _.NONE);
+    const s = 0, i = this._value.length;
+    switch (t) {
+      case _.LEFT:
+      case _.FORCE_LEFT:
+        return s;
+      case _.NONE:
+      case _.RIGHT:
+      case _.FORCE_RIGHT:
+      default:
+        return i;
+    }
+  }
+  totalInputPositions(e, t) {
+    return e === void 0 && (e = 0), t === void 0 && (t = this._value.length), this._isRawInput ? t - e : 0;
+  }
+  extractInput(e, t, s) {
+    return e === void 0 && (e = 0), t === void 0 && (t = this._value.length), s === void 0 && (s = {}), s.raw && this._isRawInput && this._value.slice(e, t) || "";
+  }
+  get isComplete() {
+    return !0;
+  }
+  get isFilled() {
+    return !!this._value;
+  }
+  _appendChar(e, t) {
+    if (t === void 0 && (t = {}), this.isFilled) return new T();
+    const s = this.eager === !0 || this.eager === "append", r = this.char === e && (this.isUnmasking || t.input || t.raw) && (!t.raw || !s) && !t.tail, a = new T({
+      inserted: this.char,
+      rawInserted: r ? this.char : ""
+    });
+    return this._value = this.char, this._isRawInput = r && (t.raw || t.input), a;
+  }
+  _appendEager() {
+    return this._appendChar(this.char, {
+      tail: !0
+    });
+  }
+  _appendPlaceholder() {
+    const e = new T();
+    return this.isFilled || (this._value = e.inserted = this.char), e;
+  }
+  extractTail() {
+    return new ie("");
+  }
+  appendTail(e) {
+    return pe(e) && (e = new ie(String(e))), e.appendTo(this);
+  }
+  append(e, t, s) {
+    const i = this._appendChar(e[0], t);
+    return s != null && (i.tailShift += this.appendTail(s).tailShift), i;
+  }
+  doCommit() {
+  }
+  get state() {
+    return {
+      _value: this._value,
+      _rawInputValue: this.rawInputValue
+    };
+  }
+  set state(e) {
+    this._value = e._value, this._isRawInput = !!e._rawInputValue;
+  }
+  pad(e) {
+    return this._appendPlaceholder();
+  }
+}
+class xe {
+  /** */
+  /** */
+  /** */
+  /** */
+  /** */
+  /** */
+  /** */
+  /** */
+  constructor(e) {
+    const {
+      parent: t,
+      isOptional: s,
+      placeholderChar: i,
+      displayChar: r,
+      lazy: a,
+      eager: u,
+      ...o
+    } = e;
+    this.masked = le(o), Object.assign(this, {
+      parent: t,
+      isOptional: s,
+      placeholderChar: i,
+      displayChar: r,
+      lazy: a,
+      eager: u
+    });
+  }
+  reset() {
+    this.isFilled = !1, this.masked.reset();
+  }
+  remove(e, t) {
+    return e === void 0 && (e = 0), t === void 0 && (t = this.value.length), e === 0 && t >= 1 ? (this.isFilled = !1, this.masked.remove(e, t)) : new T();
+  }
+  get value() {
+    return this.masked.value || (this.isFilled && !this.isOptional ? this.placeholderChar : "");
+  }
+  get unmaskedValue() {
+    return this.masked.unmaskedValue;
+  }
+  get rawInputValue() {
+    return this.masked.rawInputValue;
+  }
+  get displayValue() {
+    return this.masked.value && this.displayChar || this.value;
+  }
+  get isComplete() {
+    return !!this.masked.value || this.isOptional;
+  }
+  _appendChar(e, t) {
+    if (t === void 0 && (t = {}), this.isFilled) return new T();
+    const s = this.masked.state;
+    let i = this.masked._appendChar(e, this.currentMaskFlags(t));
+    return i.inserted && this.doValidate(t) === !1 && (i = new T(), this.masked.state = s), !i.inserted && !this.isOptional && !this.lazy && !t.input && (i.inserted = this.placeholderChar), i.skip = !i.inserted && !this.isOptional, this.isFilled = !!i.inserted, i;
+  }
+  append(e, t, s) {
+    return this.masked.append(e, this.currentMaskFlags(t), s);
+  }
+  _appendPlaceholder() {
+    return this.isFilled || this.isOptional ? new T() : (this.isFilled = !0, new T({
+      inserted: this.placeholderChar
+    }));
+  }
+  _appendEager() {
+    return new T();
+  }
+  extractTail(e, t) {
+    return this.masked.extractTail(e, t);
+  }
+  appendTail(e) {
+    return this.masked.appendTail(e);
+  }
+  extractInput(e, t, s) {
+    return e === void 0 && (e = 0), t === void 0 && (t = this.value.length), this.masked.extractInput(e, t, s);
+  }
+  nearestInputPos(e, t) {
+    t === void 0 && (t = _.NONE);
+    const s = 0, i = this.value.length, r = Math.min(Math.max(e, s), i);
+    switch (t) {
+      case _.LEFT:
+      case _.FORCE_LEFT:
+        return this.isComplete ? r : s;
+      case _.RIGHT:
+      case _.FORCE_RIGHT:
+        return this.isComplete ? r : i;
+      case _.NONE:
+      default:
+        return r;
+    }
+  }
+  totalInputPositions(e, t) {
+    return e === void 0 && (e = 0), t === void 0 && (t = this.value.length), this.value.slice(e, t).length;
+  }
+  doValidate(e) {
+    return this.masked.doValidate(this.currentMaskFlags(e)) && (!this.parent || this.parent.doValidate(this.currentMaskFlags(e)));
+  }
+  doCommit() {
+    this.masked.doCommit();
+  }
+  get state() {
+    return {
+      _value: this.value,
+      _rawInputValue: this.rawInputValue,
+      masked: this.masked.state,
+      isFilled: this.isFilled
+    };
+  }
+  set state(e) {
+    this.masked.state = e.masked, this.isFilled = e.isFilled;
+  }
+  currentMaskFlags(e) {
+    var t;
+    return {
+      ...e,
+      _beforeTailState: (e == null || (t = e._beforeTailState) == null ? void 0 : t.masked) || (e == null ? void 0 : e._beforeTailState)
+    };
+  }
+  pad(e) {
+    return new T();
+  }
+}
+xe.DEFAULT_DEFINITIONS = {
+  0: /\d/,
+  a: /[\u0041-\u005A\u0061-\u007A\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/,
+  // http://stackoverflow.com/a/22075070
+  "*": /./
+};
+class bs extends z {
+  /** */
+  /** Enable characters overwriting */
+  /** */
+  /** */
+  /** */
+  updateOptions(e) {
+    super.updateOptions(e);
+  }
+  _update(e) {
+    const t = e.mask;
+    t && (e.validate = (s) => s.search(t) >= 0), super._update(e);
+  }
+}
+C.MaskedRegExp = bs;
+class q extends z {
+  /** */
+  /** */
+  /** Single char for empty input */
+  /** Single char for filled input */
+  /** Show placeholder only when needed */
+  /** Enable characters overwriting */
+  /** */
+  /** */
+  /** */
+  constructor(e) {
+    super({
+      ...q.DEFAULTS,
+      ...e,
+      definitions: Object.assign({}, xe.DEFAULT_DEFINITIONS, e == null ? void 0 : e.definitions)
+    });
+  }
+  updateOptions(e) {
+    super.updateOptions(e);
+  }
+  _update(e) {
+    e.definitions = Object.assign({}, this.definitions, e.definitions), super._update(e), this._rebuildMask();
+  }
+  _rebuildMask() {
+    const e = this.definitions;
+    this._blocks = [], this.exposeBlock = void 0, this._stops = [], this._maskedBlocks = {};
+    const t = this.mask;
+    if (!t || !e) return;
+    let s = !1, i = !1;
+    for (let r = 0; r < t.length; ++r) {
+      if (this.blocks) {
+        const l = t.slice(r), p = Object.keys(this.blocks).filter((k) => l.indexOf(k) === 0);
+        p.sort((k, E) => E.length - k.length);
+        const d = p[0];
+        if (d) {
+          const {
+            expose: k,
+            repeat: E,
+            ...I
+          } = Ee(this.blocks[d]), y = {
+            lazy: this.lazy,
+            eager: this.eager,
+            placeholderChar: this.placeholderChar,
+            displayChar: this.displayChar,
+            overwrite: this.overwrite,
+            autofix: this.autofix,
+            ...I,
+            repeat: E,
+            parent: this
+          }, F = E != null ? new C.RepeatBlock(
+            y
+            /* TODO */
+          ) : le(y);
+          F && (this._blocks.push(F), k && (this.exposeBlock = F), this._maskedBlocks[d] || (this._maskedBlocks[d] = []), this._maskedBlocks[d].push(this._blocks.length - 1)), r += d.length - 1;
+          continue;
+        }
+      }
+      let a = t[r], u = a in e;
+      if (a === q.STOP_CHAR) {
+        this._stops.push(this._blocks.length);
+        continue;
+      }
+      if (a === "{" || a === "}") {
+        s = !s;
+        continue;
+      }
+      if (a === "[" || a === "]") {
+        i = !i;
+        continue;
+      }
+      if (a === q.ESCAPE_CHAR) {
+        if (++r, a = t[r], !a) break;
+        u = !1;
+      }
+      const o = u ? new xe({
+        isOptional: i,
+        lazy: this.lazy,
+        eager: this.eager,
+        placeholderChar: this.placeholderChar,
+        displayChar: this.displayChar,
+        ...Ee(e[a]),
+        parent: this
+      }) : new xt({
+        char: a,
+        eager: this.eager,
+        isUnmasking: s
+      });
+      this._blocks.push(o);
+    }
+  }
+  get state() {
+    return {
+      ...super.state,
+      _blocks: this._blocks.map((e) => e.state)
+    };
+  }
+  set state(e) {
+    if (!e) {
+      this.reset();
+      return;
+    }
+    const {
+      _blocks: t,
+      ...s
+    } = e;
+    this._blocks.forEach((i, r) => i.state = t[r]), super.state = s;
+  }
+  reset() {
+    super.reset(), this._blocks.forEach((e) => e.reset());
+  }
+  get isComplete() {
+    return this.exposeBlock ? this.exposeBlock.isComplete : this._blocks.every((e) => e.isComplete);
+  }
+  get isFilled() {
+    return this._blocks.every((e) => e.isFilled);
+  }
+  get isFixed() {
+    return this._blocks.every((e) => e.isFixed);
+  }
+  get isOptional() {
+    return this._blocks.every((e) => e.isOptional);
+  }
+  doCommit() {
+    this._blocks.forEach((e) => e.doCommit()), super.doCommit();
+  }
+  get unmaskedValue() {
+    return this.exposeBlock ? this.exposeBlock.unmaskedValue : this._blocks.reduce((e, t) => e += t.unmaskedValue, "");
+  }
+  set unmaskedValue(e) {
+    if (this.exposeBlock) {
+      const t = this.extractTail(this._blockStartPos(this._blocks.indexOf(this.exposeBlock)) + this.exposeBlock.displayValue.length);
+      this.exposeBlock.unmaskedValue = e, this.appendTail(t), this.doCommit();
+    } else super.unmaskedValue = e;
+  }
+  get value() {
+    return this.exposeBlock ? this.exposeBlock.value : (
+      // TODO return _value when not in change?
+      this._blocks.reduce((e, t) => e += t.value, "")
+    );
+  }
+  set value(e) {
+    if (this.exposeBlock) {
+      const t = this.extractTail(this._blockStartPos(this._blocks.indexOf(this.exposeBlock)) + this.exposeBlock.displayValue.length);
+      this.exposeBlock.value = e, this.appendTail(t), this.doCommit();
+    } else super.value = e;
+  }
+  get typedValue() {
+    return this.exposeBlock ? this.exposeBlock.typedValue : super.typedValue;
+  }
+  set typedValue(e) {
+    if (this.exposeBlock) {
+      const t = this.extractTail(this._blockStartPos(this._blocks.indexOf(this.exposeBlock)) + this.exposeBlock.displayValue.length);
+      this.exposeBlock.typedValue = e, this.appendTail(t), this.doCommit();
+    } else super.typedValue = e;
+  }
+  get displayValue() {
+    return this._blocks.reduce((e, t) => e += t.displayValue, "");
+  }
+  appendTail(e) {
+    return super.appendTail(e).aggregate(this._appendPlaceholder());
+  }
+  _appendEager() {
+    var e;
+    const t = new T();
+    let s = (e = this._mapPosToBlock(this.displayValue.length)) == null ? void 0 : e.index;
+    if (s == null) return t;
+    this._blocks[s].isFilled && ++s;
+    for (let i = s; i < this._blocks.length; ++i) {
+      const r = this._blocks[i]._appendEager();
+      if (!r.inserted) break;
+      t.aggregate(r);
+    }
+    return t;
+  }
+  _appendCharRaw(e, t) {
+    t === void 0 && (t = {});
+    const s = this._mapPosToBlock(this.displayValue.length), i = new T();
+    if (!s) return i;
+    for (let a = s.index, u; u = this._blocks[a]; ++a) {
+      var r;
+      const o = u._appendChar(e, {
+        ...t,
+        _beforeTailState: (r = t._beforeTailState) == null || (r = r._blocks) == null ? void 0 : r[a]
+      });
+      if (i.aggregate(o), o.consumed) break;
+    }
+    return i;
+  }
+  extractTail(e, t) {
+    e === void 0 && (e = 0), t === void 0 && (t = this.displayValue.length);
+    const s = new fe();
+    return e === t || this._forEachBlocksInRange(e, t, (i, r, a, u) => {
+      const o = i.extractTail(a, u);
+      o.stop = this._findStopBefore(r), o.from = this._blockStartPos(r), o instanceof fe && (o.blockIndex = r), s.extend(o);
+    }), s;
+  }
+  extractInput(e, t, s) {
+    if (e === void 0 && (e = 0), t === void 0 && (t = this.displayValue.length), s === void 0 && (s = {}), e === t) return "";
+    let i = "";
+    return this._forEachBlocksInRange(e, t, (r, a, u, o) => {
+      i += r.extractInput(u, o, s);
+    }), i;
+  }
+  _findStopBefore(e) {
+    let t;
+    for (let s = 0; s < this._stops.length; ++s) {
+      const i = this._stops[s];
+      if (i <= e) t = i;
+      else break;
+    }
+    return t;
+  }
+  /** Appends placeholder depending on laziness */
+  _appendPlaceholder(e) {
+    const t = new T();
+    if (this.lazy && e == null) return t;
+    const s = this._mapPosToBlock(this.displayValue.length);
+    if (!s) return t;
+    const i = s.index, r = e ?? this._blocks.length;
+    return this._blocks.slice(i, r).forEach((a) => {
+      if (!a.lazy || e != null) {
+        var u;
+        t.aggregate(a._appendPlaceholder((u = a._blocks) == null ? void 0 : u.length));
+      }
+    }), t;
+  }
+  /** Finds block in pos */
+  _mapPosToBlock(e) {
+    let t = "";
+    for (let s = 0; s < this._blocks.length; ++s) {
+      const i = this._blocks[s], r = t.length;
+      if (t += i.displayValue, e <= t.length)
+        return {
+          index: s,
+          offset: e - r
+        };
+    }
+  }
+  _blockStartPos(e) {
+    return this._blocks.slice(0, e).reduce((t, s) => t += s.displayValue.length, 0);
+  }
+  _forEachBlocksInRange(e, t, s) {
+    t === void 0 && (t = this.displayValue.length);
+    const i = this._mapPosToBlock(e);
+    if (i) {
+      const r = this._mapPosToBlock(t), a = r && i.index === r.index, u = i.offset, o = r && a ? r.offset : this._blocks[i.index].displayValue.length;
+      if (s(this._blocks[i.index], i.index, u, o), r && !a) {
+        for (let l = i.index + 1; l < r.index; ++l)
+          s(this._blocks[l], l, 0, this._blocks[l].displayValue.length);
+        s(this._blocks[r.index], r.index, 0, r.offset);
+      }
+    }
+  }
+  remove(e, t) {
+    e === void 0 && (e = 0), t === void 0 && (t = this.displayValue.length);
+    const s = super.remove(e, t);
+    return this._forEachBlocksInRange(e, t, (i, r, a, u) => {
+      s.aggregate(i.remove(a, u));
+    }), s;
+  }
+  nearestInputPos(e, t) {
+    if (t === void 0 && (t = _.NONE), !this._blocks.length) return 0;
+    const s = new Cs(this, e);
+    if (t === _.NONE)
+      return s.pushRightBeforeInput() || (s.popState(), s.pushLeftBeforeInput()) ? s.pos : this.displayValue.length;
+    if (t === _.LEFT || t === _.FORCE_LEFT) {
+      if (t === _.LEFT) {
+        if (s.pushRightBeforeFilled(), s.ok && s.pos === e) return e;
+        s.popState();
+      }
+      if (s.pushLeftBeforeInput(), s.pushLeftBeforeRequired(), s.pushLeftBeforeFilled(), t === _.LEFT) {
+        if (s.pushRightBeforeInput(), s.pushRightBeforeRequired(), s.ok && s.pos <= e || (s.popState(), s.ok && s.pos <= e)) return s.pos;
+        s.popState();
+      }
+      return s.ok ? s.pos : t === _.FORCE_LEFT ? 0 : (s.popState(), s.ok || (s.popState(), s.ok) ? s.pos : 0);
+    }
+    return t === _.RIGHT || t === _.FORCE_RIGHT ? (s.pushRightBeforeInput(), s.pushRightBeforeRequired(), s.pushRightBeforeFilled() ? s.pos : t === _.FORCE_RIGHT ? this.displayValue.length : (s.popState(), s.ok || (s.popState(), s.ok) ? s.pos : this.nearestInputPos(e, _.LEFT))) : e;
+  }
+  totalInputPositions(e, t) {
+    e === void 0 && (e = 0), t === void 0 && (t = this.displayValue.length);
+    let s = 0;
+    return this._forEachBlocksInRange(e, t, (i, r, a, u) => {
+      s += i.totalInputPositions(a, u);
+    }), s;
+  }
+  /** Get block by name */
+  maskedBlock(e) {
+    return this.maskedBlocks(e)[0];
+  }
+  /** Get all blocks by name */
+  maskedBlocks(e) {
+    const t = this._maskedBlocks[e];
+    return t ? t.map((s) => this._blocks[s]) : [];
+  }
+  pad(e) {
+    const t = new T();
+    return this._forEachBlocksInRange(0, this.displayValue.length, (s) => t.aggregate(s.pad(e))), t;
+  }
+}
+q.DEFAULTS = {
+  ...z.DEFAULTS,
+  lazy: !0,
+  placeholderChar: "_"
+};
+q.STOP_CHAR = "`";
+q.ESCAPE_CHAR = "\\";
+q.InputDefinition = xe;
+q.FixedDefinition = xt;
+C.MaskedPattern = q;
+class Se extends q {
+  /**
+    Optionally sets max length of pattern.
+    Used when pattern length is longer then `to` param length. Pads zeros at start in this case.
+  */
+  /** Min bound */
+  /** Max bound */
+  get _matchFrom() {
+    return this.maxLength - String(this.from).length;
+  }
+  constructor(e) {
+    super(e);
+  }
+  updateOptions(e) {
+    super.updateOptions(e);
+  }
+  _update(e) {
+    const {
+      to: t = this.to || 0,
+      from: s = this.from || 0,
+      maxLength: i = this.maxLength || 0,
+      autofix: r = this.autofix,
+      ...a
+    } = e;
+    this.to = t, this.from = s, this.maxLength = Math.max(String(t).length, i), this.autofix = r;
+    const u = String(this.from).padStart(this.maxLength, "0"), o = String(this.to).padStart(this.maxLength, "0");
+    let l = 0;
+    for (; l < o.length && o[l] === u[l]; ) ++l;
+    a.mask = o.slice(0, l).replace(/0/g, "\\0") + "0".repeat(this.maxLength - l), super._update(a);
+  }
+  get isComplete() {
+    return super.isComplete && !!this.value;
+  }
+  boundaries(e) {
+    let t = "", s = "";
+    const [, i, r] = e.match(/^(\D*)(\d*)(\D*)/) || [];
+    return r && (t = "0".repeat(i.length) + r, s = "9".repeat(i.length) + r), t = t.padEnd(this.maxLength, "0"), s = s.padEnd(this.maxLength, "9"), [t, s];
+  }
+  doPrepareChar(e, t) {
+    t === void 0 && (t = {});
+    let s;
+    return [e, s] = super.doPrepareChar(e.replace(/\D/g, ""), t), e || (s.skip = !this.isComplete), [e, s];
+  }
+  _appendCharRaw(e, t) {
+    if (t === void 0 && (t = {}), !this.autofix || this.value.length + 1 > this.maxLength) return super._appendCharRaw(e, t);
+    const s = String(this.from).padStart(this.maxLength, "0"), i = String(this.to).padStart(this.maxLength, "0"), [r, a] = this.boundaries(this.value + e);
+    return Number(a) < this.from ? super._appendCharRaw(s[this.value.length], t) : Number(r) > this.to ? !t.tail && this.autofix === "pad" && this.value.length + 1 < this.maxLength ? super._appendCharRaw(s[this.value.length], t).aggregate(this._appendCharRaw(e, t)) : super._appendCharRaw(i[this.value.length], t) : super._appendCharRaw(e, t);
+  }
+  doValidate(e) {
+    const t = this.value;
+    if (t.search(/[^0]/) === -1 && t.length <= this._matchFrom) return !0;
+    const [i, r] = this.boundaries(t);
+    return this.from <= Number(r) && Number(i) <= this.to && super.doValidate(e);
+  }
+  pad(e) {
+    const t = new T();
+    if (this.value.length === this.maxLength) return t;
+    const s = this.value, i = this.maxLength - this.value.length;
+    if (i) {
+      this.reset();
+      for (let r = 0; r < i; ++r)
+        t.aggregate(super._appendCharRaw("0", e));
+      s.split("").forEach((r) => this._appendCharRaw(r));
+    }
+    return t;
+  }
+}
+C.MaskedRange = Se;
+const As = "d{.}`m{.}`Y";
+class oe extends q {
+  static extractPatternOptions(e) {
+    const {
+      mask: t,
+      pattern: s,
+      ...i
+    } = e;
+    return {
+      ...i,
+      mask: pe(t) ? t : s
+    };
+  }
+  /** Pattern mask for date according to {@link MaskedDate#format} */
+  /** Start date */
+  /** End date */
+  /** Format typed value to string */
+  /** Parse string to get typed value */
+  constructor(e) {
+    super(oe.extractPatternOptions({
+      ...oe.DEFAULTS,
+      ...e
+    }));
+  }
+  updateOptions(e) {
+    super.updateOptions(e);
+  }
+  _update(e) {
+    const {
+      mask: t,
+      pattern: s,
+      blocks: i,
+      ...r
+    } = {
+      ...oe.DEFAULTS,
+      ...e
+    }, a = Object.assign({}, oe.GET_DEFAULT_BLOCKS());
+    e.min && (a.Y.from = e.min.getFullYear()), e.max && (a.Y.to = e.max.getFullYear()), e.min && e.max && a.Y.from === a.Y.to && (a.m.from = e.min.getMonth() + 1, a.m.to = e.max.getMonth() + 1, a.m.from === a.m.to && (a.d.from = e.min.getDate(), a.d.to = e.max.getDate())), Object.assign(a, this.blocks, i), super._update({
+      ...r,
+      mask: pe(t) ? t : s,
+      blocks: a
+    });
+  }
+  doValidate(e) {
+    const t = this.date;
+    return super.doValidate(e) && (!this.isComplete || this.isDateExist(this.value) && t != null && (this.min == null || this.min <= t) && (this.max == null || t <= this.max));
+  }
+  /** Checks if date is exists */
+  isDateExist(e) {
+    return this.format(this.parse(e, this), this).indexOf(e) >= 0;
+  }
+  /** Parsed Date */
+  get date() {
+    return this.typedValue;
+  }
+  set date(e) {
+    this.typedValue = e;
+  }
+  get typedValue() {
+    return this.isComplete ? super.typedValue : null;
+  }
+  set typedValue(e) {
+    super.typedValue = e;
+  }
+  maskEquals(e) {
+    return e === Date || super.maskEquals(e);
+  }
+  optionsIsChanged(e) {
+    return super.optionsIsChanged(oe.extractPatternOptions(e));
+  }
+}
+oe.GET_DEFAULT_BLOCKS = () => ({
+  d: {
+    mask: Se,
+    from: 1,
+    to: 31,
+    maxLength: 2
+  },
+  m: {
+    mask: Se,
+    from: 1,
+    to: 12,
+    maxLength: 2
+  },
+  Y: {
+    mask: Se,
+    from: 1900,
+    to: 9999
+  }
+});
+oe.DEFAULTS = {
+  ...q.DEFAULTS,
+  mask: Date,
+  pattern: As,
+  format: (n, e) => {
+    if (!n) return "";
+    const t = String(n.getDate()).padStart(2, "0"), s = String(n.getMonth() + 1).padStart(2, "0"), i = n.getFullYear();
+    return [t, s, i].join(".");
+  },
+  parse: (n, e) => {
+    const [t, s, i] = n.split(".").map(Number);
+    return new Date(i, s - 1, t);
+  }
+};
+C.MaskedDate = oe;
+class Oe extends z {
+  constructor(e) {
+    super({
+      ...Oe.DEFAULTS,
+      ...e
+    }), this.currentMask = void 0;
+  }
+  updateOptions(e) {
+    super.updateOptions(e);
+  }
+  _update(e) {
+    super._update(e), "mask" in e && (this.exposeMask = void 0, this.compiledMasks = Array.isArray(e.mask) ? e.mask.map((t) => {
+      const {
+        expose: s,
+        ...i
+      } = Ee(t), r = le({
+        overwrite: this._overwrite,
+        eager: this._eager,
+        skipInvalid: this._skipInvalid,
+        ...i
+      });
+      return s && (this.exposeMask = r), r;
+    }) : []);
+  }
+  _appendCharRaw(e, t) {
+    t === void 0 && (t = {});
+    const s = this._applyDispatch(e, t);
+    return this.currentMask && s.aggregate(this.currentMask._appendChar(e, this.currentMaskFlags(t))), s;
+  }
+  _applyDispatch(e, t, s) {
+    e === void 0 && (e = ""), t === void 0 && (t = {}), s === void 0 && (s = "");
+    const i = t.tail && t._beforeTailState != null ? t._beforeTailState._value : this.value, r = this.rawInputValue, a = t.tail && t._beforeTailState != null ? t._beforeTailState._rawInputValue : r, u = r.slice(a.length), o = this.currentMask, l = new T(), p = o == null ? void 0 : o.state;
+    return this.currentMask = this.doDispatch(e, {
+      ...t
+    }, s), this.currentMask && (this.currentMask !== o ? (this.currentMask.reset(), a && (this.currentMask.append(a, {
+      raw: !0
+    }), l.tailShift = this.currentMask.value.length - i.length), u && (l.tailShift += this.currentMask.append(u, {
+      raw: !0,
+      tail: !0
+    }).tailShift)) : p && (this.currentMask.state = p)), l;
+  }
+  _appendPlaceholder() {
+    const e = this._applyDispatch();
+    return this.currentMask && e.aggregate(this.currentMask._appendPlaceholder()), e;
+  }
+  _appendEager() {
+    const e = this._applyDispatch();
+    return this.currentMask && e.aggregate(this.currentMask._appendEager()), e;
+  }
+  appendTail(e) {
+    const t = new T();
+    return e && t.aggregate(this._applyDispatch("", {}, e)), t.aggregate(this.currentMask ? this.currentMask.appendTail(e) : super.appendTail(e));
+  }
+  currentMaskFlags(e) {
+    var t, s;
+    return {
+      ...e,
+      _beforeTailState: ((t = e._beforeTailState) == null ? void 0 : t.currentMaskRef) === this.currentMask && ((s = e._beforeTailState) == null ? void 0 : s.currentMask) || e._beforeTailState
+    };
+  }
+  doDispatch(e, t, s) {
+    return t === void 0 && (t = {}), s === void 0 && (s = ""), this.dispatch(e, this, t, s);
+  }
+  doValidate(e) {
+    return super.doValidate(e) && (!this.currentMask || this.currentMask.doValidate(this.currentMaskFlags(e)));
+  }
+  doPrepare(e, t) {
+    t === void 0 && (t = {});
+    let [s, i] = super.doPrepare(e, t);
+    if (this.currentMask) {
+      let r;
+      [s, r] = super.doPrepare(s, this.currentMaskFlags(t)), i = i.aggregate(r);
+    }
+    return [s, i];
+  }
+  doPrepareChar(e, t) {
+    t === void 0 && (t = {});
+    let [s, i] = super.doPrepareChar(e, t);
+    if (this.currentMask) {
+      let r;
+      [s, r] = super.doPrepareChar(s, this.currentMaskFlags(t)), i = i.aggregate(r);
+    }
+    return [s, i];
+  }
+  reset() {
+    var e;
+    (e = this.currentMask) == null || e.reset(), this.compiledMasks.forEach((t) => t.reset());
+  }
+  get value() {
+    return this.exposeMask ? this.exposeMask.value : this.currentMask ? this.currentMask.value : "";
+  }
+  set value(e) {
+    this.exposeMask ? (this.exposeMask.value = e, this.currentMask = this.exposeMask, this._applyDispatch()) : super.value = e;
+  }
+  get unmaskedValue() {
+    return this.exposeMask ? this.exposeMask.unmaskedValue : this.currentMask ? this.currentMask.unmaskedValue : "";
+  }
+  set unmaskedValue(e) {
+    this.exposeMask ? (this.exposeMask.unmaskedValue = e, this.currentMask = this.exposeMask, this._applyDispatch()) : super.unmaskedValue = e;
+  }
+  get typedValue() {
+    return this.exposeMask ? this.exposeMask.typedValue : this.currentMask ? this.currentMask.typedValue : "";
+  }
+  set typedValue(e) {
+    if (this.exposeMask) {
+      this.exposeMask.typedValue = e, this.currentMask = this.exposeMask, this._applyDispatch();
+      return;
+    }
+    let t = String(e);
+    this.currentMask && (this.currentMask.typedValue = e, t = this.currentMask.unmaskedValue), this.unmaskedValue = t;
+  }
+  get displayValue() {
+    return this.currentMask ? this.currentMask.displayValue : "";
+  }
+  get isComplete() {
+    var e;
+    return !!((e = this.currentMask) != null && e.isComplete);
+  }
+  get isFilled() {
+    var e;
+    return !!((e = this.currentMask) != null && e.isFilled);
+  }
+  remove(e, t) {
+    const s = new T();
+    return this.currentMask && s.aggregate(this.currentMask.remove(e, t)).aggregate(this._applyDispatch()), s;
+  }
+  get state() {
+    var e;
+    return {
+      ...super.state,
+      _rawInputValue: this.rawInputValue,
+      compiledMasks: this.compiledMasks.map((t) => t.state),
+      currentMaskRef: this.currentMask,
+      currentMask: (e = this.currentMask) == null ? void 0 : e.state
+    };
+  }
+  set state(e) {
+    const {
+      compiledMasks: t,
+      currentMaskRef: s,
+      currentMask: i,
+      ...r
+    } = e;
+    t && this.compiledMasks.forEach((a, u) => a.state = t[u]), s != null && (this.currentMask = s, this.currentMask.state = i), super.state = r;
+  }
+  extractInput(e, t, s) {
+    return this.currentMask ? this.currentMask.extractInput(e, t, s) : "";
+  }
+  extractTail(e, t) {
+    return this.currentMask ? this.currentMask.extractTail(e, t) : super.extractTail(e, t);
+  }
+  doCommit() {
+    this.currentMask && this.currentMask.doCommit(), super.doCommit();
+  }
+  nearestInputPos(e, t) {
+    return this.currentMask ? this.currentMask.nearestInputPos(e, t) : super.nearestInputPos(e, t);
+  }
+  get overwrite() {
+    return this.currentMask ? this.currentMask.overwrite : this._overwrite;
+  }
+  set overwrite(e) {
+    this._overwrite = e;
+  }
+  get eager() {
+    return this.currentMask ? this.currentMask.eager : this._eager;
+  }
+  set eager(e) {
+    this._eager = e;
+  }
+  get skipInvalid() {
+    return this.currentMask ? this.currentMask.skipInvalid : this._skipInvalid;
+  }
+  set skipInvalid(e) {
+    this._skipInvalid = e;
+  }
+  get autofix() {
+    return this.currentMask ? this.currentMask.autofix : this._autofix;
+  }
+  set autofix(e) {
+    this._autofix = e;
+  }
+  maskEquals(e) {
+    return Array.isArray(e) ? this.compiledMasks.every((t, s) => {
+      if (!e[s]) return;
+      const {
+        mask: i,
+        ...r
+      } = e[s];
+      return Fe(t, r) && t.maskEquals(i);
+    }) : super.maskEquals(e);
+  }
+  typedValueEquals(e) {
+    var t;
+    return !!((t = this.currentMask) != null && t.typedValueEquals(e));
+  }
+}
+Oe.DEFAULTS = {
+  ...z.DEFAULTS,
+  dispatch: (n, e, t, s) => {
+    if (!e.compiledMasks.length) return;
+    const i = e.rawInputValue, r = e.compiledMasks.map((a, u) => {
+      const o = e.currentMask === a, l = o ? a.displayValue.length : a.nearestInputPos(a.displayValue.length, _.FORCE_LEFT);
+      return a.rawInputValue !== i ? (a.reset(), a.append(i, {
+        raw: !0
+      })) : o || a.remove(l), a.append(n, e.currentMaskFlags(t)), a.appendTail(s), {
+        index: u,
+        weight: a.rawInputValue.length,
+        totalInputPositions: a.totalInputPositions(0, Math.max(l, a.nearestInputPos(a.displayValue.length, _.FORCE_LEFT)))
+      };
+    });
+    return r.sort((a, u) => u.weight - a.weight || u.totalInputPositions - a.totalInputPositions), e.compiledMasks[r[0].index];
+  }
+};
+C.MaskedDynamic = Oe;
+class De extends q {
+  constructor(e) {
+    super({
+      ...De.DEFAULTS,
+      ...e
+    });
+  }
+  updateOptions(e) {
+    super.updateOptions(e);
+  }
+  _update(e) {
+    const {
+      enum: t,
+      ...s
+    } = e;
+    if (t) {
+      const i = t.map((u) => u.length), r = Math.min(...i), a = Math.max(...i) - r;
+      s.mask = "*".repeat(r), a && (s.mask += "[" + "*".repeat(a) + "]"), this.enum = t;
+    }
+    super._update(s);
+  }
+  _appendCharRaw(e, t) {
+    t === void 0 && (t = {});
+    const s = Math.min(this.nearestInputPos(0, _.FORCE_RIGHT), this.value.length), i = this.enum.filter((r) => this.matchValue(r, this.unmaskedValue + e, s));
+    if (i.length) {
+      i.length === 1 && this._forEachBlocksInRange(0, this.value.length, (a, u) => {
+        const o = i[0][u];
+        u >= this.value.length || o === a.value || (a.reset(), a._appendChar(o, t));
+      });
+      const r = super._appendCharRaw(i[0][this.value.length], t);
+      return i.length === 1 && i[0].slice(this.unmaskedValue.length).split("").forEach((a) => r.aggregate(super._appendCharRaw(a))), r;
+    }
+    return new T({
+      skip: !this.isComplete
+    });
+  }
+  extractTail(e, t) {
+    return e === void 0 && (e = 0), t === void 0 && (t = this.displayValue.length), new ie("", e);
+  }
+  remove(e, t) {
+    if (e === void 0 && (e = 0), t === void 0 && (t = this.displayValue.length), e === t) return new T();
+    const s = Math.min(super.nearestInputPos(0, _.FORCE_RIGHT), this.value.length);
+    let i;
+    for (i = e; i >= 0 && !(this.enum.filter((u) => this.matchValue(u, this.value.slice(s, i), s)).length > 1); --i)
+      ;
+    const r = super.remove(i, t);
+    return r.tailShift += i - e, r;
+  }
+  get isComplete() {
+    return this.enum.indexOf(this.value) >= 0;
+  }
+}
+De.DEFAULTS = {
+  ...q.DEFAULTS,
+  matchValue: (n, e, t) => n.indexOf(e, t) === t
+};
+C.MaskedEnum = De;
+class Ss extends z {
+  /** */
+  /** Enable characters overwriting */
+  /** */
+  /** */
+  /** */
+  updateOptions(e) {
+    super.updateOptions(e);
+  }
+  _update(e) {
+    super._update({
+      ...e,
+      validate: e.mask
+    });
+  }
+}
+C.MaskedFunction = Ss;
+var It;
+class K extends z {
+  /** Single char */
+  /** Single char */
+  /** Array of single chars */
+  /** */
+  /** */
+  /** Digits after point */
+  /** Flag to remove leading and trailing zeros in the end of editing */
+  /** Flag to pad trailing zeros after point in the end of editing */
+  /** Enable characters overwriting */
+  /** */
+  /** */
+  /** */
+  /** Format typed value to string */
+  /** Parse string to get typed value */
+  constructor(e) {
+    super({
+      ...K.DEFAULTS,
+      ...e
+    });
+  }
+  updateOptions(e) {
+    super.updateOptions(e);
+  }
+  _update(e) {
+    super._update(e), this._updateRegExps();
+  }
+  _updateRegExps() {
+    const e = "^" + (this.allowNegative ? "[+|\\-]?" : ""), t = "\\d*", s = (this.scale ? "(" + Ve(this.radix) + "\\d{0," + this.scale + "})?" : "") + "$";
+    this._numberRegExp = new RegExp(e + t + s), this._mapToRadixRegExp = new RegExp("[" + this.mapToRadix.map(Ve).join("") + "]", "g"), this._thousandsSeparatorRegExp = new RegExp(Ve(this.thousandsSeparator), "g");
+  }
+  _removeThousandsSeparators(e) {
+    return e.replace(this._thousandsSeparatorRegExp, "");
+  }
+  _insertThousandsSeparators(e) {
+    const t = e.split(this.radix);
+    return t[0] = t[0].replace(/\B(?=(\d{3})+(?!\d))/g, this.thousandsSeparator), t.join(this.radix);
+  }
+  doPrepareChar(e, t) {
+    t === void 0 && (t = {});
+    const [s, i] = super.doPrepareChar(this._removeThousandsSeparators(this.scale && this.mapToRadix.length && /*
+      radix should be mapped when
+      1) input is done from keyboard = flags.input && flags.raw
+      2) unmasked value is set = !flags.input && !flags.raw
+      and should not be mapped when
+      1) value is set = flags.input && !flags.raw
+      2) raw value is set = !flags.input && flags.raw
+    */
+    (t.input && t.raw || !t.input && !t.raw) ? e.replace(this._mapToRadixRegExp, this.radix) : e), t);
+    return e && !s && (i.skip = !0), s && !this.allowPositive && !this.value && s !== "-" && i.aggregate(this._appendChar("-")), [s, i];
+  }
+  _separatorsCount(e, t) {
+    t === void 0 && (t = !1);
+    let s = 0;
+    for (let i = 0; i < e; ++i)
+      this._value.indexOf(this.thousandsSeparator, i) === i && (++s, t && (e += this.thousandsSeparator.length));
+    return s;
+  }
+  _separatorsCountFromSlice(e) {
+    return e === void 0 && (e = this._value), this._separatorsCount(this._removeThousandsSeparators(e).length, !0);
+  }
+  extractInput(e, t, s) {
+    return e === void 0 && (e = 0), t === void 0 && (t = this.displayValue.length), [e, t] = this._adjustRangeWithSeparators(e, t), this._removeThousandsSeparators(super.extractInput(e, t, s));
+  }
+  _appendCharRaw(e, t) {
+    t === void 0 && (t = {});
+    const s = t.tail && t._beforeTailState ? t._beforeTailState._value : this._value, i = this._separatorsCountFromSlice(s);
+    this._value = this._removeThousandsSeparators(this.value);
+    const r = this._value;
+    this._value += e;
+    const a = this.number;
+    let u = !isNaN(a), o = !1;
+    if (u) {
+      let k;
+      this.min != null && this.min < 0 && this.number < this.min && (k = this.min), this.max != null && this.max > 0 && this.number > this.max && (k = this.max), k != null && (this.autofix ? (this._value = this.format(k, this).replace(K.UNMASKED_RADIX, this.radix), o || (o = r === this._value && !t.tail)) : u = !1), u && (u = !!this._value.match(this._numberRegExp));
+    }
+    let l;
+    u ? l = new T({
+      inserted: this._value.slice(r.length),
+      rawInserted: o ? "" : e,
+      skip: o
+    }) : (this._value = r, l = new T()), this._value = this._insertThousandsSeparators(this._value);
+    const p = t.tail && t._beforeTailState ? t._beforeTailState._value : this._value, d = this._separatorsCountFromSlice(p);
+    return l.tailShift += (d - i) * this.thousandsSeparator.length, l;
+  }
+  _findSeparatorAround(e) {
+    if (this.thousandsSeparator) {
+      const t = e - this.thousandsSeparator.length + 1, s = this.value.indexOf(this.thousandsSeparator, t);
+      if (s <= e) return s;
+    }
+    return -1;
+  }
+  _adjustRangeWithSeparators(e, t) {
+    const s = this._findSeparatorAround(e);
+    s >= 0 && (e = s);
+    const i = this._findSeparatorAround(t);
+    return i >= 0 && (t = i + this.thousandsSeparator.length), [e, t];
+  }
+  remove(e, t) {
+    e === void 0 && (e = 0), t === void 0 && (t = this.displayValue.length), [e, t] = this._adjustRangeWithSeparators(e, t);
+    const s = this.value.slice(0, e), i = this.value.slice(t), r = this._separatorsCount(s.length);
+    this._value = this._insertThousandsSeparators(this._removeThousandsSeparators(s + i));
+    const a = this._separatorsCountFromSlice(s);
+    return new T({
+      tailShift: (a - r) * this.thousandsSeparator.length
+    });
+  }
+  nearestInputPos(e, t) {
+    if (!this.thousandsSeparator) return e;
+    switch (t) {
+      case _.NONE:
+      case _.LEFT:
+      case _.FORCE_LEFT: {
+        const s = this._findSeparatorAround(e - 1);
+        if (s >= 0) {
+          const i = s + this.thousandsSeparator.length;
+          if (e < i || this.value.length <= i || t === _.FORCE_LEFT)
+            return s;
+        }
+        break;
+      }
+      case _.RIGHT:
+      case _.FORCE_RIGHT: {
+        const s = this._findSeparatorAround(e);
+        if (s >= 0)
+          return s + this.thousandsSeparator.length;
+      }
+    }
+    return e;
+  }
+  doCommit() {
+    if (this.value) {
+      const e = this.number;
+      let t = e;
+      this.min != null && (t = Math.max(t, this.min)), this.max != null && (t = Math.min(t, this.max)), t !== e && (this.unmaskedValue = this.format(t, this));
+      let s = this.value;
+      this.normalizeZeros && (s = this._normalizeZeros(s)), this.padFractionalZeros && this.scale > 0 && (s = this._padFractionalZeros(s)), this._value = s;
+    }
+    super.doCommit();
+  }
+  _normalizeZeros(e) {
+    const t = this._removeThousandsSeparators(e).split(this.radix);
+    return t[0] = t[0].replace(/^(\D*)(0*)(\d*)/, (s, i, r, a) => i + a), e.length && !/\d$/.test(t[0]) && (t[0] = t[0] + "0"), t.length > 1 && (t[1] = t[1].replace(/0*$/, ""), t[1].length || (t.length = 1)), this._insertThousandsSeparators(t.join(this.radix));
+  }
+  _padFractionalZeros(e) {
+    if (!e) return e;
+    const t = e.split(this.radix);
+    return t.length < 2 && t.push(""), t[1] = t[1].padEnd(this.scale, "0"), t.join(this.radix);
+  }
+  doSkipInvalid(e, t, s) {
+    t === void 0 && (t = {});
+    const i = this.scale === 0 && e !== this.thousandsSeparator && (e === this.radix || e === K.UNMASKED_RADIX || this.mapToRadix.includes(e));
+    return super.doSkipInvalid(e, t, s) && !i;
+  }
+  get unmaskedValue() {
+    return this._removeThousandsSeparators(this._normalizeZeros(this.value)).replace(this.radix, K.UNMASKED_RADIX);
+  }
+  set unmaskedValue(e) {
+    super.unmaskedValue = e;
+  }
+  get typedValue() {
+    return this.parse(this.unmaskedValue, this);
+  }
+  set typedValue(e) {
+    this.rawInputValue = this.format(e, this).replace(K.UNMASKED_RADIX, this.radix);
+  }
+  /** Parsed Number */
+  get number() {
+    return this.typedValue;
+  }
+  set number(e) {
+    this.typedValue = e;
+  }
+  get allowNegative() {
+    return this.min != null && this.min < 0 || this.max != null && this.max < 0;
+  }
+  get allowPositive() {
+    return this.min != null && this.min > 0 || this.max != null && this.max > 0;
+  }
+  typedValueEquals(e) {
+    return (super.typedValueEquals(e) || K.EMPTY_VALUES.includes(e) && K.EMPTY_VALUES.includes(this.typedValue)) && !(e === 0 && this.value === "");
+  }
+}
+It = K;
+K.UNMASKED_RADIX = ".";
+K.EMPTY_VALUES = [...z.EMPTY_VALUES, 0];
+K.DEFAULTS = {
+  ...z.DEFAULTS,
+  mask: Number,
+  radix: ",",
+  thousandsSeparator: "",
+  mapToRadix: [It.UNMASKED_RADIX],
+  min: Number.MIN_SAFE_INTEGER,
+  max: Number.MAX_SAFE_INTEGER,
+  scale: 2,
+  normalizeZeros: !0,
+  padFractionalZeros: !1,
+  parse: Number,
+  format: (n) => n.toLocaleString("en-US", {
+    useGrouping: !1,
+    maximumFractionDigits: 20
+  })
+};
+C.MaskedNumber = K;
+const Ye = {
+  MASKED: "value",
+  UNMASKED: "unmaskedValue",
+  TYPED: "typedValue"
+};
+function Tt(n, e, t) {
+  e === void 0 && (e = Ye.MASKED), t === void 0 && (t = Ye.MASKED);
+  const s = le(n);
+  return (i) => s.runIsolated((r) => (r[e] = i, r[t]));
+}
+function Fs(n, e, t, s) {
+  return Tt(e, t, s)(n);
+}
+C.PIPE_TYPE = Ye;
+C.createPipe = Tt;
+C.pipe = Fs;
+class xs extends q {
+  get repeatFrom() {
+    var e;
+    return (e = Array.isArray(this.repeat) ? this.repeat[0] : this.repeat === 1 / 0 ? 0 : this.repeat) != null ? e : 0;
+  }
+  get repeatTo() {
+    var e;
+    return (e = Array.isArray(this.repeat) ? this.repeat[1] : this.repeat) != null ? e : 1 / 0;
+  }
+  constructor(e) {
+    super(e);
+  }
+  updateOptions(e) {
+    super.updateOptions(e);
+  }
+  _update(e) {
+    var t, s, i;
+    const {
+      repeat: r,
+      ...a
+    } = Ee(e);
+    this._blockOpts = Object.assign({}, this._blockOpts, a);
+    const u = le(this._blockOpts);
+    this.repeat = (t = (s = r ?? u.repeat) != null ? s : this.repeat) != null ? t : 1 / 0, super._update({
+      mask: "m".repeat(Math.max(this.repeatTo === 1 / 0 && ((i = this._blocks) == null ? void 0 : i.length) || 0, this.repeatFrom)),
+      blocks: {
+        m: u
+      },
+      eager: u.eager,
+      overwrite: u.overwrite,
+      skipInvalid: u.skipInvalid,
+      lazy: u.lazy,
+      placeholderChar: u.placeholderChar,
+      displayChar: u.displayChar
+    });
+  }
+  _allocateBlock(e) {
+    if (e < this._blocks.length) return this._blocks[e];
+    if (this.repeatTo === 1 / 0 || this._blocks.length < this.repeatTo)
+      return this._blocks.push(le(this._blockOpts)), this.mask += "m", this._blocks[this._blocks.length - 1];
+  }
+  _appendCharRaw(e, t) {
+    t === void 0 && (t = {});
+    const s = new T();
+    for (
+      let o = (i = (r = this._mapPosToBlock(this.displayValue.length)) == null ? void 0 : r.index) != null ? i : Math.max(this._blocks.length - 1, 0), l, p;
+      // try to get a block or
+      // try to allocate a new block if not allocated already
+      l = (a = this._blocks[o]) != null ? a : p = !p && this._allocateBlock(o);
+      ++o
+    ) {
+      var i, r, a, u;
+      const d = l._appendChar(e, {
+        ...t,
+        _beforeTailState: (u = t._beforeTailState) == null || (u = u._blocks) == null ? void 0 : u[o]
+      });
+      if (d.skip && p) {
+        this._blocks.pop(), this.mask = this.mask.slice(1);
+        break;
+      }
+      if (s.aggregate(d), d.consumed) break;
+    }
+    return s;
+  }
+  _trimEmptyTail(e, t) {
+    var s, i;
+    e === void 0 && (e = 0);
+    const r = Math.max(((s = this._mapPosToBlock(e)) == null ? void 0 : s.index) || 0, this.repeatFrom, 0);
+    let a;
+    t != null && (a = (i = this._mapPosToBlock(t)) == null ? void 0 : i.index), a == null && (a = this._blocks.length - 1);
+    let u = 0;
+    for (let o = a; r <= o && !this._blocks[o].unmaskedValue; --o, ++u)
+      ;
+    u && (this._blocks.splice(a - u + 1, u), this.mask = this.mask.slice(u));
+  }
+  reset() {
+    super.reset(), this._trimEmptyTail();
+  }
+  remove(e, t) {
+    e === void 0 && (e = 0), t === void 0 && (t = this.displayValue.length);
+    const s = super.remove(e, t);
+    return this._trimEmptyTail(e, t), s;
+  }
+  totalInputPositions(e, t) {
+    return e === void 0 && (e = 0), t == null && this.repeatTo === 1 / 0 ? 1 / 0 : super.totalInputPositions(e, t);
+  }
+  get state() {
+    return super.state;
+  }
+  set state(e) {
+    this._blocks.length = e._blocks.length, this.mask = this.mask.slice(0, this._blocks.length), super.state = e;
+  }
+}
+C.RepeatBlock = xs;
+try {
+  globalThis.IMask = C;
+} catch {
+}
+function wt(n) {
+  return n && n.__esModule && Object.prototype.hasOwnProperty.call(n, "default") ? n.default : n;
+}
+var be = { exports: {} }, Ae = { exports: {} }, V = {};
+/** @license React v16.13.1
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var ut;
+function Is() {
+  if (ut) return V;
+  ut = 1;
+  var n = typeof Symbol == "function" && Symbol.for, e = n ? Symbol.for("react.element") : 60103, t = n ? Symbol.for("react.portal") : 60106, s = n ? Symbol.for("react.fragment") : 60107, i = n ? Symbol.for("react.strict_mode") : 60108, r = n ? Symbol.for("react.profiler") : 60114, a = n ? Symbol.for("react.provider") : 60109, u = n ? Symbol.for("react.context") : 60110, o = n ? Symbol.for("react.async_mode") : 60111, l = n ? Symbol.for("react.concurrent_mode") : 60111, p = n ? Symbol.for("react.forward_ref") : 60112, d = n ? Symbol.for("react.suspense") : 60113, k = n ? Symbol.for("react.suspense_list") : 60120, E = n ? Symbol.for("react.memo") : 60115, I = n ? Symbol.for("react.lazy") : 60116, y = n ? Symbol.for("react.block") : 60121, F = n ? Symbol.for("react.fundamental") : 60117, N = n ? Symbol.for("react.responder") : 60118, L = n ? Symbol.for("react.scope") : 60119;
+  function A(c) {
+    if (typeof c == "object" && c !== null) {
+      var $ = c.$$typeof;
+      switch ($) {
+        case e:
+          switch (c = c.type, c) {
+            case o:
+            case l:
+            case s:
+            case r:
+            case i:
+            case d:
+              return c;
+            default:
+              switch (c = c && c.$$typeof, c) {
+                case u:
+                case p:
+                case I:
+                case E:
+                case a:
+                  return c;
+                default:
+                  return $;
+              }
+          }
+        case t:
+          return $;
+      }
+    }
+  }
+  function D(c) {
+    return A(c) === l;
+  }
+  return V.AsyncMode = o, V.ConcurrentMode = l, V.ContextConsumer = u, V.ContextProvider = a, V.Element = e, V.ForwardRef = p, V.Fragment = s, V.Lazy = I, V.Memo = E, V.Portal = t, V.Profiler = r, V.StrictMode = i, V.Suspense = d, V.isAsyncMode = function(c) {
+    return D(c) || A(c) === o;
+  }, V.isConcurrentMode = D, V.isContextConsumer = function(c) {
+    return A(c) === u;
+  }, V.isContextProvider = function(c) {
+    return A(c) === a;
+  }, V.isElement = function(c) {
+    return typeof c == "object" && c !== null && c.$$typeof === e;
+  }, V.isForwardRef = function(c) {
+    return A(c) === p;
+  }, V.isFragment = function(c) {
+    return A(c) === s;
+  }, V.isLazy = function(c) {
+    return A(c) === I;
+  }, V.isMemo = function(c) {
+    return A(c) === E;
+  }, V.isPortal = function(c) {
+    return A(c) === t;
+  }, V.isProfiler = function(c) {
+    return A(c) === r;
+  }, V.isStrictMode = function(c) {
+    return A(c) === i;
+  }, V.isSuspense = function(c) {
+    return A(c) === d;
+  }, V.isValidElementType = function(c) {
+    return typeof c == "string" || typeof c == "function" || c === s || c === l || c === r || c === i || c === d || c === k || typeof c == "object" && c !== null && (c.$$typeof === I || c.$$typeof === E || c.$$typeof === a || c.$$typeof === u || c.$$typeof === p || c.$$typeof === F || c.$$typeof === N || c.$$typeof === L || c.$$typeof === y);
+  }, V.typeOf = A, V;
+}
+var P = {};
+/** @license React v16.13.1
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var ot;
+function Ts() {
+  return ot || (ot = 1, process.env.NODE_ENV !== "production" && function() {
+    var n = typeof Symbol == "function" && Symbol.for, e = n ? Symbol.for("react.element") : 60103, t = n ? Symbol.for("react.portal") : 60106, s = n ? Symbol.for("react.fragment") : 60107, i = n ? Symbol.for("react.strict_mode") : 60108, r = n ? Symbol.for("react.profiler") : 60114, a = n ? Symbol.for("react.provider") : 60109, u = n ? Symbol.for("react.context") : 60110, o = n ? Symbol.for("react.async_mode") : 60111, l = n ? Symbol.for("react.concurrent_mode") : 60111, p = n ? Symbol.for("react.forward_ref") : 60112, d = n ? Symbol.for("react.suspense") : 60113, k = n ? Symbol.for("react.suspense_list") : 60120, E = n ? Symbol.for("react.memo") : 60115, I = n ? Symbol.for("react.lazy") : 60116, y = n ? Symbol.for("react.block") : 60121, F = n ? Symbol.for("react.fundamental") : 60117, N = n ? Symbol.for("react.responder") : 60118, L = n ? Symbol.for("react.scope") : 60119;
+    function A(f) {
+      return typeof f == "string" || typeof f == "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+      f === s || f === l || f === r || f === i || f === d || f === k || typeof f == "object" && f !== null && (f.$$typeof === I || f.$$typeof === E || f.$$typeof === a || f.$$typeof === u || f.$$typeof === p || f.$$typeof === F || f.$$typeof === N || f.$$typeof === L || f.$$typeof === y);
+    }
+    function D(f) {
+      if (typeof f == "object" && f !== null) {
+        var se = f.$$typeof;
+        switch (se) {
+          case e:
+            var Ce = f.type;
+            switch (Ce) {
+              case o:
+              case l:
+              case s:
+              case r:
+              case i:
+              case d:
+                return Ce;
+              default:
+                var et = Ce && Ce.$$typeof;
+                switch (et) {
+                  case u:
+                  case p:
+                  case I:
+                  case E:
+                  case a:
+                    return et;
+                  default:
+                    return se;
+                }
+            }
+          case t:
+            return se;
+        }
+      }
+    }
+    var c = o, $ = l, Q = u, ee = a, he = e, re = p, ne = s, te = I, W = E, U = t, de = r, Y = i, G = d, ae = !1;
+    function ue(f) {
+      return ae || (ae = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.")), h(f) || D(f) === o;
+    }
+    function h(f) {
+      return D(f) === l;
+    }
+    function m(f) {
+      return D(f) === u;
+    }
+    function w(f) {
+      return D(f) === a;
+    }
+    function g(f) {
+      return typeof f == "object" && f !== null && f.$$typeof === e;
+    }
+    function b(f) {
+      return D(f) === p;
+    }
+    function R(f) {
+      return D(f) === s;
+    }
+    function x(f) {
+      return D(f) === I;
+    }
+    function S(f) {
+      return D(f) === E;
+    }
+    function B(f) {
+      return D(f) === t;
+    }
+    function O(f) {
+      return D(f) === r;
+    }
+    function M(f) {
+      return D(f) === i;
+    }
+    function H(f) {
+      return D(f) === d;
+    }
+    P.AsyncMode = c, P.ConcurrentMode = $, P.ContextConsumer = Q, P.ContextProvider = ee, P.Element = he, P.ForwardRef = re, P.Fragment = ne, P.Lazy = te, P.Memo = W, P.Portal = U, P.Profiler = de, P.StrictMode = Y, P.Suspense = G, P.isAsyncMode = ue, P.isConcurrentMode = h, P.isContextConsumer = m, P.isContextProvider = w, P.isElement = g, P.isForwardRef = b, P.isFragment = R, P.isLazy = x, P.isMemo = S, P.isPortal = B, P.isProfiler = O, P.isStrictMode = M, P.isSuspense = H, P.isValidElementType = A, P.typeOf = D;
+  }()), P;
+}
+var lt;
+function Rt() {
+  return lt || (lt = 1, process.env.NODE_ENV === "production" ? Ae.exports = Is() : Ae.exports = Ts()), Ae.exports;
+}
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var Pe, ht;
+function ws() {
+  if (ht) return Pe;
+  ht = 1;
+  var n = Object.getOwnPropertySymbols, e = Object.prototype.hasOwnProperty, t = Object.prototype.propertyIsEnumerable;
+  function s(r) {
+    if (r == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(r);
+  }
+  function i() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var r = new String("abc");
+      if (r[5] = "de", Object.getOwnPropertyNames(r)[0] === "5")
+        return !1;
+      for (var a = {}, u = 0; u < 10; u++)
+        a["_" + String.fromCharCode(u)] = u;
+      var o = Object.getOwnPropertyNames(a).map(function(p) {
+        return a[p];
+      });
+      if (o.join("") !== "0123456789")
+        return !1;
+      var l = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(p) {
+        l[p] = p;
+      }), Object.keys(Object.assign({}, l)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return Pe = i() ? Object.assign : function(r, a) {
+    for (var u, o = s(r), l, p = 1; p < arguments.length; p++) {
+      u = Object(arguments[p]);
+      for (var d in u)
+        e.call(u, d) && (o[d] = u[d]);
+      if (n) {
+        l = n(u);
+        for (var k = 0; k < l.length; k++)
+          t.call(u, l[k]) && (o[l[k]] = u[l[k]]);
+      }
+    }
+    return o;
+  }, Pe;
+}
+var Le, ct;
+function Qe() {
+  if (ct) return Le;
+  ct = 1;
+  var n = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return Le = n, Le;
+}
+var Ne, pt;
+function Bt() {
+  return pt || (pt = 1, Ne = Function.call.bind(Object.prototype.hasOwnProperty)), Ne;
+}
+var je, dt;
+function Rs() {
+  if (dt) return je;
+  dt = 1;
+  var n = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var e = /* @__PURE__ */ Qe(), t = {}, s = /* @__PURE__ */ Bt();
+    n = function(r) {
+      var a = "Warning: " + r;
+      typeof console < "u" && console.error(a);
+      try {
+        throw new Error(a);
+      } catch {
+      }
+    };
+  }
+  function i(r, a, u, o, l) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var p in r)
+        if (s(r, p)) {
+          var d;
+          try {
+            if (typeof r[p] != "function") {
+              var k = Error(
+                (o || "React class") + ": " + u + " type `" + p + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof r[p] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw k.name = "Invariant Violation", k;
+            }
+            d = r[p](a, p, o, u, null, e);
+          } catch (I) {
+            d = I;
+          }
+          if (d && !(d instanceof Error) && n(
+            (o || "React class") + ": type specification of " + u + " `" + p + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof d + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), d instanceof Error && !(d.message in t)) {
+            t[d.message] = !0;
+            var E = l ? l() : "";
+            n(
+              "Failed " + u + " type: " + d.message + (E ?? "")
+            );
+          }
+        }
+    }
+  }
+  return i.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (t = {});
+  }, je = i, je;
+}
+var $e, ft;
+function Bs() {
+  if (ft) return $e;
+  ft = 1;
+  var n = Rt(), e = ws(), t = /* @__PURE__ */ Qe(), s = /* @__PURE__ */ Bt(), i = /* @__PURE__ */ Rs(), r = function() {
+  };
+  process.env.NODE_ENV !== "production" && (r = function(u) {
+    var o = "Warning: " + u;
+    typeof console < "u" && console.error(o);
+    try {
+      throw new Error(o);
+    } catch {
+    }
+  });
+  function a() {
+    return null;
+  }
+  return $e = function(u, o) {
+    var l = typeof Symbol == "function" && Symbol.iterator, p = "@@iterator";
+    function d(h) {
+      var m = h && (l && h[l] || h[p]);
+      if (typeof m == "function")
+        return m;
+    }
+    var k = "<<anonymous>>", E = {
+      array: N("array"),
+      bigint: N("bigint"),
+      bool: N("boolean"),
+      func: N("function"),
+      number: N("number"),
+      object: N("object"),
+      string: N("string"),
+      symbol: N("symbol"),
+      any: L(),
+      arrayOf: A,
+      element: D(),
+      elementType: c(),
+      instanceOf: $,
+      node: re(),
+      objectOf: ee,
+      oneOf: Q,
+      oneOfType: he,
+      shape: te,
+      exact: W
+    };
+    function I(h, m) {
+      return h === m ? h !== 0 || 1 / h === 1 / m : h !== h && m !== m;
+    }
+    function y(h, m) {
+      this.message = h, this.data = m && typeof m == "object" ? m : {}, this.stack = "";
+    }
+    y.prototype = Error.prototype;
+    function F(h) {
+      if (process.env.NODE_ENV !== "production")
+        var m = {}, w = 0;
+      function g(R, x, S, B, O, M, H) {
+        if (B = B || k, M = M || S, H !== t) {
+          if (o) {
+            var f = new Error(
+              "Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types"
+            );
+            throw f.name = "Invariant Violation", f;
+          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
+            var se = B + ":" + S;
+            !m[se] && // Avoid spamming the console because they are often not actionable except for lib authors
+            w < 3 && (r(
+              "You are manually calling a React.PropTypes validation function for the `" + M + "` prop on `" + B + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."
+            ), m[se] = !0, w++);
+          }
+        }
+        return x[S] == null ? R ? x[S] === null ? new y("The " + O + " `" + M + "` is marked as required " + ("in `" + B + "`, but its value is `null`.")) : new y("The " + O + " `" + M + "` is marked as required in " + ("`" + B + "`, but its value is `undefined`.")) : null : h(x, S, B, O, M);
+      }
+      var b = g.bind(null, !1);
+      return b.isRequired = g.bind(null, !0), b;
+    }
+    function N(h) {
+      function m(w, g, b, R, x, S) {
+        var B = w[g], O = Y(B);
+        if (O !== h) {
+          var M = G(B);
+          return new y(
+            "Invalid " + R + " `" + x + "` of type " + ("`" + M + "` supplied to `" + b + "`, expected ") + ("`" + h + "`."),
+            { expectedType: h }
+          );
+        }
+        return null;
+      }
+      return F(m);
+    }
+    function L() {
+      return F(a);
+    }
+    function A(h) {
+      function m(w, g, b, R, x) {
+        if (typeof h != "function")
+          return new y("Property `" + x + "` of component `" + b + "` has invalid PropType notation inside arrayOf.");
+        var S = w[g];
+        if (!Array.isArray(S)) {
+          var B = Y(S);
+          return new y("Invalid " + R + " `" + x + "` of type " + ("`" + B + "` supplied to `" + b + "`, expected an array."));
+        }
+        for (var O = 0; O < S.length; O++) {
+          var M = h(S, O, b, R, x + "[" + O + "]", t);
+          if (M instanceof Error)
+            return M;
+        }
+        return null;
+      }
+      return F(m);
+    }
+    function D() {
+      function h(m, w, g, b, R) {
+        var x = m[w];
+        if (!u(x)) {
+          var S = Y(x);
+          return new y("Invalid " + b + " `" + R + "` of type " + ("`" + S + "` supplied to `" + g + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return F(h);
+    }
+    function c() {
+      function h(m, w, g, b, R) {
+        var x = m[w];
+        if (!n.isValidElementType(x)) {
+          var S = Y(x);
+          return new y("Invalid " + b + " `" + R + "` of type " + ("`" + S + "` supplied to `" + g + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return F(h);
+    }
+    function $(h) {
+      function m(w, g, b, R, x) {
+        if (!(w[g] instanceof h)) {
+          var S = h.name || k, B = ue(w[g]);
+          return new y("Invalid " + R + " `" + x + "` of type " + ("`" + B + "` supplied to `" + b + "`, expected ") + ("instance of `" + S + "`."));
+        }
+        return null;
+      }
+      return F(m);
+    }
+    function Q(h) {
+      if (!Array.isArray(h))
+        return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? r(
+          "Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])."
+        ) : r("Invalid argument supplied to oneOf, expected an array.")), a;
+      function m(w, g, b, R, x) {
+        for (var S = w[g], B = 0; B < h.length; B++)
+          if (I(S, h[B]))
+            return null;
+        var O = JSON.stringify(h, function(H, f) {
+          var se = G(f);
+          return se === "symbol" ? String(f) : f;
+        });
+        return new y("Invalid " + R + " `" + x + "` of value `" + String(S) + "` " + ("supplied to `" + b + "`, expected one of " + O + "."));
+      }
+      return F(m);
+    }
+    function ee(h) {
+      function m(w, g, b, R, x) {
+        if (typeof h != "function")
+          return new y("Property `" + x + "` of component `" + b + "` has invalid PropType notation inside objectOf.");
+        var S = w[g], B = Y(S);
+        if (B !== "object")
+          return new y("Invalid " + R + " `" + x + "` of type " + ("`" + B + "` supplied to `" + b + "`, expected an object."));
+        for (var O in S)
+          if (s(S, O)) {
+            var M = h(S, O, b, R, x + "." + O, t);
+            if (M instanceof Error)
+              return M;
+          }
+        return null;
+      }
+      return F(m);
+    }
+    function he(h) {
+      if (!Array.isArray(h))
+        return process.env.NODE_ENV !== "production" && r("Invalid argument supplied to oneOfType, expected an instance of array."), a;
+      for (var m = 0; m < h.length; m++) {
+        var w = h[m];
+        if (typeof w != "function")
+          return r(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + ae(w) + " at index " + m + "."
+          ), a;
+      }
+      function g(b, R, x, S, B) {
+        for (var O = [], M = 0; M < h.length; M++) {
+          var H = h[M], f = H(b, R, x, S, B, t);
+          if (f == null)
+            return null;
+          f.data && s(f.data, "expectedType") && O.push(f.data.expectedType);
+        }
+        var se = O.length > 0 ? ", expected one of type [" + O.join(", ") + "]" : "";
+        return new y("Invalid " + S + " `" + B + "` supplied to " + ("`" + x + "`" + se + "."));
+      }
+      return F(g);
+    }
+    function re() {
+      function h(m, w, g, b, R) {
+        return U(m[w]) ? null : new y("Invalid " + b + " `" + R + "` supplied to " + ("`" + g + "`, expected a ReactNode."));
+      }
+      return F(h);
+    }
+    function ne(h, m, w, g, b) {
+      return new y(
+        (h || "React class") + ": " + m + " type `" + w + "." + g + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + b + "`."
+      );
+    }
+    function te(h) {
+      function m(w, g, b, R, x) {
+        var S = w[g], B = Y(S);
+        if (B !== "object")
+          return new y("Invalid " + R + " `" + x + "` of type `" + B + "` " + ("supplied to `" + b + "`, expected `object`."));
+        for (var O in h) {
+          var M = h[O];
+          if (typeof M != "function")
+            return ne(b, R, x, O, G(M));
+          var H = M(S, O, b, R, x + "." + O, t);
+          if (H)
+            return H;
+        }
+        return null;
+      }
+      return F(m);
+    }
+    function W(h) {
+      function m(w, g, b, R, x) {
+        var S = w[g], B = Y(S);
+        if (B !== "object")
+          return new y("Invalid " + R + " `" + x + "` of type `" + B + "` " + ("supplied to `" + b + "`, expected `object`."));
+        var O = e({}, w[g], h);
+        for (var M in O) {
+          var H = h[M];
+          if (s(h, M) && typeof H != "function")
+            return ne(b, R, x, M, G(H));
+          if (!H)
+            return new y(
+              "Invalid " + R + " `" + x + "` key `" + M + "` supplied to `" + b + "`.\nBad object: " + JSON.stringify(w[g], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(h), null, "  ")
+            );
+          var f = H(S, M, b, R, x + "." + M, t);
+          if (f)
+            return f;
+        }
+        return null;
+      }
+      return F(m);
+    }
+    function U(h) {
+      switch (typeof h) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !h;
+        case "object":
+          if (Array.isArray(h))
+            return h.every(U);
+          if (h === null || u(h))
+            return !0;
+          var m = d(h);
+          if (m) {
+            var w = m.call(h), g;
+            if (m !== h.entries) {
+              for (; !(g = w.next()).done; )
+                if (!U(g.value))
+                  return !1;
+            } else
+              for (; !(g = w.next()).done; ) {
+                var b = g.value;
+                if (b && !U(b[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function de(h, m) {
+      return h === "symbol" ? !0 : m ? m["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && m instanceof Symbol : !1;
+    }
+    function Y(h) {
+      var m = typeof h;
+      return Array.isArray(h) ? "array" : h instanceof RegExp ? "object" : de(m, h) ? "symbol" : m;
+    }
+    function G(h) {
+      if (typeof h > "u" || h === null)
+        return "" + h;
+      var m = Y(h);
+      if (m === "object") {
+        if (h instanceof Date)
+          return "date";
+        if (h instanceof RegExp)
+          return "regexp";
+      }
+      return m;
+    }
+    function ae(h) {
+      var m = G(h);
+      switch (m) {
+        case "array":
+        case "object":
+          return "an " + m;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + m;
+        default:
+          return m;
+      }
+    }
+    function ue(h) {
+      return !h.constructor || !h.constructor.name ? k : h.constructor.name;
+    }
+    return E.checkPropTypes = i, E.resetWarningCache = i.resetWarningCache, E.PropTypes = E, E;
+  }, $e;
+}
+var Ue, mt;
+function Ms() {
+  if (mt) return Ue;
+  mt = 1;
+  var n = /* @__PURE__ */ Qe();
+  function e() {
+  }
+  function t() {
+  }
+  return t.resetWarningCache = e, Ue = function() {
+    function s(a, u, o, l, p, d) {
+      if (d !== n) {
+        var k = new Error(
+          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
+        );
+        throw k.name = "Invariant Violation", k;
+      }
+    }
+    s.isRequired = s;
+    function i() {
+      return s;
+    }
+    var r = {
+      array: s,
+      bigint: s,
+      bool: s,
+      func: s,
+      number: s,
+      object: s,
+      string: s,
+      symbol: s,
+      any: s,
+      arrayOf: i,
+      element: s,
+      elementType: s,
+      instanceOf: i,
+      node: s,
+      objectOf: i,
+      oneOf: i,
+      oneOfType: i,
+      shape: i,
+      exact: i,
+      checkPropTypes: t,
+      resetWarningCache: e
+    };
+    return r.PropTypes = r, r;
+  }, Ue;
+}
+var vt;
+function Os() {
+  if (vt) return be.exports;
+  if (vt = 1, process.env.NODE_ENV !== "production") {
+    var n = Rt(), e = !0;
+    be.exports = /* @__PURE__ */ Bs()(n.isElement, e);
+  } else
+    be.exports = /* @__PURE__ */ Ms()();
+  return be.exports;
+}
+var Ds = /* @__PURE__ */ Os();
+const v = /* @__PURE__ */ wt(Ds), Mt = {
+  // common
+  mask: v.oneOfType([v.array, v.func, v.string, v.instanceOf(RegExp), v.oneOf([Date, Number, C.Masked]), v.instanceOf(C.Masked)]),
+  value: v.any,
+  unmask: v.oneOfType([v.bool, v.oneOf(["typed"])]),
+  prepare: v.func,
+  prepareChar: v.func,
+  validate: v.func,
+  commit: v.func,
+  overwrite: v.oneOfType([v.bool, v.oneOf(["shift"])]),
+  eager: v.oneOfType([v.bool, v.oneOf(["append", "remove"])]),
+  skipInvalid: v.bool,
+  // events
+  onAccept: v.func,
+  onComplete: v.func,
+  // pattern
+  placeholderChar: v.string,
+  displayChar: v.string,
+  lazy: v.bool,
+  definitions: v.object,
+  blocks: v.object,
+  // enum
+  enum: v.arrayOf(v.string),
+  // range
+  maxLength: v.number,
+  from: v.number,
+  to: v.number,
+  // date
+  pattern: v.string,
+  format: v.func,
+  parse: v.func,
+  autofix: v.oneOfType([v.bool, v.oneOf(["pad"])]),
+  // number
+  radix: v.string,
+  thousandsSeparator: v.string,
+  mapToRadix: v.arrayOf(v.string),
+  scale: v.number,
+  normalizeZeros: v.bool,
+  padFractionalZeros: v.bool,
+  min: v.oneOfType([v.number, v.instanceOf(Date)]),
+  max: v.oneOfType([v.number, v.instanceOf(Date)]),
+  // dynamic
+  dispatch: v.func,
+  // ref
+  inputRef: v.oneOfType([v.func, v.shape({
+    current: v.object
+  })])
+}, Ot = Object.keys(Mt).filter((n) => n !== "value"), Vs = ["value", "unmask", "onAccept", "onComplete", "inputRef"], Ps = Ot.filter((n) => Vs.indexOf(n) < 0);
+function Ls(n) {
+  var e;
+  const t = (e = class extends ce.Component {
+    constructor(r) {
+      super(r), this._inputRef = this._inputRef.bind(this);
+    }
+    componentDidMount() {
+      this.props.mask && this.initMask();
+    }
+    componentDidUpdate() {
+      const r = this.props, a = this._extractMaskOptionsFromProps(r);
+      if (a.mask)
+        this.maskRef ? (this.maskRef.updateOptions(a), "value" in r && r.value !== void 0 && (this.maskValue = r.value)) : this.initMask(a);
+      else if (this.destroyMask(), "value" in r && r.value !== void 0) {
+        var u;
+        (u = this.element) != null && u.isContentEditable && this.element.tagName !== "INPUT" && this.element.tagName !== "TEXTAREA" ? this.element.textContent = r.value : this.element.value = r.value;
+      }
+    }
+    componentWillUnmount() {
+      this.destroyMask();
+    }
+    _inputRef(r) {
+      this.element = r, this.props.inputRef && (Object.prototype.hasOwnProperty.call(this.props.inputRef, "current") ? this.props.inputRef.current = r : this.props.inputRef(r));
+    }
+    initMask(r) {
+      r === void 0 && (r = this._extractMaskOptionsFromProps(this.props)), this.maskRef = C(this.element, r).on("accept", this._onAccept.bind(this)).on("complete", this._onComplete.bind(this)), "value" in this.props && this.props.value !== void 0 && (this.maskValue = this.props.value);
+    }
+    destroyMask() {
+      this.maskRef && (this.maskRef.destroy(), delete this.maskRef);
+    }
+    _extractMaskOptionsFromProps(r) {
+      const {
+        ...a
+      } = r;
+      return Object.keys(a).filter((u) => Ps.indexOf(u) < 0).forEach((u) => {
+        delete a[u];
+      }), a;
+    }
+    _extractNonMaskProps(r) {
+      const {
+        ...a
+      } = r;
+      return Ot.forEach((u) => {
+        u !== "maxLength" && delete a[u];
+      }), "defaultValue" in a || (a.defaultValue = r.mask ? "" : a.value), delete a.value, a;
+    }
+    get maskValue() {
+      return this.maskRef ? this.props.unmask === "typed" ? this.maskRef.typedValue : this.props.unmask ? this.maskRef.unmaskedValue : this.maskRef.value : "";
+    }
+    set maskValue(r) {
+      this.maskRef && (r = r == null && this.props.unmask !== "typed" ? "" : r, this.props.unmask === "typed" ? this.maskRef.typedValue = r : this.props.unmask ? this.maskRef.unmaskedValue = r : this.maskRef.value = r);
+    }
+    _onAccept(r) {
+      this.props.onAccept && this.maskRef && this.props.onAccept(this.maskValue, this.maskRef, r);
+    }
+    _onComplete(r) {
+      this.props.onComplete && this.maskRef && this.props.onComplete(this.maskValue, this.maskRef, r);
+    }
+    render() {
+      return ce.createElement(n, {
+        ...this._extractNonMaskProps(this.props),
+        inputRef: this._inputRef
+      });
+    }
+  }, e.displayName = void 0, e.propTypes = void 0, e), s = n.displayName || n.name || "Component";
+  return t.displayName = "IMask(" + s + ")", t.propTypes = Mt, ce.forwardRef((i, r) => ce.createElement(t, {
+    ...i,
+    ref: r
+  }));
+}
+const Ns = Ls((n) => {
+  let {
+    inputRef: e,
+    ...t
+  } = n;
+  return ce.createElement("input", {
+    ...t,
+    ref: e
+  });
+}), js = (n, e) => ce.createElement(Ns, {
+  ...n,
+  ref: e
+}), $s = ce.forwardRef(js), Us = "_input_u23b9_1", zs = "_section_u23b9_7", Dt = {
+  input: Us,
+  section: zs
+}, qs = (n) => /* @__PURE__ */ tt.createElement("svg", { width: 20, height: 20, viewBox: "0 0 20 20", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...n }, /* @__PURE__ */ tt.createElement("path", { d: "M2.49984 2.5H17.4998C17.7209 2.5 17.9328 2.5878 18.0891 2.74408C18.2454 2.90036 18.3332 3.11232 18.3332 3.33333V16.6667C18.3332 16.8877 18.2454 17.0996 18.0891 17.2559C17.9328 17.4122 17.7209 17.5 17.4998 17.5H2.49984C2.27882 17.5 2.06686 17.4122 1.91058 17.2559C1.7543 17.0996 1.6665 16.8877 1.6665 16.6667V3.33333C1.6665 3.11232 1.7543 2.90036 1.91058 2.74408C2.06686 2.5878 2.27882 2.5 2.49984 2.5ZM16.6665 9.16667H3.33317V15.8333H16.6665V9.16667ZM16.6665 7.5V4.16667H3.33317V7.5H16.6665ZM11.6665 12.5H14.9998V14.1667H11.6665V12.5Z", fill: "currentColor", fillOpacity: 0.4, style: {
+  fill: "#0D1126",
+  fill: "color(display-p3 0.0510 0.0667 0.1490)",
+  fillOpacity: 0.4
+} }));
+var ze = { exports: {} };
+/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+*/
+var _t;
+function Ys() {
+  return _t || (_t = 1, function(n) {
+    (function() {
+      var e = {}.hasOwnProperty;
+      function t() {
+        for (var r = "", a = 0; a < arguments.length; a++) {
+          var u = arguments[a];
+          u && (r = i(r, s(u)));
+        }
+        return r;
+      }
+      function s(r) {
+        if (typeof r == "string" || typeof r == "number")
+          return r;
+        if (typeof r != "object")
+          return "";
+        if (Array.isArray(r))
+          return t.apply(null, r);
+        if (r.toString !== Object.prototype.toString && !r.toString.toString().includes("[native code]"))
+          return r.toString();
+        var a = "";
+        for (var u in r)
+          e.call(r, u) && r[u] && (a = i(a, u));
+        return a;
+      }
+      function i(r, a) {
+        return a ? r ? r + " " + a : r + a : r;
+      }
+      n.exports ? (t.default = t, n.exports = t) : window.classNames = t;
+    })();
+  }(ze)), ze.exports;
+}
+var Hs = Ys();
+const Ws = /* @__PURE__ */ wt(Hs), Ks = Ws(Dt.input, Ut["caption-l-regular"]), Gs = Xe.withProps({
+  leftSection: /* @__PURE__ */ j(qs, {}),
+  component: $s,
+  mask: "0000 0000 0000 0000",
+  placeholder: "____ ____ ____ ____",
+  classNames: { input: Ks, section: Dt.section }
+}), ni = (n) => {
+  const e = zt(n.value);
+  return /* @__PURE__ */ j(
+    Gs,
+    {
+      ...n,
+      rightSection: e && /* @__PURE__ */ j(e, {})
+    }
+  );
+};
+export {
+  ni as CardInput,
+  Gs as CardInputBase
+};