<h2>Edit File - menu.js</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/home/u548619843/domains/indusjewellery.com/public_html/admin/assets/admin/js/menu.js">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">const TRANSITION_EVENTS = [&#039;transitionend&#039;, &#039;webkitTransitionEnd&#039;, &#039;oTransitionEnd&#039;]
// const TRANSITION_PROPERTIES = [&#039;transition&#039;, &#039;MozTransition&#039;, &#039;webkitTransition&#039;, &#039;WebkitTransition&#039;, &#039;OTransition&#039;]

class Menu {
  constructor(el, config = {}, _PS = null) {
    this._el = el
    this._animate = config.animate !== false
    this._accordion = config.accordion !== false
    this._closeChildren = Boolean(config.closeChildren)

    this._onOpen = config.onOpen || (() =&gt; {})
    this._onOpened = config.onOpened || (() =&gt; {})
    this._onClose = config.onClose || (() =&gt; {})
    this._onClosed = config.onClosed || (() =&gt; {})

    this._psScroll = null
    this._topParent = null
    this._menuBgClass = null

    el.classList.add(&#039;menu&#039;)
    el.classList[this._animate ? &#039;remove&#039; : &#039;add&#039;](&#039;menu-no-animation&#039;) // check

    el.classList.add(&#039;menu-vertical&#039;)

    const PerfectScrollbarLib = _PS || window.PerfectScrollbar

    if (PerfectScrollbarLib) {
      this._scrollbar = new PerfectScrollbarLib(el.querySelector(&#039;.menu-inner&#039;), {
        suppressScrollX: true,
        wheelPropagation: !Menu._hasClass(&#039;layout-menu-fixed layout-menu-fixed-offcanvas&#039;)
      })

      window.Helpers.menuPsScroll = this._scrollbar
    } else {
      el.querySelector(&#039;.menu-inner&#039;).classList.add(&#039;overflow-auto&#039;)
    }

    // Add data attribute for bg color class of menu
    const menuClassList = el.classList

    for (let i = 0; i &lt; menuClassList.length; i++) {
      if (menuClassList[i].startsWith(&#039;bg-&#039;)) {
        this._menuBgClass = menuClassList[i]
      }
    }
    el.setAttribute(&#039;data-bg-class&#039;, this._menuBgClass)

    this._bindEvents()

    // Link menu instance to element
    el.menuInstance = this
  }

  _bindEvents() {
    // Click Event
    this._evntElClick = e =&gt; {
      // Find top parent element
      if (e.target.closest(&#039;ul&#039;) &amp;&amp; e.target.closest(&#039;ul&#039;).classList.contains(&#039;menu-inner&#039;)) {
        const menuItem = Menu._findParent(e.target, &#039;menu-item&#039;, false)

        // eslint-disable-next-line prefer-destructuring
        if (menuItem) this._topParent = menuItem.childNodes[0]
      }

      const toggleLink = e.target.classList.contains(&#039;menu-toggle&#039;)
        ? e.target
        : Menu._findParent(e.target, &#039;menu-toggle&#039;, false)

      if (toggleLink) {
        e.preventDefault()

        if (toggleLink.getAttribute(&#039;data-hover&#039;) !== &#039;true&#039;) {
          this.toggle(toggleLink)
        }
      }
    }
    if (window.Helpers.isMobileDevice) this._el.addEventListener(&#039;click&#039;, this._evntElClick)

    this._evntWindowResize = () =&gt; {
      this.update()
      if (this._lastWidth !== window.innerWidth) {
        this._lastWidth = window.innerWidth
        this.update()
      }

      const horizontalMenuTemplate = document.querySelector(&quot;[data-template^=&#039;horizontal-menu&#039;]&quot;)
      if (!this._horizontal &amp;&amp; !horizontalMenuTemplate) this.manageScroll()
    }
    window.addEventListener(&#039;resize&#039;, this._evntWindowResize)
  }

  static childOf(/* child node */ c, /* parent node */ p) {
    // returns boolean
    if (c.parentNode) {
      while ((c = c.parentNode) &amp;&amp; c !== p);
      return !!c
    }
    return false
  }

  _unbindEvents() {
    if (this._evntElClick) {
      this._el.removeEventListener(&#039;click&#039;, this._evntElClick)
      this._evntElClick = null
    }

    if (this._evntElMouseOver) {
      this._el.removeEventListener(&#039;mouseover&#039;, this._evntElMouseOver)
      this._evntElMouseOver = null
    }

    if (this._evntElMouseOut) {
      this._el.removeEventListener(&#039;mouseout&#039;, this._evntElMouseOut)
      this._evntElMouseOut = null
    }

    if (this._evntWindowResize) {
      window.removeEventListener(&#039;resize&#039;, this._evntWindowResize)
      this._evntWindowResize = null
    }

    if (this._evntBodyClick) {
      document.body.removeEventListener(&#039;click&#039;, this._evntBodyClick)
      this._evntBodyClick = null
    }

    if (this._evntInnerMousemove) {
      this._inner.removeEventListener(&#039;mousemove&#039;, this._evntInnerMousemove)
      this._evntInnerMousemove = null
    }

    if (this._evntInnerMouseleave) {
      this._inner.removeEventListener(&#039;mouseleave&#039;, this._evntInnerMouseleave)
      this._evntInnerMouseleave = null
    }
  }

  static _isRoot(item) {
    return !Menu._findParent(item, &#039;menu-item&#039;, false)
  }

  static _findParent(el, cls, throwError = true) {
    if (el.tagName.toUpperCase() === &#039;BODY&#039;) return null
    el = el.parentNode
    while (el.tagName.toUpperCase() !== &#039;BODY&#039; &amp;&amp; !el.classList.contains(cls)) {
      el = el.parentNode
    }

    el = el.tagName.toUpperCase() !== &#039;BODY&#039; ? el : null

    if (!el &amp;&amp; throwError) throw new Error(`Cannot find \`.${cls}\` parent element`)

    return el
  }

  static _findChild(el, cls) {
    const items = el.childNodes
    const found = []

    for (let i = 0, l = items.length; i &lt; l; i++) {
      if (items[i].classList) {
        let passed = 0

        for (let j = 0; j &lt; cls.length; j++) {
          if (items[i].classList.contains(cls[j])) passed += 1
        }

        if (cls.length === passed) found.push(items[i])
      }
    }

    return found
  }

  static _findMenu(item) {
    let curEl = item.childNodes[0]
    let menu = null

    while (curEl &amp;&amp; !menu) {
      if (curEl.classList &amp;&amp; curEl.classList.contains(&#039;menu-sub&#039;)) menu = curEl
      curEl = curEl.nextSibling
    }

    if (!menu) throw new Error(&#039;Cannot find `.menu-sub` element for the current `.menu-toggle`&#039;)

    return menu
  }

  // Has class
  static _hasClass(cls, el = window.Helpers.ROOT_EL) {
    let result = false

    cls.split(&#039; &#039;).forEach(c =&gt; {
      if (el.classList.contains(c)) result = true
    })

    return result
  }

  open(el, closeChildren = this._closeChildren) {
    const item = this._findUnopenedParent(Menu._getItem(el, true), closeChildren)

    if (!item) return

    const toggleLink = Menu._getLink(item, true)

    Menu._promisify(this._onOpen, this, item, toggleLink, Menu._findMenu(item))
      .then(() =&gt; {
        if (!this._horizontal || !Menu._isRoot(item)) {
          if (this._animate &amp;&amp; !this._horizontal) {
            window.requestAnimationFrame(() =&gt; this._toggleAnimation(true, item, false))
            if (this._accordion) this._closeOther(item, closeChildren)
          } else if (this._animate) {
            // eslint-disable-next-line no-unused-expressions
            this._onOpened &amp;&amp; this._onOpened(this, item, toggleLink, Menu._findMenu(item))
          } else {
            item.classList.add(&#039;open&#039;)
            // eslint-disable-next-line no-unused-expressions
            this._onOpened &amp;&amp; this._onOpened(this, item, toggleLink, Menu._findMenu(item))
            if (this._accordion) this._closeOther(item, closeChildren)
          }
        } else {
          // eslint-disable-next-line no-unused-expressions
          this._onOpened &amp;&amp; this._onOpened(this, item, toggleLink, Menu._findMenu(item))
        }
      })
      .catch(() =&gt; {})
  }

  close(el, closeChildren = this._closeChildren, _autoClose = false) {
    const item = Menu._getItem(el, true)
    const toggleLink = Menu._getLink(el, true)

    if (!item.classList.contains(&#039;open&#039;) || item.classList.contains(&#039;disabled&#039;)) return

    Menu._promisify(this._onClose, this, item, toggleLink, Menu._findMenu(item), _autoClose)
      .then(() =&gt; {
        if (!this._horizontal || !Menu._isRoot(item)) {
          if (this._animate &amp;&amp; !this._horizontal) {
            window.requestAnimationFrame(() =&gt; this._toggleAnimation(false, item, closeChildren))
          } else {
            item.classList.remove(&#039;open&#039;)

            if (closeChildren) {
              const opened = item.querySelectorAll(&#039;.menu-item.open&#039;)
              for (let i = 0, l = opened.length; i &lt; l; i++) opened[i].classList.remove(&#039;open&#039;)
            }

            // eslint-disable-next-line no-unused-expressions
            this._onClosed &amp;&amp; this._onClosed(this, item, toggleLink, Menu._findMenu(item))
          }
        } else {
          // eslint-disable-next-line no-unused-expressions
          this._onClosed &amp;&amp; this._onClosed(this, item, toggleLink, Menu._findMenu(item))
        }
      })
      .catch(() =&gt; {})
  }

  _closeOther(item, closeChildren) {
    const opened = Menu._findChild(item.parentNode, [&#039;menu-item&#039;, &#039;open&#039;])

    for (let i = 0, l = opened.length; i &lt; l; i++) {
      if (opened[i] !== item) this.close(opened[i], closeChildren)
    }
  }

  toggle(el, closeChildren = this._closeChildren) {
    const item = Menu._getItem(el, true)
    // const toggleLink = Menu._getLink(el, true)

    if (item.classList.contains(&#039;open&#039;)) this.close(item, closeChildren)
    else this.open(item, closeChildren)
  }

  static _getItem(el, toggle) {
    let item = null
    const selector = toggle ? &#039;menu-toggle&#039; : &#039;menu-link&#039;

    if (el.classList.contains(&#039;menu-item&#039;)) {
      if (Menu._findChild(el, [selector]).length) item = el
    } else if (el.classList.contains(selector)) {
      item = el.parentNode.classList.contains(&#039;menu-item&#039;) ? el.parentNode : null
    }

    if (!item) {
      throw new Error(`${toggle ? &#039;Toggable &#039; : &#039;&#039;}\`.menu-item\` element not found.`)
    }

    return item
  }

  static _getLink(el, toggle) {
    let found = []
    const selector = toggle ? &#039;menu-toggle&#039; : &#039;menu-link&#039;

    if (el.classList.contains(selector)) found = [el]
    else if (el.classList.contains(&#039;menu-item&#039;)) found = Menu._findChild(el, [selector])

    if (!found.length) throw new Error(`\`${selector}\` element not found.`)

    return found[0]
  }

  _findUnopenedParent(item, closeChildren) {
    let tree = []
    let parentItem = null

    while (item) {
      if (item.classList.contains(&#039;disabled&#039;)) {
        parentItem = null
        tree = []
      } else {
        if (!item.classList.contains(&#039;open&#039;)) parentItem = item
        tree.push(item)
      }

      item = Menu._findParent(item, &#039;menu-item&#039;, false)
    }

    if (!parentItem) return null
    if (tree.length === 1) return parentItem

    tree = tree.slice(0, tree.indexOf(parentItem))

    for (let i = 0, l = tree.length; i &lt; l; i++) {
      tree[i].classList.add(&#039;open&#039;)

      if (this._accordion) {
        const openedItems = Menu._findChild(tree[i].parentNode, [&#039;menu-item&#039;, &#039;open&#039;])

        for (let j = 0, k = openedItems.length; j &lt; k; j++) {
          if (openedItems[j] !== tree[i]) {
            openedItems[j].classList.remove(&#039;open&#039;)

            if (closeChildren) {
              const openedChildren = openedItems[j].querySelectorAll(&#039;.menu-item.open&#039;)
              for (let x = 0, z = openedChildren.length; x &lt; z; x++) {
                openedChildren[x].classList.remove(&#039;open&#039;)
              }
            }
          }
        }
      }
    }

    return parentItem
  }

  _toggleAnimation(open, item, closeChildren) {
    const toggleLink = Menu._getLink(item, true)
    const menu = Menu._findMenu(item)

    Menu._unbindAnimationEndEvent(item)

    const linkHeight = Math.round(toggleLink.getBoundingClientRect().height)

    item.style.overflow = &#039;hidden&#039;

    const clearItemStyle = () =&gt; {
      item.classList.remove(&#039;menu-item-animating&#039;)
      item.classList.remove(&#039;menu-item-closing&#039;)
      item.style.overflow = null
      item.style.height = null

      this.update()
    }

    if (open) {
      item.style.height = `${linkHeight}px`
      item.classList.add(&#039;menu-item-animating&#039;)
      item.classList.add(&#039;open&#039;)

      Menu._bindAnimationEndEvent(item, () =&gt; {
        clearItemStyle()
        this._onOpened(this, item, toggleLink, menu)
      })

      setTimeout(() =&gt; {
        item.style.height = `${linkHeight + Math.round(menu.getBoundingClientRect().height)}px`
      }, 50)
    } else {
      item.style.height = `${linkHeight + Math.round(menu.getBoundingClientRect().height)}px`
      item.classList.add(&#039;menu-item-animating&#039;)
      item.classList.add(&#039;menu-item-closing&#039;)

      Menu._bindAnimationEndEvent(item, () =&gt; {
        item.classList.remove(&#039;open&#039;)
        clearItemStyle()

        if (closeChildren) {
          const opened = item.querySelectorAll(&#039;.menu-item.open&#039;)
          for (let i = 0, l = opened.length; i &lt; l; i++) opened[i].classList.remove(&#039;open&#039;)
        }

        this._onClosed(this, item, toggleLink, menu)
      })

      setTimeout(() =&gt; {
        item.style.height = `${linkHeight}px`
      }, 50)
    }
  }

  static _bindAnimationEndEvent(el, handler) {
    const cb = e =&gt; {
      if (e.target !== el) return
      Menu._unbindAnimationEndEvent(el)
      handler(e)
    }

    let duration = window.getComputedStyle(el).transitionDuration
    duration = parseFloat(duration) * (duration.indexOf(&#039;ms&#039;) !== -1 ? 1 : 1000)

    el._menuAnimationEndEventCb = cb
    TRANSITION_EVENTS.forEach(ev =&gt; el.addEventListener(ev, el._menuAnimationEndEventCb, false))

    el._menuAnimationEndEventTimeout = setTimeout(() =&gt; {
      cb({ target: el })
    }, duration + 50)
  }

  _getItemOffset(item) {
    let curItem = this._inner.childNodes[0]
    let left = 0

    while (curItem !== item) {
      if (curItem.tagName) {
        left += Math.round(curItem.getBoundingClientRect().width)
      }

      curItem = curItem.nextSibling
    }

    return left
  }

  static _promisify(fn, ...args) {
    const result = fn(...args)
    if (result instanceof Promise) {
      return result
    }
    if (result === false) {
      return Promise.reject()
    }
    return Promise.resolve()
  }

  get _innerWidth() {
    const items = this._inner.childNodes
    let width = 0

    for (let i = 0, l = items.length; i &lt; l; i++) {
      if (items[i].tagName) {
        width += Math.round(items[i].getBoundingClientRect().width)
      }
    }

    return width
  }

  get _innerPosition() {
    return parseInt(this._inner.style[this._rtl ? &#039;marginRight&#039; : &#039;marginLeft&#039;] || &#039;0px&#039;, 10)
  }

  set _innerPosition(value) {
    this._inner.style[this._rtl ? &#039;marginRight&#039; : &#039;marginLeft&#039;] = `${value}px`
    return value
  }

  static _unbindAnimationEndEvent(el) {
    const cb = el._menuAnimationEndEventCb

    if (el._menuAnimationEndEventTimeout) {
      clearTimeout(el._menuAnimationEndEventTimeout)
      el._menuAnimationEndEventTimeout = null
    }

    if (!cb) return

    TRANSITION_EVENTS.forEach(ev =&gt; el.removeEventListener(ev, cb, false))
    el._menuAnimationEndEventCb = null
  }

  closeAll(closeChildren = this._closeChildren) {
    const opened = this._el.querySelectorAll(&#039;.menu-inner &gt; .menu-item.open&#039;)

    for (let i = 0, l = opened.length; i &lt; l; i++) this.close(opened[i], closeChildren)
  }

  static setDisabled(el, disabled) {
    Menu._getItem(el, false).classList[disabled ? &#039;add&#039; : &#039;remove&#039;](&#039;disabled&#039;)
  }

  static isActive(el) {
    return Menu._getItem(el, false).classList.contains(&#039;active&#039;)
  }

  static isOpened(el) {
    return Menu._getItem(el, false).classList.contains(&#039;open&#039;)
  }

  static isDisabled(el) {
    return Menu._getItem(el, false).classList.contains(&#039;disabled&#039;)
  }

  update() {
    if (this._scrollbar) {
      this._scrollbar.update()
    }
  }

  manageScroll() {
    const { PerfectScrollbar } = window
    const menuInner = document.querySelector(&#039;.menu-inner&#039;)

    if (window.innerWidth &lt; window.Helpers.LAYOUT_BREAKPOINT) {
      if (this._scrollbar !== null) {
        // window.Helpers.menuPsScroll.destroy()
        this._scrollbar.destroy()
        this._scrollbar = null
      }
      menuInner.classList.add(&#039;overflow-auto&#039;)
    } else {
      if (this._scrollbar === null) {
        const menuScroll = new PerfectScrollbar(document.querySelector(&#039;.menu-inner&#039;), {
          suppressScrollX: true,
          wheelPropagation: false
        })
        this._scrollbar = menuScroll
      }
      menuInner.classList.remove(&#039;overflow-auto&#039;)
    }
  }

  destroy() {
    if (!this._el) return

    this._unbindEvents()

    const items = this._el.querySelectorAll(&#039;.menu-item&#039;)
    for (let i = 0, l = items.length; i &lt; l; i++) {
      Menu._unbindAnimationEndEvent(items[i])
      items[i].classList.remove(&#039;menu-item-animating&#039;)
      items[i].classList.remove(&#039;open&#039;)
      items[i].style.overflow = null
      items[i].style.height = null
    }

    const menus = this._el.querySelectorAll(&#039;.menu-menu&#039;)
    for (let i2 = 0, l2 = menus.length; i2 &lt; l2; i2++) {
      menus[i2].style.marginRight = null
      menus[i2].style.marginLeft = null
    }

    this._el.classList.remove(&#039;menu-no-animation&#039;)

    if (this._wrapper) {
      this._prevBtn.parentNode.removeChild(this._prevBtn)
      this._nextBtn.parentNode.removeChild(this._nextBtn)
      this._wrapper.parentNode.insertBefore(this._inner, this._wrapper)
      this._wrapper.parentNode.removeChild(this._wrapper)
      this._inner.style.marginLeft = null
      this._inner.style.marginRight = null
    }

    this._el.menuInstance = null
    delete this._el.menuInstance

    this._el = null
    this._animate = null
    this._accordion = null
    this._closeChildren = null
    this._onOpen = null
    this._onOpened = null
    this._onClose = null
    this._onClosed = null
    if (this._scrollbar) {
      this._scrollbar.destroy()
      this._scrollbar = null
    }
    this._inner = null
    this._prevBtn = null
    this._wrapper = null
    this._nextBtn = null
  }
}

export { Menu }
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>