@gitlab/ui 114.1.0 → 114.1.1

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/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/loose-equal.spec.js

@@ -1,203 +0,0 @@
-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/normalize-slot.spec.js

@@ -1,63 +0,0 @@
-import { normalizeSlot } from './normalize-slot'
-
-describe('utils/normalizeSlot', () => {
-  it('works', async () => {
-    const $scoped = {
-      default(slotScope) {
-        return 'foo' + (slotScope.a || '')
-      }
-    }
-    const $slots = {
-      default: 'bar'
-    }
-    expect(typeof normalizeSlot).toBe('function')
-
-    // Prefers scopedSlots over slots
-    let result = normalizeSlot('default', {}, $scoped, $slots)
-    expect(result).toBe('foo')
-
-    // Passes slot scope to scopedSlot
-    result = normalizeSlot('default', { a: ' foo' }, $scoped, $slots)
-    expect(result).toBe('foo foo')
-
-    // Uses named slot if scopedSlot not found
-    result = normalizeSlot('default', {}, {}, $slots)
-    expect(result).toBe('bar')
-
-    // Works if only named slot found
-    result = normalizeSlot('default', { a: ' foo' }, {}, $slots)
-    expect(result).toBe('bar')
-
-    // Works if only named slot found and scopedSlots is undef
-    result = normalizeSlot('default', { a: ' foo' }, undefined, $slots)
-    expect(result).toBe('bar')
-
-    // Works if only scoped slot found
-    result = normalizeSlot('default', { a: ' bar' }, $scoped, {})
-    expect(result).toBe('foo bar')
-
-    // Works if only scoped slot found and scoped is undef
-    result = normalizeSlot('default', { a: ' bar' }, $scoped, undefined)
-    expect(result).toBe('foo bar')
-
-    // Returns undefined if slot name not found
-    result = normalizeSlot('default', {}, {}, {})
-    expect(result).toBeUndefined()
-
-    // Returns undefined if slot name not found
-    result = normalizeSlot('baz', {}, $scoped, $slots)
-    expect(result).toBeUndefined()
-
-    // Works with array (named slot)
-    result = normalizeSlot(['none', 'default'], { a: ' foo' }, undefined, $slots)
-    expect(result).toBe('bar')
-
-    // Works with arrays (scoped slot)
-    result = normalizeSlot(['none', 'default'], { a: ' bar' }, $scoped, {})
-    expect(result).toBe('foo bar')
-
-    // Returns undefined if slot name not found with array
-    result = normalizeSlot(['baz', 'bar'], {}, $scoped, $slots)
-    expect(result).toBeUndefined()
-  })
-})