@gitlab/duo-ui 0.1.0

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

@@ -0,0 +1,308 @@
+import { DOCUMENT, WINDOW } from '../constants/env'
+import { Element } from '../constants/safe-types'
+import { from as arrayFrom } from './array'
+import { isFunction, isNull } from './inspect'
+import { toFloat } from './number'
+import { toString } from './string'
+
+// --- Constants ---
+
+const ELEMENT_PROTO = Element.prototype
+
+const TABABLE_SELECTOR = [
+  'button',
+  '[href]:not(.disabled)',
+  'input',
+  'select',
+  'textarea',
+  '[tabindex]',
+  '[contenteditable]'
+]
+  .map(s => `${s}:not(:disabled):not([disabled])`)
+  .join(', ')
+
+// --- Normalization utils ---
+
+// See: https://developer.mozilla.org/en-US/docs/Web/API/Element/matches#Polyfill
+/* istanbul ignore next */
+export const matchesEl =
+  ELEMENT_PROTO.matches || ELEMENT_PROTO.msMatchesSelector || ELEMENT_PROTO.webkitMatchesSelector
+
+// See: https://developer.mozilla.org/en-US/docs/Web/API/Element/closest
+/* istanbul ignore next */
+export const closestEl =
+  ELEMENT_PROTO.closest ||
+  function(sel) {
+    let el = this
+    do {
+      // Use our "patched" matches function
+      if (matches(el, sel)) {
+        return el
+      }
+      el = el.parentElement || el.parentNode
+    } while (!isNull(el) && el.nodeType === Node.ELEMENT_NODE)
+    return null
+  }
+
+// `requestAnimationFrame()` convenience method
+/* istanbul ignore next: JSDOM always returns the first option */
+export const requestAF = (
+  WINDOW.requestAnimationFrame ||
+  WINDOW.webkitRequestAnimationFrame ||
+  WINDOW.mozRequestAnimationFrame ||
+  WINDOW.msRequestAnimationFrame ||
+  WINDOW.oRequestAnimationFrame ||
+  // Fallback, but not a true polyfill
+  // Only needed for Opera Mini
+  /* istanbul ignore next */
+  (cb => setTimeout(cb, 16))
+).bind(WINDOW)
+
+export const MutationObs =
+  WINDOW.MutationObserver || WINDOW.WebKitMutationObserver || WINDOW.MozMutationObserver || null
+
+// --- Utils ---
+
+// Remove a node from DOM
+export const removeNode = el => el && el.parentNode && el.parentNode.removeChild(el)
+
+// Determine if an element is an HTML element
+export const isElement = el => !!(el && el.nodeType === Node.ELEMENT_NODE)
+
+// Get the currently active HTML element
+export const getActiveElement = (excludes = []) => {
+  const { activeElement } = DOCUMENT
+  return activeElement && !excludes.some(el => el === activeElement) ? activeElement : null
+}
+
+// Returns `true` if a tag's name equals `name`
+export const isTag = (tag, name) => toString(tag).toLowerCase() === toString(name).toLowerCase()
+
+// Determine if an HTML element is the currently active element
+export const isActiveElement = el => isElement(el) && el === getActiveElement()
+
+// Determine if an HTML element is visible - Faster than CSS check
+export const isVisible = el => {
+  if (!isElement(el) || !el.parentNode || !contains(DOCUMENT.body, el)) {
+    // Note this can fail for shadow dom elements since they
+    // are not a direct descendant of document.body
+    return false
+  }
+  if (getStyle(el, 'display') === 'none') {
+    // We do this check to help with vue-test-utils when using v-show
+    /* istanbul ignore next */
+    return false
+  }
+  // All browsers support getBoundingClientRect(), except JSDOM as it returns all 0's for values :(
+  // So any tests that need isVisible will fail in JSDOM
+  // Except when we override the getBCR prototype in some tests
+  const bcr = getBCR(el)
+  return !!(bcr && bcr.height > 0 && bcr.width > 0)
+}
+
+// Determine if an element is disabled
+export const isDisabled = el =>
+  !isElement(el) || el.disabled || hasAttr(el, 'disabled') || hasClass(el, 'disabled')
+
+// Cause/wait-for an element to reflow its content (adjusting its height/width)
+export const reflow = el => {
+  // Requesting an elements offsetHight will trigger a reflow of the element content
+  /* istanbul ignore next: reflow doesn't happen in JSDOM */
+  return isElement(el) && el.offsetHeight
+}
+
+// Select all elements matching selector. Returns `[]` if none found
+export const selectAll = (selector, root) =>
+  arrayFrom((isElement(root) ? root : DOCUMENT).querySelectorAll(selector))
+
+// Select a single element, returns `null` if not found
+export const select = (selector, root) =>
+  (isElement(root) ? root : DOCUMENT).querySelector(selector) || null
+
+// Determine if an element matches a selector
+export const matches = (el, selector) => (isElement(el) ? matchesEl.call(el, selector) : false)
+
+// Finds closest element matching selector. Returns `null` if not found
+export const closest = (selector, root, includeRoot = false) => {
+  if (!isElement(root)) {
+    return null
+  }
+  const el = closestEl.call(root, selector)
+
+  // Native closest behaviour when `includeRoot` is truthy,
+  // else emulate jQuery closest and return `null` if match is
+  // the passed in root element when `includeRoot` is falsey
+  return includeRoot ? el : el === root ? null : el
+}
+
+// Returns true if the parent element contains the child element
+export const contains = (parent, child) =>
+  parent && isFunction(parent.contains) ? parent.contains(child) : false
+
+// Get an element given an ID
+export const getById = id => DOCUMENT.getElementById(/^#/.test(id) ? id.slice(1) : id) || null
+
+// Add a class to an element
+export const addClass = (el, className) => {
+  // We are checking for `el.classList` existence here since IE 11
+  // returns `undefined` for some elements (e.g. SVG elements)
+  // See https://github.com/bootstrap-vue/bootstrap-vue/issues/2713
+  if (className && isElement(el) && el.classList) {
+    el.classList.add(className)
+  }
+}
+
+// Remove a class from an element
+export const removeClass = (el, className) => {
+  // We are checking for `el.classList` existence here since IE 11
+  // returns `undefined` for some elements (e.g. SVG elements)
+  // See https://github.com/bootstrap-vue/bootstrap-vue/issues/2713
+  if (className && isElement(el) && el.classList) {
+    el.classList.remove(className)
+  }
+}
+
+// Test if an element has a class
+export const hasClass = (el, className) => {
+  // We are checking for `el.classList` existence here since IE 11
+  // returns `undefined` for some elements (e.g. SVG elements)
+  // See https://github.com/bootstrap-vue/bootstrap-vue/issues/2713
+  if (className && isElement(el) && el.classList) {
+    return el.classList.contains(className)
+  }
+  return false
+}
+
+// Set an attribute on an element
+export const setAttr = (el, attr, value) => {
+  if (attr && isElement(el)) {
+    el.setAttribute(attr, value)
+  }
+}
+
+// Remove an attribute from an element
+export const removeAttr = (el, attr) => {
+  if (attr && isElement(el)) {
+    el.removeAttribute(attr)
+  }
+}
+
+// Get an attribute value from an element
+// Returns `null` if not found
+export const getAttr = (el, attr) => (attr && isElement(el) ? el.getAttribute(attr) : null)
+
+// Determine if an attribute exists on an element
+// Returns `true` or `false`, or `null` if element not found
+export const hasAttr = (el, attr) => (attr && isElement(el) ? el.hasAttribute(attr) : null)
+
+// Set an style property on an element
+export const setStyle = (el, prop, value) => {
+  if (prop && isElement(el)) {
+    el.style[prop] = value
+  }
+}
+
+// Remove an style property from an element
+export const removeStyle = (el, prop) => {
+  if (prop && isElement(el)) {
+    el.style[prop] = ''
+  }
+}
+
+// Get an style property value from an element
+// Returns `null` if not found
+export const getStyle = (el, prop) => (prop && isElement(el) ? el.style[prop] || null : null)
+
+// Return the Bounding Client Rect of an element
+// Returns `null` if not an element
+/* istanbul ignore next: getBoundingClientRect() doesn't work in JSDOM */
+export const getBCR = el => (isElement(el) ? el.getBoundingClientRect() : null)
+
+// Get computed style object for an element
+/* istanbul ignore next: getComputedStyle() doesn't work in JSDOM */
+export const getCS = el => {
+  const { getComputedStyle } = WINDOW
+  return getComputedStyle && isElement(el) ? getComputedStyle(el) : {}
+}
+
+// Returns a `Selection` object representing the range of text selected
+// Returns `null` if no window support is given
+/* istanbul ignore next: getSelection() doesn't work in JSDOM */
+export const getSel = () => {
+  const { getSelection } = WINDOW
+  return getSelection ? WINDOW.getSelection() : null
+}
+
+// Return an element's offset with respect to document element
+// https://j11y.io/jquery/#v=git&fn=jQuery.fn.offset
+export const offset = el => /* istanbul ignore next: getBoundingClientRect(), getClientRects() doesn't work in JSDOM */ {
+  const _offset = { top: 0, left: 0 }
+  if (!isElement(el) || el.getClientRects().length === 0) {
+    return _offset
+  }
+  const bcr = getBCR(el)
+  if (bcr) {
+    const win = el.ownerDocument.defaultView
+    _offset.top = bcr.top + win.pageYOffset
+    _offset.left = bcr.left + win.pageXOffset
+  }
+  return _offset
+}
+
+// Return an element's offset with respect to to its offsetParent
+// https://j11y.io/jquery/#v=git&fn=jQuery.fn.position
+export const position = el => /* istanbul ignore next: getBoundingClientRect() doesn't work in JSDOM */ {
+  let _offset = { top: 0, left: 0 }
+  if (!isElement(el)) {
+    return _offset
+  }
+  let parentOffset = { top: 0, left: 0 }
+  const elStyles = getCS(el)
+  if (elStyles.position === 'fixed') {
+    _offset = getBCR(el) || _offset
+  } else {
+    _offset = offset(el)
+    const doc = el.ownerDocument
+    let offsetParent = el.offsetParent || doc.documentElement
+    while (
+      offsetParent &&
+      (offsetParent === doc.body || offsetParent === doc.documentElement) &&
+      getCS(offsetParent).position === 'static'
+    ) {
+      offsetParent = offsetParent.parentNode
+    }
+    if (offsetParent && offsetParent !== el && offsetParent.nodeType === Node.ELEMENT_NODE) {
+      parentOffset = offset(offsetParent)
+      const offsetParentStyles = getCS(offsetParent)
+      parentOffset.top += toFloat(offsetParentStyles.borderTopWidth, 0)
+      parentOffset.left += toFloat(offsetParentStyles.borderLeftWidth, 0)
+    }
+  }
+  return {
+    top: _offset.top - parentOffset.top - toFloat(elStyles.marginTop, 0),
+    left: _offset.left - parentOffset.left - toFloat(elStyles.marginLeft, 0)
+  }
+}
+
+// Find all tabable elements in the given element
+// Assumes users have not used `tabindex` > `0` on elements
+export const getTabables = (rootEl = document) =>
+  selectAll(TABABLE_SELECTOR, rootEl)
+    .filter(isVisible)
+    .filter(el => el.tabIndex > -1 && !el.disabled)
+
+// Attempt to focus an element, and return `true` if successful
+export const attemptFocus = (el, options = {}) => {
+  try {
+    el.focus(options)
+  } catch {}
+  return isActiveElement(el)
+}
+
+// Attempt to blur an element, and return `true` if successful
+export const attemptBlur = el => {
+  try {
+    el.blur()
+  } catch {}
+  return !isActiveElement(el)
+}

package/src/vendor/bootstrap-vue/src/utils/element-to-vue-instance-registry.js

@@ -0,0 +1,40 @@
+import { isVue3 } from '../vue'
+
+let registry = null
+if (isVue3) {
+  registry = new WeakMap()
+}
+
+export const registerElementToInstance = (element, instance) => {
+  if (!isVue3) {
+    return
+  }
+
+  registry.set(element, instance)
+}
+
+export const removeElementToInstance = element => {
+  if (!isVue3) {
+    return
+  }
+
+  registry.delete(element)
+}
+
+export const getInstanceFromElement = element => {
+  if (!isVue3) {
+    return element.__vue__
+  }
+
+  let currentElement = element
+
+  while (currentElement) {
+    if (registry.has(currentElement)) {
+      /* istanbul ignore next */
+      return registry.get(currentElement)
+    }
+    currentElement = currentElement.parentNode
+  }
+
+  return null
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Utilities to get information about the current environment
+ */
+
+export const getEnv = (key, fallback = null) => {
+  const env = typeof process !== 'undefined' && process ? process.env || {} : {}
+  if (!key) {
+    /* istanbul ignore next */
+    return env
+  }
+  return env[key] || fallback
+}
+
+export const getNoWarn = () =>
+  getEnv('BOOTSTRAP_VUE_NO_WARN') || getEnv('NODE_ENV') === 'production'

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

@@ -0,0 +1,71 @@
+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/get-event-root.js

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

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

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

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

@@ -0,0 +1,64 @@
+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/html.js

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

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

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

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