@thednp/shorty 1.0.1 → 2.0.0-alpha1

package/dist/index.js

@@ -0,0 +1,1542 @@
+/*!
+* SHORTY v2.0.0alpha1 (https://github.com/thednp/shorty)
+* Copyright 2022 © dnp_theme
+* Licensed under MIT (https://github.com/thednp/shorty/blob/main/LICENSE)
+*/
+// src/strings/ariaChecked.ts
+var ariaChecked = "aria-checked";
+var ariaChecked_default = ariaChecked;
+
+// src/strings/ariaDescription.ts
+var ariaDescription = "aria-description";
+var ariaDescription_default = ariaDescription;
+
+// src/strings/ariaDescribedBy.ts
+var ariaDescribedBy = "aria-describedby";
+var ariaDescribedBy_default = ariaDescribedBy;
+
+// src/strings/ariaExpanded.ts
+var ariaExpanded = "aria-expanded";
+var ariaExpanded_default = ariaExpanded;
+
+// src/strings/ariaHasPopup.ts
+var ariaHasPopup = "aria-haspopup";
+var ariaHasPopup_default = ariaHasPopup;
+
+// src/strings/ariaHidden.ts
+var ariaHidden = "aria-hidden";
+var ariaHidden_default = ariaHidden;
+
+// src/strings/ariaLabel.ts
+var ariaLabel = "aria-label";
+var ariaLabel_default = ariaLabel;
+
+// src/strings/ariaLabelledBy.ts
+var ariaLabelledBy = "aria-labelledby";
+var ariaLabelledBy_default = ariaLabelledBy;
+
+// src/strings/ariaModal.ts
+var ariaModal = "aria-modal";
+var ariaModal_default = ariaModal;
+
+// src/strings/ariaPressed.ts
+var ariaPressed = "aria-pressed";
+var ariaPressed_default = ariaPressed;
+
+// src/strings/ariaSelected.ts
+var ariaSelected = "aria-selected";
+var ariaSelected_default = ariaSelected;
+
+// src/strings/ariaValueMin.ts
+var ariaValueMin = "aria-valuemin";
+var ariaValueMin_default = ariaValueMin;
+
+// src/strings/ariaValueMax.ts
+var ariaValueMax = "aria-valuemax";
+var ariaValueMax_default = ariaValueMax;
+
+// src/strings/ariaValueNow.ts
+var ariaValueNow = "aria-valuenow";
+var ariaValueNow_default = ariaValueNow;
+
+// src/strings/ariaValueText.ts
+var ariaValueText = "aria-valuetext";
+var ariaValueText_default = ariaValueText;
+
+// src/strings/abortEvent.ts
+var abortEvent = "abort";
+var abortEvent_default = abortEvent;
+
+// src/strings/beforeunloadEvent.ts
+var beforeunloadEvent = "beforeunload";
+var beforeunloadEvent_default = beforeunloadEvent;
+
+// src/strings/blurEvent.ts
+var blurEvent = "blur";
+var blurEvent_default = blurEvent;
+
+// src/strings/changeEvent.ts
+var changeEvent = "change";
+var changeEvent_default = changeEvent;
+
+// src/strings/contextmenuEvent.ts
+var contextmenuEvent = "contextmenu";
+var contextmenuEvent_default = contextmenuEvent;
+
+// src/strings/DOMContentLoadedEvent.ts
+var DOMContentLoadedEvent = "DOMContentLoaded";
+var DOMContentLoadedEvent_default = DOMContentLoadedEvent;
+
+// src/strings/DOMMouseScrollEvent.ts
+var DOMMouseScrollEvent = "DOMMouseScroll";
+var DOMMouseScrollEvent_default = DOMMouseScrollEvent;
+
+// src/strings/errorEvent.ts
+var errorEvent = "error";
+var errorEvent_default = errorEvent;
+
+// src/strings/focusEvent.ts
+var focusEvent = "focus";
+var focusEvent_default = focusEvent;
+
+// src/strings/focusinEvent.ts
+var focusinEvent = "focusin";
+var focusinEvent_default = focusinEvent;
+
+// src/strings/focusoutEvent.ts
+var focusoutEvent = "focusout";
+var focusoutEvent_default = focusoutEvent;
+
+// src/strings/gesturechangeEvent.ts
+var gesturechangeEvent = "gesturechange";
+var gesturechangeEvent_default = gesturechangeEvent;
+
+// src/strings/gestureendEvent.ts
+var gestureendEvent = "gestureend";
+var gestureendEvent_default = gestureendEvent;
+
+// src/strings/gesturestartEvent.ts
+var gesturestartEvent = "gesturestart";
+var gesturestartEvent_default = gesturestartEvent;
+
+// src/strings/keydownEvent.ts
+var keydownEvent = "keydown";
+var keydownEvent_default = keydownEvent;
+
+// src/strings/keypressEvent.ts
+var keypressEvent = "keypress";
+var keypressEvent_default = keypressEvent;
+
+// src/strings/keyupEvent.ts
+var keyupEvent = "keyup";
+var keyupEvent_default = keyupEvent;
+
+// src/strings/loadEvent.ts
+var loadEvent = "load";
+var loadEvent_default = loadEvent;
+
+// src/strings/mouseclickEvent.ts
+var mouseclickEvent = "click";
+var mouseclickEvent_default = mouseclickEvent;
+
+// src/strings/mousedblclickEvent.ts
+var mousedblclickEvent = "dblclick";
+var mousedblclickEvent_default = mousedblclickEvent;
+
+// src/strings/mousedownEvent.ts
+var mousedownEvent = "mousedown";
+var mousedownEvent_default = mousedownEvent;
+
+// src/strings/mouseupEvent.ts
+var mouseupEvent = "mouseup";
+var mouseupEvent_default = mouseupEvent;
+
+// src/strings/mousehoverEvent.ts
+var mousehoverEvent = "hover";
+var mousehoverEvent_default = mousehoverEvent;
+
+// src/strings/mouseenterEvent.ts
+var mouseenterEvent = "mouseenter";
+var mouseenterEvent_default = mouseenterEvent;
+
+// src/strings/mouseleaveEvent.ts
+var mouseleaveEvent = "mouseleave";
+var mouseleaveEvent_default = mouseleaveEvent;
+
+// src/strings/mouseinEvent.ts
+var mouseinEvent = "mousein";
+var mouseinEvent_default = mouseinEvent;
+
+// src/strings/mouseoutEvent.ts
+var mouseoutEvent = "mouseout";
+var mouseoutEvent_default = mouseoutEvent;
+
+// src/strings/mouseoverEvent.ts
+var mouseoverEvent = "mouseover";
+var mouseoverEvent_default = mouseoverEvent;
+
+// src/strings/mousemoveEvent.ts
+var mousemoveEvent = "mousemove";
+var mousemoveEvent_default = mousemoveEvent;
+
+// src/strings/mousewheelEvent.ts
+var mousewheelEvent = "mousewheel";
+var mousewheelEvent_default = mousewheelEvent;
+
+// src/strings/moveEvent.ts
+var moveEvent = "move";
+var moveEvent_default = moveEvent;
+
+// src/strings/orientationchangeEvent.ts
+var orientationchangeEvent = "orientationchange";
+var orientationchangeEvent_default = orientationchangeEvent;
+
+// src/strings/pointercancelEvent.ts
+var pointercancelEvent = "pointercancel";
+var pointercancelEvent_default = pointercancelEvent;
+
+// src/strings/pointerdownEvent.ts
+var pointerdownEvent = "pointerdown";
+var pointerdownEvent_default = pointerdownEvent;
+
+// src/strings/pointerleaveEvent.ts
+var pointerleaveEvent = "pointerleave";
+var pointerleaveEvent_default = pointerleaveEvent;
+
+// src/strings/pointermoveEvent.ts
+var pointermoveEvent = "pointermove";
+var pointermoveEvent_default = pointermoveEvent;
+
+// src/strings/pointerupEvent.ts
+var pointerupEvent = "pointerup";
+var pointerupEvent_default = pointerupEvent;
+
+// src/strings/readystatechangeEvent.ts
+var readystatechangeEvent = "readystatechange";
+var readystatechangeEvent_default = readystatechangeEvent;
+
+// src/strings/resetEvent.ts
+var resetEvent = "reset";
+var resetEvent_default = resetEvent;
+
+// src/strings/resizeEvent.ts
+var resizeEvent = "resize";
+var resizeEvent_default = resizeEvent;
+
+// src/strings/selectEvent.ts
+var selectEvent = "select";
+var selectEvent_default = selectEvent;
+
+// src/strings/selectendEvent.ts
+var selectendEvent = "selectend";
+var selectendEvent_default = selectendEvent;
+
+// src/strings/selectstartEvent.ts
+var selectstartEvent = "selectstart";
+var selectstartEvent_default = selectstartEvent;
+
+// src/strings/scrollEvent.ts
+var scrollEvent = "scroll";
+var scrollEvent_default = scrollEvent;
+
+// src/strings/submitEvent.ts
+var submitEvent = "submit";
+var submitEvent_default = submitEvent;
+
+// src/strings/touchstartEvent.ts
+var touchstartEvent = "touchstart";
+var touchstartEvent_default = touchstartEvent;
+
+// src/strings/touchmoveEvent.ts
+var touchmoveEvent = "touchmove";
+var touchmoveEvent_default = touchmoveEvent;
+
+// src/strings/touchcancelEvent.ts
+var touchcancelEvent = "touchcancel";
+var touchcancelEvent_default = touchcancelEvent;
+
+// src/strings/touchendEvent.ts
+var touchendEvent = "touchend";
+var touchendEvent_default = touchendEvent;
+
+// src/strings/unloadEvent.ts
+var unloadEvent = "unload";
+var unloadEvent_default = unloadEvent;
+
+// src/strings/nativeEvents.ts
+var nativeEvents = {
+  DOMContentLoaded: DOMContentLoadedEvent_default,
+  DOMMouseScroll: DOMMouseScrollEvent_default,
+  abort: abortEvent_default,
+  beforeunload: beforeunloadEvent_default,
+  blur: blurEvent_default,
+  change: changeEvent_default,
+  click: mouseclickEvent_default,
+  contextmenu: contextmenuEvent_default,
+  dblclick: mousedblclickEvent_default,
+  error: errorEvent_default,
+  focus: focusEvent_default,
+  focusin: focusinEvent_default,
+  focusout: focusoutEvent_default,
+  gesturechange: gesturechangeEvent_default,
+  gestureend: gestureendEvent_default,
+  gesturestart: gesturestartEvent_default,
+  hover: mousehoverEvent_default,
+  keydown: keydownEvent_default,
+  keypress: keypressEvent_default,
+  keyup: keyupEvent_default,
+  load: loadEvent_default,
+  mousedown: mousedownEvent_default,
+  mousemove: mousemoveEvent_default,
+  mousein: mouseinEvent_default,
+  mouseout: mouseoutEvent_default,
+  mouseenter: mouseenterEvent_default,
+  mouseleave: mouseleaveEvent_default,
+  mouseover: mouseoverEvent_default,
+  mouseup: mouseupEvent_default,
+  mousewheel: mousewheelEvent_default,
+  move: moveEvent_default,
+  orientationchange: orientationchangeEvent_default,
+  pointercancel: pointercancelEvent_default,
+  pointerdown: pointerdownEvent_default,
+  pointerleave: pointerleaveEvent_default,
+  pointermove: pointermoveEvent_default,
+  pointerup: pointerupEvent_default,
+  readystatechange: readystatechangeEvent_default,
+  reset: resetEvent_default,
+  resize: resizeEvent_default,
+  scroll: scrollEvent_default,
+  select: selectEvent_default,
+  selectend: selectendEvent_default,
+  selectstart: selectstartEvent_default,
+  submit: submitEvent_default,
+  touchcancel: touchcancelEvent_default,
+  touchend: touchendEvent_default,
+  touchmove: touchmoveEvent_default,
+  touchstart: touchstartEvent_default,
+  unload: unloadEvent_default
+};
+var nativeEvents_default = nativeEvents;
+
+// src/strings/loadstartEvent.ts
+var loadstartEvent = "loadstart";
+var loadstartEvent_default = loadstartEvent;
+
+// src/strings/mouseSwipeEvents.ts
+var mouseSwipeEvents = {
+  start: "mousedown",
+  end: "mouseup",
+  move: "mousemove",
+  cancel: "mouseleave"
+};
+var mouseSwipeEvents_default = mouseSwipeEvents;
+
+// src/strings/mouseClickEvents.ts
+var mouseClickEvents = { down: "mousedown", up: "mouseup" };
+var mouseClickEvents_default = mouseClickEvents;
+
+// src/strings/mouseHoverEvents.ts
+var mouseHoverEvents = "onmouseleave" in document ? ["mouseenter", "mouseleave"] : ["mouseover", "mouseout"];
+var mouseHoverEvents_default = mouseHoverEvents;
+
+// src/strings/touchEvents.ts
+var touchEvents = {
+  start: "touchstart",
+  end: "touchend",
+  move: "touchmove",
+  cancel: "touchcancel"
+};
+var touchEvents_default = touchEvents;
+
+// src/strings/focusEvents.ts
+var focusEvents = { in: "focusin", out: "focusout" };
+var focusEvents_default = focusEvents;
+
+// src/strings/keyboardEventKeys.ts
+var keyboardEventKeys = {
+  Backspace: "Backspace",
+  Tab: "Tab",
+  Enter: "Enter",
+  Shift: "Shift",
+  Control: "Control",
+  Alt: "Alt",
+  Pause: "Pause",
+  CapsLock: "CapsLock",
+  Escape: "Escape",
+  Scape: "Space",
+  ArrowLeft: "ArrowLeft",
+  ArrowUp: "ArrowUp",
+  ArrowRight: "ArrowRight",
+  ArrowDown: "ArrowDown",
+  Insert: "Insert",
+  Delete: "Delete",
+  Meta: "Meta",
+  ContextMenu: "ContextMenu",
+  ScrollLock: "ScrollLock"
+};
+var keyboardEventKeys_default = keyboardEventKeys;
+
+// src/strings/keyAlt.ts
+var keyAlt = "Alt";
+var keyAlt_default = keyAlt;
+
+// src/strings/keyArrowDown.ts
+var keyArrowDown = "ArrowDown";
+var keyArrowDown_default = keyArrowDown;
+
+// src/strings/keyArrowUp.ts
+var keyArrowUp = "ArrowUp";
+var keyArrowUp_default = keyArrowUp;
+
+// src/strings/keyArrowLeft.ts
+var keyArrowLeft = "ArrowLeft";
+var keyArrowLeft_default = keyArrowLeft;
+
+// src/strings/keyArrowRight.ts
+var keyArrowRight = "ArrowRight";
+var keyArrowRight_default = keyArrowRight;
+
+// src/strings/keyBackspace.ts
+var keyBackspace = "Backspace";
+var keyBackspace_default = keyBackspace;
+
+// src/strings/keyCapsLock.ts
+var keyCapsLock = "CapsLock";
+var keyCapsLock_default = keyCapsLock;
+
+// src/strings/keyControl.ts
+var keyControl = "Control";
+var keyControl_default = keyControl;
+
+// src/strings/keyDelete.ts
+var keyDelete = "Delete";
+var keyDelete_default = keyDelete;
+
+// src/strings/keyEnter.ts
+var keyEnter = "Enter";
+var keyEnter_default = keyEnter;
+
+// src/strings/keyEscape.ts
+var keyEscape = "Escape";
+var keyEscape_default = keyEscape;
+
+// src/strings/keyInsert.ts
+var keyInsert = "Insert";
+var keyInsert_default = keyInsert;
+
+// src/strings/keyMeta.ts
+var keyMeta = "Meta";
+var keyMeta_default = keyMeta;
+
+// src/strings/keyPause.ts
+var keyPause = "Pause";
+var keyPause_default = keyPause;
+
+// src/strings/keyScrollLock.ts
+var keyScrollLock = "ScrollLock";
+var keyScrollLock_default = keyScrollLock;
+
+// src/strings/keyShift.ts
+var keyShift = "Shift";
+var keyShift_default = keyShift;
+
+// src/strings/keySpace.ts
+var keySpace = "Space";
+var keySpace_default = keySpace;
+
+// src/strings/keyTab.ts
+var keyTab = "Tab";
+var keyTab_default = keyTab;
+
+// src/strings/animationDuration.ts
+var animationDuration = "animationDuration";
+var animationDuration_default = animationDuration;
+
+// src/strings/animationDelay.ts
+var animationDelay = "animationDelay";
+var animationDelay_default = animationDelay;
+
+// src/strings/animationName.ts
+var animationName = "animationName";
+var animationName_default = animationName;
+
+// src/strings/animationEndEvent.ts
+var animationEndEvent = "animationend";
+var animationEndEvent_default = animationEndEvent;
+
+// src/strings/transitionDuration.ts
+var transitionDuration = "transitionDuration";
+var transitionDuration_default = transitionDuration;
+
+// src/strings/transitionDelay.ts
+var transitionDelay = "transitionDelay";
+var transitionDelay_default = transitionDelay;
+
+// src/strings/transitionEndEvent.ts
+var transitionEndEvent = "transitionend";
+var transitionEndEvent_default = transitionEndEvent;
+
+// src/strings/transitionProperty.ts
+var transitionProperty = "transitionProperty";
+var transitionProperty_default = transitionProperty;
+
+// src/strings/addEventListener.ts
+var addEventListener = "addEventListener";
+var addEventListener_default = addEventListener;
+
+// src/strings/removeEventListener.ts
+var removeEventListener = "removeEventListener";
+var removeEventListener_default = removeEventListener;
+
+// src/strings/bezierEasings.ts
+var bezierEasings = {
+  linear: "linear",
+  easingSinusoidalIn: "cubic-bezier(0.47,0,0.745,0.715)",
+  easingSinusoidalOut: "cubic-bezier(0.39,0.575,0.565,1)",
+  easingSinusoidalInOut: "cubic-bezier(0.445,0.05,0.55,0.95)",
+  easingQuadraticIn: "cubic-bezier(0.550,0.085,0.680,0.530)",
+  easingQuadraticOut: "cubic-bezier(0.250,0.460,0.450,0.940)",
+  easingQuadraticInOut: "cubic-bezier(0.455,0.030,0.515,0.955)",
+  easingCubicIn: "cubic-bezier(0.55,0.055,0.675,0.19)",
+  easingCubicOut: "cubic-bezier(0.215,0.61,0.355,1)",
+  easingCubicInOut: "cubic-bezier(0.645,0.045,0.355,1)",
+  easingQuarticIn: "cubic-bezier(0.895,0.03,0.685,0.22)",
+  easingQuarticOut: "cubic-bezier(0.165,0.84,0.44,1)",
+  easingQuarticInOut: "cubic-bezier(0.77,0,0.175,1)",
+  easingQuinticIn: "cubic-bezier(0.755,0.05,0.855,0.06)",
+  easingQuinticOut: "cubic-bezier(0.23,1,0.32,1)",
+  easingQuinticInOut: "cubic-bezier(0.86,0,0.07,1)",
+  easingExponentialIn: "cubic-bezier(0.95,0.05,0.795,0.035)",
+  easingExponentialOut: "cubic-bezier(0.19,1,0.22,1)",
+  easingExponentialInOut: "cubic-bezier(1,0,0,1)",
+  easingCircularIn: "cubic-bezier(0.6,0.04,0.98,0.335)",
+  easingCircularOut: "cubic-bezier(0.075,0.82,0.165,1)",
+  easingCircularInOut: "cubic-bezier(0.785,0.135,0.15,0.86)",
+  easingBackIn: "cubic-bezier(0.6,-0.28,0.735,0.045)",
+  easingBackOut: "cubic-bezier(0.175,0.885,0.32,1.275)",
+  easingBackInOut: "cubic-bezier(0.68,-0.55,0.265,1.55)"
+};
+var bezierEasings_default = bezierEasings;
+
+// src/strings/offsetHeight.ts
+var offsetHeight = "offsetHeight";
+var offsetHeight_default = offsetHeight;
+
+// src/strings/offsetWidth.ts
+var offsetWidth = "offsetWidth";
+var offsetWidth_default = offsetWidth;
+
+// src/strings/scrollHeight.ts
+var scrollHeight = "scrollHeight";
+var scrollHeight_default = scrollHeight;
+
+// src/strings/scrollWidth.ts
+var scrollWidth = "scrollWidth";
+var scrollWidth_default = scrollWidth;
+
+// src/strings/tabindex.ts
+var tabindex = "tabindex";
+var tabindex_default = tabindex;
+
+// src/strings/userAgentData.ts
+var uaDATA = navigator.userAgentData;
+var userAgentData = uaDATA;
+var userAgentData_default = userAgentData;
+
+// src/strings/userAgent.ts
+var { userAgent: userAgentString } = navigator;
+var userAgent = userAgentString;
+var userAgent_default = userAgent;
+
+// src/boolean/isMobile.ts
+var mobileBrands = /iPhone|iPad|iPod|Android/i;
+var isMobileCheck = false;
+if (userAgentData_default) {
+  isMobileCheck = userAgentData_default.brands.some((x) => mobileBrands.test(x.brand));
+} else {
+  isMobileCheck = mobileBrands.test(userAgent_default);
+}
+var isMobile = isMobileCheck;
+var isMobile_default = isMobile;
+
+// src/boolean/isApple.ts
+var appleBrands = /(iPhone|iPod|iPad)/;
+var isApple = userAgentData_default ? userAgentData_default.brands.some((x) => appleBrands.test(x.brand)) : appleBrands.test(userAgent_default);
+var isApple_default = isApple;
+
+// src/boolean/isFirefox.ts
+var isFirefox = userAgent_default ? userAgent_default.includes("Firefox") : false;
+var isFirefox_default = isFirefox;
+
+// src/blocks/documentHead.ts
+var { head: documentHead } = document;
+var documentHead_default = documentHead;
+
+// src/boolean/support3DTransform.ts
+var support3DTransform = ["webkitPerspective", "perspective"].some((p) => p in documentHead_default.style);
+var support3DTransform_default = support3DTransform;
+
+// src/event/on.ts
+function on(element, eventName, listener, options) {
+  const ops = options || false;
+  element.addEventListener(eventName, listener, ops);
+}
+
+// src/event/off.ts
+function off(element, eventName, listener, options) {
+  const ops = options || false;
+  element.removeEventListener(eventName, listener, ops);
+}
+
+// src/event/one.ts
+var one = (element, eventName, listener, options) => {
+  const handlerWrapper = (e) => {
+    if (e.target === element) {
+      listener.apply(element, [e]);
+      off(element, eventName, handlerWrapper, options);
+    }
+  };
+  on(element, eventName, handlerWrapper, options);
+};
+var one_default = one;
+
+// src/boolean/supportPassive.ts
+var supportPassive = (() => {
+  let result = false;
+  try {
+    const opts = Object.defineProperty({}, "passive", {
+      get() {
+        result = true;
+        return result;
+      }
+    });
+    one_default(document, DOMContentLoadedEvent_default, () => {
+    }, opts);
+  } catch (e) {
+  }
+  return result;
+})();
+var supportPassive_default = supportPassive;
+
+// src/boolean/supportTransform.ts
+var supportTransform = ["webkitTransform", "transform"].some((p) => p in documentHead_default.style);
+var supportTransform_default = supportTransform;
+
+// src/boolean/supportTouch.ts
+var supportTouch = "ontouchstart" in window || "msMaxTouchPoints" in navigator;
+var supportTouch_default = supportTouch;
+
+// src/boolean/supportAnimation.ts
+var supportAnimation = ["webkitAnimation", "animation"].some((p) => p in documentHead_default.style);
+var supportAnimation_default = supportAnimation;
+
+// src/boolean/supportTransition.ts
+var supportTransition = ["webkitTransition", "transition"].some((p) => p in documentHead_default.style);
+var supportTransition_default = supportTransition;
+
+// src/attr/getAttribute.ts
+var getAttribute = (element, att) => element.getAttribute(att);
+var getAttribute_default = getAttribute;
+
+// src/attr/getAttributeNS.ts
+var getAttributeNS = (ns, element, att) => element.getAttributeNS(ns, att);
+var getAttributeNS_default = getAttributeNS;
+
+// src/attr/hasAttribute.ts
+var hasAttribute = (element, att) => element.hasAttribute(att);
+var hasAttribute_default = hasAttribute;
+
+// src/attr/hasAttributeNS.ts
+var hasAttributeNS = (ns, element, att) => element.hasAttributeNS(ns, att);
+var hasAttributeNS_default = hasAttributeNS;
+
+// src/attr/setAttribute.ts
+var setAttribute = (element, att, value) => element.setAttribute(att, value);
+var setAttribute_default = setAttribute;
+
+// src/attr/setAttributeNS.ts
+var setAttributeNS = (ns, element, att, value) => element.setAttributeNS(ns, att, value);
+var setAttributeNS_default = setAttributeNS;
+
+// src/attr/removeAttribute.ts
+var removeAttribute = (element, att) => element.removeAttribute(att);
+var removeAttribute_default = removeAttribute;
+
+// src/attr/removeAttributeNS.ts
+var removeAttributeNS = (ns, element, att) => element.removeAttributeNS(ns, att);
+var removeAttributeNS_default = removeAttributeNS;
+
+// src/class/addClass.ts
+var addClass = (element, classNAME) => {
+  element.classList.add(classNAME);
+};
+var addClass_default = addClass;
+
+// src/class/removeClass.ts
+var removeClass = (element, classNAME) => {
+  element.classList.remove(classNAME);
+};
+var removeClass_default = removeClass;
+
+// src/class/hasClass.ts
+var hasClass = (element, classNAME) => {
+  return element.classList.contains(classNAME);
+};
+var hasClass_default = hasClass;
+
+// src/misc/ArrayFrom.ts
+var ArrayFrom = (arr) => Array.from(arr);
+var ArrayFrom_default = ArrayFrom;
+
+// src/is/isHTMLElement.ts
+var isHTMLElement = (element) => element && element.nodeType === 1 || false;
+var isHTMLElement_default = isHTMLElement;
+
+// src/misc/data.ts
+var componentData = /* @__PURE__ */ new Map();
+var Data = {
+  set: (element, component, instance) => {
+    if (!isHTMLElement_default(element))
+      return;
+    if (!componentData.has(component)) {
+      componentData.set(component, /* @__PURE__ */ new Map());
+    }
+    const instanceMap = componentData.get(component);
+    instanceMap.set(element, instance);
+  },
+  getAllFor: (component) => {
+    const instanceMap = componentData.get(component);
+    return instanceMap || null;
+  },
+  get: (element, component) => {
+    if (!isHTMLElement_default(element) || !component)
+      return null;
+    const allForC = Data.getAllFor(component);
+    const instance = element && allForC && allForC.get(element);
+    return instance || null;
+  },
+  remove: (element, component) => {
+    const instanceMap = componentData.get(component);
+    if (!instanceMap || !isHTMLElement_default(element))
+      return;
+    instanceMap.delete(element);
+    if (instanceMap.size === 0) {
+      componentData.delete(component);
+    }
+  }
+};
+var getInstance = (target, component) => Data.get(target, component);
+var data_default = Data;
+
+// src/is/isNode.ts
+var isNode = (node) => node && [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].some((x) => node.nodeType === x) || false;
+var isNode_default = isNode;
+
+// src/is/isWindow.ts
+var isWindow = (obj) => obj && obj.constructor.name === "Window" || false;
+var isWindow_default = isWindow;
+
+// src/is/isDocument.ts
+var isDocument = (obj) => obj && obj.nodeType === 9 || false;
+var isDocument_default = isDocument;
+
+// src/get/getDocument.ts
+var getDocument = (node) => {
+  if (isDocument_default(node))
+    return node;
+  if (isNode_default(node))
+    return node.ownerDocument;
+  if (isWindow_default(node))
+    return node.document;
+  return window.document;
+};
+var getDocument_default = getDocument;
+
+// src/misc/ObjectEntries.ts
+var ObjectEntries = (obj) => Object.entries(obj);
+var ObjectEntries_default = ObjectEntries;
+
+// src/misc/createElement.ts
+var createElement = (param) => {
+  if (!param)
+    return void 0;
+  if (typeof param === "string") {
+    return getDocument_default().createElement(param);
+  }
+  const { tagName } = param;
+  const newElement = createElement(tagName);
+  if (!newElement)
+    return void 0;
+  const attr = { ...param };
+  delete attr.tagName;
+  ObjectEntries_default(attr).forEach(([key, value]) => {
+    setAttribute_default(newElement, key, value);
+  });
+  return newElement;
+};
+var createElement_default = createElement;
+
+// src/misc/createElementNS.ts
+var createElementNS = (ns, param) => {
+  if (!ns && !param)
+    return void 0;
+  if (typeof param === "string") {
+    return getDocument_default().createElementNS(ns, param);
+  }
+  const { tagName } = param;
+  const newElement = createElementNS(ns, tagName);
+  if (!newElement)
+    return void 0;
+  const attr = { ...param };
+  delete attr.tagName;
+  ObjectEntries_default(attr).forEach(([key, value]) => {
+    setAttribute_default(newElement, key, value);
+  });
+  return newElement;
+};
+var createElementNS_default = createElementNS;
+
+// src/misc/dispatchEvent.ts
+var dispatchEvent = (element, event) => element.dispatchEvent(event);
+var dispatchEvent_default = dispatchEvent;
+
+// src/misc/distinct.ts
+var distinct = (value, index, self) => self.indexOf(value) === index;
+var distinct_default = distinct;
+
+// src/get/getElementStyle.ts
+var getElementStyle = (element, property) => {
+  const computedStyle = getComputedStyle(element);
+  return property.includes("--") ? computedStyle.getPropertyValue(property) : computedStyle[property];
+};
+var getElementStyle_default = getElementStyle;
+
+// src/get/getElementAnimationDelay.ts
+var getElementAnimationDelay = (element) => {
+  const propertyValue = getElementStyle_default(element, animationName_default);
+  const durationValue = getElementStyle_default(element, animationDelay_default);
+  const durationScale = durationValue.includes("ms") ? 1 : 1e3;
+  const duration = propertyValue && propertyValue !== "none" ? parseFloat(durationValue) * durationScale : 0;
+  return !Number.isNaN(duration) ? duration : 0;
+};
+var getElementAnimationDelay_default = getElementAnimationDelay;
+
+// src/get/getElementAnimationDuration.ts
+var getElementAnimationDuration = (element) => {
+  const propertyValue = getElementStyle_default(element, animationName_default);
+  const durationValue = getElementStyle_default(element, animationDuration_default);
+  const durationScale = durationValue.includes("ms") ? 1 : 1e3;
+  const duration = propertyValue && propertyValue !== "none" ? parseFloat(durationValue) * durationScale : 0;
+  return !Number.isNaN(duration) ? duration : 0;
+};
+var getElementAnimationDuration_default = getElementAnimationDuration;
+
+// src/misc/emulateAnimationEnd.ts
+var emulateAnimationEnd = (element, handler) => {
+  let called = 0;
+  const endEvent = new Event(animationEndEvent_default);
+  const duration = getElementAnimationDuration_default(element);
+  const delay = getElementAnimationDelay_default(element);
+  if (duration) {
+    const animationEndWrapper = (e) => {
+      if (e.target === element) {
+        handler.apply(element, [e]);
+        element.removeEventListener(animationEndEvent_default, animationEndWrapper);
+        called = 1;
+      }
+    };
+    element.addEventListener(animationEndEvent_default, animationEndWrapper);
+    setTimeout(() => {
+      if (!called)
+        dispatchEvent_default(element, endEvent);
+    }, duration + delay + 17);
+  } else {
+    handler.apply(element, [endEvent]);
+  }
+};
+var emulateAnimationEnd_default = emulateAnimationEnd;
+
+// src/get/getElementTransitionDelay.ts
+var getElementTransitionDelay = (element) => {
+  const propertyValue = getElementStyle_default(element, transitionProperty_default);
+  const delayValue = getElementStyle_default(element, transitionDelay_default);
+  const delayScale = delayValue.includes("ms") ? 1 : 1e3;
+  const duration = propertyValue && propertyValue !== "none" ? parseFloat(delayValue) * delayScale : 0;
+  return !Number.isNaN(duration) ? duration : 0;
+};
+var getElementTransitionDelay_default = getElementTransitionDelay;
+
+// src/get/getElementTransitionDuration.ts
+var getElementTransitionDuration = (element) => {
+  const propertyValue = getElementStyle_default(element, transitionProperty_default);
+  const durationValue = getElementStyle_default(element, transitionDuration_default);
+  const durationScale = durationValue.includes("ms") ? 1 : 1e3;
+  const duration = propertyValue && propertyValue !== "none" ? parseFloat(durationValue) * durationScale : 0;
+  return !Number.isNaN(duration) ? duration : 0;
+};
+var getElementTransitionDuration_default = getElementTransitionDuration;
+
+// src/misc/emulateTransitionEnd.ts
+var emulateTransitionEnd = (element, handler) => {
+  let called = 0;
+  const endEvent = new Event(transitionEndEvent_default);
+  const duration = getElementTransitionDuration_default(element);
+  const delay = getElementTransitionDelay_default(element);
+  if (duration) {
+    const transitionEndWrapper = (e) => {
+      if (e.target === element) {
+        handler.apply(element, [e]);
+        element.removeEventListener(transitionEndEvent_default, transitionEndWrapper);
+        called = 1;
+      }
+    };
+    element.addEventListener(transitionEndEvent_default, transitionEndWrapper);
+    setTimeout(() => {
+      if (!called)
+        dispatchEvent_default(element, endEvent);
+    }, duration + delay + 17);
+  } else {
+    handler.apply(element, [endEvent]);
+  }
+};
+var emulateTransitionEnd_default = emulateTransitionEnd;
+
+// src/misc/Float32ArrayFrom.ts
+var Float32ArrayFrom = (arr) => Float32Array.from(Array.from(arr));
+var Float32ArrayFrom_default = Float32ArrayFrom;
+
+// src/misc/Float64ArrayFrom.ts
+var Float64ArrayFrom = (arr) => Float64Array.from(Array.from(arr));
+var Float64ArrayFrom_default = Float64ArrayFrom;
+
+// src/misc/focus.ts
+var focus = (element) => element.focus();
+var focus_default = focus;
+
+// src/misc/noop.ts
+var noop = () => {
+};
+var noop_default = noop;
+
+// src/misc/normalizeValue.ts
+var normalizeValue = (value) => {
+  if (["true", true].includes(value)) {
+    return true;
+  }
+  if (["false", false].includes(value)) {
+    return false;
+  }
+  if (value === "" || value === "null") {
+    return null;
+  }
+  if (value !== "" && !Number.isNaN(+value)) {
+    return +value;
+  }
+  return value;
+};
+var normalizeValue_default = normalizeValue;
+
+// src/misc/ObjectKeys.ts
+var ObjectKeys = (obj) => Object.keys(obj);
+var ObjectKeys_default = ObjectKeys;
+
+// src/misc/toLowerCase.ts
+var toLowerCase = (source) => source.toLowerCase();
+var toLowerCase_default = toLowerCase;
+
+// src/misc/normalizeOptions.ts
+var normalizeOptions = (element, defaultOps, inputOps, ns) => {
+  const data = { ...element.dataset };
+  const normalOps = {};
+  const dataOps = {};
+  const title = "title";
+  ObjectKeys_default(data).forEach((k) => {
+    const key = ns && k.includes(ns) ? k.replace(ns, "").replace(/[A-Z]/, (match) => toLowerCase_default(match)) : k;
+    dataOps[key] = normalizeValue_default(data[k]);
+  });
+  ObjectKeys_default(inputOps).forEach((k) => {
+    inputOps[k] = normalizeValue_default(inputOps[k]);
+  });
+  ObjectKeys_default(defaultOps).forEach((k) => {
+    if (k in inputOps) {
+      normalOps[k] = inputOps[k];
+    } else if (k in dataOps) {
+      normalOps[k] = dataOps[k];
+    } else {
+      normalOps[k] = k === title ? getAttribute_default(element, title) : defaultOps[k];
+    }
+  });
+  return normalOps;
+};
+var normalizeOptions_default = normalizeOptions;
+
+// src/misc/ObjectAssign.ts
+var ObjectAssign = (obj, source) => Object.assign(obj, source);
+var ObjectAssign_default = ObjectAssign;
+
+// src/misc/ObjectValues.ts
+var ObjectValues = (obj) => Object.values(obj);
+var ObjectValues_default = ObjectValues;
+
+// src/is/isObject.ts
+var isObject = (obj) => typeof obj === "object" || false;
+var isObject_default = isObject;
+
+// src/misc/OriginalEvent.ts
+var OriginalEvent = (EventType, config) => {
+  const OriginalCustomEvent = new CustomEvent(EventType, {
+    cancelable: true,
+    bubbles: true
+  });
+  if (isObject_default(config)) {
+    ObjectAssign_default(OriginalCustomEvent, config);
+  }
+  return OriginalCustomEvent;
+};
+var OriginalEvent_default = OriginalEvent;
+
+// src/misc/passiveHandler.ts
+var passiveHandler = { passive: true };
+var passiveHandler_default = passiveHandler;
+
+// src/misc/reflow.ts
+var reflow = (element) => element.offsetHeight;
+var reflow_default = reflow;
+
+// src/misc/setElementStyle.ts
+var setElementStyle = (element, styles) => {
+  ObjectEntries_default(styles).forEach(([key, value]) => {
+    if (key.includes("--")) {
+      element.style.setProperty(key, value);
+    } else {
+      const propObject = {};
+      propObject[key] = value;
+      ObjectAssign_default(element.style, propObject);
+    }
+  });
+};
+var setElementStyle_default = setElementStyle;
+
+// src/misc/timer.ts
+var TimeCache = /* @__PURE__ */ new Map();
+var Timer = {
+  set: (element, callback, delay, key) => {
+    if (!isHTMLElement_default(element))
+      return;
+    if (key && key.length) {
+      if (!TimeCache.has(element)) {
+        TimeCache.set(element, /* @__PURE__ */ new Map());
+      }
+      const keyTimers = TimeCache.get(element);
+      keyTimers.set(key, setTimeout(callback, delay));
+    } else {
+      TimeCache.set(element, setTimeout(callback, delay));
+    }
+  },
+  get: (element, key) => {
+    if (!isHTMLElement_default(element))
+      return null;
+    const keyTimers = TimeCache.get(element);
+    if (key && key.length && keyTimers && keyTimers.get) {
+      return keyTimers.get(key) || null;
+    }
+    return keyTimers || null;
+  },
+  clear: (element, key) => {
+    if (!isHTMLElement_default(element))
+      return;
+    if (key && key.length) {
+      const keyTimers = TimeCache.get(element);
+      if (keyTimers && keyTimers.get) {
+        clearTimeout(keyTimers.get(key));
+        keyTimers.delete(key);
+        if (keyTimers.size === 0) {
+          TimeCache.delete(element);
+        }
+      }
+    } else {
+      clearTimeout(TimeCache.get(element));
+      TimeCache.delete(element);
+    }
+  }
+};
+var timer_default = Timer;
+
+// src/misc/toUpperCase.ts
+var toUpperCase = (source) => source.toUpperCase();
+var toUpperCase_default = toUpperCase;
+
+// src/get/getBoundingClientRect.ts
+var getBoundingClientRect = (element, includeScale) => {
+  const { width, height, top, right, bottom, left } = element.getBoundingClientRect();
+  let scaleX = 1;
+  let scaleY = 1;
+  if (includeScale && isHTMLElement_default(element)) {
+    const { offsetWidth: offsetWidth2, offsetHeight: offsetHeight2 } = element;
+    scaleX = offsetWidth2 > 0 ? Math.round(width) / offsetWidth2 : 1;
+    scaleY = offsetHeight2 > 0 ? Math.round(height) / offsetHeight2 : 1;
+  }
+  return {
+    width: width / scaleX,
+    height: height / scaleY,
+    top: top / scaleY,
+    right: right / scaleX,
+    bottom: bottom / scaleY,
+    left: left / scaleX,
+    x: left / scaleX,
+    y: top / scaleY
+  };
+};
+var getBoundingClientRect_default = getBoundingClientRect;
+
+// src/get/getDocumentBody.ts
+var getDocumentBody = (node) => {
+  return getDocument_default(node).body;
+};
+var getDocumentBody_default = getDocumentBody;
+
+// src/get/getDocumentElement.ts
+var getDocumentElement = (node) => {
+  return getDocument_default(node).documentElement;
+};
+var getDocumentElement_default = getDocumentElement;
+
+// src/get/getDocumentHead.ts
+var getDocumentHead = (node) => {
+  return getDocument_default(node).head;
+};
+var getDocumentHead_default = getDocumentHead;
+
+// src/get/getNodeScroll.ts
+var getNodeScroll = (element) => {
+  const isWin = isWindow_default(element);
+  const x = isWin ? element.scrollX : element.scrollLeft;
+  const y = isWin ? element.scrollY : element.scrollTop;
+  return { x, y };
+};
+var getNodeScroll_default = getNodeScroll;
+
+// src/is/isShadowRoot.ts
+var isShadowRoot = (element) => element && element.constructor.name === "ShadowRoot" || false;
+var isShadowRoot_default = isShadowRoot;
+
+// src/get/getParentNode.ts
+var getParentNode = (node) => {
+  if (node.nodeName === "HTML") {
+    return node;
+  }
+  return node.assignedSlot || node.parentNode || isShadowRoot_default(node) && node.host || getDocumentElement_default(node);
+};
+var getParentNode_default = getParentNode;
+
+// src/is/isScaledElement.ts
+function isScaledElement(element) {
+  if (!isHTMLElement_default(element))
+    return false;
+  const { width, height } = getBoundingClientRect_default(element);
+  const { offsetWidth: offsetWidth2, offsetHeight: offsetHeight2 } = element;
+  return Math.round(width) !== offsetWidth2 || Math.round(height) !== offsetHeight2;
+}
+
+// src/get/getRectRelativeToOffsetParent.ts
+var getRectRelativeToOffsetParent = (element, offsetParent, scroll) => {
+  const isParentAnElement = isHTMLElement_default(offsetParent);
+  const rect = getBoundingClientRect_default(element, isParentAnElement && isScaledElement(offsetParent));
+  const offsets = { x: 0, y: 0 };
+  if (isParentAnElement) {
+    const offsetRect = getBoundingClientRect_default(offsetParent, true);
+    offsets.x = offsetRect.x + offsetParent.clientLeft;
+    offsets.y = offsetRect.y + offsetParent.clientTop;
+  }
+  return {
+    x: rect.left + scroll.x - offsets.x,
+    y: rect.top + scroll.y - offsets.y,
+    width: rect.width,
+    height: rect.height
+  };
+};
+var getRectRelativeToOffsetParent_default = getRectRelativeToOffsetParent;
+
+// src/get/getUID.ts
+var elementUID = 0;
+var elementMapUID = 0;
+var elementIDMap = /* @__PURE__ */ new Map();
+var getUID = (element, key) => {
+  let result = key ? elementUID : elementMapUID;
+  if (key) {
+    const elID = getUID(element);
+    const elMap = elementIDMap.get(elID) || /* @__PURE__ */ new Map();
+    if (!elementIDMap.has(elID)) {
+      elementIDMap.set(elID, elMap);
+    }
+    if (!elMap.has(key)) {
+      elMap.set(key, result);
+      elementUID += 1;
+    } else
+      result = elMap.get(key);
+  } else {
+    const elkey = element.id || element;
+    if (!elementIDMap.has(elkey)) {
+      elementIDMap.set(elkey, result);
+      elementMapUID += 1;
+    } else
+      result = elementIDMap.get(elkey);
+  }
+  return result;
+};
+var getUID_default = getUID;
+
+// src/get/getWindow.ts
+var getWindow = (node) => {
+  if (!node)
+    return window;
+  if (isDocument_default(node))
+    return node.defaultView;
+  if (isNode_default(node))
+    return node.ownerDocument.defaultView;
+  return node;
+};
+var getWindow_default = getWindow;
+
+// src/is/isArray.ts
+var isArray = (arr) => Array.isArray(arr) || false;
+var isArray_default = isArray;
+
+// src/is/isCustomElement.ts
+var isCustomElement = (element) => element && !!element.shadowRoot || false;
+var isCustomElement_default = isCustomElement;
+
+// src/is/isElement.ts
+var isElement = (element) => element && [1, 2, 3, 4, 5, 6, 7, 8].some((x) => element.nodeType === x) || false;
+var isElement_default = isElement;
+
+// src/is/isElementInScrollRange.ts
+var isElementInScrollRange = (element) => {
+  if (!element || !isNode_default(element))
+    return false;
+  const { top, bottom } = getBoundingClientRect_default(element);
+  const { clientHeight } = getDocumentElement_default(element);
+  return top <= clientHeight && bottom >= 0;
+};
+var isElementInScrollRange_default = isElementInScrollRange;
+
+// src/is/isElementInViewport.ts
+var isElementInViewport = (element) => {
+  if (!element || !isNode_default(element))
+    return false;
+  const { clientWidth, clientHeight } = getDocumentElement_default(element);
+  const { top, left, bottom, right } = getBoundingClientRect_default(element, true);
+  return top >= 0 && left >= 0 && bottom <= clientHeight && right <= clientWidth;
+};
+var isElementInViewport_default = isElementInViewport;
+
+// src/is/isElementsArray.ts
+var isElementsArray = (obj) => isArray_default(obj) && obj.every(isHTMLElement_default) || false;
+var isElementsArray_default = isElementsArray;
+
+// src/is/isFunction.ts
+var isFunction = (fn) => fn && fn.constructor.name === "Function" || false;
+var isFunction_default = isFunction;
+
+// src/is/isHTMLCollection.ts
+var isHTMLCollection = (obj) => obj && obj.constructor.name === "HTMLCollection" || false;
+var isHTMLCollection_default = isHTMLCollection;
+
+// src/is/isHTMLImageElement.ts
+var isHTMLImageElement = (element) => element && element.tagName === "IMG" || false;
+var isHTMLImageElement_default = isHTMLImageElement;
+
+// src/is/isMedia.ts
+var isMedia = (element) => element && element.nodeType === 1 && ["SVG", "Image", "Video"].some((s) => element.constructor.name.includes(s)) || false;
+var isMedia_default = isMedia;
+
+// src/is/isNodeList.ts
+var isNodeList = (obj) => obj && obj.constructor.name === "NodeList" || false;
+var isNodeList_default = isNodeList;
+
+// src/is/isNumber.ts
+var isNumber = (num) => typeof num === "number" || false;
+var isNumber_default = isNumber;
+
+// src/is/isRTL.ts
+var isRTL = (node) => getDocumentElement_default(node).dir === "rtl";
+var isRTL_default = isRTL;
+
+// src/is/isString.ts
+var isString = (str) => typeof str === "string" || false;
+var isString_default = isString;
+
+// src/is/isSVGElement.ts
+var isSVGElement = (element) => element && element.constructor.name.includes("SVG") || false;
+var isSVGElement_default = isSVGElement;
+
+// src/is/isTableElement.ts
+var isTableElement = (element) => element && ["TABLE", "TD", "TH"].includes(element.tagName) || false;
+var isTableElement_default = isTableElement;
+
+// src/selectors/closest.ts
+var closest = (element, selector) => {
+  return element ? element.closest(selector) || closest(element.getRootNode().host, selector) : null;
+};
+var closest_default = closest;
+
+// src/selectors/querySelector.ts
+var querySelector = (selector, parent) => {
+  if (typeof selector === "object" && isNode_default(selector)) {
+    return selector;
+  }
+  const lookUp = parent && isNode_default(parent) ? parent : getDocument_default();
+  return lookUp.querySelector(selector);
+};
+var querySelector_default = querySelector;
+
+// src/selectors/getElementsByTagName.ts
+var getElementsByTagName = (selector, parent) => {
+  const lookUp = isNode_default(parent) ? parent : getDocument_default();
+  return lookUp.getElementsByTagName(selector);
+};
+var getElementsByTagName_default = getElementsByTagName;
+
+// src/selectors/getCustomElements.ts
+var getCustomElements = (parent) => {
+  const collection = getElementsByTagName_default("*", parent);
+  return [...collection].filter(isCustomElement_default);
+};
+var getCustomElements_default = getCustomElements;
+
+// src/selectors/getElementById.ts
+var getElementById = (id, context) => {
+  return getDocument_default(context).getElementById(id) || null;
+};
+var getElementById_default = getElementById;
+
+// src/selectors/querySelectorAll.ts
+var querySelectorAll = (selector, parent) => {
+  const lookUp = isNode_default(parent) ? parent : getDocument_default();
+  return lookUp.querySelectorAll(selector);
+};
+var querySelectorAll_default = querySelectorAll;
+
+// src/selectors/getElementsByClassName.ts
+var getElementsByClassName = (selector, parent) => {
+  const lookUp = parent && isNode_default(parent) ? parent : getDocument_default();
+  return lookUp.getElementsByClassName(selector);
+};
+var getElementsByClassName_default = getElementsByClassName;
+
+// src/selectors/matches.ts
+var matches = (target, selector) => target.matches(selector);
+var matches_default = matches;
+
+// src/index.ts
+var SHORTY = {
+  ariaChecked: ariaChecked_default,
+  ariaDescription: ariaDescription_default,
+  ariaDescribedBy: ariaDescribedBy_default,
+  ariaExpanded: ariaExpanded_default,
+  ariaHidden: ariaHidden_default,
+  ariaHasPopup: ariaHasPopup_default,
+  ariaLabel: ariaLabel_default,
+  ariaLabelledBy: ariaLabelledBy_default,
+  ariaModal: ariaModal_default,
+  ariaPressed: ariaPressed_default,
+  ariaSelected: ariaSelected_default,
+  ariaValueMin: ariaValueMin_default,
+  ariaValueMax: ariaValueMax_default,
+  ariaValueNow: ariaValueNow_default,
+  ariaValueText: ariaValueText_default,
+  nativeEvents: nativeEvents_default,
+  abortEvent: abortEvent_default,
+  blurEvent: blurEvent_default,
+  moveEvent: moveEvent_default,
+  changeEvent: changeEvent_default,
+  errorEvent: errorEvent_default,
+  resetEvent: resetEvent_default,
+  resizeEvent: resizeEvent_default,
+  scrollEvent: scrollEvent_default,
+  submitEvent: submitEvent_default,
+  loadEvent: loadEvent_default,
+  loadstartEvent: loadstartEvent_default,
+  unloadEvent: unloadEvent_default,
+  readystatechangeEvent: readystatechangeEvent_default,
+  beforeunloadEvent: beforeunloadEvent_default,
+  orientationchangeEvent: orientationchangeEvent_default,
+  contextmenuEvent: contextmenuEvent_default,
+  DOMContentLoadedEvent: DOMContentLoadedEvent_default,
+  DOMMouseScrollEvent: DOMMouseScrollEvent_default,
+  selectEvent: selectEvent_default,
+  selectendEvent: selectendEvent_default,
+  selectstartEvent: selectstartEvent_default,
+  mouseClickEvents: mouseClickEvents_default,
+  mouseclickEvent: mouseclickEvent_default,
+  mousedblclickEvent: mousedblclickEvent_default,
+  mousedownEvent: mousedownEvent_default,
+  mouseupEvent: mouseupEvent_default,
+  mousehoverEvent: mousehoverEvent_default,
+  mouseHoverEvents: mouseHoverEvents_default,
+  mouseenterEvent: mouseenterEvent_default,
+  mouseleaveEvent: mouseleaveEvent_default,
+  mouseinEvent: mouseinEvent_default,
+  mouseoutEvent: mouseoutEvent_default,
+  mouseoverEvent: mouseoverEvent_default,
+  mousemoveEvent: mousemoveEvent_default,
+  mousewheelEvent: mousewheelEvent_default,
+  mouseSwipeEvents: mouseSwipeEvents_default,
+  touchEvents: touchEvents_default,
+  touchstartEvent: touchstartEvent_default,
+  touchmoveEvent: touchmoveEvent_default,
+  touchcancelEvent: touchcancelEvent_default,
+  touchendEvent: touchendEvent_default,
+  pointercancelEvent: pointercancelEvent_default,
+  pointerdownEvent: pointerdownEvent_default,
+  pointerleaveEvent: pointerleaveEvent_default,
+  pointermoveEvent: pointermoveEvent_default,
+  pointerupEvent: pointerupEvent_default,
+  focusEvents: focusEvents_default,
+  focusEvent: focusEvent_default,
+  focusinEvent: focusinEvent_default,
+  focusoutEvent: focusoutEvent_default,
+  gesturechangeEvent: gesturechangeEvent_default,
+  gestureendEvent: gestureendEvent_default,
+  gesturestartEvent: gesturestartEvent_default,
+  bezierEasings: bezierEasings_default,
+  animationDuration: animationDuration_default,
+  animationDelay: animationDelay_default,
+  animationName: animationName_default,
+  animationEndEvent: animationEndEvent_default,
+  transitionDuration: transitionDuration_default,
+  transitionDelay: transitionDelay_default,
+  transitionEndEvent: transitionEndEvent_default,
+  transitionProperty: transitionProperty_default,
+  isMobile: isMobile_default,
+  isApple: isApple_default,
+  isFirefox: isFirefox_default,
+  support3DTransform: support3DTransform_default,
+  supportPassive: supportPassive_default,
+  supportTransform: supportTransform_default,
+  supportTouch: supportTouch_default,
+  supportAnimation: supportAnimation_default,
+  supportTransition: supportTransition_default,
+  addEventListener: addEventListener_default,
+  removeEventListener: removeEventListener_default,
+  keyboardEventKeys: keyboardEventKeys_default,
+  keydownEvent: keydownEvent_default,
+  keypressEvent: keypressEvent_default,
+  keyupEvent: keyupEvent_default,
+  keyAlt: keyAlt_default,
+  keyArrowDown: keyArrowDown_default,
+  keyArrowLeft: keyArrowLeft_default,
+  keyArrowRight: keyArrowRight_default,
+  keyArrowUp: keyArrowUp_default,
+  keyBackspace: keyBackspace_default,
+  keyCapsLock: keyCapsLock_default,
+  keyControl: keyControl_default,
+  keyDelete: keyDelete_default,
+  keyEnter: keyEnter_default,
+  keyEscape: keyEscape_default,
+  keyInsert: keyInsert_default,
+  keyMeta: keyMeta_default,
+  keyPause: keyPause_default,
+  keyScrollLock: keyScrollLock_default,
+  keyShift: keyShift_default,
+  keySpace: keySpace_default,
+  keyTab: keyTab_default,
+  offsetHeight: offsetHeight_default,
+  offsetWidth: offsetWidth_default,
+  scrollHeight: scrollHeight_default,
+  scrollWidth: scrollWidth_default,
+  userAgentData: userAgentData_default,
+  userAgent: userAgent_default,
+  tabindex: tabindex_default,
+  addClass: addClass_default,
+  removeClass: removeClass_default,
+  hasClass: hasClass_default,
+  on,
+  off,
+  one: one_default,
+  dispatchEvent: dispatchEvent_default,
+  distinct: distinct_default,
+  Data: data_default,
+  getInstance,
+  createElement: createElement_default,
+  createElementNS: createElementNS_default,
+  toUpperCase: toUpperCase_default,
+  toLowerCase: toLowerCase_default,
+  Timer: timer_default,
+  emulateAnimationEnd: emulateAnimationEnd_default,
+  emulateTransitionEnd: emulateTransitionEnd_default,
+  isElementInScrollRange: isElementInScrollRange_default,
+  isElementInViewport: isElementInViewport_default,
+  passiveHandler: passiveHandler_default,
+  getElementAnimationDuration: getElementAnimationDuration_default,
+  getElementAnimationDelay: getElementAnimationDelay_default,
+  getElementTransitionDuration: getElementTransitionDuration_default,
+  getElementTransitionDelay: getElementTransitionDelay_default,
+  getNodeScroll: getNodeScroll_default,
+  getParentNode: getParentNode_default,
+  getRectRelativeToOffsetParent: getRectRelativeToOffsetParent_default,
+  getWindow: getWindow_default,
+  isArray: isArray_default,
+  isString: isString_default,
+  isCustomElement: isCustomElement_default,
+  isElement: isElement_default,
+  isNode: isNode_default,
+  isNumber: isNumber_default,
+  isHTMLElement: isHTMLElement_default,
+  isHTMLImageElement: isHTMLImageElement_default,
+  isSVGElement: isSVGElement_default,
+  isNodeList: isNodeList_default,
+  isHTMLCollection: isHTMLCollection_default,
+  isScaledElement,
+  isTableElement: isTableElement_default,
+  isShadowRoot: isShadowRoot_default,
+  isDocument: isDocument_default,
+  isElementsArray: isElementsArray_default,
+  isFunction: isFunction_default,
+  isObject: isObject_default,
+  isWindow: isWindow_default,
+  isMedia: isMedia_default,
+  isRTL: isRTL_default,
+  closest: closest_default,
+  querySelector: querySelector_default,
+  getCustomElements: getCustomElements_default,
+  getElementById: getElementById_default,
+  querySelectorAll: querySelectorAll_default,
+  getElementsByClassName: getElementsByClassName_default,
+  getElementsByTagName: getElementsByTagName_default,
+  matches: matches_default,
+  normalizeValue: normalizeValue_default,
+  normalizeOptions: normalizeOptions_default,
+  reflow: reflow_default,
+  noop: noop_default,
+  focus: focus_default,
+  getUID: getUID_default,
+  ArrayFrom: ArrayFrom_default,
+  Float32ArrayFrom: Float32ArrayFrom_default,
+  Float64ArrayFrom: Float64ArrayFrom_default,
+  ObjectAssign: ObjectAssign_default,
+  ObjectEntries: ObjectEntries_default,
+  ObjectKeys: ObjectKeys_default,
+  ObjectValues: ObjectValues_default,
+  OriginalEvent: OriginalEvent_default,
+  getBoundingClientRect: getBoundingClientRect_default,
+  getDocument: getDocument_default,
+  getDocumentBody: getDocumentBody_default,
+  getDocumentElement: getDocumentElement_default,
+  getDocumentHead: getDocumentHead_default,
+  getElementStyle: getElementStyle_default,
+  setElementStyle: setElementStyle_default,
+  hasAttribute: hasAttribute_default,
+  hasAttributeNS: hasAttributeNS_default,
+  getAttribute: getAttribute_default,
+  getAttributeNS: getAttributeNS_default,
+  setAttribute: setAttribute_default,
+  setAttributeNS: setAttributeNS_default,
+  removeAttribute: removeAttribute_default,
+  removeAttributeNS: removeAttributeNS_default
+};
+var src_default = SHORTY;
+export {
+  src_default as default
+};
+//# sourceMappingURL=index.js.map