@gitlab/ui 84.2.0 → 85.0.0

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

@@ -0,0 +1,55 @@
+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 isEmptyString = value => value === ''
+
+export const isUndefinedOrNull = value => isUndefined(value) || isNull(value)
+
+export const isUndefinedOrNullOrEmpty = value => isUndefinedOrNull(value) || isEmptyString(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

@@ -0,0 +1,251 @@
+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

@@ -0,0 +1,34 @@
+// 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)
+}

package/src/vendor/bootstrap-vue/src/utils/loose-equal.js

@@ -0,0 +1,57 @@
+import { hasOwnProperty, keys } from './object'
+import { isArray, isDate, isObject } from './inspect'
+
+// Assumes both a and b are arrays!
+// Handles when arrays are "sparse" (array.every(...) doesn't handle sparse)
+const compareArrays = (a, b) => {
+  if (a.length !== b.length) {
+    return false
+  }
+  let equal = true
+  for (let i = 0; equal && i < a.length; i++) {
+    equal = looseEqual(a[i], b[i])
+  }
+  return equal
+}
+
+/**
+ * Check if two values are loosely equal - that is,
+ * if they are plain objects, do they have the same shape?
+ * Returns boolean true or false
+ */
+export const looseEqual = (a, b) => {
+  if (a === b) {
+    return true
+  }
+  let aValidType = isDate(a)
+  let bValidType = isDate(b)
+  if (aValidType || bValidType) {
+    return aValidType && bValidType ? a.getTime() === b.getTime() : false
+  }
+  aValidType = isArray(a)
+  bValidType = isArray(b)
+  if (aValidType || bValidType) {
+    return aValidType && bValidType ? compareArrays(a, b) : false
+  }
+  aValidType = isObject(a)
+  bValidType = isObject(b)
+  if (aValidType || bValidType) {
+    /* istanbul ignore if: this if will probably never be called */
+    if (!aValidType || !bValidType) {
+      return false
+    }
+    const aKeysCount = keys(a).length
+    const bKeysCount = keys(b).length
+    if (aKeysCount !== bKeysCount) {
+      return false
+    }
+    for (const key in a) {
+      const aHasKey = hasOwnProperty(a, key)
+      const bHasKey = hasOwnProperty(b, key)
+      if ((aHasKey && !bHasKey) || (!aHasKey && bHasKey) || !looseEqual(a[key], b[key])) {
+        return false
+      }
+    }
+  }
+  return String(a) === String(b)
+}

package/src/vendor/bootstrap-vue/src/utils/loose-equal.spec.js

@@ -0,0 +1,203 @@
+import { looseEqual } from './loose-equal'
+
+describe('utils/looseEqual', () => {
+  it('compares booleans correctly', () => {
+    expect(looseEqual(true, true)).toBe(true)
+    expect(looseEqual(false, false)).toBe(true)
+    expect(looseEqual(true, false)).toBe(false)
+    expect(looseEqual(true, true)).toBe(true)
+    expect(looseEqual(true, 1)).toBe(false)
+    expect(looseEqual(false, 0)).toBe(false)
+  })
+
+  it('compares strings correctly', () => {
+    const text = 'Lorem ipsum'
+    const number = 1
+    const bool = true
+
+    expect(looseEqual(text, text)).toBe(true)
+    expect(looseEqual(text, text.slice(0, -1))).toBe(false)
+    expect(looseEqual(String(number), number)).toBe(true)
+    expect(looseEqual(String(bool), bool)).toBe(true)
+  })
+
+  it('compares numbers correctly', () => {
+    const number = 100
+    const decimal = 2.5
+    const multiplier = 1.0000001
+
+    expect(looseEqual(number, number)).toBe(true)
+    expect(looseEqual(number, number - 1)).toBe(false)
+    expect(looseEqual(decimal, decimal)).toBe(true)
+    expect(looseEqual(decimal, decimal * multiplier)).toBe(false)
+    expect(looseEqual(number, number * multiplier)).toBe(false)
+    expect(looseEqual(multiplier, multiplier)).toBe(true)
+  })
+
+  it('compares dates correctly', () => {
+    const date1 = new Date(2020, 1, 2, 3, 4, 5, 6)
+    const date2 = new Date(2020, 1, 2, 3, 4, 5, 6)
+    const date3 = new Date(2020, 1, 2, 3, 4, 5, 7)
+    const date4 = new Date(2219, 1, 2, 3, 4, 5, 6)
+
+    // Identical date object references
+    expect(looseEqual(date1, date1)).toBe(true)
+    // Different date references with identical values
+    expect(looseEqual(date1, date2)).toBe(true)
+    // Dates with slightly different time (ms)
+    expect(looseEqual(date1, date3)).toBe(false)
+    // Dates with different year
+    expect(looseEqual(date1, date4)).toBe(false)
+  })
+
+  it('compares files correctly', () => {
+    const date1 = new Date(2020, 1, 2, 3, 4, 5, 6)
+    const date2 = new Date(2020, 1, 2, 3, 4, 5, 7)
+    const file1 = new File([''], 'filename.txt', { type: 'text/plain', lastModified: date1 })
+    const file2 = new File([''], 'filename.txt', { type: 'text/plain', lastModified: date1 })
+    const file3 = new File([''], 'filename.txt', { type: 'text/plain', lastModified: date2 })
+    const file4 = new File([''], 'filename.csv', { type: 'text/csv', lastModified: date1 })
+    const file5 = new File(['abcdef'], 'filename.txt', { type: 'text/plain', lastModified: date1 })
+    const file6 = new File(['12345'], 'filename.txt', { type: 'text/plain', lastModified: date1 })
+
+    // Identical file object references
+    expect(looseEqual(file1, file1)).toBe(true)
+    // Different file references with identical values
+    expect(looseEqual(file1, file2)).toBe(true)
+    // Files with slightly different dates
+    expect(looseEqual(file1, file3)).toBe(false)
+    // Two different file types
+    expect(looseEqual(file1, file4)).toBe(false)
+    // Two files with same name, modified date, but different content
+    expect(looseEqual(file5, file6)).toBe(false)
+  })
+
+  it('compares arrays correctly', () => {
+    const arr1 = [1, 2, 3, 4]
+    const arr2 = [1, 2, 3, '4']
+    const arr3 = [1, 2, 3, 4, 5]
+    const arr4 = [1, 2, 3, 4, { a: 5 }]
+
+    // Identical array references
+    expect(looseEqual(arr1, arr1)).toBe(true)
+    // Different array references with identical values
+    expect(looseEqual(arr1, arr1.slice())).toBe(true)
+    expect(looseEqual(arr4, arr4.slice())).toBe(true)
+    // Array with one value different (loose)
+    expect(looseEqual(arr1, arr2)).toBe(true)
+    // Array with one value different
+    expect(looseEqual(arr3, arr4)).toBe(false)
+    // Arrays with different lengths
+    expect(looseEqual(arr1, arr3)).toBe(false)
+    // Arrays with values in different order
+    expect(looseEqual(arr1, arr1.slice().reverse())).toBe(false)
+  })
+
+  it('compares RegExp correctly', () => {
+    const rx1 = /^foo$/
+    const rx2 = /^foo$/
+    const rx3 = /^bar$/
+    const rx4 = /^bar$/i
+
+    // Identical regex references
+    expect(looseEqual(rx1, rx1)).toBe(true)
+    // Different regex references with identical values
+    expect(looseEqual(rx1, rx2)).toBe(true)
+    // Different regex
+    expect(looseEqual(rx1, rx3)).toBe(false)
+    // Same regex with different options
+    expect(looseEqual(rx3, rx4)).toBe(false)
+  })
+
+  it('compares objects correctly', () => {
+    const obj1 = { foo: 'bar' }
+    const obj2 = { foo: 'bar1' }
+    const obj3 = { a: 1, b: 2, c: 3 }
+    const obj4 = { b: 2, c: 3, a: 1 }
+    const obj5 = { ...obj4, z: 999 }
+    const nestedObj1 = { ...obj1, bar: [{ ...obj1 }, { ...obj1 }] }
+    const nestedObj2 = { ...obj1, bar: [{ ...obj1 }, { ...obj2 }] }
+
+    // Identical object references
+    expect(looseEqual(obj1, obj1)).toBe(true)
+    // Two objects with identical keys/values
+    expect(looseEqual(obj1, { ...obj1 })).toBe(true)
+    // Different key values
+    expect(looseEqual(obj1, obj2)).toBe(false)
+    // Keys in different orders
+    expect(looseEqual(obj3, obj4)).toBe(true)
+    // One object has additional key
+    expect(looseEqual(obj4, obj5)).toBe(false)
+    // Identical object references with nested array
+    expect(looseEqual(nestedObj1, nestedObj1)).toBe(true)
+    // Identical object definitions with nested array
+    expect(looseEqual(nestedObj1, { ...nestedObj1 })).toBe(true)
+    // Object definitions with nested array (which has different order)
+    expect(looseEqual(nestedObj1, nestedObj2)).toBe(false)
+  })
+
+  it('compares different types correctly', () => {
+    const obj1 = {}
+    const obj2 = { a: 1 }
+    const obj3 = { 0: 0, 1: 1, 2: 2 }
+    const arr1 = []
+    const arr2 = [1]
+    const arr3 = [0, 1, 2]
+    const date1 = new Date(2020, 1, 2, 3, 4, 5, 6)
+    const file1 = new File([''], 'filename.txt', { type: 'text/plain', lastModified: date1 })
+
+    expect(looseEqual(123, '123')).toBe(true)
+    expect(looseEqual(123, new Date(123))).toBe(false)
+    expect(looseEqual(`123`, new Date(123))).toBe(false)
+    expect(looseEqual([1, 2, 3], '1,2,3')).toBe(false)
+    expect(looseEqual(obj1, arr1)).toBe(false)
+    expect(looseEqual(obj2, arr2)).toBe(false)
+    expect(looseEqual(obj1, '[object Object]')).toBe(false)
+    expect(looseEqual(arr1, '[object Array]')).toBe(false)
+    expect(looseEqual(obj1, date1)).toBe(false)
+    expect(looseEqual(obj2, date1)).toBe(false)
+    expect(looseEqual(arr1, date1)).toBe(false)
+    expect(looseEqual(arr2, date1)).toBe(false)
+    expect(looseEqual(obj2, file1)).toBe(false)
+    expect(looseEqual(arr2, file1)).toBe(false)
+    expect(looseEqual(date1, file1)).toBe(false)
+    // Special case where an object's keys are the same as keys (indexes) of an array
+    expect(looseEqual(obj3, arr3)).toBe(false)
+  })
+
+  it('compares null and undefined values correctly', () => {
+    expect(looseEqual(null, null)).toBe(true)
+    expect(looseEqual(undefined, undefined)).toBe(true)
+    // eslint-disable-next-line no-void
+    expect(looseEqual(void 0, undefined)).toBe(true)
+    expect(looseEqual(null, undefined)).toBe(false)
+    // eslint-disable-next-line no-void
+    expect(looseEqual(null, void 0)).toBe(false)
+    expect(looseEqual(null, '')).toBe(false)
+    expect(looseEqual(null, false)).toBe(false)
+    expect(looseEqual(undefined, false)).toBe(false)
+  })
+
+  it('compares sparse arrays correctly', () => {
+    // The following arrays all have a length of 3
+    // But the first two are "sparse"
+    const arr1 = []
+    arr1[2] = true
+    const arr2 = []
+    arr2[2] = true
+    const arr3 = [false, false, true]
+    const arr4 = [undefined, undefined, true]
+    // This one is also sparse (missing index 1)
+    const arr5 = []
+    arr5[0] = arr5[2] = true
+
+    expect(looseEqual(arr1, arr2)).toBe(true)
+    expect(looseEqual(arr2, arr1)).toBe(true)
+    expect(looseEqual(arr1, arr3)).toBe(false)
+    expect(looseEqual(arr3, arr1)).toBe(false)
+    expect(looseEqual(arr1, arr4)).toBe(true)
+    expect(looseEqual(arr4, arr1)).toBe(true)
+    expect(looseEqual(arr1, arr5)).toBe(false)
+    expect(looseEqual(arr5, arr1)).toBe(false)
+  })
+})

package/src/vendor/bootstrap-vue/src/utils/loose-index-of.js

@@ -0,0 +1,11 @@
+import { looseEqual } from './loose-equal'
+
+// Assumes that the first argument is an array
+export const looseIndexOf = (array, value) => {
+  for (let i = 0; i < array.length; i++) {
+    if (looseEqual(array[i], value)) {
+      return i
+    }
+  }
+  return -1
+}

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

@@ -0,0 +1,15 @@
+// Math utilty functions
+
+export const mathMin = Math.min
+
+export const mathMax = Math.max
+
+export const mathAbs = Math.abs
+
+export const mathCeil = Math.ceil
+
+export const mathFloor = Math.floor
+
+export const mathPow = Math.pow
+
+export const mathRound = Math.round

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

@@ -0,0 +1,10 @@
+import { create } from './object'
+
+export const memoize = fn => {
+  const cache = create(null)
+
+  return (...args) => {
+    const argsKey = JSON.stringify(args)
+    return (cache[argsKey] = cache[argsKey] || fn.apply(null, args))
+  }
+}

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

@@ -0,0 +1,29 @@
+import { extend } from '../vue'
+import { EVENT_NAME_INPUT } from '../constants/events'
+import { PROP_TYPE_ANY } from '../constants/props'
+import { makeProp } from './props'
+
+export const makeModelMixin = (
+  prop,
+  {
+    type = PROP_TYPE_ANY,
+    defaultValue = undefined,
+    validator = undefined,
+    event = EVENT_NAME_INPUT
+  } = {}
+) => {
+  const props = {
+    [prop]: makeProp(type, defaultValue, validator)
+  }
+
+  // @vue/component
+  const mixin = extend({
+    model: {
+      prop,
+      event
+    },
+    props
+  })
+
+  return { mixin, props, prop, event }
+}

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

@@ -0,0 +1 @@
+export const noop = () => {}