@gitlab/duo-ui 0.1.0 → 0.3.0

package/src/vendor/bootstrap-vue/src/mixins/listeners.spec.js

@@ -0,0 +1,245 @@
+import { isVue3 } from '../vue'
+import { mount } from '@vue/test-utils'
+import { listenersMixin } from './listeners'
+
+// Note: The following tests indirectly test `utils/cache`
+
+describe('mixins > listeners', () => {
+  it('works', async () => {
+    const BTest = {
+      compatConfig: {
+        MODE: 3,
+        RENDER_FUNCTION: 'suppress-warning',
+        INSTANCE_LISTENERS: 'suppress-warning'
+      },
+      name: 'BTest',
+      mixins: [listenersMixin],
+      inheritAttrs: false,
+      render(h) {
+        return h('button', { on: this.bvListeners })
+      }
+    }
+    const App = {
+      compatConfig: { MODE: 3, RENDER_FUNCTION: 'suppress-warning' },
+      name: 'App',
+      props: ['listenClick', 'listenFocus', 'listenBlur'],
+      computed: {
+        listeners() {
+          const listeners = {}
+          if (this.listenClick) {
+            listeners.click = event => this.$emit('click', event)
+          }
+          if (this.listenFocus) {
+            listeners.focus = event => this.$emit('focus', event)
+          }
+          if (this.listenBlur) {
+            listeners.blur = event => this.$emit('blur', event)
+          }
+          return listeners
+        }
+      },
+      render(h) {
+        return h(BTest, { on: this.listeners })
+      }
+    }
+
+    const wrapper = mount(App)
+
+    expect(wrapper).toBeDefined()
+    expect(wrapper.vm).toBeDefined()
+    expect(wrapper.element.tagName).toBe('BUTTON')
+
+    const $test = wrapper.findComponent(BTest)
+
+    expect($test.exists()).toBe(true)
+    expect($test.vm).toBeDefined()
+
+    expect($test.vm.bvListeners).toBeDefined()
+    expect($test.vm.bvListeners.click).toBeUndefined()
+    expect($test.vm.bvListeners.focus).toBeUndefined()
+    expect($test.vm.bvListeners.blur).toBeUndefined()
+
+    // Correctly adds new listeners
+    await wrapper.setProps({
+      listenClick: true,
+      listenFocus: true
+    })
+
+    expect($test.vm.bvListeners.click).toBeDefined()
+    expect($test.vm.bvListeners.focus).toBeDefined()
+    expect($test.vm.bvListeners.blur).toBeUndefined()
+
+    // Correctly updates listeners
+    await wrapper.setProps({
+      listenClick: false,
+      listenBlur: true
+    })
+
+    expect($test.vm.bvListeners.click).toBeUndefined()
+    expect($test.vm.bvListeners.focus).toBeDefined()
+    expect($test.vm.bvListeners.blur).toBeDefined()
+
+    // Correctly removes listeners
+    await wrapper.setProps({
+      listenClick: false,
+      listenFocus: false,
+      listenBlur: false
+    })
+
+    expect($test.vm.bvListeners.click).toBeUndefined()
+    expect($test.vm.bvListeners.focus).toBeUndefined()
+    expect($test.vm.bvListeners.blur).toBeUndefined()
+
+    wrapper.destroy()
+  })
+
+  it('does not re-render parent child components', async () => {
+    let input1RenderCount = 0
+    let input2RenderCount = 0
+
+    const Input1 = {
+      compatConfig: {
+        MODE: 3,
+        RENDER_FUNCTION: 'suppress-warning',
+        INSTANCE_LISTENERS: 'suppress-warning'
+      },
+      props: ['value'],
+      render(h) {
+        input1RenderCount++
+        return h('input', {
+          attrs: { value: this.value },
+          domProps: { value: this.value },
+          on: { ...this.$listeners, input: e => this.$emit('input', e.target.value) }
+        })
+      }
+    }
+    const Input2 = {
+      compatConfig: {
+        MODE: 3,
+        RENDER_FUNCTION: 'suppress-warning',
+        INSTANCE_LISTENERS: 'suppress-warning'
+      },
+      props: ['value'],
+      mixins: [listenersMixin],
+      render(h) {
+        input2RenderCount++
+        return h('input', {
+          attrs: { value: this.value },
+          domProps: { value: this.value },
+          on: { ...this.bvListeners, input: e => this.$emit('input', e.target.value) }
+        })
+      }
+    }
+
+    const App1 = {
+      components: { Input1 },
+      props: ['listenFocus1', 'listenFocus2'],
+      methods: {
+        emit1($event) {
+          if (this.listenFocus1) {
+            this.$emit('focus1', $event)
+          }
+        },
+        emit2($event) {
+          if (this.listenFocus2) {
+            this.$emit('focus2', $event)
+          }
+        }
+      },
+      template: `<div>
+        <Input1 @focus="emit1" />
+        <Input1 @focus="emit2" />
+      </div>`
+    }
+    const App2 = {
+      components: { Input2 },
+      props: ['listenFocus1', 'listenFocus2'],
+      methods: {
+        emit1($event) {
+          if (this.listenFocus1) {
+            this.$emit('focus1', $event)
+          }
+        },
+        emit2($event) {
+          if (this.listenFocus2) {
+            this.$emit('focus2', $event)
+          }
+        }
+      },
+      template: `<div>
+        <Input2 @focus="emit1" />
+        <Input2 @focus="emit2" />
+      </div>`
+    }
+
+    const wrapper1 = mount(App1, { attachTo: document.body })
+    const wrapper2 = mount(App2, { attachTo: document.body })
+
+    // --- `Input1` tests ---
+
+    const $inputs1 = wrapper1.findAllComponents(Input1)
+    expect($inputs1.length).toBe(2)
+    expect($inputs1.at(0)).toBeDefined()
+    expect($inputs1.at(1)).toBeDefined()
+    expect(wrapper1.emitted().focus1).not.toBeTruthy()
+    expect(wrapper1.emitted().focus2).not.toBeTruthy()
+    expect(input1RenderCount).toBe(2)
+
+    await $inputs1.at(0).trigger('focus')
+    expect(wrapper1.emitted().focus1).not.toBeTruthy()
+    await $inputs1.at(1).trigger('focus')
+    expect(wrapper1.emitted().focus2).not.toBeTruthy()
+    expect(input1RenderCount).toBe(2)
+
+    // Enable focus events for the first input and trigger it
+    await wrapper1.setProps({ listenFocus1: true })
+    await $inputs1.at(0).trigger('focus')
+    expect(wrapper1.emitted().focus1).toBeTruthy()
+    expect(wrapper1.emitted().focus2).not.toBeTruthy()
+    // Both `Input1`'s are re-rendered (See: https://github.com/vuejs/vue/issues/7257)
+    expect(input1RenderCount).toBe(isVue3 ? 2 : 4)
+
+    // Enable focus events for the second input and trigger it
+    await wrapper1.setProps({ listenFocus2: true })
+    await $inputs1.at(1).trigger('focus')
+    expect(wrapper1.emitted().focus1).toBeTruthy()
+    expect(wrapper1.emitted().focus2).toBeTruthy()
+    // Both `Input1`'s are re-rendered (See: https://github.com/vuejs/vue/issues/7257)
+    expect(input1RenderCount).toBe(isVue3 ? 2 : 6)
+
+    // --- `Input2` tests ---
+
+    const $inputs2 = wrapper2.findAllComponents(Input2)
+    expect($inputs2.length).toBe(2)
+    expect($inputs2.at(0)).toBeDefined()
+    expect($inputs2.at(1)).toBeDefined()
+    expect(wrapper2.emitted().focus1).not.toBeTruthy()
+    expect(wrapper2.emitted().focus2).not.toBeTruthy()
+    expect(input2RenderCount).toBe(2)
+
+    await $inputs2.at(0).trigger('focus')
+    expect(wrapper2.emitted().focus1).not.toBeTruthy()
+    await $inputs2.at(1).trigger('focus')
+    expect(wrapper2.emitted().focus2).not.toBeTruthy()
+    expect(input2RenderCount).toBe(2)
+
+    // Enable focus events for the first input and trigger it
+    await wrapper2.setProps({ listenFocus1: true })
+    await $inputs2.at(0).trigger('focus')
+    expect(wrapper2.emitted().focus1).toBeTruthy()
+    expect(wrapper2.emitted().focus2).not.toBeTruthy()
+    // With `listenersMixin` only the affected `Input2` is re-rendered
+    expect(input2RenderCount).toBe(2)
+
+    // Enable focus events for the second input and trigger it
+    await wrapper2.setProps({ listenFocus2: true })
+    await $inputs2.at(1).trigger('focus')
+    expect(wrapper2.emitted().focus1).toBeTruthy()
+    expect(wrapper2.emitted().focus2).toBeTruthy()
+    // With `listenersMixin` only the affected `Input2` is re-rendered
+    expect(input2RenderCount).toBe(2)
+
+    wrapper1.destroy()
+    wrapper2.destroy()
+  })
+})

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

@@ -0,0 +1,66 @@
+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/clone-deep.spec.js

@@ -0,0 +1,70 @@
+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.spec.js

@@ -0,0 +1,169 @@
+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/css-escape.spec.js

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