@gitlab/duo-ui 3.0.0 → 3.0.1

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

@@ -1,71 +0,0 @@
-import { HAS_PASSIVE_EVENT_SUPPORT } from '../constants/env'
-import { ROOT_EVENT_NAME_PREFIX, ROOT_EVENT_NAME_SEPARATOR } from '../constants/events'
-import { RX_BV_PREFIX } from '../constants/regex'
-import { isObject } from './inspect'
-import { kebabCase } from './string'
-
-// --- Utils ---
-
-// Normalize event options based on support of passive option
-// Exported only for testing purposes
-export const parseEventOptions = options => {
-  /* istanbul ignore else: can't test in JSDOM, as it supports passive */
-  if (HAS_PASSIVE_EVENT_SUPPORT) {
-    return isObject(options) ? options : { capture: !!options || false }
-  } else {
-    // Need to translate to actual Boolean value
-    return !!(isObject(options) ? options.capture : options)
-  }
-}
-
-// Attach an event listener to an element
-export const eventOn = (el, eventName, handler, options) => {
-  if (el && el.addEventListener) {
-    el.addEventListener(eventName, handler, parseEventOptions(options))
-  }
-}
-
-// Remove an event listener from an element
-export const eventOff = (el, eventName, handler, options) => {
-  if (el && el.removeEventListener) {
-    el.removeEventListener(eventName, handler, parseEventOptions(options))
-  }
-}
-
-// Utility method to add/remove a event listener based on first argument (boolean)
-// It passes all other arguments to the `eventOn()` or `eventOff` method
-export const eventOnOff = (on, ...args) => {
-  const method = on ? eventOn : eventOff
-  method(...args)
-}
-
-// Utility method to prevent the default event handling and propagation
-export const stopEvent = (
-  event,
-  { preventDefault = true, propagation = true, immediatePropagation = false } = {}
-) => {
-  if (preventDefault) {
-    event.preventDefault()
-  }
-  if (propagation) {
-    event.stopPropagation()
-  }
-  if (immediatePropagation) {
-    event.stopImmediatePropagation()
-  }
-}
-
-// Helper method to convert a component/directive name to a base event name
-// `getBaseEventName('BNavigationItem')` => 'navigation-item'
-// `getBaseEventName('BVToggle')` => 'toggle'
-const getBaseEventName = value => kebabCase(value.replace(RX_BV_PREFIX, ''))
-
-// Get a root event name by component/directive and event name
-// `getBaseEventName('BModal', 'show')` => 'bv::modal::show'
-export const getRootEventName = (name, eventName) =>
-  [ROOT_EVENT_NAME_PREFIX, getBaseEventName(name), eventName].join(ROOT_EVENT_NAME_SEPARATOR)
-
-// Get a root action event name by component/directive and action name
-// `getRootActionEventName('BModal', 'show')` => 'bv::show::modal'
-export const getRootActionEventName = (name, actionName) =>
-  [ROOT_EVENT_NAME_PREFIX, actionName, getBaseEventName(name)].join(ROOT_EVENT_NAME_SEPARATOR)

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

@@ -1,41 +0,0 @@
-import { HAS_PASSIVE_EVENT_SUPPORT } from '../constants/env'
-import { parseEventOptions } from './events'
-
-describe('utils/events', () => {
-  it('event options parsing works', async () => {
-    // JSDOM probably does not support passive mode
-    if (HAS_PASSIVE_EVENT_SUPPORT) {
-      // Converts boolean to object
-      expect(parseEventOptions(true)).toEqual({ capture: true })
-      expect(parseEventOptions(false)).toEqual({ capture: false })
-      expect(parseEventOptions()).toEqual({ capture: false })
-
-      // Parses object correctly (returns as-is)
-      expect(parseEventOptions({ capture: false })).toEqual({ capture: false })
-      expect(parseEventOptions({ capture: true })).toEqual({ capture: true })
-      expect(parseEventOptions({})).toEqual({})
-      expect(parseEventOptions({ capture: false, foobar: true })).toEqual({
-        capture: false,
-        foobar: true
-      })
-      expect(parseEventOptions({ capture: true, foobar: false })).toEqual({
-        capture: true,
-        foobar: false
-      })
-    } else {
-      // Converts non object to boolean
-      expect(parseEventOptions(true)).toEqual(true)
-      expect(parseEventOptions(false)).toEqual(false)
-      expect(parseEventOptions()).toEqual(false)
-      expect(parseEventOptions(null)).toEqual(false)
-      // Converts object to boolean
-      expect(parseEventOptions({ capture: false })).toEqual(false)
-      expect(parseEventOptions({ capture: true })).toEqual(true)
-      expect(parseEventOptions({})).toEqual(false)
-      expect(parseEventOptions({ capture: false, foobar: true })).toEqual(false)
-      expect(parseEventOptions({ capture: true, foobar: true })).toEqual(true)
-      expect(parseEventOptions({ foobar: true })).toEqual(false)
-      expect(parseEventOptions({ foobar: false })).toEqual(false)
-    }
-  })
-})

package/src/vendor/bootstrap-vue/src/utils/get-event-root.js

@@ -1,3 +0,0 @@
-export const getEventRoot = vm => {
-  return vm.$root.$options.bvEventRoot || vm.$root
-}

package/src/vendor/bootstrap-vue/src/utils/get-instance-from-directive.js

@@ -1,4 +0,0 @@
-import { isVue3 } from '../vue'
-
-export const getInstanceFromDirective = (vnode, bindings) =>
-  isVue3 ? bindings.instance : vnode.context

package/src/vendor/bootstrap-vue/src/utils/get-scope-id.js

@@ -1,6 +0,0 @@
-// This method returns a component's scoped style attribute name: `data-v-xxxxxxx`
-// The `_scopeId` options property is added by vue-loader when using scoped styles
-// and will be `undefined` if no scoped styles are in use
-export const getScopeId = (vm, defaultValue = null) => {
-  return vm ? vm.$options._scopeId || defaultValue : defaultValue
-}

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

@@ -1,64 +0,0 @@
-import { RX_ARRAY_NOTATION } from '../constants/regex'
-import { identity } from './identity'
-import { isArray, isNull, isObject, isUndefinedOrNull } from './inspect'
-
-/**
- * Get property defined by dot/array notation in string, returns undefined if not found
- *
- * @link https://gist.github.com/jeneg/9767afdcca45601ea44930ea03e0febf#gistcomment-1935901
- *
- * @param {Object} obj
- * @param {string|Array} path
- * @return {*}
- */
-export const getRaw = (obj, path, defaultValue = undefined) => {
-  // Handle array of path values
-  path = isArray(path) ? path.join('.') : path
-
-  // If no path or no object passed
-  if (!path || !isObject(obj)) {
-    return defaultValue
-  }
-
-  // Handle edge case where user has dot(s) in top-level item field key
-  // See https://github.com/bootstrap-vue/bootstrap-vue/issues/2762
-  // Switched to `in` operator vs `hasOwnProperty` to handle obj.prototype getters
-  // https://github.com/bootstrap-vue/bootstrap-vue/issues/3463
-  if (path in obj) {
-    return obj[path]
-  }
-
-  // Handle string array notation (numeric indices only)
-  path = String(path).replace(RX_ARRAY_NOTATION, '.$1')
-
-  const steps = path.split('.').filter(identity)
-
-  // Handle case where someone passes a string of only dots
-  if (steps.length === 0) {
-    return defaultValue
-  }
-
-  // Traverse path in object to find result
-  // Switched to `in` operator vs `hasOwnProperty` to handle obj.prototype getters
-  // https://github.com/bootstrap-vue/bootstrap-vue/issues/3463
-  return steps.every(step => isObject(obj) && step in obj && !isUndefinedOrNull((obj = obj[step])))
-    ? obj
-    : isNull(obj)
-      ? null
-      : defaultValue
-}
-
-/**
- * Get property defined by dot/array notation in string.
- *
- * @link https://gist.github.com/jeneg/9767afdcca45601ea44930ea03e0febf#gistcomment-1935901
- *
- * @param {Object} obj
- * @param {string|Array} path
- * @param {*} defaultValue (optional)
- * @return {*}
- */
-export const get = (obj, path, defaultValue = null) => {
-  const value = getRaw(obj, path)
-  return isUndefinedOrNull(value) ? defaultValue : value
-}

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

@@ -1,109 +0,0 @@
-import { get } from './get'
-
-describe('get', () => {
-  it('handles invalid values gracefully', async () => {
-    expect(get(null, '')).toBe(null)
-    expect(get({}, null)).toBe(null)
-    expect(get({}, '')).toBe(null)
-    expect(get({}, 'a')).toBe(null)
-    expect(get({}, [])).toBe(null)
-    expect(get({ a: 'b' }, 'b')).toBe(null)
-    expect(get({ a: { c: 'd' } }, 'a.d')).toBe(null)
-  })
-
-  it('returns expected default value', async () => {
-    expect(get(null, '')).toBe(null)
-    expect(get({}, null, undefined)).toBe(null)
-    expect(get({}, '', true)).toBe(true)
-    expect(get({}, 'a', '')).toBe('')
-    expect(get({}, [], 0)).toBe(0)
-    expect(get({ a: 'b' }, 'b', {})).toEqual({})
-    expect(get({ a: { c: 'd' } }, 'a.d', [])).toEqual([])
-    expect(get({ a: { c: undefined } }, 'a.c')).toBe(null)
-    expect(get({ a: 0, b: false }, 'c')).toBe(null)
-  })
-
-  it('returns expected value', async () => {
-    const obj1 = { a: 'b' }
-    const obj2 = { a: { b: { c: { d: 'e' } } } }
-    const obj3 = { a: [{ b: 'c' }] }
-    const obj4 = { a: [[{ b: 'c' }], [{ d: { e: ['f'] } }]] }
-    const obj5 = { a: { b: 0, c: '', d: false } }
-    const obj6 = { a: 0, b: false }
-
-    expect(get(obj1, 'a')).toBe('b')
-    expect(get(obj1, ['a'])).toBe('b')
-    expect(get(obj2, 'a.b.c.d')).toBe('e')
-    expect(get(obj2, ['a', 'b', 'c', 'd'])).toBe('e')
-    expect(get(obj3, 'a[0].b')).toBe('c')
-    expect(get(obj3, ['a', 0, 'b'])).toBe('c')
-    expect(get(obj4, 'a[1][0].d.e[0]')).toBe('f')
-    expect(get(obj4, ['a', 1, 0, 'd', 'e', 0])).toBe('f')
-    expect(get(obj4, ['a[1]', 0, 'd', 'e[0]'])).toBe('f')
-    expect(get(obj5, 'a.b')).toBe(0)
-    expect(get(obj5, 'a.c')).toBe('')
-    expect(get(obj5, 'a.d')).toBe(false)
-    expect(get(obj6, 'a')).toBe(0)
-    expect(get(obj6, 'b')).toBe(false)
-  })
-
-  it('handles when field name has dot', async () => {
-    // https://github.com/bootstrap-vue/bootstrap-vue/issues/2762
-    const obj1 = {
-      'a.b': 'foo',
-      a: { b: 'fiz' },
-      c: 'bar',
-      d: { e: 'baz' },
-      f: { 'g.h': 'faz' },
-      'i.j.k': 'fuz'
-    }
-    const obj2 = {
-      a: { b: 'fiz' },
-      c: 'bar',
-      d: { e: 'baz' }
-    }
-
-    expect(get(obj1, 'a.b')).toBe('foo')
-    expect(get(obj1, 'c')).toBe('bar')
-    expect(get(obj1, 'd.e')).toBe('baz')
-    expect(get(obj1, 'f.g.h', 'zzz')).toBe('zzz')
-    expect(get(obj1, 'f.g.h')).toBe(null)
-    expect(get(obj1, 'f.g', 'zzz')).toBe('zzz')
-    expect(get(obj1, 'f.g')).toBe(null)
-    expect(get(obj1, 'i.j.k')).toBe('fuz')
-    expect(get(obj1, 'i.j', 'zzz')).toBe('zzz')
-    expect(get(obj1, 'i.j')).toBe(null)
-
-    expect(get({ a: 'b' }, '...', true)).toBe(true)
-    expect(get({ a: 'b' }, '...')).toBe(null)
-
-    expect(get(obj2, 'a.b')).toBe('fiz')
-    expect(get(obj2, 'c')).toBe('bar')
-    expect(get(obj2, 'd.e')).toBe('baz')
-  })
-
-  it('handles when field value is not array or object', async () => {
-    // https://github.com/bootstrap-vue/bootstrap-vue/issues/2807
-    const obj1 = {
-      a: { b: 'c' },
-      b: [{ c: 'd' }],
-      c: { d: { e: 'f' } },
-      d: [{ e: [{ f: 'g' }] }]
-    }
-    const obj2 = {
-      a: null,
-      b: undefined,
-      c: 0,
-      d: [null]
-    }
-
-    expect(get(obj1, 'a.b')).toBe('c')
-    expect(get(obj2, 'a.b')).toBe(null)
-    expect(get(obj1, 'b[0].c')).toBe('d')
-    expect(get(obj2, 'b[0].c')).toBe(null)
-    expect(get(obj1, 'c.d.e')).toBe('f')
-    expect(get(obj2, 'c.d.e')).toBe(null)
-    expect(get(obj1, 'd[0].e[0].f')).toBe('g')
-    expect(get(obj2, 'd[0].e[0].f')).toBe(null)
-  })
-})

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

@@ -1,8 +0,0 @@
-import { RX_HTML_TAGS } from '../constants/regex'
-
-// Removes anything that looks like an HTML tag from the supplied string
-export const stripTags = (text = '') => String(text).replace(RX_HTML_TAGS, '')
-
-// Generate a `domProps` object for either `innerHTML`, `textContent` or an empty object
-export const htmlOrText = (innerHTML, textContent) =>
-  innerHTML ? { innerHTML } : textContent ? { textContent } : {}

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

@@ -1 +0,0 @@
-export const identity = x => x

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

@@ -1,51 +0,0 @@
-import { RX_NUMBER } from '../constants/regex'
-import { File } from '../constants/safe-types'
-
-// --- Convenience inspection utilities ---
-
-export const toType = value => typeof value
-
-export const toRawType = value => Object.prototype.toString.call(value).slice(8, -1)
-
-export const toRawTypeLC = value => toRawType(value).toLowerCase()
-
-export const isUndefined = value => value === undefined
-
-export const isNull = value => value === null
-
-export const isUndefinedOrNull = value => isUndefined(value) || isNull(value)
-
-export const isFunction = value => toType(value) === 'function'
-
-export const isBoolean = value => toType(value) === 'boolean'
-
-export const isString = value => toType(value) === 'string'
-
-export const isNumber = value => toType(value) === 'number'
-
-export const isNumeric = value => RX_NUMBER.test(String(value))
-
-export const isPrimitive = value => isBoolean(value) || isString(value) || isNumber(value)
-
-export const isArray = value => Array.isArray(value)
-
-// Quick object check
-// This is primarily used to tell Objects from primitive values
-// when we know the value is a JSON-compliant type
-// Note object could be a complex type like array, Date, etc.
-export const isObject = obj => obj !== null && typeof obj === 'object'
-
-// Strict object type check
-// Only returns true for plain JavaScript objects
-export const isPlainObject = obj => Object.prototype.toString.call(obj) === '[object Object]'
-
-export const isDate = value => value instanceof Date
-
-export const isEvent = value => value instanceof Event
-
-export const isFile = value => value instanceof File
-
-export const isRegExp = value => toRawType(value) === 'RegExp'
-
-export const isPromise = value =>
-  !isUndefinedOrNull(value) && isFunction(value.then) && isFunction(value.catch)

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

@@ -1,251 +0,0 @@
-import {
-  toType,
-  toRawType,
-  toRawTypeLC,
-  isUndefined,
-  isNull,
-  isUndefinedOrNull,
-  isFunction,
-  isBoolean,
-  isString,
-  isNumber,
-  isNumeric,
-  isPrimitive,
-  isDate,
-  isEvent,
-  isRegExp,
-  isPromise
-} from './inspect'
-
-describe('utils/inspect', () => {
-  it('toType()', async () => {
-    expect(toType(123)).toEqual('number')
-    expect(toType('123')).toEqual('string')
-    expect(toType(true)).toEqual('boolean')
-    expect(toType({})).toEqual('object')
-    expect(toType([])).toEqual('object')
-    expect(toType(/abc/)).toEqual('object')
-    expect(toType(() => {})).toEqual('function')
-    expect(toType(Date)).toEqual('function')
-    expect(toType(new Date())).toEqual('object')
-    expect(toType(undefined)).toEqual('undefined')
-    expect(toType(null)).toEqual('object')
-  })
-
-  it('toRawType()', async () => {
-    expect(toRawType(123)).toEqual('Number')
-    expect(toRawType('123')).toEqual('String')
-    expect(toRawType(true)).toEqual('Boolean')
-    expect(toRawType({})).toEqual('Object')
-    expect(toRawType([])).toEqual('Array')
-    expect(toRawType(/abc/)).toEqual('RegExp')
-    expect(toRawType(() => {})).toEqual('Function')
-    expect(toRawType(Date)).toEqual('Function')
-    expect(toRawType(new Date())).toEqual('Date')
-    expect(toRawType(undefined)).toEqual('Undefined')
-    expect(toRawType(null)).toEqual('Null')
-  })
-
-  it('toRawTypeLC()', async () => {
-    expect(toRawTypeLC(123)).toEqual('number')
-    expect(toRawTypeLC('123')).toEqual('string')
-    expect(toRawTypeLC(true)).toEqual('boolean')
-    expect(toRawTypeLC({})).toEqual('object')
-    expect(toRawTypeLC([])).toEqual('array')
-    expect(toRawTypeLC(/abc/)).toEqual('regexp')
-    expect(toRawTypeLC(() => {})).toEqual('function')
-    expect(toRawTypeLC(Date)).toEqual('function')
-    expect(toRawTypeLC(new Date())).toEqual('date')
-    expect(toRawTypeLC(undefined)).toEqual('undefined')
-    expect(toRawTypeLC(null)).toEqual('null')
-  })
-
-  it('isUndefined()', async () => {
-    expect(isUndefined(123)).toEqual(false)
-    expect(isUndefined('123')).toEqual(false)
-    expect(isUndefined(true)).toEqual(false)
-    expect(isUndefined({})).toEqual(false)
-    expect(isUndefined([])).toEqual(false)
-    expect(isUndefined(/abc/)).toEqual(false)
-    expect(isUndefined(() => {})).toEqual(false)
-    expect(isUndefined(Date)).toEqual(false)
-    expect(isUndefined(new Date())).toEqual(false)
-    expect(isUndefined(undefined)).toEqual(true)
-    expect(isUndefined(null)).toEqual(false)
-  })
-
-  it('isNull()', async () => {
-    expect(isNull(123)).toEqual(false)
-    expect(isNull('123')).toEqual(false)
-    expect(isNull(true)).toEqual(false)
-    expect(isNull({})).toEqual(false)
-    expect(isNull([])).toEqual(false)
-    expect(isNull(/abc/)).toEqual(false)
-    expect(isNull(() => {})).toEqual(false)
-    expect(isNull(Date)).toEqual(false)
-    expect(isNull(new Date())).toEqual(false)
-    expect(isNull(undefined)).toEqual(false)
-    expect(isNull(null)).toEqual(true)
-  })
-
-  it('isUndefinedOrNull()', async () => {
-    expect(isUndefinedOrNull(123)).toEqual(false)
-    expect(isUndefinedOrNull('123')).toEqual(false)
-    expect(isUndefinedOrNull(true)).toEqual(false)
-    expect(isUndefinedOrNull({})).toEqual(false)
-    expect(isUndefinedOrNull([])).toEqual(false)
-    expect(isUndefinedOrNull(/abc/)).toEqual(false)
-    expect(isUndefinedOrNull(() => {})).toEqual(false)
-    expect(isUndefinedOrNull(Date)).toEqual(false)
-    expect(isUndefinedOrNull(new Date())).toEqual(false)
-    expect(isUndefinedOrNull(undefined)).toEqual(true)
-    expect(isUndefinedOrNull(null)).toEqual(true)
-  })
-
-  it('isFunction()', async () => {
-    expect(isFunction(123)).toEqual(false)
-    expect(isFunction('123')).toEqual(false)
-    expect(isFunction(true)).toEqual(false)
-    expect(isFunction({})).toEqual(false)
-    expect(isFunction([])).toEqual(false)
-    expect(isFunction(/abc/)).toEqual(false)
-    expect(isFunction(() => {})).toEqual(true)
-    expect(isFunction(Date)).toEqual(true)
-    expect(isFunction(new Date())).toEqual(false)
-    expect(isFunction(undefined)).toEqual(false)
-    expect(isFunction(null)).toEqual(false)
-  })
-
-  it('isBoolean()', async () => {
-    expect(isBoolean(123)).toEqual(false)
-    expect(isBoolean('123')).toEqual(false)
-    expect(isBoolean(true)).toEqual(true)
-    expect(isBoolean({})).toEqual(false)
-    expect(isBoolean([])).toEqual(false)
-    expect(isBoolean(/abc/)).toEqual(false)
-    expect(isBoolean(() => {})).toEqual(false)
-    expect(isBoolean(Date)).toEqual(false)
-    expect(isBoolean(new Date())).toEqual(false)
-    expect(isBoolean(undefined)).toEqual(false)
-    expect(isBoolean(null)).toEqual(false)
-  })
-
-  it('isString()', async () => {
-    expect(isString(123)).toEqual(false)
-    expect(isString('123')).toEqual(true)
-    expect(isString(true)).toEqual(false)
-    expect(isString({})).toEqual(false)
-    expect(isString([])).toEqual(false)
-    expect(isString(/abc/)).toEqual(false)
-    expect(isString(() => {})).toEqual(false)
-    expect(isString(Date)).toEqual(false)
-    expect(isString(new Date())).toEqual(false)
-    expect(isString(undefined)).toEqual(false)
-    expect(isString(null)).toEqual(false)
-  })
-
-  it('isNumber()', async () => {
-    expect(isNumber(123)).toEqual(true)
-    expect(isNumber(123.5)).toEqual(true)
-    expect(isNumber('123')).toEqual(false)
-    expect(isNumber(true)).toEqual(false)
-    expect(isNumber({})).toEqual(false)
-    expect(isNumber([])).toEqual(false)
-    expect(isNumber(/abc/)).toEqual(false)
-    expect(isNumber(() => {})).toEqual(false)
-    expect(isNumber(Date)).toEqual(false)
-    expect(isNumber(new Date())).toEqual(false)
-    expect(isNumber(undefined)).toEqual(false)
-    expect(isNumber(null)).toEqual(false)
-  })
-
-  it('isNumeric()', async () => {
-    expect(isNumeric(123)).toEqual(true)
-    expect(isNumeric(123.5)).toEqual(true)
-    expect(isNumeric('123')).toEqual(true)
-    expect(isNumeric('123.5')).toEqual(true)
-    expect(isNumeric('123,5')).toEqual(false)
-    expect(isNumeric(true)).toEqual(false)
-    expect(isNumeric({})).toEqual(false)
-    expect(isNumeric([])).toEqual(false)
-    expect(isNumeric(/abc/)).toEqual(false)
-    expect(isNumeric(() => {})).toEqual(false)
-    expect(isNumeric(Date)).toEqual(false)
-    expect(isNumeric(new Date())).toEqual(false)
-    expect(isNumeric(undefined)).toEqual(false)
-    expect(isNumeric(null)).toEqual(false)
-  })
-
-  it('isPrimitive()', async () => {
-    expect(isPrimitive(123)).toEqual(true)
-    expect(isPrimitive('123')).toEqual(true)
-    expect(isPrimitive(true)).toEqual(true)
-    expect(isPrimitive({})).toEqual(false)
-    expect(isPrimitive([])).toEqual(false)
-    expect(isPrimitive(/abc/)).toEqual(false)
-    expect(isPrimitive(() => {})).toEqual(false)
-    expect(isPrimitive(Date)).toEqual(false)
-    expect(isPrimitive(new Date())).toEqual(false)
-    expect(isPrimitive(undefined)).toEqual(false)
-    expect(isPrimitive(null)).toEqual(false)
-  })
-
-  it('isDate()', async () => {
-    expect(isDate(123)).toEqual(false)
-    expect(isDate('123')).toEqual(false)
-    expect(isDate(true)).toEqual(false)
-    expect(isDate({})).toEqual(false)
-    expect(isDate([])).toEqual(false)
-    expect(isDate(/abc/)).toEqual(false)
-    expect(isDate(() => {})).toEqual(false)
-    expect(isDate(Date)).toEqual(false)
-    expect(isDate(new Date())).toEqual(true)
-    expect(isDate(undefined)).toEqual(false)
-    expect(isDate(null)).toEqual(false)
-  })
-
-  it('isEvent()', async () => {
-    expect(isEvent(123)).toEqual(false)
-    expect(isEvent('123')).toEqual(false)
-    expect(isEvent(true)).toEqual(false)
-    expect(isEvent({})).toEqual(false)
-    expect(isEvent([])).toEqual(false)
-    expect(isEvent(/abc/)).toEqual(false)
-    expect(isEvent(() => {})).toEqual(false)
-    expect(isEvent(Date)).toEqual(false)
-    expect(isEvent(new Date())).toEqual(false)
-    expect(isEvent(Event)).toEqual(false)
-    expect(isEvent(new Event('click'))).toEqual(true)
-    expect(isEvent(undefined)).toEqual(false)
-    expect(isEvent(null)).toEqual(false)
-  })
-
-  it('isRegExp()', async () => {
-    expect(isRegExp(123)).toEqual(false)
-    expect(isRegExp('123')).toEqual(false)
-    expect(isRegExp(true)).toEqual(false)
-    expect(isRegExp({})).toEqual(false)
-    expect(isRegExp([])).toEqual(false)
-    expect(isRegExp(/abc/)).toEqual(true)
-    expect(isRegExp(() => {})).toEqual(false)
-    expect(isRegExp(Date)).toEqual(false)
-    expect(isRegExp(new Date())).toEqual(false)
-    expect(isRegExp(undefined)).toEqual(false)
-    expect(isRegExp(null)).toEqual(false)
-  })
-
-  it('isPromise()', async () => {
-    expect(isPromise(123)).toEqual(false)
-    expect(isPromise('123')).toEqual(false)
-    expect(isPromise(true)).toEqual(false)
-    expect(isPromise({})).toEqual(false)
-    expect(isPromise([])).toEqual(false)
-    expect(isPromise(/abc/)).toEqual(false)
-    expect(isPromise(() => {})).toEqual(false)
-    expect(isPromise(Date)).toEqual(false)
-    expect(isPromise(new Date())).toEqual(false)
-    expect(isPromise(undefined)).toEqual(false)
-    expect(isPromise(null)).toEqual(false)
-    expect(isPromise({ then() {}, catch() {} })).toEqual(true)
-  })
-})

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

@@ -1,34 +0,0 @@
-// Localization utilities
-import { RX_STRIP_LOCALE_MODS } from '../constants/regex'
-import { arrayIncludes } from './array'
-import { toString } from './string'
-
-// Languages that are RTL
-const RTL_LANGS = [
-  'ar',
-  'az',
-  'ckb',
-  'fa',
-  'he',
-  'ks',
-  'lrc',
-  'mzn',
-  'ps',
-  'sd',
-  'te',
-  'ug',
-  'ur',
-  'yi'
-].map(locale => locale.toLowerCase())
-
-// Returns true if the locale is RTL
-export const isLocaleRTL = locale => {
-  // Determines if the locale is RTL (only single locale supported)
-  const parts = toString(locale)
-    .toLowerCase()
-    .replace(RX_STRIP_LOCALE_MODS, '')
-    .split('-')
-  const locale1 = parts.slice(0, 2).join('-')
-  const locale2 = parts[0]
-  return arrayIncludes(RTL_LANGS, locale1) || arrayIncludes(RTL_LANGS, locale2)
-}