@gitlab/ui 84.1.0 → 85.0.0

package/src/vendor/bootstrap-vue/src/utils/css-escape.spec.js

@@ -0,0 +1,82 @@
+import { cssEscape } from './css-escape'
+
+describe('utils/cssEscape', () => {
+  it('works', () => {
+    expect(cssEscape('\0')).toBe('\uFFFD')
+    expect(cssEscape('a\0')).toBe('a\uFFFD')
+    expect(cssEscape('\0b')).toBe('\uFFFDb')
+    expect(cssEscape('a\0b')).toBe('a\uFFFDb')
+
+    expect(cssEscape('\uFFFD')).toBe('\uFFFD')
+    expect(cssEscape('a\uFFFD')).toBe('a\uFFFD')
+    expect(cssEscape('\uFFFDb')).toBe('\uFFFDb')
+    expect(cssEscape('a\uFFFDb')).toBe('a\uFFFDb')
+
+    expect(cssEscape(undefined)).toBe('')
+    expect(cssEscape(null)).toBe('')
+    expect(cssEscape(true)).toBe('true')
+    expect(cssEscape(false)).toBe('false')
+    expect(cssEscape('')).toBe('')
+
+    expect(cssEscape('\x01\x02\x1E\x1F')).toBe('\\1 \\2 \\1e \\1f ')
+
+    expect(cssEscape('0a')).toBe('\\30 a')
+    expect(cssEscape('1a')).toBe('\\31 a')
+    expect(cssEscape('2a')).toBe('\\32 a')
+    expect(cssEscape('3a')).toBe('\\33 a')
+    expect(cssEscape('4a')).toBe('\\34 a')
+    expect(cssEscape('5a')).toBe('\\35 a')
+    expect(cssEscape('6a')).toBe('\\36 a')
+    expect(cssEscape('7a')).toBe('\\37 a')
+    expect(cssEscape('8a')).toBe('\\38 a')
+    expect(cssEscape('9a')).toBe('\\39 a')
+
+    expect(cssEscape('a0b')).toBe('a0b')
+    expect(cssEscape('a1b')).toBe('a1b')
+    expect(cssEscape('a2b')).toBe('a2b')
+    expect(cssEscape('a3b')).toBe('a3b')
+    expect(cssEscape('a4b')).toBe('a4b')
+    expect(cssEscape('a5b')).toBe('a5b')
+    expect(cssEscape('a6b')).toBe('a6b')
+    expect(cssEscape('a7b')).toBe('a7b')
+    expect(cssEscape('a8b')).toBe('a8b')
+    expect(cssEscape('a9b')).toBe('a9b')
+
+    expect(cssEscape('-0a')).toBe('-\\30 a')
+    expect(cssEscape('-1a')).toBe('-\\31 a')
+    expect(cssEscape('-2a')).toBe('-\\32 a')
+    expect(cssEscape('-3a')).toBe('-\\33 a')
+    expect(cssEscape('-4a')).toBe('-\\34 a')
+    expect(cssEscape('-5a')).toBe('-\\35 a')
+    expect(cssEscape('-6a')).toBe('-\\36 a')
+    expect(cssEscape('-7a')).toBe('-\\37 a')
+    expect(cssEscape('-8a')).toBe('-\\38 a')
+    expect(cssEscape('-9a')).toBe('-\\39 a')
+
+    expect(cssEscape('-')).toBe('\\-')
+    expect(cssEscape('-a')).toBe('-a')
+    expect(cssEscape('--')).toBe('--')
+    expect(cssEscape('--a')).toBe('--a')
+
+    expect(cssEscape('\x80\x2D\x5F\xA9')).toBe('\x80\x2D\x5F\xA9')
+    expect(
+      cssEscape(
+        '\x7F\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F'
+      )
+    ).toBe(
+      '\\7f \x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F'
+    )
+    expect(cssEscape('\xA0\xA1\xA2')).toBe('\xA0\xA1\xA2')
+    expect(cssEscape('a0123456789b')).toBe('a0123456789b')
+    expect(cssEscape('abcdefghijklmnopqrstuvwxyz')).toBe('abcdefghijklmnopqrstuvwxyz')
+    expect(cssEscape('ABCDEFGHIJKLMNOPQRSTUVWXYZ')).toBe('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
+
+    expect(cssEscape('\x20\x21\x78\x79')).toBe('\\ \\!xy')
+
+    // Astral symbol (U+1D306 TETRAGRAM FOR CENTRE)
+    expect(cssEscape('\uD834\uDF06')).toBe('\uD834\uDF06')
+    // Lone surrogates
+    expect(cssEscape('\uDF06')).toBe('\uDF06')
+    expect(cssEscape('\uD834')).toBe('\uD834')
+  })
+})

package/src/vendor/bootstrap-vue/src/utils/date.js

@@ -0,0 +1,130 @@
+// Date utility functions
+import { CALENDAR_GREGORY } from '../constants/date'
+import { RX_DATE, RX_DATE_SPLIT } from '../constants/regex'
+import { concat } from './array'
+import { identity } from './identity'
+import { isDate, isString } from './inspect'
+import { toInteger } from './number'
+
+// --- Date utility methods ---
+
+// Create or clone a date (`new Date(...)` shortcut)
+export const createDate = (...args) => new Date(...args)
+
+// Parse a date sting, or Date object, into a Date object (with no time information)
+export const parseYMD = date => {
+  if (isString(date) && RX_DATE.test(date.trim())) {
+    const [year, month, day] = date.split(RX_DATE_SPLIT).map(v => toInteger(v, 1))
+    return createDate(year, month - 1, day)
+  } else if (isDate(date)) {
+    return createDate(date.getFullYear(), date.getMonth(), date.getDate())
+  }
+  return null
+}
+
+// Format a date object as `YYYY-MM-DD` format
+export const formatYMD = date => {
+  date = parseYMD(date)
+  if (!date) {
+    return null
+  }
+  const year = date.getFullYear()
+  const month = `0${date.getMonth() + 1}`.slice(-2)
+  const day = `0${date.getDate()}`.slice(-2)
+  return `${year}-${month}-${day}`
+}
+
+// Given a locale (or locales), resolve the browser available locale
+export const resolveLocale = (locales, calendar = CALENDAR_GREGORY) => /* istanbul ignore next */ {
+  locales = concat(locales).filter(identity)
+  const fmt = new Intl.DateTimeFormat(locales, { calendar })
+  return fmt.resolvedOptions().locale
+}
+
+// Create a `Intl.DateTimeFormat` formatter function
+export const createDateFormatter = (locale, options) => /* istanbul ignore next */ {
+  const dtf = new Intl.DateTimeFormat(locale, options)
+  return dtf.format
+}
+
+// Determine if two dates are the same date (ignoring time portion)
+export const datesEqual = (date1, date2) => {
+  // Returns true of the date portion of two date objects are equal
+  // We don't compare the time portion
+  return formatYMD(date1) === formatYMD(date2)
+}
+
+// --- Date "math" utility methods (for BCalendar component mainly) ---
+
+export const firstDateOfMonth = date => {
+  date = createDate(date)
+  date.setDate(1)
+  return date
+}
+
+export const lastDateOfMonth = date => {
+  date = createDate(date)
+  date.setMonth(date.getMonth() + 1)
+  date.setDate(0)
+  return date
+}
+
+export const addYears = (date, numberOfYears) => {
+  date = createDate(date)
+  const month = date.getMonth()
+  date.setFullYear(date.getFullYear() + numberOfYears)
+  // Handle Feb 29th for leap years
+  if (date.getMonth() !== month) {
+    date.setDate(0)
+  }
+  return date
+}
+
+export const oneMonthAgo = date => {
+  date = createDate(date)
+  const month = date.getMonth()
+  date.setMonth(month - 1)
+  // Handle when days in month are different
+  if (date.getMonth() === month) {
+    date.setDate(0)
+  }
+  return date
+}
+
+export const oneMonthAhead = date => {
+  date = createDate(date)
+  const month = date.getMonth()
+  date.setMonth(month + 1)
+  // Handle when days in month are different
+  if (date.getMonth() === (month + 2) % 12) {
+    date.setDate(0)
+  }
+  return date
+}
+
+export const oneYearAgo = date => {
+  return addYears(date, -1)
+}
+
+export const oneYearAhead = date => {
+  return addYears(date, 1)
+}
+
+export const oneDecadeAgo = date => {
+  return addYears(date, -10)
+}
+
+export const oneDecadeAhead = date => {
+  return addYears(date, 10)
+}
+
+// Helper function to constrain a date between two values
+// Always returns a `Date` object or `null` if no date passed
+export const constrainDate = (date, min = null, max = null) => {
+  // Ensure values are `Date` objects (or `null`)
+  date = parseYMD(date)
+  min = parseYMD(min) || date
+  max = parseYMD(max) || date
+  // Return a new `Date` object (or `null`)
+  return date ? (date < min ? min : date > max ? max : date) : null
+}

package/src/vendor/bootstrap-vue/src/utils/date.spec.js

@@ -0,0 +1,159 @@
+import {
+  parseYMD,
+  formatYMD,
+  datesEqual,
+  firstDateOfMonth,
+  lastDateOfMonth,
+  oneMonthAgo,
+  oneMonthAhead,
+  oneYearAgo,
+  oneYearAhead,
+  oneDecadeAgo,
+  oneDecadeAhead,
+  constrainDate
+} from './date'
+
+describe('utils/date', () => {
+  it('parseYMD() works', async () => {
+    const date1 = parseYMD('2020-01-15')
+    const date2 = new Date(2020, 0, 15)
+    const date3 = parseYMD('2020-01-15T23:16:56.131Z')
+    const date4 = parseYMD('2020-01-15 23:16:56')
+
+    expect(date1.toISOString()).toEqual(date2.toISOString())
+    expect(date1.toISOString()).toEqual(date3.toISOString())
+    expect(date1.toISOString()).toEqual(date4.toISOString())
+    expect(parseYMD('yyyy-mm-dd')).toEqual(null)
+    expect(parseYMD('2020-01-15XYZ')).toEqual(null)
+  })
+
+  it('formatYMD() works', async () => {
+    expect(formatYMD(new Date(2020, 0, 15))).toEqual('2020-01-15')
+    expect(formatYMD('2020-01-15')).toEqual('2020-01-15')
+    expect(formatYMD('2020-01-32')).toEqual('2020-02-01')
+    expect(formatYMD('foobar')).toEqual(null)
+    expect(formatYMD('x2020-01-15')).toEqual(null)
+    expect(formatYMD('2020-01-15x')).toEqual(null)
+    expect(formatYMD('2020-01-15T23:16:56.131Z')).toEqual('2020-01-15')
+    expect(formatYMD('2020-01-15 23:16:56')).toEqual('2020-01-15')
+  })
+
+  it('datesEqual() works', async () => {
+    expect(datesEqual('2020-01-15', '2020-01-15')).toBe(true)
+    expect(datesEqual('2020-01-15', '2020-12-15')).toBe(false)
+    expect(datesEqual(new Date(2020, 0, 15), '2020-12-15')).toBe(false)
+    expect(datesEqual(new Date(2020, 0, 15), new Date(2020, 0, 15, 5, 4, 3))).toBe(true)
+    expect(datesEqual('2020-01-15', new Date(2020, 0, 15))).toBe(true)
+    expect(datesEqual('2020-02-15', new Date(2020, 0, 15))).toBe(false)
+  })
+
+  it('firstDateOfMonth() works', async () => {
+    // February 2020 was a leap year
+    expect(formatYMD(firstDateOfMonth(parseYMD('2020-02-03')))).toEqual('2020-02-01')
+    expect(formatYMD(firstDateOfMonth(parseYMD('2020-02-29')))).toEqual('2020-02-01')
+    expect(formatYMD(firstDateOfMonth(parseYMD('2020-01-03')))).toEqual('2020-01-01')
+    expect(formatYMD(firstDateOfMonth(parseYMD('2020-11-03')))).toEqual('2020-11-01')
+    expect(formatYMD(firstDateOfMonth(parseYMD('2020-12-03')))).toEqual('2020-12-01')
+  })
+
+  it('lastDateOfMonth() works', async () => {
+    // February 2020 was a leap year
+    expect(formatYMD(lastDateOfMonth(parseYMD('2020-02-03')))).toEqual('2020-02-29')
+    expect(formatYMD(lastDateOfMonth(parseYMD('2019-02-03')))).toEqual('2019-02-28')
+    expect(formatYMD(lastDateOfMonth(parseYMD('2020-01-03')))).toEqual('2020-01-31')
+    expect(formatYMD(lastDateOfMonth(parseYMD('2020-11-03')))).toEqual('2020-11-30')
+    expect(formatYMD(lastDateOfMonth(parseYMD('2020-12-03')))).toEqual('2020-12-31')
+  })
+
+  it('oneMonthAgo() works', async () => {
+    // February 2020 was a leap year
+    expect(formatYMD(oneMonthAgo(parseYMD('2020-02-03')))).toEqual('2020-01-03')
+    expect(formatYMD(oneMonthAgo(parseYMD('2020-03-28')))).toEqual('2020-02-28')
+    expect(formatYMD(oneMonthAgo(parseYMD('2020-03-31')))).toEqual('2020-02-29')
+    expect(formatYMD(oneMonthAgo(parseYMD('2020-12-30')))).toEqual('2020-11-30')
+    expect(formatYMD(oneMonthAgo(parseYMD('2020-12-31')))).toEqual('2020-11-30')
+  })
+
+  it('oneMonthAhead() works', async () => {
+    // February 2020 was a leap year
+    expect(formatYMD(oneMonthAhead(parseYMD('2020-02-03')))).toEqual('2020-03-03')
+    expect(formatYMD(oneMonthAhead(parseYMD('2020-01-31')))).toEqual('2020-02-29')
+    expect(formatYMD(oneMonthAhead(parseYMD('2020-02-29')))).toEqual('2020-03-29')
+    expect(formatYMD(oneMonthAhead(parseYMD('2020-03-28')))).toEqual('2020-04-28')
+    expect(formatYMD(oneMonthAhead(parseYMD('2020-03-31')))).toEqual('2020-04-30')
+    expect(formatYMD(oneMonthAhead(parseYMD('2020-10-31')))).toEqual('2020-11-30')
+    expect(formatYMD(oneMonthAhead(parseYMD('2020-12-30')))).toEqual('2021-01-30')
+    expect(formatYMD(oneMonthAhead(parseYMD('2020-12-31')))).toEqual('2021-01-31')
+  })
+
+  it('oneYearAgo() works', async () => {
+    // February 2020 was a leap year
+    expect(formatYMD(oneYearAgo(parseYMD('2020-02-29')))).toEqual('2019-02-28')
+    expect(formatYMD(oneYearAgo(parseYMD('2020-02-28')))).toEqual('2019-02-28')
+    expect(formatYMD(oneYearAgo(parseYMD('2020-01-31')))).toEqual('2019-01-31')
+    expect(formatYMD(oneYearAgo(parseYMD('2020-11-01')))).toEqual('2019-11-01')
+    expect(formatYMD(oneYearAgo(parseYMD('2020-11-30')))).toEqual('2019-11-30')
+    expect(formatYMD(oneYearAgo(parseYMD('2020-12-31')))).toEqual('2019-12-31')
+  })
+
+  it('oneYearAhead() works', async () => {
+    // February 2020 was a leap year
+    expect(formatYMD(oneYearAhead(parseYMD('2020-02-29')))).toEqual('2021-02-28')
+    expect(formatYMD(oneYearAhead(parseYMD('2020-02-28')))).toEqual('2021-02-28')
+    expect(formatYMD(oneYearAhead(parseYMD('2020-01-31')))).toEqual('2021-01-31')
+    expect(formatYMD(oneYearAhead(parseYMD('2020-11-01')))).toEqual('2021-11-01')
+    expect(formatYMD(oneYearAhead(parseYMD('2020-11-30')))).toEqual('2021-11-30')
+    expect(formatYMD(oneYearAhead(parseYMD('2020-12-31')))).toEqual('2021-12-31')
+  })
+
+  it('oneDecadeAgo() works', async () => {
+    // February 2020 was a leap year
+    expect(formatYMD(oneDecadeAgo(parseYMD('2020-02-29')))).toEqual('2010-02-28')
+    expect(formatYMD(oneDecadeAgo(parseYMD('2020-02-28')))).toEqual('2010-02-28')
+    expect(formatYMD(oneDecadeAgo(parseYMD('2020-01-31')))).toEqual('2010-01-31')
+    expect(formatYMD(oneDecadeAgo(parseYMD('2020-11-01')))).toEqual('2010-11-01')
+    expect(formatYMD(oneDecadeAgo(parseYMD('2020-11-30')))).toEqual('2010-11-30')
+    expect(formatYMD(oneDecadeAgo(parseYMD('2020-12-31')))).toEqual('2010-12-31')
+  })
+
+  it('oneDecadeAhead() works', async () => {
+    // February 2020 was a leap year
+    expect(formatYMD(oneDecadeAhead(parseYMD('2020-02-29')))).toEqual('2030-02-28')
+    expect(formatYMD(oneDecadeAhead(parseYMD('2020-02-28')))).toEqual('2030-02-28')
+    expect(formatYMD(oneDecadeAhead(parseYMD('2020-01-31')))).toEqual('2030-01-31')
+    expect(formatYMD(oneDecadeAhead(parseYMD('2020-11-01')))).toEqual('2030-11-01')
+    expect(formatYMD(oneDecadeAhead(parseYMD('2020-11-30')))).toEqual('2030-11-30')
+    expect(formatYMD(oneDecadeAhead(parseYMD('2020-12-31')))).toEqual('2030-12-31')
+  })
+
+  it('constrainDate() works', async () => {
+    const min = parseYMD('2020-01-05')
+    const max = parseYMD('2020-01-15')
+    const date1 = parseYMD('2020-01-10')
+    const date2 = parseYMD('2020-01-01')
+    const date3 = parseYMD('2020-01-20')
+
+    expect(constrainDate(null, null, null)).toEqual(null)
+    expect(constrainDate(null, min, max)).toEqual(null)
+
+    expect(constrainDate(date1, null, null)).not.toEqual(null)
+    expect(constrainDate(date1, null, null).toISOString()).toEqual(date1.toISOString())
+
+    expect(constrainDate(date1, min, max)).not.toEqual(null)
+    expect(constrainDate(date1, min, max).toISOString()).toEqual(date1.toISOString())
+
+    expect(constrainDate(date2, min, max)).not.toEqual(null)
+    expect(constrainDate(date2, min, max).toISOString()).toEqual(min.toISOString())
+    expect(constrainDate(date2, '', max)).not.toEqual(null)
+    expect(constrainDate(date2, '', max).toISOString()).toEqual(date2.toISOString())
+    expect(constrainDate(date2, null, max)).not.toEqual(null)
+    expect(constrainDate(date2, null, max).toISOString()).toEqual(date2.toISOString())
+
+    expect(constrainDate(date3, min, max)).not.toEqual(null)
+    expect(constrainDate(date3, min, max).toISOString()).toEqual(max.toISOString())
+    expect(constrainDate(date3, min, '')).not.toEqual(null)
+    expect(constrainDate(date3, min, '').toISOString()).toEqual(date3.toISOString())
+    expect(constrainDate(date3, min, null)).not.toEqual(null)
+    expect(constrainDate(date3, min, null).toISOString()).toEqual(date3.toISOString())
+  })
+})

package/src/vendor/bootstrap-vue/src/utils/dom.js

@@ -0,0 +1,308 @@
+import { DOCUMENT, WINDOW } from '../constants/env'
+import { Element } from '../constants/safe-types'
+import { from as arrayFrom } from './array'
+import { isFunction, isNull } from './inspect'
+import { toFloat } from './number'
+import { toString } from './string'
+
+// --- Constants ---
+
+const ELEMENT_PROTO = Element.prototype
+
+const TABABLE_SELECTOR = [
+  'button',
+  '[href]:not(.disabled)',
+  'input',
+  'select',
+  'textarea',
+  '[tabindex]',
+  '[contenteditable]'
+]
+  .map(s => `${s}:not(:disabled):not([disabled])`)
+  .join(', ')
+
+// --- Normalization utils ---
+
+// See: https://developer.mozilla.org/en-US/docs/Web/API/Element/matches#Polyfill
+/* istanbul ignore next */
+export const matchesEl =
+  ELEMENT_PROTO.matches || ELEMENT_PROTO.msMatchesSelector || ELEMENT_PROTO.webkitMatchesSelector
+
+// See: https://developer.mozilla.org/en-US/docs/Web/API/Element/closest
+/* istanbul ignore next */
+export const closestEl =
+  ELEMENT_PROTO.closest ||
+  function(sel) {
+    let el = this
+    do {
+      // Use our "patched" matches function
+      if (matches(el, sel)) {
+        return el
+      }
+      el = el.parentElement || el.parentNode
+    } while (!isNull(el) && el.nodeType === Node.ELEMENT_NODE)
+    return null
+  }
+
+// `requestAnimationFrame()` convenience method
+/* istanbul ignore next: JSDOM always returns the first option */
+export const requestAF = (
+  WINDOW.requestAnimationFrame ||
+  WINDOW.webkitRequestAnimationFrame ||
+  WINDOW.mozRequestAnimationFrame ||
+  WINDOW.msRequestAnimationFrame ||
+  WINDOW.oRequestAnimationFrame ||
+  // Fallback, but not a true polyfill
+  // Only needed for Opera Mini
+  /* istanbul ignore next */
+  (cb => setTimeout(cb, 16))
+).bind(WINDOW)
+
+export const MutationObs =
+  WINDOW.MutationObserver || WINDOW.WebKitMutationObserver || WINDOW.MozMutationObserver || null
+
+// --- Utils ---
+
+// Remove a node from DOM
+export const removeNode = el => el && el.parentNode && el.parentNode.removeChild(el)
+
+// Determine if an element is an HTML element
+export const isElement = el => !!(el && el.nodeType === Node.ELEMENT_NODE)
+
+// Get the currently active HTML element
+export const getActiveElement = (excludes = []) => {
+  const { activeElement } = DOCUMENT
+  return activeElement && !excludes.some(el => el === activeElement) ? activeElement : null
+}
+
+// Returns `true` if a tag's name equals `name`
+export const isTag = (tag, name) => toString(tag).toLowerCase() === toString(name).toLowerCase()
+
+// Determine if an HTML element is the currently active element
+export const isActiveElement = el => isElement(el) && el === getActiveElement()
+
+// Determine if an HTML element is visible - Faster than CSS check
+export const isVisible = el => {
+  if (!isElement(el) || !el.parentNode || !contains(DOCUMENT.body, el)) {
+    // Note this can fail for shadow dom elements since they
+    // are not a direct descendant of document.body
+    return false
+  }
+  if (getStyle(el, 'display') === 'none') {
+    // We do this check to help with vue-test-utils when using v-show
+    /* istanbul ignore next */
+    return false
+  }
+  // All browsers support getBoundingClientRect(), except JSDOM as it returns all 0's for values :(
+  // So any tests that need isVisible will fail in JSDOM
+  // Except when we override the getBCR prototype in some tests
+  const bcr = getBCR(el)
+  return !!(bcr && bcr.height > 0 && bcr.width > 0)
+}
+
+// Determine if an element is disabled
+export const isDisabled = el =>
+  !isElement(el) || el.disabled || hasAttr(el, 'disabled') || hasClass(el, 'disabled')
+
+// Cause/wait-for an element to reflow its content (adjusting its height/width)
+export const reflow = el => {
+  // Requesting an elements offsetHight will trigger a reflow of the element content
+  /* istanbul ignore next: reflow doesn't happen in JSDOM */
+  return isElement(el) && el.offsetHeight
+}
+
+// Select all elements matching selector. Returns `[]` if none found
+export const selectAll = (selector, root) =>
+  arrayFrom((isElement(root) ? root : DOCUMENT).querySelectorAll(selector))
+
+// Select a single element, returns `null` if not found
+export const select = (selector, root) =>
+  (isElement(root) ? root : DOCUMENT).querySelector(selector) || null
+
+// Determine if an element matches a selector
+export const matches = (el, selector) => (isElement(el) ? matchesEl.call(el, selector) : false)
+
+// Finds closest element matching selector. Returns `null` if not found
+export const closest = (selector, root, includeRoot = false) => {
+  if (!isElement(root)) {
+    return null
+  }
+  const el = closestEl.call(root, selector)
+
+  // Native closest behaviour when `includeRoot` is truthy,
+  // else emulate jQuery closest and return `null` if match is
+  // the passed in root element when `includeRoot` is falsey
+  return includeRoot ? el : el === root ? null : el
+}
+
+// Returns true if the parent element contains the child element
+export const contains = (parent, child) =>
+  parent && isFunction(parent.contains) ? parent.contains(child) : false
+
+// Get an element given an ID
+export const getById = id => DOCUMENT.getElementById(/^#/.test(id) ? id.slice(1) : id) || null
+
+// Add a class to an element
+export const addClass = (el, className) => {
+  // We are checking for `el.classList` existence here since IE 11
+  // returns `undefined` for some elements (e.g. SVG elements)
+  // See https://github.com/bootstrap-vue/bootstrap-vue/issues/2713
+  if (className && isElement(el) && el.classList) {
+    el.classList.add(className)
+  }
+}
+
+// Remove a class from an element
+export const removeClass = (el, className) => {
+  // We are checking for `el.classList` existence here since IE 11
+  // returns `undefined` for some elements (e.g. SVG elements)
+  // See https://github.com/bootstrap-vue/bootstrap-vue/issues/2713
+  if (className && isElement(el) && el.classList) {
+    el.classList.remove(className)
+  }
+}
+
+// Test if an element has a class
+export const hasClass = (el, className) => {
+  // We are checking for `el.classList` existence here since IE 11
+  // returns `undefined` for some elements (e.g. SVG elements)
+  // See https://github.com/bootstrap-vue/bootstrap-vue/issues/2713
+  if (className && isElement(el) && el.classList) {
+    return el.classList.contains(className)
+  }
+  return false
+}
+
+// Set an attribute on an element
+export const setAttr = (el, attr, value) => {
+  if (attr && isElement(el)) {
+    el.setAttribute(attr, value)
+  }
+}
+
+// Remove an attribute from an element
+export const removeAttr = (el, attr) => {
+  if (attr && isElement(el)) {
+    el.removeAttribute(attr)
+  }
+}
+
+// Get an attribute value from an element
+// Returns `null` if not found
+export const getAttr = (el, attr) => (attr && isElement(el) ? el.getAttribute(attr) : null)
+
+// Determine if an attribute exists on an element
+// Returns `true` or `false`, or `null` if element not found
+export const hasAttr = (el, attr) => (attr && isElement(el) ? el.hasAttribute(attr) : null)
+
+// Set an style property on an element
+export const setStyle = (el, prop, value) => {
+  if (prop && isElement(el)) {
+    el.style[prop] = value
+  }
+}
+
+// Remove an style property from an element
+export const removeStyle = (el, prop) => {
+  if (prop && isElement(el)) {
+    el.style[prop] = ''
+  }
+}
+
+// Get an style property value from an element
+// Returns `null` if not found
+export const getStyle = (el, prop) => (prop && isElement(el) ? el.style[prop] || null : null)
+
+// Return the Bounding Client Rect of an element
+// Returns `null` if not an element
+/* istanbul ignore next: getBoundingClientRect() doesn't work in JSDOM */
+export const getBCR = el => (isElement(el) ? el.getBoundingClientRect() : null)
+
+// Get computed style object for an element
+/* istanbul ignore next: getComputedStyle() doesn't work in JSDOM */
+export const getCS = el => {
+  const { getComputedStyle } = WINDOW
+  return getComputedStyle && isElement(el) ? getComputedStyle(el) : {}
+}
+
+// Returns a `Selection` object representing the range of text selected
+// Returns `null` if no window support is given
+/* istanbul ignore next: getSelection() doesn't work in JSDOM */
+export const getSel = () => {
+  const { getSelection } = WINDOW
+  return getSelection ? WINDOW.getSelection() : null
+}
+
+// Return an element's offset with respect to document element
+// https://j11y.io/jquery/#v=git&fn=jQuery.fn.offset
+export const offset = el => /* istanbul ignore next: getBoundingClientRect(), getClientRects() doesn't work in JSDOM */ {
+  const _offset = { top: 0, left: 0 }
+  if (!isElement(el) || el.getClientRects().length === 0) {
+    return _offset
+  }
+  const bcr = getBCR(el)
+  if (bcr) {
+    const win = el.ownerDocument.defaultView
+    _offset.top = bcr.top + win.pageYOffset
+    _offset.left = bcr.left + win.pageXOffset
+  }
+  return _offset
+}
+
+// Return an element's offset with respect to to its offsetParent
+// https://j11y.io/jquery/#v=git&fn=jQuery.fn.position
+export const position = el => /* istanbul ignore next: getBoundingClientRect() doesn't work in JSDOM */ {
+  let _offset = { top: 0, left: 0 }
+  if (!isElement(el)) {
+    return _offset
+  }
+  let parentOffset = { top: 0, left: 0 }
+  const elStyles = getCS(el)
+  if (elStyles.position === 'fixed') {
+    _offset = getBCR(el) || _offset
+  } else {
+    _offset = offset(el)
+    const doc = el.ownerDocument
+    let offsetParent = el.offsetParent || doc.documentElement
+    while (
+      offsetParent &&
+      (offsetParent === doc.body || offsetParent === doc.documentElement) &&
+      getCS(offsetParent).position === 'static'
+    ) {
+      offsetParent = offsetParent.parentNode
+    }
+    if (offsetParent && offsetParent !== el && offsetParent.nodeType === Node.ELEMENT_NODE) {
+      parentOffset = offset(offsetParent)
+      const offsetParentStyles = getCS(offsetParent)
+      parentOffset.top += toFloat(offsetParentStyles.borderTopWidth, 0)
+      parentOffset.left += toFloat(offsetParentStyles.borderLeftWidth, 0)
+    }
+  }
+  return {
+    top: _offset.top - parentOffset.top - toFloat(elStyles.marginTop, 0),
+    left: _offset.left - parentOffset.left - toFloat(elStyles.marginLeft, 0)
+  }
+}
+
+// Find all tabable elements in the given element
+// Assumes users have not used `tabindex` > `0` on elements
+export const getTabables = (rootEl = document) =>
+  selectAll(TABABLE_SELECTOR, rootEl)
+    .filter(isVisible)
+    .filter(el => el.tabIndex > -1 && !el.disabled)
+
+// Attempt to focus an element, and return `true` if successful
+export const attemptFocus = (el, options = {}) => {
+  try {
+    el.focus(options)
+  } catch {}
+  return isActiveElement(el)
+}
+
+// Attempt to blur an element, and return `true` if successful
+export const attemptBlur = el => {
+  try {
+    el.blur()
+  } catch {}
+  return !isActiveElement(el)
+}