@apia/util 3.0.1 → 3.0.6

package/dist/index.js

@@ -1,63 +1,2651 @@
-export { animate } from './animate/index.js';
-export { decodeHTMLEntities } from './encoding/index.js';
-export { addBoundary, noNaN, parseAsSize } from './number/index.js';
-export { default as arrayOrArray } from './array/arrayOrArray.js';
-export { default as makeImperativeComponent } from './imperative/makeImperativeComponent.js';
-export { default as makeSingleImperativeComponent } from './imperative/makeSingleImperativeComponent.js';
-export { default as useImperativeComponentContext } from './imperative/useImperativeIdentifierContext.js';
-export { getIndex } from './array/getIndex.js';
-export { decrypt } from './crypto/decrypt.js';
-export { encrypt } from './crypto/encrypt.js';
-export { apiaDateToStandarFormat } from './date/apiaDateToStandarFormat.js';
-export { dateToApiaFormat } from './date/dateToApiaFormat.js';
-export { getDateFormat } from './date/getDateFormat.js';
-export { debugDispatcher, isDebugDispatcherEnabled } from './debug/debugDispatcher.js';
-export { shortcutController } from './debug/shortcutController.js';
-export { downloadStringAsDoc } from './documents/downloadStringAsDoc.js';
-export { defaultGetNameFromResponse, downloadUrl } from './documents/downloadUrl.js';
-export { openAndReadFile } from './documents/openAndReadFile.js';
-export { customEvents } from './dom/customEvents.js';
-export { cantFocusSelector, focusSelector, getFocusSelector } from './dom/getFocusSelector.js';
-export { getSpecificParent } from './dom/getSpecificParent.js';
-export { isChild } from './dom/isChild.js';
-export { Url } from './dom/url.js';
-export { disableChildrenFocus, enableChildrenFocus } from './dom/enableChildrenFocus.js';
-export { autoDisconnectMutationObserver } from './dom/autoDisconnectMutationObserver.js';
-export { findOffsetRelativeToScrollParent } from './dom/findOffsetRelativeToScrollParent.js';
-export { findScrollContainer } from './dom/findScrollContainer.js';
-export { scrollParentIntoElement } from './dom/scrollParentIntoElement.js';
-export { usePanAndZoom } from './dom/usePanAndZoom.js';
-export { BouncingEmitter } from './events/BouncingEmitter.js';
-export { EventEmitter } from './events/EventEmitter.js';
-export { StatefulEmitter, isSetter } from './events/StatefulEmitter.js';
-export { focus, notificationsSelector } from './focus/focusController.js';
-export { globalFocus } from './focus/globalFocus.js';
-export { History } from './history/History.js';
-export { useCombinedRefs } from './hooks/useCombinedRefs.js';
-export { useDebouncedCallback } from './hooks/useDebouncedCallback.js';
-export { useLatest } from './hooks/useLatest.js';
-export { useMount } from './hooks/useMount.js';
-export { useUnmount } from './hooks/useUnmount.js';
-export { usePrevious } from './hooks/usePrevious.js';
-export { useStateRef } from './hooks/useStateRef.js';
-export { useSubscription } from './hooks/useSubscription.js';
-export { useUpdateEffect } from './hooks/useUpdateEffect.js';
-export { shallowCompareArrays, shallowEqual, useShallowMemo } from './hooks/useShallowMemo.js';
-export { default as useImperativeComponentEvents } from './imperative/useImperativeComponentEvents.js';
-export { getLabel } from './labels/getLabel.js';
-export { formatMessage } from './labels/formatMessage.js';
-export { getValueByPath } from './objects/getValueByPath.js';
-export { setValueByPath } from './objects/setValueByPath.js';
-export { PropsSelectorUndefinedObject, PropsStore, propsStore } from './propsStore/propsStore.js';
-export { isPropsConfigurationObject, usePropsSelector } from './propsStore/usePropsSelector.js';
-export { useDomState } from './states/useDomState.js';
-export { useDebouncedState } from './states/useDebouncedState.js';
-export { screenLocker } from './screenLock/screenLocker.js';
-export { default as persistentStorage } from './storage/persistentStorage.js';
-export { useLocalStorage } from './storage/useLocalStorage.js';
-export { BasicStoredElement, makeStatefulStore } from './storage/StatefulStore.js';
-export { alignment } from './string/alignment.js';
-export { ucfirst } from './string/ucfirst.js';
-export { toBoolean } from './typeGuards/toBoolean.js';
-export { parseXmlAsync } from './xml/parseXmlAsync.js';
+import { jsx } from 'react/jsx-runtime';
+import * as React from 'react';
+import React__default, { useRef, useCallback, useState, useEffect, useMemo, createContext, useContext } from 'react';
+import uniqueId from 'lodash-es/uniqueId';
+import isFunction from 'lodash-es/isFunction';
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import clone from 'lodash-es/clone';
+import cloneDeep from 'lodash-es/cloneDeep';
+import xml2js from 'xml2js';
+import { parseBooleans, parseNumbers } from 'xml2js/lib/processors';
+
+function addBoundary(definition, min, max, loop) {
+  const actualNumber = typeof definition === "number" ? definition : definition.number;
+  const actualMin = typeof definition === "number" ? min : definition.min;
+  const actualMax = typeof definition === "number" ? max : definition.max;
+  const isActualLoop = typeof definition === "number" ? loop : definition.loop;
+  let newNumber = Number(actualNumber ?? 0);
+  if (actualMin !== void 0 && newNumber < actualMin) {
+    if (actualMax !== void 0 && isActualLoop) {
+      newNumber = actualMax;
+    } else {
+      newNumber = actualMin;
+    }
+  }
+  if (actualMax !== void 0 && newNumber > actualMax) {
+    if (actualMin !== void 0 && isActualLoop) {
+      newNumber = actualMin;
+    } else {
+      newNumber = actualMax;
+    }
+  }
+  return newNumber;
+}
+const sizeUnits = ["b", "kb", "mb", "gb", "tb"];
+function parseAsSize(num) {
+  let index = 0;
+  let finalSize = num;
+  if (finalSize === Infinity)
+    return "1000GB";
+  while (finalSize > 1024) {
+    finalSize /= 1024;
+    index++;
+  }
+  return `${Math.round(finalSize * 10) / 10}${sizeUnits[index]}`;
+}
+function noNaN(number, defaultReturn = 0) {
+  const returnNumber = Number(number);
+  if (number === null || Number.isNaN(returnNumber))
+    return defaultReturn;
+  return returnNumber;
+}
+
+function animate(duration, callback, onFinish) {
+  let initialTime = void 0;
+  let suscription;
+  function innerAnimate(current) {
+    if (initialTime === void 0)
+      initialTime = current;
+    const ellapsed = current - initialTime;
+    const progress = ellapsed / duration;
+    callback(addBoundary(progress, 0, 1));
+    if (progress < 1)
+      suscription = window.requestAnimationFrame(innerAnimate);
+    else
+      onFinish?.();
+  }
+  suscription = window.requestAnimationFrame(innerAnimate);
+  return () => {
+    window.cancelAnimationFrame(suscription);
+  };
+}
+
+function arrayOrArray(o) {
+  if (o === void 0)
+    return [];
+  return Array.isArray(o) ? o : [o];
+}
+
+function getIndex(arr, conditions, defaultIndex) {
+  for (let i = 0; i < conditions.length; i++) {
+    if (typeof conditions[i] === "boolean" && conditions[i] || isFunction(conditions[i]) && conditions[i]())
+      return arr[i];
+  }
+  return arr[defaultIndex ?? -1];
+}
+
+const generateKey = async (salt, passPhrase, keySize, iterationCount) => {
+  const CryptoJS = (await import('crypto-js')).default;
+  const key = CryptoJS.PBKDF2(passPhrase, CryptoJS.enc.Hex.parse(salt), {
+    keySize: keySize / 32,
+    iterations: iterationCount
+  });
+  return key;
+};
+
+const decrypt = async (salt, iv, passPhrase, cipherText, keySize, iterationCount) => {
+  const CryptoJS = (await import('crypto-js')).default;
+  const key = await generateKey(salt, passPhrase, keySize, iterationCount);
+  const cipherParams = CryptoJS.lib.CipherParams.create({
+    ciphertext: CryptoJS.enc.Base64.parse(cipherText)
+  });
+  const decrypted = CryptoJS.AES.decrypt(cipherParams, key, {
+    iv: CryptoJS.enc.Hex.parse(iv)
+  });
+  return decrypted.toString(CryptoJS.enc.Utf8);
+};
+
+const encrypt = async (salt, iv, passPhrase, plainText, keySize, iterationCount) => {
+  const CryptoJS = (await import('crypto-js')).default;
+  const key = await generateKey(salt, passPhrase, keySize, iterationCount);
+  const encrypted = CryptoJS.AES.encrypt(plainText, key, {
+    iv: CryptoJS.enc.Hex.parse(iv)
+  });
+  return encrypted.ciphertext.toString(CryptoJS.enc.Base64);
+};
+
+dayjs.extend(customParseFormat);
+const DEFAULT_DATE_FORMAT = "DD/MM/YYYY";
+const getDateFormat = () => {
+  switch (window.DATE_FORMAT) {
+    case "m/d/Y":
+      return "MM/DD/YYYY";
+    case "d/m/Y":
+      return DEFAULT_DATE_FORMAT;
+    case "Y/m/d":
+      return "YYYY/MM/DD";
+    default:
+      return "DD/MM/YYYY";
+  }
+};
+
+function apiaDateToStandarFormat(date) {
+  const newDate = dayjs(date, getDateFormat());
+  if (!newDate.isValid())
+    return "";
+  return newDate.format("YYYY-MM-DD");
+}
+
+function dateToApiaFormat(date) {
+  return dayjs(date).format(getDateFormat());
+}
+
+const isEnabled = WP_DEVELOP_MODE;
+function isDebugDispatcherEnabled() {
+  return isEnabled;
+}
+const debugDispatcher = new class DDispatcher {
+  constructor() {
+    this.callbacks = {};
+    this.actions = {
+      shout: () => {
+        console.log(Object.keys(this.callbacks));
+      }
+    };
+    this.emit = (action, ...parameters) => {
+      try {
+        if (this.actions[action])
+          this.actions[action]();
+        else {
+          if ((this.callbacks[action] ?? []).length === 1)
+            return this.callbacks[action]?.[0]?.(parameters);
+          (this.callbacks[action] ?? []).forEach((cb) => {
+            return cb(parameters);
+          });
+        }
+        return null;
+      } catch (e) {
+        console.error("DD", e);
+      }
+    };
+  }
+  on(action, cb, help, onlyDevelop = false) {
+    if (!isEnabled && onlyDevelop)
+      return () => {
+      };
+    if (Object.keys(this.actions).includes(action))
+      throw new Error(
+        `The action ${action} is a reserved word for the dispatcher.`
+      );
+    if (!this.callbacks[action])
+      this.callbacks[action] = [];
+    const actionMethod = Object.assign(cb, {
+      help: () => {
+        if (typeof help === "string")
+          console.info(help);
+      }
+    });
+    this.callbacks[action].push(actionMethod);
+    this[action] = Object.assign(
+      (...props) => {
+        this.emit(action, ...props);
+      },
+      {
+        help: () => {
+          if (typeof help === "string")
+            console.info(help);
+        }
+      }
+    );
+    return () => {
+      this.off(action, cb);
+    };
+  }
+  off(action, cb) {
+    this.callbacks[action] = this.callbacks[action].filter((current) => {
+      return current !== cb;
+    });
+  }
+}();
+window.dd = debugDispatcher;
+window.adt = debugDispatcher;
+
+const shortcutController = new class ShortcutController {
+  constructor() {
+    this.history = [];
+    this.candidates = [];
+    this.shortcuts = {
+      callbacks: [],
+      children: [],
+      key: { key: "" }
+    };
+    this.shortcutsStrings = [];
+    this.categories = {
+      dev: ["shift&D"]
+    };
+    document.addEventListener("keydown", (ev) => {
+      if (ev.key?.length !== 1 && ev.key !== "Escape")
+        return;
+      this.candidates = [
+        ...this.candidates.reduce(
+          (accumulated, current) => [
+            ...accumulated,
+            ...current.children.filter(
+              (child) => child.key.key === ev.key && child.key.altKey === ev.altKey && child.key.ctrlKey === ev.ctrlKey && child.key.shiftKey === ev.shiftKey
+            )
+          ],
+          []
+        ),
+        ...this.shortcuts.children.filter(
+          (current) => current.key.key === ev.key && current.key.altKey === ev.altKey && current.key.ctrlKey === ev.ctrlKey && current.key.shiftKey === ev.shiftKey
+        )
+      ];
+      this.candidates.forEach((current) => {
+        if (current.fireEvenFromInputs || !(!ev.key || ev.key.length > 1 || ["input", "textarea", "select"].includes(
+          ev.target.tagName?.toLowerCase()
+        ))) {
+          if (current.callbacks)
+            current.callbacks.forEach((cb) => cb(ev));
+        }
+      });
+    });
+    debugDispatcher.on(
+      "shortcuts",
+      () => {
+        console.info(this.shortcutsStrings);
+        console.info(this.shortcuts, this.history);
+      },
+      "Muestra los shortcuts registrados"
+    );
+    this.on(
+      "short".split(""),
+      () => {
+        this.shortcutsStrings.forEach((shortcut) => console.info(shortcut));
+      },
+      "dev"
+    );
+  }
+  parseKeyToString(key) {
+    if (typeof key === "string")
+      return key;
+    return `${key.altKey ? "alt&" : ""}${key.ctrlKey ? "ctrl&" : ""}${key.shiftKey ? "shift&" : ""}${key.key}`;
+  }
+  parseKey(keyString) {
+    const elements = keyString.split("&");
+    const altKey = elements.includes("alt");
+    const ctrlKey = elements.includes("ctrl");
+    const shiftKey = elements.includes("shift");
+    const key = elements.find(
+      (current) => current !== "shift" && current !== "alt" && current !== "ctrl"
+    );
+    if (!key)
+      throw new Error(`parseKey "${keyString}" does not have key.`);
+    return {
+      key,
+      altKey,
+      ctrlKey,
+      shiftKey
+    };
+  }
+  /**
+     * Para setear un shorcut se puede pasar un string representativo con la
+     * forma:
+     *
+     * **alt**?&**ctrl**?&**shift**?&**(\w)**
+     *
+     * Donde: alt? ctrl? shift? implica que cualquiera de esas palabras pueden o
+     * no aparecer y (\w) es una letra, símbolo o número.
+     *
+     * Puede aparecer cualquier tecla de control o no, pero el símbolo o letra
+     * debe aparecer.
+     *
+     * @param category
+     * Agrega un prefijo de teclas que se deben presionar antes del shortcut para
+     * que funcione, de forma que por ejemplo, todos los shortcuts de la categoría
+     * dev serán ejecutados solamente si antes se presionó shift&D
+     *
+     * @example
+     *
+      shortcutController.on(['shift&A', 'b', 'ctrl&c', 'alt&d'], (ev) => {
+        ev.preventDefault();
+        console.log('Abctrl+cd'),
+      }); // Este shortcut se ejecuta en desarrollo y producción
+  
+      shortcutController.on('unshortcut'.split(''), (ev) => {
+        ev.preventDefault();
+        console.log('Abctrl+cd'),
+      }, 'dev'); // Este shortcut solo se ejecuta en desarrollo
+     */
+  on(keys, callback, category, fireEvenFromInputs) {
+    if (category === "dev" && !isDebugDispatcherEnabled())
+      return;
+    let container = this.shortcuts;
+    const actualKeys = category ? [...this.categories[category], ...keys] : keys;
+    if (this.shortcutsStrings.includes(
+      actualKeys.map((current) => this.parseKeyToString(current)).join("")
+    )) {
+      console.warn(
+        `The shortcut ${actualKeys.map((current) => this.parseKeyToString(current)).join(
+          ""
+        )} is being setted twice. The controller wont register more than one instance but this could be a hint if some unexpected behavior.`
+      );
+      return;
+    }
+    for (const key of actualKeys) {
+      const actualKey = typeof key === "string" ? this.parseKey(key) : key;
+      if (actualKey.key === "")
+        throw new Error(`Empty key ('') is not allowed`);
+      const keyContainer = container.children.find(
+        (current) => current.key.key === actualKey.key || current.key.key === "" && current.key.altKey === actualKey.altKey && current.key.ctrlKey === actualKey.ctrlKey && current.key.shiftKey === actualKey.shiftKey && current.fireEvenFromInputs === fireEvenFromInputs
+      );
+      if (keyContainer)
+        container = keyContainer;
+      else {
+        const newContainer = {
+          callbacks: [],
+          children: [],
+          key: actualKey,
+          fireEvenFromInputs
+        };
+        container.children.push(newContainer);
+        container = newContainer;
+      }
+    }
+    this.shortcutsStrings.push(
+      actualKeys.map((current) => this.parseKeyToString(current)).join("")
+    );
+    container.callbacks.push(callback);
+  }
+}();
+
+async function downloadStringAsDoc(content, options) {
+  (await import('file-saver')).default.saveAs(
+    new Blob([content], {
+      type: "text/plain; charset=utf-8",
+      ...options?.blobProps
+    }),
+    options?.fileName
+  );
+}
+
+function defaultGetNameFromResponse(blob) {
+  return blob.headers["content-disposition"]?.match?.(
+    /filename=(?:\\?")?([\w,\s-() ]+(?:\.[A-Za-z]+)?)(?:\\?")?;?/
+  )?.[1] ?? "noFileName";
+}
+async function downloadUrl(url, secondParameter = defaultGetNameFromResponse) {
+  const blob = await (await import('axios')).default.get(url, {
+    responseType: "blob"
+  });
+  const actualFileName = typeof secondParameter === "string" ? secondParameter : secondParameter(blob);
+  (await import('file-saver')).default.saveAs(
+    new Blob([blob.data]),
+    actualFileName
+  );
+}
+
+function openAndReadFile() {
+  return new Promise((resolve) => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.style.display = "none";
+    document.body.append(input);
+    input.click();
+    input.addEventListener("change", (ev) => {
+      const fileInput = ev.target;
+      const file = fileInput?.files?.[0];
+      if (file) {
+        const reader = new FileReader();
+        reader.onload = (event) => {
+          fileInput.value = "";
+          const content = event.target?.result;
+          if (content) {
+            resolve(content);
+          }
+        };
+        reader.readAsText(file);
+      } else {
+        resolve(null);
+      }
+    });
+  });
+}
+
+function autoDisconnectMutationObserver(element, callback, conf) {
+  let timeoutRegister = -1;
+  let isConnected = false;
+  function disconnect() {
+    if (isConnected) {
+      isConnected = false;
+      observer.disconnect();
+      clearTimeout(timeoutRegister);
+    }
+  }
+  let shoutCallback;
+  const observer = new MutationObserver((...props) => {
+    if (props[0]?.[0] && (props[0][0].removedNodes || props[0][0].addedNodes)) {
+      clearTimeout(shoutCallback);
+      shoutCallback = setTimeout(callback, 100);
+      clearTimeout(timeoutRegister);
+      timeoutRegister = setTimeout(
+        disconnect,
+        conf?.timeout ?? 100
+      );
+    }
+  });
+  isConnected = true;
+  observer.observe(element, { subtree: true, childList: true });
+  timeoutRegister = setTimeout(
+    disconnect,
+    conf?.timeout ?? 100
+  );
+  if (conf?.runCallbackOnInit !== false)
+    shoutCallback = setTimeout(callback, 100);
+  return disconnect;
+}
+
+const REGEXP_SCROLL_PARENT = /^(visible|hidden)/;
+function findScrollContainer(el) {
+  return !(el instanceof HTMLElement) || typeof window.getComputedStyle !== "function" ? null : el.scrollHeight >= el.clientHeight && !REGEXP_SCROLL_PARENT.test(
+    window.getComputedStyle(el).overflowY || "visible"
+  ) ? el : findScrollContainer(el.parentElement) || document.body;
+}
+
+function findOffsetRelativeToScrollParent(element, which = "Top") {
+  const scrollParent = findScrollContainer(element);
+  let currentElement = element;
+  let offset = 0;
+  let offsetParent = currentElement;
+  while (currentElement && currentElement !== scrollParent && currentElement !== document.body && offsetParent !== scrollParent) {
+    if (offsetParent !== currentElement.offsetParent) {
+      offset += currentElement[`offset${which}`];
+      offsetParent = currentElement.offsetParent;
+    }
+    currentElement = currentElement.parentElement;
+  }
+  return offset;
+}
+
+const scrollIntervals = {};
+function scrollParentIntoElement(element, fixedOffsetTop = 0, tries = 2, timeout = 100, scrollId = void 0) {
+  if (scrollId) {
+    clearTimeout(scrollIntervals[scrollId]);
+  }
+  const scrollParent = findScrollContainer(element);
+  const offsetTop = findOffsetRelativeToScrollParent(element);
+  if (scrollParent && (scrollParent.scrollTop + fixedOffsetTop > offsetTop || (scrollParent?.clientHeight ?? Infinity) - fixedOffsetTop < element.getBoundingClientRect().height)) {
+    scrollParent.scrollTop = offsetTop - fixedOffsetTop;
+  } else if (scrollParent && scrollParent.scrollTop + scrollParent.clientHeight < offsetTop + element.getBoundingClientRect().height) {
+    scrollParent.scrollTop = offsetTop;
+  }
+  if (tries > 0)
+    scrollIntervals[scrollId ?? "noId"] = setTimeout(
+      () => scrollParentIntoElement(element, fixedOffsetTop, tries - 1, timeout),
+      timeout
+    );
+}
+
+function usePanAndZoom(effectiveMargin = { left: 0, bottom: 0, right: 0, top: 0 }, blockZoom = true) {
+  const boxRef = useRef(null);
+  const elementRef = useRef(null);
+  const [isPanning, setIsPanning] = React__default.useState(false);
+  const [panningPosition, setPanningPosition] = React__default.useState({ x: 0, y: 0 });
+  React__default.useEffect(() => {
+    if (blockZoom)
+      return;
+    const container = boxRef.current;
+    const innerElement = elementRef.current;
+    const handlePanStart = (ev) => {
+      ev.preventDefault();
+      setIsPanning(true);
+      setPanningPosition({ x: ev.clientX, y: ev.clientY });
+    };
+    const handlePanEnd = (ev) => {
+      ev.preventDefault();
+      setIsPanning(false);
+    };
+    const handlePan = (ev) => {
+      if (!innerElement || !container) {
+        return;
+      }
+      if (isPanning) {
+        ev.preventDefault();
+        ev.stopPropagation();
+        const dx = ev.clientX - panningPosition.x;
+        const dy = ev.clientY - panningPosition.y;
+        container.scrollLeft -= dx;
+        container.scrollTop -= dy;
+        setPanningPosition({ x: ev.clientX, y: ev.clientY });
+      }
+    };
+    if (container) {
+      container.addEventListener("mousedown", handlePanStart);
+      container.addEventListener("mouseup", handlePanEnd);
+      container.addEventListener("mouseleave", handlePanEnd);
+      container.addEventListener("mousemove", handlePan);
+      return () => {
+        container.removeEventListener("mousedown", handlePanStart);
+        container.removeEventListener("mousemove", handlePan);
+        container.removeEventListener("mouseup", handlePanEnd);
+        container.removeEventListener("mouseleave", handlePanEnd);
+      };
+    }
+  }, [isPanning, panningPosition]);
+  React__default.useEffect(() => {
+    if (blockZoom)
+      return;
+    const container = boxRef.current;
+    const innerElement = elementRef.current;
+    let newScale = 1;
+    const handleZoom = (ev) => {
+      ev.preventDefault();
+      const newDelta = ev.deltaY;
+      const scaleIncrement = 0.1;
+      if (newDelta < 0) {
+        if (newScale + scaleIncrement >= 2) {
+          return;
+        }
+        newScale += scaleIncrement;
+      } else {
+        if (newScale - scaleIncrement <= 0.9) {
+          return;
+        }
+        newScale -= scaleIncrement;
+      }
+      if (!innerElement || !container) {
+        return;
+      }
+      const containerRect = container.getBoundingClientRect();
+      const cursorX = ev.clientX - containerRect.left - effectiveMargin.left;
+      const cursorY = ev.clientY - containerRect.top - effectiveMargin.top;
+      const cursorXFromCenter = cursorX - containerRect.width / 2;
+      const cursorYFromCenter = cursorY - containerRect.height / 2;
+      if (newScale <= 1) {
+        if (boxRef.current) {
+          boxRef.current.style.overflow = "hidden";
+        }
+      } else {
+        if (boxRef.current) {
+          boxRef.current.style.overflow = "hidden";
+        }
+      }
+      innerElement.style.transform = `scale(${newScale})`;
+      innerElement.style.transformOrigin = "0px 0px";
+      if (newDelta < 0) {
+        container.scrollLeft += cursorXFromCenter / (newScale * 2);
+        container.scrollTop += cursorYFromCenter / (newScale * 2);
+      } else {
+        container.scrollLeft -= cursorXFromCenter / (newScale * 2);
+        container.scrollTop -= cursorYFromCenter / (newScale * 2);
+      }
+    };
+    if (container) {
+      container.addEventListener("wheel", handleZoom);
+      return () => {
+        container.removeEventListener("wheel", handleZoom);
+      };
+    }
+  }, []);
+  return {
+    boxRef,
+    elementRef
+  };
+}
+
+const customEvents = {
+  /**
+   * Indica que un elemento necesita recibir el foco,
+   * de esta forma, elementos que no se están mostrando
+   * en pantalla (por display:none por ejemplo), pueden
+   * indicar a sus ancestros que deben expandirse.
+   */
+  focus: "customFocus",
+  /**
+   * Indica que debe cambiarse el título del modal
+   */
+  iframeModalChangeTitle: "iframeModalChangeTitle",
+  /**
+   * Indica que un iframe modal debe cerrarse
+   */
+  iframeModalClose: "iframeModalClose",
+  /**
+   * Indica que un iframe modal debe cerrarse
+   */
+  iframeModalNotify: "iframeModalNotify",
+  /**
+   * Indica que un modal debe cerrarse
+   */
+  modalClose: "modalClose",
+  /**
+   * Indica que el panel contenedor debe cerrarse porque
+   * está vacío
+   */
+  hidePanel: "hidePanel",
+  showPanel: "showPanel"
+};
+
+const cantFocusSelector = [
+  "[disabled]",
+  '[tabIndex="-1"]',
+  '[aria-hidden="true"]',
+  "[readonly]",
+  "[data-focus-guard]",
+  ".modal__closeButton"
+].map((current) => `:not(${current})`).join("");
+const focusSelector = [
+  "input",
+  "textarea",
+  "select",
+  "a",
+  "button:not(.toggleAccordionElement)",
+  "[contenteditable]",
+  "[tabIndex]",
+  '[role="button"]'
+].map((current) => `${current}${cantFocusSelector}`).join(",");
+function getFocusSelector(not) {
+  return `input${not ?? ""}, 
+    textarea${not ?? ""}, 
+    select${not ?? ""}, 
+    a${not ?? ""}, 
+    button:not(.toggleAccordionElement)${not ?? ""}, 
+    [contenteditable]${not ?? ""}, 
+    [tabIndex]${not ?? ""}`;
+}
+
+function getSpecificParent(element, checkParent) {
+  let currentElement = element;
+  while (element !== document.documentElement && currentElement) {
+    const hasFoundTheParent = checkParent(currentElement);
+    if (hasFoundTheParent === null)
+      return null;
+    if (hasFoundTheParent)
+      return currentElement;
+    const parent = currentElement.parentElement;
+    if (parent)
+      currentElement = parent;
+    else
+      return null;
+  }
+  return null;
+}
+
+function isChild(element, checkParent) {
+  return !!getSpecificParent(element, checkParent);
+}
+
+var __accessCheck$4 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$4 = (obj, member, getter) => {
+  __accessCheck$4(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$4 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var _parameters;
+class Url {
+  constructor(baseUrl, defaultAllowMultiple = true) {
+    this.defaultAllowMultiple = defaultAllowMultiple;
+    __privateAdd$4(this, _parameters, {});
+    const [base, query] = baseUrl.split("?");
+    this.base = base;
+    query?.split("&").forEach((current) => {
+      const [name, ...value] = current.split("=");
+      this.addParameter(name, value.join("="));
+    });
+  }
+  addParameter(name, value, allowMultiple) {
+    if (allowMultiple === void 0 && !this.defaultAllowMultiple || allowMultiple === false)
+      __privateGet$4(this, _parameters)[name] = String(value);
+    else
+      __privateGet$4(this, _parameters)[name] = __privateGet$4(this, _parameters)[name] ? [...arrayOrArray(__privateGet$4(this, _parameters)[name]), String(value)] : [String(value)];
+  }
+  addParameters(parameters) {
+    parameters.forEach(
+      (current) => this.addParameter(current.name, current.value, current.allowMultiple)
+    );
+  }
+  getParameter(name) {
+    return __privateGet$4(this, _parameters)[name];
+  }
+  toString() {
+    const parametersArray = Object.entries(__privateGet$4(this, _parameters));
+    return `${this.base}${parametersArray.length > 0 ? `?${parametersArray.map(
+      ([name, value]) => Array.isArray(value) ? value.map((current) => `${name}=${current}`).join("&") : `${name}=${String(value)}`
+    ).join("&")}` : ""}`;
+  }
+}
+_parameters = new WeakMap();
+
+const previousTabIndexLabel = "data-previous-tabindex";
+function disableChildrenFocus(parent) {
+  const focusElement = parent.querySelectorAll(focusSelector);
+  focusElement.forEach((element) => {
+    element.setAttribute(
+      previousTabIndexLabel,
+      element.getAttribute("tabindex") ?? ""
+    );
+    element.setAttribute("tabindex", "-1");
+  });
+}
+function enableChildrenFocus(parent) {
+  const focusElement = parent.querySelectorAll(`[${previousTabIndexLabel}]`);
+  focusElement.forEach((element) => {
+    element.setAttribute(
+      "tabindex",
+      element.getAttribute(previousTabIndexLabel) ?? "0"
+    );
+    element.removeAttribute(previousTabIndexLabel);
+  });
+}
+
+const decodeHTMLEntities = (str) => {
+  const parser = new DOMParser();
+  const dom = parser.parseFromString(
+    "<!doctype html><body>" + str,
+    "text/html"
+  );
+  const decodedString = dom.body.textContent;
+  return decodedString;
+};
+
+class EventEmitter {
+  constructor() {
+    this.callbacks = {
+      on: {},
+      once: {}
+    };
+    this.enabled = true;
+    this.debugMode = false;
+  }
+  debug(enable = true) {
+    this.debugMode = enable;
+  }
+  /**
+   * Emits an event with the given data. Any listeners subscribed to this event will be invoked with the passed data.
+   *
+   * @param event - The event name to emit.
+   * @param data - The data associated with the event. Its type is dependent on the event name.
+   */
+  emit(event, data) {
+    this.callbacks.on[event]?.forEach((current) => current(data));
+    this.callbacks.once[event]?.forEach((current) => current(data));
+    this.callbacks.once[event] = [];
+  }
+  /**
+   * Reflects the current emitter state. A disabled state indicates that the emitter wont call listeners until its functionality gets enabled again.
+   */
+  get isEnabled() {
+    return this.enabled;
+  }
+  off(event, cb) {
+    this.callbacks.on[event] = this.callbacks.on[event]?.filter(
+      (c) => c !== cb
+    );
+    this.callbacks.once[event] = this.callbacks.once[event]?.filter(
+      (c) => c !== cb
+    );
+  }
+  /**
+   * Subscribes a callback function to an event. The callback is invoked each time the event is emitted.
+   *
+   * @param event - The event name to listen to.
+   * @param cb - The callback function to be invoked when the event is emitted.
+   * @returns A function to unsubscribe the event listener.
+   */
+  on(event, cb) {
+    if (!this.callbacks.on[event])
+      this.callbacks.on[event] = [];
+    this.callbacks.on[event].push(cb);
+    return () => {
+      this.callbacks.on[event] = this.callbacks.on[event].filter(
+        (c) => c !== cb
+      );
+    };
+  }
+  /**
+   * Subscribes a callback function to an event for a single occurrence. After the event is emitted once, the listener is automatically removed.
+   *
+   * @param event - The event name to listen to for a single occurrence.
+   * @param cb - The callback function to be invoked when the event is emitted.
+   * @returns A function to unsubscribe the event listener.
+   */
+  once(event, cb) {
+    if (!this.callbacks.once[event])
+      this.callbacks.once[event] = [];
+    this.callbacks.once[event].push(cb);
+    return () => {
+      this.callbacks.once[event] = this.callbacks.once[event].filter(
+        (c) => c !== cb
+      );
+    };
+  }
+}
+
+function useCombinedRefs(...refs) {
+  const [targetRef, setTargetRef] = React.useState();
+  React.useEffect(() => {
+    refs.forEach((ref) => {
+      if (!ref)
+        return;
+      if (typeof ref === "function") {
+        ref(targetRef);
+      } else {
+        ref.current = targetRef;
+      }
+    });
+  }, [refs, targetRef]);
+  return setTargetRef;
+}
+
+const useDebouncedCallback = (callback, { runWhenTriggered, timeout } = { runWhenTriggered: false, timeout: 200 }) => {
+  const timeoutRef = useRef(-1);
+  return useCallback(
+    (...params) => {
+      if (runWhenTriggered)
+        callback(...params);
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = setTimeout(
+        () => callback(...params),
+        timeout
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      );
+    },
+    [callback, runWhenTriggered, timeout]
+  );
+};
+
+function usePrevious$1(element) {
+  const el = React__default.useRef(element);
+  const last = React__default.useRef(null);
+  last.current = el.current;
+  el.current = element;
+  return last;
+}
+
+function shallowEqual$1(a, b) {
+  if (Object.is(a, b))
+    return true;
+  if (!Object.is(a, b) && typeof a !== typeof b) {
+    return false;
+  }
+  if (typeof a === "object") {
+    if (Array.isArray(a)) {
+      if (!Array.isArray(b) || a.length !== b.length) {
+        return false;
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (!Object.is(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    } else if (a && b) {
+      for (const [key, value] of Object.entries(a)) {
+        if (!Object.is(value, b[key])) {
+          return false;
+        }
+      }
+      for (const [key, value] of Object.entries(b)) {
+        if (!Object.is(value, a[key])) {
+          return false;
+        }
+      }
+      return true;
+    } else if (a && !b || !a && b) {
+      return false;
+    }
+  }
+  return a === b;
+}
+
+function useIntermediateValue(currentValue) {
+  const [innerState, setInnerState] = useState(currentValue);
+  const previousValue = usePrevious$1(currentValue);
+  if (!shallowEqual$1(currentValue, previousValue.current)) {
+    setInnerState(currentValue);
+  }
+  return [innerState, setInnerState];
+}
+
+function useLatest(value) {
+  const ref = useRef(value);
+  ref.current = value;
+  return ref;
+}
+
+function useMount(effect) {
+  useEffect(() => {
+    return effect();
+  }, []);
+}
+
+function useUnmount(unmountCallback) {
+  useEffect(() => {
+    return unmountCallback;
+  }, []);
+}
+
+function usePrevious(value) {
+  const previousValue = useRef(void 0);
+  const currentValue = useRef(void 0);
+  previousValue.current = currentValue.current;
+  currentValue.current = value;
+  return previousValue;
+}
+
+function useStateRef(initialState) {
+  const [state, setState] = useState(initialState);
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  return [state, setState, stateRef];
+}
+
+function useSubscription({
+  getInitialState,
+  makeSubscription
+}) {
+  const [state, setState] = useState(getInitialState?.());
+  useMount(() => {
+    let newState = getInitialState?.();
+    if (typeof newState === "function")
+      newState = newState();
+    if (newState !== void 0)
+      setState(newState);
+    return makeSubscription(setState);
+  });
+  return state;
+}
+
+function useUpdateEffect(effect, deps) {
+  const hasRunnedForFirstTime = useRef(false);
+  useEffect(() => {
+    if (hasRunnedForFirstTime.current) {
+      return effect();
+    }
+    hasRunnedForFirstTime.current = true;
+    return () => {
+    };
+  }, deps);
+}
+
+function shallowEqual(a, b) {
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a === "object" && a && typeof b === "object" && b) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+      return false;
+    for (let i = 0; i < aKeys.length; i++) {
+      if (a[aKeys[i]] !== b[bKeys[i]])
+        return false;
+    }
+  } else {
+    if (a !== b)
+      return false;
+  }
+  return true;
+}
+function shallowCompareArrays(a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0; i < a.length; i++) {
+    const differ = shallowEqual(a, b);
+    if (!differ)
+      return false;
+  }
+  return true;
+}
+function useShallowMemo(creator, deps) {
+  const value = useRef(creator());
+  const previousDeps = usePrevious(deps);
+  if (!shallowEqual(previousDeps.current ?? [], deps)) {
+    value.current = creator();
+  }
+  return value.current;
+}
+
+function useWhyUpdated(label, e) {
+  const previousData = usePrevious(e);
+  const diffs = [];
+  Object.entries(e).forEach(([key, value]) => {
+    if (!Object.is(value, previousData.current?.[key])) {
+      diffs.push({ key, value, previous: previousData.current?.[key] });
+    }
+  });
+  if (diffs.length) {
+    console.log(label, diffs);
+  }
+}
+
+function isSetter(data) {
+  return typeof data === "function";
+}
+class StatefulEmitter extends EventEmitter {
+  constructor(initialState) {
+    super();
+    this.state = {};
+    /**
+     * Allows to consume an event stream as a real time updated state
+     */
+    this.useState = (event) => {
+      return useSubscription({
+        getInitialState: () => this.state[event],
+        makeSubscription: (setState) => {
+          return this.on(event, setState);
+        }
+      });
+    };
+    this.useStateSelector = (event, selector, comparator = Object.is) => {
+      const previousSelection = useRef(null);
+      return useSubscription({
+        getInitialState: () => selector(this.state[event]),
+        makeSubscription: (setState) => {
+          return this.on(event, () => {
+            const selection = selector(this.state[event]);
+            if (!comparator(selection, previousSelection.current)) {
+              setState(selection);
+            }
+          });
+        }
+      });
+    };
+    this.state = Object.assign({}, initialState);
+  }
+  emit(event, data) {
+    this.state[event] = data;
+    super.emit(event, data);
+  }
+  on(event, cb) {
+    if (this.state[event])
+      this.emit(event, this.state[event]);
+    return super.on(event, cb);
+  }
+  once(event, cb) {
+    if (this.state[event]) {
+      this.emit(event, this.state[event]);
+      return () => {
+      };
+    }
+    return super.once(event, cb);
+  }
+  /**
+   * Retrieves the stored state for a given event
+   */
+  getState(event) {
+    return this.state[event];
+  }
+  /**
+   * Just an alias for emit, with the advantage that can be called with a callback as second parameter in which case behaves exactly as react's setState.
+   */
+  setState(event, data) {
+    const actualData = isSetter(data) ? data(this.getState(event)) : data;
+    this.emit(event, actualData);
+  }
+}
+
+const NullObject = Symbol("NullObject");
+class BouncingEmitter extends StatefulEmitter {
+  constructor() {
+    super(...arguments);
+    this.bouncingTimeouts = {};
+    this.defaultTiming = 100;
+    /**
+     * Throttles a event emit with the warranty that the data will be emitted at most every (timing)ms. Take the following event throttling, where each E is a call to this method and each character represents 20ms:
+     *
+     * E_E_E_E_E_E_E_E_E
+     *
+     * If timing is configured to 100ms, which is the default, the emission will occur as follows:
+     *
+     * ____E____E____E______E
+     *
+     * @param configuration.emitOnStart - Emits an event on the first call to throttle when no pending throttle is stored. **If emitOnStart is true and an only call to throttle is made, it will emit an only event.**
+     */
+    this.throttleData = {};
+    this.throttleEmittedOnInit = {};
+  }
+  /**
+   * Debounces a event emit with until there is no call to the emit methods by (timing)ms. Take the following event throttling, where each E is a call to this method and each character represents 20ms:
+   *
+   * E_E_E_E_E_E_E_E_E
+   *
+   * If timing is configured to 100ms, which is the default, the emission will occur as follows:
+   *
+   * _____________________E
+   */
+  debounce(event, data, configuration) {
+    clearTimeout(this.bouncingTimeouts[event]);
+    this.bouncingTimeouts[event] = setTimeout(() => {
+      this.emit(event, data);
+    }, configuration?.timing ?? this.defaultTiming);
+  }
+  throttle(event, data, configuration) {
+    if (!this.throttleEmittedOnInit[event] && configuration?.emitOnStart) {
+      this.throttleEmittedOnInit[event] = true;
+      setTimeout(() => {
+        this.throttleEmittedOnInit[event] = false;
+      }, configuration?.timing ?? this.defaultTiming);
+      this.emit(event, data);
+    } else if (!configuration?.emitOnStart) {
+      if (this.throttleData[event] === NullObject || !(event in this.throttleData)) {
+        setTimeout(() => {
+          this.emit(event, this.throttleData[event]);
+          this.throttleData[event] = NullObject;
+        }, configuration?.timing ?? this.defaultTiming);
+      }
+      this.throttleData[event] = data;
+    }
+  }
+  /**
+   * This method is a mix between setState and debounce
+   */
+  setStateDebounced(event, data, configuration) {
+    const actualData = isSetter(data) ? data(this.getState(event)) : data;
+    this.debounce(event, actualData, configuration);
+  }
+  /**
+   * This method is a mix between setState and throttle
+   */
+  setStateThrottled(event, data, configuration) {
+    const actualData = isSetter(data) ? data(this.getState(event)) : data;
+    this.throttle(event, actualData, configuration);
+  }
+}
+
+var __accessCheck$3 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$3 = (obj, member, getter) => {
+  __accessCheck$3(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$3 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$3 = (obj, member, value, setter) => {
+  __accessCheck$3(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _onFocusCallbacks, _a$1;
+const historySize = 50;
+const globalFocus = new (_a$1 = class {
+  constructor() {
+    this.focused = [];
+    __privateAdd$3(this, _onFocusCallbacks, []);
+    debugDispatcher.on(
+      "focusHistory",
+      () => {
+        console.info(this.focused);
+      },
+      "Muestra el historial de elementos que recibieron foco."
+    );
+  }
+  offFocus(cb) {
+    __privateSet$3(this, _onFocusCallbacks, __privateGet$3(this, _onFocusCallbacks).filter(
+      (current) => current !== cb
+    ));
+  }
+  onFocus(cb) {
+    __privateGet$3(this, _onFocusCallbacks).push(cb);
+    return () => {
+      this.offFocus(cb);
+    };
+  }
+  inDocument(el) {
+    return el instanceof Function || el instanceof HTMLElement && el.offsetParent !== null;
+  }
+  set focus(element) {
+    this.focused = this.focused.filter((el) => {
+      const existsInDocument = this.inDocument(el) && element !== el;
+      return existsInDocument;
+    });
+    this.focused.unshift(element);
+    if (this.focused.length > historySize) {
+      this.focused = this.focused.splice(0, historySize);
+    }
+    __privateGet$3(this, _onFocusCallbacks).forEach((cb) => cb());
+  }
+  get list() {
+    return [...this.focused];
+  }
+  /**
+   * @param querySelector A query selector against which the element should match
+   * @returns The last HTMLElement if no querySelector argument provided or else, the last which matches
+   * against that query selector.
+   * */
+  last(querySelector, omit = 0) {
+    if (querySelector)
+      for (let i = omit; i <= this.focused.length; i++) {
+        const storedElement = this.focused[i];
+        const element = (
+          // eslint-disable-next-line no-nested-ternary
+          storedElement?.id !== void 0 ? storedElement : isFunction(storedElement) ? storedElement(false) : null
+        );
+        if (element && this.inDocument(element) && element.matches && element.matches(querySelector))
+          return element;
+      }
+    else
+      return this.focused[this.focused.length - 1];
+    return null;
+  }
+}, _onFocusCallbacks = new WeakMap(), _a$1)();
+
+var __accessCheck$2 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$2 = (obj, member, getter) => {
+  __accessCheck$2(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$2 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$2 = (obj, member, value, setter) => {
+  __accessCheck$2(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod$1 = (obj, member, method) => {
+  __accessCheck$2(obj, member, "access private method");
+  return method;
+};
+var _hasReleasedFirstTime, _wasReleasedFirstTime, _isForced, _locks, _shoutLockState, shoutLockState_fn;
+class ScreenLocker extends EventEmitter {
+  constructor() {
+    super();
+    __privateAdd$2(this, _shoutLockState);
+    __privateAdd$2(this, _hasReleasedFirstTime, false);
+    __privateAdd$2(this, _wasReleasedFirstTime, false);
+    __privateAdd$2(this, _isForced, false);
+    __privateAdd$2(this, _locks, {
+      common: false
+    });
+    this.emit("ready", null);
+  }
+  get hasReleasedFirstTime() {
+    return __privateGet$2(this, _hasReleasedFirstTime);
+  }
+  get isForced() {
+    return __privateGet$2(this, _isForced);
+  }
+  /**
+   * Permite saber si un bloqueo determinado está activo o si la clase tiene
+   * forceLock activo.
+   */
+  isLocked(lockName = "common") {
+    return __privateGet$2(this, _locks)[lockName] || __privateGet$2(this, _isForced);
+  }
+  lock(lockName = "common") {
+    __privateGet$2(this, _locks)[lockName] = true;
+    __privateMethod$1(this, _shoutLockState, shoutLockState_fn).call(this, lockName);
+  }
+  unlock(lockName = "common") {
+    if (lockName === "common")
+      __privateSet$2(this, _hasReleasedFirstTime, true);
+    __privateGet$2(this, _locks)[lockName] = false;
+    __privateMethod$1(this, _shoutLockState, shoutLockState_fn).call(this, lockName);
+  }
+  force() {
+    __privateSet$2(this, _isForced, true);
+    __privateMethod$1(this, _shoutLockState, shoutLockState_fn).call(this);
+  }
+  releaseForced() {
+    __privateSet$2(this, _isForced, false);
+    __privateMethod$1(this, _shoutLockState, shoutLockState_fn).call(this);
+  }
+}
+_hasReleasedFirstTime = new WeakMap();
+_wasReleasedFirstTime = new WeakMap();
+_isForced = new WeakMap();
+_locks = new WeakMap();
+_shoutLockState = new WeakSet();
+shoutLockState_fn = function(lockName) {
+  if (__privateGet$2(this, _isForced) || lockName === void 0) {
+    this.emit("forcedStateChange", {
+      isForced: __privateGet$2(this, _isForced),
+      hasReleasedFirstTime: __privateGet$2(this, _hasReleasedFirstTime)
+    });
+  } else {
+    if (lockName === "common" && !__privateGet$2(this, _wasReleasedFirstTime) && __privateGet$2(this, _hasReleasedFirstTime)) {
+      this.emit("releaseForFirstTime", null);
+    }
+    this.emit("lockStateChange", {
+      lockName,
+      hasReleasedFirstTime: __privateGet$2(this, _hasReleasedFirstTime),
+      isLocked: __privateGet$2(this, _locks)[lockName]
+    });
+  }
+};
+const screenLocker = new ScreenLocker();
+
+var __accessCheck$1 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$1 = (obj, member, getter) => {
+  __accessCheck$1(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$1 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$1 = (obj, member, value, setter) => {
+  __accessCheck$1(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _onUpdateCbs;
+function upper(s) {
+  return `${s.charAt(0).toUpperCase()}${s.slice(1)}`;
+}
+function isUpdater(props) {
+  return typeof props === "function";
+}
+class BasicStoredElement {
+  constructor(props) {
+    __privateAdd$1(this, _onUpdateCbs, []);
+    this.props = {};
+    this.shoutUpdates = () => {
+      __privateGet$1(this, _onUpdateCbs).forEach((current) => current());
+    };
+    this.useProps = () => {
+      const [props, setState] = useState(this.props);
+      useMount(() => {
+        setState({ ...this.props });
+        return this.onUpdate(() => {
+          setState({ ...this.props });
+        });
+      });
+      return props;
+    };
+    this.props = props;
+  }
+  onUpdate(cb) {
+    __privateGet$1(this, _onUpdateCbs).push(cb);
+    return () => {
+      __privateSet$1(this, _onUpdateCbs, __privateGet$1(this, _onUpdateCbs).filter((current) => current !== cb));
+    };
+  }
+  update(newProps) {
+    const actualNewProps = isUpdater(newProps) ? newProps(this.props) : newProps;
+    this.props = { ...this.props, ...actualNewProps };
+    this.shoutUpdates();
+  }
+}
+_onUpdateCbs = new WeakMap();
+class People extends BasicStoredElement {
+  getId() {
+    return this.props.name;
+  }
+}
+makeStatefulStore({
+  people: People.prototype
+});
+function makeStatefulStore(entries, initialStates) {
+  const hookUseState = {};
+  const hookUseList = {};
+  const hookUseStateById = {};
+  const suscribeById = {};
+  const suscribeToList = {};
+  const suscribeToListCount = {};
+  const addActions = {};
+  const emptyActions = {};
+  const removeActions = {};
+  const updateListActions = {};
+  const getItemActions = {};
+  const getStateActions = {};
+  const updateItemActions = {};
+  Object.keys(entries).forEach((name) => {
+    const initialStateKey = `${upper(name)}State`;
+    let store = {};
+    const initialState = initialStates?.[initialStateKey];
+    initialState?.forEach((current) => {
+      store[current.getId()] = current;
+    });
+    let listStateChangeHandlers = [];
+    function shoutListStateChange() {
+      listStateChangeHandlers.forEach((current) => current());
+    }
+    const elementChangeHandlers = {};
+    function shoutListElementChange(id) {
+      elementChangeHandlers[id]?.forEach((current) => current());
+    }
+    let listCountChangeHandlers = [];
+    function shoutListCountChange() {
+      listCountChangeHandlers.forEach((current) => current());
+    }
+    const onUpdateElementSuscriptions = {};
+    const addKey = `add${upper(name)}`;
+    addActions[addKey] = (newElement) => {
+      let elId = newElement.getId();
+      let lastProps = { ...newElement.props };
+      store[elId] = newElement;
+      const suscription = newElement.onUpdate(() => {
+        const id = newElement.getId();
+        if (id !== elId) {
+          if (store[id]) {
+            newElement.update(lastProps);
+            throw new Error(
+              `Cannot set new id ${id} because it already exists`
+            );
+          }
+          delete store[elId];
+          store[id] = newElement;
+          elId = id;
+          lastProps = newElement.props;
+        }
+        shoutListElementChange(id);
+        shoutListStateChange();
+      });
+      onUpdateElementSuscriptions[newElement.getId()] = suscription;
+      shoutListStateChange();
+      shoutListCountChange();
+      shoutListElementChange(elId);
+    };
+    const emptyKey = `empty${upper(name)}`;
+    emptyActions[emptyKey] = () => {
+      Object.values(onUpdateElementSuscriptions).forEach(
+        (current) => current()
+      );
+      store = {};
+      shoutListCountChange();
+      shoutListStateChange();
+      Object.keys(elementChangeHandlers).forEach(
+        (current) => shoutListElementChange(current)
+      );
+    };
+    const removeKey = `remove${upper(name)}`;
+    removeActions[removeKey] = (id) => {
+      onUpdateElementSuscriptions[id]?.();
+      delete store[id];
+      shoutListCountChange();
+      shoutListStateChange();
+      shoutListElementChange(id);
+    };
+    const updateListKey = `update${upper(
+      name
+    )}List`;
+    updateListActions[updateListKey] = (list) => {
+      store[name] = list;
+      shoutListCountChange();
+      shoutListStateChange();
+    };
+    const getStateKey = `get${upper(name)}State`;
+    getStateActions[getStateKey] = () => {
+      return Object.values(store);
+    };
+    const getState = getStateActions[getStateKey];
+    const getItemKey = `get${upper(name)}`;
+    getItemActions[getItemKey] = (id) => {
+      return store[id];
+    };
+    const updateItemKey = `update${upper(name)}`;
+    updateItemActions[updateItemKey] = (id, newProps) => {
+      store[id].update(newProps);
+    };
+    const hookUseStateKey = `use${upper(name)}`;
+    hookUseState[hookUseStateKey] = () => {
+      const [state2, setState] = useState(getState());
+      useMount(() => {
+        setState(getState());
+        const eventHandler = () => {
+          setState(getState());
+        };
+        listStateChangeHandlers.push(eventHandler);
+        return () => {
+          listStateChangeHandlers = listStateChangeHandlers.filter(
+            (current) => current !== eventHandler
+          );
+        };
+      });
+      return state2;
+    };
+    const hookUseListKey = `use${upper(name)}List`;
+    hookUseList[hookUseListKey] = () => {
+      const [state2, setState] = useState(getState());
+      useMount(() => {
+        setState(getState());
+        const eventHandler = () => {
+          setState(getState());
+        };
+        listCountChangeHandlers.push(eventHandler);
+        return () => {
+          listCountChangeHandlers = listCountChangeHandlers.filter(
+            (current) => current !== eventHandler
+          );
+        };
+      });
+      return state2;
+    };
+    const hookUseStateByIdKey = `use${upper(
+      name
+    )}ById`;
+    hookUseStateById[hookUseStateByIdKey] = (id) => {
+      const [state2, setState] = useState({ obj: store[id] });
+      useMount(() => {
+        setState({ obj: store[id] });
+        const eventHandler = () => {
+          setState({ obj: store[id] });
+        };
+        if (!elementChangeHandlers[id])
+          elementChangeHandlers[id] = [];
+        elementChangeHandlers[id].push(eventHandler);
+        return () => {
+          elementChangeHandlers[id] = elementChangeHandlers[id].filter(
+            (current) => current !== eventHandler
+          );
+        };
+      });
+      return state2.obj;
+    };
+    const onChangeElementKey = `change${upper(
+      name
+    )}Element`;
+    suscribeById[onChangeElementKey] = (id, cb) => {
+      if (!elementChangeHandlers[id])
+        elementChangeHandlers[id] = [];
+      const innerCb = () => {
+        cb(store[id]);
+      };
+      elementChangeHandlers[id].push(innerCb);
+      return () => {
+        elementChangeHandlers[id] = elementChangeHandlers[id].filter(
+          (current) => current !== innerCb
+        );
+      };
+    };
+    const onChangeListKey = `change${upper(
+      name
+    )}`;
+    suscribeToList[onChangeListKey] = (cb) => {
+      const innerCb = () => {
+        cb(getState());
+      };
+      listStateChangeHandlers.push(innerCb);
+      return () => {
+        listStateChangeHandlers = listStateChangeHandlers.filter(
+          (current) => current !== innerCb
+        );
+      };
+    };
+    const onChangeListCountKey = `change${upper(
+      name
+    )}Ammount`;
+    suscribeToListCount[onChangeListCountKey] = (cb) => {
+      const innerCb = () => {
+        cb(getState());
+      };
+      listCountChangeHandlers.push(innerCb);
+      return () => {
+        listCountChangeHandlers = listCountChangeHandlers.filter(
+          (current) => current !== innerCb
+        );
+      };
+    };
+  });
+  const actions = Object.assign(
+    {},
+    addActions,
+    removeActions,
+    emptyActions,
+    updateListActions
+  );
+  const hooks = Object.assign({}, hookUseState, hookUseStateById, hookUseList);
+  const on = Object.assign(
+    {},
+    suscribeById,
+    suscribeToList,
+    suscribeToListCount
+  );
+  const state = Object.assign(
+    {},
+    getStateActions,
+    getItemActions,
+    updateItemActions
+  );
+  return Object.assign(
+    {},
+    { hooks },
+    { actions },
+    { state },
+    { on }
+  );
+}
+
+const persistentStorage = new Proxy(
+  {
+    remove(prop) {
+      localStorage.removeItem(prop);
+    }
+  },
+  {
+    get(_, prop) {
+      try {
+        const value = localStorage.getItem(String(prop));
+        if (!value)
+          return void 0;
+        return JSON.parse(value);
+      } catch {
+        return void 0;
+      }
+    },
+    set(_, prop, value) {
+      localStorage.setItem(String(prop), JSON.stringify(value));
+      return true;
+    }
+  }
+);
+window.persistentStorage = persistentStorage;
+var persistentStorage$1 = persistentStorage;
+
+const localStorageController = new class LocalSctorageController extends EventEmitter {
+}();
+function useLocalStorage(prop, defaultValue) {
+  const actualProp = useMemo(() => prop, []);
+  const storageValue = useMemo(
+    () => localStorage.getItem(actualProp),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const [value, setValue] = useState(
+    storageValue ? JSON.parse(storageValue) : defaultValue
+  );
+  useEffect(() => {
+    setValue(JSON.parse(storageValue));
+    return localStorageController.on("update", (ev) => {
+      if (ev.prop === actualProp) {
+        setValue(ev.value);
+        localStorage.setItem(actualProp, JSON.stringify(ev.value));
+      }
+    });
+  }, []);
+  return [
+    value,
+    useCallback(
+      (newValue) => {
+        localStorageController.emit("update", {
+          prop: actualProp,
+          value: newValue
+        });
+      },
+      [actualProp]
+    )
+  ];
+}
+
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _root, _props, _actualFocusQuery, _currentInstruction, _focusDelay, _focusRetries, _focusTimeout, _isIntervalRunning, _focusQuery, focusQuery_get, _checkInstruction, checkInstruction_fn, _doFocus, doFocus_fn, _resetInterval, resetInterval_fn, _runFocusInterval, runFocusInterval_fn, _a;
+const notificationsSelector = ".notification";
+const focus = new (_a = class {
+  constructor(root, props) {
+    __privateAdd(this, _focusQuery);
+    __privateAdd(this, _checkInstruction);
+    __privateAdd(this, _doFocus);
+    __privateAdd(this, _resetInterval);
+    __privateAdd(this, _runFocusInterval);
+    __privateAdd(this, _root, void 0);
+    __privateAdd(this, _props, void 0);
+    this.afterNotificationFocus = void 0;
+    __privateAdd(this, _actualFocusQuery, []);
+    __privateAdd(this, _currentInstruction, 0);
+    __privateAdd(this, _focusDelay, 300);
+    __privateAdd(this, _focusRetries, 3);
+    __privateAdd(this, _focusTimeout, -1);
+    __privateAdd(this, _isIntervalRunning, false);
+    this.focusOnReload = null;
+    __privateSet(this, _root, root);
+    __privateSet(this, _props, props);
+    window.focusStatus = {};
+    globalFocus.onFocus(() => {
+      __privateMethod(this, _resetInterval, resetInterval_fn).call(this);
+    });
+  }
+  /**
+   * Da la instrucción de colocar el foco en el elemento provisto como
+   * parámetro una vez que todas las notificaciones se hayan cerrado. En caso
+   * de no existir notificaciones abiertas, hace foco en el elemento
+   * directamente.
+   */
+  afterNotifications(element, configuration) {
+    if (!element)
+      return;
+    void this.on(element, configuration);
+  }
+  /**
+   * Da la instrucción de colocar el foco en el elemento provisto como
+   * parámetro luego de recargar la página.
+   *
+   * Los parámetros pasados serán ordenados en orden de importancia priorizando
+   * en el siguiente orden:
+   * - id
+   * - name
+   * - className
+   * - selector
+   */
+  afterReload({
+    className,
+    id,
+    name,
+    selector
+  }) {
+    persistentStorage$1.focusOnReload = [
+      id ? `#${id}` : void 0,
+      name ? `[name="${name}"]` : void 0,
+      className ? `.${className}` : void 0,
+      selector
+    ].filter((el) => el !== void 0).join(",");
+  }
+  /**
+   * Da la instrucción de colocar el foco el elemento pasado como parámetro.
+   * Se puede pasar también una función que devuelva HTMLElement | false |
+   * null.
+   *
+   * El segundo parámetro del método on es un objeto de tipo
+   * ScrollIntoViewOptions, que permite modificar el comportamiento del scroll
+   * a en el elemento.
+   *
+   * @see TFocusRetriever para más detalles sobre la función como parámetro.
+   */
+  async on(element, configuration) {
+    if (element) {
+      const focusElement = {
+        element,
+        configuration
+      };
+      for (let i = 0; i < __privateGet(this, _focusRetries); i++)
+        __privateGet(this, _focusQuery, focusQuery_get).unshift(focusElement);
+      __privateMethod(this, _resetInterval, resetInterval_fn).call(this);
+      return __privateMethod(this, _runFocusInterval, runFocusInterval_fn).call(this, focusElement);
+    }
+    return false;
+  }
+  restore() {
+    void this.on(
+      globalFocus.last(":not(body), body#tinymce") || document.querySelector(focusSelector)
+    );
+  }
+  init() {
+    const modalsObserver = new MutationObserver((mutation) => {
+      if (mutation[0].removedNodes.length === 0)
+        return;
+      this.afterNotifications(
+        globalFocus.last(
+          ":not(body):not(.notificationsView *), body#tinymce"
+        )
+      );
+    });
+    const appModalsBox = (__privateGet(this, _props)?.modalsContainerRetriever ?? (() => __privateGet(this, _root).querySelector("#AppModals")))();
+    if (appModalsBox)
+      modalsObserver.observe(appModalsBox, { childList: true });
+    screenLocker.on("releaseForFirstTime", () => {
+      if (persistentStorage$1.focusOnReload)
+        this.focusOnReload = persistentStorage$1.focusOnReload;
+      persistentStorage$1.focusOnReload = null;
+      this.afterNotifications(() => {
+        if (this.focusOnReload) {
+          const initialFocusElement = document.querySelector(
+            this.focusOnReload
+          );
+          const scrollTop = noNaN(
+            window.CURRENT_TAB?.split(
+              "~"
+            )[1]
+          );
+          if (document.scrollingElement)
+            document.scrollingElement.scrollTop = scrollTop;
+          return initialFocusElement;
+        }
+        return false;
+      });
+    });
+  }
+}, _root = new WeakMap(), _props = new WeakMap(), _actualFocusQuery = new WeakMap(), _currentInstruction = new WeakMap(), _focusDelay = new WeakMap(), _focusRetries = new WeakMap(), _focusTimeout = new WeakMap(), _isIntervalRunning = new WeakMap(), _focusQuery = new WeakSet(), focusQuery_get = function() {
+  return new Proxy(__privateGet(this, _actualFocusQuery), {
+    get: (target, key) => {
+      if (key in target) {
+        const prop = target[key];
+        if (isFunction(prop))
+          return (...props) => {
+            const result = target[key].bind(target, ...props)();
+            return result;
+          };
+        return prop;
+      }
+      return void 0;
+    }
+  });
+}, _checkInstruction = new WeakSet(), checkInstruction_fn = function(focusCheck) {
+  return focusCheck.currentInstruction === __privateGet(this, _currentInstruction);
+}, _doFocus = new WeakSet(), doFocus_fn = async function(HTMLElement, focusCheck, isLastTry, configuration) {
+  if (screenLocker.isLocked("common") && !configuration?.focusEvenWhenScreenLocked) {
+    return null;
+  }
+  const actualHTMLElement = isFunction(HTMLElement) ? HTMLElement(isLastTry) : HTMLElement;
+  if (actualHTMLElement) {
+    if (actualHTMLElement.disabled)
+      return false;
+    actualHTMLElement.focus();
+    return new Promise((resolve) => {
+      if (configuration?.dispatchCustomEvent !== false) {
+        const customFocusEvent = new CustomEvent(customEvents.focus, {
+          bubbles: true
+        });
+        actualHTMLElement.dispatchEvent(customFocusEvent);
+      }
+      setTimeout(() => {
+        if (!__privateMethod(this, _checkInstruction, checkInstruction_fn).call(this, focusCheck)) {
+          resolve(false);
+          return;
+        }
+        try {
+          if (configuration?.scrollIntoViewOptions)
+            actualHTMLElement?.scrollIntoView(
+              configuration.scrollIntoViewOptions
+            );
+        } catch (e) {
+          console.error(e);
+        }
+        setTimeout(() => {
+          if (!__privateMethod(this, _checkInstruction, checkInstruction_fn).call(this, focusCheck)) {
+            resolve(false);
+          } else if (document.activeElement?.tagName === "IFRAME") {
+            resolve(
+              document.activeElement.contentDocument?.contains(actualHTMLElement) ? actualHTMLElement : null
+            );
+          } else
+            resolve(
+              document.activeElement === actualHTMLElement ? actualHTMLElement : null
+            );
+        }, 0);
+      }, 0);
+    });
+  }
+  return actualHTMLElement;
+}, _resetInterval = new WeakSet(), resetInterval_fn = function() {
+  clearTimeout(__privateGet(this, _focusTimeout));
+  __privateSet(this, _focusTimeout, -1);
+  __privateSet(this, _isIntervalRunning, false);
+  __privateWrapper(this, _currentInstruction)._++;
+}, _runFocusInterval = new WeakSet(), runFocusInterval_fn = async function(focusElement, internalCall) {
+  if (!internalCall && (__privateGet(this, _focusTimeout) !== -1 || __privateGet(this, _isIntervalRunning)))
+    return false;
+  const currentInstruction = {
+    currentInstruction: __privateGet(this, _currentInstruction)
+  };
+  __privateSet(this, _isIntervalRunning, true);
+  return new Promise((resolve) => {
+    const resolvePromise = async () => {
+      const element = focusElement ?? __privateGet(this, _focusQuery, focusQuery_get).shift();
+      if (element) {
+        const hasFocused = await __privateMethod(this, _doFocus, doFocus_fn).call(this, element.element, currentInstruction, element !== __privateGet(this, _focusQuery, focusQuery_get)[0], element.configuration);
+        if (!__privateMethod(this, _checkInstruction, checkInstruction_fn).call(this, currentInstruction)) {
+          resolve(false);
+          return;
+        }
+        if (hasFocused !== null && hasFocused !== false) {
+          __privateSet(this, _actualFocusQuery, []);
+          resolve(hasFocused);
+          __privateSet(this, _isIntervalRunning, false);
+          return;
+        }
+        if (hasFocused === false) {
+          __privateSet(this, _actualFocusQuery, __privateGet(this, _actualFocusQuery).filter(
+            (current) => current !== element
+          ));
+        }
+      }
+      if (!__privateMethod(this, _checkInstruction, checkInstruction_fn).call(this, currentInstruction)) {
+        resolve(false);
+        return;
+      }
+      if (__privateGet(this, _actualFocusQuery).length > 0) {
+        __privateSet(this, _focusTimeout, setTimeout(() => {
+          const runInterval = async () => {
+            const result = await __privateMethod(this, _runFocusInterval, runFocusInterval_fn).call(this, void 0, true);
+            resolve(result);
+            __privateSet(this, _isIntervalRunning, true);
+          };
+          void runInterval();
+        }, __privateGet(this, _focusDelay)));
+      } else {
+        const lastFocused = globalFocus.last(":not(body)");
+        if (lastFocused) {
+          const result = await __privateMethod(this, _doFocus, doFocus_fn).call(this, lastFocused, currentInstruction, element !== __privateGet(this, _focusQuery, focusQuery_get)[0], element?.configuration);
+          if (!__privateMethod(this, _checkInstruction, checkInstruction_fn).call(this, currentInstruction)) {
+            resolve(false);
+            return;
+          }
+          if (result)
+            resolve(result);
+          else
+            resolve(false);
+          __privateSet(this, _isIntervalRunning, true);
+        }
+        resolve(false);
+        __privateSet(this, _isIntervalRunning, true);
+      }
+    };
+    void resolvePromise();
+  });
+}, _a)(document.getElementById("root"));
+
+class History extends EventEmitter {
+  constructor(onCloseWindow, configuration = { maxLength: 100 }) {
+    super();
+    this.configuration = configuration;
+    this.autocloseTimeout = -1;
+    this.currentStep = 0;
+    this.content = [];
+    this.emitting = 0;
+    this.enabled = true;
+    this._isOpen = false;
+    this.timeoutMs = 350;
+    this.closeWindow = () => {
+      if (this._isOpen) {
+        this.onCloseWindow(this.push.bind(this));
+        this._isOpen = false;
+      }
+    };
+    this.getEvent = () => {
+      const stepCount = this.content.length - 1;
+      const event = {
+        content: this.content[this.currentStep],
+        currentStep: this.currentStep,
+        stepCount,
+        hasNext: this.currentStep < stepCount,
+        hasPrevious: this.currentStep >= 0
+      };
+      return event;
+    };
+    this.push = (el) => {
+      this.content = [...this.content.slice(0, this.currentStep + 1), el];
+      this.content = this.content.slice(
+        Math.max(0, this.content.length - this.configuration.maxLength)
+      );
+      this.currentStep = this.content.length - 1;
+      this.shoutStepChange(true);
+    };
+    this.shoutStepChange = (fromPush) => {
+      try {
+        this.emit("stepChange", { ...this.getEvent(), fromPush });
+      } catch (e) {
+        console.error(e);
+      }
+    };
+    this.hooks = {
+      useCountChange: (onChange) => {
+        useMount(() => {
+          onChange(this.getEvent());
+          this.on("stepChange", () => {
+            onChange(this.getEvent());
+          });
+        });
+      }
+    };
+    this.back = () => {
+      clearTimeout(this.autocloseTimeout);
+      if (this.currentStep >= 0) {
+        this.currentStep -= 1;
+        this.shoutStepChange();
+      }
+    };
+    this.disable = () => {
+      this.enabled = false;
+    };
+    this.enable = () => {
+      this.enabled = true;
+    };
+    this.forward = () => {
+      clearTimeout(this.autocloseTimeout);
+      if (this.currentStep < this.content.length - 1) {
+        this.currentStep += 1;
+        this.shoutStepChange();
+      }
+    };
+    this.openWindow = () => {
+      if (!this.enabled || this.emitting !== 0)
+        return;
+      this._isOpen = true;
+      clearTimeout(this.autocloseTimeout);
+      this.autocloseTimeout = setTimeout(() => {
+        this.closeWindow();
+      }, this.timeoutMs);
+    };
+    this.reset = () => {
+      clearTimeout(this.autocloseTimeout);
+      this.content = [];
+      this.currentStep = -1;
+      this.openWindow();
+    };
+    this.updateConfig = (newConfiguration) => {
+      this.configuration = { ...this.configuration, ...newConfiguration };
+    };
+    this.useStep = () => {
+      const [hasPrevious, setHasPrevious] = useState({ hasNext: false, hasPrevious: false, currentStep: 0 });
+      useMount(() => {
+        return this.on("stepChange", (ev) => {
+          setHasPrevious({
+            currentStep: ev.currentStep,
+            hasNext: ev.hasNext,
+            hasPrevious: ev.hasPrevious
+          });
+        });
+      });
+      return hasPrevious;
+    };
+    this.onCloseWindow = onCloseWindow;
+  }
+  emit(eventName, params) {
+    this.emitting++;
+    super.emit(eventName, params);
+    this.emitting--;
+  }
+  get isOpen() {
+    return this._isOpen;
+  }
+}
+
+const ImperativeComponentContext = createContext(
+  {}
+);
+
+function makeImperativeComponent() {
+  return function ImperativeComponent({
+    Component,
+    initialState,
+    methods
+  }) {
+    const setStates = {};
+    const actualMethods = {};
+    Object.entries(methods ?? {}).forEach(([key, method]) => {
+      actualMethods[key] = (id, ...args) => {
+        if (setStates[id]) {
+          method(setStates[id], ...args);
+          return true;
+        } else {
+          return false;
+        }
+      };
+    });
+    const eventsHandlers = {};
+    const fireEvent = (id, ev, args) => {
+      if (eventsHandlers[id]) {
+        eventsHandlers[id]?.[ev]?.forEach((current) => current.cb(args));
+        return true;
+      } else {
+        return false;
+      }
+    };
+    const ActualComponent = ({
+      id,
+      ...props
+    }) => {
+      const [state, innerSetState] = useState(initialState);
+      setStates[id] = (newState) => innerSetState((current) => ({ ...current, ...newState }));
+      return /* @__PURE__ */ jsx(
+        ImperativeComponentContext.Provider,
+        {
+          value: useMemo(() => ({ id, eventsStore: eventsHandlers }), [id]),
+          children: /* @__PURE__ */ jsx(Component, { ...props, ...state })
+        }
+      );
+    };
+    return [actualMethods, fireEvent, ActualComponent];
+  };
+}
+
+function makeSingleImperativeComponent() {
+  return function SingleImperativeComponent({
+    initialState,
+    methods,
+    Component
+  }) {
+    const id = uniqueId();
+    const [actualMethods, originalFireEvent, ImperativeComponent] = makeImperativeComponent()({
+      initialState,
+      methods,
+      Component
+    });
+    const fireEvent = (ev, args) => originalFireEvent(id, ev, args);
+    const newMethods = {};
+    Object.entries(actualMethods).forEach(([name, method]) => {
+      newMethods[name] = (...args) => method(id, ...args);
+    });
+    return [
+      newMethods,
+      fireEvent,
+      (props) => /* @__PURE__ */ jsx(ImperativeComponent, { ...props, id })
+    ];
+  };
+}
+
+function useImperativeComponentContext() {
+  const context = useContext(ImperativeComponentContext);
+  return context;
+}
+
+const useImperativeComponentEvents = (handlers) => {
+  const uniqueHookId = useMemo(() => uniqueId("hook"), []);
+  const { id, eventsStore } = useImperativeComponentContext();
+  const hasRegistered = useRef(false);
+  const registerEvents = useCallback(() => {
+    Object.entries(handlers).forEach(([name, callback]) => {
+      if (!eventsStore[id])
+        eventsStore[id] = {};
+      if (!eventsStore[id][name])
+        eventsStore[id][name] = [];
+      eventsStore[id][name]?.push({
+        cb: callback,
+        uniqueHookId
+      });
+    });
+  }, [eventsStore, handlers, id, uniqueHookId]);
+  useEffect(() => {
+    registerEvents();
+    return () => {
+      hasRegistered.current = false;
+      Object.entries(handlers).forEach(([name]) => {
+        eventsStore[id][name] = (eventsStore[id][name] ?? []).filter((current) => current.uniqueHookId !== uniqueHookId);
+      });
+    };
+  }, [eventsStore, handlers, id, registerEvents, uniqueHookId]);
+  return uniqueHookId;
+};
+var useImperativeComponentEvents$1 = useImperativeComponentEvents;
+
+const formatMessage = (str, obj) => {
+  let newStr = str;
+  Object.entries(obj).forEach(([key, value]) => {
+    const placeHolder = `<${key}>`;
+    if (newStr?.includes(placeHolder)) {
+      newStr = newStr.replace(placeHolder, value ?? "");
+    }
+  });
+  return newStr;
+};
+
+function getLabel(name, replaceTokens) {
+  const label = {
+    ...window.labels[name] ?? {
+      text: `Not preloaded: ${name}`,
+      tooltip: `Not preloaded: ${name}`
+    }
+  };
+  if (replaceTokens?.text !== void 0)
+    label.text = formatMessage(label.text, replaceTokens.text);
+  if (replaceTokens?.title !== void 0)
+    label.tooltip = formatMessage(label.tooltip, replaceTokens.title);
+  return label;
+}
+
+function getValueByPath(obj, path, separator = ".") {
+  const actualPath = typeof path === "string" ? path.split(separator) : path;
+  if (typeof obj !== "object" || !obj) {
+    if (actualPath.length === 0)
+      return obj;
+    return void 0;
+  }
+  const currentStep = actualPath.shift();
+  if (actualPath.length === 0)
+    return obj[currentStep];
+  return getValueByPath(
+    obj[currentStep],
+    actualPath,
+    separator
+  );
+}
+
+function setValueByPath(obj, path, value) {
+  if (path === "")
+    return value;
+  const steps = path.split(".");
+  if (steps.length === 0) {
+    console.warn(`An empty path was provoided ${path}`);
+    return null;
+  }
+  const originalClonedObject = clone(obj ?? {});
+  let currentObj = originalClonedObject;
+  for (let i = 0; i < steps.length - 1; i++) {
+    if (!currentObj[steps[i]])
+      currentObj[steps[i]] = {};
+    if (typeof currentObj[steps[i]] === "object") {
+      currentObj = currentObj[steps[i]];
+    } else {
+      console.info({
+        originalObject: obj,
+        originalPath: path,
+        currentObj,
+        currentStep: steps[i]
+      });
+      throw new Error(
+        `The provided path ${path} cannot be applied due to it is not an object's path.`
+      );
+    }
+  }
+  currentObj[steps.pop()] = value;
+  return originalClonedObject;
+}
+
+const propsLog = "propsLog";
+const PropsSelectorUndefinedObject = {};
+class PropsStore {
+  constructor(configuration) {
+    this.configuration = configuration;
+    this.log = persistentStorage$1[propsLog];
+    this.fields = {};
+    this.suscriptors = {};
+    this.loggers = {
+      propsLog: ([log]) => {
+        this.log = log;
+        persistentStorage$1[propsLog] = log;
+      },
+      propsStore: ([fieldId]) => {
+        if (fieldId)
+          console.info(this.fields[fieldId]);
+        else
+          console.info(this.fields);
+      },
+      propsSuscriptors: ([fieldId]) => {
+        if (fieldId)
+          console.info(this.suscriptors[fieldId]);
+        else
+          console.info(this.suscriptors);
+      },
+      updateProp: ([fieldId, newProps]) => {
+        this.updateField(fieldId, newProps);
+      }
+    };
+    if (this.configuration) {
+      if (this.configuration.logCommands.propsStore)
+        debugDispatcher.on(
+          this.configuration.logCommands.propsStore,
+          this.loggers.propsStore,
+          "Muestra el contenido actual del propsStore"
+        );
+      if (this.configuration.logCommands.updateProp)
+        debugDispatcher.on(
+          this.configuration.logCommands.updateProp,
+          this.loggers.updateProp,
+          "dd.updateProp(fieldId, newProps). El objeto newProps ser\xE1 mergeado sobre las props actuales"
+        );
+      if (this.configuration.logCommands.propsSuscriptors)
+        debugDispatcher.on(
+          this.configuration.logCommands.propsSuscriptors,
+          this.loggers.propsSuscriptors,
+          "Muestra los suscriptores actuales del propsStore"
+        );
+      if (this.configuration.logCommands.propsLog)
+        debugDispatcher.on(
+          this.configuration.logCommands.propsLog,
+          this.loggers.propsLog,
+          "Si se pasa como true, hace log de las acciones. Si se pasa como trace(fieldId), se hace log de todas las acciones y trace del campo especificado. Si se pasa trace(), hace log y trace de todas las acciones."
+        );
+    }
+  }
+  destructor() {
+    if (this.configuration) {
+      if (this.configuration.logCommands.propsStore)
+        debugDispatcher.off(
+          this.configuration.logCommands.propsStore,
+          this.loggers.propsStore
+        );
+      if (this.configuration.logCommands.updateProp)
+        debugDispatcher.off(
+          this.configuration.logCommands.updateProp,
+          this.loggers.updateProp
+        );
+      if (this.configuration.logCommands.propsSuscriptors)
+        debugDispatcher.off(
+          this.configuration.logCommands.propsSuscriptors,
+          this.loggers.propsSuscriptors
+        );
+      if (this.configuration.logCommands.propsLog)
+        debugDispatcher.off(
+          this.configuration.logCommands.propsLog,
+          this.loggers.propsLog
+        );
+    }
+  }
+  getAllFields() {
+    return cloneDeep(this.fields);
+  }
+  /**
+   * Devuelve los props actuales de un campo.
+   */
+  getFieldProps(fieldId) {
+    return this.fields[fieldId];
+  }
+  removeField(fieldId) {
+    this.suscriptors[fieldId] = [];
+    delete this.fields[fieldId];
+    if (this.log)
+      console.info(`propsStore: removeNode ${fieldId}`);
+  }
+  /**
+   * Permite establecer un suscriptor que será llamado
+   * cada vez que las props del campo especificado cambien.
+   */
+  suscribe(fieldId, callback) {
+    if (!this.suscriptors[fieldId])
+      this.suscriptors[fieldId] = [];
+    this.suscriptors[fieldId].push(callback);
+    callback(this.fields[fieldId] ?? PropsSelectorUndefinedObject);
+    return () => {
+      this.suscriptors[fieldId] = this.suscriptors[fieldId].filter(
+        (current) => {
+          return current !== callback;
+        }
+      );
+    };
+  }
+  /**
+   * Actualiza o crea las props de un campo.
+   *
+   * La tercera prop está relacionada
+   */
+  updateField(fieldId, props, conf) {
+    if (fieldId === void 0)
+      return;
+    const { noEmit, isUrgent } = conf ?? {};
+    const newProps = { ...this.fields[fieldId], ...props };
+    this.fields[fieldId] = newProps;
+    if (this.log === true || this.log === fieldId)
+      console.info({ fieldId, props });
+    if (this.log === "trace")
+      console.trace();
+    else {
+      const logId = typeof this.log === "string" && (this.log.match(/trace\(([^)]+)\)/) ?? [])[1];
+      if (fieldId === logId)
+        console.trace();
+    }
+    if (!noEmit) {
+      this.suscriptors[fieldId]?.forEach((current) => {
+        return current(newProps, isUrgent);
+      });
+      this.suscriptors.any?.forEach((current) => {
+        return current({ ...newProps, fieldId }, isUrgent);
+      });
+    }
+  }
+}
+const propsStore = new PropsStore({
+  logCommands: {
+    propsLog: "propsLog",
+    propsStore: "propsStore",
+    propsSuscriptors: "propsSuscriptors",
+    updateProp: "updateProp"
+  }
+});
+
+const defaultComparator = (a, b) => {
+  return a === b;
+};
+function getDefaultSelector() {
+  return (current) => {
+    return current;
+  };
+}
+function isPropsConfigurationObject(value) {
+  return typeof value === "object" && value && ("selector" in value || "comparator" in value || "initialValue" in value);
+}
+function usePropsSelector(fieldId, par1, par2, par3) {
+  const selector = React__default.useMemo(
+    () => {
+      return isPropsConfigurationObject(par1) ? par1.selector : par1;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const comparator = React__default.useMemo(
+    () => {
+      return isPropsConfigurationObject(par1) ? par1.comparator : par2;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const initialValue = React__default.useMemo(
+    () => {
+      return isPropsConfigurationObject(par1) ? par1.initialValue : void 0;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const actualPropsStore = React__default.useMemo(
+    () => {
+      return par3 ?? (isPropsConfigurationObject(par1) ? par1.propsStore : propsStore) ?? propsStore;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      par3 ?? (isPropsConfigurationObject(par1) ? par1.propsStore : propsStore) ?? propsStore
+    ]
+  );
+  const getCurrentProps = React__default.useCallback(() => {
+    const currentProps = actualPropsStore.getFieldProps(fieldId);
+    const willSetInitialValue = currentProps !== void 0 && initialValue !== void 0;
+    if (willSetInitialValue) {
+      actualPropsStore.updateField(
+        fieldId,
+        initialValue
+      );
+    }
+    return (selector ?? getDefaultSelector())(
+      currentProps ?? PropsSelectorUndefinedObject
+    );
+  }, []);
+  const [props, setProps] = React__default.useState(getCurrentProps);
+  const prevProps = useRef(props);
+  const prevFieldId = useRef(fieldId);
+  React__default.useEffect(() => {
+    const unsuscribe = actualPropsStore.suscribe(
+      fieldId,
+      (newProps, isUrgent) => {
+        const newSelectedProps = (selector ?? getDefaultSelector())(
+          newProps
+        );
+        if (!(comparator ?? defaultComparator)(
+          prevProps.current,
+          newSelectedProps
+        ) || prevFieldId.current !== fieldId) {
+          if (isUrgent)
+            setProps(newSelectedProps);
+          else
+            React__default.startTransition(() => {
+              setProps(newSelectedProps);
+            });
+        }
+        prevProps.current = newSelectedProps;
+      }
+    );
+    return () => {
+      unsuscribe();
+    };
+  }, [fieldId, actualPropsStore, selector, comparator]);
+  return props;
+}
+
+function assignProps(el, { style, ...props }) {
+  if (style) {
+    Object.entries(style).forEach(([name, value]) => {
+      el.style[name] = value;
+    });
+  }
+  Object.assign(el, props);
+}
+function useDomState(initialDomProps) {
+  const domProps = React__default.useRef({
+    ...initialDomProps ?? {},
+    ref: React__default.useCallback((el) => {
+      ref.current = el;
+      assignProps(ref.current, domProps.current);
+    }, [])
+  });
+  const ref = React__default.useRef(null);
+  return {
+    domProps: domProps.current,
+    setDomProps: React__default.useCallback(({ style, ...newDomProps }) => {
+      if (style) {
+        const newStyles = { ...domProps.current.style, ...style };
+        domProps.current.style = newStyles;
+      }
+      Object.assign(domProps.current, newDomProps);
+      if (ref.current)
+        assignProps(ref.current, domProps.current);
+    }, [])
+  };
+}
+
+function useDebouncedState(timeout, initialState) {
+  const [state, innerSetState] = useState(initialState);
+  const t = useRef(-1);
+  const setState = useCallback(
+    (newState, immediate) => {
+      clearTimeout(t.current);
+      if (immediate)
+        innerSetState(newState);
+      else
+        t.current = setTimeout(() => {
+          innerSetState(newState);
+        }, timeout);
+    },
+    [timeout]
+  );
+  return [state, setState];
+}
+
+function alignment(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++)
+    dp[i][0] = i;
+  for (let j = 0; j <= n; j++)
+    dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        // deletion
+        dp[i][j - 1] + 1,
+        // insertion
+        dp[i - 1][j - 1] + cost
+        // substitution
+      );
+    }
+  }
+  return dp[m][n];
+}
+
+function ucfirst(word) {
+  return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+}
+
+function toBoolean(value) {
+  if (typeof value === "string") {
+    return !["false", ""].includes(value.toLowerCase());
+  }
+  if (Array.isArray(value))
+    return value.length > 0;
+  return !!value;
+}
+
+const processAjaxEventTagNames = (name) => {
+  return name;
+};
+const processAjaxEventAttrNames = (name) => {
+  return name;
+};
+const processAjaxEventResponse = (value, name) => {
+  if (name === "v" && value === "T")
+    return true;
+  if (name === "v" && value === "F")
+    return false;
+  return value;
+};
+const processStringObj = (value, key) => {
+  if (key === "value" && typeof value === "number" && Number.isNaN(value)) {
+    return "";
+  }
+  if (key === "valueType" && typeof value === "string" && value === "null") {
+    return "";
+  }
+  if ((key === "cols" || key === "rows" || key === "x" || key === "y" || key === "length") && typeof value === "string") {
+    return parseNumbers(value);
+  }
+  return value;
+};
+const parseXmlAsync = async (xml) => {
+  const parser = new xml2js.Parser({
+    trim: true,
+    normalize: true,
+    explicitRoot: false,
+    mergeAttrs: true,
+    explicitArray: false,
+    charkey: "content",
+    attrValueProcessors: [
+      parseBooleans,
+      processStringObj,
+      processAjaxEventResponse
+    ],
+    tagNameProcessors: [processAjaxEventTagNames],
+    attrNameProcessors: [processAjaxEventAttrNames]
+  });
+  const result = await new Promise((resolve, reject) => {
+    parser.parseString(xml, (err, innerResult) => {
+      if (err)
+        reject(err);
+      else {
+        resolve(innerResult);
+      }
+    });
+  });
+  return result;
+};
+
+export { BasicStoredElement, BouncingEmitter, EventEmitter, History, PropsSelectorUndefinedObject, PropsStore, StatefulEmitter, Url, addBoundary, alignment, animate, apiaDateToStandarFormat, arrayOrArray, autoDisconnectMutationObserver, cantFocusSelector, customEvents, dateToApiaFormat, debugDispatcher, decodeHTMLEntities, decrypt, defaultGetNameFromResponse, disableChildrenFocus, downloadStringAsDoc, downloadUrl, enableChildrenFocus, encrypt, findOffsetRelativeToScrollParent, findScrollContainer, focus, focusSelector, formatMessage, getDateFormat, getFocusSelector, getIndex, getLabel, getSpecificParent, getValueByPath, globalFocus, isChild, isDebugDispatcherEnabled, isPropsConfigurationObject, isSetter, makeImperativeComponent, makeSingleImperativeComponent, makeStatefulStore, noNaN, notificationsSelector, openAndReadFile, parseAsSize, parseXmlAsync, persistentStorage$1 as persistentStorage, propsStore, screenLocker, scrollParentIntoElement, setValueByPath, shallowCompareArrays, shallowEqual, shortcutController, toBoolean, ucfirst, useCombinedRefs, useDebouncedCallback, useDebouncedState, useDomState, useImperativeComponentContext, useImperativeComponentEvents$1 as useImperativeComponentEvents, useIntermediateValue, useLatest, useLocalStorage, useMount, usePanAndZoom, usePrevious, usePropsSelector, useShallowMemo, useStateRef, useSubscription, useUnmount, useUpdateEffect, useWhyUpdated };
 //# sourceMappingURL=index.js.map