@7pmlabs/design-system 0.6.3 → 0.6.4

package/dist/design-system104.mjs

@@ -1,21 +1,2175 @@
-import { openBlock as e, createElementBlock as t, createElementVNode as s } from "vue";
-import o from "./design-system57.mjs";
-const d = {}, c = { class: "ds-absolute ds-rounded-full ds-bg-black/20" }, l = /* @__PURE__ */ s("div", { class: "ds-flex ds-h-full ds-w-full ds-items-center ds-justify-center" }, [
-  /* @__PURE__ */ s("svg", {
-    class: "ds-h-5 ds-w-5 ds-cursor-pointer ds-fill-white hover:ds-fill-white/60",
-    viewBox: "0 0 512 512",
-    xmlns: "http://www.w3.org/2000/svg"
-  }, [
-    /* @__PURE__ */ s("path", { d: "M0 256C0 114.6 114.6 0 256 0C397.4 0 512 114.6 512 256C512 397.4 397.4 512 256 512C114.6 512 0 397.4 0 256zM175 208.1L222.1 255.1L175 303C165.7 312.4 165.7 327.6 175 336.1C184.4 346.3 199.6 346.3 208.1 336.1L255.1 289.9L303 336.1C312.4 346.3 327.6 346.3 336.1 336.1C346.3 327.6 346.3 312.4 336.1 303L289.9 255.1L336.1 208.1C346.3 199.6 346.3 184.4 336.1 175C327.6 165.7 312.4 165.7 303 175L255.1 222.1L208.1 175C199.6 165.7 184.4 165.7 175 175C165.7 184.4 165.7 199.6 175 208.1V208.1z" })
-  ])
-], -1), r = [
-  l
-];
-function n(i, f) {
-  return e(), t("div", c, r);
-}
-const C = /* @__PURE__ */ o(d, [["render", n]]);
+(function(p, m) {
+  typeof exports == "object" && typeof module < "u" ? m(exports) : typeof define == "function" && define.amd ? define(["exports"], m) : (p = typeof globalThis < "u" ? globalThis : p || self, m(p.IMask = {}));
+})(globalThis, function(p) {
+  function m(n) {
+    return typeof n == "string" || n instanceof String;
+  }
+  function P(n) {
+    var t;
+    return typeof n == "object" && n != null && (n == null || (t = n.constructor) == null ? void 0 : t.name) === "Object";
+  }
+  function U(n, t) {
+    return Array.isArray(t) ? U(n, (e, s) => t.includes(s)) : Object.entries(n).reduce((e, s) => {
+      let [i, u] = s;
+      return t(u, i) && (e[i] = u), e;
+    }, {});
+  }
+  const h = {
+    NONE: "NONE",
+    LEFT: "LEFT",
+    FORCE_LEFT: "FORCE_LEFT",
+    RIGHT: "RIGHT",
+    FORCE_RIGHT: "FORCE_RIGHT"
+  };
+  function j(n) {
+    switch (n) {
+      case h.LEFT:
+        return h.FORCE_LEFT;
+      case h.RIGHT:
+        return h.FORCE_RIGHT;
+      default:
+        return n;
+    }
+  }
+  function y(n) {
+    return n.replace(/([.*+?^=!:${}()|[\]/\\])/g, "\\$1");
+  }
+  function b(n, t) {
+    if (t === n)
+      return !0;
+    const e = Array.isArray(t), s = Array.isArray(n);
+    let i;
+    if (e && s) {
+      if (t.length != n.length)
+        return !1;
+      for (i = 0; i < t.length; i++)
+        if (!b(t[i], n[i]))
+          return !1;
+      return !0;
+    }
+    if (e != s)
+      return !1;
+    if (t && n && typeof t == "object" && typeof n == "object") {
+      const u = t instanceof Date, a = n instanceof Date;
+      if (u && a)
+        return t.getTime() == n.getTime();
+      if (u != a)
+        return !1;
+      const r = t instanceof RegExp, l = n instanceof RegExp;
+      if (r && l)
+        return t.toString() == n.toString();
+      if (r != l)
+        return !1;
+      const d = Object.keys(t);
+      for (i = 0; i < d.length; i++)
+        if (!Object.prototype.hasOwnProperty.call(n, d[i]))
+          return !1;
+      for (i = 0; i < d.length; i++)
+        if (!b(n[d[i]], t[d[i]]))
+          return !1;
+      return !0;
+    } else if (t && n && typeof t == "function" && typeof n == "function")
+      return t.toString() === n.toString();
+    return !1;
+  }
+  class Z {
+    /** 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;
+    }
+    /** 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 ? h.NONE : (this.oldSelection.end === this.cursorPos || this.oldSelection.start === this.cursorPos) && // if not range removed (event with backspace)
+      this.oldSelection.end === this.oldSelection.start ? h.RIGHT : h.LEFT;
+    }
+  }
+  function o(n, t) {
+    return new o.InputMask(n, t);
+  }
+  function H(n) {
+    if (n == null)
+      throw new Error("mask property should be defined");
+    return n instanceof RegExp ? o.MaskedRegExp : m(n) ? o.MaskedPattern : n === Date ? o.MaskedDate : n === Number ? o.MaskedNumber : Array.isArray(n) || n === Array ? o.MaskedDynamic : o.Masked && n.prototype instanceof o.Masked ? n : o.Masked && n instanceof o.Masked ? n.constructor : n instanceof Function ? o.MaskedFunction : (console.warn("Mask not found for mask", n), o.Masked);
+  }
+  function x(n) {
+    if (!n)
+      throw new Error("Options in not defined");
+    if (o.Masked) {
+      if (n.prototype instanceof o.Masked)
+        return {
+          mask: n
+        };
+      const {
+        mask: t = void 0,
+        ...e
+      } = n instanceof o.Masked ? {
+        mask: n
+      } : P(n) && n.mask instanceof o.Masked ? n : {};
+      if (t) {
+        const s = t.mask;
+        return {
+          ...U(t, (i, u) => !u.startsWith("_")),
+          mask: t.constructor,
+          _mask: s,
+          ...e
+        };
+      }
+    }
+    return P(n) ? {
+      ...n
+    } : {
+      mask: n
+    };
+  }
+  function A(n) {
+    if (o.Masked && n instanceof o.Masked)
+      return n;
+    const t = x(n), e = H(t.mask);
+    if (!e)
+      throw new Error("Masked class is not found for provided 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);
+  }
+  o.createMask = A;
+  class I {
+    /** */
+    /** */
+    /** */
+    /** 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;
+    }
+    /** */
+    get isActive() {
+      return !1;
+    }
+    /** Safely sets element selection */
+    select(t, e) {
+      if (!(t == null || e == null || t === this.selectionStart && e === this.selectionEnd))
+        try {
+          this._unsafeSelect(t, e);
+        } catch {
+        }
+    }
+    /** */
+    /** */
+    /** */
+  }
+  o.MaskElement = I;
+  class F extends I {
+    /** HTMLElement to use mask on */
+    constructor(t) {
+      super(), this.input = t, this._handlers = {};
+    }
+    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) {
+      Object.keys(t).forEach((e) => this._toggleEventHandler(F.EVENTS_MAP[e], t[e]));
+    }
+    /**
+     Unbinds HTMLElement events to mask internal events
+     */
+    unbindEvents() {
+      Object.keys(this._handlers).forEach((t) => this._toggleEventHandler(t));
+    }
+    _toggleEventHandler(t, e) {
+      this._handlers[t] && (this.input.removeEventListener(t, this._handlers[t]), delete this._handlers[t]), e && (this.input.addEventListener(t, e), this._handlers[t] = e);
+    }
+  }
+  F.EVENTS_MAP = {
+    selectionChange: "keydown",
+    input: "input",
+    drop: "drop",
+    click: "click",
+    focus: "focus",
+    commit: "blur"
+  }, o.HTMLMaskElement = F;
+  class z extends F {
+    /** InputElement to use mask on */
+    constructor(t) {
+      super(t), this.input = t, this._handlers = {};
+    }
+    /** 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;
+    }
+    get value() {
+      return this.input.value;
+    }
+    set value(t) {
+      this.input.value = t;
+    }
+    /** Sets InputElement selection */
+    _unsafeSelect(t, e) {
+      this.input.setSelectionRange(t, e);
+    }
+  }
+  o.HTMLMaskElement = F;
+  class w extends F {
+    /** Returns HTMLElement selection start */
+    get _unsafeSelectionStart() {
+      const t = this.rootElement, e = t.getSelection && t.getSelection(), s = e && e.anchorOffset, i = e && e.focusOffset;
+      return i == null || s == null || s < i ? s : i;
+    }
+    /** Returns HTMLElement selection end */
+    get _unsafeSelectionEnd() {
+      const t = this.rootElement, e = t.getSelection && t.getSelection(), s = e && e.anchorOffset, i = e && e.focusOffset;
+      return i == null || s == null || s > i ? s : i;
+    }
+    /** HTMLElement value */
+    get value() {
+      return this.input.textContent || "";
+    }
+    set value(t) {
+      this.input.textContent = t;
+    }
+    /** 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 i = this.rootElement, u = i.getSelection && i.getSelection();
+      u && (u.removeAllRanges(), u.addRange(s));
+    }
+  }
+  o.HTMLContenteditableMaskElement = w;
+  class G {
+    /**
+     View element
+     */
+    /** Internal {@link Masked} model */
+    constructor(t, e) {
+      this.el = t instanceof I ? t : t.isContentEditable && t.tagName !== "INPUT" && t.tagName !== "TEXTAREA" ? new w(t) : new z(t), this.masked = A(e), this._listeners = {}, this._value = "", this._unmaskedValue = "", 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.alignCursor = this.alignCursor.bind(this), this.alignCursorFriendly = this.alignCursorFriendly.bind(this), this._bindEvents(), this.updateValue(), this._onChange();
+    }
+    /** Masked */
+    get mask() {
+      return this.masked.mask;
+    }
+    set mask(t) {
+      if (this.maskEquals(t))
+        return;
+      if (!(t instanceof o.Masked) && this.masked.constructor === H(t)) {
+        this.masked.updateOptions({
+          mask: t
+        });
+        return;
+      }
+      const e = t instanceof o.Masked ? t : A({
+        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(), this.alignCursor());
+    }
+    /** Unmasked value */
+    get unmaskedValue() {
+      return this._unmaskedValue;
+    }
+    set unmaskedValue(t) {
+      this.unmaskedValue !== t && (this.masked.unmaskedValue = 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(), this.alignCursor());
+    }
+    /** Display value */
+    get displayValue() {
+      return this.masked.displayValue;
+    }
+    /** 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());
+    }
+    maskEquals(t) {
+      var e;
+      return t == null || ((e = this.masked) == null ? void 0 : e.maskEquals(t));
+    }
+    /** 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
+      });
+    }
+    /** 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((i) => i(e));
+    }
+    /** 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;
+    }
+    /** Syncronizes view from model value, fires change events */
+    updateControl() {
+      const t = this.masked.unmaskedValue, e = this.masked.value, s = this.displayValue, i = this.unmaskedValue !== t || this.value !== e;
+      this._unmaskedValue = t, this._value = e, this.el.value !== s && (this.el.value = s), i && this._fireChangeEvents();
+    }
+    /** Updates options with deep equal check, recreates {@link Masked} model if mask type changes */
+    updateOptions(t) {
+      const {
+        mask: e,
+        ...s
+      } = t, i = !this.maskEquals(e), u = !b(this.masked, s);
+      i && (this.mask = e), u && this.masked.updateOptions(s), (i || u) && 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, h.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) {
+      if (this._inputEvent = t, this._abortUpdateCursor(), !this._selection)
+        return this.updateValue();
+      const e = new Z({
+        // new state
+        value: this.el.value,
+        cursorPos: this.cursorPos,
+        // old state
+        oldValue: this.displayValue,
+        oldSelection: this._selection
+      }), s = this.masked.rawInputValue, i = this.masked.splice(e.startChangePos, e.removed.length, e.inserted, e.removeDirection, {
+        input: !0,
+        raw: !0
+      }).offset, u = s === this.masked.rawInputValue ? e.removeDirection : h.NONE;
+      let a = this.masked.nearestInputPos(e.startChangePos + i, u);
+      u !== h.NONE && (a = this.masked.nearestInputPos(a, h.NONE)), this.updateControl(), this.updateCursor(a), delete this._inputEvent;
+    }
+    /** Handles view change event and commits model value */
+    _onChange() {
+      this.displayValue !== this.el.value && this.updateValue(), this.masked.doCommit(), this.updateControl(), this._saveSelection();
+    }
+    /** Handles view drop event, prevents by default */
+    _onDrop(t) {
+      t.preventDefault(), t.stopPropagation();
+    }
+    /** Restore last selection on focus */
+    _onFocus(t) {
+      this.alignCursorFriendly();
+    }
+    /** Restore last selection on focus */
+    _onClick(t) {
+      this.alignCursorFriendly();
+    }
+    /** Unbind view events and removes element reference */
+    destroy() {
+      this._unbindEvents(), this._listeners.length = 0, delete this.el;
+    }
+  }
+  o.InputMask = G;
+  class c {
+    /** Inserted symbols */
+    /** Can skip chars */
+    /** Additional offset if any changes occurred before tail */
+    constructor(t) {
+      Object.assign(this, {
+        inserted: "",
+        rawInserted: "",
+        skip: !1,
+        tailShift: 0
+      }, t);
+    }
+    /** Total offset considering all changes */
+    get offset() {
+      return this.tailShift + this.inserted.length;
+    }
+    /** Raw inserted is used by dynamic mask */
+    static normalize(t) {
+      return Array.isArray(t) ? t : [t, new c()];
+    }
+    /** Aggregate changes */
+    aggregate(t) {
+      return this.rawInserted += t.rawInserted, this.skip = this.skip || t.skip, this.inserted += t.inserted, this.tailShift += t.tailShift, this;
+    }
+  }
+  o.ChangeDetails = c;
+  class E {
+    /** 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;
+    }
+    get state() {
+      return {
+        value: this.value,
+        from: this.from,
+        stop: this.stop
+      };
+    }
+    set state(t) {
+      Object.assign(this, t);
+    }
+    toString() {
+      return this.value;
+    }
+    extend(t) {
+      this.value += String(t);
+    }
+    appendTo(t) {
+      return t.append(this.toString(), {
+        tail: !0
+      }).aggregate(t._appendPlaceholder());
+    }
+    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 f {
+    /** */
+    /** */
+    /** 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({
+        ...f.DEFAULTS,
+        ...t
+      }), this._initialized = !0;
+    }
+    /** Mask state */
+    get state() {
+      return {
+        _value: this.value,
+        _rawInputValue: this.rawInputValue
+      };
+    }
+    set state(t) {
+      this._value = t._value;
+    }
+    get value() {
+      return this._value;
+    }
+    set value(t) {
+      this.resolve(t, {
+        input: !0
+      });
+    }
+    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;
+    }
+    /** Sets and applies new options */
+    updateOptions(t) {
+      Object.keys(t).length && this.withValueRefresh(this._update.bind(this, t));
+    }
+    /** Sets new options */
+    _update(t) {
+      Object.assign(this, t);
+    }
+    /** Resets value */
+    reset() {
+      this._value = "";
+    }
+    /** Resolve new value */
+    resolve(t, e) {
+      e === void 0 && (e = {
+        input: !0
+      }), this.reset(), this.append(t, e, ""), this.doCommit();
+    }
+    /** 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 E(this.extractInput(t, e), t);
+    }
+    /** Appends tail */
+    appendTail(t) {
+      return m(t) && (t = new E(String(t))), t.appendTo(this);
+    }
+    /** Appends char */
+    _appendCharRaw(t, e) {
+      return t ? (this._value += t, new c({
+        inserted: t,
+        rawInserted: t
+      })) : new c();
+    }
+    /** Appends char */
+    _appendChar(t, e, s) {
+      e === void 0 && (e = {});
+      const i = this.state;
+      let u;
+      if ([t, u] = this.doPrepareChar(t, e), u = u.aggregate(this._appendCharRaw(t, e)), u.inserted) {
+        let a, r = this.doValidate(e) !== !1;
+        if (r && s != null) {
+          const l = this.state;
+          this.overwrite === !0 && (a = s.state, s.unshift(this.displayValue.length - u.tailShift));
+          let d = this.appendTail(s);
+          r = d.rawInserted === s.toString(), !(r && d.inserted) && this.overwrite === "shift" && (this.state = l, a = s.state, s.shift(), d = this.appendTail(s), r = d.rawInserted === s.toString()), r && d.inserted && (this.state = l);
+        }
+        r || (u = new c(), this.state = i, s && a && (s.state = a));
+      }
+      return u;
+    }
+    /** Appends optional placeholder at the end */
+    _appendPlaceholder() {
+      return new c();
+    }
+    /** Appends optional eager placeholder at the end */
+    _appendEager() {
+      return new c();
+    }
+    /** Appends symbols considering flags */
+    append(t, e, s) {
+      if (!m(t))
+        throw new Error("value should be string");
+      const i = m(s) ? new E(String(s)) : s;
+      e != null && e.tail && (e._beforeTailState = this.state);
+      let u;
+      [t, u] = this.doPrepare(t, e);
+      for (let a = 0; a < t.length; ++a) {
+        const r = this._appendChar(t[a], e, i);
+        if (!r.rawInserted && !this.doSkipInvalid(t[a], e, i))
+          break;
+        u.aggregate(r);
+      }
+      return (this.eager === !0 || this.eager === "append") && e != null && e.input && t && u.aggregate(this._appendEager()), i != null && (u.tailShift += this.appendTail(i).tailShift), u;
+    }
+    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 c();
+    }
+    /** 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, i = t();
+      return this.rawInputValue = e, this.value && this.value !== s && s.indexOf(this.value) === 0 && this.append(s.slice(this.displayValue.length), {}, ""), delete this._refreshing, i;
+    }
+    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 = {}), c.normalize(this.prepare ? this.prepare(t, this, e) : t);
+    }
+    /** Prepares each char before mask processing */
+    doPrepareChar(t, e) {
+      return e === void 0 && (e = {}), c.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, i, u) {
+      i === void 0 && (i = h.NONE), u === void 0 && (u = {
+        input: !0
+      });
+      const a = t + e, r = this.extractTail(a), l = this.eager === !0 || this.eager === "remove";
+      let d;
+      l && (i = j(i), d = this.extractInput(0, a, {
+        raw: !0
+      }));
+      let v = t;
+      const _ = new c();
+      if (i !== h.NONE && (v = this.nearestInputPos(t, e > 1 && t !== 0 && !l ? h.NONE : i), _.tailShift = v - t), _.aggregate(this.remove(v)), l && i !== h.NONE && d === this.rawInputValue)
+        if (i === h.FORCE_LEFT) {
+          let S;
+          for (; d === this.rawInputValue && (S = this.displayValue.length); )
+            _.aggregate(new c({
+              tailShift: -1
+            })).aggregate(this.remove(S - 1));
+        } else
+          i === h.FORCE_RIGHT && r.unshift();
+      return _.aggregate(this.append(s, u, r));
+    }
+    maskEquals(t) {
+      return this.mask === t;
+    }
+    typedValueEquals(t) {
+      const e = this.typedValue;
+      return t === e || f.EMPTY_VALUES.includes(t) && f.EMPTY_VALUES.includes(e) || (this.format ? this.format(t, this) === this.format(this.typedValue, this) : !1);
+    }
+  }
+  f.DEFAULTS = {
+    skipInvalid: !0
+  }, f.EMPTY_VALUES = [void 0, null, ""], o.Masked = f;
+  class C {
+    /** */
+    constructor(t, e) {
+      t === void 0 && (t = []), e === void 0 && (e = 0), this.chunks = t, this.from = 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((i) => {
+        const u = "chunks" in i ? new C() : new E();
+        return u.state = i, u;
+      });
+    }
+    toString() {
+      return this.chunks.map(String).join("");
+    }
+    extend(t) {
+      if (!String(t))
+        return;
+      t = m(t) ? new E(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 E)
+        s ? e.extend(t.toString()) : this.chunks.push(t);
+      else if (t instanceof C) {
+        if (t.stop == null) {
+          let i;
+          for (; t.chunks.length && t.chunks[0].stop == null; )
+            i = t.chunks.shift(), i.from += t.from, this.extend(i);
+        }
+        t.toString() && (t.stop = t.blockIndex, this.chunks.push(t));
+      }
+    }
+    appendTo(t) {
+      if (!(t instanceof o.MaskedPattern))
+        return new E(this.toString()).appendTo(t);
+      const e = new c();
+      for (let s = 0; s < this.chunks.length && !e.skip; ++s) {
+        const i = this.chunks[s], u = t._mapPosToBlock(t.displayValue.length), a = i.stop;
+        let r;
+        if (a != null && // if block not found or stop is behind lastBlock
+        (!u || u.index <= a)) {
+          if (i instanceof C || // for continuous block also check if stop is exist
+          t._stops.indexOf(a) >= 0) {
+            const l = t._appendPlaceholder(a);
+            e.aggregate(l);
+          }
+          r = i instanceof C && t._blocks[a];
+        }
+        if (r) {
+          const l = r.appendTail(i);
+          l.skip = !1, e.aggregate(l), t._value += l.inserted;
+          const d = i.toString().slice(l.rawInserted.length);
+          d && e.aggregate(t.append(d, {
+            tail: !0
+          }));
+        } else
+          e.aggregate(t.append(i.toString(), {
+            tail: !0
+          }));
+      }
+      return e;
+    }
+    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 i = this.chunks[s], u = i.unshift(e);
+        if (i.toString()) {
+          if (!u)
+            break;
+          ++s;
+        } else
+          this.chunks.splice(s, 1);
+        if (u)
+          return u;
+      }
+      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 X {
+    constructor(t, e) {
+      this.masked = t, this._log = [];
+      const {
+        offset: s,
+        index: i
+      } = t._mapPosToBlock(e) || (e < 0 ? (
+        // first
+        {
+          index: 0,
+          offset: 0
+        }
+      ) : (
+        // last
+        {
+          index: this.masked._blocks.length,
+          offset: 0
+        }
+      ));
+      this.offset = s, this.index = i, this.ok = !1;
+    }
+    get block() {
+      return this.masked._blocks[this.index];
+    }
+    get pos() {
+      return this.masked._blockStartPos(this.index) + this.offset;
+    }
+    get state() {
+      return {
+        index: this.index,
+        offset: this.offset,
+        ok: this.ok
+      };
+    }
+    set state(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, h.FORCE_LEFT), this.offset !== 0))
+          return !0;
+      });
+    }
+    pushLeftBeforeInput() {
+      return this._pushLeft(() => {
+        if (!this.block.isFixed)
+          return this.offset = this.block.nearestInputPos(this.offset, h.LEFT), !0;
+      });
+    }
+    pushLeftBeforeRequired() {
+      return this._pushLeft(() => {
+        if (!(this.block.isFixed || this.block.isOptional && !this.block.value))
+          return this.offset = this.block.nearestInputPos(this.offset, h.LEFT), !0;
+      });
+    }
+    pushRightBeforeFilled() {
+      return this._pushRight(() => {
+        if (!(this.block.isFixed || !this.block.value) && (this.offset = this.block.nearestInputPos(this.offset, h.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, h.NONE), !0;
+      });
+    }
+    pushRightBeforeRequired() {
+      return this._pushRight(() => {
+        if (!(this.block.isFixed || this.block.isOptional && !this.block.value))
+          return this.offset = this.block.nearestInputPos(this.offset, h.NONE), !0;
+      });
+    }
+  }
+  class R {
+    /** */
+    /** */
+    /** */
+    /** */
+    /** */
+    /** */
+    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;
+    }
+    get isComplete() {
+      return !0;
+    }
+    get isFilled() {
+      return !!this._value;
+    }
+    get state() {
+      return {
+        _value: this._value,
+        _rawInputValue: this.rawInputValue
+      };
+    }
+    set state(t) {
+      this._value = t._value, this._isRawInput = !!t._rawInputValue;
+    }
+    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 c();
+    }
+    nearestInputPos(t, e) {
+      e === void 0 && (e = h.NONE);
+      const s = 0, i = this._value.length;
+      switch (e) {
+        case h.LEFT:
+        case h.FORCE_LEFT:
+          return s;
+        case h.NONE:
+        case h.RIGHT:
+        case h.FORCE_RIGHT:
+        default:
+          return i;
+      }
+    }
+    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) || "";
+    }
+    _appendChar(t, e) {
+      e === void 0 && (e = {});
+      const s = new c();
+      if (this.isFilled)
+        return s;
+      const i = this.eager === !0 || this.eager === "append", a = this.char === t && (this.isUnmasking || e.input || e.raw) && (!e.raw || !i) && !e.tail;
+      return a && (s.rawInserted = this.char), this._value = s.inserted = this.char, this._isRawInput = a && (e.raw || e.input), s;
+    }
+    _appendEager() {
+      return this._appendChar(this.char, {
+        tail: !0
+      });
+    }
+    _appendPlaceholder() {
+      const t = new c();
+      return this.isFilled || (this._value = t.inserted = this.char), t;
+    }
+    extractTail() {
+      return new E("");
+    }
+    appendTail(t) {
+      return m(t) && (t = new E(String(t))), t.appendTo(this);
+    }
+    append(t, e, s) {
+      const i = this._appendChar(t[0], e);
+      return s != null && (i.tailShift += this.appendTail(s).tailShift), i;
+    }
+    doCommit() {
+    }
+  }
+  class M {
+    /** */
+    /** */
+    /** */
+    /** */
+    /** */
+    /** */
+    /** */
+    /** */
+    constructor(t) {
+      const {
+        parent: e,
+        isOptional: s,
+        placeholderChar: i,
+        displayChar: u,
+        lazy: a,
+        eager: r,
+        ...l
+      } = t;
+      this.masked = A(l), Object.assign(this, {
+        parent: e,
+        isOptional: s,
+        placeholderChar: i,
+        displayChar: u,
+        lazy: a,
+        eager: r
+      });
+    }
+    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;
+    }
+    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;
+    }
+    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 c();
+    }
+    _appendChar(t, e) {
+      if (e === void 0 && (e = {}), this.isFilled)
+        return new c();
+      const s = this.masked.state, i = this.masked._appendChar(t, this.currentMaskFlags(e));
+      return i.inserted && this.doValidate(e) === !1 && (i.inserted = i.rawInserted = "", this.masked.state = s), !i.inserted && !this.isOptional && !this.lazy && !e.input && (i.inserted = this.placeholderChar), i.skip = !i.inserted && !this.isOptional, this.isFilled = !!i.inserted, i;
+    }
+    append(t, e, s) {
+      return this.masked.append(t, this.currentMaskFlags(e), s);
+    }
+    _appendPlaceholder() {
+      const t = new c();
+      return this.isFilled || this.isOptional || (this.isFilled = !0, t.inserted = this.placeholderChar), t;
+    }
+    _appendEager() {
+      return new c();
+    }
+    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 = h.NONE);
+      const s = 0, i = this.value.length, u = Math.min(Math.max(t, s), i);
+      switch (e) {
+        case h.LEFT:
+        case h.FORCE_LEFT:
+          return this.isComplete ? u : s;
+        case h.RIGHT:
+        case h.FORCE_RIGHT:
+          return this.isComplete ? u : i;
+        case h.NONE:
+        default:
+          return u;
+      }
+    }
+    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();
+    }
+    currentMaskFlags(t) {
+      var e;
+      return {
+        ...t,
+        _beforeTailState: (t == null || (e = t._beforeTailState) == null ? void 0 : e.masked) || (t == null ? void 0 : t._beforeTailState)
+      };
+    }
+  }
+  M.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 q extends f {
+    /** */
+    /** 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);
+    }
+  }
+  o.MaskedRegExp = q;
+  class k extends f {
+    /** */
+    /** */
+    /** Single char for empty input */
+    /** Single char for filled input */
+    /** Show placeholder only when needed */
+    /** Enable characters overwriting */
+    /** */
+    /** */
+    constructor(t) {
+      super({
+        ...k.DEFAULTS,
+        ...t,
+        definitions: Object.assign({}, M.DEFAULT_DEFINITIONS, t == null ? void 0 : t.definitions)
+      });
+    }
+    get state() {
+      return {
+        ...super.state,
+        _blocks: this._blocks.map((t) => t.state)
+      };
+    }
+    set state(t) {
+      const {
+        _blocks: e,
+        ...s
+      } = t;
+      this._blocks.forEach((i, u) => i.state = e[u]), super.state = s;
+    }
+    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);
+    }
+    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, "");
+    }
+    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, i = !1;
+      for (let u = 0; u < e.length; ++u) {
+        if (this.blocks) {
+          const d = e.slice(u), v = Object.keys(this.blocks).filter((S) => d.indexOf(S) === 0);
+          v.sort((S, L) => L.length - S.length);
+          const _ = v[0];
+          if (_) {
+            const {
+              expose: S,
+              ...L
+            } = x(this.blocks[_]), N = A({
+              lazy: this.lazy,
+              eager: this.eager,
+              placeholderChar: this.placeholderChar,
+              displayChar: this.displayChar,
+              overwrite: this.overwrite,
+              ...L,
+              parent: this
+            });
+            N && (this._blocks.push(N), S && (this.exposeBlock = N), this._maskedBlocks[_] || (this._maskedBlocks[_] = []), this._maskedBlocks[_].push(this._blocks.length - 1)), u += _.length - 1;
+            continue;
+          }
+        }
+        let a = e[u], r = a in t;
+        if (a === k.STOP_CHAR) {
+          this._stops.push(this._blocks.length);
+          continue;
+        }
+        if (a === "{" || a === "}") {
+          s = !s;
+          continue;
+        }
+        if (a === "[" || a === "]") {
+          i = !i;
+          continue;
+        }
+        if (a === k.ESCAPE_CHAR) {
+          if (++u, a = e[u], !a)
+            break;
+          r = !1;
+        }
+        const l = r ? new M({
+          isOptional: i,
+          lazy: this.lazy,
+          eager: this.eager,
+          placeholderChar: this.placeholderChar,
+          displayChar: this.displayChar,
+          ...x(t[a]),
+          parent: this
+        }) : new R({
+          char: a,
+          eager: this.eager,
+          isUnmasking: s
+        });
+        this._blocks.push(l);
+      }
+    }
+    reset() {
+      super.reset(), this._blocks.forEach((t) => t.reset());
+    }
+    doCommit() {
+      this._blocks.forEach((t) => t.doCommit()), super.doCommit();
+    }
+    appendTail(t) {
+      return super.appendTail(t).aggregate(this._appendPlaceholder());
+    }
+    _appendEager() {
+      var t;
+      const e = new c();
+      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 i = s; i < this._blocks.length; ++i) {
+        const u = this._blocks[i]._appendEager();
+        if (!u.inserted)
+          break;
+        e.aggregate(u);
+      }
+      return e;
+    }
+    _appendCharRaw(t, e) {
+      e === void 0 && (e = {});
+      const s = this._mapPosToBlock(this.displayValue.length), i = new c();
+      if (!s)
+        return i;
+      for (let a = s.index; ; ++a) {
+        var u;
+        const r = this._blocks[a];
+        if (!r)
+          break;
+        const l = r._appendChar(t, {
+          ...e,
+          _beforeTailState: (u = e._beforeTailState) == null || (u = u._blocks) == null ? void 0 : u[a]
+        }), d = l.skip;
+        if (i.aggregate(l), d || l.rawInserted)
+          break;
+      }
+      return i;
+    }
+    extractTail(t, e) {
+      t === void 0 && (t = 0), e === void 0 && (e = this.displayValue.length);
+      const s = new C();
+      return t === e || this._forEachBlocksInRange(t, e, (i, u, a, r) => {
+        const l = i.extractTail(a, r);
+        l.stop = this._findStopBefore(u), l.from = this._blockStartPos(u), l instanceof C && (l.blockIndex = u), 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 i = "";
+      return this._forEachBlocksInRange(t, e, (u, a, r, l) => {
+        i += u.extractInput(r, l, s);
+      }), i;
+    }
+    _findStopBefore(t) {
+      let e;
+      for (let s = 0; s < this._stops.length; ++s) {
+        const i = this._stops[s];
+        if (i <= t)
+          e = i;
+        else
+          break;
+      }
+      return e;
+    }
+    /** Appends placeholder depending on laziness */
+    _appendPlaceholder(t) {
+      const e = new c();
+      if (this.lazy && t == null)
+        return e;
+      const s = this._mapPosToBlock(this.displayValue.length);
+      if (!s)
+        return e;
+      const i = s.index, u = t ?? this._blocks.length;
+      return this._blocks.slice(i, u).forEach((a) => {
+        if (!a.lazy || t != null) {
+          var r;
+          const l = a._appendPlaceholder((r = a._blocks) == null ? void 0 : r.length);
+          this._value += l.inserted, e.aggregate(l);
+        }
+      }), e;
+    }
+    /** Finds block in pos */
+    _mapPosToBlock(t) {
+      let e = "";
+      for (let s = 0; s < this._blocks.length; ++s) {
+        const i = this._blocks[s], u = e.length;
+        if (e += i.displayValue, t <= e.length)
+          return {
+            index: s,
+            offset: t - u
+          };
+      }
+    }
+    _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 i = this._mapPosToBlock(t);
+      if (i) {
+        const u = this._mapPosToBlock(e), a = u && i.index === u.index, r = i.offset, l = u && a ? u.offset : this._blocks[i.index].displayValue.length;
+        if (s(this._blocks[i.index], i.index, r, l), u && !a) {
+          for (let d = i.index + 1; d < u.index; ++d)
+            s(this._blocks[d], d, 0, this._blocks[d].displayValue.length);
+          s(this._blocks[u.index], u.index, 0, u.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, (i, u, a, r) => {
+        s.aggregate(i.remove(a, r));
+      }), s;
+    }
+    nearestInputPos(t, e) {
+      if (e === void 0 && (e = h.NONE), !this._blocks.length)
+        return 0;
+      const s = new X(this, t);
+      if (e === h.NONE)
+        return s.pushRightBeforeInput() || (s.popState(), s.pushLeftBeforeInput()) ? s.pos : this.displayValue.length;
+      if (e === h.LEFT || e === h.FORCE_LEFT) {
+        if (e === h.LEFT) {
+          if (s.pushRightBeforeFilled(), s.ok && s.pos === t)
+            return t;
+          s.popState();
+        }
+        if (s.pushLeftBeforeInput(), s.pushLeftBeforeRequired(), s.pushLeftBeforeFilled(), e === h.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 === h.FORCE_LEFT ? 0 : (s.popState(), s.ok || (s.popState(), s.ok) ? s.pos : 0);
+      }
+      return e === h.RIGHT || e === h.FORCE_RIGHT ? (s.pushRightBeforeInput(), s.pushRightBeforeRequired(), s.pushRightBeforeFilled() ? s.pos : e === h.FORCE_RIGHT ? this.displayValue.length : (s.popState(), s.ok || (s.popState(), s.ok) ? s.pos : this.nearestInputPos(t, h.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, (i, u, a, r) => {
+        s += i.totalInputPositions(a, r);
+      }), 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]) : [];
+    }
+  }
+  k.DEFAULTS = {
+    lazy: !0,
+    placeholderChar: "_"
+  }, k.STOP_CHAR = "`", k.ESCAPE_CHAR = "\\", k.InputDefinition = M, k.FixedDefinition = R, o.MaskedPattern = k;
+  class V extends k {
+    /**
+     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 */
+    constructor(t) {
+      super(t);
+    }
+    /** */
+    get _matchFrom() {
+      return this.maxLength - String(this.from).length;
+    }
+    get isComplete() {
+      return super.isComplete && !!this.value;
+    }
+    updateOptions(t) {
+      super.updateOptions(t);
+    }
+    _update(t) {
+      const {
+        to: e = this.to || 0,
+        from: s = this.from || 0,
+        maxLength: i = this.maxLength || 0,
+        autofix: u = this.autofix,
+        ...a
+      } = t;
+      this.to = e, this.from = s, this.maxLength = Math.max(String(e).length, i), this.autofix = u;
+      const r = String(this.from).padStart(this.maxLength, "0"), l = String(this.to).padStart(this.maxLength, "0");
+      let d = 0;
+      for (; d < l.length && l[d] === r[d]; )
+        ++d;
+      a.mask = l.slice(0, d).replace(/0/g, "\\0") + "0".repeat(this.maxLength - d), super._update(a);
+    }
+    boundaries(t) {
+      let e = "", s = "";
+      const [, i, u] = t.match(/^(\D*)(\d*)(\D*)/) || [];
+      return u && (e = "0".repeat(i.length) + u, s = "9".repeat(i.length) + u), e = e.padEnd(this.maxLength, "0"), s = s.padEnd(this.maxLength, "9"), [e, s];
+    }
+    doPrepareChar(t, e) {
+      e === void 0 && (e = {});
+      let s;
+      if ([t, s] = super.doPrepareChar(t.replace(/\D/g, ""), e), !this.autofix || !t)
+        return [t, s];
+      const i = String(this.from).padStart(this.maxLength, "0"), u = String(this.to).padStart(this.maxLength, "0"), a = this.value + t;
+      if (a.length > this.maxLength)
+        return ["", s];
+      const [r, l] = this.boundaries(a);
+      return Number(l) < this.from ? [i[a.length - 1], s] : Number(r) > this.to ? this.autofix === "pad" && a.length < this.maxLength ? ["", s.aggregate(this.append(i[a.length - 1] + t, e))] : [u[a.length - 1], s] : [t, s];
+    }
+    doValidate(t) {
+      const e = this.value;
+      if (e.search(/[^0]/) === -1 && e.length <= this._matchFrom)
+        return !0;
+      const [i, u] = this.boundaries(e);
+      return this.from <= Number(u) && Number(i) <= this.to && super.doValidate(t);
+    }
+  }
+  o.MaskedRange = V;
+  class B extends k {
+    /** 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) {
+      const {
+        mask: e,
+        pattern: s,
+        ...i
+      } = {
+        ...B.DEFAULTS,
+        ...t
+      };
+      super({
+        ...i,
+        mask: m(e) ? e : s
+      });
+    }
+    /** 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;
+    }
+    updateOptions(t) {
+      super.updateOptions(t);
+    }
+    _update(t) {
+      const {
+        mask: e,
+        pattern: s,
+        blocks: i,
+        ...u
+      } = {
+        ...B.DEFAULTS,
+        ...t
+      }, a = Object.assign({}, B.GET_DEFAULT_BLOCKS());
+      t.min && (a.Y.from = t.min.getFullYear()), t.max && (a.Y.to = t.max.getFullYear()), t.min && t.max && a.Y.from === a.Y.to && (a.m.from = t.min.getMonth() + 1, a.m.to = t.max.getMonth() + 1, a.m.from === a.m.to && (a.d.from = t.min.getDate(), a.d.to = t.max.getDate())), Object.assign(a, this.blocks, i), Object.keys(a).forEach((r) => {
+        const l = a[r];
+        !("autofix" in l) && "autofix" in t && (l.autofix = t.autofix);
+      }), super._update({
+        ...u,
+        mask: m(e) ? e : s,
+        blocks: a
+      });
+    }
+    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;
+    }
+    maskEquals(t) {
+      return t === Date || super.maskEquals(t);
+    }
+  }
+  B.GET_DEFAULT_BLOCKS = () => ({
+    d: {
+      mask: V,
+      from: 1,
+      to: 31,
+      maxLength: 2
+    },
+    m: {
+      mask: V,
+      from: 1,
+      to: 12,
+      maxLength: 2
+    },
+    Y: {
+      mask: V,
+      from: 1900,
+      to: 9999
+    }
+  }), B.DEFAULTS = {
+    mask: Date,
+    pattern: "d{.}`m{.}`Y",
+    format: (n, t) => {
+      if (!n)
+        return "";
+      const e = String(n.getDate()).padStart(2, "0"), s = String(n.getMonth() + 1).padStart(2, "0"), i = n.getFullYear();
+      return [e, s, i].join(".");
+    },
+    parse: (n, t) => {
+      const [e, s, i] = n.split(".").map(Number);
+      return new Date(i, s - 1, e);
+    }
+  }, o.MaskedDate = B;
+  class D extends f {
+    /** Currently chosen mask */
+    /** Currently chosen mask */
+    /** Compliled {@link Masked} options */
+    /** Chooses {@link Masked} depending on input value */
+    constructor(t) {
+      super({
+        ...D.DEFAULTS,
+        ...t
+      }), this.currentMask = void 0;
+    }
+    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);
+    }
+    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: i,
+        ...u
+      } = t;
+      e && this.compiledMasks.forEach((a, r) => a.state = e[r]), s != null && (this.currentMask = s, this.currentMask.state = i), super.state = u;
+    }
+    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;
+    }
+    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,
+          ...i
+        } = x(e), u = A({
+          overwrite: this._overwrite,
+          eager: this._eager,
+          skipInvalid: this._skipInvalid,
+          ...i
+        });
+        return s && (this.exposeMask = u), u;
+      }) : []);
+    }
+    _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 i = e.tail && e._beforeTailState != null ? e._beforeTailState._value : this.value, u = this.rawInputValue, a = e.tail && e._beforeTailState != null ? e._beforeTailState._rawInputValue : u, r = u.slice(a.length), l = this.currentMask, d = new c(), v = l == null ? void 0 : l.state;
+      if (this.currentMask = this.doDispatch(t, {
+        ...e
+      }, s), this.currentMask)
+        if (this.currentMask !== l) {
+          if (this.currentMask.reset(), a) {
+            const _ = this.currentMask.append(a, {
+              raw: !0
+            });
+            d.tailShift = _.inserted.length - i.length;
+          }
+          r && (d.tailShift += this.currentMask.append(r, {
+            raw: !0,
+            tail: !0
+          }).tailShift);
+        } else
+          v && (this.currentMask.state = v);
+      return d;
+    }
+    _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 c();
+      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, i] = super.doPrepare(t, e);
+      if (this.currentMask) {
+        let u;
+        [s, u] = super.doPrepare(s, this.currentMaskFlags(e)), i = i.aggregate(u);
+      }
+      return [s, i];
+    }
+    doPrepareChar(t, e) {
+      e === void 0 && (e = {});
+      let [s, i] = super.doPrepareChar(t, e);
+      if (this.currentMask) {
+        let u;
+        [s, u] = super.doPrepareChar(s, this.currentMaskFlags(e)), i = i.aggregate(u);
+      }
+      return [s, i];
+    }
+    reset() {
+      var t;
+      (t = this.currentMask) == null || t.reset(), this.compiledMasks.forEach((e) => e.reset());
+    }
+    remove(t, e) {
+      const s = new c();
+      return this.currentMask && s.aggregate(this.currentMask.remove(t, e)).aggregate(this._applyDispatch()), s;
+    }
+    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);
+    }
+    maskEquals(t) {
+      return Array.isArray(t) ? this.compiledMasks.every((e, s) => {
+        if (!t[s])
+          return;
+        const {
+          mask: i,
+          ...u
+        } = t[s];
+        return b(e, u) && e.maskEquals(i);
+      }) : super.maskEquals(t);
+    }
+    typedValueEquals(t) {
+      var e;
+      return !!((e = this.currentMask) != null && e.typedValueEquals(t));
+    }
+  }
+  D.DEFAULTS = void 0, D.DEFAULTS = {
+    dispatch: (n, t, e, s) => {
+      if (!t.compiledMasks.length)
+        return;
+      const i = t.rawInputValue, u = t.compiledMasks.map((a, r) => {
+        const l = t.currentMask === a, d = l ? a.displayValue.length : a.nearestInputPos(a.displayValue.length, h.FORCE_LEFT);
+        return a.rawInputValue !== i ? (a.reset(), a.append(i, {
+          raw: !0
+        })) : l || a.remove(d), a.append(n, t.currentMaskFlags(e)), a.appendTail(s), {
+          index: r,
+          weight: a.rawInputValue.length,
+          totalInputPositions: a.totalInputPositions(0, Math.max(d, a.nearestInputPos(a.displayValue.length, h.FORCE_LEFT)))
+        };
+      });
+      return u.sort((a, r) => r.weight - a.weight || r.totalInputPositions - a.totalInputPositions), t.compiledMasks[u[0].index];
+    }
+  }, o.MaskedDynamic = D;
+  class Y extends k {
+    constructor(t) {
+      super(t);
+    }
+    updateOptions(t) {
+      super.updateOptions(t);
+    }
+    _update(t) {
+      const {
+        enum: e,
+        ...s
+      } = t;
+      if (e) {
+        const i = e.map((r) => r.length), u = Math.min(...i), a = Math.max(...i) - u;
+        s.mask = "*".repeat(u), a && (s.mask += "[" + "*".repeat(a) + "]"), this.enum = e;
+      }
+      super._update(s);
+    }
+    doValidate(t) {
+      return this.enum.some((e) => e.indexOf(this.unmaskedValue) === 0) && super.doValidate(t);
+    }
+  }
+  o.MaskedEnum = Y;
+  class $ extends f {
+    /** */
+    /** Enable characters overwriting */
+    /** */
+    /** */
+    updateOptions(t) {
+      super.updateOptions(t);
+    }
+    _update(t) {
+      super._update({
+        ...t,
+        validate: t.mask
+      });
+    }
+  }
+  o.MaskedFunction = $;
+  class g extends f {
+    /** 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({
+        ...g.DEFAULTS,
+        ...t
+      });
+    }
+    get unmaskedValue() {
+      return this._removeThousandsSeparators(this._normalizeZeros(this.value)).replace(this.radix, g.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(g.UNMASKED_RADIX, this.radix);
+    }
+    /** Parsed Number */
+    get number() {
+      return this.typedValue;
+    }
+    set number(t) {
+      this.typedValue = t;
+    }
+    /**
+     Is negative allowed
+     */
+    get allowNegative() {
+      return this.min != null && this.min < 0 || this.max != null && this.max < 0;
+    }
+    /**
+     Is positive allowed
+     */
+    get allowPositive() {
+      return this.min != null && this.min > 0 || this.max != null && this.max > 0;
+    }
+    updateOptions(t) {
+      super.updateOptions(t);
+    }
+    _update(t) {
+      super._update(t), this._updateRegExps();
+    }
+    _updateRegExps() {
+      const t = "^" + (this.allowNegative ? "[+|\\-]?" : ""), e = "\\d*", s = (this.scale ? "(" + y(this.radix) + "\\d{0," + this.scale + "})?" : "") + "$";
+      this._numberRegExp = new RegExp(t + e + s), this._mapToRadixRegExp = new RegExp("[" + this.mapToRadix.map(y).join("") + "]", "g"), this._thousandsSeparatorRegExp = new RegExp(y(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, i] = super.doPrepareChar(this._removeThousandsSeparators(this.scale && this.mapToRadix.length && /*
+        radix should be mapped when
+        1) input is done from keyboard = flags.input && flags.raw
+        2) unmasked value is set = !flags.input && !flags.raw
+        and should not be mapped when
+        1) value is set = flags.input && !flags.raw
+        2) raw value is set = !flags.input && flags.raw
+      */
+      (e.input && e.raw || !e.input && !e.raw) ? t.replace(this._mapToRadixRegExp, this.radix) : t), e);
+      return t && !s && (i.skip = !0), s && !this.allowPositive && !this.value && s !== "-" && i.aggregate(this._appendChar("-")), [s, i];
+    }
+    _separatorsCount(t, e) {
+      e === void 0 && (e = !1);
+      let s = 0;
+      for (let i = 0; i < t; ++i)
+        this._value.indexOf(this.thousandsSeparator, i) === i && (++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) {
+      if (e === void 0 && (e = {}), !this.thousandsSeparator)
+        return super._appendCharRaw(t, e);
+      const s = e.tail && e._beforeTailState ? e._beforeTailState._value : this._value, i = this._separatorsCountFromSlice(s);
+      this._value = this._removeThousandsSeparators(this.value);
+      const u = super._appendCharRaw(t, e);
+      this._value = this._insertThousandsSeparators(this._value);
+      const a = e.tail && e._beforeTailState ? e._beforeTailState._value : this._value, r = this._separatorsCountFromSlice(a);
+      return u.tailShift += (r - i) * this.thousandsSeparator.length, u.skip = !u.rawInserted && t === this.thousandsSeparator, u;
+    }
+    _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 i = this._findSeparatorAround(e);
+      return i >= 0 && (e = i + 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), i = this.value.slice(e), u = this._separatorsCount(s.length);
+      this._value = this._insertThousandsSeparators(this._removeThousandsSeparators(s + i));
+      const a = this._separatorsCountFromSlice(s);
+      return new c({
+        tailShift: (a - u) * this.thousandsSeparator.length
+      });
+    }
+    nearestInputPos(t, e) {
+      if (!this.thousandsSeparator)
+        return t;
+      switch (e) {
+        case h.NONE:
+        case h.LEFT:
+        case h.FORCE_LEFT: {
+          const s = this._findSeparatorAround(t - 1);
+          if (s >= 0) {
+            const i = s + this.thousandsSeparator.length;
+            if (t < i || this.value.length <= i || e === h.FORCE_LEFT)
+              return s;
+          }
+          break;
+        }
+        case h.RIGHT:
+        case h.FORCE_RIGHT: {
+          const s = this._findSeparatorAround(t);
+          if (s >= 0)
+            return s + this.thousandsSeparator.length;
+        }
+      }
+      return t;
+    }
+    doValidate(t) {
+      let e = !!this._removeThousandsSeparators(this.value).match(this._numberRegExp);
+      if (e) {
+        const s = this.number;
+        e = e && !isNaN(s) && // check min bound for negative values
+        (this.min == null || this.min >= 0 || this.min <= this.number) && // check max bound for positive values
+        (this.max == null || this.max <= 0 || this.number <= this.max);
+      }
+      return e && super.doValidate(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, i, u, a) => i + a), 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 i = this.scale === 0 && t !== this.thousandsSeparator && (t === this.radix || t === g.UNMASKED_RADIX || this.mapToRadix.includes(t));
+      return super.doSkipInvalid(t, e, s) && !i;
+    }
+    typedValueEquals(t) {
+      return (super.typedValueEquals(t) || g.EMPTY_VALUES.includes(t) && g.EMPTY_VALUES.includes(this.typedValue)) && !(t === 0 && this.value === "");
+    }
+  }
+  g.UNMASKED_RADIX = ".", g.EMPTY_VALUES = [...f.EMPTY_VALUES, 0], g.DEFAULTS = {
+    mask: Number,
+    radix: ",",
+    thousandsSeparator: "",
+    mapToRadix: [g.UNMASKED_RADIX],
+    min: Number.MIN_SAFE_INTEGER,
+    max: Number.MAX_SAFE_INTEGER,
+    scale: 2,
+    normalizeZeros: !0,
+    padFractionalZeros: !1,
+    parse: Number,
+    format: (n) => n.toLocaleString("en-US", {
+      useGrouping: !1,
+      maximumFractionDigits: 20
+    })
+  }, o.MaskedNumber = g;
+  const T = {
+    MASKED: "value",
+    UNMASKED: "unmaskedValue",
+    TYPED: "typedValue"
+  };
+  function O(n, t, e) {
+    t === void 0 && (t = T.MASKED), e === void 0 && (e = T.MASKED);
+    const s = A(n);
+    return (i) => s.runIsolated((u) => (u[t] = i, u[e]));
+  }
+  function K(n, t, e, s) {
+    return O(t, e, s)(n);
+  }
+  o.PIPE_TYPE = T, o.createPipe = O, o.pipe = K;
+  try {
+    globalThis.IMask = o;
+  } catch {
+  }
+  p.ChangeDetails = c, p.ChunksTailDetails = C, p.DIRECTION = h, p.HTMLContenteditableMaskElement = w, p.HTMLInputMaskElement = z, p.HTMLMaskElement = F, p.InputMask = G, p.MaskElement = I, p.Masked = f, p.MaskedDate = B, p.MaskedDynamic = D, p.MaskedEnum = Y, p.MaskedFunction = $, p.MaskedNumber = g, p.MaskedPattern = k, p.MaskedRange = V, p.MaskedRegExp = q, p.PIPE_TYPE = T, p.PatternFixedDefinition = R, p.PatternInputDefinition = M, p.createMask = A, p.createPipe = O, p.default = o, p.forceDirection = j, p.normalizeOpts = x, p.pipe = K, Object.defineProperty(p, "__esModule", { value: !0 });
+});
+const W = IMask;
 export {
-  C as default
+  W as default
 };
 //# sourceMappingURL=design-system104.mjs.map