@7pmlabs/design-system 0.2.7 → 0.2.8

package/dist/design-system93.mjs

@@ -1,70 +1,2455 @@
-import { defineComponent as k, ref as C, computed as d, onMounted as h, onBeforeUnmount as B, openBlock as E, createBlock as x, withCtx as y, createElementVNode as a, normalizeClass as c, renderSlot as L } from "vue";
-import { BModalSize as t } from "./design-system5.mjs";
-import _ from "./design-system34.mjs";
-const W = /* @__PURE__ */ k({
-  __name: "BModalContainer",
-  props: {
-    size: { default: t.Medium },
-    fullscreen: { type: Boolean, default: !1 },
-    persistent: { type: Boolean, default: !1 }
-  },
-  emits: ["close"],
-  setup(i, { emit: n }) {
-    const s = i, o = C(null), u = d(() => {
-      let e = "ds-relative ds-w-full ds-h-auto ds-m-auto ds-flex ds-items-center ";
-      if (s.fullscreen)
-        e += "ds-w-screen ds-h-screen ";
-      else
-        switch (e += "ds-p-4 ", s.size) {
-          case t.Small:
-            e += "ds-max-w-md ";
+(function(g, k) {
+  typeof exports == "object" && typeof module < "u" ? k(exports) : typeof define == "function" && define.amd ? define(["exports"], k) : (g = typeof globalThis < "u" ? globalThis : g || self, k(g.IMask = {}));
+})(globalThis, function(g) {
+  function k(a, t) {
+    if (a == null)
+      return {};
+    var e = {}, s = Object.keys(a), n, u;
+    for (u = 0; u < s.length; u++)
+      n = s[u], !(t.indexOf(n) >= 0) && (e[n] = a[n]);
+    return e;
+  }
+  function h(a) {
+    let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    return new h.InputMask(a, t);
+  }
+  class c {
+    /** Inserted symbols */
+    /** Can skip chars */
+    /** Additional offset if any changes occurred before tail */
+    /** Raw inserted is used by dynamic mask */
+    constructor(t) {
+      Object.assign(
+        this,
+        {
+          inserted: "",
+          rawInserted: "",
+          skip: !1,
+          tailShift: 0
+        },
+        t
+      );
+    }
+    /**
+      Aggregate changes
+      @returns {ChangeDetails} `this`
+    */
+    aggregate(t) {
+      return this.rawInserted += t.rawInserted, this.skip = this.skip || t.skip, this.inserted += t.inserted, this.tailShift += t.tailShift, this;
+    }
+    /** Total offset considering all changes */
+    get offset() {
+      return this.tailShift + this.inserted.length;
+    }
+  }
+  h.ChangeDetails = c;
+  function B(a) {
+    return typeof a == "string" || a instanceof String;
+  }
+  const o = {
+    NONE: "NONE",
+    LEFT: "LEFT",
+    FORCE_LEFT: "FORCE_LEFT",
+    RIGHT: "RIGHT",
+    FORCE_RIGHT: "FORCE_RIGHT"
+  };
+  function $(a) {
+    switch (a) {
+      case o.LEFT:
+        return o.FORCE_LEFT;
+      case o.RIGHT:
+        return o.FORCE_RIGHT;
+      default:
+        return a;
+    }
+  }
+  function R(a) {
+    return a.replace(/([.*+?^=!:${}()|[\]\/\\])/g, "\\$1");
+  }
+  function M(a) {
+    return Array.isArray(a) ? a : [a, new c()];
+  }
+  function I(a, t) {
+    if (t === a)
+      return !0;
+    var e = Array.isArray(t), s = Array.isArray(a), n;
+    if (e && s) {
+      if (t.length != a.length)
+        return !1;
+      for (n = 0; n < t.length; n++)
+        if (!I(t[n], a[n]))
+          return !1;
+      return !0;
+    }
+    if (e != s)
+      return !1;
+    if (t && a && typeof t == "object" && typeof a == "object") {
+      var u = t instanceof Date, i = a instanceof Date;
+      if (u && i)
+        return t.getTime() == a.getTime();
+      if (u != i)
+        return !1;
+      var r = t instanceof RegExp, l = a instanceof RegExp;
+      if (r && l)
+        return t.toString() == a.toString();
+      if (r != l)
+        return !1;
+      var d = Object.keys(t);
+      for (n = 0; n < d.length; n++)
+        if (!Object.prototype.hasOwnProperty.call(a, d[n]))
+          return !1;
+      for (n = 0; n < d.length; n++)
+        if (!I(a[d[n]], t[d[n]]))
+          return !1;
+      return !0;
+    } else if (t && a && typeof t == "function" && typeof a == "function")
+      return t.toString() === a.toString();
+    return !1;
+  }
+  class K {
+    /** Current input value */
+    /** Current cursor position */
+    /** Old input value */
+    /** Old selection */
+    constructor(t, e, s, n) {
+      for (this.value = t, this.cursorPos = e, this.oldValue = s, this.oldSelection = n; this.value.slice(0, this.startChangePos) !== this.oldValue.slice(0, this.startChangePos); )
+        --this.oldSelection.start;
+    }
+    /**
+      Start changing position
+      @readonly
+    */
+    get startChangePos() {
+      return Math.min(this.cursorPos, this.oldSelection.start);
+    }
+    /**
+      Inserted symbols count
+      @readonly
+    */
+    get insertedCount() {
+      return this.cursorPos - this.startChangePos;
+    }
+    /**
+      Inserted symbols
+      @readonly
+    */
+    get inserted() {
+      return this.value.substr(this.startChangePos, this.insertedCount);
+    }
+    /**
+      Removed symbols count
+      @readonly
+    */
+    get removedCount() {
+      return Math.max(
+        this.oldSelection.end - this.startChangePos || // for Delete
+        this.oldValue.length - this.value.length,
+        0
+      );
+    }
+    /**
+      Removed symbols
+      @readonly
+    */
+    get removed() {
+      return this.oldValue.substr(this.startChangePos, this.removedCount);
+    }
+    /**
+      Unchanged head symbols
+      @readonly
+    */
+    get head() {
+      return this.value.substring(0, this.startChangePos);
+    }
+    /**
+      Unchanged tail symbols
+      @readonly
+    */
+    get tail() {
+      return this.value.substring(this.startChangePos + this.insertedCount);
+    }
+    /**
+      Remove direction
+      @readonly
+    */
+    get removeDirection() {
+      return !this.removedCount || this.insertedCount ? o.NONE : (this.oldSelection.end === this.cursorPos || this.oldSelection.start === this.cursorPos) && // if not range removed (event with backspace)
+      this.oldSelection.end === this.oldSelection.start ? o.RIGHT : o.LEFT;
+    }
+  }
+  class _ {
+    /** Tail value as string */
+    /** Tail start position */
+    /** Start position */
+    constructor() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "", e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0, s = arguments.length > 2 ? arguments[2] : void 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 {
+    // $Shape<MaskedOptions>; TODO after fix https://github.com/facebook/flow/issues/4773
+    /** @type {Mask} */
+    /** */
+    // $FlowFixMe no ideas
+    /** Transforms value before mask processing */
+    /** Validates if value is acceptable */
+    /** Does additional processing in the end of editing */
+    /** Format typed value to string */
+    /** Parse strgin to get typed value */
+    /** Enable characters overwriting */
+    /** */
+    /** */
+    /** */
+    constructor(t) {
+      this._value = "", this._update(Object.assign({}, p.DEFAULTS, t)), this.isInitialized = !0;
+    }
+    /** Sets and applies new options */
+    updateOptions(t) {
+      Object.keys(t).length && this.withValueRefresh(this._update.bind(this, t));
+    }
+    /**
+      Sets new options
+      @protected
+    */
+    _update(t) {
+      Object.assign(this, t);
+    }
+    /** Mask state */
+    get state() {
+      return {
+        _value: this.value
+      };
+    }
+    set state(t) {
+      this._value = t._value;
+    }
+    /** Resets value */
+    reset() {
+      this._value = "";
+    }
+    /** */
+    get value() {
+      return this._value;
+    }
+    set value(t) {
+      this.resolve(t);
+    }
+    /** Resolve new value */
+    resolve(t) {
+      return this.reset(), this.append(
+        t,
+        {
+          input: !0
+        },
+        ""
+      ), this.doCommit(), this.value;
+    }
+    /** */
+    get unmaskedValue() {
+      return this.value;
+    }
+    set unmaskedValue(t) {
+      this.reset(), this.append(t, {}, ""), this.doCommit();
+    }
+    /** */
+    get typedValue() {
+      return this.doParse(this.value);
+    }
+    set typedValue(t) {
+      this.value = this.doFormat(t);
+    }
+    /** Value that includes raw user input */
+    get rawInputValue() {
+      return this.extractInput(0, this.value.length, {
+        raw: !0
+      });
+    }
+    set rawInputValue(t) {
+      this.reset(), this.append(
+        t,
+        {
+          raw: !0
+        },
+        ""
+      ), this.doCommit();
+    }
+    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() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length;
+      return Math.min(this.value.length, e - t);
+    }
+    /** Extracts value in range considering flags */
+    extractInput() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length;
+      return this.value.slice(t, e);
+    }
+    /** Extracts tail in range */
+    extractTail() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length;
+      return new _(
+        this.extractInput(t, e),
+        t
+      );
+    }
+    /** Appends tail */
+    // $FlowFixMe no ideas
+    appendTail(t) {
+      return B(t) && (t = new _(String(t))), t.appendTo(this);
+    }
+    /** Appends char */
+    _appendCharRaw(t) {
+      return t ? (this._value += t, new c({
+        inserted: t,
+        rawInserted: t
+      })) : new c();
+    }
+    /** Appends char */
+    _appendChar(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, s = arguments.length > 2 ? arguments[2] : void 0;
+      const n = this.state;
+      let u;
+      if ([t, u] = M(this.doPrepare(t, e)), u = u.aggregate(this._appendCharRaw(t, e)), u.inserted) {
+        let i, r = this.doValidate(e) !== !1;
+        if (r && s != null) {
+          const l = this.state;
+          this.overwrite === !0 && (i = s.state, s.unshift(this.value.length - u.tailShift));
+          let d = this.appendTail(s);
+          r = d.rawInserted === s.toString(), !(r && d.inserted) && this.overwrite === "shift" && (this.state = l, i = 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 = n, s && i && (s.state = i));
+      }
+      return u;
+    }
+    /** Appends optional placeholder at end */
+    _appendPlaceholder() {
+      return new c();
+    }
+    /** Appends optional eager placeholder at end */
+    _appendEager() {
+      return new c();
+    }
+    /** Appends symbols considering flags */
+    // $FlowFixMe no ideas
+    append(t, e, s) {
+      if (!B(t))
+        throw new Error("value should be string");
+      const n = new c(), u = B(s) ? new _(String(s)) : s;
+      e != null && e.tail && (e._beforeTailState = this.state);
+      for (let i = 0; i < t.length; ++i) {
+        const r = this._appendChar(t[i], e, u);
+        if (!r.rawInserted && !this.doSkipInvalid(t[i], e, u))
+          break;
+        n.aggregate(r);
+      }
+      return u != null && (n.tailShift += this.appendTail(u).tailShift), (this.eager === !0 || this.eager === "append") && e !== null && e !== void 0 && e.input && t && n.aggregate(this._appendEager()), n;
+    }
+    /** */
+    remove() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length;
+      return this._value = this.value.slice(0, t) + this.value.slice(e), new c();
+    }
+    /** Calls function and reapplies current value */
+    withValueRefresh(t) {
+      if (this._refreshing || !this.isInitialized)
+        return t();
+      this._refreshing = !0;
+      const e = this.rawInputValue, s = this.value, n = t();
+      return this.rawInputValue = e, this.value && this.value !== s && s.indexOf(this.value) === 0 && this.append(s.slice(this.value.length), {}, ""), delete this._refreshing, n;
+    }
+    /** */
+    runIsolated(t) {
+      if (this._isolated || !this.isInitialized)
+        return t(this);
+      this._isolated = !0;
+      const e = this.state, s = t(this);
+      return this.state = e, delete this._isolated, s;
+    }
+    /** */
+    doSkipInvalid(t) {
+      return this.skipInvalid;
+    }
+    /**
+      Prepares string before mask processing
+      @protected
+    */
+    doPrepare(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      return this.prepare ? this.prepare(t, this, e) : t;
+    }
+    /**
+      Validates if value is acceptable
+      @protected
+    */
+    doValidate(t) {
+      return (!this.validate || this.validate(this.value, this, t)) && (!this.parent || this.parent.doValidate(t));
+    }
+    /**
+      Does additional processing in the end of editing
+      @protected
+    */
+    doCommit() {
+      this.commit && this.commit(this.value, this);
+    }
+    /** */
+    doFormat(t) {
+      return this.format ? this.format(t, this) : t;
+    }
+    /** */
+    doParse(t) {
+      return this.parse ? this.parse(t, this) : t;
+    }
+    /** */
+    splice(t, e, s, n) {
+      let u = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : {
+        input: !0
+      };
+      const i = t + e, r = this.extractTail(i), l = this.eager === !0 || this.eager === "remove";
+      let d;
+      l && (n = $(n), d = this.extractInput(0, i, {
+        raw: !0
+      }));
+      let E = t;
+      const A = new c();
+      if (n !== o.NONE && (E = this.nearestInputPos(
+        t,
+        e > 1 && t !== 0 && !l ? o.NONE : n
+      ), A.tailShift = E - t), A.aggregate(this.remove(E)), l && n !== o.NONE && d === this.rawInputValue)
+        if (n === o.FORCE_LEFT) {
+          let V;
+          for (; d === this.rawInputValue && (V = this.value.length); )
+            A.aggregate(
+              new c({
+                tailShift: -1
+              })
+            ).aggregate(this.remove(V - 1));
+        } else
+          n === o.FORCE_RIGHT && r.unshift();
+      return A.aggregate(this.append(s, u, r));
+    }
+    maskEquals(t) {
+      return this.mask === t;
+    }
+    typedValueEquals(t) {
+      const e = this.typedValue;
+      return t === e || p.EMPTY_VALUES.includes(t) && p.EMPTY_VALUES.includes(e) || this.doFormat(t) === this.doFormat(this.typedValue);
+    }
+  }
+  p.DEFAULTS = {
+    format: String,
+    parse: (a) => a,
+    skipInvalid: !0
+  }, p.EMPTY_VALUES = [void 0, null, ""], h.Masked = p;
+  function L(a) {
+    if (a == null)
+      throw new Error("mask property should be defined");
+    return a instanceof RegExp ? h.MaskedRegExp : B(a) ? h.MaskedPattern : a instanceof Date || a === Date ? h.MaskedDate : a instanceof Number || typeof a == "number" || a === Number ? h.MaskedNumber : Array.isArray(a) || a === Array ? h.MaskedDynamic : h.Masked && a.prototype instanceof h.Masked ? a : a instanceof h.Masked ? a.constructor : a instanceof Function ? h.MaskedFunction : (console.warn("Mask not found for mask", a), h.Masked);
+  }
+  function v(a) {
+    if (h.Masked && a instanceof h.Masked)
+      return a;
+    a = Object.assign({}, a);
+    const t = a.mask;
+    if (h.Masked && t instanceof h.Masked)
+      return t;
+    const e = L(t);
+    if (!e)
+      throw new Error(
+        "Masked class is not found for provided mask, appropriate module needs to be import manually before creating mask."
+      );
+    return new e(a);
+  }
+  h.createMask = v;
+  const Z = [
+    "parent",
+    "isOptional",
+    "placeholderChar",
+    "displayChar",
+    "lazy",
+    "eager"
+  ], X = {
+    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 N {
+    /** */
+    /** */
+    /** */
+    /** */
+    /** */
+    /** */
+    /** */
+    /** */
+    constructor(t) {
+      const { parent: e, isOptional: s, placeholderChar: n, displayChar: u, lazy: i, eager: r } = t, l = k(t, Z);
+      this.masked = v(l), Object.assign(this, {
+        parent: e,
+        isOptional: s,
+        placeholderChar: n,
+        displayChar: u,
+        lazy: i,
+        eager: r
+      });
+    }
+    reset() {
+      this.isFilled = !1, this.masked.reset();
+    }
+    remove() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length;
+      return t === 0 && e >= 1 ? (this.isFilled = !1, this.masked.remove(t, e)) : new c();
+    }
+    get value() {
+      return this.masked.value || (this.isFilled && !this.isOptional ? this.placeholderChar : "");
+    }
+    get unmaskedValue() {
+      return this.masked.unmaskedValue;
+    }
+    get displayValue() {
+      return this.masked.value && this.displayChar || this.value;
+    }
+    get isComplete() {
+      return !!this.masked.value || this.isOptional;
+    }
+    _appendChar(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      if (this.isFilled)
+        return new c();
+      const s = this.masked.state, n = this.masked._appendChar(t, e);
+      return n.inserted && this.doValidate(e) === !1 && (n.inserted = n.rawInserted = "", this.masked.state = s), !n.inserted && !this.isOptional && !this.lazy && !e.input && (n.inserted = this.placeholderChar), n.skip = !n.inserted && !this.isOptional, this.isFilled = !!n.inserted, n;
+    }
+    append() {
+      return this.masked.append(...arguments);
+    }
+    _appendPlaceholder() {
+      const t = new c();
+      return this.isFilled || this.isOptional || (this.isFilled = !0, t.inserted = this.placeholderChar), t;
+    }
+    _appendEager() {
+      return new c();
+    }
+    extractTail() {
+      return this.masked.extractTail(...arguments);
+    }
+    appendTail() {
+      return this.masked.appendTail(...arguments);
+    }
+    extractInput() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length, s = arguments.length > 2 ? arguments[2] : void 0;
+      return this.masked.extractInput(t, e, s);
+    }
+    nearestInputPos(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : o.NONE;
+      const s = 0, n = this.value.length, u = Math.min(Math.max(t, s), n);
+      switch (e) {
+        case o.LEFT:
+        case o.FORCE_LEFT:
+          return this.isComplete ? u : s;
+        case o.RIGHT:
+        case o.FORCE_RIGHT:
+          return this.isComplete ? u : n;
+        case o.NONE:
+        default:
+          return u;
+      }
+    }
+    totalInputPositions() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length;
+      return this.value.slice(t, e).length;
+    }
+    doValidate() {
+      return this.masked.doValidate(...arguments) && (!this.parent || this.parent.doValidate(...arguments));
+    }
+    doCommit() {
+      this.masked.doCommit();
+    }
+    get state() {
+      return {
+        masked: this.masked.state,
+        isFilled: this.isFilled
+      };
+    }
+    set state(t) {
+      this.masked.state = t.masked, this.isFilled = t.isFilled;
+    }
+  }
+  class j {
+    /** */
+    /** */
+    /** */
+    /** */
+    /** */
+    /** */
+    constructor(t) {
+      Object.assign(this, t), this._value = "", this.isFixed = !0;
+    }
+    get value() {
+      return this._value;
+    }
+    get unmaskedValue() {
+      return this.isUnmasking ? this.value : "";
+    }
+    get displayValue() {
+      return this.value;
+    }
+    reset() {
+      this._isRawInput = !1, this._value = "";
+    }
+    remove() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this._value.length;
+      return this._value = this._value.slice(0, t) + this._value.slice(e), this._value || (this._isRawInput = !1), new c();
+    }
+    nearestInputPos(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : o.NONE;
+      const s = 0, n = this._value.length;
+      switch (e) {
+        case o.LEFT:
+        case o.FORCE_LEFT:
+          return s;
+        case o.NONE:
+        case o.RIGHT:
+        case o.FORCE_RIGHT:
+        default:
+          return n;
+      }
+    }
+    totalInputPositions() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this._value.length;
+      return this._isRawInput ? e - t : 0;
+    }
+    extractInput() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this._value.length;
+      return (arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}).raw && this._isRawInput && this._value.slice(t, e) || "";
+    }
+    get isComplete() {
+      return !0;
+    }
+    get isFilled() {
+      return !!this._value;
+    }
+    _appendChar(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      const s = new c();
+      if (this.isFilled)
+        return s;
+      const n = this.eager === !0 || this.eager === "append", i = this.char === t && (this.isUnmasking || e.input || e.raw) && (!e.raw || !n) && !e.tail;
+      return i && (s.rawInserted = this.char), this._value = s.inserted = this.char, this._isRawInput = i && (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 arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length, new _("");
+    }
+    // $FlowFixMe no ideas
+    appendTail(t) {
+      return B(t) && (t = new _(String(t))), t.appendTo(this);
+    }
+    append(t, e, s) {
+      const n = this._appendChar(t[0], e);
+      return s != null && (n.tailShift += this.appendTail(s).tailShift), n;
+    }
+    doCommit() {
+    }
+    get state() {
+      return {
+        _value: this._value,
+        _isRawInput: this._isRawInput
+      };
+    }
+    set state(t) {
+      Object.assign(this, t);
+    }
+  }
+  const W = ["chunks"];
+  class F {
+    /** */
+    constructor() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [], e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+      this.chunks = t, this.from = e;
+    }
+    toString() {
+      return this.chunks.map(String).join("");
+    }
+    // $FlowFixMe no ideas
+    extend(t) {
+      if (!String(t))
+        return;
+      B(t) && (t = new _(String(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 _)
+        s ? e.extend(t.toString()) : this.chunks.push(t);
+      else if (t instanceof F) {
+        if (t.stop == null) {
+          let n;
+          for (; t.chunks.length && t.chunks[0].stop == null; )
+            n = t.chunks.shift(), n.from += t.from, this.extend(n);
+        }
+        t.toString() && (t.stop = t.blockIndex, this.chunks.push(t));
+      }
+    }
+    appendTo(t) {
+      if (!(t instanceof h.MaskedPattern))
+        return new _(this.toString()).appendTo(t);
+      const e = new c();
+      for (let s = 0; s < this.chunks.length && !e.skip; ++s) {
+        const n = this.chunks[s], u = t._mapPosToBlock(t.value.length), i = n.stop;
+        let r;
+        if (i != null && // if block not found or stop is behind lastBlock
+        (!u || u.index <= i)) {
+          if (n instanceof F || // for continuous block also check if stop is exist
+          t._stops.indexOf(i) >= 0) {
+            const l = t._appendPlaceholder(i);
+            e.aggregate(l);
+          }
+          r = n instanceof F && t._blocks[i];
+        }
+        if (r) {
+          const l = r.appendTail(n);
+          l.skip = !1, e.aggregate(l), t._value += l.inserted;
+          const d = n.toString().slice(l.rawInserted.length);
+          d && e.aggregate(
+            t.append(d, {
+              tail: !0
+            })
+          );
+        } else
+          e.aggregate(
+            t.append(n.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 } = t, s = k(t, W);
+      Object.assign(this, s), this.chunks = e.map((n) => {
+        const u = "chunks" in n ? new F() : new _();
+        return u.state = n, u;
+      });
+    }
+    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 n = this.chunks[s], u = n.unshift(e);
+        if (n.toString()) {
+          if (!u)
             break;
-          case t.Large:
-            e += "ds-max-w-4xl ";
+          ++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;
-          case t.Medium:
-          default:
-            e += "ds-max-w-2xl ";
+          --t;
+        } else
+          this.chunks.splice(t, 1);
+        if (s)
+          return s;
+      }
+      return "";
+    }
+  }
+  class J {
+    constructor(t, e) {
+      this.masked = t, this._log = [];
+      const { offset: s, index: n } = t._mapPosToBlock(e) || (e < 0 ? (
+        // first
+        {
+          index: 0,
+          offset: 0
+        }
+      ) : (
+        // last
+        {
+          index: this.masked._blocks.length,
+          offset: 0
+        }
+      ));
+      this.offset = s, this.index = n, 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 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.value.length));
+    }
+    _pushLeft(t) {
+      for (this.pushState(), this.bindBlock(); 0 <= this.index; --this.index, this.offset = ((e = this.block) === null || e === void 0 ? void 0 : e.value.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,
+          o.FORCE_LEFT
+        ), this.offset !== 0))
+          return !0;
+      });
+    }
+    pushLeftBeforeInput() {
+      return this._pushLeft(() => {
+        if (!this.block.isFixed)
+          return this.offset = this.block.nearestInputPos(this.offset, o.LEFT), !0;
+      });
+    }
+    pushLeftBeforeRequired() {
+      return this._pushLeft(() => {
+        if (!(this.block.isFixed || this.block.isOptional && !this.block.value))
+          return this.offset = this.block.nearestInputPos(this.offset, o.LEFT), !0;
+      });
+    }
+    pushRightBeforeFilled() {
+      return this._pushRight(() => {
+        if (!(this.block.isFixed || !this.block.value) && (this.offset = this.block.nearestInputPos(
+          this.offset,
+          o.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, o.NONE), !0;
+      });
+    }
+    pushRightBeforeRequired() {
+      return this._pushRight(() => {
+        if (!(this.block.isFixed || this.block.isOptional && !this.block.value))
+          return this.offset = this.block.nearestInputPos(this.offset, o.NONE), !0;
+      });
+    }
+  }
+  class U extends p {
+    /**
+      @override
+      @param {Object} opts
+    */
+    _update(t) {
+      t.mask && (t.validate = (e) => e.search(t.mask) >= 0), super._update(t);
+    }
+  }
+  h.MaskedRegExp = U;
+  const Q = ["_blocks"];
+  class f extends p {
+    /** */
+    /** */
+    /** Single char for empty input */
+    /** Single char for filled input */
+    /** Show placeholder only when needed */
+    constructor() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      t.definitions = Object.assign(
+        {},
+        X,
+        t.definitions
+      ), super(Object.assign({}, f.DEFAULTS, t));
+    }
+    /**
+      @override
+      @param {Object} opts
+    */
+    _update() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      t.definitions = Object.assign({}, this.definitions, t.definitions), super._update(t), this._rebuildMask();
+    }
+    /** */
+    _rebuildMask() {
+      const t = this.definitions;
+      this._blocks = [], this._stops = [], this._maskedBlocks = {};
+      let e = this.mask;
+      if (!e || !t)
+        return;
+      let s = !1, n = !1;
+      for (let r = 0; r < e.length; ++r) {
+        var u, i;
+        if (this.blocks) {
+          const V = e.slice(r), Y = Object.keys(this.blocks).filter(
+            (D) => V.indexOf(D) === 0
+          );
+          Y.sort((D, nt) => nt.length - D.length);
+          const b = Y[0];
+          if (b) {
+            const D = v(
+              Object.assign(
+                {
+                  parent: this,
+                  lazy: this.lazy,
+                  eager: this.eager,
+                  placeholderChar: this.placeholderChar,
+                  displayChar: this.displayChar,
+                  overwrite: this.overwrite
+                },
+                this.blocks[b]
+              )
+            );
+            D && (this._blocks.push(D), this._maskedBlocks[b] || (this._maskedBlocks[b] = []), this._maskedBlocks[b].push(this._blocks.length - 1)), r += b.length - 1;
+            continue;
+          }
+        }
+        let l = e[r], d = l in t;
+        if (l === f.STOP_CHAR) {
+          this._stops.push(this._blocks.length);
+          continue;
+        }
+        if (l === "{" || l === "}") {
+          s = !s;
+          continue;
+        }
+        if (l === "[" || l === "]") {
+          n = !n;
+          continue;
+        }
+        if (l === f.ESCAPE_CHAR) {
+          if (++r, l = e[r], !l)
             break;
+          d = !1;
         }
+        const E = (u = t[l]) !== null && u !== void 0 && u.mask && !(((i = t[l]) === null || i === void 0 ? void 0 : i.mask.prototype) instanceof h.Masked) ? t[l] : {
+          mask: t[l]
+        }, A = d ? new N(
+          Object.assign(
+            {
+              parent: this,
+              isOptional: n,
+              lazy: this.lazy,
+              eager: this.eager,
+              placeholderChar: this.placeholderChar,
+              displayChar: this.displayChar
+            },
+            E
+          )
+        ) : new j({
+          char: l,
+          eager: this.eager,
+          isUnmasking: s
+        });
+        this._blocks.push(A);
+      }
+    }
+    /**
+      @override
+    */
+    get state() {
+      return Object.assign({}, super.state, {
+        _blocks: this._blocks.map((t) => t.state)
+      });
+    }
+    set state(t) {
+      const { _blocks: e } = t, s = k(t, Q);
+      this._blocks.forEach((n, u) => n.state = e[u]), super.state = s;
+    }
+    /**
+      @override
+    */
+    reset() {
+      super.reset(), this._blocks.forEach((t) => t.reset());
+    }
+    /**
+      @override
+    */
+    get isComplete() {
+      return this._blocks.every((t) => t.isComplete);
+    }
+    /**
+      @override
+    */
+    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);
+    }
+    /**
+      @override
+    */
+    doCommit() {
+      this._blocks.forEach((t) => t.doCommit()), super.doCommit();
+    }
+    /**
+      @override
+    */
+    get unmaskedValue() {
+      return this._blocks.reduce((t, e) => t += e.unmaskedValue, "");
+    }
+    set unmaskedValue(t) {
+      super.unmaskedValue = t;
+    }
+    /**
+      @override
+    */
+    get value() {
+      return this._blocks.reduce((t, e) => t += e.value, "");
+    }
+    set value(t) {
+      super.value = t;
+    }
+    get displayValue() {
+      return this._blocks.reduce((t, e) => t += e.displayValue, "");
+    }
+    /**
+      @override
+    */
+    appendTail(t) {
+      return super.appendTail(t).aggregate(this._appendPlaceholder());
+    }
+    /**
+      @override
+    */
+    _appendEager() {
+      var t;
+      const e = new c();
+      let s = (t = this._mapPosToBlock(this.value.length)) === null || t === void 0 ? void 0 : t.index;
+      if (s == null)
+        return e;
+      this._blocks[s].isFilled && ++s;
+      for (let n = s; n < this._blocks.length; ++n) {
+        const u = this._blocks[n]._appendEager();
+        if (!u.inserted)
+          break;
+        e.aggregate(u);
+      }
+      return e;
+    }
+    /**
+      @override
+    */
+    _appendCharRaw(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      const s = this._mapPosToBlock(this.value.length), n = new c();
+      if (!s)
+        return n;
+      for (let r = s.index; ; ++r) {
+        var u, i;
+        const l = this._blocks[r];
+        if (!l)
+          break;
+        const d = l._appendChar(
+          t,
+          Object.assign({}, e, {
+            _beforeTailState: (u = e._beforeTailState) === null || u === void 0 || (i = u._blocks) === null || i === void 0 ? void 0 : i[r]
+          })
+        ), E = d.skip;
+        if (n.aggregate(d), E || d.rawInserted)
+          break;
+      }
+      return n;
+    }
+    /**
+      @override
+    */
+    extractTail() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length;
+      const s = new F();
+      return t === e || this._forEachBlocksInRange(t, e, (n, u, i, r) => {
+        const l = n.extractTail(i, r);
+        l.stop = this._findStopBefore(u), l.from = this._blockStartPos(u), l instanceof F && (l.blockIndex = u), s.extend(l);
+      }), s;
+    }
+    /**
+      @override
+    */
+    extractInput() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length, s = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+      if (t === e)
+        return "";
+      let n = "";
+      return this._forEachBlocksInRange(t, e, (u, i, r, l) => {
+        n += u.extractInput(r, l, s);
+      }), n;
+    }
+    _findStopBefore(t) {
+      let e;
+      for (let s = 0; s < this._stops.length; ++s) {
+        const n = this._stops[s];
+        if (n <= t)
+          e = n;
+        else
+          break;
+      }
       return e;
-    }), m = d(() => {
-      let e = "ds-relative ds-bg-white ds-rounded-lg ds-shadow ";
-      return e += s.fullscreen ? "ds-w-screen ds-h-screen ds-rounded-none " : "", e;
-    }), p = () => {
-      document.addEventListener("keydown", r);
-    }, r = (e) => {
-      e.key === "Escape" && n("close");
-    }, f = () => {
-      document.addEventListener("click", l);
-    }, l = (e) => {
-      [o.value].some((v) => e.composedPath().includes(v)) || n("close");
-    };
-    return h(() => {
-      s.persistent || setTimeout(() => {
-        p(), f();
-      }, 200);
-    }), B(() => {
-      s.persistent || (document.removeEventListener("keydown", r), document.removeEventListener("click", l));
-    }), (e, w) => (E(), x(_, null, {
-      default: y(() => [
-        a("div", {
-          class: c(["modal-wrapper", u.value])
-        }, [
-          a("div", {
-            ref_key: "modalWrapperContentRef",
-            ref: o,
-            class: c(["modal-wrapper-content ds-w-full", m.value])
-          }, [
-            L(e.$slots, "default")
-          ], 2)
-        ], 2)
-      ]),
-      _: 3
-    }));
+    }
+    /** Appends placeholder depending on laziness */
+    _appendPlaceholder(t) {
+      const e = new c();
+      if (this.lazy && t == null)
+        return e;
+      const s = this._mapPosToBlock(this.value.length);
+      if (!s)
+        return e;
+      const n = s.index, u = t ?? this._blocks.length;
+      return this._blocks.slice(n, u).forEach((i) => {
+        if (!i.lazy || t != null) {
+          const r = i._blocks != null ? [i._blocks.length] : [], l = i._appendPlaceholder(...r);
+          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 n = this._blocks[s], u = e.length;
+        if (e += n.value, t <= e.length)
+          return {
+            index: s,
+            offset: t - u
+          };
+      }
+    }
+    /** */
+    _blockStartPos(t) {
+      return this._blocks.slice(0, t).reduce((e, s) => e += s.value.length, 0);
+    }
+    /** */
+    _forEachBlocksInRange(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length, s = arguments.length > 2 ? arguments[2] : void 0;
+      const n = this._mapPosToBlock(t);
+      if (n) {
+        const u = this._mapPosToBlock(e), i = u && n.index === u.index, r = n.offset, l = u && i ? u.offset : this._blocks[n.index].value.length;
+        if (s(
+          this._blocks[n.index],
+          n.index,
+          r,
+          l
+        ), u && !i) {
+          for (let d = n.index + 1; d < u.index; ++d)
+            s(this._blocks[d], d, 0, this._blocks[d].value.length);
+          s(
+            this._blocks[u.index],
+            u.index,
+            0,
+            u.offset
+          );
+        }
+      }
+    }
+    /**
+      @override
+    */
+    remove() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length;
+      const s = super.remove(t, e);
+      return this._forEachBlocksInRange(t, e, (n, u, i, r) => {
+        s.aggregate(n.remove(i, r));
+      }), s;
+    }
+    /**
+      @override
+    */
+    nearestInputPos(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : o.NONE;
+      if (!this._blocks.length)
+        return 0;
+      const s = new J(this, t);
+      if (e === o.NONE)
+        return s.pushRightBeforeInput() || (s.popState(), s.pushLeftBeforeInput()) ? s.pos : this.value.length;
+      if (e === o.LEFT || e === o.FORCE_LEFT) {
+        if (e === o.LEFT) {
+          if (s.pushRightBeforeFilled(), s.ok && s.pos === t)
+            return t;
+          s.popState();
+        }
+        if (s.pushLeftBeforeInput(), s.pushLeftBeforeRequired(), s.pushLeftBeforeFilled(), e === o.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 === o.FORCE_LEFT ? 0 : (s.popState(), s.ok || (s.popState(), s.ok) ? s.pos : 0);
+      }
+      return e === o.RIGHT || e === o.FORCE_RIGHT ? (s.pushRightBeforeInput(), s.pushRightBeforeRequired(), s.pushRightBeforeFilled() ? s.pos : e === o.FORCE_RIGHT ? this.value.length : (s.popState(), s.ok || (s.popState(), s.ok) ? s.pos : this.nearestInputPos(t, o.LEFT))) : t;
+    }
+    /**
+      @override
+    */
+    totalInputPositions() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length, s = 0;
+      return this._forEachBlocksInRange(t, e, (n, u, i, r) => {
+        s += n.totalInputPositions(i, 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]) : [];
+    }
+  }
+  f.DEFAULTS = {
+    lazy: !0,
+    placeholderChar: "_"
+  }, f.STOP_CHAR = "`", f.ESCAPE_CHAR = "\\", f.InputDefinition = N, f.FixedDefinition = j, h.MaskedPattern = f;
+  class T extends f {
+    /**
+      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;
+    }
+    /**
+      @override
+    */
+    _update(t) {
+      t = Object.assign(
+        {
+          to: this.to || 0,
+          from: this.from || 0,
+          maxLength: this.maxLength || 0
+        },
+        t
+      );
+      let e = String(t.to).length;
+      t.maxLength != null && (e = Math.max(e, t.maxLength)), t.maxLength = e;
+      const s = String(t.from).padStart(e, "0"), n = String(t.to).padStart(e, "0");
+      let u = 0;
+      for (; u < n.length && n[u] === s[u]; )
+        ++u;
+      t.mask = n.slice(0, u).replace(/0/g, "\\0") + "0".repeat(e - u), super._update(t);
+    }
+    /**
+      @override
+    */
+    get isComplete() {
+      return super.isComplete && !!this.value;
+    }
+    boundaries(t) {
+      let e = "", s = "";
+      const [, n, u] = t.match(/^(\D*)(\d*)(\D*)/) || [];
+      return u && (e = "0".repeat(n.length) + u, s = "9".repeat(n.length) + u), e = e.padEnd(this.maxLength, "0"), s = s.padEnd(this.maxLength, "9"), [e, s];
+    }
+    // TODO str is a single char everytime
+    /**
+      @override
+    */
+    doPrepare(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, s;
+      if ([t, s] = M(
+        super.doPrepare(t.replace(/\D/g, ""), e)
+      ), !this.autofix || !t)
+        return t;
+      const n = String(this.from).padStart(this.maxLength, "0"), u = String(this.to).padStart(this.maxLength, "0");
+      let i = this.value + t;
+      if (i.length > this.maxLength)
+        return "";
+      const [r, l] = this.boundaries(i);
+      return Number(l) < this.from ? n[i.length - 1] : Number(r) > this.to ? this.autofix === "pad" && i.length < this.maxLength ? [
+        "",
+        s.aggregate(
+          this.append(n[i.length - 1] + t, e)
+        )
+      ] : u[i.length - 1] : t;
+    }
+    /**
+      @override
+    */
+    doValidate() {
+      const t = this.value;
+      if (t.search(/[^0]/) === -1 && t.length <= this._matchFrom)
+        return !0;
+      const [s, n] = this.boundaries(t);
+      return this.from <= Number(n) && Number(s) <= this.to && super.doValidate(...arguments);
+    }
+  }
+  h.MaskedRange = T;
+  class C extends f {
+    /** Pattern mask for date according to {@link MaskedDate#format} */
+    /** Start date */
+    /** End date */
+    /** */
+    /**
+      @param {Object} opts
+    */
+    constructor(t) {
+      super(Object.assign({}, C.DEFAULTS, t));
+    }
+    /**
+      @override
+    */
+    _update(t) {
+      t.mask === Date && delete t.mask, t.pattern && (t.mask = t.pattern);
+      const e = t.blocks;
+      t.blocks = Object.assign({}, C.GET_DEFAULT_BLOCKS()), t.min && (t.blocks.Y.from = t.min.getFullYear()), t.max && (t.blocks.Y.to = t.max.getFullYear()), t.min && t.max && t.blocks.Y.from === t.blocks.Y.to && (t.blocks.m.from = t.min.getMonth() + 1, t.blocks.m.to = t.max.getMonth() + 1, t.blocks.m.from === t.blocks.m.to && (t.blocks.d.from = t.min.getDate(), t.blocks.d.to = t.max.getDate())), Object.assign(t.blocks, this.blocks, e), Object.keys(t.blocks).forEach((s) => {
+        const n = t.blocks[s];
+        !("autofix" in n) && "autofix" in t && (n.autofix = t.autofix);
+      }), super._update(t);
+    }
+    /**
+      @override
+    */
+    doValidate() {
+      const t = this.date;
+      return super.doValidate(...arguments) && (!this.isComplete || this.isDateExist(this.value) && t != null && (this.min == null || this.min <= t) && (this.max == null || t <= this.max));
+    }
+    /** Checks if date is exists */
+    isDateExist(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;
+    }
+    /**
+      @override
+    */
+    get typedValue() {
+      return this.isComplete ? super.typedValue : null;
+    }
+    set typedValue(t) {
+      super.typedValue = t;
+    }
+    /**
+      @override
+    */
+    maskEquals(t) {
+      return t === Date || super.maskEquals(t);
+    }
+  }
+  C.DEFAULTS = {
+    pattern: "d{.}`m{.}`Y",
+    format: (a) => {
+      if (!a)
+        return "";
+      const t = String(a.getDate()).padStart(2, "0"), e = String(a.getMonth() + 1).padStart(2, "0"), s = a.getFullYear();
+      return [t, e, s].join(".");
+    },
+    parse: (a) => {
+      const [t, e, s] = a.split(".");
+      return new Date(s, e - 1, t);
+    }
+  }, C.GET_DEFAULT_BLOCKS = () => ({
+    d: {
+      mask: T,
+      from: 1,
+      to: 31,
+      maxLength: 2
+    },
+    m: {
+      mask: T,
+      from: 1,
+      to: 12,
+      maxLength: 2
+    },
+    Y: {
+      mask: T,
+      from: 1900,
+      to: 9999
+    }
+  }), h.MaskedDate = C;
+  class P {
+    /** */
+    /** */
+    /** */
+    /** 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 {
+        }
+    }
+    /** Should be overriden in subclasses */
+    _unsafeSelect(t, e) {
+    }
+    /** Should be overriden in subclasses */
+    get isActive() {
+      return !1;
+    }
+    /** Should be overriden in subclasses */
+    bindEvents(t) {
+    }
+    /** Should be overriden in subclasses */
+    unbindEvents() {
+    }
+  }
+  h.MaskElement = P;
+  class S extends P {
+    /** Mapping between HTMLElement events and mask internal events */
+    /** HTMLElement to use mask on */
+    /**
+      @param {HTMLInputElement|HTMLTextAreaElement} input
+    */
+    constructor(t) {
+      super(), this.input = t, this._handlers = {};
+    }
+    /** */
+    // $FlowFixMe https://github.com/facebook/flow/issues/2839
+    get rootElement() {
+      var t, e, s;
+      return (t = (e = (s = this.input).getRootNode) === null || e === void 0 ? void 0 : e.call(s)) !== null && t !== void 0 ? t : document;
+    }
+    /**
+      Is element in focus
+      @readonly
+    */
+    get isActive() {
+      return this.input === this.rootElement.activeElement;
+    }
+    /**
+      Returns HTMLElement selection start
+      @override
+    */
+    get _unsafeSelectionStart() {
+      return this.input.selectionStart;
+    }
+    /**
+      Returns HTMLElement selection end
+      @override
+    */
+    get _unsafeSelectionEnd() {
+      return this.input.selectionEnd;
+    }
+    /**
+      Sets HTMLElement selection
+      @override
+    */
+    _unsafeSelect(t, e) {
+      this.input.setSelectionRange(t, e);
+    }
+    /**
+      HTMLElement value
+      @override
+    */
+    get value() {
+      return this.input.value;
+    }
+    set value(t) {
+      this.input.value = t;
+    }
+    /**
+      Binds HTMLElement events to mask internal events
+      @override
+    */
+    bindEvents(t) {
+      Object.keys(t).forEach(
+        (e) => this._toggleEventHandler(
+          S.EVENTS_MAP[e],
+          t[e]
+        )
+      );
+    }
+    /**
+      Unbinds HTMLElement events to mask internal events
+      @override
+    */
+    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);
+    }
+  }
+  S.EVENTS_MAP = {
+    selectionChange: "keydown",
+    input: "input",
+    drop: "drop",
+    click: "click",
+    focus: "focus",
+    commit: "blur"
+  }, h.HTMLMaskElement = S;
+  class y extends S {
+    /**
+      Returns HTMLElement selection start
+      @override
+    */
+    get _unsafeSelectionStart() {
+      const t = this.rootElement, e = t.getSelection && t.getSelection(), s = e && e.anchorOffset, n = e && e.focusOffset;
+      return n == null || s == null || s < n ? s : n;
+    }
+    /**
+      Returns HTMLElement selection end
+      @override
+    */
+    get _unsafeSelectionEnd() {
+      const t = this.rootElement, e = t.getSelection && t.getSelection(), s = e && e.anchorOffset, n = e && e.focusOffset;
+      return n == null || s == null || s > n ? s : n;
+    }
+    /**
+      Sets HTMLElement selection
+      @override
+    */
+    _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 n = this.rootElement, u = n.getSelection && n.getSelection();
+      u && (u.removeAllRanges(), u.addRange(s));
+    }
+    /**
+      HTMLElement value
+      @override
+    */
+    get value() {
+      return this.input.textContent;
+    }
+    set value(t) {
+      this.input.textContent = t;
+    }
+  }
+  h.HTMLContenteditableMaskElement = y;
+  const tt = ["mask"];
+  class H {
+    /**
+      View element
+      @readonly
+    */
+    /**
+      Internal {@link Masked} model
+      @readonly
+    */
+    /**
+      @param {MaskElement|HTMLInputElement|HTMLTextAreaElement} el
+      @param {Object} opts
+    */
+    constructor(t, e) {
+      this.el = t instanceof P ? t : t.isContentEditable && t.tagName !== "INPUT" && t.tagName !== "TEXTAREA" ? new y(t) : new S(t), this.masked = v(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();
+    }
+    /** Read or update mask */
+    get mask() {
+      return this.masked.mask;
+    }
+    maskEquals(t) {
+      var e;
+      return t == null || ((e = this.masked) === null || e === void 0 ? void 0 : e.maskEquals(t));
+    }
+    set mask(t) {
+      if (this.maskEquals(t))
+        return;
+      if (!(t instanceof h.Masked) && this.masked.constructor === L(t)) {
+        this.masked.updateOptions({
+          mask: t
+        });
+        return;
+      }
+      const e = v({
+        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;
+    }
+    /**
+      Starts listening to element events
+      @protected
+    */
+    _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
+      @protected
+     */
+    _unbindEvents() {
+      this.el && this.el.unbindEvents();
+    }
+    /**
+      Fires custom event
+      @protected
+     */
+    _fireEvent(t) {
+      for (var e = arguments.length, s = new Array(e > 1 ? e - 1 : 0), n = 1; n < e; n++)
+        s[n - 1] = arguments[n];
+      const u = this._listeners[t];
+      u && u.forEach((i) => i(...s));
+    }
+    /**
+      Current selection start
+      @readonly
+    */
+    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
+      @protected
+    */
+    _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, n = this.unmaskedValue !== t || this.value !== e;
+      this._unmaskedValue = t, this._value = e, this.el.value !== s && (this.el.value = s), n && this._fireChangeEvents();
+    }
+    /** Updates options with deep equal check, recreates @{link Masked} model if mask type changes */
+    updateOptions(t) {
+      const { mask: e } = t, s = k(t, tt), n = !this.maskEquals(e), u = !I(this.masked, s);
+      n && (this.mask = e), u && this.masked.updateOptions(s), (n || u) && this.updateControl();
+    }
+    /** Updates cursor */
+    updateCursor(t) {
+      t != null && (this.cursorPos = t, this._delayUpdateCursor(t));
+    }
+    /**
+      Delays cursor update to support mobile browsers
+      @private
+    */
+    _delayUpdateCursor(t) {
+      this._abortUpdateCursor(), this._changingCursorPos = t, this._cursorChanging = setTimeout(() => {
+        this.el && (this.cursorPos = this._changingCursorPos, this._abortUpdateCursor());
+      }, 10);
+    }
+    /**
+      Fires custom events
+      @protected
+    */
+    _fireChangeEvents() {
+      this._fireEvent("accept", this._inputEvent), this.masked.isComplete && this._fireEvent("complete", this._inputEvent);
+    }
+    /**
+      Aborts delayed cursor update
+      @private
+    */
+    _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, o.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 K(
+        // new state
+        this.el.value,
+        this.cursorPos,
+        // old state
+        this.displayValue,
+        this._selection
+      ), s = this.masked.rawInputValue, n = this.masked.splice(
+        e.startChangePos,
+        e.removed.length,
+        e.inserted,
+        e.removeDirection,
+        {
+          input: !0,
+          raw: !0
+        }
+      ).offset, u = s === this.masked.rawInputValue ? e.removeDirection : o.NONE;
+      let i = this.masked.nearestInputPos(
+        e.startChangePos + n,
+        u
+      );
+      u !== o.NONE && (i = this.masked.nearestInputPos(i, o.NONE)), this.updateControl(), this.updateCursor(i), 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;
+    }
+  }
+  h.InputMask = H;
+  class z extends f {
+    /**
+      @override
+      @param {Object} opts
+    */
+    _update(t) {
+      t.enum && (t.mask = "*".repeat(t.enum[0].length)), super._update(t);
+    }
+    /**
+      @override
+    */
+    doValidate() {
+      return this.enum.some((t) => t.indexOf(this.unmaskedValue) >= 0) && super.doValidate(...arguments);
+    }
+  }
+  h.MaskedEnum = z;
+  class m 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 */
+    constructor(t) {
+      super(Object.assign({}, m.DEFAULTS, t));
+    }
+    /**
+      @override
+    */
+    _update(t) {
+      super._update(t), this._updateRegExps();
+    }
+    /** */
+    _updateRegExps() {
+      let t = "^" + (this.allowNegative ? "[+|\\-]?" : ""), e = "\\d*", s = (this.scale ? "(".concat(R(this.radix), "\\d{0,").concat(this.scale, "})?") : "") + "$";
+      this._numberRegExp = new RegExp(t + e + s), this._mapToRadixRegExp = new RegExp(
+        "[".concat(this.mapToRadix.map(R).join(""), "]"),
+        "g"
+      ), this._thousandsSeparatorRegExp = new RegExp(
+        R(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);
+    }
+    /**
+      @override
+    */
+    doPrepare(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      t = 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
+      );
+      const [s, n] = M(super.doPrepare(t, e));
+      return t && !s && (n.skip = !0), [s, n];
+    }
+    /** */
+    _separatorsCount(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1, s = 0;
+      for (let n = 0; n < t; ++n)
+        this._value.indexOf(this.thousandsSeparator, n) === n && (++s, e && (t += this.thousandsSeparator.length));
+      return s;
+    }
+    /** */
+    _separatorsCountFromSlice() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this._value;
+      return this._separatorsCount(
+        this._removeThousandsSeparators(t).length,
+        !0
+      );
+    }
+    /**
+      @override
+    */
+    extractInput() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length, s = arguments.length > 2 ? arguments[2] : void 0;
+      return [t, e] = this._adjustRangeWithSeparators(t, e), this._removeThousandsSeparators(
+        super.extractInput(t, e, s)
+      );
+    }
+    /**
+      @override
+    */
+    _appendCharRaw(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      if (!this.thousandsSeparator)
+        return super._appendCharRaw(t, e);
+      const s = e.tail && e._beforeTailState ? e._beforeTailState._value : this._value, n = this._separatorsCountFromSlice(s);
+      this._value = this._removeThousandsSeparators(this.value);
+      const u = super._appendCharRaw(t, e);
+      this._value = this._insertThousandsSeparators(this._value);
+      const i = e.tail && e._beforeTailState ? e._beforeTailState._value : this._value, r = this._separatorsCountFromSlice(i);
+      return u.tailShift += (r - n) * 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 n = this._findSeparatorAround(e);
+      return n >= 0 && (e = n + this.thousandsSeparator.length), [t, e];
+    }
+    /**
+      @override
+    */
+    remove() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0, e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.value.length;
+      [t, e] = this._adjustRangeWithSeparators(t, e);
+      const s = this.value.slice(0, t), n = this.value.slice(e), u = this._separatorsCount(
+        s.length
+      );
+      this._value = this._insertThousandsSeparators(
+        this._removeThousandsSeparators(s + n)
+      );
+      const i = this._separatorsCountFromSlice(s);
+      return new c({
+        tailShift: (i - u) * this.thousandsSeparator.length
+      });
+    }
+    /**
+      @override
+    */
+    nearestInputPos(t, e) {
+      if (!this.thousandsSeparator)
+        return t;
+      switch (e) {
+        case o.NONE:
+        case o.LEFT:
+        case o.FORCE_LEFT: {
+          const s = this._findSeparatorAround(t - 1);
+          if (s >= 0) {
+            const n = s + this.thousandsSeparator.length;
+            if (t < n || this.value.length <= n || e === o.FORCE_LEFT)
+              return s;
+          }
+          break;
+        }
+        case o.RIGHT:
+        case o.FORCE_RIGHT: {
+          const s = this._findSeparatorAround(t);
+          if (s >= 0)
+            return s + this.thousandsSeparator.length;
+        }
+      }
+      return t;
+    }
+    /**
+      @override
+    */
+    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);
+    }
+    /**
+      @override
+    */
+    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.doFormat(e));
+        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, n, u, i) => n + i
+      ), 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) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, s = arguments.length > 2 ? arguments[2] : void 0;
+      const n = this.scale === 0 && t !== this.thousandsSeparator && (t === this.radix || t === m.UNMASKED_RADIX || this.mapToRadix.includes(t));
+      return super.doSkipInvalid(t, e, s) && !n;
+    }
+    /**
+      @override
+    */
+    get unmaskedValue() {
+      return this._removeThousandsSeparators(
+        this._normalizeZeros(this.value)
+      ).replace(this.radix, m.UNMASKED_RADIX);
+    }
+    set unmaskedValue(t) {
+      super.unmaskedValue = t;
+    }
+    /**
+      @override
+    */
+    get typedValue() {
+      return this.doParse(this.unmaskedValue);
+    }
+    set typedValue(t) {
+      this.rawInputValue = this.doFormat(t).replace(
+        m.UNMASKED_RADIX,
+        this.radix
+      );
+    }
+    /** Parsed Number */
+    get number() {
+      return this.typedValue;
+    }
+    set number(t) {
+      this.typedValue = t;
+    }
+    /**
+      Is negative allowed
+      @readonly
+    */
+    get allowNegative() {
+      return this.signed || this.min != null && this.min < 0 || this.max != null && this.max < 0;
+    }
+    /**
+      @override
+    */
+    typedValueEquals(t) {
+      return (super.typedValueEquals(t) || m.EMPTY_VALUES.includes(t) && m.EMPTY_VALUES.includes(this.typedValue)) && !(t === 0 && this.value === "");
+    }
+  }
+  m.UNMASKED_RADIX = ".", m.DEFAULTS = {
+    radix: ",",
+    thousandsSeparator: "",
+    mapToRadix: [m.UNMASKED_RADIX],
+    scale: 2,
+    signed: !1,
+    normalizeZeros: !0,
+    padFractionalZeros: !1,
+    parse: Number,
+    format: (a) => a.toLocaleString("en-US", {
+      useGrouping: !1,
+      maximumFractionDigits: 20
+    })
+  }, m.EMPTY_VALUES = [...p.EMPTY_VALUES, 0], h.MaskedNumber = m;
+  class G extends p {
+    /**
+      @override
+      @param {Object} opts
+    */
+    _update(t) {
+      t.mask && (t.validate = t.mask), super._update(t);
+    }
+  }
+  h.MaskedFunction = G;
+  const et = ["compiledMasks", "currentMaskRef", "currentMask"], st = ["mask"];
+  class x extends p {
+    /** Currently chosen mask */
+    /** Compliled {@link Masked} options */
+    /** Chooses {@link Masked} depending on input value */
+    /**
+      @param {Object} opts
+    */
+    constructor(t) {
+      super(Object.assign({}, x.DEFAULTS, t)), this.currentMask = null;
+    }
+    /**
+      @override
+    */
+    _update(t) {
+      super._update(t), "mask" in t && (this.compiledMasks = Array.isArray(t.mask) ? t.mask.map((e) => v(e)) : []);
+    }
+    /**
+      @override
+    */
+    _appendCharRaw(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      const s = this._applyDispatch(t, e);
+      return this.currentMask && s.aggregate(
+        this.currentMask._appendChar(t, this.currentMaskFlags(e))
+      ), s;
+    }
+    _applyDispatch() {
+      let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "", e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, s = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "";
+      const n = e.tail && e._beforeTailState != null ? e._beforeTailState._value : this.value, u = this.rawInputValue, i = e.tail && e._beforeTailState != null ? (
+        // $FlowFixMe - tired to fight with type system
+        e._beforeTailState._rawInputValue
+      ) : u, r = u.slice(i.length), l = this.currentMask, d = new c(), E = l == null ? void 0 : l.state;
+      if (this.currentMask = this.doDispatch(
+        t,
+        Object.assign({}, e),
+        s
+      ), this.currentMask)
+        if (this.currentMask !== l) {
+          if (this.currentMask.reset(), i) {
+            const A = this.currentMask.append(i, {
+              raw: !0
+            });
+            d.tailShift = A.inserted.length - n.length;
+          }
+          r && (d.tailShift += this.currentMask.append(r, {
+            raw: !0,
+            tail: !0
+          }).tailShift);
+        } else
+          this.currentMask.state = E;
+      return d;
+    }
+    _appendPlaceholder() {
+      const t = this._applyDispatch(...arguments);
+      return this.currentMask && t.aggregate(this.currentMask._appendPlaceholder()), t;
+    }
+    /**
+     @override
+    */
+    _appendEager() {
+      const t = this._applyDispatch(...arguments);
+      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 Object.assign({}, t, {
+        _beforeTailState: ((e = t._beforeTailState) === null || e === void 0 ? void 0 : e.currentMaskRef) === this.currentMask && ((s = t._beforeTailState) === null || s === void 0 ? void 0 : s.currentMask) || t._beforeTailState
+      });
+    }
+    /**
+      @override
+    */
+    doDispatch(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, s = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "";
+      return this.dispatch(t, this, e, s);
+    }
+    /**
+      @override
+    */
+    doValidate(t) {
+      return super.doValidate(t) && (!this.currentMask || this.currentMask.doValidate(this.currentMaskFlags(t)));
+    }
+    /**
+      @override
+    */
+    doPrepare(t) {
+      let e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, [s, n] = M(super.doPrepare(t, e));
+      if (this.currentMask) {
+        let u;
+        [s, u] = M(
+          super.doPrepare(s, this.currentMaskFlags(e))
+        ), n = n.aggregate(u);
+      }
+      return [s, n];
+    }
+    /**
+      @override
+    */
+    reset() {
+      var t;
+      (t = this.currentMask) === null || t === void 0 || t.reset(), this.compiledMasks.forEach((e) => e.reset());
+    }
+    /**
+      @override
+    */
+    get value() {
+      return this.currentMask ? this.currentMask.value : "";
+    }
+    set value(t) {
+      super.value = t;
+    }
+    /**
+      @override
+    */
+    get unmaskedValue() {
+      return this.currentMask ? this.currentMask.unmaskedValue : "";
+    }
+    set unmaskedValue(t) {
+      super.unmaskedValue = t;
+    }
+    /**
+      @override
+    */
+    get typedValue() {
+      return this.currentMask ? this.currentMask.typedValue : "";
+    }
+    // probably typedValue should not be used with dynamic
+    set typedValue(t) {
+      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 : "";
+    }
+    /**
+      @override
+    */
+    get isComplete() {
+      var t;
+      return !!(!((t = this.currentMask) === null || t === void 0) && t.isComplete);
+    }
+    /**
+      @override
+    */
+    get isFilled() {
+      var t;
+      return !!(!((t = this.currentMask) === null || t === void 0) && t.isFilled);
+    }
+    /**
+      @override
+    */
+    remove() {
+      const t = new c();
+      return this.currentMask && t.aggregate(this.currentMask.remove(...arguments)).aggregate(this._applyDispatch()), t;
+    }
+    /**
+      @override
+    */
+    get state() {
+      var t;
+      return Object.assign({}, super.state, {
+        _rawInputValue: this.rawInputValue,
+        compiledMasks: this.compiledMasks.map((e) => e.state),
+        currentMaskRef: this.currentMask,
+        currentMask: (t = this.currentMask) === null || t === void 0 ? void 0 : t.state
+      });
+    }
+    set state(t) {
+      const { compiledMasks: e, currentMaskRef: s, currentMask: n } = t, u = k(t, et);
+      this.compiledMasks.forEach((i, r) => i.state = e[r]), s != null && (this.currentMask = s, this.currentMask.state = n), super.state = u;
+    }
+    /**
+      @override
+    */
+    extractInput() {
+      return this.currentMask ? this.currentMask.extractInput(...arguments) : "";
+    }
+    /**
+      @override
+    */
+    extractTail() {
+      return this.currentMask ? this.currentMask.extractTail(...arguments) : super.extractTail(...arguments);
+    }
+    /**
+      @override
+    */
+    doCommit() {
+      this.currentMask && this.currentMask.doCommit(), super.doCommit();
+    }
+    /**
+      @override
+    */
+    nearestInputPos() {
+      return this.currentMask ? this.currentMask.nearestInputPos(...arguments) : super.nearestInputPos(...arguments);
+    }
+    get overwrite() {
+      return this.currentMask ? this.currentMask.overwrite : super.overwrite;
+    }
+    set overwrite(t) {
+      console.warn(
+        '"overwrite" option is not available in dynamic mask, use this option in siblings'
+      );
+    }
+    get eager() {
+      return this.currentMask ? this.currentMask.eager : super.eager;
+    }
+    set eager(t) {
+      console.warn(
+        '"eager" option is not available in dynamic mask, use this option in siblings'
+      );
+    }
+    get skipInvalid() {
+      return this.currentMask ? this.currentMask.skipInvalid : super.skipInvalid;
+    }
+    set skipInvalid(t) {
+      (this.isInitialized || t !== p.DEFAULTS.skipInvalid) && console.warn(
+        '"skipInvalid" option is not available in dynamic mask, use this option in siblings'
+      );
+    }
+    /**
+      @override
+    */
+    maskEquals(t) {
+      return Array.isArray(t) && this.compiledMasks.every((e, s) => {
+        if (!t[s])
+          return;
+        const n = t[s], { mask: u } = n, i = k(n, st);
+        return I(e, i) && e.maskEquals(u);
+      });
+    }
+    /**
+      @override
+    */
+    typedValueEquals(t) {
+      var e;
+      return !!(!((e = this.currentMask) === null || e === void 0) && e.typedValueEquals(t));
+    }
+  }
+  x.DEFAULTS = {
+    dispatch: (a, t, e, s) => {
+      if (!t.compiledMasks.length)
+        return;
+      const n = t.rawInputValue, u = t.compiledMasks.map((i, r) => {
+        const l = t.currentMask === i, d = l ? i.value.length : i.nearestInputPos(i.value.length, o.FORCE_LEFT);
+        return i.rawInputValue !== n ? (i.reset(), i.append(n, {
+          raw: !0
+        })) : l || i.remove(d), i.append(a, t.currentMaskFlags(e)), i.appendTail(s), {
+          index: r,
+          weight: i.rawInputValue.length,
+          totalInputPositions: i.totalInputPositions(
+            0,
+            Math.max(
+              d,
+              i.nearestInputPos(i.value.length, o.FORCE_LEFT)
+            )
+          )
+        };
+      });
+      return u.sort(
+        (i, r) => r.weight - i.weight || r.totalInputPositions - i.totalInputPositions
+      ), t.compiledMasks[u[0].index];
+    }
+  }, h.MaskedDynamic = x;
+  const w = {
+    MASKED: "value",
+    UNMASKED: "unmaskedValue",
+    TYPED: "typedValue"
+  };
+  function O(a) {
+    let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : w.MASKED, e = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : w.MASKED;
+    const s = v(a);
+    return (n) => s.runIsolated((u) => (u[t] = n, u[e]));
+  }
+  function q(a) {
+    for (var t = arguments.length, e = new Array(t > 1 ? t - 1 : 0), s = 1; s < t; s++)
+      e[s - 1] = arguments[s];
+    return O(...e)(a);
+  }
+  h.PIPE_TYPE = w, h.createPipe = O, h.pipe = q;
+  try {
+    globalThis.IMask = h;
+  } catch {
   }
+  g.ChangeDetails = c, g.HTMLContenteditableMaskElement = y, g.HTMLMaskElement = S, g.InputMask = H, g.MaskElement = P, g.Masked = p, g.MaskedDate = C, g.MaskedDynamic = x, g.MaskedEnum = z, g.MaskedFunction = G, g.MaskedNumber = m, g.MaskedPattern = f, g.MaskedRange = T, g.MaskedRegExp = U, g.PIPE_TYPE = w, g.createMask = v, g.createPipe = O, g.default = h, g.pipe = q, Object.defineProperty(g, "__esModule", { value: !0 });
 });
+const ut = IMask;
 export {
-  W as default
+  ut as default
 };
 //# sourceMappingURL=design-system93.mjs.map