@kvell-group/ui 1.8.3 → 1.9.1

package/dist/components/CardInput/CardInput.js

@@ -0,0 +1,3223 @@
+import { jsx as wt } from "react/jsx-runtime";
+import { InputBase as ue } from "@mantine/core";
+import * as Dt from "react";
+import X from "react";
+import { c as oe } from "../../Text.module-R-XLggXY.js";
+import { useCardLogo as le } from "./useCardLogo.js";
+import '../../assets/CardInput.css';function G(a) {
+  return typeof a == "string" || a instanceof String;
+}
+function Vt(a) {
+  var t;
+  return typeof a == "object" && a != null && (a == null || (t = a.constructor) == null ? void 0 : t.name) === "Object";
+}
+function Wt(a, t) {
+  return Array.isArray(t) ? Wt(a, (e, s) => t.includes(s)) : Object.entries(a).reduce((e, s) => {
+    let [r, i] = s;
+    return t(i, r) && (e[r] = i), e;
+  }, {});
+}
+const m = {
+  NONE: "NONE",
+  LEFT: "LEFT",
+  FORCE_LEFT: "FORCE_LEFT",
+  RIGHT: "RIGHT",
+  FORCE_RIGHT: "FORCE_RIGHT"
+};
+function he(a) {
+  switch (a) {
+    case m.LEFT:
+      return m.FORCE_LEFT;
+    case m.RIGHT:
+      return m.FORCE_RIGHT;
+    default:
+      return a;
+  }
+}
+function Ct(a) {
+  return a.replace(/([.*+?^=!:${}()|[\]/\\])/g, "\\$1");
+}
+function ot(a, t) {
+  if (t === a) return !0;
+  const e = Array.isArray(t), s = Array.isArray(a);
+  let r;
+  if (e && s) {
+    if (t.length != a.length) return !1;
+    for (r = 0; r < t.length; r++) if (!ot(t[r], a[r])) return !1;
+    return !0;
+  }
+  if (e != s) return !1;
+  if (t && a && typeof t == "object" && typeof a == "object") {
+    const i = t instanceof Date, n = a instanceof Date;
+    if (i && n) return t.getTime() == a.getTime();
+    if (i != n) return !1;
+    const u = t instanceof RegExp, l = a instanceof RegExp;
+    if (u && l) return t.toString() == a.toString();
+    if (u != l) return !1;
+    const h = Object.keys(t);
+    for (r = 0; r < h.length; r++) if (!Object.prototype.hasOwnProperty.call(a, h[r])) return !1;
+    for (r = 0; r < h.length; r++) if (!ot(a[h[r]], t[h[r]])) return !1;
+    return !0;
+  } else if (t && a && typeof t == "function" && typeof a == "function")
+    return t.toString() === a.toString();
+  return !1;
+}
+class pe {
+  /** Current input value */
+  /** Current cursor position */
+  /** Old input value */
+  /** Old selection */
+  constructor(t) {
+    for (Object.assign(this, t); 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 ? m.NONE : (this.oldSelection.end === this.cursorPos || this.oldSelection.start === this.cursorPos) && // if not range removed (event with backspace)
+    this.oldSelection.end === this.oldSelection.start ? m.RIGHT : m.LEFT;
+  }
+}
+function g(a, t) {
+  return new g.InputMask(a, t);
+}
+function Zt(a) {
+  if (a == null) throw new Error("mask property should be defined");
+  return a instanceof RegExp ? g.MaskedRegExp : G(a) ? g.MaskedPattern : a === Date ? g.MaskedDate : a === Number ? g.MaskedNumber : Array.isArray(a) || a === Array ? g.MaskedDynamic : g.Masked && a.prototype instanceof g.Masked ? a : g.Masked && a instanceof g.Masked ? a.constructor : a instanceof Function ? g.MaskedFunction : (console.warn("Mask not found for mask", a), g.Masked);
+}
+function et(a) {
+  if (!a) throw new Error("Options in not defined");
+  if (g.Masked) {
+    if (a.prototype instanceof g.Masked) return {
+      mask: a
+    };
+    const {
+      mask: t = void 0,
+      ...e
+    } = a instanceof g.Masked ? {
+      mask: a
+    } : Vt(a) && a.mask instanceof g.Masked ? a : {};
+    if (t) {
+      const s = t.mask;
+      return {
+        ...Wt(t, (r, i) => !i.startsWith("_")),
+        mask: t.constructor,
+        _mask: s,
+        ...e
+      };
+    }
+  }
+  return Vt(a) ? {
+    ...a
+  } : {
+    mask: a
+  };
+}
+function K(a) {
+  if (g.Masked && a instanceof g.Masked) return a;
+  const t = et(a), e = Zt(t.mask);
+  if (!e) throw new Error("Masked class is not found for provided mask " + t.mask + ", appropriate module needs to be imported manually before creating mask.");
+  return t.mask === e && delete t.mask, t._mask && (t.mask = t._mask, delete t._mask), new e(t);
+}
+g.createMask = K;
+class Mt {
+  /** */
+  /** */
+  /** */
+  /** Safely returns selection start */
+  get selectionStart() {
+    let t;
+    try {
+      t = this._unsafeSelectionStart;
+    } catch {
+    }
+    return t ?? this.value.length;
+  }
+  /** Safely returns selection end */
+  get selectionEnd() {
+    let t;
+    try {
+      t = this._unsafeSelectionEnd;
+    } catch {
+    }
+    return t ?? this.value.length;
+  }
+  /** Safely sets element selection */
+  select(t, e) {
+    if (!(t == null || e == null || t === this.selectionStart && e === this.selectionEnd))
+      try {
+        this._unsafeSelect(t, e);
+      } catch {
+      }
+  }
+  /** */
+  get isActive() {
+    return !1;
+  }
+  /** */
+  /** */
+  /** */
+}
+g.MaskElement = Mt;
+const Pt = 90, ce = 89;
+class ht extends Mt {
+  /** HTMLElement to use mask on */
+  constructor(t) {
+    super(), this.input = t, 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 t, e, s;
+    return (t = (e = (s = this.input).getRootNode) == null ? void 0 : e.call(s)) != null ? t : document;
+  }
+  /** Is element in focus */
+  get isActive() {
+    return this.input === this.rootElement.activeElement;
+  }
+  /** Binds HTMLElement events to mask internal events */
+  bindEvents(t) {
+    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", t.drop), this.input.addEventListener("click", t.click), this.input.addEventListener("focus", t.focus), this.input.addEventListener("blur", t.commit), this._handlers = t;
+  }
+  _onKeydown(t) {
+    if (this._handlers.redo && (t.keyCode === Pt && t.shiftKey && (t.metaKey || t.ctrlKey) || t.keyCode === ce && t.ctrlKey))
+      return t.preventDefault(), this._handlers.redo(t);
+    if (this._handlers.undo && t.keyCode === Pt && (t.metaKey || t.ctrlKey))
+      return t.preventDefault(), this._handlers.undo(t);
+    t.isComposing || this._handlers.selectionChange(t);
+  }
+  _onBeforeinput(t) {
+    if (t.inputType === "historyUndo" && this._handlers.undo)
+      return t.preventDefault(), this._handlers.undo(t);
+    if (t.inputType === "historyRedo" && this._handlers.redo)
+      return t.preventDefault(), this._handlers.redo(t);
+  }
+  _onCompositionEnd(t) {
+    this._handlers.input(t);
+  }
+  _onInput(t) {
+    t.isComposing || this._handlers.input(t);
+  }
+  /** 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 = {};
+  }
+}
+g.HTMLMaskElement = ht;
+class de extends ht {
+  /** InputElement to use mask on */
+  constructor(t) {
+    super(t), this.input = t;
+  }
+  /** 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(t, e) {
+    this.input.setSelectionRange(t, e);
+  }
+  get value() {
+    return this.input.value;
+  }
+  set value(t) {
+    this.input.value = t;
+  }
+}
+g.HTMLMaskElement = ht;
+class Xt extends ht {
+  /** Returns HTMLElement selection start */
+  get _unsafeSelectionStart() {
+    const t = this.rootElement, e = t.getSelection && t.getSelection(), s = e && e.anchorOffset, r = e && e.focusOffset;
+    return r == null || s == null || s < r ? s : r;
+  }
+  /** Returns HTMLElement selection end */
+  get _unsafeSelectionEnd() {
+    const t = this.rootElement, e = t.getSelection && t.getSelection(), s = e && e.anchorOffset, r = e && e.focusOffset;
+    return r == null || s == null || s > r ? s : r;
+  }
+  /** Sets HTMLElement selection */
+  _unsafeSelect(t, e) {
+    if (!this.rootElement.createRange) return;
+    const s = this.rootElement.createRange();
+    s.setStart(this.input.firstChild || this.input, t), s.setEnd(this.input.lastChild || this.input, e);
+    const r = this.rootElement, i = r.getSelection && r.getSelection();
+    i && (i.removeAllRanges(), i.addRange(s));
+  }
+  /** HTMLElement value */
+  get value() {
+    return this.input.textContent || "";
+  }
+  set value(t) {
+    this.input.textContent = t;
+  }
+}
+g.HTMLContenteditableMaskElement = Xt;
+class pt {
+  constructor() {
+    this.states = [], this.currentIndex = 0;
+  }
+  get currentState() {
+    return this.states[this.currentIndex];
+  }
+  get isEmpty() {
+    return this.states.length === 0;
+  }
+  push(t) {
+    this.currentIndex < this.states.length - 1 && (this.states.length = this.currentIndex + 1), this.states.push(t), this.states.length > pt.MAX_LENGTH && this.states.shift(), this.currentIndex = this.states.length - 1;
+  }
+  go(t) {
+    return this.currentIndex = Math.min(Math.max(this.currentIndex + t, 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;
+  }
+}
+pt.MAX_LENGTH = 100;
+class fe {
+  /**
+    View element
+  */
+  /** Internal {@link Masked} model */
+  constructor(t, e) {
+    this.el = t instanceof Mt ? t : t.isContentEditable && t.tagName !== "INPUT" && t.tagName !== "TEXTAREA" ? new Xt(t) : new de(t), this.masked = K(e), this._listeners = {}, this._value = "", this._unmaskedValue = "", this._rawInputValue = "", this.history = new pt(), 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(t) {
+    var e;
+    return t == null || ((e = this.masked) == null ? void 0 : e.maskEquals(t));
+  }
+  /** Masked */
+  get mask() {
+    return this.masked.mask;
+  }
+  set mask(t) {
+    if (this.maskEquals(t)) return;
+    if (!(t instanceof g.Masked) && this.masked.constructor === Zt(t)) {
+      this.masked.updateOptions({
+        mask: t
+      });
+      return;
+    }
+    const e = t instanceof g.Masked ? t : K({
+      mask: t
+    });
+    e.unmaskedValue = this.masked.unmaskedValue, this.masked = e;
+  }
+  /** Raw value */
+  get value() {
+    return this._value;
+  }
+  set value(t) {
+    this.value !== t && (this.masked.value = t, this.updateControl("auto"));
+  }
+  /** Unmasked value */
+  get unmaskedValue() {
+    return this._unmaskedValue;
+  }
+  set unmaskedValue(t) {
+    this.unmaskedValue !== t && (this.masked.unmaskedValue = t, this.updateControl("auto"));
+  }
+  /** Raw input value */
+  get rawInputValue() {
+    return this._rawInputValue;
+  }
+  set rawInputValue(t) {
+    this.rawInputValue !== t && (this.masked.rawInputValue = t, this.updateControl(), this.alignCursor());
+  }
+  /** Typed unmasked value */
+  get typedValue() {
+    return this.masked.typedValue;
+  }
+  set typedValue(t) {
+    this.masked.typedValueEquals(t) || (this.masked.typedValue = t, 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(t, e) {
+    const s = this._listeners[t];
+    s && s.forEach((r) => r(e));
+  }
+  /** 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(t) {
+    !this.el || !this.el.isActive || (this.el.select(t, t), 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(t) {
+    const e = this.masked.unmaskedValue, s = this.masked.value, r = this.masked.rawInputValue, i = this.displayValue, n = this.unmaskedValue !== e || this.value !== s || this._rawInputValue !== r;
+    this._unmaskedValue = e, this._value = s, this._rawInputValue = r, this.el.value !== i && (this.el.value = i), t === "auto" ? this.alignCursor() : t != null && (this.cursorPos = t), n && this._fireChangeEvents(), !this._historyChanging && (n || this.history.isEmpty) && this.history.push({
+      unmaskedValue: e,
+      selection: {
+        start: this.selectionStart,
+        end: this.cursorPos
+      }
+    });
+  }
+  /** Updates options with deep equal check, recreates {@link Masked} model if mask type changes */
+  updateOptions(t) {
+    const {
+      mask: e,
+      ...s
+    } = t, r = !this.maskEquals(e), i = this.masked.optionsIsChanged(s);
+    r && (this.mask = e), i && this.masked.updateOptions(s), (r || i) && this.updateControl();
+  }
+  /** Updates cursor */
+  updateCursor(t) {
+    t != null && (this.cursorPos = t, this._delayUpdateCursor(t));
+  }
+  /** Delays cursor update to support mobile browsers */
+  _delayUpdateCursor(t) {
+    this._abortUpdateCursor(), this._changingCursorPos = t, 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, m.LEFT));
+  }
+  /** Aligns cursor only if selection is empty */
+  alignCursorFriendly() {
+    this.selectionStart === this.cursorPos && this.alignCursor();
+  }
+  /** Adds listener on custom event */
+  on(t, e) {
+    return this._listeners[t] || (this._listeners[t] = []), this._listeners[t].push(e), this;
+  }
+  /** Removes custom event listener */
+  off(t, e) {
+    if (!this._listeners[t]) return this;
+    if (!e)
+      return delete this._listeners[t], this;
+    const s = this._listeners[t].indexOf(e);
+    return s >= 0 && this._listeners[t].splice(s, 1), this;
+  }
+  /** Handles view input event */
+  _onInput(t) {
+    this._inputEvent = t, this._abortUpdateCursor();
+    const e = new pe({
+      // new state
+      value: this.el.value,
+      cursorPos: this.cursorPos,
+      // old state
+      oldValue: this.displayValue,
+      oldSelection: this._selection
+    }), s = this.masked.rawInputValue, r = this.masked.splice(e.startChangePos, e.removed.length, e.inserted, e.removeDirection, {
+      input: !0,
+      raw: !0
+    }).offset, i = s === this.masked.rawInputValue ? e.removeDirection : m.NONE;
+    let n = this.masked.nearestInputPos(e.startChangePos + r, i);
+    i !== m.NONE && (n = this.masked.nearestInputPos(n, m.NONE)), this.updateControl(n), 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(t) {
+    t.preventDefault(), t.stopPropagation();
+  }
+  /** Restore last selection on focus */
+  _onFocus(t) {
+    this.alignCursorFriendly();
+  }
+  /** Restore last selection on focus */
+  _onClick(t) {
+    this.alignCursorFriendly();
+  }
+  _onUndo() {
+    this._applyHistoryState(this.history.undo());
+  }
+  _onRedo() {
+    this._applyHistoryState(this.history.redo());
+  }
+  _applyHistoryState(t) {
+    t && (this._historyChanging = !0, this.unmaskedValue = t.unmaskedValue, this.el.select(t.selection.start, t.selection.end), this._saveSelection(), this._historyChanging = !1);
+  }
+  /** Unbind view events and removes element reference */
+  destroy() {
+    this._unbindEvents(), this._listeners.length = 0, delete this.el;
+  }
+}
+g.InputMask = fe;
+class E {
+  /** Inserted symbols */
+  /** Additional offset if any changes occurred before tail */
+  /** Raw inserted is used by dynamic mask */
+  /** Can skip chars */
+  static normalize(t) {
+    return Array.isArray(t) ? t : [t, new E()];
+  }
+  constructor(t) {
+    Object.assign(this, {
+      inserted: "",
+      rawInserted: "",
+      tailShift: 0,
+      skip: !1
+    }, t);
+  }
+  /** Aggregate changes */
+  aggregate(t) {
+    return this.inserted += t.inserted, this.rawInserted += t.rawInserted, this.tailShift += t.tailShift, this.skip = this.skip || t.skip, this;
+  }
+  /** Total offset considering all changes */
+  get offset() {
+    return this.tailShift + this.inserted.length;
+  }
+  get consumed() {
+    return !!this.rawInserted || this.skip;
+  }
+  equals(t) {
+    return this.inserted === t.inserted && this.tailShift === t.tailShift && this.rawInserted === t.rawInserted && this.skip === t.skip;
+  }
+}
+g.ChangeDetails = E;
+class H {
+  /** Tail value as string */
+  /** Tail start position */
+  /** Start position */
+  constructor(t, e, s) {
+    t === void 0 && (t = ""), e === void 0 && (e = 0), this.value = t, this.from = e, this.stop = s;
+  }
+  toString() {
+    return this.value;
+  }
+  extend(t) {
+    this.value += String(t);
+  }
+  appendTo(t) {
+    return t.append(this.toString(), {
+      tail: !0
+    }).aggregate(t._appendPlaceholder());
+  }
+  get state() {
+    return {
+      value: this.value,
+      from: this.from,
+      stop: this.stop
+    };
+  }
+  set state(t) {
+    Object.assign(this, t);
+  }
+  unshift(t) {
+    if (!this.value.length || t != null && this.from >= t) return "";
+    const e = this.value[0];
+    return this.value = this.value.slice(1), e;
+  }
+  shift() {
+    if (!this.value.length) return "";
+    const t = this.value[this.value.length - 1];
+    return this.value = this.value.slice(0, -1), t;
+  }
+}
+class P {
+  /** */
+  /** */
+  /** 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(t) {
+    this._value = "", this._update({
+      ...P.DEFAULTS,
+      ...t
+    }), this._initialized = !0;
+  }
+  /** Sets and applies new options */
+  updateOptions(t) {
+    this.optionsIsChanged(t) && this.withValueRefresh(this._update.bind(this, t));
+  }
+  /** Sets new options */
+  _update(t) {
+    Object.assign(this, t);
+  }
+  /** Mask state */
+  get state() {
+    return {
+      _value: this.value,
+      _rawInputValue: this.rawInputValue
+    };
+  }
+  set state(t) {
+    this._value = t._value;
+  }
+  /** Resets value */
+  reset() {
+    this._value = "";
+  }
+  get value() {
+    return this._value;
+  }
+  set value(t) {
+    this.resolve(t, {
+      input: !0
+    });
+  }
+  /** Resolve new value */
+  resolve(t, e) {
+    e === void 0 && (e = {
+      input: !0
+    }), this.reset(), this.append(t, e, ""), this.doCommit();
+  }
+  get unmaskedValue() {
+    return this.value;
+  }
+  set unmaskedValue(t) {
+    this.resolve(t, {});
+  }
+  get typedValue() {
+    return this.parse ? this.parse(this.value, this) : this.unmaskedValue;
+  }
+  set typedValue(t) {
+    this.format ? this.value = this.format(t, this) : this.unmaskedValue = String(t);
+  }
+  /** Value that includes raw user input */
+  get rawInputValue() {
+    return this.extractInput(0, this.displayValue.length, {
+      raw: !0
+    });
+  }
+  set rawInputValue(t) {
+    this.resolve(t, {
+      raw: !0
+    });
+  }
+  get displayValue() {
+    return this.value;
+  }
+  get isComplete() {
+    return !0;
+  }
+  get isFilled() {
+    return this.isComplete;
+  }
+  /** Finds nearest input position in direction */
+  nearestInputPos(t, e) {
+    return t;
+  }
+  totalInputPositions(t, e) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), Math.min(this.displayValue.length, e - t);
+  }
+  /** Extracts value in range considering flags */
+  extractInput(t, e, s) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), this.displayValue.slice(t, e);
+  }
+  /** Extracts tail in range */
+  extractTail(t, e) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), new H(this.extractInput(t, e), t);
+  }
+  /** Appends tail */
+  appendTail(t) {
+    return G(t) && (t = new H(String(t))), t.appendTo(this);
+  }
+  /** Appends char */
+  _appendCharRaw(t, e) {
+    return t ? (this._value += t, new E({
+      inserted: t,
+      rawInserted: t
+    })) : new E();
+  }
+  /** Appends char */
+  _appendChar(t, e, s) {
+    e === void 0 && (e = {});
+    const r = this.state;
+    let i;
+    if ([t, i] = this.doPrepareChar(t, e), t && (i = i.aggregate(this._appendCharRaw(t, e)), !i.rawInserted && this.autofix === "pad")) {
+      const n = this.state;
+      this.state = r;
+      let u = this.pad(e);
+      const l = this._appendCharRaw(t, e);
+      u = u.aggregate(l), l.rawInserted || u.equals(i) ? i = u : this.state = n;
+    }
+    if (i.inserted) {
+      let n, u = this.doValidate(e) !== !1;
+      if (u && s != null) {
+        const l = this.state;
+        if (this.overwrite === !0) {
+          n = s.state;
+          for (let v = 0; v < i.rawInserted.length; ++v)
+            s.unshift(this.displayValue.length - i.tailShift);
+        }
+        let h = this.appendTail(s);
+        if (u = h.rawInserted.length === s.toString().length, !(u && h.inserted) && this.overwrite === "shift") {
+          this.state = l, n = s.state;
+          for (let v = 0; v < i.rawInserted.length; ++v)
+            s.shift();
+          h = this.appendTail(s), u = h.rawInserted.length === s.toString().length;
+        }
+        u && h.inserted && (this.state = l);
+      }
+      u || (i = new E(), this.state = r, s && n && (s.state = n));
+    }
+    return i;
+  }
+  /** Appends optional placeholder at the end */
+  _appendPlaceholder() {
+    return new E();
+  }
+  /** Appends optional eager placeholder at the end */
+  _appendEager() {
+    return new E();
+  }
+  /** Appends symbols considering flags */
+  append(t, e, s) {
+    if (!G(t)) throw new Error("value should be string");
+    const r = G(s) ? new H(String(s)) : s;
+    e != null && e.tail && (e._beforeTailState = this.state);
+    let i;
+    [t, i] = this.doPrepare(t, e);
+    for (let n = 0; n < t.length; ++n) {
+      const u = this._appendChar(t[n], e, r);
+      if (!u.rawInserted && !this.doSkipInvalid(t[n], e, r)) break;
+      i.aggregate(u);
+    }
+    return (this.eager === !0 || this.eager === "append") && e != null && e.input && t && i.aggregate(this._appendEager()), r != null && (i.tailShift += this.appendTail(r).tailShift), i;
+  }
+  remove(t, e) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), this._value = this.displayValue.slice(0, t) + this.displayValue.slice(e), new E();
+  }
+  /** Calls function and reapplies current value */
+  withValueRefresh(t) {
+    if (this._refreshing || !this._initialized) return t();
+    this._refreshing = !0;
+    const e = this.rawInputValue, s = this.value, r = t();
+    return this.rawInputValue = e, this.value && this.value !== s && s.indexOf(this.value) === 0 && (this.append(s.slice(this.displayValue.length), {}, ""), this.doCommit()), delete this._refreshing, r;
+  }
+  runIsolated(t) {
+    if (this._isolated || !this._initialized) return t(this);
+    this._isolated = !0;
+    const e = this.state, s = t(this);
+    return this.state = e, delete this._isolated, s;
+  }
+  doSkipInvalid(t, e, s) {
+    return !!this.skipInvalid;
+  }
+  /** Prepares string before mask processing */
+  doPrepare(t, e) {
+    return e === void 0 && (e = {}), E.normalize(this.prepare ? this.prepare(t, this, e) : t);
+  }
+  /** Prepares each char before mask processing */
+  doPrepareChar(t, e) {
+    return e === void 0 && (e = {}), E.normalize(this.prepareChar ? this.prepareChar(t, this, e) : t);
+  }
+  /** Validates if value is acceptable */
+  doValidate(t) {
+    return (!this.validate || this.validate(this.value, this, t)) && (!this.parent || this.parent.doValidate(t));
+  }
+  /** Does additional processing at the end of editing */
+  doCommit() {
+    this.commit && this.commit(this.value, this);
+  }
+  splice(t, e, s, r, i) {
+    s === void 0 && (s = ""), r === void 0 && (r = m.NONE), i === void 0 && (i = {
+      input: !0
+    });
+    const n = t + e, u = this.extractTail(n), l = this.eager === !0 || this.eager === "remove";
+    let h;
+    l && (r = he(r), h = this.extractInput(0, n, {
+      raw: !0
+    }));
+    let v = t;
+    const _ = new E();
+    if (r !== m.NONE && (v = this.nearestInputPos(t, e > 1 && t !== 0 && !l ? m.NONE : r), _.tailShift = v - t), _.aggregate(this.remove(v)), l && r !== m.NONE && h === this.rawInputValue)
+      if (r === m.FORCE_LEFT) {
+        let S;
+        for (; h === this.rawInputValue && (S = this.displayValue.length); )
+          _.aggregate(new E({
+            tailShift: -1
+          })).aggregate(this.remove(S - 1));
+      } else r === m.FORCE_RIGHT && u.unshift();
+    return _.aggregate(this.append(s, i, u));
+  }
+  maskEquals(t) {
+    return this.mask === t;
+  }
+  optionsIsChanged(t) {
+    return !ot(this, t);
+  }
+  typedValueEquals(t) {
+    const e = this.typedValue;
+    return t === e || P.EMPTY_VALUES.includes(t) && P.EMPTY_VALUES.includes(e) || (this.format ? this.format(t, this) === this.format(this.typedValue, this) : !1);
+  }
+  pad(t) {
+    return new E();
+  }
+}
+P.DEFAULTS = {
+  skipInvalid: !0
+};
+P.EMPTY_VALUES = [void 0, null, ""];
+g.Masked = P;
+class J {
+  /** */
+  constructor(t, e) {
+    t === void 0 && (t = []), e === void 0 && (e = 0), this.chunks = t, this.from = e;
+  }
+  toString() {
+    return this.chunks.map(String).join("");
+  }
+  extend(t) {
+    if (!String(t)) return;
+    t = G(t) ? new H(String(t)) : t;
+    const e = this.chunks[this.chunks.length - 1], s = e && // if stops are same or tail has no stop
+    (e.stop === t.stop || t.stop == null) && // if tail chunk goes just after last chunk
+    t.from === e.from + e.toString().length;
+    if (t instanceof H)
+      s ? e.extend(t.toString()) : this.chunks.push(t);
+    else if (t instanceof J) {
+      if (t.stop == null) {
+        let r;
+        for (; t.chunks.length && t.chunks[0].stop == null; )
+          r = t.chunks.shift(), r.from += t.from, this.extend(r);
+      }
+      t.toString() && (t.stop = t.blockIndex, this.chunks.push(t));
+    }
+  }
+  appendTo(t) {
+    if (!(t instanceof g.MaskedPattern))
+      return new H(this.toString()).appendTo(t);
+    const e = new E();
+    for (let s = 0; s < this.chunks.length; ++s) {
+      const r = this.chunks[s], i = t._mapPosToBlock(t.displayValue.length), n = r.stop;
+      let u;
+      if (n != null && // if block not found or stop is behind lastBlock
+      (!i || i.index <= n) && ((r instanceof J || // for continuous block also check if stop is exist
+      t._stops.indexOf(n) >= 0) && e.aggregate(t._appendPlaceholder(n)), u = r instanceof J && t._blocks[n]), u) {
+        const l = u.appendTail(r);
+        e.aggregate(l);
+        const h = r.toString().slice(l.rawInserted.length);
+        h && e.aggregate(t.append(h, {
+          tail: !0
+        }));
+      } else
+        e.aggregate(t.append(r.toString(), {
+          tail: !0
+        }));
+    }
+    return e;
+  }
+  get state() {
+    return {
+      chunks: this.chunks.map((t) => t.state),
+      from: this.from,
+      stop: this.stop,
+      blockIndex: this.blockIndex
+    };
+  }
+  set state(t) {
+    const {
+      chunks: e,
+      ...s
+    } = t;
+    Object.assign(this, s), this.chunks = e.map((r) => {
+      const i = "chunks" in r ? new J() : new H();
+      return i.state = r, i;
+    });
+  }
+  unshift(t) {
+    if (!this.chunks.length || t != null && this.from >= t) return "";
+    const e = t != null ? t - this.from : t;
+    let s = 0;
+    for (; s < this.chunks.length; ) {
+      const r = this.chunks[s], i = r.unshift(e);
+      if (r.toString()) {
+        if (!i) break;
+        ++s;
+      } else
+        this.chunks.splice(s, 1);
+      if (i) return i;
+    }
+    return "";
+  }
+  shift() {
+    if (!this.chunks.length) return "";
+    let t = this.chunks.length - 1;
+    for (; 0 <= t; ) {
+      const e = this.chunks[t], s = e.shift();
+      if (e.toString()) {
+        if (!s) break;
+        --t;
+      } else
+        this.chunks.splice(t, 1);
+      if (s) return s;
+    }
+    return "";
+  }
+}
+class me {
+  constructor(t, e) {
+    this.masked = t, this._log = [];
+    const {
+      offset: s,
+      index: r
+    } = t._mapPosToBlock(e) || (e < 0 ? (
+      // first
+      {
+        index: 0,
+        offset: 0
+      }
+    ) : (
+      // last
+      {
+        index: this.masked._blocks.length,
+        offset: 0
+      }
+    ));
+    this.offset = s, this.index = r, 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(t) {
+    Object.assign(this, t);
+  }
+  pushState() {
+    this._log.push(this.state);
+  }
+  popState() {
+    const t = this._log.pop();
+    return t && (this.state = t), t;
+  }
+  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(t) {
+    for (this.pushState(), this.bindBlock(); 0 <= this.index; --this.index, this.offset = ((e = this.block) == null ? void 0 : e.displayValue.length) || 0) {
+      var e;
+      if (t()) return this.ok = !0;
+    }
+    return this.ok = !1;
+  }
+  _pushRight(t) {
+    for (this.pushState(), this.bindBlock(); this.index < this.masked._blocks.length; ++this.index, this.offset = 0)
+      if (t()) 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, m.FORCE_LEFT), this.offset !== 0))
+        return !0;
+    });
+  }
+  pushLeftBeforeInput() {
+    return this._pushLeft(() => {
+      if (!this.block.isFixed)
+        return this.offset = this.block.nearestInputPos(this.offset, m.LEFT), !0;
+    });
+  }
+  pushLeftBeforeRequired() {
+    return this._pushLeft(() => {
+      if (!(this.block.isFixed || this.block.isOptional && !this.block.value))
+        return this.offset = this.block.nearestInputPos(this.offset, m.LEFT), !0;
+    });
+  }
+  pushRightBeforeFilled() {
+    return this._pushRight(() => {
+      if (!(this.block.isFixed || !this.block.value) && (this.offset = this.block.nearestInputPos(this.offset, m.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, m.NONE), !0;
+    });
+  }
+  pushRightBeforeRequired() {
+    return this._pushRight(() => {
+      if (!(this.block.isFixed || this.block.isOptional && !this.block.value))
+        return this.offset = this.block.nearestInputPos(this.offset, m.NONE), !0;
+    });
+  }
+}
+class Jt {
+  /** */
+  /** */
+  /** */
+  /** */
+  /** */
+  /** */
+  constructor(t) {
+    Object.assign(this, t), 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(t, e) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this._value.length), this._value = this._value.slice(0, t) + this._value.slice(e), this._value || (this._isRawInput = !1), new E();
+  }
+  nearestInputPos(t, e) {
+    e === void 0 && (e = m.NONE);
+    const s = 0, r = this._value.length;
+    switch (e) {
+      case m.LEFT:
+      case m.FORCE_LEFT:
+        return s;
+      case m.NONE:
+      case m.RIGHT:
+      case m.FORCE_RIGHT:
+      default:
+        return r;
+    }
+  }
+  totalInputPositions(t, e) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this._value.length), this._isRawInput ? e - t : 0;
+  }
+  extractInput(t, e, s) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this._value.length), s === void 0 && (s = {}), s.raw && this._isRawInput && this._value.slice(t, e) || "";
+  }
+  get isComplete() {
+    return !0;
+  }
+  get isFilled() {
+    return !!this._value;
+  }
+  _appendChar(t, e) {
+    if (e === void 0 && (e = {}), this.isFilled) return new E();
+    const s = this.eager === !0 || this.eager === "append", i = this.char === t && (this.isUnmasking || e.input || e.raw) && (!e.raw || !s) && !e.tail, n = new E({
+      inserted: this.char,
+      rawInserted: i ? this.char : ""
+    });
+    return this._value = this.char, this._isRawInput = i && (e.raw || e.input), n;
+  }
+  _appendEager() {
+    return this._appendChar(this.char, {
+      tail: !0
+    });
+  }
+  _appendPlaceholder() {
+    const t = new E();
+    return this.isFilled || (this._value = t.inserted = this.char), t;
+  }
+  extractTail() {
+    return new H("");
+  }
+  appendTail(t) {
+    return G(t) && (t = new H(String(t))), t.appendTo(this);
+  }
+  append(t, e, s) {
+    const r = this._appendChar(t[0], e);
+    return s != null && (r.tailShift += this.appendTail(s).tailShift), r;
+  }
+  doCommit() {
+  }
+  get state() {
+    return {
+      _value: this._value,
+      _rawInputValue: this.rawInputValue
+    };
+  }
+  set state(t) {
+    this._value = t._value, this._isRawInput = !!t._rawInputValue;
+  }
+  pad(t) {
+    return this._appendPlaceholder();
+  }
+}
+class lt {
+  /** */
+  /** */
+  /** */
+  /** */
+  /** */
+  /** */
+  /** */
+  /** */
+  constructor(t) {
+    const {
+      parent: e,
+      isOptional: s,
+      placeholderChar: r,
+      displayChar: i,
+      lazy: n,
+      eager: u,
+      ...l
+    } = t;
+    this.masked = K(l), Object.assign(this, {
+      parent: e,
+      isOptional: s,
+      placeholderChar: r,
+      displayChar: i,
+      lazy: n,
+      eager: u
+    });
+  }
+  reset() {
+    this.isFilled = !1, this.masked.reset();
+  }
+  remove(t, e) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.value.length), t === 0 && e >= 1 ? (this.isFilled = !1, this.masked.remove(t, e)) : new E();
+  }
+  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(t, e) {
+    if (e === void 0 && (e = {}), this.isFilled) return new E();
+    const s = this.masked.state;
+    let r = this.masked._appendChar(t, this.currentMaskFlags(e));
+    return r.inserted && this.doValidate(e) === !1 && (r = new E(), this.masked.state = s), !r.inserted && !this.isOptional && !this.lazy && !e.input && (r.inserted = this.placeholderChar), r.skip = !r.inserted && !this.isOptional, this.isFilled = !!r.inserted, r;
+  }
+  append(t, e, s) {
+    return this.masked.append(t, this.currentMaskFlags(e), s);
+  }
+  _appendPlaceholder() {
+    return this.isFilled || this.isOptional ? new E() : (this.isFilled = !0, new E({
+      inserted: this.placeholderChar
+    }));
+  }
+  _appendEager() {
+    return new E();
+  }
+  extractTail(t, e) {
+    return this.masked.extractTail(t, e);
+  }
+  appendTail(t) {
+    return this.masked.appendTail(t);
+  }
+  extractInput(t, e, s) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.value.length), this.masked.extractInput(t, e, s);
+  }
+  nearestInputPos(t, e) {
+    e === void 0 && (e = m.NONE);
+    const s = 0, r = this.value.length, i = Math.min(Math.max(t, s), r);
+    switch (e) {
+      case m.LEFT:
+      case m.FORCE_LEFT:
+        return this.isComplete ? i : s;
+      case m.RIGHT:
+      case m.FORCE_RIGHT:
+        return this.isComplete ? i : r;
+      case m.NONE:
+      default:
+        return i;
+    }
+  }
+  totalInputPositions(t, e) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.value.length), this.value.slice(t, e).length;
+  }
+  doValidate(t) {
+    return this.masked.doValidate(this.currentMaskFlags(t)) && (!this.parent || this.parent.doValidate(this.currentMaskFlags(t)));
+  }
+  doCommit() {
+    this.masked.doCommit();
+  }
+  get state() {
+    return {
+      _value: this.value,
+      _rawInputValue: this.rawInputValue,
+      masked: this.masked.state,
+      isFilled: this.isFilled
+    };
+  }
+  set state(t) {
+    this.masked.state = t.masked, this.isFilled = t.isFilled;
+  }
+  currentMaskFlags(t) {
+    var e;
+    return {
+      ...t,
+      _beforeTailState: (t == null || (e = t._beforeTailState) == null ? void 0 : e.masked) || (t == null ? void 0 : t._beforeTailState)
+    };
+  }
+  pad(t) {
+    return new E();
+  }
+}
+lt.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 ve extends P {
+  /** */
+  /** Enable characters overwriting */
+  /** */
+  /** */
+  /** */
+  updateOptions(t) {
+    super.updateOptions(t);
+  }
+  _update(t) {
+    const e = t.mask;
+    e && (t.validate = (s) => s.search(e) >= 0), super._update(t);
+  }
+}
+g.MaskedRegExp = ve;
+class L extends P {
+  /** */
+  /** */
+  /** Single char for empty input */
+  /** Single char for filled input */
+  /** Show placeholder only when needed */
+  /** Enable characters overwriting */
+  /** */
+  /** */
+  /** */
+  constructor(t) {
+    super({
+      ...L.DEFAULTS,
+      ...t,
+      definitions: Object.assign({}, lt.DEFAULT_DEFINITIONS, t == null ? void 0 : t.definitions)
+    });
+  }
+  updateOptions(t) {
+    super.updateOptions(t);
+  }
+  _update(t) {
+    t.definitions = Object.assign({}, this.definitions, t.definitions), super._update(t), this._rebuildMask();
+  }
+  _rebuildMask() {
+    const t = this.definitions;
+    this._blocks = [], this.exposeBlock = void 0, this._stops = [], this._maskedBlocks = {};
+    const e = this.mask;
+    if (!e || !t) return;
+    let s = !1, r = !1;
+    for (let i = 0; i < e.length; ++i) {
+      if (this.blocks) {
+        const h = e.slice(i), v = Object.keys(this.blocks).filter((S) => h.indexOf(S) === 0);
+        v.sort((S, B) => B.length - S.length);
+        const _ = v[0];
+        if (_) {
+          const {
+            expose: S,
+            repeat: B,
+            ...N
+          } = et(this.blocks[_]), M = {
+            lazy: this.lazy,
+            eager: this.eager,
+            placeholderChar: this.placeholderChar,
+            displayChar: this.displayChar,
+            overwrite: this.overwrite,
+            autofix: this.autofix,
+            ...N,
+            repeat: B,
+            parent: this
+          }, O = B != null ? new g.RepeatBlock(
+            M
+            /* TODO */
+          ) : K(M);
+          O && (this._blocks.push(O), S && (this.exposeBlock = O), this._maskedBlocks[_] || (this._maskedBlocks[_] = []), this._maskedBlocks[_].push(this._blocks.length - 1)), i += _.length - 1;
+          continue;
+        }
+      }
+      let n = e[i], u = n in t;
+      if (n === L.STOP_CHAR) {
+        this._stops.push(this._blocks.length);
+        continue;
+      }
+      if (n === "{" || n === "}") {
+        s = !s;
+        continue;
+      }
+      if (n === "[" || n === "]") {
+        r = !r;
+        continue;
+      }
+      if (n === L.ESCAPE_CHAR) {
+        if (++i, n = e[i], !n) break;
+        u = !1;
+      }
+      const l = u ? new lt({
+        isOptional: r,
+        lazy: this.lazy,
+        eager: this.eager,
+        placeholderChar: this.placeholderChar,
+        displayChar: this.displayChar,
+        ...et(t[n]),
+        parent: this
+      }) : new Jt({
+        char: n,
+        eager: this.eager,
+        isUnmasking: s
+      });
+      this._blocks.push(l);
+    }
+  }
+  get state() {
+    return {
+      ...super.state,
+      _blocks: this._blocks.map((t) => t.state)
+    };
+  }
+  set state(t) {
+    if (!t) {
+      this.reset();
+      return;
+    }
+    const {
+      _blocks: e,
+      ...s
+    } = t;
+    this._blocks.forEach((r, i) => r.state = e[i]), super.state = s;
+  }
+  reset() {
+    super.reset(), this._blocks.forEach((t) => t.reset());
+  }
+  get isComplete() {
+    return this.exposeBlock ? this.exposeBlock.isComplete : this._blocks.every((t) => t.isComplete);
+  }
+  get isFilled() {
+    return this._blocks.every((t) => t.isFilled);
+  }
+  get isFixed() {
+    return this._blocks.every((t) => t.isFixed);
+  }
+  get isOptional() {
+    return this._blocks.every((t) => t.isOptional);
+  }
+  doCommit() {
+    this._blocks.forEach((t) => t.doCommit()), super.doCommit();
+  }
+  get unmaskedValue() {
+    return this.exposeBlock ? this.exposeBlock.unmaskedValue : this._blocks.reduce((t, e) => t += e.unmaskedValue, "");
+  }
+  set unmaskedValue(t) {
+    if (this.exposeBlock) {
+      const e = this.extractTail(this._blockStartPos(this._blocks.indexOf(this.exposeBlock)) + this.exposeBlock.displayValue.length);
+      this.exposeBlock.unmaskedValue = t, this.appendTail(e), this.doCommit();
+    } else super.unmaskedValue = t;
+  }
+  get value() {
+    return this.exposeBlock ? this.exposeBlock.value : (
+      // TODO return _value when not in change?
+      this._blocks.reduce((t, e) => t += e.value, "")
+    );
+  }
+  set value(t) {
+    if (this.exposeBlock) {
+      const e = this.extractTail(this._blockStartPos(this._blocks.indexOf(this.exposeBlock)) + this.exposeBlock.displayValue.length);
+      this.exposeBlock.value = t, this.appendTail(e), this.doCommit();
+    } else super.value = t;
+  }
+  get typedValue() {
+    return this.exposeBlock ? this.exposeBlock.typedValue : super.typedValue;
+  }
+  set typedValue(t) {
+    if (this.exposeBlock) {
+      const e = this.extractTail(this._blockStartPos(this._blocks.indexOf(this.exposeBlock)) + this.exposeBlock.displayValue.length);
+      this.exposeBlock.typedValue = t, this.appendTail(e), this.doCommit();
+    } else super.typedValue = t;
+  }
+  get displayValue() {
+    return this._blocks.reduce((t, e) => t += e.displayValue, "");
+  }
+  appendTail(t) {
+    return super.appendTail(t).aggregate(this._appendPlaceholder());
+  }
+  _appendEager() {
+    var t;
+    const e = new E();
+    let s = (t = this._mapPosToBlock(this.displayValue.length)) == null ? void 0 : t.index;
+    if (s == null) return e;
+    this._blocks[s].isFilled && ++s;
+    for (let r = s; r < this._blocks.length; ++r) {
+      const i = this._blocks[r]._appendEager();
+      if (!i.inserted) break;
+      e.aggregate(i);
+    }
+    return e;
+  }
+  _appendCharRaw(t, e) {
+    e === void 0 && (e = {});
+    const s = this._mapPosToBlock(this.displayValue.length), r = new E();
+    if (!s) return r;
+    for (let n = s.index, u; u = this._blocks[n]; ++n) {
+      var i;
+      const l = u._appendChar(t, {
+        ...e,
+        _beforeTailState: (i = e._beforeTailState) == null || (i = i._blocks) == null ? void 0 : i[n]
+      });
+      if (r.aggregate(l), l.consumed) break;
+    }
+    return r;
+  }
+  extractTail(t, e) {
+    t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length);
+    const s = new J();
+    return t === e || this._forEachBlocksInRange(t, e, (r, i, n, u) => {
+      const l = r.extractTail(n, u);
+      l.stop = this._findStopBefore(i), l.from = this._blockStartPos(i), l instanceof J && (l.blockIndex = i), s.extend(l);
+    }), s;
+  }
+  extractInput(t, e, s) {
+    if (t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), s === void 0 && (s = {}), t === e) return "";
+    let r = "";
+    return this._forEachBlocksInRange(t, e, (i, n, u, l) => {
+      r += i.extractInput(u, l, s);
+    }), r;
+  }
+  _findStopBefore(t) {
+    let e;
+    for (let s = 0; s < this._stops.length; ++s) {
+      const r = this._stops[s];
+      if (r <= t) e = r;
+      else break;
+    }
+    return e;
+  }
+  /** Appends placeholder depending on laziness */
+  _appendPlaceholder(t) {
+    const e = new E();
+    if (this.lazy && t == null) return e;
+    const s = this._mapPosToBlock(this.displayValue.length);
+    if (!s) return e;
+    const r = s.index, i = t ?? this._blocks.length;
+    return this._blocks.slice(r, i).forEach((n) => {
+      if (!n.lazy || t != null) {
+        var u;
+        e.aggregate(n._appendPlaceholder((u = n._blocks) == null ? void 0 : u.length));
+      }
+    }), e;
+  }
+  /** Finds block in pos */
+  _mapPosToBlock(t) {
+    let e = "";
+    for (let s = 0; s < this._blocks.length; ++s) {
+      const r = this._blocks[s], i = e.length;
+      if (e += r.displayValue, t <= e.length)
+        return {
+          index: s,
+          offset: t - i
+        };
+    }
+  }
+  _blockStartPos(t) {
+    return this._blocks.slice(0, t).reduce((e, s) => e += s.displayValue.length, 0);
+  }
+  _forEachBlocksInRange(t, e, s) {
+    e === void 0 && (e = this.displayValue.length);
+    const r = this._mapPosToBlock(t);
+    if (r) {
+      const i = this._mapPosToBlock(e), n = i && r.index === i.index, u = r.offset, l = i && n ? i.offset : this._blocks[r.index].displayValue.length;
+      if (s(this._blocks[r.index], r.index, u, l), i && !n) {
+        for (let h = r.index + 1; h < i.index; ++h)
+          s(this._blocks[h], h, 0, this._blocks[h].displayValue.length);
+        s(this._blocks[i.index], i.index, 0, i.offset);
+      }
+    }
+  }
+  remove(t, e) {
+    t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length);
+    const s = super.remove(t, e);
+    return this._forEachBlocksInRange(t, e, (r, i, n, u) => {
+      s.aggregate(r.remove(n, u));
+    }), s;
+  }
+  nearestInputPos(t, e) {
+    if (e === void 0 && (e = m.NONE), !this._blocks.length) return 0;
+    const s = new me(this, t);
+    if (e === m.NONE)
+      return s.pushRightBeforeInput() || (s.popState(), s.pushLeftBeforeInput()) ? s.pos : this.displayValue.length;
+    if (e === m.LEFT || e === m.FORCE_LEFT) {
+      if (e === m.LEFT) {
+        if (s.pushRightBeforeFilled(), s.ok && s.pos === t) return t;
+        s.popState();
+      }
+      if (s.pushLeftBeforeInput(), s.pushLeftBeforeRequired(), s.pushLeftBeforeFilled(), e === m.LEFT) {
+        if (s.pushRightBeforeInput(), s.pushRightBeforeRequired(), s.ok && s.pos <= t || (s.popState(), s.ok && s.pos <= t)) return s.pos;
+        s.popState();
+      }
+      return s.ok ? s.pos : e === m.FORCE_LEFT ? 0 : (s.popState(), s.ok || (s.popState(), s.ok) ? s.pos : 0);
+    }
+    return e === m.RIGHT || e === m.FORCE_RIGHT ? (s.pushRightBeforeInput(), s.pushRightBeforeRequired(), s.pushRightBeforeFilled() ? s.pos : e === m.FORCE_RIGHT ? this.displayValue.length : (s.popState(), s.ok || (s.popState(), s.ok) ? s.pos : this.nearestInputPos(t, m.LEFT))) : t;
+  }
+  totalInputPositions(t, e) {
+    t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length);
+    let s = 0;
+    return this._forEachBlocksInRange(t, e, (r, i, n, u) => {
+      s += r.totalInputPositions(n, u);
+    }), s;
+  }
+  /** Get block by name */
+  maskedBlock(t) {
+    return this.maskedBlocks(t)[0];
+  }
+  /** Get all blocks by name */
+  maskedBlocks(t) {
+    const e = this._maskedBlocks[t];
+    return e ? e.map((s) => this._blocks[s]) : [];
+  }
+  pad(t) {
+    const e = new E();
+    return this._forEachBlocksInRange(0, this.displayValue.length, (s) => e.aggregate(s.pad(t))), e;
+  }
+}
+L.DEFAULTS = {
+  ...P.DEFAULTS,
+  lazy: !0,
+  placeholderChar: "_"
+};
+L.STOP_CHAR = "`";
+L.ESCAPE_CHAR = "\\";
+L.InputDefinition = lt;
+L.FixedDefinition = Jt;
+g.MaskedPattern = L;
+class ut extends L {
+  /**
+    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(t) {
+    super(t);
+  }
+  updateOptions(t) {
+    super.updateOptions(t);
+  }
+  _update(t) {
+    const {
+      to: e = this.to || 0,
+      from: s = this.from || 0,
+      maxLength: r = this.maxLength || 0,
+      autofix: i = this.autofix,
+      ...n
+    } = t;
+    this.to = e, this.from = s, this.maxLength = Math.max(String(e).length, r), this.autofix = i;
+    const u = String(this.from).padStart(this.maxLength, "0"), l = String(this.to).padStart(this.maxLength, "0");
+    let h = 0;
+    for (; h < l.length && l[h] === u[h]; ) ++h;
+    n.mask = l.slice(0, h).replace(/0/g, "\\0") + "0".repeat(this.maxLength - h), super._update(n);
+  }
+  get isComplete() {
+    return super.isComplete && !!this.value;
+  }
+  boundaries(t) {
+    let e = "", s = "";
+    const [, r, i] = t.match(/^(\D*)(\d*)(\D*)/) || [];
+    return i && (e = "0".repeat(r.length) + i, s = "9".repeat(r.length) + i), e = e.padEnd(this.maxLength, "0"), s = s.padEnd(this.maxLength, "9"), [e, s];
+  }
+  doPrepareChar(t, e) {
+    e === void 0 && (e = {});
+    let s;
+    return [t, s] = super.doPrepareChar(t.replace(/\D/g, ""), e), t || (s.skip = !this.isComplete), [t, s];
+  }
+  _appendCharRaw(t, e) {
+    if (e === void 0 && (e = {}), !this.autofix || this.value.length + 1 > this.maxLength) return super._appendCharRaw(t, e);
+    const s = String(this.from).padStart(this.maxLength, "0"), r = String(this.to).padStart(this.maxLength, "0"), [i, n] = this.boundaries(this.value + t);
+    return Number(n) < this.from ? super._appendCharRaw(s[this.value.length], e) : Number(i) > this.to ? !e.tail && this.autofix === "pad" && this.value.length + 1 < this.maxLength ? super._appendCharRaw(s[this.value.length], e).aggregate(this._appendCharRaw(t, e)) : super._appendCharRaw(r[this.value.length], e) : super._appendCharRaw(t, e);
+  }
+  doValidate(t) {
+    const e = this.value;
+    if (e.search(/[^0]/) === -1 && e.length <= this._matchFrom) return !0;
+    const [r, i] = this.boundaries(e);
+    return this.from <= Number(i) && Number(r) <= this.to && super.doValidate(t);
+  }
+  pad(t) {
+    const e = new E();
+    if (this.value.length === this.maxLength) return e;
+    const s = this.value, r = this.maxLength - this.value.length;
+    if (r) {
+      this.reset();
+      for (let i = 0; i < r; ++i)
+        e.aggregate(super._appendCharRaw("0", t));
+      s.split("").forEach((i) => this._appendCharRaw(i));
+    }
+    return e;
+  }
+}
+g.MaskedRange = ut;
+const ge = "d{.}`m{.}`Y";
+class z extends L {
+  static extractPatternOptions(t) {
+    const {
+      mask: e,
+      pattern: s,
+      ...r
+    } = t;
+    return {
+      ...r,
+      mask: G(e) ? e : 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(t) {
+    super(z.extractPatternOptions({
+      ...z.DEFAULTS,
+      ...t
+    }));
+  }
+  updateOptions(t) {
+    super.updateOptions(t);
+  }
+  _update(t) {
+    const {
+      mask: e,
+      pattern: s,
+      blocks: r,
+      ...i
+    } = {
+      ...z.DEFAULTS,
+      ...t
+    }, n = Object.assign({}, z.GET_DEFAULT_BLOCKS());
+    t.min && (n.Y.from = t.min.getFullYear()), t.max && (n.Y.to = t.max.getFullYear()), t.min && t.max && n.Y.from === n.Y.to && (n.m.from = t.min.getMonth() + 1, n.m.to = t.max.getMonth() + 1, n.m.from === n.m.to && (n.d.from = t.min.getDate(), n.d.to = t.max.getDate())), Object.assign(n, this.blocks, r), super._update({
+      ...i,
+      mask: G(e) ? e : s,
+      blocks: n
+    });
+  }
+  doValidate(t) {
+    const e = this.date;
+    return super.doValidate(t) && (!this.isComplete || this.isDateExist(this.value) && e != null && (this.min == null || this.min <= e) && (this.max == null || e <= this.max));
+  }
+  /** Checks if date is exists */
+  isDateExist(t) {
+    return this.format(this.parse(t, this), this).indexOf(t) >= 0;
+  }
+  /** Parsed Date */
+  get date() {
+    return this.typedValue;
+  }
+  set date(t) {
+    this.typedValue = t;
+  }
+  get typedValue() {
+    return this.isComplete ? super.typedValue : null;
+  }
+  set typedValue(t) {
+    super.typedValue = t;
+  }
+  maskEquals(t) {
+    return t === Date || super.maskEquals(t);
+  }
+  optionsIsChanged(t) {
+    return super.optionsIsChanged(z.extractPatternOptions(t));
+  }
+}
+z.GET_DEFAULT_BLOCKS = () => ({
+  d: {
+    mask: ut,
+    from: 1,
+    to: 31,
+    maxLength: 2
+  },
+  m: {
+    mask: ut,
+    from: 1,
+    to: 12,
+    maxLength: 2
+  },
+  Y: {
+    mask: ut,
+    from: 1900,
+    to: 9999
+  }
+});
+z.DEFAULTS = {
+  ...L.DEFAULTS,
+  mask: Date,
+  pattern: ge,
+  format: (a, t) => {
+    if (!a) return "";
+    const e = String(a.getDate()).padStart(2, "0"), s = String(a.getMonth() + 1).padStart(2, "0"), r = a.getFullYear();
+    return [e, s, r].join(".");
+  },
+  parse: (a, t) => {
+    const [e, s, r] = a.split(".").map(Number);
+    return new Date(r, s - 1, e);
+  }
+};
+g.MaskedDate = z;
+class ct extends P {
+  constructor(t) {
+    super({
+      ...ct.DEFAULTS,
+      ...t
+    }), this.currentMask = void 0;
+  }
+  updateOptions(t) {
+    super.updateOptions(t);
+  }
+  _update(t) {
+    super._update(t), "mask" in t && (this.exposeMask = void 0, this.compiledMasks = Array.isArray(t.mask) ? t.mask.map((e) => {
+      const {
+        expose: s,
+        ...r
+      } = et(e), i = K({
+        overwrite: this._overwrite,
+        eager: this._eager,
+        skipInvalid: this._skipInvalid,
+        ...r
+      });
+      return s && (this.exposeMask = i), i;
+    }) : []);
+  }
+  _appendCharRaw(t, e) {
+    e === void 0 && (e = {});
+    const s = this._applyDispatch(t, e);
+    return this.currentMask && s.aggregate(this.currentMask._appendChar(t, this.currentMaskFlags(e))), s;
+  }
+  _applyDispatch(t, e, s) {
+    t === void 0 && (t = ""), e === void 0 && (e = {}), s === void 0 && (s = "");
+    const r = e.tail && e._beforeTailState != null ? e._beforeTailState._value : this.value, i = this.rawInputValue, n = e.tail && e._beforeTailState != null ? e._beforeTailState._rawInputValue : i, u = i.slice(n.length), l = this.currentMask, h = new E(), v = l == null ? void 0 : l.state;
+    return this.currentMask = this.doDispatch(t, {
+      ...e
+    }, s), this.currentMask && (this.currentMask !== l ? (this.currentMask.reset(), n && (this.currentMask.append(n, {
+      raw: !0
+    }), h.tailShift = this.currentMask.value.length - r.length), u && (h.tailShift += this.currentMask.append(u, {
+      raw: !0,
+      tail: !0
+    }).tailShift)) : v && (this.currentMask.state = v)), h;
+  }
+  _appendPlaceholder() {
+    const t = this._applyDispatch();
+    return this.currentMask && t.aggregate(this.currentMask._appendPlaceholder()), t;
+  }
+  _appendEager() {
+    const t = this._applyDispatch();
+    return this.currentMask && t.aggregate(this.currentMask._appendEager()), t;
+  }
+  appendTail(t) {
+    const e = new E();
+    return t && e.aggregate(this._applyDispatch("", {}, t)), e.aggregate(this.currentMask ? this.currentMask.appendTail(t) : super.appendTail(t));
+  }
+  currentMaskFlags(t) {
+    var e, s;
+    return {
+      ...t,
+      _beforeTailState: ((e = t._beforeTailState) == null ? void 0 : e.currentMaskRef) === this.currentMask && ((s = t._beforeTailState) == null ? void 0 : s.currentMask) || t._beforeTailState
+    };
+  }
+  doDispatch(t, e, s) {
+    return e === void 0 && (e = {}), s === void 0 && (s = ""), this.dispatch(t, this, e, s);
+  }
+  doValidate(t) {
+    return super.doValidate(t) && (!this.currentMask || this.currentMask.doValidate(this.currentMaskFlags(t)));
+  }
+  doPrepare(t, e) {
+    e === void 0 && (e = {});
+    let [s, r] = super.doPrepare(t, e);
+    if (this.currentMask) {
+      let i;
+      [s, i] = super.doPrepare(s, this.currentMaskFlags(e)), r = r.aggregate(i);
+    }
+    return [s, r];
+  }
+  doPrepareChar(t, e) {
+    e === void 0 && (e = {});
+    let [s, r] = super.doPrepareChar(t, e);
+    if (this.currentMask) {
+      let i;
+      [s, i] = super.doPrepareChar(s, this.currentMaskFlags(e)), r = r.aggregate(i);
+    }
+    return [s, r];
+  }
+  reset() {
+    var t;
+    (t = this.currentMask) == null || t.reset(), this.compiledMasks.forEach((e) => e.reset());
+  }
+  get value() {
+    return this.exposeMask ? this.exposeMask.value : this.currentMask ? this.currentMask.value : "";
+  }
+  set value(t) {
+    this.exposeMask ? (this.exposeMask.value = t, this.currentMask = this.exposeMask, this._applyDispatch()) : super.value = t;
+  }
+  get unmaskedValue() {
+    return this.exposeMask ? this.exposeMask.unmaskedValue : this.currentMask ? this.currentMask.unmaskedValue : "";
+  }
+  set unmaskedValue(t) {
+    this.exposeMask ? (this.exposeMask.unmaskedValue = t, this.currentMask = this.exposeMask, this._applyDispatch()) : super.unmaskedValue = t;
+  }
+  get typedValue() {
+    return this.exposeMask ? this.exposeMask.typedValue : this.currentMask ? this.currentMask.typedValue : "";
+  }
+  set typedValue(t) {
+    if (this.exposeMask) {
+      this.exposeMask.typedValue = t, this.currentMask = this.exposeMask, this._applyDispatch();
+      return;
+    }
+    let e = String(t);
+    this.currentMask && (this.currentMask.typedValue = t, e = this.currentMask.unmaskedValue), this.unmaskedValue = e;
+  }
+  get displayValue() {
+    return this.currentMask ? this.currentMask.displayValue : "";
+  }
+  get isComplete() {
+    var t;
+    return !!((t = this.currentMask) != null && t.isComplete);
+  }
+  get isFilled() {
+    var t;
+    return !!((t = this.currentMask) != null && t.isFilled);
+  }
+  remove(t, e) {
+    const s = new E();
+    return this.currentMask && s.aggregate(this.currentMask.remove(t, e)).aggregate(this._applyDispatch()), s;
+  }
+  get state() {
+    var t;
+    return {
+      ...super.state,
+      _rawInputValue: this.rawInputValue,
+      compiledMasks: this.compiledMasks.map((e) => e.state),
+      currentMaskRef: this.currentMask,
+      currentMask: (t = this.currentMask) == null ? void 0 : t.state
+    };
+  }
+  set state(t) {
+    const {
+      compiledMasks: e,
+      currentMaskRef: s,
+      currentMask: r,
+      ...i
+    } = t;
+    e && this.compiledMasks.forEach((n, u) => n.state = e[u]), s != null && (this.currentMask = s, this.currentMask.state = r), super.state = i;
+  }
+  extractInput(t, e, s) {
+    return this.currentMask ? this.currentMask.extractInput(t, e, s) : "";
+  }
+  extractTail(t, e) {
+    return this.currentMask ? this.currentMask.extractTail(t, e) : super.extractTail(t, e);
+  }
+  doCommit() {
+    this.currentMask && this.currentMask.doCommit(), super.doCommit();
+  }
+  nearestInputPos(t, e) {
+    return this.currentMask ? this.currentMask.nearestInputPos(t, e) : super.nearestInputPos(t, e);
+  }
+  get overwrite() {
+    return this.currentMask ? this.currentMask.overwrite : this._overwrite;
+  }
+  set overwrite(t) {
+    this._overwrite = t;
+  }
+  get eager() {
+    return this.currentMask ? this.currentMask.eager : this._eager;
+  }
+  set eager(t) {
+    this._eager = t;
+  }
+  get skipInvalid() {
+    return this.currentMask ? this.currentMask.skipInvalid : this._skipInvalid;
+  }
+  set skipInvalid(t) {
+    this._skipInvalid = t;
+  }
+  get autofix() {
+    return this.currentMask ? this.currentMask.autofix : this._autofix;
+  }
+  set autofix(t) {
+    this._autofix = t;
+  }
+  maskEquals(t) {
+    return Array.isArray(t) ? this.compiledMasks.every((e, s) => {
+      if (!t[s]) return;
+      const {
+        mask: r,
+        ...i
+      } = t[s];
+      return ot(e, i) && e.maskEquals(r);
+    }) : super.maskEquals(t);
+  }
+  typedValueEquals(t) {
+    var e;
+    return !!((e = this.currentMask) != null && e.typedValueEquals(t));
+  }
+}
+ct.DEFAULTS = {
+  ...P.DEFAULTS,
+  dispatch: (a, t, e, s) => {
+    if (!t.compiledMasks.length) return;
+    const r = t.rawInputValue, i = t.compiledMasks.map((n, u) => {
+      const l = t.currentMask === n, h = l ? n.displayValue.length : n.nearestInputPos(n.displayValue.length, m.FORCE_LEFT);
+      return n.rawInputValue !== r ? (n.reset(), n.append(r, {
+        raw: !0
+      })) : l || n.remove(h), n.append(a, t.currentMaskFlags(e)), n.appendTail(s), {
+        index: u,
+        weight: n.rawInputValue.length,
+        totalInputPositions: n.totalInputPositions(0, Math.max(h, n.nearestInputPos(n.displayValue.length, m.FORCE_LEFT)))
+      };
+    });
+    return i.sort((n, u) => u.weight - n.weight || u.totalInputPositions - n.totalInputPositions), t.compiledMasks[i[0].index];
+  }
+};
+g.MaskedDynamic = ct;
+class dt extends L {
+  constructor(t) {
+    super({
+      ...dt.DEFAULTS,
+      ...t
+    });
+  }
+  updateOptions(t) {
+    super.updateOptions(t);
+  }
+  _update(t) {
+    const {
+      enum: e,
+      ...s
+    } = t;
+    if (e) {
+      const r = e.map((u) => u.length), i = Math.min(...r), n = Math.max(...r) - i;
+      s.mask = "*".repeat(i), n && (s.mask += "[" + "*".repeat(n) + "]"), this.enum = e;
+    }
+    super._update(s);
+  }
+  _appendCharRaw(t, e) {
+    e === void 0 && (e = {});
+    const s = Math.min(this.nearestInputPos(0, m.FORCE_RIGHT), this.value.length), r = this.enum.filter((i) => this.matchValue(i, this.unmaskedValue + t, s));
+    if (r.length) {
+      r.length === 1 && this._forEachBlocksInRange(0, this.value.length, (n, u) => {
+        const l = r[0][u];
+        u >= this.value.length || l === n.value || (n.reset(), n._appendChar(l, e));
+      });
+      const i = super._appendCharRaw(r[0][this.value.length], e);
+      return r.length === 1 && r[0].slice(this.unmaskedValue.length).split("").forEach((n) => i.aggregate(super._appendCharRaw(n))), i;
+    }
+    return new E({
+      skip: !this.isComplete
+    });
+  }
+  extractTail(t, e) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), new H("", t);
+  }
+  remove(t, e) {
+    if (t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), t === e) return new E();
+    const s = Math.min(super.nearestInputPos(0, m.FORCE_RIGHT), this.value.length);
+    let r;
+    for (r = t; r >= 0 && !(this.enum.filter((u) => this.matchValue(u, this.value.slice(s, r), s)).length > 1); --r)
+      ;
+    const i = super.remove(r, e);
+    return i.tailShift += r - t, i;
+  }
+  get isComplete() {
+    return this.enum.indexOf(this.value) >= 0;
+  }
+}
+dt.DEFAULTS = {
+  ...L.DEFAULTS,
+  matchValue: (a, t, e) => a.indexOf(t, e) === e
+};
+g.MaskedEnum = dt;
+class _e extends P {
+  /** */
+  /** Enable characters overwriting */
+  /** */
+  /** */
+  /** */
+  updateOptions(t) {
+    super.updateOptions(t);
+  }
+  _update(t) {
+    super._update({
+      ...t,
+      validate: t.mask
+    });
+  }
+}
+g.MaskedFunction = _e;
+var Qt;
+class U extends P {
+  /** 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(t) {
+    super({
+      ...U.DEFAULTS,
+      ...t
+    });
+  }
+  updateOptions(t) {
+    super.updateOptions(t);
+  }
+  _update(t) {
+    super._update(t), this._updateRegExps();
+  }
+  _updateRegExps() {
+    const t = "^" + (this.allowNegative ? "[+|\\-]?" : ""), e = "\\d*", s = (this.scale ? "(" + Ct(this.radix) + "\\d{0," + this.scale + "})?" : "") + "$";
+    this._numberRegExp = new RegExp(t + e + s), this._mapToRadixRegExp = new RegExp("[" + this.mapToRadix.map(Ct).join("") + "]", "g"), this._thousandsSeparatorRegExp = new RegExp(Ct(this.thousandsSeparator), "g");
+  }
+  _removeThousandsSeparators(t) {
+    return t.replace(this._thousandsSeparatorRegExp, "");
+  }
+  _insertThousandsSeparators(t) {
+    const e = t.split(this.radix);
+    return e[0] = e[0].replace(/\B(?=(\d{3})+(?!\d))/g, this.thousandsSeparator), e.join(this.radix);
+  }
+  doPrepareChar(t, e) {
+    e === void 0 && (e = {});
+    const [s, r] = 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
+    */
+    (e.input && e.raw || !e.input && !e.raw) ? t.replace(this._mapToRadixRegExp, this.radix) : t), e);
+    return t && !s && (r.skip = !0), s && !this.allowPositive && !this.value && s !== "-" && r.aggregate(this._appendChar("-")), [s, r];
+  }
+  _separatorsCount(t, e) {
+    e === void 0 && (e = !1);
+    let s = 0;
+    for (let r = 0; r < t; ++r)
+      this._value.indexOf(this.thousandsSeparator, r) === r && (++s, e && (t += this.thousandsSeparator.length));
+    return s;
+  }
+  _separatorsCountFromSlice(t) {
+    return t === void 0 && (t = this._value), this._separatorsCount(this._removeThousandsSeparators(t).length, !0);
+  }
+  extractInput(t, e, s) {
+    return t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), [t, e] = this._adjustRangeWithSeparators(t, e), this._removeThousandsSeparators(super.extractInput(t, e, s));
+  }
+  _appendCharRaw(t, e) {
+    e === void 0 && (e = {});
+    const s = e.tail && e._beforeTailState ? e._beforeTailState._value : this._value, r = this._separatorsCountFromSlice(s);
+    this._value = this._removeThousandsSeparators(this.value);
+    const i = this._value;
+    this._value += t;
+    const n = this.number;
+    let u = !isNaN(n), l = !1;
+    if (u) {
+      let S;
+      this.min != null && this.min < 0 && this.number < this.min && (S = this.min), this.max != null && this.max > 0 && this.number > this.max && (S = this.max), S != null && (this.autofix ? (this._value = this.format(S, this).replace(U.UNMASKED_RADIX, this.radix), l || (l = i === this._value && !e.tail)) : u = !1), u && (u = !!this._value.match(this._numberRegExp));
+    }
+    let h;
+    u ? h = new E({
+      inserted: this._value.slice(i.length),
+      rawInserted: l ? "" : t,
+      skip: l
+    }) : (this._value = i, h = new E()), this._value = this._insertThousandsSeparators(this._value);
+    const v = e.tail && e._beforeTailState ? e._beforeTailState._value : this._value, _ = this._separatorsCountFromSlice(v);
+    return h.tailShift += (_ - r) * this.thousandsSeparator.length, h;
+  }
+  _findSeparatorAround(t) {
+    if (this.thousandsSeparator) {
+      const e = t - this.thousandsSeparator.length + 1, s = this.value.indexOf(this.thousandsSeparator, e);
+      if (s <= t) return s;
+    }
+    return -1;
+  }
+  _adjustRangeWithSeparators(t, e) {
+    const s = this._findSeparatorAround(t);
+    s >= 0 && (t = s);
+    const r = this._findSeparatorAround(e);
+    return r >= 0 && (e = r + this.thousandsSeparator.length), [t, e];
+  }
+  remove(t, e) {
+    t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length), [t, e] = this._adjustRangeWithSeparators(t, e);
+    const s = this.value.slice(0, t), r = this.value.slice(e), i = this._separatorsCount(s.length);
+    this._value = this._insertThousandsSeparators(this._removeThousandsSeparators(s + r));
+    const n = this._separatorsCountFromSlice(s);
+    return new E({
+      tailShift: (n - i) * this.thousandsSeparator.length
+    });
+  }
+  nearestInputPos(t, e) {
+    if (!this.thousandsSeparator) return t;
+    switch (e) {
+      case m.NONE:
+      case m.LEFT:
+      case m.FORCE_LEFT: {
+        const s = this._findSeparatorAround(t - 1);
+        if (s >= 0) {
+          const r = s + this.thousandsSeparator.length;
+          if (t < r || this.value.length <= r || e === m.FORCE_LEFT)
+            return s;
+        }
+        break;
+      }
+      case m.RIGHT:
+      case m.FORCE_RIGHT: {
+        const s = this._findSeparatorAround(t);
+        if (s >= 0)
+          return s + this.thousandsSeparator.length;
+      }
+    }
+    return t;
+  }
+  doCommit() {
+    if (this.value) {
+      const t = this.number;
+      let e = t;
+      this.min != null && (e = Math.max(e, this.min)), this.max != null && (e = Math.min(e, this.max)), e !== t && (this.unmaskedValue = this.format(e, 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(t) {
+    const e = this._removeThousandsSeparators(t).split(this.radix);
+    return e[0] = e[0].replace(/^(\D*)(0*)(\d*)/, (s, r, i, n) => r + n), t.length && !/\d$/.test(e[0]) && (e[0] = e[0] + "0"), e.length > 1 && (e[1] = e[1].replace(/0*$/, ""), e[1].length || (e.length = 1)), this._insertThousandsSeparators(e.join(this.radix));
+  }
+  _padFractionalZeros(t) {
+    if (!t) return t;
+    const e = t.split(this.radix);
+    return e.length < 2 && e.push(""), e[1] = e[1].padEnd(this.scale, "0"), e.join(this.radix);
+  }
+  doSkipInvalid(t, e, s) {
+    e === void 0 && (e = {});
+    const r = this.scale === 0 && t !== this.thousandsSeparator && (t === this.radix || t === U.UNMASKED_RADIX || this.mapToRadix.includes(t));
+    return super.doSkipInvalid(t, e, s) && !r;
+  }
+  get unmaskedValue() {
+    return this._removeThousandsSeparators(this._normalizeZeros(this.value)).replace(this.radix, U.UNMASKED_RADIX);
+  }
+  set unmaskedValue(t) {
+    super.unmaskedValue = t;
+  }
+  get typedValue() {
+    return this.parse(this.unmaskedValue, this);
+  }
+  set typedValue(t) {
+    this.rawInputValue = this.format(t, this).replace(U.UNMASKED_RADIX, this.radix);
+  }
+  /** Parsed Number */
+  get number() {
+    return this.typedValue;
+  }
+  set number(t) {
+    this.typedValue = t;
+  }
+  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(t) {
+    return (super.typedValueEquals(t) || U.EMPTY_VALUES.includes(t) && U.EMPTY_VALUES.includes(this.typedValue)) && !(t === 0 && this.value === "");
+  }
+}
+Qt = U;
+U.UNMASKED_RADIX = ".";
+U.EMPTY_VALUES = [...P.EMPTY_VALUES, 0];
+U.DEFAULTS = {
+  ...P.DEFAULTS,
+  mask: Number,
+  radix: ",",
+  thousandsSeparator: "",
+  mapToRadix: [Qt.UNMASKED_RADIX],
+  min: Number.MIN_SAFE_INTEGER,
+  max: Number.MAX_SAFE_INTEGER,
+  scale: 2,
+  normalizeZeros: !0,
+  padFractionalZeros: !1,
+  parse: Number,
+  format: (a) => a.toLocaleString("en-US", {
+    useGrouping: !1,
+    maximumFractionDigits: 20
+  })
+};
+g.MaskedNumber = U;
+const Rt = {
+  MASKED: "value",
+  UNMASKED: "unmaskedValue",
+  TYPED: "typedValue"
+};
+function te(a, t, e) {
+  t === void 0 && (t = Rt.MASKED), e === void 0 && (e = Rt.MASKED);
+  const s = K(a);
+  return (r) => s.runIsolated((i) => (i[t] = r, i[e]));
+}
+function ke(a, t, e, s) {
+  return te(t, e, s)(a);
+}
+g.PIPE_TYPE = Rt;
+g.createPipe = te;
+g.pipe = ke;
+class Ee extends L {
+  get repeatFrom() {
+    var t;
+    return (t = Array.isArray(this.repeat) ? this.repeat[0] : this.repeat === 1 / 0 ? 0 : this.repeat) != null ? t : 0;
+  }
+  get repeatTo() {
+    var t;
+    return (t = Array.isArray(this.repeat) ? this.repeat[1] : this.repeat) != null ? t : 1 / 0;
+  }
+  constructor(t) {
+    super(t);
+  }
+  updateOptions(t) {
+    super.updateOptions(t);
+  }
+  _update(t) {
+    var e, s, r;
+    const {
+      repeat: i,
+      ...n
+    } = et(t);
+    this._blockOpts = Object.assign({}, this._blockOpts, n);
+    const u = K(this._blockOpts);
+    this.repeat = (e = (s = i ?? u.repeat) != null ? s : this.repeat) != null ? e : 1 / 0, super._update({
+      mask: "m".repeat(Math.max(this.repeatTo === 1 / 0 && ((r = this._blocks) == null ? void 0 : r.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(t) {
+    if (t < this._blocks.length) return this._blocks[t];
+    if (this.repeatTo === 1 / 0 || this._blocks.length < this.repeatTo)
+      return this._blocks.push(K(this._blockOpts)), this.mask += "m", this._blocks[this._blocks.length - 1];
+  }
+  _appendCharRaw(t, e) {
+    e === void 0 && (e = {});
+    const s = new E();
+    for (
+      let l = (r = (i = this._mapPosToBlock(this.displayValue.length)) == null ? void 0 : i.index) != null ? r : Math.max(this._blocks.length - 1, 0), h, v;
+      // try to get a block or
+      // try to allocate a new block if not allocated already
+      h = (n = this._blocks[l]) != null ? n : v = !v && this._allocateBlock(l);
+      ++l
+    ) {
+      var r, i, n, u;
+      const _ = h._appendChar(t, {
+        ...e,
+        _beforeTailState: (u = e._beforeTailState) == null || (u = u._blocks) == null ? void 0 : u[l]
+      });
+      if (_.skip && v) {
+        this._blocks.pop(), this.mask = this.mask.slice(1);
+        break;
+      }
+      if (s.aggregate(_), _.consumed) break;
+    }
+    return s;
+  }
+  _trimEmptyTail(t, e) {
+    var s, r;
+    t === void 0 && (t = 0);
+    const i = Math.max(((s = this._mapPosToBlock(t)) == null ? void 0 : s.index) || 0, this.repeatFrom, 0);
+    let n;
+    e != null && (n = (r = this._mapPosToBlock(e)) == null ? void 0 : r.index), n == null && (n = this._blocks.length - 1);
+    let u = 0;
+    for (let l = n; i <= l && !this._blocks[l].unmaskedValue; --l, ++u)
+      ;
+    u && (this._blocks.splice(n - u + 1, u), this.mask = this.mask.slice(u));
+  }
+  reset() {
+    super.reset(), this._trimEmptyTail();
+  }
+  remove(t, e) {
+    t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length);
+    const s = super.remove(t, e);
+    return this._trimEmptyTail(t, e), s;
+  }
+  totalInputPositions(t, e) {
+    return t === void 0 && (t = 0), e == null && this.repeatTo === 1 / 0 ? 1 / 0 : super.totalInputPositions(t, e);
+  }
+  get state() {
+    return super.state;
+  }
+  set state(t) {
+    this._blocks.length = t._blocks.length, this.mask = this.mask.slice(0, this._blocks.length), super.state = t;
+  }
+}
+g.RepeatBlock = Ee;
+try {
+  globalThis.IMask = g;
+} catch {
+}
+function ee(a) {
+  return a && a.__esModule && Object.prototype.hasOwnProperty.call(a, "default") ? a.default : a;
+}
+var nt = { exports: {} }, at = { exports: {} }, I = {};
+/** @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 Lt;
+function ye() {
+  if (Lt) return I;
+  Lt = 1;
+  var a = typeof Symbol == "function" && Symbol.for, t = a ? Symbol.for("react.element") : 60103, e = a ? Symbol.for("react.portal") : 60106, s = a ? Symbol.for("react.fragment") : 60107, r = a ? Symbol.for("react.strict_mode") : 60108, i = a ? Symbol.for("react.profiler") : 60114, n = a ? Symbol.for("react.provider") : 60109, u = a ? Symbol.for("react.context") : 60110, l = a ? Symbol.for("react.async_mode") : 60111, h = a ? Symbol.for("react.concurrent_mode") : 60111, v = a ? Symbol.for("react.forward_ref") : 60112, _ = a ? Symbol.for("react.suspense") : 60113, S = a ? Symbol.for("react.suspense_list") : 60120, B = a ? Symbol.for("react.memo") : 60115, N = a ? Symbol.for("react.lazy") : 60116, M = a ? Symbol.for("react.block") : 60121, O = a ? Symbol.for("react.fundamental") : 60117, q = a ? Symbol.for("react.responder") : 60118, tt = a ? Symbol.for("react.scope") : 60119;
+  function V(c) {
+    if (typeof c == "object" && c !== null) {
+      var W = c.$$typeof;
+      switch (W) {
+        case t:
+          switch (c = c.type, c) {
+            case l:
+            case h:
+            case s:
+            case i:
+            case r:
+            case _:
+              return c;
+            default:
+              switch (c = c && c.$$typeof, c) {
+                case u:
+                case v:
+                case N:
+                case B:
+                case n:
+                  return c;
+                default:
+                  return W;
+              }
+          }
+        case e:
+          return W;
+      }
+    }
+  }
+  function D(c) {
+    return V(c) === h;
+  }
+  return I.AsyncMode = l, I.ConcurrentMode = h, I.ContextConsumer = u, I.ContextProvider = n, I.Element = t, I.ForwardRef = v, I.Fragment = s, I.Lazy = N, I.Memo = B, I.Portal = e, I.Profiler = i, I.StrictMode = r, I.Suspense = _, I.isAsyncMode = function(c) {
+    return D(c) || V(c) === l;
+  }, I.isConcurrentMode = D, I.isContextConsumer = function(c) {
+    return V(c) === u;
+  }, I.isContextProvider = function(c) {
+    return V(c) === n;
+  }, I.isElement = function(c) {
+    return typeof c == "object" && c !== null && c.$$typeof === t;
+  }, I.isForwardRef = function(c) {
+    return V(c) === v;
+  }, I.isFragment = function(c) {
+    return V(c) === s;
+  }, I.isLazy = function(c) {
+    return V(c) === N;
+  }, I.isMemo = function(c) {
+    return V(c) === B;
+  }, I.isPortal = function(c) {
+    return V(c) === e;
+  }, I.isProfiler = function(c) {
+    return V(c) === i;
+  }, I.isStrictMode = function(c) {
+    return V(c) === r;
+  }, I.isSuspense = function(c) {
+    return V(c) === _;
+  }, I.isValidElementType = function(c) {
+    return typeof c == "string" || typeof c == "function" || c === s || c === h || c === i || c === r || c === _ || c === S || typeof c == "object" && c !== null && (c.$$typeof === N || c.$$typeof === B || c.$$typeof === n || c.$$typeof === u || c.$$typeof === v || c.$$typeof === O || c.$$typeof === q || c.$$typeof === tt || c.$$typeof === M);
+  }, I.typeOf = V, I;
+}
+var w = {};
+/** @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 Nt;
+function Ce() {
+  return Nt || (Nt = 1, process.env.NODE_ENV !== "production" && function() {
+    var a = typeof Symbol == "function" && Symbol.for, t = a ? Symbol.for("react.element") : 60103, e = a ? Symbol.for("react.portal") : 60106, s = a ? Symbol.for("react.fragment") : 60107, r = a ? Symbol.for("react.strict_mode") : 60108, i = a ? Symbol.for("react.profiler") : 60114, n = a ? Symbol.for("react.provider") : 60109, u = a ? Symbol.for("react.context") : 60110, l = a ? Symbol.for("react.async_mode") : 60111, h = a ? Symbol.for("react.concurrent_mode") : 60111, v = a ? Symbol.for("react.forward_ref") : 60112, _ = a ? Symbol.for("react.suspense") : 60113, S = a ? Symbol.for("react.suspense_list") : 60120, B = a ? Symbol.for("react.memo") : 60115, N = a ? Symbol.for("react.lazy") : 60116, M = a ? Symbol.for("react.block") : 60121, O = a ? Symbol.for("react.fundamental") : 60117, q = a ? Symbol.for("react.responder") : 60118, tt = a ? Symbol.for("react.scope") : 60119;
+    function V(p) {
+      return typeof p == "string" || typeof p == "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+      p === s || p === h || p === i || p === r || p === _ || p === S || typeof p == "object" && p !== null && (p.$$typeof === N || p.$$typeof === B || p.$$typeof === n || p.$$typeof === u || p.$$typeof === v || p.$$typeof === O || p.$$typeof === q || p.$$typeof === tt || p.$$typeof === M);
+    }
+    function D(p) {
+      if (typeof p == "object" && p !== null) {
+        var Y = p.$$typeof;
+        switch (Y) {
+          case t:
+            var rt = p.type;
+            switch (rt) {
+              case l:
+              case h:
+              case s:
+              case i:
+              case r:
+              case _:
+                return rt;
+              default:
+                var Ot = rt && rt.$$typeof;
+                switch (Ot) {
+                  case u:
+                  case v:
+                  case N:
+                  case B:
+                  case n:
+                    return Ot;
+                  default:
+                    return Y;
+                }
+            }
+          case e:
+            return Y;
+        }
+      }
+    }
+    var c = l, W = h, ft = u, mt = n, vt = t, gt = v, st = s, _t = N, kt = B, Q = e, Et = i, $ = r, Z = _, it = !1;
+    function yt(p) {
+      return it || (it = !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.")), o(p) || D(p) === l;
+    }
+    function o(p) {
+      return D(p) === h;
+    }
+    function d(p) {
+      return D(p) === u;
+    }
+    function b(p) {
+      return D(p) === n;
+    }
+    function C(p) {
+      return typeof p == "object" && p !== null && p.$$typeof === t;
+    }
+    function k(p) {
+      return D(p) === v;
+    }
+    function F(p) {
+      return D(p) === s;
+    }
+    function y(p) {
+      return D(p) === N;
+    }
+    function A(p) {
+      return D(p) === B;
+    }
+    function x(p) {
+      return D(p) === e;
+    }
+    function R(p) {
+      return D(p) === i;
+    }
+    function T(p) {
+      return D(p) === r;
+    }
+    function j(p) {
+      return D(p) === _;
+    }
+    w.AsyncMode = c, w.ConcurrentMode = W, w.ContextConsumer = ft, w.ContextProvider = mt, w.Element = vt, w.ForwardRef = gt, w.Fragment = st, w.Lazy = _t, w.Memo = kt, w.Portal = Q, w.Profiler = Et, w.StrictMode = $, w.Suspense = Z, w.isAsyncMode = yt, w.isConcurrentMode = o, w.isContextConsumer = d, w.isContextProvider = b, w.isElement = C, w.isForwardRef = k, w.isFragment = F, w.isLazy = y, w.isMemo = A, w.isPortal = x, w.isProfiler = R, w.isStrictMode = T, w.isSuspense = j, w.isValidElementType = V, w.typeOf = D;
+  }()), w;
+}
+var jt;
+function se() {
+  return jt || (jt = 1, process.env.NODE_ENV === "production" ? at.exports = ye() : at.exports = Ce()), at.exports;
+}
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var At, Ut;
+function Ae() {
+  if (Ut) return At;
+  Ut = 1;
+  var a = Object.getOwnPropertySymbols, t = Object.prototype.hasOwnProperty, e = Object.prototype.propertyIsEnumerable;
+  function s(i) {
+    if (i == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(i);
+  }
+  function r() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var i = new String("abc");
+      if (i[5] = "de", Object.getOwnPropertyNames(i)[0] === "5")
+        return !1;
+      for (var n = {}, u = 0; u < 10; u++)
+        n["_" + String.fromCharCode(u)] = u;
+      var l = Object.getOwnPropertyNames(n).map(function(v) {
+        return n[v];
+      });
+      if (l.join("") !== "0123456789")
+        return !1;
+      var h = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(v) {
+        h[v] = v;
+      }), Object.keys(Object.assign({}, h)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return At = r() ? Object.assign : function(i, n) {
+    for (var u, l = s(i), h, v = 1; v < arguments.length; v++) {
+      u = Object(arguments[v]);
+      for (var _ in u)
+        t.call(u, _) && (l[_] = u[_]);
+      if (a) {
+        h = a(u);
+        for (var S = 0; S < h.length; S++)
+          e.call(u, h[S]) && (l[h[S]] = u[h[S]]);
+      }
+    }
+    return l;
+  }, At;
+}
+var bt, qt;
+function Bt() {
+  if (qt) return bt;
+  qt = 1;
+  var a = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return bt = a, bt;
+}
+var St, $t;
+function ie() {
+  return $t || ($t = 1, St = Function.call.bind(Object.prototype.hasOwnProperty)), St;
+}
+var Ft, Yt;
+function be() {
+  if (Yt) return Ft;
+  Yt = 1;
+  var a = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var t = /* @__PURE__ */ Bt(), e = {}, s = /* @__PURE__ */ ie();
+    a = function(i) {
+      var n = "Warning: " + i;
+      typeof console < "u" && console.error(n);
+      try {
+        throw new Error(n);
+      } catch {
+      }
+    };
+  }
+  function r(i, n, u, l, h) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var v in i)
+        if (s(i, v)) {
+          var _;
+          try {
+            if (typeof i[v] != "function") {
+              var S = Error(
+                (l || "React class") + ": " + u + " type `" + v + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof i[v] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw S.name = "Invariant Violation", S;
+            }
+            _ = i[v](n, v, l, u, null, t);
+          } catch (N) {
+            _ = N;
+          }
+          if (_ && !(_ instanceof Error) && a(
+            (l || "React class") + ": type specification of " + u + " `" + v + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof _ + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), _ instanceof Error && !(_.message in e)) {
+            e[_.message] = !0;
+            var B = h ? h() : "";
+            a(
+              "Failed " + u + " type: " + _.message + (B ?? "")
+            );
+          }
+        }
+    }
+  }
+  return r.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (e = {});
+  }, Ft = r, Ft;
+}
+var xt, Ht;
+function Se() {
+  if (Ht) return xt;
+  Ht = 1;
+  var a = se(), t = Ae(), e = /* @__PURE__ */ Bt(), s = /* @__PURE__ */ ie(), r = /* @__PURE__ */ be(), i = function() {
+  };
+  process.env.NODE_ENV !== "production" && (i = function(u) {
+    var l = "Warning: " + u;
+    typeof console < "u" && console.error(l);
+    try {
+      throw new Error(l);
+    } catch {
+    }
+  });
+  function n() {
+    return null;
+  }
+  return xt = function(u, l) {
+    var h = typeof Symbol == "function" && Symbol.iterator, v = "@@iterator";
+    function _(o) {
+      var d = o && (h && o[h] || o[v]);
+      if (typeof d == "function")
+        return d;
+    }
+    var S = "<<anonymous>>", B = {
+      array: q("array"),
+      bigint: q("bigint"),
+      bool: q("boolean"),
+      func: q("function"),
+      number: q("number"),
+      object: q("object"),
+      string: q("string"),
+      symbol: q("symbol"),
+      any: tt(),
+      arrayOf: V,
+      element: D(),
+      elementType: c(),
+      instanceOf: W,
+      node: gt(),
+      objectOf: mt,
+      oneOf: ft,
+      oneOfType: vt,
+      shape: _t,
+      exact: kt
+    };
+    function N(o, d) {
+      return o === d ? o !== 0 || 1 / o === 1 / d : o !== o && d !== d;
+    }
+    function M(o, d) {
+      this.message = o, this.data = d && typeof d == "object" ? d : {}, this.stack = "";
+    }
+    M.prototype = Error.prototype;
+    function O(o) {
+      if (process.env.NODE_ENV !== "production")
+        var d = {}, b = 0;
+      function C(F, y, A, x, R, T, j) {
+        if (x = x || S, T = T || A, j !== e) {
+          if (l) {
+            var p = 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 p.name = "Invariant Violation", p;
+          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
+            var Y = x + ":" + A;
+            !d[Y] && // Avoid spamming the console because they are often not actionable except for lib authors
+            b < 3 && (i(
+              "You are manually calling a React.PropTypes validation function for the `" + T + "` prop on `" + x + "`. 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."
+            ), d[Y] = !0, b++);
+          }
+        }
+        return y[A] == null ? F ? y[A] === null ? new M("The " + R + " `" + T + "` is marked as required " + ("in `" + x + "`, but its value is `null`.")) : new M("The " + R + " `" + T + "` is marked as required in " + ("`" + x + "`, but its value is `undefined`.")) : null : o(y, A, x, R, T);
+      }
+      var k = C.bind(null, !1);
+      return k.isRequired = C.bind(null, !0), k;
+    }
+    function q(o) {
+      function d(b, C, k, F, y, A) {
+        var x = b[C], R = $(x);
+        if (R !== o) {
+          var T = Z(x);
+          return new M(
+            "Invalid " + F + " `" + y + "` of type " + ("`" + T + "` supplied to `" + k + "`, expected ") + ("`" + o + "`."),
+            { expectedType: o }
+          );
+        }
+        return null;
+      }
+      return O(d);
+    }
+    function tt() {
+      return O(n);
+    }
+    function V(o) {
+      function d(b, C, k, F, y) {
+        if (typeof o != "function")
+          return new M("Property `" + y + "` of component `" + k + "` has invalid PropType notation inside arrayOf.");
+        var A = b[C];
+        if (!Array.isArray(A)) {
+          var x = $(A);
+          return new M("Invalid " + F + " `" + y + "` of type " + ("`" + x + "` supplied to `" + k + "`, expected an array."));
+        }
+        for (var R = 0; R < A.length; R++) {
+          var T = o(A, R, k, F, y + "[" + R + "]", e);
+          if (T instanceof Error)
+            return T;
+        }
+        return null;
+      }
+      return O(d);
+    }
+    function D() {
+      function o(d, b, C, k, F) {
+        var y = d[b];
+        if (!u(y)) {
+          var A = $(y);
+          return new M("Invalid " + k + " `" + F + "` of type " + ("`" + A + "` supplied to `" + C + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return O(o);
+    }
+    function c() {
+      function o(d, b, C, k, F) {
+        var y = d[b];
+        if (!a.isValidElementType(y)) {
+          var A = $(y);
+          return new M("Invalid " + k + " `" + F + "` of type " + ("`" + A + "` supplied to `" + C + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return O(o);
+    }
+    function W(o) {
+      function d(b, C, k, F, y) {
+        if (!(b[C] instanceof o)) {
+          var A = o.name || S, x = yt(b[C]);
+          return new M("Invalid " + F + " `" + y + "` of type " + ("`" + x + "` supplied to `" + k + "`, expected ") + ("instance of `" + A + "`."));
+        }
+        return null;
+      }
+      return O(d);
+    }
+    function ft(o) {
+      if (!Array.isArray(o))
+        return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? i(
+          "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])."
+        ) : i("Invalid argument supplied to oneOf, expected an array.")), n;
+      function d(b, C, k, F, y) {
+        for (var A = b[C], x = 0; x < o.length; x++)
+          if (N(A, o[x]))
+            return null;
+        var R = JSON.stringify(o, function(j, p) {
+          var Y = Z(p);
+          return Y === "symbol" ? String(p) : p;
+        });
+        return new M("Invalid " + F + " `" + y + "` of value `" + String(A) + "` " + ("supplied to `" + k + "`, expected one of " + R + "."));
+      }
+      return O(d);
+    }
+    function mt(o) {
+      function d(b, C, k, F, y) {
+        if (typeof o != "function")
+          return new M("Property `" + y + "` of component `" + k + "` has invalid PropType notation inside objectOf.");
+        var A = b[C], x = $(A);
+        if (x !== "object")
+          return new M("Invalid " + F + " `" + y + "` of type " + ("`" + x + "` supplied to `" + k + "`, expected an object."));
+        for (var R in A)
+          if (s(A, R)) {
+            var T = o(A, R, k, F, y + "." + R, e);
+            if (T instanceof Error)
+              return T;
+          }
+        return null;
+      }
+      return O(d);
+    }
+    function vt(o) {
+      if (!Array.isArray(o))
+        return process.env.NODE_ENV !== "production" && i("Invalid argument supplied to oneOfType, expected an instance of array."), n;
+      for (var d = 0; d < o.length; d++) {
+        var b = o[d];
+        if (typeof b != "function")
+          return i(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + it(b) + " at index " + d + "."
+          ), n;
+      }
+      function C(k, F, y, A, x) {
+        for (var R = [], T = 0; T < o.length; T++) {
+          var j = o[T], p = j(k, F, y, A, x, e);
+          if (p == null)
+            return null;
+          p.data && s(p.data, "expectedType") && R.push(p.data.expectedType);
+        }
+        var Y = R.length > 0 ? ", expected one of type [" + R.join(", ") + "]" : "";
+        return new M("Invalid " + A + " `" + x + "` supplied to " + ("`" + y + "`" + Y + "."));
+      }
+      return O(C);
+    }
+    function gt() {
+      function o(d, b, C, k, F) {
+        return Q(d[b]) ? null : new M("Invalid " + k + " `" + F + "` supplied to " + ("`" + C + "`, expected a ReactNode."));
+      }
+      return O(o);
+    }
+    function st(o, d, b, C, k) {
+      return new M(
+        (o || "React class") + ": " + d + " type `" + b + "." + C + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + k + "`."
+      );
+    }
+    function _t(o) {
+      function d(b, C, k, F, y) {
+        var A = b[C], x = $(A);
+        if (x !== "object")
+          return new M("Invalid " + F + " `" + y + "` of type `" + x + "` " + ("supplied to `" + k + "`, expected `object`."));
+        for (var R in o) {
+          var T = o[R];
+          if (typeof T != "function")
+            return st(k, F, y, R, Z(T));
+          var j = T(A, R, k, F, y + "." + R, e);
+          if (j)
+            return j;
+        }
+        return null;
+      }
+      return O(d);
+    }
+    function kt(o) {
+      function d(b, C, k, F, y) {
+        var A = b[C], x = $(A);
+        if (x !== "object")
+          return new M("Invalid " + F + " `" + y + "` of type `" + x + "` " + ("supplied to `" + k + "`, expected `object`."));
+        var R = t({}, b[C], o);
+        for (var T in R) {
+          var j = o[T];
+          if (s(o, T) && typeof j != "function")
+            return st(k, F, y, T, Z(j));
+          if (!j)
+            return new M(
+              "Invalid " + F + " `" + y + "` key `" + T + "` supplied to `" + k + "`.\nBad object: " + JSON.stringify(b[C], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(o), null, "  ")
+            );
+          var p = j(A, T, k, F, y + "." + T, e);
+          if (p)
+            return p;
+        }
+        return null;
+      }
+      return O(d);
+    }
+    function Q(o) {
+      switch (typeof o) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !o;
+        case "object":
+          if (Array.isArray(o))
+            return o.every(Q);
+          if (o === null || u(o))
+            return !0;
+          var d = _(o);
+          if (d) {
+            var b = d.call(o), C;
+            if (d !== o.entries) {
+              for (; !(C = b.next()).done; )
+                if (!Q(C.value))
+                  return !1;
+            } else
+              for (; !(C = b.next()).done; ) {
+                var k = C.value;
+                if (k && !Q(k[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function Et(o, d) {
+      return o === "symbol" ? !0 : d ? d["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && d instanceof Symbol : !1;
+    }
+    function $(o) {
+      var d = typeof o;
+      return Array.isArray(o) ? "array" : o instanceof RegExp ? "object" : Et(d, o) ? "symbol" : d;
+    }
+    function Z(o) {
+      if (typeof o > "u" || o === null)
+        return "" + o;
+      var d = $(o);
+      if (d === "object") {
+        if (o instanceof Date)
+          return "date";
+        if (o instanceof RegExp)
+          return "regexp";
+      }
+      return d;
+    }
+    function it(o) {
+      var d = Z(o);
+      switch (d) {
+        case "array":
+        case "object":
+          return "an " + d;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + d;
+        default:
+          return d;
+      }
+    }
+    function yt(o) {
+      return !o.constructor || !o.constructor.name ? S : o.constructor.name;
+    }
+    return B.checkPropTypes = r, B.resetWarningCache = r.resetWarningCache, B.PropTypes = B, B;
+  }, xt;
+}
+var Tt, zt;
+function Fe() {
+  if (zt) return Tt;
+  zt = 1;
+  var a = /* @__PURE__ */ Bt();
+  function t() {
+  }
+  function e() {
+  }
+  return e.resetWarningCache = t, Tt = function() {
+    function s(n, u, l, h, v, _) {
+      if (_ !== a) {
+        var S = 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 S.name = "Invariant Violation", S;
+      }
+    }
+    s.isRequired = s;
+    function r() {
+      return s;
+    }
+    var i = {
+      array: s,
+      bigint: s,
+      bool: s,
+      func: s,
+      number: s,
+      object: s,
+      string: s,
+      symbol: s,
+      any: s,
+      arrayOf: r,
+      element: s,
+      elementType: s,
+      instanceOf: r,
+      node: s,
+      objectOf: r,
+      oneOf: r,
+      oneOfType: r,
+      shape: r,
+      exact: r,
+      checkPropTypes: e,
+      resetWarningCache: t
+    };
+    return i.PropTypes = i, i;
+  }, Tt;
+}
+var Kt;
+function xe() {
+  if (Kt) return nt.exports;
+  if (Kt = 1, process.env.NODE_ENV !== "production") {
+    var a = se(), t = !0;
+    nt.exports = /* @__PURE__ */ Se()(a.isElement, t);
+  } else
+    nt.exports = /* @__PURE__ */ Fe()();
+  return nt.exports;
+}
+var Te = /* @__PURE__ */ xe();
+const f = /* @__PURE__ */ ee(Te), re = {
+  // common
+  mask: f.oneOfType([f.array, f.func, f.string, f.instanceOf(RegExp), f.oneOf([Date, Number, g.Masked]), f.instanceOf(g.Masked)]),
+  value: f.any,
+  unmask: f.oneOfType([f.bool, f.oneOf(["typed"])]),
+  prepare: f.func,
+  prepareChar: f.func,
+  validate: f.func,
+  commit: f.func,
+  overwrite: f.oneOfType([f.bool, f.oneOf(["shift"])]),
+  eager: f.oneOfType([f.bool, f.oneOf(["append", "remove"])]),
+  skipInvalid: f.bool,
+  // events
+  onAccept: f.func,
+  onComplete: f.func,
+  // pattern
+  placeholderChar: f.string,
+  displayChar: f.string,
+  lazy: f.bool,
+  definitions: f.object,
+  blocks: f.object,
+  // enum
+  enum: f.arrayOf(f.string),
+  // range
+  maxLength: f.number,
+  from: f.number,
+  to: f.number,
+  // date
+  pattern: f.string,
+  format: f.func,
+  parse: f.func,
+  autofix: f.oneOfType([f.bool, f.oneOf(["pad"])]),
+  // number
+  radix: f.string,
+  thousandsSeparator: f.string,
+  mapToRadix: f.arrayOf(f.string),
+  scale: f.number,
+  normalizeZeros: f.bool,
+  padFractionalZeros: f.bool,
+  min: f.oneOfType([f.number, f.instanceOf(Date)]),
+  max: f.oneOfType([f.number, f.instanceOf(Date)]),
+  // dynamic
+  dispatch: f.func,
+  // ref
+  inputRef: f.oneOfType([f.func, f.shape({
+    current: f.object
+  })])
+}, ne = Object.keys(re).filter((a) => a !== "value"), Ie = ["value", "unmask", "onAccept", "onComplete", "inputRef"], we = ne.filter((a) => Ie.indexOf(a) < 0);
+function Re(a) {
+  var t;
+  const e = (t = class extends X.Component {
+    constructor(i) {
+      super(i), this._inputRef = this._inputRef.bind(this);
+    }
+    componentDidMount() {
+      this.props.mask && this.initMask();
+    }
+    componentDidUpdate() {
+      const i = this.props, n = this._extractMaskOptionsFromProps(i);
+      if (n.mask)
+        this.maskRef ? (this.maskRef.updateOptions(n), "value" in i && i.value !== void 0 && (this.maskValue = i.value)) : this.initMask(n);
+      else if (this.destroyMask(), "value" in i && i.value !== void 0) {
+        var u;
+        (u = this.element) != null && u.isContentEditable && this.element.tagName !== "INPUT" && this.element.tagName !== "TEXTAREA" ? this.element.textContent = i.value : this.element.value = i.value;
+      }
+    }
+    componentWillUnmount() {
+      this.destroyMask();
+    }
+    _inputRef(i) {
+      this.element = i, this.props.inputRef && (Object.prototype.hasOwnProperty.call(this.props.inputRef, "current") ? this.props.inputRef.current = i : this.props.inputRef(i));
+    }
+    initMask(i) {
+      i === void 0 && (i = this._extractMaskOptionsFromProps(this.props)), this.maskRef = g(this.element, i).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(i) {
+      const {
+        ...n
+      } = i;
+      return Object.keys(n).filter((u) => we.indexOf(u) < 0).forEach((u) => {
+        delete n[u];
+      }), n;
+    }
+    _extractNonMaskProps(i) {
+      const {
+        ...n
+      } = i;
+      return ne.forEach((u) => {
+        u !== "maxLength" && delete n[u];
+      }), "defaultValue" in n || (n.defaultValue = i.mask ? "" : n.value), delete n.value, n;
+    }
+    get maskValue() {
+      return this.maskRef ? this.props.unmask === "typed" ? this.maskRef.typedValue : this.props.unmask ? this.maskRef.unmaskedValue : this.maskRef.value : "";
+    }
+    set maskValue(i) {
+      this.maskRef && (i = i == null && this.props.unmask !== "typed" ? "" : i, this.props.unmask === "typed" ? this.maskRef.typedValue = i : this.props.unmask ? this.maskRef.unmaskedValue = i : this.maskRef.value = i);
+    }
+    _onAccept(i) {
+      this.props.onAccept && this.maskRef && this.props.onAccept(this.maskValue, this.maskRef, i);
+    }
+    _onComplete(i) {
+      this.props.onComplete && this.maskRef && this.props.onComplete(this.maskValue, this.maskRef, i);
+    }
+    render() {
+      return X.createElement(a, {
+        ...this._extractNonMaskProps(this.props),
+        inputRef: this._inputRef
+      });
+    }
+  }, t.displayName = void 0, t.propTypes = void 0, t), s = a.displayName || a.name || "Component";
+  return e.displayName = "IMask(" + s + ")", e.propTypes = re, X.forwardRef((r, i) => X.createElement(e, {
+    ...r,
+    ref: i
+  }));
+}
+const Me = Re((a) => {
+  let {
+    inputRef: t,
+    ...e
+  } = a;
+  return X.createElement("input", {
+    ...e,
+    ref: t
+  });
+}), Be = (a, t) => X.createElement(Me, {
+  ...a,
+  ref: t
+}), Oe = X.forwardRef(Be), De = "_input_u23b9_1", Ve = "_section_u23b9_7", ae = {
+  input: De,
+  section: Ve
+}, Pe = (a) => /* @__PURE__ */ Dt.createElement("svg", { width: 20, height: 20, viewBox: "0 0 20 20", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...a }, /* @__PURE__ */ Dt.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 It = { exports: {} };
+/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+*/
+var Gt;
+function Le() {
+  return Gt || (Gt = 1, function(a) {
+    (function() {
+      var t = {}.hasOwnProperty;
+      function e() {
+        for (var i = "", n = 0; n < arguments.length; n++) {
+          var u = arguments[n];
+          u && (i = r(i, s(u)));
+        }
+        return i;
+      }
+      function s(i) {
+        if (typeof i == "string" || typeof i == "number")
+          return i;
+        if (typeof i != "object")
+          return "";
+        if (Array.isArray(i))
+          return e.apply(null, i);
+        if (i.toString !== Object.prototype.toString && !i.toString.toString().includes("[native code]"))
+          return i.toString();
+        var n = "";
+        for (var u in i)
+          t.call(i, u) && i[u] && (n = r(n, u));
+        return n;
+      }
+      function r(i, n) {
+        return n ? i ? i + " " + n : i + n : i;
+      }
+      a.exports ? (e.default = e, a.exports = e) : window.classNames = e;
+    })();
+  }(It)), It.exports;
+}
+var Ne = Le();
+const je = /* @__PURE__ */ ee(Ne), Ue = je(ae.input, oe["caption-l-regular"]), qe = ue.withProps({
+  leftSection: /* @__PURE__ */ wt(Pe, {}),
+  component: Oe,
+  mask: "0000 0000 0000 0000",
+  placeholder: "____ ____ ____ ____",
+  classNames: { input: Ue, section: ae.section }
+}), We = (a) => {
+  const t = le(a.value);
+  return /* @__PURE__ */ wt(
+    qe,
+    {
+      ...a,
+      rightSection: t && /* @__PURE__ */ wt(t, {})
+    }
+  );
+};
+export {
+  We as CardInput,
+  qe as CardInputBase
+};