vrembem 1.40.1 → 1.40.2

package/dev/scripts.modern.js

@@ -456,47 +456,6 @@ var defaults$2 = {
   transition: true
 };
 
-async function switchToModal(drawerKey, obj) {
-  // Initial guards
-  const drawer = obj.getDrawer(drawerKey);
-  if (!drawer) return obj.drawerNotFound(drawerKey);
-  if (hasClass(drawer, obj.settings.classModal)) return; // Enable modal state
-
-  addClass(drawer, obj.settings.classModal);
-  addClass(drawer, obj.settings.stateClosed);
-  removeClass(drawer, obj.settings.stateOpened); // Dispatch custom event
-
-  drawer.dispatchEvent(new CustomEvent(obj.settings.customEventPrefix + 'toModal', {
-    bubbles: true
-  }));
-  return drawer;
-}
-async function switchToDefault(drawerKey, obj) {
-  // Initial guards
-  const drawer = obj.getDrawer(drawerKey);
-  if (!drawer) return obj.drawerNotFound(drawerKey);
-  if (!hasClass(drawer, obj.settings.classModal)) return; // Tear down modal state
-
-  setInert(false, obj.settings.selectorInert);
-  setOverflowHidden(false, obj.settings.selectorOverflow);
-  removeClass(drawer, obj.settings.classModal);
-  obj.focusTrap.destroy(); // Restore drawers saved state
-
-  drawerKey = drawer.getAttribute(`data-${obj.settings.dataDrawer}`);
-  const drawerState = obj.state[drawerKey];
-
-  if (drawerState == obj.settings.stateOpened) {
-    addClass(drawer, obj.settings.stateOpened);
-    removeClass(drawer, obj.settings.stateClosed);
-  } // Dispatch custom event
-
-
-  drawer.dispatchEvent(new CustomEvent(obj.settings.customEventPrefix + 'toDefault', {
-    bubbles: true
-  }));
-  return drawer;
-}
-
 class Breakpoint {
   constructor(parent) {
     this.mediaQueryLists = [];
@@ -549,9 +508,9 @@ class Breakpoint {
 
   match(mql, drawer) {
     if (mql.matches) {
-      switchToDefault(drawer, this.parent);
+      this.parent.switchToDefault(drawer);
     } else {
-      switchToModal(drawer, this.parent);
+      this.parent.switchToModal(drawer);
     }
   }
 
@@ -576,6 +535,41 @@ class Breakpoint {
 
 }
 
+function getDrawer(drawerKey) {
+  if (typeof drawerKey !== 'string') return drawerKey;
+  return document.querySelector(`[data-${this.settings.dataDrawer}="${drawerKey}"]`);
+}
+function drawerNotFound(key) {
+  return Promise.reject(new Error(`Did not find drawer with key: "${key}"`));
+}
+
+async function close$2(drawerKey) {
+  const drawer = this.getDrawer(drawerKey);
+  if (!drawer) return drawerNotFound(drawerKey);
+
+  if (hasClass(drawer, this.settings.stateOpened)) {
+    this.working = true;
+
+    if (hasClass(drawer, this.settings.classModal)) {
+      setInert(false, this.settings.selectorInert);
+      setOverflowHidden(false, this.settings.selectorOverflow);
+    }
+
+    await closeTransition(drawer, this.settings);
+    this.stateSave(drawer);
+    focusTrigger(this);
+    this.focusTrap.destroy();
+    drawer.dispatchEvent(new CustomEvent(this.settings.customEventPrefix + 'closed', {
+      detail: this,
+      bubbles: true
+    }));
+    this.working = false;
+    return drawer;
+  } else {
+    return drawer;
+  }
+}
+
 function handlerClick$2(event) {
   // Working catch
   if (this.working) return; // Toggle data trigger
@@ -638,6 +632,39 @@ function handlerKeydown$2(event) {
   }
 }
 
+async function open$2(drawerKey) {
+  const drawer = this.getDrawer(drawerKey);
+  if (!drawer) return drawerNotFound(drawerKey);
+
+  if (!hasClass(drawer, this.settings.stateOpened)) {
+    this.working = true;
+    const isModal = hasClass(drawer, this.settings.classModal);
+
+    if (isModal) {
+      setOverflowHidden(true, this.settings.selectorOverflow);
+    }
+
+    await openTransition(drawer, this.settings);
+    this.stateSave(drawer);
+
+    if (isModal) {
+      this.focusTrap.init(drawer);
+      setInert(true, this.settings.selectorInert);
+    }
+
+    focusTarget(drawer, this.settings);
+    drawer.dispatchEvent(new CustomEvent(this.settings.customEventPrefix + 'opened', {
+      detail: this,
+      bubbles: true
+    }));
+    this.working = false;
+    return drawer;
+  } else {
+    focusTarget(drawer, this.settings);
+    return drawer;
+  }
+}
+
 function stateSet(settings) {
   // If save state is disabled
   if (!settings.stateSave) return stateClear(settings); // If there isn't an existing state to set
@@ -682,6 +709,59 @@ function stateClear(settings) {
   return {};
 }
 
+async function switchToModal(drawerKey) {
+  // Initial guards
+  const drawer = this.getDrawer(drawerKey);
+  if (!drawer) return drawerNotFound(drawerKey);
+  if (hasClass(drawer, this.settings.classModal)) return; // Enable modal state
+
+  addClass(drawer, this.settings.classModal);
+  addClass(drawer, this.settings.stateClosed);
+  removeClass(drawer, this.settings.stateOpened); // Dispatch custom event
+
+  drawer.dispatchEvent(new CustomEvent(this.settings.customEventPrefix + 'toModal', {
+    bubbles: true
+  }));
+  return drawer;
+}
+async function switchToDefault(drawerKey) {
+  // Initial guards
+  const drawer = this.getDrawer(drawerKey);
+  if (!drawer) return drawerNotFound(drawerKey);
+  if (!hasClass(drawer, this.settings.classModal)) return; // Tear down modal state
+
+  setInert(false, this.settings.selectorInert);
+  setOverflowHidden(false, this.settings.selectorOverflow);
+  removeClass(drawer, this.settings.classModal);
+  this.focusTrap.destroy(); // Restore drawers saved state
+
+  drawerKey = drawer.getAttribute(`data-${this.settings.dataDrawer}`);
+  const drawerState = this.state[drawerKey];
+
+  if (drawerState == this.settings.stateOpened) {
+    addClass(drawer, this.settings.stateOpened);
+    removeClass(drawer, this.settings.stateClosed);
+  } // Dispatch custom event
+
+
+  drawer.dispatchEvent(new CustomEvent(this.settings.customEventPrefix + 'toDefault', {
+    bubbles: true
+  }));
+  return drawer;
+}
+
+async function toggle(drawerKey) {
+  const drawer = this.getDrawer(drawerKey);
+  if (!drawer) return drawerNotFound(drawerKey);
+  const isClosed = !hasClass(drawer, this.settings.stateOpened);
+
+  if (isClosed) {
+    return this.open(drawer);
+  } else {
+    return this.close(drawer);
+  }
+}
+
 class Drawer {
   constructor(options) {
     this.defaults = defaults$2;
@@ -743,20 +823,14 @@ class Drawer {
 
 
   getDrawer(drawerKey) {
-    if (typeof drawerKey !== 'string') return drawerKey;
-    return document.querySelector(`[data-${this.settings.dataDrawer}="${drawerKey}"]`);
-  }
-
-  drawerNotFound(key) {
-    return Promise.reject(new Error(`Did not find drawer with key: "${key}"`));
+    return getDrawer.call(this, drawerKey);
   }
 
   setTabindex() {
-    const selectorTabindex = `
+    return setTabindex(`
       [data-${this.settings.dataDrawer}]
       [data-${this.settings.dataDialog}]
-    `;
-    setTabindex(selectorTabindex);
+    `);
   }
   /**
    * Save state functionality
@@ -780,87 +854,27 @@ class Drawer {
 
 
   switchToDefault(drawerKey) {
-    return switchToDefault(drawerKey, this);
+    return switchToDefault.call(this, drawerKey);
   }
 
   switchToModal(drawerKey) {
-    return switchToModal(drawerKey, this);
+    return switchToModal.call(this, drawerKey);
   }
   /**
    * Change state functionality
    */
 
 
-  async toggle(drawerKey) {
-    const drawer = this.getDrawer(drawerKey);
-    if (!drawer) return this.drawerNotFound(drawerKey);
-    const isClosed = !hasClass(drawer, this.settings.stateOpened);
-
-    if (isClosed) {
-      return this.open(drawer);
-    } else {
-      return this.close(drawer);
-    }
+  toggle(drawerKey) {
+    return toggle.call(this, drawerKey);
   }
 
-  async open(drawerKey) {
-    const drawer = this.getDrawer(drawerKey);
-    if (!drawer) return this.drawerNotFound(drawerKey);
-
-    if (!hasClass(drawer, this.settings.stateOpened)) {
-      this.working = true;
-      const isModal = hasClass(drawer, this.settings.classModal);
-
-      if (isModal) {
-        setOverflowHidden(true, this.settings.selectorOverflow);
-      }
-
-      await openTransition(drawer, this.settings);
-      this.stateSave(drawer);
-
-      if (isModal) {
-        this.focusTrap.init(drawer);
-        setInert(true, this.settings.selectorInert);
-      }
-
-      focusTarget(drawer, this.settings);
-      drawer.dispatchEvent(new CustomEvent(this.settings.customEventPrefix + 'opened', {
-        detail: this,
-        bubbles: true
-      }));
-      this.working = false;
-      return drawer;
-    } else {
-      focusTarget(drawer, this.settings);
-      return drawer;
-    }
+  open(drawerKey) {
+    return open$2.call(this, drawerKey);
   }
 
-  async close(drawerKey) {
-    const drawer = this.getDrawer(drawerKey);
-    if (!drawer) return this.drawerNotFound(drawerKey);
-
-    if (hasClass(drawer, this.settings.stateOpened)) {
-      this.working = true;
-
-      if (hasClass(drawer, this.settings.classModal)) {
-        setInert(false, this.settings.selectorInert);
-        setOverflowHidden(false, this.settings.selectorOverflow);
-      }
-
-      await closeTransition(drawer, this.settings);
-      this.stateSave(drawer);
-      focusTrigger(this);
-      this.focusTrap.destroy();
-      drawer.dispatchEvent(new CustomEvent(this.settings.customEventPrefix + 'closed', {
-        detail: this,
-        bubbles: true
-      }));
-      this.working = false;
-      return drawer;
-    } else {
-      return drawer;
-    }
+  close(drawerKey) {
+    return close$2.call(this, drawerKey);
   }
 
 }
@@ -893,6 +907,27 @@ var defaults$1 = {
   transition: true
 };
 
+async function close$1(returnFocus = true) {
+  const modal = document.querySelector(`[data-${this.settings.dataModal}].${this.settings.stateOpened}`);
+
+  if (modal) {
+    this.working = true;
+    setInert(false, this.settings.selectorInert);
+    setOverflowHidden(false, this.settings.selectorOverflow);
+    await closeTransition(modal, this.settings);
+    if (returnFocus) focusTrigger(this);
+    this.focusTrap.destroy();
+    modal.dispatchEvent(new CustomEvent(this.settings.customEventPrefix + 'closed', {
+      detail: this,
+      bubbles: true
+    }));
+    this.working = false;
+    return modal;
+  } else {
+    return modal;
+  }
+}
+
 async function handlerClick$1(event) {
   // Working catch
   if (this.working) return; // Trigger click
@@ -935,21 +970,57 @@ function handlerKeydown$1(event) {
   }
 }
 
-function setInitialState(obj) {
-  const modals = document.querySelectorAll(`[data-${obj.settings.dataModal}]`);
+function getModal(modalKey) {
+  if (typeof modalKey !== 'string') return modalKey;
+  return document.querySelector(`[data-${this.settings.dataModal}="${modalKey}"]`);
+}
+function modalNotFound(key) {
+  return Promise.reject(new Error(`Did not find modal with key: "${key}"`));
+}
+function moveModals(type = this.settings.moveModals.type, ref = this.settings.moveModals.ref) {
+  const modals = document.querySelectorAll(`[data-${this.settings.dataModal}]`);
+  if (modals.length) moveElement(modals, type, ref);
+}
+
+function setInitialState() {
+  const modals = document.querySelectorAll(`[data-${this.settings.dataModal}]`);
   modals.forEach(el => {
-    if (el.classList.contains(obj.settings.stateOpened)) {
-      setInert(false, obj.settings.selectorInert);
-      setOverflowHidden(false, obj.settings.selectorOverflow);
-      focusTrigger(obj);
-      obj.focusTrap.destroy();
-    }
+    // Remove opened state setup
+    if (el.classList.contains(this.settings.stateOpened)) {
+      setInert(false, this.settings.selectorInert);
+      setOverflowHidden(false, this.settings.selectorOverflow);
+      focusTrigger(this);
+      this.focusTrap.destroy();
+    } // Remove all state classes and add the default state (closed)
 
-    removeClass(el, obj.settings.stateOpened, obj.settings.stateOpening, obj.settings.stateClosing);
-    addClass(el, obj.settings.stateClosed);
+
+    removeClass(el, this.settings.stateOpened, this.settings.stateOpening, this.settings.stateClosing);
+    addClass(el, this.settings.stateClosed);
   });
 }
 
+async function open$1(modalKey) {
+  const modal = getModal.call(this, modalKey);
+  if (!modal) return modalNotFound(modalKey);
+
+  if (hasClass(modal, this.settings.stateClosed)) {
+    this.working = true;
+    setOverflowHidden(true, this.settings.selectorOverflow);
+    await openTransition(modal, this.settings);
+    this.focusTrap.init(modal);
+    focusTarget(modal, this.settings);
+    setInert(true, this.settings.selectorInert);
+    modal.dispatchEvent(new CustomEvent(this.settings.customEventPrefix + 'opened', {
+      detail: this,
+      bubbles: true
+    }));
+    this.working = false;
+    return modal;
+  } else {
+    return modal;
+  }
+}
+
 class Modal {
   constructor(options) {
     this.defaults = defaults$1;
@@ -965,13 +1036,12 @@ class Modal {
   init(options = null) {
     if (options) this.settings = _extends({}, this.settings, options);
     this.moveModals();
+    this.setInitialState();
 
     if (this.settings.setTabindex) {
       this.setTabindex();
     }
 
-    this.setInitialState();
-
     if (this.settings.eventListeners) {
       this.initEventListeners();
     }
@@ -1006,76 +1076,34 @@ class Modal {
 
 
   getModal(modalKey) {
-    if (typeof modalKey !== 'string') return modalKey;
-    return document.querySelector(`[data-${this.settings.dataModal}="${modalKey}"]`);
-  }
-
-  modalNotFound(key) {
-    return Promise.reject(new Error(`Did not find modal with key: "${key}"`));
+    return getModal.call(this, modalKey);
   }
 
   setTabindex() {
-    const selectorTabindex = `
+    return setTabindex(`
       [data-${this.settings.dataModal}]
       [data-${this.settings.dataDialog}]
-    `;
-    setTabindex(selectorTabindex);
+    `);
   }
 
   setInitialState() {
-    setInitialState(this);
+    return setInitialState.call(this);
   }
 
-  moveModals(type = this.settings.moveModals.type, ref = this.settings.moveModals.ref) {
-    const modals = document.querySelectorAll(`[data-${this.settings.dataModal}]`);
-    if (modals.length) moveElement(modals, type, ref);
+  moveModals(type, ref) {
+    return moveModals.call(this, type, ref);
   }
   /**
    * Change state functionality
    */
 
 
-  async open(modalKey) {
-    const modal = this.getModal(modalKey);
-    if (!modal) return this.modalNotFound(modalKey);
-
-    if (hasClass(modal, this.settings.stateClosed)) {
-      this.working = true;
-      setOverflowHidden(true, this.settings.selectorOverflow);
-      await openTransition(modal, this.settings);
-      this.focusTrap.init(modal);
-      focusTarget(modal, this.settings);
-      setInert(true, this.settings.selectorInert);
-      modal.dispatchEvent(new CustomEvent(this.settings.customEventPrefix + 'opened', {
-        detail: this,
-        bubbles: true
-      }));
-      this.working = false;
-      return modal;
-    } else {
-      return modal;
-    }
+  open(modalKey) {
+    return open$1.call(this, modalKey);
   }
 
-  async close(returnFocus = true) {
-    const modal = document.querySelector(`[data-${this.settings.dataModal}].${this.settings.stateOpened}`);
-
-    if (modal) {
-      this.working = true;
-      setInert(false, this.settings.selectorInert);
-      setOverflowHidden(false, this.settings.selectorOverflow);
-      await closeTransition(modal, this.settings);
-      if (returnFocus) focusTrigger(this);
-      this.focusTrap.destroy();
-      modal.dispatchEvent(new CustomEvent(this.settings.customEventPrefix + 'closed', {
-        detail: this,
-        bubbles: true
-      }));
-      this.working = false;
-      return modal;
-    } else {
-      return modal;
-    }
+  close(returnFocus) {
+    return close$1.call(this, returnFocus);
   }
 
 }
@@ -1096,9 +1124,9 @@ var defaults = {
   placement: 'bottom-start'
 };
 
-function hide$2(popover, obj) {
+function close(popover) {
   // Update state class
-  popover.target.classList.remove(obj.settings.stateActive); // Update a11y attributes
+  popover.target.classList.remove(this.settings.stateActive); // Update a11y attributes
 
   popover.trigger.setAttribute('aria-expanded', 'false'); // Disable popper event listeners
 
@@ -1109,39 +1137,39 @@ function hide$2(popover, obj) {
     }]
   }); // Update collection status with new state
 
-  const index = obj.collection.findIndex(item => {
+  const index = this.collection.findIndex(item => {
     return item.target === popover.target;
   });
-  obj.collection[index].state = 'hide'; // Clear the memory if popover trigger matches the ones saved in memory
+  this.collection[index].state = 'closed'; // Clear the memory if popover trigger matches the ones saved in memory
 
-  if (popover.trigger === obj.memory.trigger) {
-    obj.memory.trigger = null;
+  if (popover.trigger === this.memory.trigger) {
+    this.memory.trigger = null;
   } // Return the popover
 
 
   return popover;
 }
-function hideAll(obj) {
-  obj.collection.forEach(popover => {
-    if (popover.state === 'show') {
-      hide$2(popover, obj);
+function closeAll() {
+  this.collection.forEach(popover => {
+    if (popover.state === 'opened') {
+      this.close(popover);
     }
   }); // Return the collection
 
-  return obj.collection;
+  return this.collection;
 }
-function hideCheck(popover, obj) {
-  // Only run hideCheck if provided popover is currently open
-  if (popover.state != 'show') return; // Needed to correctly check which element is currently being focused
+function closeCheck(popover) {
+  // Only run closeCheck if provided popover is currently open
+  if (popover.state != 'opened') return; // Needed to correctly check which element is currently being focused
 
   setTimeout(() => {
     // Check if trigger or target are being hovered
     const isHovered = popover.target.closest(':hover') === popover.target || popover.trigger.closest(':hover') === popover.trigger; // Check if trigger or target are being focused
 
-    const isFocused = document.activeElement.closest(`[data-${obj.settings.dataPopover}]`) === popover.target || document.activeElement.closest(`[data-${obj.settings.dataTrigger}]`) === popover.trigger; // Hide if the trigger and target are not currently hovered or focused
+    const isFocused = document.activeElement.closest(`[data-${this.settings.dataPopover}]`) === popover.target || document.activeElement.closest(`[data-${this.settings.dataTrigger}]`) === popover.trigger; // Close if the trigger and target are not currently hovered or focused
 
     if (!isHovered && !isFocused) {
-      hide$2(popover, obj);
+      this.close(popover);
     } // Return the popover
 
 
@@ -1149,6 +1177,55 @@ function hideCheck(popover, obj) {
   }, 1);
 }
 
+function handlerClick(popover) {
+  if (popover.target.classList.contains(this.settings.stateActive)) {
+    this.close(popover);
+  } else {
+    this.memory.trigger = popover.trigger;
+    this.open(popover);
+    documentClick.call(this, popover);
+  }
+}
+function handlerKeydown(event) {
+  switch (event.key) {
+    case 'Escape':
+      if (this.memory.trigger) {
+        this.memory.trigger.focus();
+      }
+
+      this.closeAll();
+      return;
+
+    case 'Tab':
+      this.collection.forEach(popover => {
+        closeCheck.call(this, popover);
+      });
+      return;
+
+    default:
+      return;
+  }
+}
+function documentClick(popover) {
+  const obj = this;
+  document.addEventListener('click', function _f(event) {
+    const result = event.target.closest(`[data-${obj.settings.dataPopover}], [data-${obj.settings.dataTrigger}]`);
+    const match = result === popover.target || result === popover.trigger;
+
+    if (!match) {
+      if (popover.target.classList.contains(obj.settings.stateActive)) {
+        obj.close(popover);
+      }
+
+      this.removeEventListener('click', _f);
+    } else {
+      if (!popover.target.classList.contains(obj.settings.stateActive)) {
+        this.removeEventListener('click', _f);
+      }
+    }
+  });
+}
+
 function getConfig(el, settings) {
   // Get the computed styles of the popover
   const styles = getComputedStyle(el); // Setup the config obj with default values
@@ -1269,16 +1346,16 @@ function getPopover(trigger, settings) {
   }
 }
 
-function show(popover, obj) {
+function open(popover) {
   // Update state class
-  popover.target.classList.add(obj.settings.stateActive); // Update a11y attributes
+  popover.target.classList.add(this.settings.stateActive); // Update a11y attributes
 
   popover.trigger.setAttribute('aria-expanded', 'true'); // Update popover config
 
-  popover.config = getConfig(popover.target, obj.settings); // Enable popper event listeners and set placement/modifiers
+  popover.config = getConfig(popover.target, this.settings); // Enable popper event listeners and set placement/modifiers
 
   popover.popper.setOptions({
-    placement: getData(popover.target, obj.settings.dataPlacement, popover.config['placement']),
+    placement: getData(popover.target, this.settings.dataPlacement, popover.config['placement']),
     modifiers: [{
       name: 'eventListeners',
       enabled: true
@@ -1287,62 +1364,14 @@ function show(popover, obj) {
 
   popover.popper.update(); // Update collection status with new state
 
-  const index = obj.collection.findIndex(item => {
+  const index = this.collection.findIndex(item => {
     return item.target === popover.target;
   });
-  obj.collection[index].state = 'show'; // Return the popover
+  this.collection[index].state = 'opened'; // Return the popover
 
   return popover;
 }
 
-function handlerClick(popover) {
-  if (popover.target.classList.contains(this.settings.stateActive)) {
-    hide$2(popover, this);
-  } else {
-    this.memory.trigger = popover.trigger;
-    show(popover, this);
-    documentClick(popover, this);
-  }
-}
-function handlerKeydown(event) {
-  switch (event.key) {
-    case 'Escape':
-      if (this.memory.trigger) {
-        this.memory.trigger.focus();
-      }
-
-      hideAll(this);
-      return;
-
-    case 'Tab':
-      this.collection.forEach(popover => {
-        hideCheck(popover, this);
-      });
-      return;
-
-    default:
-      return;
-  }
-}
-function documentClick(popover, obj) {
-  document.addEventListener('click', function _f(event) {
-    const result = event.target.closest(`[data-${obj.settings.dataPopover}], [data-${obj.settings.dataTrigger}]`);
-    const match = result === popover.target || result === popover.trigger;
-
-    if (!match) {
-      if (popover.target.classList.contains(obj.settings.stateActive)) {
-        hide$2(popover, obj);
-      }
-
-      this.removeEventListener('click', _f);
-    } else {
-      if (!popover.target.classList.contains(obj.settings.stateActive)) {
-        this.removeEventListener('click', _f);
-      }
-    }
-  });
-}
-
 var top = 'top';
 var bottom = 'bottom';
 var right = 'right';
@@ -3126,11 +3155,11 @@ var createPopper = /*#__PURE__*/popperGenerator({
   defaultModifiers: defaultModifiers
 }); // eslint-disable-next-line import/no-unused-modules
 
-function register(trigger, target, obj) {
+function register(trigger, target) {
   // If no target is passed
   if (!target) {
     // Try and get the target
-    target = getPopover(trigger, obj.settings); // If still no target is returned, log an error and return false
+    target = getPopover(trigger, this.settings); // If still no target is returned, log an error and return false
 
     if (!target) {
       console.error('No popover associated with the provided trigger:', trigger);
@@ -3139,7 +3168,7 @@ function register(trigger, target, obj) {
   } // Check if this item has already been registered in the collection
 
 
-  const index = obj.collection.findIndex(item => {
+  const index = this.collection.findIndex(item => {
     return item.trigger === trigger && item.target === target;
   }); // Initiate popover variable
 
@@ -3147,45 +3176,45 @@ function register(trigger, target, obj) {
 
   if (index >= 0) {
     // Set popover as item from collection
-    popover = obj.collection[index];
+    popover = this.collection[index];
   } else {
     // Create popper instance
     const popperInstance = createPopper(trigger, target); // Build popover object and push to collection array
 
     popover = {
-      state: 'hide',
+      state: 'closed',
       trigger: trigger,
       target: target,
       popper: popperInstance,
-      config: getConfig(target, obj.settings)
+      config: getConfig(target, this.settings)
     }; // Add item to collection
 
-    obj.collection.push(popover);
+    this.collection.push(popover);
   } // Setup event listeners
 
 
-  registerEventListeners(popover, obj); // Set initial state of popover
+  registerEventListeners.call(this, popover); // Set initial state of popover
 
-  if (popover.target.classList.contains(obj.settings.stateActive)) {
-    show(popover, obj);
-    documentClick(popover, obj);
+  if (popover.target.classList.contains(this.settings.stateActive)) {
+    this.open(popover);
+    documentClick.call(this, popover);
   } else {
-    hide$2(popover, obj);
+    this.close(popover);
   } // Return the popover object
 
 
   return popover;
 }
-function deregister(popover, obj) {
+function deregister(popover) {
   // Check if this item has been registered in the collection
-  const index = obj.collection.findIndex(item => {
+  const index = this.collection.findIndex(item => {
     return item.trigger === popover.trigger && item.target === popover.target;
   }); // If the item exists in the collection
 
   if (index >= 0) {
-    // Hide the popover
-    if (popover.state === 'show') {
-      hide$2(popover, obj);
+    // Close the popover
+    if (popover.state === 'opened') {
+      this.close(popover);
     } // Clean up the popper instance
 
 
@@ -3193,28 +3222,28 @@ function deregister(popover, obj) {
 
     deregisterEventListeners(popover); // Remove item from collection
 
-    obj.collection.splice(index, 1);
+    this.collection.splice(index, 1);
   } // Return the new collection
 
 
-  return obj.collection;
+  return this.collection;
 }
-function registerEventListeners(popover, obj) {
+function registerEventListeners(popover) {
   // If event listeners aren't already setup
   if (!popover.__eventListeners) {
     // Add event listeners based on event type
-    const eventType = getData(popover.target, obj.settings.dataEventType, popover.config['event']);
+    const eventType = getData(popover.target, this.settings.dataEventType, popover.config['event']);
 
     if (eventType === 'hover') {
       // Setup event listeners object for hover
       popover.__eventListeners = [{
         el: ['trigger'],
         type: ['mouseenter', 'focus'],
-        listener: show.bind(null, popover, obj)
+        listener: open.bind(this, popover)
       }, {
         el: ['trigger', 'target'],
         type: ['mouseleave', 'focusout'],
-        listener: hideCheck.bind(null, popover, obj)
+        listener: closeCheck.bind(this, popover)
       }]; // Loop through listeners and apply to appropriate elements
 
       popover.__eventListeners.forEach(evObj => {
@@ -3229,7 +3258,7 @@ function registerEventListeners(popover, obj) {
       popover.__eventListeners = [{
         el: ['trigger'],
         type: ['click'],
-        listener: handlerClick.bind(obj, popover)
+        listener: handlerClick.bind(this, popover)
       }]; // Loop through listeners and apply to appropriate elements
 
       popover.__eventListeners.forEach(evObj => {
@@ -3264,24 +3293,24 @@ function deregisterEventListeners(popover) {
 
   return popover;
 }
-function registerCollection(obj) {
+function registerCollection() {
   // Get all the triggers
-  const triggers = document.querySelectorAll(`[data-${obj.settings.dataTrigger}]`);
+  const triggers = document.querySelectorAll(`[data-${this.settings.dataTrigger}]`);
   triggers.forEach(trigger => {
     // Register the popover and save to collection array
-    register(trigger, false, obj);
+    this.register(trigger, false);
   }); // Return the popover collection
 
-  return obj.collection;
+  return this.collection;
 }
-function deregisterCollection(obj) {
+function deregisterCollection() {
   // Loop through all items within the collection and pass them to deregister()
-  while (obj.collection.length > 0) {
-    deregister(obj.collection[0], obj);
+  while (this.collection.length > 0) {
+    this.deregister(this.collection[0]);
   } // Return the popover collection
 
 
-  return obj.collection;
+  return this.collection;
 }
 
 class Popover {
@@ -3300,7 +3329,7 @@ class Popover {
     // Update settings with passed options
     if (options) this.settings = _extends({}, this.settings, options); // Build the collections array with popover instances
 
-    registerCollection(this); // If eventListeners is enabled
+    this.registerCollection(); // If eventListeners is enabled
 
     if (this.settings.eventListeners) {
       // Pass false to initEventListeners() since registerCollection()
@@ -3311,7 +3340,7 @@ class Popover {
 
   destroy() {
     // Deregister all popovers from collection
-    deregisterCollection(this); // If eventListeners is enabled
+    this.deregisterCollection(); // If eventListeners is enabled
 
     if (this.settings.eventListeners) {
       // Pass false to destroyEventListeners() since deregisterCollection()
@@ -3328,7 +3357,7 @@ class Popover {
     if (processCollection) {
       // Loop through collection and setup event listeners
       this.collection.forEach(popover => {
-        registerEventListeners(popover, this);
+        registerEventListeners.call(this, popover);
       });
     } // Add keydown global event listener
 
@@ -3353,35 +3382,35 @@ class Popover {
 
 
   register(trigger, target = false) {
-    return register(trigger, target, this);
+    return register.call(this, trigger, target);
   }
 
   deregister(popover) {
-    return deregister(popover, this);
+    return deregister.call(this, popover);
   }
 
   registerCollection() {
-    return registerCollection(this);
+    return registerCollection.call(this);
   }
 
   deregisterCollection() {
-    return deregisterCollection(this);
+    return deregisterCollection.call(this);
   }
   /**
    * Change state functionality
    */
 
 
-  show(popover) {
-    return show(popover, this);
+  open(popover) {
+    return open.call(this, popover);
   }
 
-  hide(popover) {
-    return hide$2(popover, this);
+  close(popover) {
+    return close.call(this, popover);
   }
 
-  hideAll() {
-    return hideAll(this);
+  closeAll() {
+    return closeAll.call(this);
   }
 
 }