avances en plantillas

storage/public/dist/libs/imask/esm/controls/html-contenteditable-mask-element.d.ts

@@ -0,0 +1,14 @@
+import HTMLMaskElement from './html-mask-element';
+export default class HTMLContenteditableMaskElement extends HTMLMaskElement {
+    input: HTMLElement;
+    /** Returns HTMLElement selection start */
+    get _unsafeSelectionStart(): number | null;
+    /** Returns HTMLElement selection end */
+    get _unsafeSelectionEnd(): number | null;
+    /** Sets HTMLElement selection */
+    _unsafeSelect(start: number, end: number): void;
+    /** HTMLElement value */
+    get value(): string;
+    set value(value: string);
+}
+//# sourceMappingURL=html-contenteditable-mask-element.d.ts.map

storage/public/dist/libs/imask/esm/controls/html-contenteditable-mask-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-contenteditable-mask-element.d.ts","sourceRoot":"","sources":["../../src/controls/html-contenteditable-mask-element.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,MAAM,qBAAqB,CAAC;AAIlD,MAAM,CAAC,OAAO,OACR,8BAA+B,SAAQ,eAAe;IAClD,KAAK,EAAE,WAAW,CAAC;IAC3B,0CAA0C;IAC1C,IAAa,qBAAqB,IAAK,MAAM,GAAG,IAAI,CASnD;IAED,wCAAwC;IACxC,IAAa,mBAAmB,IAAK,MAAM,GAAG,IAAI,CASjD;IAED,iCAAiC;IACxB,aAAa,CAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAclD,wBAAwB;IACxB,IAAa,KAAK,IAAK,MAAM,CAE5B;IACD,IAAa,KAAK,CAAE,KAAK,EAAE,MAAM,EAEhC;CACF"}

storage/public/dist/libs/imask/esm/controls/html-contenteditable-mask-element.js

@@ -0,0 +1,54 @@
+import HTMLMaskElement from './html-mask-element.js';
+import IMask from '../core/holder.js';
+import './mask-element.js';
+
+class HTMLContenteditableMaskElement extends HTMLMaskElement {
+  /** Returns HTMLElement selection start */
+  get _unsafeSelectionStart() {
+    const root = this.rootElement;
+    const selection = root.getSelection && root.getSelection();
+    const anchorOffset = selection && selection.anchorOffset;
+    const focusOffset = selection && selection.focusOffset;
+    if (focusOffset == null || anchorOffset == null || anchorOffset < focusOffset) {
+      return anchorOffset;
+    }
+    return focusOffset;
+  }
+
+  /** Returns HTMLElement selection end */
+  get _unsafeSelectionEnd() {
+    const root = this.rootElement;
+    const selection = root.getSelection && root.getSelection();
+    const anchorOffset = selection && selection.anchorOffset;
+    const focusOffset = selection && selection.focusOffset;
+    if (focusOffset == null || anchorOffset == null || anchorOffset > focusOffset) {
+      return anchorOffset;
+    }
+    return focusOffset;
+  }
+
+  /** Sets HTMLElement selection */
+  _unsafeSelect(start, end) {
+    if (!this.rootElement.createRange) return;
+    const range = this.rootElement.createRange();
+    range.setStart(this.input.firstChild || this.input, start);
+    range.setEnd(this.input.lastChild || this.input, end);
+    const root = this.rootElement;
+    const selection = root.getSelection && root.getSelection();
+    if (selection) {
+      selection.removeAllRanges();
+      selection.addRange(range);
+    }
+  }
+
+  /** HTMLElement value */
+  get value() {
+    return this.input.textContent || '';
+  }
+  set value(value) {
+    this.input.textContent = value;
+  }
+}
+IMask.HTMLContenteditableMaskElement = HTMLContenteditableMaskElement;
+
+export { HTMLContenteditableMaskElement as default };

storage/public/dist/libs/imask/esm/controls/html-input-mask-element.d.ts

@@ -0,0 +1,17 @@
+import HTMLMaskElement from './html-mask-element';
+export type InputElement = HTMLTextAreaElement | HTMLInputElement;
+/** Bridge between InputElement and {@link Masked} */
+export default class HTMLInputMaskElement extends HTMLMaskElement {
+    /** InputElement to use mask on */
+    input: InputElement;
+    constructor(input: InputElement);
+    /** Returns InputElement selection start */
+    get _unsafeSelectionStart(): number | null;
+    /** Returns InputElement selection end */
+    get _unsafeSelectionEnd(): number | null;
+    /** Sets InputElement selection */
+    _unsafeSelect(start: number, end: number): void;
+    get value(): string;
+    set value(value: string);
+}
+//# sourceMappingURL=html-input-mask-element.d.ts.map

storage/public/dist/libs/imask/esm/controls/html-input-mask-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-input-mask-element.d.ts","sourceRoot":"","sources":["../../src/controls/html-input-mask-element.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,MAAM,qBAAqB,CAAC;AAGlD,MAAM,MACD,YAAY,GAAG,mBAAmB,GAAG,gBAAgB,CAAC;AAE3D,qDAAqD;AACrD,MAAM,CAAC,OAAO,OACR,oBAAqB,SAAQ,eAAe;IAChD,kCAAkC;IAC1B,KAAK,EAAE,YAAY,CAAC;gBAEf,KAAK,EAAE,YAAY;IAKhC,2CAA2C;IAC3C,IAAa,qBAAqB,IAAK,MAAM,GAAG,IAAI,CAEnD;IAED,yCAAyC;IACzC,IAAa,mBAAmB,IAAK,MAAM,GAAG,IAAI,CAEjD;IAED,kCAAkC;IAClC,aAAa,CAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAIzC,IAAa,KAAK,IAAK,MAAM,CAE5B;IACD,IAAa,KAAK,CAAE,KAAK,EAAE,MAAM,EAEhC;CACF"}

storage/public/dist/libs/imask/esm/controls/html-input-mask-element.js

@@ -0,0 +1,37 @@
+import HTMLMaskElement from './html-mask-element.js';
+import IMask from '../core/holder.js';
+import './mask-element.js';
+
+/** Bridge between InputElement and {@link Masked} */
+class HTMLInputMaskElement extends HTMLMaskElement {
+  /** InputElement to use mask on */
+
+  constructor(input) {
+    super(input);
+    this.input = input;
+  }
+
+  /** 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(start, end) {
+    this.input.setSelectionRange(start, end);
+  }
+  get value() {
+    return this.input.value;
+  }
+  set value(value) {
+    this.input.value = value;
+  }
+}
+IMask.HTMLMaskElement = HTMLMaskElement;
+
+export { HTMLInputMaskElement as default };

storage/public/dist/libs/imask/esm/controls/html-mask-element.d.ts

@@ -0,0 +1,21 @@
+import MaskElement, { EventHandlers } from './mask-element';
+/** Bridge between HTMLElement and {@link Masked} */
+export default abstract class HTMLMaskElement extends MaskElement {
+    /** HTMLElement to use mask on */
+    input: HTMLElement;
+    _handlers: EventHandlers;
+    abstract value: string;
+    constructor(input: HTMLElement);
+    get rootElement(): HTMLDocument;
+    /** Is element in focus */
+    get isActive(): boolean;
+    /** Binds HTMLElement events to mask internal events */
+    bindEvents(handlers: EventHandlers): void;
+    _onKeydown(e: KeyboardEvent): void;
+    _onBeforeinput(e: InputEvent): void;
+    _onCompositionEnd(e: CompositionEvent): void;
+    _onInput(e: InputEvent): void;
+    /** Unbinds HTMLElement events to mask internal events */
+    unbindEvents(): void;
+}
+//# sourceMappingURL=html-mask-element.d.ts.map

storage/public/dist/libs/imask/esm/controls/html-mask-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-mask-element.d.ts","sourceRoot":"","sources":["../../src/controls/html-mask-element.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,EAAE,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAO5D,oDAAoD;AACpD,MAAM,CAAC,OAAO,CACd,QAAQ,OAAO,eAAgB,SAAQ,WAAW;IAChD,iCAAiC;IACzB,KAAK,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEV,KAAK,EAAE,WAAW;IAS/B,IAAI,WAAW,IAAK,YAAY,CAE/B;IAED,0BAA0B;IAC1B,IAAI,QAAQ,IAAK,OAAO,CAEvB;IAED,uDAAuD;IAC9C,UAAU,CAAE,QAAQ,EAAE,aAAa;IAY5C,UAAU,CAAE,CAAC,EAAE,aAAa;IAiB5B,cAAc,CAAE,CAAC,EAAE,UAAU;IAY7B,iBAAiB,CAAE,CAAC,EAAE,gBAAgB;IAItC,QAAQ,CAAE,CAAC,EAAE,UAAU;IAIvB,yDAAyD;IAChD,YAAY;CAWtB"}

storage/public/dist/libs/imask/esm/controls/html-mask-element.js

@@ -0,0 +1,84 @@
+import MaskElement from './mask-element.js';
+import IMask from '../core/holder.js';
+
+const KEY_Z = 90;
+const KEY_Y = 89;
+
+/** Bridge between HTMLElement and {@link Masked} */
+class HTMLMaskElement extends MaskElement {
+  /** HTMLElement to use mask on */
+
+  constructor(input) {
+    super();
+    this.input = input;
+    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 _this$input$getRootNo, _this$input$getRootNo2, _this$input;
+    return (_this$input$getRootNo = (_this$input$getRootNo2 = (_this$input = this.input).getRootNode) == null ? void 0 : _this$input$getRootNo2.call(_this$input)) != null ? _this$input$getRootNo : document;
+  }
+
+  /** Is element in focus */
+  get isActive() {
+    return this.input === this.rootElement.activeElement;
+  }
+
+  /** Binds HTMLElement events to mask internal events */
+  bindEvents(handlers) {
+    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', handlers.drop);
+    this.input.addEventListener('click', handlers.click);
+    this.input.addEventListener('focus', handlers.focus);
+    this.input.addEventListener('blur', handlers.commit);
+    this._handlers = handlers;
+  }
+  _onKeydown(e) {
+    if (this._handlers.redo && (e.keyCode === KEY_Z && e.shiftKey && (e.metaKey || e.ctrlKey) || e.keyCode === KEY_Y && e.ctrlKey)) {
+      e.preventDefault();
+      return this._handlers.redo(e);
+    }
+    if (this._handlers.undo && e.keyCode === KEY_Z && (e.metaKey || e.ctrlKey)) {
+      e.preventDefault();
+      return this._handlers.undo(e);
+    }
+    if (!e.isComposing) this._handlers.selectionChange(e);
+  }
+  _onBeforeinput(e) {
+    if (e.inputType === 'historyUndo' && this._handlers.undo) {
+      e.preventDefault();
+      return this._handlers.undo(e);
+    }
+    if (e.inputType === 'historyRedo' && this._handlers.redo) {
+      e.preventDefault();
+      return this._handlers.redo(e);
+    }
+  }
+  _onCompositionEnd(e) {
+    this._handlers.input(e);
+  }
+  _onInput(e) {
+    if (!e.isComposing) this._handlers.input(e);
+  }
+
+  /** Unbinds HTMLElement events to mask internal events */
+  unbindEvents() {
+    this.input.removeEventListener('keydown', this._onKeydown);
+    this.input.removeEventListener('input', this._onInput);
+    this.input.removeEventListener('beforeinput', this._onBeforeinput);
+    this.input.removeEventListener('compositionend', this._onCompositionEnd);
+    this.input.removeEventListener('drop', this._handlers.drop);
+    this.input.removeEventListener('click', this._handlers.click);
+    this.input.removeEventListener('focus', this._handlers.focus);
+    this.input.removeEventListener('blur', this._handlers.commit);
+    this._handlers = {};
+  }
+}
+IMask.HTMLMaskElement = HTMLMaskElement;
+
+export { HTMLMaskElement as default };

storage/public/dist/libs/imask/esm/controls/input-history.d.ts

@@ -0,0 +1,18 @@
+import { type Selection } from '../core/utils';
+export type InputHistoryState = {
+    unmaskedValue: string;
+    selection: Selection;
+};
+export default class InputHistory {
+    static MAX_LENGTH: number;
+    states: InputHistoryState[];
+    currentIndex: number;
+    get currentState(): InputHistoryState | undefined;
+    get isEmpty(): boolean;
+    push(state: InputHistoryState): void;
+    go(steps: number): InputHistoryState | undefined;
+    undo(): InputHistoryState | undefined;
+    redo(): InputHistoryState | undefined;
+    clear(): void;
+}
+//# sourceMappingURL=input-history.d.ts.map

storage/public/dist/libs/imask/esm/controls/input-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-history.d.ts","sourceRoot":"","sources":["../../src/controls/input-history.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAG/C,MAAM,MACD,iBAAiB,GAAG;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC;AAGF,MAAM,CAAC,OAAO,OACR,YAAY;IAChB,MAAM,CAAC,UAAU,SAAO;IACxB,MAAM,EAAE,iBAAiB,EAAE,CAAM;IACjC,YAAY,SAAK;IAEjB,IAAI,YAAY,IAAK,iBAAiB,GAAG,SAAS,CAEjD;IAED,IAAI,OAAO,IAAK,OAAO,CAEtB;IAED,IAAI,CAAE,KAAK,EAAE,iBAAiB;IAQ9B,EAAE,CAAE,KAAK,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAKjD,IAAI;IAIJ,IAAI;IAIJ,KAAK;CAIN"}

storage/public/dist/libs/imask/esm/controls/input-history.js

@@ -0,0 +1,36 @@
+class InputHistory {
+  constructor() {
+    this.states = [];
+    this.currentIndex = 0;
+  }
+  get currentState() {
+    return this.states[this.currentIndex];
+  }
+  get isEmpty() {
+    return this.states.length === 0;
+  }
+  push(state) {
+    // if current index points before the last element then remove the future
+    if (this.currentIndex < this.states.length - 1) this.states.length = this.currentIndex + 1;
+    this.states.push(state);
+    if (this.states.length > InputHistory.MAX_LENGTH) this.states.shift();
+    this.currentIndex = this.states.length - 1;
+  }
+  go(steps) {
+    this.currentIndex = Math.min(Math.max(this.currentIndex + steps, 0), this.states.length - 1);
+    return this.currentState;
+  }
+  undo() {
+    return this.go(-1);
+  }
+  redo() {
+    return this.go(+1);
+  }
+  clear() {
+    this.states.length = 0;
+    this.currentIndex = 0;
+  }
+}
+InputHistory.MAX_LENGTH = 100;
+
+export { InputHistory as default };

storage/public/dist/libs/imask/esm/controls/input.d.ts

@@ -0,0 +1,96 @@
+import { type Selection } from '../core/utils';
+import { type UpdateOpts, type FactoryArg, type FactoryReturnMasked } from '../masked/factory';
+import MaskElement from './mask-element';
+import { type InputElement } from './html-input-mask-element';
+import InputHistory, { type InputHistoryState } from './input-history';
+export type InputMaskElement = MaskElement | InputElement | HTMLElement;
+export type InputMaskEventListener = (e?: InputEvent) => void;
+/** Listens to element events and controls changes between element and {@link Masked} */
+export default class InputMask<Opts extends FactoryArg = Record<string, unknown>> {
+    /**
+      View element
+    */
+    el: MaskElement;
+    /** Internal {@link Masked} model */
+    masked: FactoryReturnMasked<Opts>;
+    _listeners: Record<string, Array<InputMaskEventListener>>;
+    _value: string;
+    _changingCursorPos: number;
+    _unmaskedValue: string;
+    _rawInputValue: string;
+    _selection: Selection;
+    _cursorChanging?: ReturnType<typeof setTimeout>;
+    _historyChanging?: boolean;
+    _inputEvent?: InputEvent;
+    history: InputHistory;
+    constructor(el: InputMaskElement, opts: Opts);
+    maskEquals(mask: any): boolean;
+    /** Masked */
+    get mask(): FactoryReturnMasked<Opts>['mask'];
+    set mask(mask: any);
+    /** Raw value */
+    get value(): string;
+    set value(str: string);
+    /** Unmasked value */
+    get unmaskedValue(): string;
+    set unmaskedValue(str: string);
+    /** Raw input value */
+    get rawInputValue(): string;
+    set rawInputValue(str: string);
+    /** Typed unmasked value */
+    get typedValue(): FactoryReturnMasked<Opts>['typedValue'];
+    set typedValue(val: FactoryReturnMasked<Opts>['typedValue']);
+    /** Display value */
+    get displayValue(): string;
+    /** Starts listening to element events */
+    _bindEvents(): void;
+    /** Stops listening to element events */
+    _unbindEvents(): void;
+    /** Fires custom event */
+    _fireEvent(ev: string, e?: InputEvent): void;
+    /** Current selection start */
+    get selectionStart(): number;
+    /** Current cursor position */
+    get cursorPos(): number;
+    set cursorPos(pos: number);
+    /** Stores current selection */
+    _saveSelection(): void;
+    /** Syncronizes model value from view */
+    updateValue(): void;
+    /** Syncronizes view from model value, fires change events */
+    updateControl(cursorPos?: number | 'auto'): void;
+    /** Updates options with deep equal check, recreates {@link Masked} model if mask type changes */
+    updateOptions(opts: UpdateOpts<Opts>): void;
+    /** Updates cursor */
+    updateCursor(cursorPos: number): void;
+    /** Delays cursor update to support mobile browsers */
+    _delayUpdateCursor(cursorPos: number): void;
+    /** Fires custom events */
+    _fireChangeEvents(): void;
+    /** Aborts delayed cursor update */
+    _abortUpdateCursor(): void;
+    /** Aligns cursor to nearest available position */
+    alignCursor(): void;
+    /** Aligns cursor only if selection is empty */
+    alignCursorFriendly(): void;
+    /** Adds listener on custom event */
+    on(ev: string, handler: InputMaskEventListener): this;
+    /** Removes custom event listener */
+    off(ev: string, handler: InputMaskEventListener): this;
+    /** Handles view input event */
+    _onInput(e: InputEvent): void;
+    /** Handles view change event and commits model value */
+    _onChange(): void;
+    /** Handles view drop event, prevents by default */
+    _onDrop(ev: Event): void;
+    /** Restore last selection on focus */
+    _onFocus(ev: Event): void;
+    /** Restore last selection on focus */
+    _onClick(ev: Event): void;
+    _onUndo(): void;
+    _onRedo(): void;
+    _applyHistoryState(state: InputHistoryState | undefined): void;
+    /** Unbind view events and removes element reference */
+    destroy(): void;
+}
+//# sourceMappingURL=input.d.ts.map

storage/public/dist/libs/imask/esm/controls/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../src/controls/input.ts"],"names":[],"mappings":"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"}

storage/public/dist/libs/imask/esm/controls/input.js

@@ -0,0 +1,350 @@
+import { DIRECTION } from '../core/utils.js';
+import ActionDetails from '../core/action-details.js';
+import createMask, { maskedClass } from '../masked/factory.js';
+import MaskElement from './mask-element.js';
+import HTMLInputMaskElement from './html-input-mask-element.js';
+import HTMLContenteditableMaskElement from './html-contenteditable-mask-element.js';
+import IMask from '../core/holder.js';
+import InputHistory from './input-history.js';
+import './html-mask-element.js';
+
+/** Listens to element events and controls changes between element and {@link Masked} */
+class InputMask {
+  /**
+    View element
+  */
+
+  /** Internal {@link Masked} model */
+
+  constructor(el, opts) {
+    this.el = el instanceof MaskElement ? el : el.isContentEditable && el.tagName !== 'INPUT' && el.tagName !== 'TEXTAREA' ? new HTMLContenteditableMaskElement(el) : new HTMLInputMaskElement(el);
+    this.masked = createMask(opts);
+    this._listeners = {};
+    this._value = '';
+    this._unmaskedValue = '';
+    this._rawInputValue = '';
+    this.history = new InputHistory();
+    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();
+
+    // refresh
+    this.updateValue();
+    this._onChange();
+  }
+  maskEquals(mask) {
+    var _this$masked;
+    return mask == null || ((_this$masked = this.masked) == null ? void 0 : _this$masked.maskEquals(mask));
+  }
+
+  /** Masked */
+  get mask() {
+    return this.masked.mask;
+  }
+  set mask(mask) {
+    if (this.maskEquals(mask)) return;
+    if (!(mask instanceof IMask.Masked) && this.masked.constructor === maskedClass(mask)) {
+      // TODO "any" no idea
+      this.masked.updateOptions({
+        mask
+      });
+      return;
+    }
+    const masked = mask instanceof IMask.Masked ? mask : createMask({
+      mask
+    });
+    masked.unmaskedValue = this.masked.unmaskedValue;
+    this.masked = masked;
+  }
+
+  /** Raw value */
+  get value() {
+    return this._value;
+  }
+  set value(str) {
+    if (this.value === str) return;
+    this.masked.value = str;
+    this.updateControl('auto');
+  }
+
+  /** Unmasked value */
+  get unmaskedValue() {
+    return this._unmaskedValue;
+  }
+  set unmaskedValue(str) {
+    if (this.unmaskedValue === str) return;
+    this.masked.unmaskedValue = str;
+    this.updateControl('auto');
+  }
+
+  /** Raw input value */
+  get rawInputValue() {
+    return this._rawInputValue;
+  }
+  set rawInputValue(str) {
+    if (this.rawInputValue === str) return;
+    this.masked.rawInputValue = str;
+    this.updateControl();
+    this.alignCursor();
+  }
+
+  /** Typed unmasked value */
+  get typedValue() {
+    return this.masked.typedValue;
+  }
+  set typedValue(val) {
+    if (this.masked.typedValueEquals(val)) return;
+    this.masked.typedValue = val;
+    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() {
+    if (this.el) this.el.unbindEvents();
+  }
+
+  /** Fires custom event */
+  _fireEvent(ev, e) {
+    const listeners = this._listeners[ev];
+    if (!listeners) return;
+    listeners.forEach(l => l(e));
+  }
+
+  /** Current selection start */
+  get selectionStart() {
+    return this._cursorChanging ? this._changingCursorPos : this.el.selectionStart;
+  }
+
+  /** Current cursor position */
+  get cursorPos() {
+    return this._cursorChanging ? this._changingCursorPos : this.el.selectionEnd;
+  }
+  set cursorPos(pos) {
+    if (!this.el || !this.el.isActive) return;
+    this.el.select(pos, pos);
+    this._saveSelection();
+  }
+
+  /** Stores current selection */
+  _saveSelection( /* ev */
+  ) {
+    if (this.displayValue !== this.el.value) {
+      console.warn('Element value was changed outside of mask. Syncronize mask using `mask.updateValue()` to work properly.'); // eslint-disable-line no-console
+    }
+    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(cursorPos) {
+    const newUnmaskedValue = this.masked.unmaskedValue;
+    const newValue = this.masked.value;
+    const newRawInputValue = this.masked.rawInputValue;
+    const newDisplayValue = this.displayValue;
+    const isChanged = this.unmaskedValue !== newUnmaskedValue || this.value !== newValue || this._rawInputValue !== newRawInputValue;
+    this._unmaskedValue = newUnmaskedValue;
+    this._value = newValue;
+    this._rawInputValue = newRawInputValue;
+    if (this.el.value !== newDisplayValue) this.el.value = newDisplayValue;
+    if (cursorPos === 'auto') this.alignCursor();else if (cursorPos != null) this.cursorPos = cursorPos;
+    if (isChanged) this._fireChangeEvents();
+    if (!this._historyChanging && (isChanged || this.history.isEmpty)) this.history.push({
+      unmaskedValue: newUnmaskedValue,
+      selection: {
+        start: this.selectionStart,
+        end: this.cursorPos
+      }
+    });
+  }
+
+  /** Updates options with deep equal check, recreates {@link Masked} model if mask type changes */
+  updateOptions(opts) {
+    const {
+      mask,
+      ...restOpts
+    } = opts; // TODO types, yes, mask is optional
+
+    const updateMask = !this.maskEquals(mask);
+    const updateOpts = this.masked.optionsIsChanged(restOpts);
+    if (updateMask) this.mask = mask;
+    if (updateOpts) this.masked.updateOptions(restOpts); // TODO
+
+    if (updateMask || updateOpts) this.updateControl();
+  }
+
+  /** Updates cursor */
+  updateCursor(cursorPos) {
+    if (cursorPos == null) return;
+    this.cursorPos = cursorPos;
+
+    // also queue change cursor for mobile browsers
+    this._delayUpdateCursor(cursorPos);
+  }
+
+  /** Delays cursor update to support mobile browsers */
+  _delayUpdateCursor(cursorPos) {
+    this._abortUpdateCursor();
+    this._changingCursorPos = cursorPos;
+    this._cursorChanging = setTimeout(() => {
+      if (!this.el) return; // if was destroyed
+      this.cursorPos = this._changingCursorPos;
+      this._abortUpdateCursor();
+    }, 10);
+  }
+
+  /** Fires custom events */
+  _fireChangeEvents() {
+    this._fireEvent('accept', this._inputEvent);
+    if (this.masked.isComplete) this._fireEvent('complete', this._inputEvent);
+  }
+
+  /** Aborts delayed cursor update */
+  _abortUpdateCursor() {
+    if (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, DIRECTION.LEFT));
+  }
+
+  /** Aligns cursor only if selection is empty */
+  alignCursorFriendly() {
+    if (this.selectionStart !== this.cursorPos) return; // skip if range is selected
+    this.alignCursor();
+  }
+
+  /** Adds listener on custom event */
+  on(ev, handler) {
+    if (!this._listeners[ev]) this._listeners[ev] = [];
+    this._listeners[ev].push(handler);
+    return this;
+  }
+
+  /** Removes custom event listener */
+  off(ev, handler) {
+    if (!this._listeners[ev]) return this;
+    if (!handler) {
+      delete this._listeners[ev];
+      return this;
+    }
+    const hIndex = this._listeners[ev].indexOf(handler);
+    if (hIndex >= 0) this._listeners[ev].splice(hIndex, 1);
+    return this;
+  }
+
+  /** Handles view input event */
+  _onInput(e) {
+    this._inputEvent = e;
+    this._abortUpdateCursor();
+    const details = new ActionDetails({
+      // new state
+      value: this.el.value,
+      cursorPos: this.cursorPos,
+      // old state
+      oldValue: this.displayValue,
+      oldSelection: this._selection
+    });
+    const oldRawValue = this.masked.rawInputValue;
+    const offset = this.masked.splice(details.startChangePos, details.removed.length, details.inserted, details.removeDirection, {
+      input: true,
+      raw: true
+    }).offset;
+
+    // force align in remove direction only if no input chars were removed
+    // otherwise we still need to align with NONE (to get out from fixed symbols for instance)
+    const removeDirection = oldRawValue === this.masked.rawInputValue ? details.removeDirection : DIRECTION.NONE;
+    let cursorPos = this.masked.nearestInputPos(details.startChangePos + offset, removeDirection);
+    if (removeDirection !== DIRECTION.NONE) cursorPos = this.masked.nearestInputPos(cursorPos, DIRECTION.NONE);
+    this.updateControl(cursorPos);
+    delete this._inputEvent;
+  }
+
+  /** Handles view change event and commits model value */
+  _onChange() {
+    if (this.displayValue !== this.el.value) this.updateValue();
+    this.masked.doCommit();
+    this.updateControl();
+    this._saveSelection();
+  }
+
+  /** Handles view drop event, prevents by default */
+  _onDrop(ev) {
+    ev.preventDefault();
+    ev.stopPropagation();
+  }
+
+  /** Restore last selection on focus */
+  _onFocus(ev) {
+    this.alignCursorFriendly();
+  }
+
+  /** Restore last selection on focus */
+  _onClick(ev) {
+    this.alignCursorFriendly();
+  }
+  _onUndo() {
+    this._applyHistoryState(this.history.undo());
+  }
+  _onRedo() {
+    this._applyHistoryState(this.history.redo());
+  }
+  _applyHistoryState(state) {
+    if (!state) return;
+    this._historyChanging = true;
+    this.unmaskedValue = state.unmaskedValue;
+    this.el.select(state.selection.start, state.selection.end);
+    this._saveSelection();
+    this._historyChanging = false;
+  }
+
+  /** Unbind view events and removes element reference */
+  destroy() {
+    this._unbindEvents();
+    this._listeners.length = 0;
+    delete this.el;
+  }
+}
+IMask.InputMask = InputMask;
+
+export { InputMask as default };

storage/public/dist/libs/imask/esm/controls/mask-element.d.ts

@@ -0,0 +1,31 @@
+export type ElementEvent = 'selectionChange' | 'input' | 'drop' | 'click' | 'focus' | 'commit';
+export type EventHandlers = {
+    [key in ElementEvent]: (...args: any[]) => void;
+} & {
+    undo?: (...args: any[]) => void;
+    redo?: (...args: any[]) => void;
+};
+/**  Generic element API to use with mask */
+export default abstract class MaskElement {
+    /** */
+    abstract _unsafeSelectionStart: number | null;
+    /** */
+    abstract _unsafeSelectionEnd: number | null;
+    /** */
+    abstract value: string;
+    /** Safely returns selection start */
+    get selectionStart(): number;
+    /** Safely returns selection end */
+    get selectionEnd(): number;
+    /** Safely sets element selection */
+    select(start: number, end: number): void;
+    /** */
+    get isActive(): boolean;
+    /** */
+    abstract _unsafeSelect(start: number, end: number): void;
+    /** */
+    abstract bindEvents(handlers: EventHandlers): void;
+    /** */
+    abstract unbindEvents(): void;
+}
+//# sourceMappingURL=mask-element.d.ts.map

storage/public/dist/libs/imask/esm/controls/mask-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mask-element.d.ts","sourceRoot":"","sources":["../../src/controls/mask-element.ts"],"names":[],"mappings":"AAGA,MAAM,MACD,YAAY,GACb,iBAAiB,GACjB,OAAO,GACP,MAAM,GACN,OAAO,GACP,OAAO,GACP,QAAQ,CACX;AAED,MAAM,MACD,aAAa,GAAG;KAAG,GAAG,IAAI,YAAY,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;CAAE,GAAG;IACzE,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;IAChC,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;CACjC,CAAA;AAED,4CAA4C;AAC5C,MAAM,CAAC,OAAO,CACd,QAAQ,OAAO,WAAW;IACxB,MAAM;IACN,QAAQ,CAAC,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,MAAM;IACN,QAAQ,CAAC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,MAAM;IACN,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,qCAAqC;IACrC,IAAI,cAAc,IAAK,MAAM,CAS5B;IAED,mCAAmC;IACnC,IAAI,YAAY,IAAK,MAAM,CAS1B;IAED,oCAAoC;IACpC,MAAM,CAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IASlC,MAAM;IACN,IAAI,QAAQ,IAAK,OAAO,CAAkB;IAC1C,MAAM;IACN,QAAQ,CAAC,aAAa,CAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IACzD,MAAM;IACN,QAAQ,CAAC,UAAU,CAAE,QAAQ,EAAE,aAAa,GAAG,IAAI;IACnD,MAAM;IACN,QAAQ,CAAC,YAAY,IAAK,IAAI;CAC/B"}

storage/public/dist/libs/imask/esm/controls/mask-element.js

@@ -0,0 +1,49 @@
+import IMask from '../core/holder.js';
+
+/**  Generic element API to use with mask */
+class MaskElement {
+  /** */
+
+  /** */
+
+  /** */
+
+  /** Safely returns selection start */
+  get selectionStart() {
+    let start;
+    try {
+      start = this._unsafeSelectionStart;
+    } catch {}
+    return start != null ? start : this.value.length;
+  }
+
+  /** Safely returns selection end */
+  get selectionEnd() {
+    let end;
+    try {
+      end = this._unsafeSelectionEnd;
+    } catch {}
+    return end != null ? end : this.value.length;
+  }
+
+  /** Safely sets element selection */
+  select(start, end) {
+    if (start == null || end == null || start === this.selectionStart && end === this.selectionEnd) return;
+    try {
+      this._unsafeSelect(start, end);
+    } catch {}
+  }
+
+  /** */
+  get isActive() {
+    return false;
+  }
+  /** */
+
+  /** */
+
+  /** */
+}
+IMask.MaskElement = MaskElement;
+
+export { MaskElement as default };