@gitlab/duo-ui 3.0.0 → 4.0.0

package/src/vendor/bootstrap-vue/src/utils/bv-event.class.spec.js

@@ -1,66 +0,0 @@
-import { BvEvent } from './bv-event.class'
-
-describe('utils/BvEvent class', () => {
-  it('works', async () => {
-    const event = new BvEvent('foobar')
-    expect(event).toBeInstanceOf(BvEvent)
-    expect(event.type).toBe('foobar')
-  })
-
-  it('throws exception if no type given', async () => {
-    let event = null
-    let failed = false
-    try {
-      event = new BvEvent()
-    } catch (e) {
-      failed = true
-    }
-    expect(event).not.toBeInstanceOf(BvEvent)
-    expect(event).toBe(null)
-    expect(failed).toBe(true)
-  })
-
-  it('supports cancelable events', async () => {
-    const event = new BvEvent('foobar', {
-      cancelable: true
-    })
-    expect(event).toBeInstanceOf(BvEvent)
-    expect(event.type).toBe('foobar')
-    expect(event.cancelable).toBe(true)
-    expect(event.defaultPrevented).toBe(false)
-    event.preventDefault()
-    expect(event.defaultPrevented).toBe(true)
-  })
-
-  it('supports non cancelable events', async () => {
-    const event = new BvEvent('foobar', {
-      cancelable: false
-    })
-    expect(event).toBeInstanceOf(BvEvent)
-    expect(event.type).toBe('foobar')
-    expect(event.cancelable).toBe(false)
-    expect(event.defaultPrevented).toBe(false)
-    event.preventDefault()
-    expect(event.defaultPrevented).toBe(false)
-  })
-
-  it('supports built in properties', async () => {
-    const event = new BvEvent('foobar', {
-      target: 'baz'
-    })
-    expect(event).toBeInstanceOf(BvEvent)
-    expect(event.type).toBe('foobar')
-    expect(event.cancelable).toBe(true)
-    expect(event.target).toBe('baz')
-  })
-
-  it('supports custom properties', async () => {
-    const event = new BvEvent('foobar', {
-      custom: 123
-    })
-    expect(event).toBeInstanceOf(BvEvent)
-    expect(event.type).toBe('foobar')
-    expect(event.cancelable).toBe(true)
-    expect(event.custom).toBe(123)
-  })
-})

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

@@ -1,37 +0,0 @@
-import { extend } from '../vue'
-import { cloneDeep } from './clone-deep'
-import { looseEqual } from './loose-equal'
-import { hasOwnProperty, keys } from './object'
-
-const isEmpty = value => !value || keys(value).length === 0
-
-export const makePropWatcher = propName => ({
-  handler(newValue, oldValue) {
-    if (looseEqual(newValue, oldValue)) {
-      return
-    }
-    if (isEmpty(newValue) || isEmpty(oldValue)) {
-      this[propName] = cloneDeep(newValue)
-      return
-    }
-    for (const key in oldValue) {
-      if (!hasOwnProperty(newValue, key)) {
-        this.$delete(this.$data[propName], key)
-      }
-    }
-    for (const key in newValue) {
-      this.$set(this.$data[propName], key, newValue[key])
-    }
-  }
-})
-
-export const makePropCacheMixin = (propName, proxyPropName) =>
-  extend({
-    data() {
-      return { [proxyPropName]: cloneDeep(this[propName]) }
-    },
-    watch: {
-      // Work around unwanted re-renders: https://github.com/vuejs/vue/issues/10115
-      [propName]: makePropWatcher(proxyPropName)
-    }
-  })

package/src/vendor/bootstrap-vue/src/utils/clone-deep.js

@@ -1,15 +0,0 @@
-import { isArray, isPlainObject } from './inspect'
-import { keys } from './object'
-
-export const cloneDeep = (obj, defaultValue = obj) => {
-  if (isArray(obj)) {
-    return obj.reduce((result, val) => [...result, cloneDeep(val, val)], [])
-  }
-  if (isPlainObject(obj)) {
-    return keys(obj).reduce(
-      (result, key) => ({ ...result, [key]: cloneDeep(obj[key], obj[key]) }),
-      {}
-    )
-  }
-  return defaultValue
-}

package/src/vendor/bootstrap-vue/src/utils/clone-deep.spec.js

@@ -1,70 +0,0 @@
-import { cloneDeep } from './clone-deep'
-
-describe('cloneDeep()', () => {
-  it('should clone arrays', () => {
-    const a = [{ a: 0 }, { b: 1 }]
-    expect(cloneDeep(a)).toEqual(a)
-
-    const b = [1, 2, 3]
-    expect(b).toEqual(b)
-
-    const c = [{ a: 0 }, { b: 1 }]
-    const d = cloneDeep(c)
-    expect(d).toEqual(c)
-    expect(d[0]).toEqual(c[0])
-
-    const e = [0, 'a', {}, [{}], [() => {}], () => {}]
-    expect(cloneDeep(e)).toEqual(e)
-  })
-
-  it('should deeply clone an array', () => {
-    const a = [[{ a: 'b' }], [{ a: 'b' }]]
-    const b = cloneDeep(a)
-    expect(b).not.toBe(a)
-    expect(b[0]).not.toBe(a[0])
-    expect(b[1]).not.toBe(a[1])
-    expect(b).toEqual(a)
-  })
-
-  it('should deeply clone object', () => {
-    const a = { a: 'b' }
-    const b = cloneDeep(a)
-    b.c = 'd'
-    expect(b).not.toEqual(a)
-  })
-
-  it('should deeply clone arrays', () => {
-    const a = { a: 'b' }
-    const b = [a]
-    const c = cloneDeep(b)
-    a.c = 'd'
-    expect(c).not.toEqual(b)
-  })
-
-  it('should return primitives', () => {
-    expect(cloneDeep(0)).toEqual(0)
-    expect(cloneDeep('foo')).toEqual('foo')
-  })
-
-  it('should clone a regex', () => {
-    expect(cloneDeep(/foo/g)).toEqual(/foo/g)
-  })
-
-  it('should clone objects', () => {
-    const a = { a: 1, b: 2, c: 3 }
-    expect(cloneDeep(a)).toEqual(a)
-    expect(cloneDeep(a)).not.toBe(a)
-  })
-
-  it('should deeply clone objects', () => {
-    const a = { a: { a: 1, b: 2, c: 3 }, b: { a: 1, b: 2, c: 3 }, c: { a: 1, b: 2, c: 3 } }
-    expect(cloneDeep(a)).toEqual(a)
-    expect(cloneDeep(a)).not.toBe(a)
-    expect(cloneDeep(a).a).toEqual(a.a)
-    expect(cloneDeep(a).a).not.toBe(a.a)
-    expect(cloneDeep(a).b).toEqual(a.b)
-    expect(cloneDeep(a).b).not.toBe(a.b)
-    expect(cloneDeep(a).c).toEqual(a.c)
-    expect(cloneDeep(a).c).not.toBe(a.c)
-  })
-})

package/src/vendor/bootstrap-vue/src/utils/config-set.js

@@ -1,80 +0,0 @@
-import { Vue as OurVue } from '../vue'
-import { NAME, PROP_NAME } from '../constants/config'
-import { cloneDeep } from './clone-deep'
-import { getRaw } from './get'
-import { isArray, isPlainObject, isString, isUndefined } from './inspect'
-import { getOwnPropertyNames } from './object'
-import { warn } from './warn'
-
-// Config manager class
-class BvConfig {
-  constructor() {
-    this.$_config = {}
-  }
-
-  // Method to merge in user config parameters
-  setConfig(config = {}) {
-    /* istanbul ignore next */
-    if (!isPlainObject(config)) {
-      return
-    }
-    const configKeys = getOwnPropertyNames(config)
-    configKeys.forEach(key => {
-      /* istanbul ignore next */
-      const subConfig = config[key]
-      if (key === 'breakpoints') {
-        /* istanbul ignore if */
-        if (
-          !isArray(subConfig) ||
-          subConfig.length < 2 ||
-          subConfig.some(b => !isString(b) || b.length === 0)
-        ) {
-          warn('"breakpoints" must be an array of at least 2 breakpoint names', NAME)
-        } else {
-          this.$_config[key] = cloneDeep(subConfig)
-        }
-      } else if (isPlainObject(subConfig)) {
-        // Component prop defaults
-        this.$_config[key] = getOwnPropertyNames(subConfig).reduce((config, prop) => {
-          if (!isUndefined(subConfig[prop])) {
-            config[prop] = cloneDeep(subConfig[prop])
-          }
-          return config
-        }, this.$_config[key] || {})
-      }
-    })
-  }
-
-  // Clear the config
-  resetConfig() {
-    this.$_config = {}
-  }
-
-  // Returns a deep copy of the user config
-  getConfig() {
-    return cloneDeep(this.$_config)
-  }
-
-  // Returns a deep copy of the config value
-  getConfigValue(key, defaultValue = undefined) {
-    return cloneDeep(getRaw(this.$_config, key, defaultValue))
-  }
-}
-
-// Method for applying a global config
-export const setConfig = (config = {}, Vue = OurVue) => {
-  // Ensure we have a `$bvConfig` Object on the Vue prototype
-  // We set on Vue and OurVue just in case consumer has not set an alias of `vue`
-  Vue.prototype[PROP_NAME] = OurVue.prototype[PROP_NAME] =
-    Vue.prototype[PROP_NAME] || OurVue.prototype[PROP_NAME] || new BvConfig()
-  // Apply the config values
-  Vue.prototype[PROP_NAME].setConfig(config)
-}
-
-// Method for resetting the user config
-// Exported for testing purposes only
-export const resetConfig = () => {
-  if (OurVue.prototype[PROP_NAME] && OurVue.prototype[PROP_NAME].resetConfig) {
-    OurVue.prototype[PROP_NAME].resetConfig()
-  }
-}

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

@@ -1,72 +0,0 @@
-import { Vue } from '../vue'
-import { DEFAULT_BREAKPOINT, PROP_NAME } from '../constants/config'
-import { cloneDeep } from './clone-deep'
-import { memoize } from './memoize'
-
-// --- Constants ---
-
-const VueProto = Vue.prototype
-
-// --- Getter methods ---
-// All methods return a deep clone (immutable) copy of the config value,
-// to prevent mutation of the user config object
-
-// Get the current config
-export const getConfig = () => {
-  const bvConfig = VueProto[PROP_NAME]
-  return bvConfig ? bvConfig.getConfig() : {}
-}
-
-// Method to grab a config value based on a dotted/array notation key
-export const getConfigValue = (key, defaultValue = undefined) => {
-  const bvConfig = VueProto[PROP_NAME]
-  return bvConfig ? bvConfig.getConfigValue(key, defaultValue) : cloneDeep(defaultValue)
-}
-
-// Method to grab a config value for a particular component
-export const getComponentConfig = (key, propKey = null, defaultValue = undefined) => {
-  // Return the particular config value for key if specified,
-  // otherwise we return the full config (or an empty object if not found)
-  return propKey ? getConfigValue(`${key}.${propKey}`, defaultValue) : getConfigValue(key, {})
-}
-
-// Get all breakpoint names
-export const getBreakpoints = () => getConfigValue('breakpoints', DEFAULT_BREAKPOINT)
-
-// Private method for caching breakpoint names
-const _getBreakpointsCached = memoize(() => getBreakpoints())
-
-// Get all breakpoint names (cached)
-export const getBreakpointsCached = () => cloneDeep(_getBreakpointsCached())
-
-// Get breakpoints with the smallest breakpoint set as ''
-// Useful for components that create breakpoint specific props
-export const getBreakpointsUp = () => {
-  const breakpoints = getBreakpoints()
-  breakpoints[0] = ''
-  return breakpoints
-}
-
-// Get breakpoints with the smallest breakpoint set as '' (cached)
-// Useful for components that create breakpoint specific props
-export const getBreakpointsUpCached = memoize(() => {
-  const breakpoints = getBreakpointsCached()
-  breakpoints[0] = ''
-  return breakpoints
-})
-
-// Get breakpoints with the largest breakpoint set as ''
-export const getBreakpointsDown = () => {
-  const breakpoints = getBreakpoints()
-  breakpoints[breakpoints.length - 1] = ''
-  return breakpoints
-}
-
-// Get breakpoints with the largest breakpoint set as '' (cached)
-// Useful for components that create breakpoint specific props
-/* istanbul ignore next: we don't use this method anywhere, yet */
-export const getBreakpointsDownCached = () => {
-  const breakpoints = getBreakpointsCached()
-  breakpoints[breakpoints.length - 1] = ''
-  return breakpoints
-}

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

@@ -1,169 +0,0 @@
-import { createLocalVue } from '@vue/test-utils'
-import { isVue3 } from '../../src/vue'
-import { BootstrapVue } from '../../src'
-import { ToastPlugin } from '../../src/components/toast'
-import { BVConfigPlugin } from '../../src/bv-config'
-import { setConfig, resetConfig } from './config-set'
-import {
-  getBreakpoints,
-  getBreakpointsDown,
-  getBreakpointsUp,
-  getComponentConfig,
-  getConfig,
-  getConfigValue
-} from './config'
-
-describe('utils/config', () => {
-  afterEach(() => {
-    resetConfig()
-  })
-
-  it('getConfig() works', async () => {
-    expect(getConfig()).toEqual({})
-  })
-
-  it('setConfig() works', async () => {
-    const config = {
-      BButton: { variant: 'danger' }
-    }
-    const breakpointsConfig = {
-      breakpoints: ['aa', 'bb', 'cc', 'dd', 'ee']
-    }
-    expect(getConfig()).toEqual({})
-
-    // Try a component config
-    setConfig(config)
-    expect(getConfig()).toEqual(config)
-    expect(getConfig()).not.toBe(config)
-    expect(getComponentConfig('BButton')).toEqual(config.BButton)
-    expect(getComponentConfig('BButton')).not.toBe(config.BButton)
-    expect(getComponentConfig('BButton', 'variant')).toEqual('danger')
-
-    // Try breakpoint config (should merge)
-    setConfig(breakpointsConfig)
-    expect(getBreakpoints()).toEqual(breakpointsConfig.breakpoints)
-    expect(getBreakpoints()).not.toBe(breakpointsConfig.breakpoints)
-    expect(getConfigValue('breakpoints')).toEqual(breakpointsConfig.breakpoints)
-    // should leave previous config
-    expect(getComponentConfig('BButton', 'variant')).toEqual('danger')
-    // Should merge config
-    expect(getConfig()).toEqual({ ...config, ...breakpointsConfig })
-
-    // Reset the configuration
-    resetConfig()
-    expect(getConfig()).toEqual({})
-  })
-
-  if (!isVue3) {
-    // We do not have complete localVue support, so resetting config does not work in proper way
-    it('config via Vue.use(BootstrapVue) works', async () => {
-      const localVue = createLocalVue()
-      const config = {
-        BButton: { variant: 'foobar' }
-      }
-
-      expect(getConfig()).toEqual({})
-
-      localVue.use(BootstrapVue, config)
-      expect(getConfig()).toEqual(config)
-
-      // Reset the configuration
-      resetConfig()
-      expect(getConfig()).toEqual({})
-    })
-
-    it('config via Vue.use(ComponentPlugin) works', async () => {
-      const localVue = createLocalVue()
-      const config = {
-        BButton: { variant: 'foobar' }
-      }
-
-      expect(getConfig()).toEqual({})
-
-      localVue.use(ToastPlugin, config)
-      expect(getConfig()).toEqual(config)
-
-      // Reset the configuration
-      resetConfig()
-      expect(getConfig()).toEqual({})
-    })
-
-    it('config via Vue.use(BVConfig) works', async () => {
-      const localVue = createLocalVue()
-      const config = {
-        BButton: { variant: 'foobar' }
-      }
-
-      expect(getConfig()).toEqual({})
-
-      localVue.use(BVConfigPlugin, config)
-      expect(getConfig()).toEqual(config)
-
-      // Reset the configuration
-      resetConfig()
-      expect(getConfig()).toEqual({})
-    })
-  }
-
-  it('getConfigValue() works', async () => {
-    const config = {
-      formControls: { size: 'sm' }
-    }
-    setConfig(config)
-
-    expect(getConfigValue('formControls')).toEqual(config.formControls)
-    // Should return a deep clone
-    expect(getConfigValue('formControls')).not.toBe(config.formControls)
-    // Shape of returned value should be the same each call
-    expect(getConfigValue('formControls')).toEqual(getConfigValue('formControls'))
-    // Should return undefined for not found
-    expect(getConfigValue('foo.bar[1].baz')).toBeUndefined()
-  })
-
-  it('getComponentConfig() works', async () => {
-    const config = {
-      BButton: { variant: 'info' }
-    }
-    setConfig(config)
-
-    // Specific component config key
-    expect(getComponentConfig('BButton', 'variant')).toEqual('info')
-    // Component's full config
-    expect(getComponentConfig('BButton')).toEqual(config.BButton)
-    // Should return a deep clone for full config
-    expect(getComponentConfig('BButton')).not.toBe(config.BButton)
-    // Should return empty object for not found component
-    expect(getComponentConfig('foobar')).toEqual({})
-    // Should return undefined for not found component key
-    expect(getComponentConfig('BButton', 'foobar')).toBeUndefined()
-  })
-
-  it('getBreakpoints() works', async () => {
-    const breakpointsConfig = {
-      breakpoints: ['aa', 'bb', 'cc', 'dd', 'ee']
-    }
-
-    expect(getBreakpoints()).toEqual(['xs', 'sm', 'md', 'lg', 'xl'])
-    // Should return a deep clone
-    expect(getBreakpoints()).not.toBe(getBreakpoints())
-
-    // Set new breakpoints
-    setConfig(breakpointsConfig)
-    expect(getBreakpoints()).toEqual(breakpointsConfig.breakpoints)
-    // Should return a deep clone
-    expect(getBreakpoints()).not.toBe(getBreakpoints())
-    expect(getBreakpoints()).not.toBe(breakpointsConfig.breakpoints)
-  })
-
-  it('getBreakpointsUp() works', async () => {
-    expect(getBreakpointsUp()).toEqual(['', 'sm', 'md', 'lg', 'xl'])
-    // Should return a deep clone
-    expect(getBreakpointsUp()).not.toBe(getBreakpointsUp())
-  })
-
-  it('getBreakpointsDown() works', async () => {
-    expect(getBreakpointsDown()).toEqual(['xs', 'sm', 'md', 'lg', ''])
-    // Should return a deep clone
-    expect(getBreakpointsDown()).not.toBe(getBreakpointsDown())
-  })
-})

package/src/vendor/bootstrap-vue/src/utils/create-new-child-component.js

@@ -1,10 +0,0 @@
-export const createNewChildComponent = (parent, Component, config = {}) => {
-  const bvEventRoot = parent.$root ? parent.$root.$options.bvEventRoot || parent.$root : null
-
-  return new Component({
-    ...config,
-    parent,
-    bvParent: parent,
-    bvEventRoot
-  })
-}

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

@@ -1,73 +0,0 @@
-import { toString } from './string'
-
-const escapeChar = value => '\\' + value
-
-// The `cssEscape()` util is based on this `CSS.escape()` polyfill:
-// https://github.com/mathiasbynens/CSS.escape
-export const cssEscape = value => {
-  value = toString(value)
-
-  const length = value.length
-  const firstCharCode = value.charCodeAt(0)
-
-  return value.split('').reduce((result, char, index) => {
-    const charCode = value.charCodeAt(index)
-
-    // If the character is NULL (U+0000), use (U+FFFD) as replacement
-    if (charCode === 0x0000) {
-      return result + '\uFFFD'
-    }
-
-    // If the character ...
-    if (
-      // ... is U+007F OR
-      charCode === 0x007f ||
-      // ... is in the range [\1-\1F] (U+0001 to U+001F) OR ...
-      (charCode >= 0x0001 && charCode <= 0x001f) ||
-      // ... is the first character and is in the range [0-9] (U+0030 to U+0039) OR ...
-      (index === 0 && charCode >= 0x0030 && charCode <= 0x0039) ||
-      // ... is the second character and is in the range [0-9] (U+0030 to U+0039)
-      // and the first character is a `-` (U+002D) ...
-      (index === 1 && charCode >= 0x0030 && charCode <= 0x0039 && firstCharCode === 0x002d)
-    ) {
-      // ... https://drafts.csswg.org/cssom/#escape-a-character-as-code-point
-      return result + escapeChar(`${charCode.toString(16)} `)
-    }
-
-    // If the character ...
-    if (
-      // ... is the first character AND ...
-      index === 0 &&
-      // ... is a `-` (U+002D) AND ...
-      charCode === 0x002d &&
-      // ... there is no second character ...
-      length === 1
-    ) {
-      // ... use the escaped character
-      return result + escapeChar(char)
-    }
-
-    // If the character ...
-    if (
-      // ... is greater than or equal to U+0080 OR ...
-      charCode >= 0x0080 ||
-      // ... is `-` (U+002D) OR ...
-      charCode === 0x002d ||
-      // ... is `_` (U+005F) OR ...
-      charCode === 0x005f ||
-      // ... is in the range [0-9] (U+0030 to U+0039) OR ...
-      (charCode >= 0x0030 && charCode <= 0x0039) ||
-      // ... is in the range [A-Z] (U+0041 to U+005A) OR ...
-      (charCode >= 0x0041 && charCode <= 0x005a) ||
-      // ... is in the range [a-z] (U+0061 to U+007A) ...
-      (charCode >= 0x0061 && charCode <= 0x007a)
-    ) {
-      // ... use the character itself
-      return result + char
-    }
-
-    // Otherwise use the escaped character
-    // See: https://drafts.csswg.org/cssom/#escape-a-character
-    return result + escapeChar(char)
-  }, '')
-}

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

@@ -1,82 +0,0 @@
-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')
-  })
-})