@vkzstudio/muza-ui 1.0.0 → 1.0.1

package/dist/node_modules/framer-motion/dist/es/render/utils/variant-props.js

@@ -0,0 +1,13 @@
+const i = [
+  "animate",
+  "whileInView",
+  "whileFocus",
+  "whileHover",
+  "whileTap",
+  "whileDrag",
+  "exit"
+], e = ["initial", ...i];
+export {
+  i as variantPriorityOrder,
+  e as variantProps
+};

package/dist/node_modules/framer-motion/dist/es/utils/delay.js

@@ -0,0 +1,12 @@
+import { time as s } from "../../../../motion-dom/dist/es/frameloop/sync-time.js";
+import { frame as m, cancelFrame as o } from "../../../../motion-dom/dist/es/frameloop/frame.js";
+function i(c, r) {
+  const n = s.now(), e = ({ timestamp: a }) => {
+    const t = a - n;
+    t >= r && (o(e), c(t - r));
+  };
+  return m.setup(e, !0), () => o(e);
+}
+export {
+  i as delay
+};

package/dist/node_modules/framer-motion/dist/es/utils/distance.js

@@ -0,0 +1,9 @@
+const s = (t, n) => Math.abs(t - n);
+function e(t, n) {
+  const a = s(t.x, n.x), c = s(t.y, n.y);
+  return Math.sqrt(a ** 2 + c ** 2);
+}
+export {
+  s as distance,
+  e as distance2D
+};

package/dist/node_modules/framer-motion/dist/es/utils/get-context-window.js

@@ -0,0 +1,4 @@
+const t = ({ current: e }) => e ? e.ownerDocument.defaultView : null;
+export {
+  t as getContextWindow
+};

package/dist/node_modules/framer-motion/dist/es/utils/is-browser.js

@@ -0,0 +1,4 @@
+const e = typeof window < "u";
+export {
+  e as isBrowser
+};

package/dist/node_modules/framer-motion/dist/es/utils/is-ref-object.js

@@ -0,0 +1,6 @@
+function e(t) {
+  return t && typeof t == "object" && Object.prototype.hasOwnProperty.call(t, "current");
+}
+export {
+  e as isRefObject
+};

package/dist/node_modules/framer-motion/dist/es/utils/reduced-motion/index.js

@@ -0,0 +1,13 @@
+import { isBrowser as o } from "../is-browser.js";
+import { hasReducedMotionListener as n, prefersReducedMotion as t } from "./state.js";
+function c() {
+  if (n.current = !0, !!o)
+    if (window.matchMedia) {
+      const e = window.matchMedia("(prefers-reduced-motion)"), r = () => t.current = e.matches;
+      e.addEventListener("change", r), r();
+    } else
+      t.current = !1;
+}
+export {
+  c as initPrefersReducedMotion
+};

package/dist/node_modules/framer-motion/dist/es/utils/reduced-motion/state.js

@@ -0,0 +1,5 @@
+const e = { current: null }, n = { current: !1 };
+export {
+  n as hasReducedMotionListener,
+  e as prefersReducedMotion
+};

package/dist/node_modules/framer-motion/dist/es/utils/shallow-compare.js

@@ -0,0 +1,14 @@
+function f(t, e) {
+  if (!Array.isArray(e))
+    return !1;
+  const n = e.length;
+  if (n !== t.length)
+    return !1;
+  for (let r = 0; r < n; r++)
+    if (e[r] !== t[r])
+      return !1;
+  return !0;
+}
+export {
+  f as shallowCompare
+};

package/dist/node_modules/framer-motion/dist/es/utils/use-composed-ref.js

@@ -0,0 +1,28 @@
+import * as l from "react";
+function f(n, u) {
+  if (typeof n == "function")
+    return n(u);
+  n != null && (n.current = u);
+}
+function i(...n) {
+  return (u) => {
+    let o = !1;
+    const c = n.map((e) => {
+      const t = f(e, u);
+      return !o && typeof t == "function" && (o = !0), t;
+    });
+    if (o)
+      return () => {
+        for (let e = 0; e < c.length; e++) {
+          const t = c[e];
+          typeof t == "function" ? t() : f(n[e], null);
+        }
+      };
+  };
+}
+function s(...n) {
+  return l.useCallback(i(...n), n);
+}
+export {
+  s as useComposedRefs
+};

package/dist/node_modules/framer-motion/dist/es/utils/use-constant.js

@@ -0,0 +1,8 @@
+import { useRef as t } from "react";
+function u(n) {
+  const r = t(null);
+  return r.current === null && (r.current = n()), r.current;
+}
+export {
+  u as useConstant
+};

package/dist/node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.js

@@ -0,0 +1,6 @@
+import { useLayoutEffect as o, useEffect as t } from "react";
+import { isBrowser as e } from "./is-browser.js";
+const s = e ? o : t;
+export {
+  s as useIsomorphicLayoutEffect
+};

package/dist/node_modules/framer-motion/dist/es/utils/use-motion-value-event.js

@@ -0,0 +1,7 @@
+import { useInsertionEffect as e } from "react";
+function i(o, n, t) {
+  e(() => o.on(n, t), [o, n, t]);
+}
+export {
+  i as useMotionValueEvent
+};

package/dist/node_modules/framer-motion/dist/es/value/use-combine-values.js

@@ -0,0 +1,15 @@
+import { useIsomorphicLayoutEffect as a } from "../utils/use-isomorphic-effect.js";
+import { useMotionValue as c } from "./use-motion-value.js";
+import { frame as m, cancelFrame as p } from "../../../../motion-dom/dist/es/frameloop/frame.js";
+function d(n, t) {
+  const r = c(t()), e = () => r.set(t());
+  return e(), a(() => {
+    const s = () => m.preRender(e, !1, !0), u = n.map((o) => o.on("change", s));
+    return () => {
+      u.forEach((o) => o()), p(e);
+    };
+  }), r;
+}
+export {
+  d as useCombineMotionValues
+};

package/dist/node_modules/framer-motion/dist/es/value/use-computed.js

@@ -0,0 +1,10 @@
+import { useCombineMotionValues as n } from "./use-combine-values.js";
+import { collectMotionValues as e } from "../../../../motion-dom/dist/es/value/index.js";
+function i(o) {
+  e.current = [], o();
+  const r = n(e.current, o);
+  return e.current = void 0, r;
+}
+export {
+  i as useComputed
+};

package/dist/node_modules/framer-motion/dist/es/value/use-motion-value.js

@@ -0,0 +1,15 @@
+import { useContext as s, useState as r, useEffect as u } from "react";
+import { MotionConfigContext as f } from "../context/MotionConfigContext.js";
+import { useConstant as i } from "../utils/use-constant.js";
+import { motionValue as m } from "../../../../motion-dom/dist/es/value/index.js";
+function x(t) {
+  const o = i(() => m(t)), { isStatic: e } = s(f);
+  if (e) {
+    const [, n] = r(t);
+    u(() => o.on("change", n), []);
+  }
+  return o;
+}
+export {
+  x as useMotionValue
+};

package/dist/node_modules/framer-motion/dist/es/value/use-transform.js

@@ -0,0 +1,23 @@
+import { useConstant as m } from "../utils/use-constant.js";
+import { useCombineMotionValues as u } from "./use-combine-values.js";
+import { useComputed as i } from "./use-computed.js";
+import { transform as c } from "../../../../motion-dom/dist/es/utils/transform.js";
+function h(o, r, e, n) {
+  if (typeof o == "function")
+    return i(o);
+  const t = typeof r == "function" ? r : c(r, e, n);
+  return Array.isArray(o) ? f(o, t) : f([o], ([s]) => t(s));
+}
+function f(o, r) {
+  const e = m(() => []);
+  return u(o, () => {
+    e.length = 0;
+    const n = o.length;
+    for (let t = 0; t < n; t++)
+      e[t] = o[t].get();
+    return r(e);
+  });
+}
+export {
+  h as useTransform
+};

package/dist/node_modules/framer-motion/dist/es/value/use-will-change/add-will-change.js

@@ -0,0 +1,14 @@
+import { isWillChangeMotionValue as o } from "./is.js";
+import { MotionGlobalConfig as i } from "../../../../../motion-utils/dist/es/global-config.js";
+function C(a, n) {
+  const l = a.getValue("willChange");
+  if (o(l))
+    return l.add(n);
+  if (!l && i.WillChange) {
+    const e = new i.WillChange("auto");
+    a.addValue("willChange", e), e.add(n);
+  }
+}
+export {
+  C as addValueToWillChange
+};

package/dist/node_modules/framer-motion/dist/es/value/use-will-change/is.js

@@ -0,0 +1,7 @@
+import { isMotionValue as i } from "../../../../../motion-dom/dist/es/value/utils/is-motion-value.js";
+function t(o) {
+  return !!(i(o) && o.add);
+}
+export {
+  t as isWillChangeMotionValue
+};

package/dist/node_modules/framer-motion/dist/es/value/utils/resolve-motion-value.js

@@ -0,0 +1,7 @@
+import { isMotionValue as t } from "../../../../../motion-dom/dist/es/value/utils/is-motion-value.js";
+function e(o) {
+  return t(o) ? o.get() : o;
+}
+export {
+  e as resolveMotionValue
+};

package/dist/node_modules/imask/esm/controls/html-contenteditable-mask-element.js

@@ -0,0 +1,34 @@
+import i from "./html-mask-element.js";
+import l from "../core/holder.js";
+import "./mask-element.js";
+class r extends i {
+  /** Returns HTMLElement selection start */
+  get _unsafeSelectionStart() {
+    const o = this.rootElement, t = o.getSelection && o.getSelection(), e = t && t.anchorOffset, n = t && t.focusOffset;
+    return n == null || e == null || e < n ? e : n;
+  }
+  /** Returns HTMLElement selection end */
+  get _unsafeSelectionEnd() {
+    const o = this.rootElement, t = o.getSelection && o.getSelection(), e = t && t.anchorOffset, n = t && t.focusOffset;
+    return n == null || e == null || e > n ? e : n;
+  }
+  /** Sets HTMLElement selection */
+  _unsafeSelect(o, t) {
+    if (!this.rootElement.createRange) return;
+    const e = this.rootElement.createRange();
+    e.setStart(this.input.firstChild || this.input, o), e.setEnd(this.input.lastChild || this.input, t);
+    const n = this.rootElement, s = n.getSelection && n.getSelection();
+    s && (s.removeAllRanges(), s.addRange(e));
+  }
+  /** HTMLElement value */
+  get value() {
+    return this.input.textContent || "";
+  }
+  set value(o) {
+    this.input.textContent = o;
+  }
+}
+l.HTMLContenteditableMaskElement = r;
+export {
+  r as default
+};

package/dist/node_modules/imask/esm/controls/html-input-mask-element.js

@@ -0,0 +1,31 @@
+import e from "./html-mask-element.js";
+import s from "../core/holder.js";
+import "./mask-element.js";
+class r extends e {
+  /** InputElement to use mask on */
+  constructor(t) {
+    super(t), this.input = t;
+  }
+  /** Returns InputElement selection start */
+  get _unsafeSelectionStart() {
+    return this.input.selectionStart != null ? this.input.selectionStart : this.value.length;
+  }
+  /** Returns InputElement selection end */
+  get _unsafeSelectionEnd() {
+    return this.input.selectionEnd;
+  }
+  /** Sets InputElement selection */
+  _unsafeSelect(t, n) {
+    this.input.setSelectionRange(t, n);
+  }
+  get value() {
+    return this.input.value;
+  }
+  set value(t) {
+    this.input.value = t;
+  }
+}
+s.HTMLMaskElement = e;
+export {
+  r as default
+};

package/dist/node_modules/imask/esm/controls/html-mask-element.js

@@ -0,0 +1,48 @@
+import s from "./mask-element.js";
+import o from "../core/holder.js";
+const e = 90, r = 89;
+class h extends s {
+  /** HTMLElement to use mask on */
+  constructor(t) {
+    super(), this.input = t, this._onKeydown = this._onKeydown.bind(this), this._onInput = this._onInput.bind(this), this._onBeforeinput = this._onBeforeinput.bind(this), this._onCompositionEnd = this._onCompositionEnd.bind(this);
+  }
+  get rootElement() {
+    var t, n, i;
+    return (t = (n = (i = this.input).getRootNode) == null ? void 0 : n.call(i)) != null ? t : document;
+  }
+  /** Is element in focus */
+  get isActive() {
+    return this.input === this.rootElement.activeElement;
+  }
+  /** Binds HTMLElement events to mask internal events */
+  bindEvents(t) {
+    this.input.addEventListener("keydown", this._onKeydown), this.input.addEventListener("input", this._onInput), this.input.addEventListener("beforeinput", this._onBeforeinput), this.input.addEventListener("compositionend", this._onCompositionEnd), this.input.addEventListener("drop", t.drop), this.input.addEventListener("click", t.click), this.input.addEventListener("focus", t.focus), this.input.addEventListener("blur", t.commit), this._handlers = t;
+  }
+  _onKeydown(t) {
+    if (this._handlers.redo && (t.keyCode === e && t.shiftKey && (t.metaKey || t.ctrlKey) || t.keyCode === r && t.ctrlKey))
+      return t.preventDefault(), this._handlers.redo(t);
+    if (this._handlers.undo && t.keyCode === e && (t.metaKey || t.ctrlKey))
+      return t.preventDefault(), this._handlers.undo(t);
+    t.isComposing || this._handlers.selectionChange(t);
+  }
+  _onBeforeinput(t) {
+    if (t.inputType === "historyUndo" && this._handlers.undo)
+      return t.preventDefault(), this._handlers.undo(t);
+    if (t.inputType === "historyRedo" && this._handlers.redo)
+      return t.preventDefault(), this._handlers.redo(t);
+  }
+  _onCompositionEnd(t) {
+    this._handlers.input(t);
+  }
+  _onInput(t) {
+    t.isComposing || this._handlers.input(t);
+  }
+  /** Unbinds HTMLElement events to mask internal events */
+  unbindEvents() {
+    this.input.removeEventListener("keydown", this._onKeydown), this.input.removeEventListener("input", this._onInput), this.input.removeEventListener("beforeinput", this._onBeforeinput), this.input.removeEventListener("compositionend", this._onCompositionEnd), this.input.removeEventListener("drop", this._handlers.drop), this.input.removeEventListener("click", this._handlers.click), this.input.removeEventListener("focus", this._handlers.focus), this.input.removeEventListener("blur", this._handlers.commit), this._handlers = {};
+  }
+}
+o.HTMLMaskElement = h;
+export {
+  h as default
+};

package/dist/node_modules/imask/esm/controls/input-history.js

@@ -0,0 +1,30 @@
+class s {
+  constructor() {
+    this.states = [], this.currentIndex = 0;
+  }
+  get currentState() {
+    return this.states[this.currentIndex];
+  }
+  get isEmpty() {
+    return this.states.length === 0;
+  }
+  push(t) {
+    this.currentIndex < this.states.length - 1 && (this.states.length = this.currentIndex + 1), this.states.push(t), this.states.length > s.MAX_LENGTH && this.states.shift(), this.currentIndex = this.states.length - 1;
+  }
+  go(t) {
+    return this.currentIndex = Math.min(Math.max(this.currentIndex + t, 0), this.states.length - 1), this.currentState;
+  }
+  undo() {
+    return this.go(-1);
+  }
+  redo() {
+    return this.go(1);
+  }
+  clear() {
+    this.states.length = 0, this.currentIndex = 0;
+  }
+}
+s.MAX_LENGTH = 100;
+export {
+  s as default
+};

package/dist/node_modules/imask/esm/controls/input.js

@@ -0,0 +1,222 @@
+import { DIRECTION as r } from "../core/utils.js";
+import h from "../core/action-details.js";
+import u, { maskedClass as l } from "../masked/factory.js";
+import d from "./mask-element.js";
+import p from "./html-input-mask-element.js";
+import _ from "./html-contenteditable-mask-element.js";
+import o from "../core/holder.js";
+import m from "./input-history.js";
+import "./html-mask-element.js";
+class c {
+  /**
+    View element
+  */
+  /** Internal {@link Masked} model */
+  constructor(t, s) {
+    this.el = t instanceof d ? t : t.isContentEditable && t.tagName !== "INPUT" && t.tagName !== "TEXTAREA" ? new _(t) : new p(t), this.masked = u(s), this._listeners = {}, this._value = "", this._unmaskedValue = "", this._rawInputValue = "", this.history = new m(), this._saveSelection = this._saveSelection.bind(this), this._onInput = this._onInput.bind(this), this._onChange = this._onChange.bind(this), this._onDrop = this._onDrop.bind(this), this._onFocus = this._onFocus.bind(this), this._onClick = this._onClick.bind(this), this._onUndo = this._onUndo.bind(this), this._onRedo = this._onRedo.bind(this), this.alignCursor = this.alignCursor.bind(this), this.alignCursorFriendly = this.alignCursorFriendly.bind(this), this._bindEvents(), this.updateValue(), this._onChange();
+  }
+  maskEquals(t) {
+    var s;
+    return t == null || ((s = this.masked) == null ? void 0 : s.maskEquals(t));
+  }
+  /** Masked */
+  get mask() {
+    return this.masked.mask;
+  }
+  set mask(t) {
+    if (this.maskEquals(t)) return;
+    if (!(t instanceof o.Masked) && this.masked.constructor === l(t)) {
+      this.masked.updateOptions({
+        mask: t
+      });
+      return;
+    }
+    const s = t instanceof o.Masked ? t : u({
+      mask: t
+    });
+    s.unmaskedValue = this.masked.unmaskedValue, this.masked = s;
+  }
+  /** Raw value */
+  get value() {
+    return this._value;
+  }
+  set value(t) {
+    this.value !== t && (this.masked.value = t, this.updateControl("auto"));
+  }
+  /** Unmasked value */
+  get unmaskedValue() {
+    return this._unmaskedValue;
+  }
+  set unmaskedValue(t) {
+    this.unmaskedValue !== t && (this.masked.unmaskedValue = t, this.updateControl("auto"));
+  }
+  /** Raw input value */
+  get rawInputValue() {
+    return this._rawInputValue;
+  }
+  set rawInputValue(t) {
+    this.rawInputValue !== t && (this.masked.rawInputValue = t, this.updateControl(), this.alignCursor());
+  }
+  /** Typed unmasked value */
+  get typedValue() {
+    return this.masked.typedValue;
+  }
+  set typedValue(t) {
+    this.masked.typedValueEquals(t) || (this.masked.typedValue = t, this.updateControl("auto"));
+  }
+  /** Display value */
+  get displayValue() {
+    return this.masked.displayValue;
+  }
+  /** Starts listening to element events */
+  _bindEvents() {
+    this.el.bindEvents({
+      selectionChange: this._saveSelection,
+      input: this._onInput,
+      drop: this._onDrop,
+      click: this._onClick,
+      focus: this._onFocus,
+      commit: this._onChange,
+      undo: this._onUndo,
+      redo: this._onRedo
+    });
+  }
+  /** Stops listening to element events */
+  _unbindEvents() {
+    this.el && this.el.unbindEvents();
+  }
+  /** Fires custom event */
+  _fireEvent(t, s) {
+    const e = this._listeners[t];
+    e && e.forEach((i) => i(s));
+  }
+  /** Current selection start */
+  get selectionStart() {
+    return this._cursorChanging ? this._changingCursorPos : this.el.selectionStart;
+  }
+  /** Current cursor position */
+  get cursorPos() {
+    return this._cursorChanging ? this._changingCursorPos : this.el.selectionEnd;
+  }
+  set cursorPos(t) {
+    !this.el || !this.el.isActive || (this.el.select(t, t), this._saveSelection());
+  }
+  /** Stores current selection */
+  _saveSelection() {
+    this.displayValue !== this.el.value && console.warn("Element value was changed outside of mask. Syncronize mask using `mask.updateValue()` to work properly."), this._selection = {
+      start: this.selectionStart,
+      end: this.cursorPos
+    };
+  }
+  /** Syncronizes model value from view */
+  updateValue() {
+    this.masked.value = this.el.value, this._value = this.masked.value, this._unmaskedValue = this.masked.unmaskedValue, this._rawInputValue = this.masked.rawInputValue;
+  }
+  /** Syncronizes view from model value, fires change events */
+  updateControl(t) {
+    const s = this.masked.unmaskedValue, e = this.masked.value, i = this.masked.rawInputValue, n = this.displayValue, a = this.unmaskedValue !== s || this.value !== e || this._rawInputValue !== i;
+    this._unmaskedValue = s, this._value = e, this._rawInputValue = i, this.el.value !== n && (this.el.value = n), t === "auto" ? this.alignCursor() : t != null && (this.cursorPos = t), a && this._fireChangeEvents(), !this._historyChanging && (a || this.history.isEmpty) && this.history.push({
+      unmaskedValue: s,
+      selection: {
+        start: this.selectionStart,
+        end: this.cursorPos
+      }
+    });
+  }
+  /** Updates options with deep equal check, recreates {@link Masked} model if mask type changes */
+  updateOptions(t) {
+    const {
+      mask: s,
+      ...e
+    } = t, i = !this.maskEquals(s), n = this.masked.optionsIsChanged(e);
+    i && (this.mask = s), n && this.masked.updateOptions(e), (i || n) && 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, r.LEFT));
+  }
+  /** Aligns cursor only if selection is empty */
+  alignCursorFriendly() {
+    this.selectionStart === this.cursorPos && this.alignCursor();
+  }
+  /** Adds listener on custom event */
+  on(t, s) {
+    return this._listeners[t] || (this._listeners[t] = []), this._listeners[t].push(s), this;
+  }
+  /** Removes custom event listener */
+  off(t, s) {
+    if (!this._listeners[t]) return this;
+    if (!s)
+      return delete this._listeners[t], this;
+    const e = this._listeners[t].indexOf(s);
+    return e >= 0 && this._listeners[t].splice(e, 1), this;
+  }
+  /** Handles view input event */
+  _onInput(t) {
+    this._inputEvent = t, this._abortUpdateCursor();
+    const s = new h({
+      // new state
+      value: this.el.value,
+      cursorPos: this.cursorPos,
+      // old state
+      oldValue: this.displayValue,
+      oldSelection: this._selection
+    }), e = this.masked.rawInputValue, i = this.masked.splice(s.startChangePos, s.removed.length, s.inserted, s.removeDirection, {
+      input: !0,
+      raw: !0
+    }).offset, n = e === this.masked.rawInputValue ? s.removeDirection : r.NONE;
+    let a = this.masked.nearestInputPos(s.startChangePos + i, n);
+    n !== r.NONE && (a = this.masked.nearestInputPos(a, r.NONE)), this.updateControl(a), delete this._inputEvent;
+  }
+  /** Handles view change event and commits model value */
+  _onChange() {
+    this.displayValue !== this.el.value && this.updateValue(), this.masked.doCommit(), this.updateControl(), this._saveSelection();
+  }
+  /** Handles view drop event, prevents by default */
+  _onDrop(t) {
+    t.preventDefault(), t.stopPropagation();
+  }
+  /** Restore last selection on focus */
+  _onFocus(t) {
+    this.alignCursorFriendly();
+  }
+  /** Restore last selection on focus */
+  _onClick(t) {
+    this.alignCursorFriendly();
+  }
+  _onUndo() {
+    this._applyHistoryState(this.history.undo());
+  }
+  _onRedo() {
+    this._applyHistoryState(this.history.redo());
+  }
+  _applyHistoryState(t) {
+    t && (this._historyChanging = !0, this.unmaskedValue = t.unmaskedValue, this.el.select(t.selection.start, t.selection.end), this._saveSelection(), this._historyChanging = !1);
+  }
+  /** Unbind view events and removes element reference */
+  destroy() {
+    this._unbindEvents(), this._listeners.length = 0, delete this.el;
+  }
+}
+o.InputMask = c;
+export {
+  c as default
+};

package/dist/node_modules/imask/esm/controls/mask-element.js

@@ -0,0 +1,43 @@
+import l from "../core/holder.js";
+class n {
+  /** */
+  /** */
+  /** */
+  /** Safely returns selection start */
+  get selectionStart() {
+    let t;
+    try {
+      t = this._unsafeSelectionStart;
+    } catch {
+    }
+    return t ?? this.value.length;
+  }
+  /** Safely returns selection end */
+  get selectionEnd() {
+    let t;
+    try {
+      t = this._unsafeSelectionEnd;
+    } catch {
+    }
+    return t ?? this.value.length;
+  }
+  /** Safely sets element selection */
+  select(t, e) {
+    if (!(t == null || e == null || t === this.selectionStart && e === this.selectionEnd))
+      try {
+        this._unsafeSelect(t, e);
+      } catch {
+      }
+  }
+  /** */
+  get isActive() {
+    return !1;
+  }
+  /** */
+  /** */
+  /** */
+}
+l.MaskElement = n;
+export {
+  n as default
+};