@tabler/core 1.5.1 → 1.6.1

package/js/src/bootstrap/carousel.ts

@@ -9,9 +9,21 @@ import BaseComponent from './base-component'
 import EventHandler from './dom/event-handler'
 import Manipulator from './dom/manipulator'
 import SelectorEngine from './dom/selector-engine'
-import { getNextActiveElement, isRTL, isVisible, reflow, triggerTransitionEnd } from './util/index'
+import { defineJQueryPlugin, getNextActiveElement, isRTL, isVisible, reflow, triggerTransitionEnd } from './util/index'
+import type { ComponentConfig as BaseComponentConfig, JQueryCollectionLike } from './types'
 import Swipe from './util/swipe'
-import type { ComponentConfig, ComponentConfigType } from './types'
+
+type ComponentConfig = {
+  interval: number | boolean
+  keyboard: boolean
+  pause: 'hover' | boolean
+  ride: boolean | 'carousel'
+  touch: boolean
+  wrap: boolean
+  defaultInterval?: number | boolean
+}
+
+type ComponentConfigInput = Partial<Omit<ComponentConfig, 'defaultInterval'>> & Record<string, unknown>
 
 const NAME = 'carousel'
 const DATA_KEY = 'bs.carousel'
@@ -66,7 +78,7 @@ const Default: ComponentConfig = {
   wrap: true,
 }
 
-const DefaultType: ComponentConfigType = {
+const DefaultType: Record<Exclude<keyof ComponentConfig, 'defaultInterval'>, string> = {
   interval: '(number|boolean)',
   keyboard: 'boolean',
   pause: '(string|boolean)',
@@ -76,6 +88,8 @@ const DefaultType: ComponentConfigType = {
 }
 
 class Carousel extends BaseComponent {
+  declare _element: HTMLElement
+  declare _config: ComponentConfig
   _interval: ReturnType<typeof setInterval> | null
   _activeElement: HTMLElement | null
   _isSliding: boolean
@@ -83,7 +97,7 @@ class Carousel extends BaseComponent {
   _swipeHelper: Swipe | null
   _indicatorsElement: HTMLElement | null
 
-  constructor(element: HTMLElement | string, config?: Partial<ComponentConfig>) {
+  constructor(element: HTMLElement | string, config?: ComponentConfigInput) {
     super(element, config)
 
     this._interval = null
@@ -104,7 +118,7 @@ class Carousel extends BaseComponent {
     return Default
   }
 
-  static get DefaultType(): ComponentConfigType {
+  static get DefaultType(): Record<Exclude<keyof ComponentConfig, 'defaultInterval'>, string> {
     return DefaultType
   }
 
@@ -273,7 +287,7 @@ class Carousel extends BaseComponent {
 
     const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval') || element.getAttribute('data-tblr-interval') || '', 10)
 
-    this._config.interval = elementInterval || this._config.defaultInterval
+    this._config.interval = elementInterval || (this._config.defaultInterval ?? this._config.interval)
   }
 
   _slide(order: string, element: HTMLElement | null = null): void {
@@ -302,7 +316,7 @@ class Carousel extends BaseComponent {
 
     const slideEvent = triggerEvent(EVENT_SLIDE)
 
-    if (slideEvent.defaultPrevented) {
+    if (slideEvent?.defaultPrevented) {
       return
     }
 
@@ -380,6 +394,25 @@ class Carousel extends BaseComponent {
 
     return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT
   }
+
+  static jQueryInterface(this: JQueryCollectionLike, config?: unknown): unknown {
+    return this.each(function (this: HTMLElement) {
+      const data = Carousel.getOrCreateInstance(this, config as BaseComponentConfig) as unknown as Record<string, (arg?: unknown) => unknown>
+
+      if (typeof config === 'number') {
+        data.to(config)
+        return
+      }
+
+      if (typeof config === 'string') {
+        if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
+          throw new TypeError(`No method named "${config}"`)
+        }
+
+        data[config]()
+      }
+    })
+  }
 }
 
 EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_SLIDE, function (this: HTMLElement, event: Event) {
@@ -418,4 +451,6 @@ EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
   }
 })
 
+defineJQueryPlugin(Carousel)
+
 export default Carousel

package/js/src/bootstrap/collapse.ts

@@ -8,8 +8,16 @@
 import BaseComponent from './base-component'
 import EventHandler from './dom/event-handler'
 import SelectorEngine from './dom/selector-engine'
-import { getElement, reflow } from './util/index'
-import type { ComponentConfig, ComponentConfigType, ElementSelector } from './types'
+import { defineJQueryPlugin, getElement, reflow } from './util/index'
+import type { DelegatedEvent } from './dom/event-handler'
+import type { ComponentConfig as BaseComponentConfig, ElementSelector, JQueryCollectionLike } from './types'
+
+type ComponentConfig = {
+  parent: HTMLElement | null
+  toggle: boolean
+}
+
+type ComponentConfigInput = Partial<Omit<ComponentConfig, 'parent'>> & { parent?: HTMLElement | string | null } & Record<string, unknown>
 
 const NAME = 'collapse'
 const DATA_KEY = 'bs.collapse'
@@ -40,16 +48,18 @@ const Default: ComponentConfig = {
   toggle: true,
 }
 
-const DefaultType: ComponentConfigType = {
+const DefaultType: Record<keyof ComponentConfig, string> = {
   parent: '(null|element)',
   toggle: 'boolean',
 }
 
 class Collapse extends BaseComponent {
+  declare _element: HTMLElement
+  declare _config: ComponentConfig
   _isTransitioning: boolean
   _triggerArray: HTMLElement[]
 
-  constructor(element: ElementSelector, config?: ComponentConfig) {
+  constructor(element: ElementSelector, config?: ComponentConfigInput) {
     super(element, config)
 
     this._isTransitioning = false
@@ -81,7 +91,7 @@ class Collapse extends BaseComponent {
     return Default
   }
 
-  static get DefaultType(): ComponentConfigType {
+  static get DefaultType(): Record<keyof ComponentConfig, string> {
     return DefaultType
   }
 
@@ -237,10 +247,30 @@ class Collapse extends BaseComponent {
       element.setAttribute('aria-expanded', String(isOpen))
     }
   }
+
+  static jQueryInterface(this: JQueryCollectionLike, config?: unknown): unknown {
+    const _config: BaseComponentConfig = {}
+    if (typeof config === 'string' && /show|hide/.test(config)) {
+      _config.toggle = false
+    }
+
+    return this.each(function (this: HTMLElement) {
+      const data = Collapse.getOrCreateInstance(this, _config) as unknown as Record<string, (arg?: unknown) => unknown>
+
+      if (typeof config === 'string') {
+        if (typeof data[config] === 'undefined') {
+          throw new TypeError(`No method named "${config}"`)
+        }
+
+        data[config]()
+      }
+    })
+  }
 }
 
 EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (this: HTMLElement, event: Event) {
-  if ((event.target as HTMLElement).tagName === 'A' || ((event as any).delegateTarget && (event as any).delegateTarget.tagName === 'A')) {
+  const { delegateTarget } = event as DelegatedEvent
+  if ((event.target as HTMLElement).tagName === 'A' || (delegateTarget && delegateTarget.tagName === 'A')) {
     event.preventDefault()
   }
 
@@ -249,4 +279,6 @@ EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (
   }
 })
 
+defineJQueryPlugin(Collapse)
+
 export default Collapse

package/js/src/bootstrap/dom/event-handler.ts

@@ -5,7 +5,13 @@
  * --------------------------------------------------------------------------
  */
 
-type EventCallback = (this: EventTarget, ...args: unknown[]) => void
+import { getjQuery } from '../util/index.js'
+import type { JQueryEventLike } from '../types'
+
+// `this` is the element the handler was bound to, or the delegate target
+export type EventCallback<E extends Event = Event> = (this: HTMLElement, event: E) => void
+
+export type DelegatedEvent<E extends Event = Event> = E & { delegateTarget: HTMLElement }
 
 interface BootstrapHandler {
   (event: Event): void
@@ -99,7 +105,7 @@ function bootstrapHandler(element: EventTarget, fn: EventCallback): BootstrapHan
       EventHandler.off(element, event.type, fn)
     }
 
-    return fn.apply(element, [event])
+    return fn.apply(element as HTMLElement, [event])
   } as BootstrapHandler
 }
 
@@ -119,7 +125,7 @@ function bootstrapDelegationHandler(element: EventTarget, selector: string, fn:
           EventHandler.off(element, event.type, selector, fn)
         }
 
-        return fn.apply(target, [event])
+        return fn.apply(target as HTMLElement, [event])
       }
     }
   } as BootstrapHandler
@@ -129,7 +135,7 @@ function findHandler(events: Record<string | number, BootstrapHandler>, callable
   return Object.values(events).find((event) => event.callable === callable && event.delegationSelector === delegationSelector)
 }
 
-function normalizeParameters(originalTypeEvent: string, handler: string | EventCallback | undefined, delegationFunction: EventCallback | undefined): [boolean, EventCallback, string] {
+function normalizeParameters(originalTypeEvent: string, handler: string | false | EventCallback | undefined, delegationFunction: EventCallback | undefined): [boolean, EventCallback, string] {
   const isDelegated = typeof handler === 'string'
   const callable = isDelegated ? delegationFunction! : (handler || delegationFunction)!
   let typeEvent = getTypeEvent(originalTypeEvent)
@@ -141,7 +147,7 @@ function normalizeParameters(originalTypeEvent: string, handler: string | EventC
   return [isDelegated, callable, typeEvent]
 }
 
-function addHandler(element: EventTarget | null, originalTypeEvent: string, handler: string | EventCallback | undefined, delegationFunction: EventCallback | undefined, oneOff: boolean): void {
+function addHandler(element: EventTarget | null, originalTypeEvent: string, handler: string | false | EventCallback | undefined, delegationFunction: EventCallback | undefined, oneOff: boolean): void {
   if (typeof originalTypeEvent !== 'string' || !element) {
     return
   }
@@ -150,10 +156,10 @@ function addHandler(element: EventTarget | null, originalTypeEvent: string, hand
 
   if (originalTypeEvent in customEvents) {
     const wrapFunction = (fn: EventCallback): EventCallback => {
-      return function (this: EventTarget, event: unknown) {
-        const evt = event as MouseEvent & { delegateTarget: HTMLElement }
+      return function (this: EventTarget, event: Event) {
+        const evt = event as DelegatedEvent<MouseEvent>
         if (!evt.relatedTarget || (evt.relatedTarget !== evt.delegateTarget && !evt.delegateTarget.contains(evt.relatedTarget as Node))) {
-          return fn.call(this, event)
+          return fn.call(this as HTMLElement, event)
         }
       }
     }
@@ -210,20 +216,20 @@ function getTypeEvent(event: string): string {
 }
 
 const EventHandler = {
-  on(element: EventTarget | null, event: string, handler: string | EventCallback, delegationFunction?: EventCallback): void {
-    addHandler(element, event, handler, delegationFunction, false)
+  on<E extends Event = Event>(element: EventTarget | null, event: string, handler: string | false | EventCallback<E>, delegationFunction?: EventCallback<E>): void {
+    addHandler(element, event, handler as string | false | EventCallback, delegationFunction as EventCallback | undefined, false)
   },
 
-  one(element: EventTarget | null, event: string, handler: string | EventCallback, delegationFunction?: EventCallback): void {
-    addHandler(element, event, handler, delegationFunction, true)
+  one<E extends Event = Event>(element: EventTarget | null, event: string, handler: string | false | EventCallback<E>, delegationFunction?: EventCallback<E>): void {
+    addHandler(element, event, handler as string | false | EventCallback, delegationFunction as EventCallback | undefined, true)
   },
 
-  off(element: EventTarget | null, originalTypeEvent: string, handler?: string | EventCallback, delegationFunction?: EventCallback): void {
+  off<E extends Event = Event>(element: EventTarget | null, originalTypeEvent: string, handler?: string | false | EventCallback<E>, delegationFunction?: EventCallback<E>): void {
     if (typeof originalTypeEvent !== 'string' || !element) {
       return
     }
 
-    const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction)
+    const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler as string | false | EventCallback | undefined, delegationFunction as EventCallback | undefined)
     const inNamespace = typeEvent !== originalTypeEvent
     const events = getElementEvents(element)
     const storeElementEvent = events[typeEvent] || {}
@@ -258,9 +264,37 @@ const EventHandler = {
       return null
     }
 
-    const evt = hydrateObj(new Event(event, { bubbles: true, cancelable: true }), args)
+    const $ = getjQuery()
+    const typeEvent = getTypeEvent(event)
+    const inNamespace = event !== typeEvent
+
+    let jQueryEvent: JQueryEventLike | null = null
+    let bubbles = true
+    let nativeDispatch = true
+    let defaultPrevented = false
+
+    if (inNamespace && $) {
+      jQueryEvent = $.Event(event, args)
+
+      $(element).trigger(jQueryEvent)
+      bubbles = !jQueryEvent.isPropagationStopped()
+      nativeDispatch = !jQueryEvent.isImmediatePropagationStopped()
+      defaultPrevented = jQueryEvent.isDefaultPrevented()
+    }
+
+    const evt = hydrateObj(new Event(event, { bubbles, cancelable: true }), args)
+
+    if (defaultPrevented) {
+      evt.preventDefault()
+    }
+
+    if (nativeDispatch) {
+      element.dispatchEvent(evt)
+    }
 
-    element.dispatchEvent(evt)
+    if (evt.defaultPrevented && jQueryEvent) {
+      jQueryEvent.preventDefault()
+    }
 
     return evt
   },

package/js/src/bootstrap/dom/manipulator.ts

@@ -43,7 +43,7 @@ const PREFIXES = ['tblr', 'bs'] as const
 
 const Manipulator = {
   setDataAttribute(element: HTMLElement, key: string, value: string): void {
-    element.setAttribute(`data-tblr-${normalizeDataKey(key)}`, value)
+    element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value)
   },
 
   removeDataAttribute(element: HTMLElement, key: string): void {

package/js/src/bootstrap/dropdown.ts

@@ -10,8 +10,26 @@ import BaseComponent from './base-component'
 import EventHandler from './dom/event-handler'
 import Manipulator from './dom/manipulator'
 import SelectorEngine from './dom/selector-engine'
-import { execute, getElement, getNextActiveElement, isDisabled, isElement, isRTL, isVisible, noop } from './util/index'
-import type { ComponentConfig, ComponentConfigType } from './types'
+import { defineJQueryPlugin, execute, getElement, getNextActiveElement, isDisabled, isElement, isRTL, isVisible, noop } from './util/index'
+import type { DelegatedEvent } from './dom/event-handler'
+import type { ComponentConfig as BaseComponentConfig, JQueryCollectionLike } from './types'
+
+type PopperOffsetData = { placement: Popper.Placement; reference: Popper.Rect; popper: Popper.Rect }
+type PopperOffsetFunction = (popperData: PopperOffsetData) => number[]
+type PopperConfigFunction = (defaultConfig: Partial<Popper.Options>) => Partial<Popper.Options>
+
+type ComponentConfig = {
+  autoClose: boolean | 'inside' | 'outside'
+  boundary: Popper.Boundary
+  display: 'dynamic' | 'static'
+  offset: number[] | string | ((popperData: PopperOffsetData, element: HTMLElement) => number[])
+  popperConfig: Partial<Popper.Options> | PopperConfigFunction | null
+  reference: 'toggle' | 'parent' | HTMLElement | Popper.VirtualElement
+}
+
+type ComponentConfigInput = Partial<ComponentConfig> & Record<string, unknown>
+
+type RelatedTarget = { relatedTarget: HTMLElement; clickEvent?: Event }
 
 const NAME = 'dropdown'
 const DATA_KEY = 'bs.dropdown'
@@ -40,7 +58,9 @@ const CLASS_NAME_DROPUP_CENTER = 'dropup-center'
 const CLASS_NAME_DROPDOWN_CENTER = 'dropdown-center'
 
 const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="dropdown"]:not(.disabled):not(:disabled), [data-tblr-toggle="dropdown"]:not(.disabled):not(:disabled)'
-const SELECTOR_DATA_TOGGLE_SHOWN = `.${CLASS_NAME_SHOW}[data-bs-toggle="dropdown"], .${CLASS_NAME_SHOW}[data-tblr-toggle="dropdown"]`
+const SELECTOR_DATA_TOGGLE_SHOWN = SELECTOR_DATA_TOGGLE.split(', ')
+  .map((selector) => `${selector}.${CLASS_NAME_SHOW}`)
+  .join(', ')
 const SELECTOR_MENU = '.dropdown-menu'
 const SELECTOR_NAVBAR = '.navbar'
 const SELECTOR_NAVBAR_NAV = '.navbar-nav'
@@ -64,7 +84,7 @@ const Default: ComponentConfig = {
   reference: 'toggle',
 }
 
-const DefaultType: ComponentConfigType = {
+const DefaultType: Record<keyof ComponentConfig, string> = {
   autoClose: '(boolean|string)',
   boundary: '(string|element)',
   display: 'string',
@@ -74,12 +94,14 @@ const DefaultType: ComponentConfigType = {
 }
 
 class Dropdown extends BaseComponent {
+  declare _element: HTMLElement
+  declare _config: ComponentConfig
   _popper: Popper.Instance | null
   _parent: HTMLElement
   _menu: HTMLElement
   _inNavbar: boolean
 
-  constructor(element: HTMLElement | string, config?: Partial<ComponentConfig>) {
+  constructor(element: HTMLElement | string, config?: ComponentConfigInput) {
     super(element, config)
 
     this._popper = null
@@ -92,7 +114,7 @@ class Dropdown extends BaseComponent {
     return Default
   }
 
-  static get DefaultType(): ComponentConfigType {
+  static get DefaultType(): Record<keyof ComponentConfig, string> {
     return DefaultType
   }
 
@@ -115,14 +137,14 @@ class Dropdown extends BaseComponent {
 
     const showEvent = EventHandler.trigger(this._element, EVENT_SHOW, relatedTarget)
 
-    if (showEvent.defaultPrevented) {
+    if (showEvent?.defaultPrevented) {
       return
     }
 
     this._createPopper()
 
     if ('ontouchstart' in document.documentElement && !this._parent.closest(SELECTOR_NAVBAR_NAV)) {
-      for (const element of [].concat(...(document.body.children as any))) {
+      for (const element of Array.from(document.body.children)) {
         EventHandler.on(element, 'mouseover', noop)
       }
     }
@@ -162,14 +184,14 @@ class Dropdown extends BaseComponent {
     }
   }
 
-  _completeHide(relatedTarget: Record<string, any>): void {
+  _completeHide(relatedTarget: RelatedTarget): void {
     const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE, relatedTarget)
-    if (hideEvent.defaultPrevented) {
+    if (hideEvent?.defaultPrevented) {
       return
     }
 
     if ('ontouchstart' in document.documentElement) {
-      for (const element of [].concat(...(document.body.children as any))) {
+      for (const element of Array.from(document.body.children)) {
         EventHandler.off(element, 'mouseover', noop)
       }
     }
@@ -185,14 +207,14 @@ class Dropdown extends BaseComponent {
     EventHandler.trigger(this._element, EVENT_HIDDEN, relatedTarget)
   }
 
-  _getConfig(config: Partial<ComponentConfig>): ComponentConfig {
-    config = super._getConfig(config)
+  _getConfig(config?: ComponentConfigInput): ComponentConfig {
+    const merged = super._getConfig(config) as ComponentConfig
 
-    if (typeof config.reference === 'object' && !isElement(config.reference) && typeof (config.reference as any).getBoundingClientRect !== 'function') {
+    if (typeof merged.reference === 'object' && !isElement(merged.reference) && typeof (merged.reference as Popper.VirtualElement).getBoundingClientRect !== 'function') {
       throw new TypeError(`${NAME.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`)
     }
 
-    return config
+    return merged
   }
 
   _createPopper(): void {
@@ -250,7 +272,7 @@ class Dropdown extends BaseComponent {
     return this._element.closest(SELECTOR_NAVBAR) !== null
   }
 
-  _getOffset(): number[] | ((popperData: any) => number[]) {
+  _getOffset(): number[] | PopperOffsetFunction {
     const { offset } = this._config
 
     if (typeof offset === 'string') {
@@ -258,10 +280,10 @@ class Dropdown extends BaseComponent {
     }
 
     if (typeof offset === 'function') {
-      return (popperData: any) => (offset as Function)(popperData, this._element)
+      return (popperData: PopperOffsetData) => offset(popperData, this._element)
     }
 
-    return offset as number[]
+    return offset
   }
 
   _getPopperConfig(): Partial<Popper.Options> {
@@ -300,14 +322,15 @@ class Dropdown extends BaseComponent {
     }
   }
 
-  _selectMenuItem({ key, target }: { key: string; target: HTMLElement }): void {
+  _selectMenuItem({ key, target }: { key: string; target: EventTarget | null }): void {
     const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter((element) => isVisible(element))
 
     if (!items.length) {
       return
     }
 
-    getNextActiveElement(items, target, key === ARROW_DOWN_KEY, !items.includes(target)).focus()
+    const activeElement = target as HTMLElement
+    getNextActiveElement(items, activeElement, key === ARROW_DOWN_KEY, !items.includes(activeElement)).focus()
   }
 
   static clearMenus(event: Event & { button?: number; key?: string; composedPath?: () => EventTarget[] }): void {
@@ -333,7 +356,7 @@ class Dropdown extends BaseComponent {
         continue
       }
 
-      const relatedTarget: Record<string, any> = { relatedTarget: context._element }
+      const relatedTarget: RelatedTarget = { relatedTarget: context._element }
 
       if (event.type === 'click') {
         relatedTarget.clickEvent = event
@@ -358,14 +381,14 @@ class Dropdown extends BaseComponent {
 
     event.preventDefault()
 
-    const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE)[0] || SelectorEngine.next(this, SELECTOR_DATA_TOGGLE)[0] || SelectorEngine.findOne(SELECTOR_DATA_TOGGLE, (event as any).delegateTarget.parentNode)
+    const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE)[0] || SelectorEngine.next(this, SELECTOR_DATA_TOGGLE)[0] || SelectorEngine.findOne(SELECTOR_DATA_TOGGLE, (event as DelegatedEvent<KeyboardEvent>).delegateTarget.parentNode as Element)
 
     const instance = Dropdown.getOrCreateInstance(getToggleButton!) as Dropdown
 
     if (isUpOrDownEvent) {
       event.stopPropagation()
       instance.show()
-      instance._selectMenuItem(event as any)
+      instance._selectMenuItem(event)
       return
     }
 
@@ -375,6 +398,22 @@ class Dropdown extends BaseComponent {
       getToggleButton!.focus()
     }
   }
+
+  static jQueryInterface(this: JQueryCollectionLike, config?: unknown): unknown {
+    return this.each(function (this: HTMLElement) {
+      const data = Dropdown.getOrCreateInstance(this, config as BaseComponentConfig) as unknown as Record<string, (arg?: unknown) => unknown>
+
+      if (typeof config !== 'string') {
+        return
+      }
+
+      if (typeof data[config] === 'undefined') {
+        throw new TypeError(`No method named "${config}"`)
+      }
+
+      data[config]()
+    })
+  }
 }
 
 EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE, Dropdown.dataApiKeydownHandler)
@@ -386,4 +425,6 @@ EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (
   ;(Dropdown.getOrCreateInstance(this) as Dropdown).toggle()
 })
 
+defineJQueryPlugin(Dropdown)
+
 export default Dropdown