@gitlab/ui 132.0.1 → 132.0.2

package/dist/vendor/bootstrap-vue/src/utils/props.js

@@ -0,0 +1,67 @@
+import { PROP_TYPE_ANY } from '../constants/props';
+import { identity } from './identity';
+import { isUndefined, isObject, isArray } from './inspect';
+import { hasOwnProperty, clone, keys } from './object';
+import { upperFirst } from './string';
+
+// Suffix can be a falsey value so nothing is appended to string
+// (helps when looping over props & some shouldn't change)
+// Use data last parameters to allow for currying
+const suffixPropName = (suffix, value) => value + (suffix ? upperFirst(suffix) : '');
+
+// Generates a prop object
+const makeProp = function () {
+  let type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : PROP_TYPE_ANY;
+  let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+  let requiredOrValidator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+  let validator = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;
+  const required = requiredOrValidator === true;
+  validator = required ? validator : requiredOrValidator;
+  return {
+    ...(type ? {
+      type
+    } : {}),
+    ...(required ? {
+      required
+    } : isUndefined(value) ? {} : {
+      default: isObject(value) ? () => value : value
+    }),
+    ...(isUndefined(validator) ? {} : {
+      validator
+    })
+  };
+};
+
+// Copies props from one array/object to a new array/object
+// Prop values are also cloned as new references to prevent possible
+// mutation of original prop object values
+// Optionally accepts a function to transform the prop name
+const copyProps = function (props) {
+  let transformFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : identity;
+  if (isArray(props)) {
+    return props.map(transformFn);
+  }
+  const copied = {};
+  for (const prop in props) {
+    /* istanbul ignore else */
+    if (hasOwnProperty(props, prop)) {
+      // If the prop value is an object, do a shallow clone
+      // to prevent potential mutations to the original object
+      copied[transformFn(prop)] = isObject(props[prop]) ? clone(props[prop]) : props[prop];
+    }
+  }
+  return copied;
+};
+
+// Given an array of properties or an object of property keys,
+// plucks all the values off the target object, returning a new object
+// that has props that reference the original prop values
+const pluckProps = function (keysToPluck, objToPluck) {
+  let transformFn = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : identity;
+  return (isArray(keysToPluck) ? keysToPluck.slice() : keys(keysToPluck)).reduce((memo, prop) => {
+    memo[transformFn(prop)] = objToPluck[prop];
+    return memo;
+  }, {});
+};
+
+export { copyProps, makeProp, pluckProps, suffixPropName };

package/dist/vendor/bootstrap-vue/src/utils/router.js

@@ -0,0 +1,150 @@
+import { RX_QUERY_START, RX_PLUS, RX_ENCODE_REVERSE, RX_ENCODED_COMMA } from '../constants/regex';
+import { isVue3 } from '../vue';
+import { isTag } from './dom';
+import { isPlainObject, isUndefined, isNull, isArray, isString } from './inspect';
+import { keys } from './object';
+import { safeVueInstance } from './safe-vue-instance';
+import { toString } from './string';
+
+const ANCHOR_TAG = 'a';
+
+// Method to replace reserved chars
+const encodeReserveReplacer = c => '%' + c.charCodeAt(0).toString(16);
+
+// Fixed encodeURIComponent which is more conformant to RFC3986:
+// - escapes [!'()*]
+// - preserve commas
+const encode = str => encodeURIComponent(toString(str)).replace(RX_ENCODE_REVERSE, encodeReserveReplacer).replace(RX_ENCODED_COMMA, ',');
+const decode = decodeURIComponent;
+
+// Stringifies an object of query parameters
+// See: https://github.com/vuejs/vue-router/blob/dev/src/util/query.js
+const stringifyQueryObj = obj => {
+  if (!isPlainObject(obj)) {
+    return '';
+  }
+  const query = keys(obj).map(key => {
+    const value = obj[key];
+    if (isUndefined(value)) {
+      return '';
+    } else if (isNull(value)) {
+      return encode(key);
+    } else if (isArray(value)) {
+      return value.reduce((results, value2) => {
+        if (isNull(value2)) {
+          results.push(encode(key));
+        } else if (!isUndefined(value2)) {
+          // Faster than string interpolation
+          results.push(encode(key) + '=' + encode(value2));
+        }
+        return results;
+      }, []).join('&');
+    }
+    // Faster than string interpolation
+    return encode(key) + '=' + encode(value);
+  })
+  /* must check for length, as we only want to filter empty strings, not things that look falsey! */.filter(x => x.length > 0).join('&');
+  return query ? `?${query}` : '';
+};
+const parseQuery = query => {
+  const parsed = {};
+  query = toString(query).trim().replace(RX_QUERY_START, '');
+  if (!query) {
+    return parsed;
+  }
+  query.split('&').forEach(param => {
+    const parts = param.replace(RX_PLUS, ' ').split('=');
+    const key = decode(parts.shift());
+    const value = parts.length > 0 ? decode(parts.join('=')) : null;
+    if (isUndefined(parsed[key])) {
+      parsed[key] = value;
+    } else if (isArray(parsed[key])) {
+      parsed[key].push(value);
+    } else {
+      parsed[key] = [parsed[key], value];
+    }
+  });
+  return parsed;
+};
+const isLink = props => !!(props.href || props.to);
+const routerLink = {
+  functional: true,
+  _name: 'router-link',
+  render(h, ctx) {
+    // $hasNormal is Vue.js 2 legacy way to check if default slot is scoped or not
+    // in bootstrap-vue codebase we never use scoped slots router-link rendering
+    return h('router-link', ctx.data, {
+      ...ctx.children,
+      $hasNormal: true
+    });
+  }
+};
+const isRouterLink = tag => !!(tag && !isTag(tag, 'a'));
+const computeTag = (_ref, thisOrParent) => {
+  let {
+    to,
+    disabled,
+    routerComponentName
+  } = _ref;
+  const hasRouter = !!safeVueInstance(thisOrParent).$router;
+  const hasNuxt = !!safeVueInstance(thisOrParent).$nuxt;
+  if (!hasRouter || hasRouter && (disabled || !to)) {
+    return ANCHOR_TAG;
+  }
+
+  // TODO:
+  //   Check registered components for existence of user supplied router link component name
+  //   We would need to check PascalCase, kebab-case, and camelCase versions of name:
+  //   const name = routerComponentName
+  //   const names = [name, PascalCase(name), KebabCase(name), CamelCase(name)]
+  //   exists = names.some(name => !!thisOrParent.$options.components[name])
+  //   And may want to cache the result for performance or we just let the render fail
+  //   if the component is not registered
+  const actualRouterLink = isVue3(thisOrParent) ? routerLink : 'router-link';
+  return routerComponentName || (hasNuxt ? 'nuxt-link' : actualRouterLink);
+};
+const computeRel = function () {
+  let {
+    target,
+    rel
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return target === '_blank' && isNull(rel) ? 'noopener' : rel || null;
+};
+const computeHref = function () {
+  let {
+    href,
+    to
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  let tag = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ANCHOR_TAG;
+  let fallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '#';
+  let toFallback = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '/';
+  // Return `href` when explicitly provided
+  if (href) {
+    return href;
+  }
+
+  // We've checked for `$router` in `computeTag()`, so `isRouterLink()` indicates a live router
+  // When deferring to Vue Router's `<router-link>`, don't use the `href` attribute at all
+  // We return `null`, and then remove `href` from the attributes passed to `<router-link>`
+  if (isRouterLink(tag)) {
+    return null;
+  }
+
+  // Fallback to `to` prop (if `to` is a string)
+  if (isString(to)) {
+    return to || toFallback;
+  }
+  // Fallback to `to.path' + `to.query` + `to.hash` prop (if `to` is an object)
+  if (isPlainObject(to) && (to.path || to.query || to.hash)) {
+    const path = toString(to.path);
+    const query = stringifyQueryObj(to.query);
+    let hash = toString(to.hash);
+    hash = !hash || hash.charAt(0) === '#' ? hash : `#${hash}`;
+    return `${path}${query}${hash}` || toFallback;
+  }
+
+  // If nothing is provided return the fallback
+  return fallback;
+};
+
+export { computeHref, computeRel, computeTag, isLink, isRouterLink, parseQuery, stringifyQueryObj };

package/dist/vendor/bootstrap-vue/src/utils/safe-vue-instance.js

@@ -0,0 +1,14 @@
+import { isVue3 } from '../vue';
+
+function safeVueInstance(target) {
+  if (!isVue3(target)) {
+    return target;
+  }
+  return new Proxy(target, {
+    get(target, prop) {
+      return prop in target ? target[prop] : undefined;
+    }
+  });
+}
+
+export { safeVueInstance };

package/dist/vendor/bootstrap-vue/src/utils/stable-sort.js

@@ -0,0 +1,28 @@
+/*
+ * Consistent and stable sort function across JavaScript platforms
+ *
+ * Inconsistent sorts can cause SSR problems between client and server
+ * such as in <b-table> if sortBy is applied to the data on server side render.
+ * Chrome and V8 native sorts are inconsistent/unstable
+ *
+ * This function uses native sort with fallback to index compare when the a and b
+ * compare returns 0
+ *
+ * Algorithm based on:
+ * https://stackoverflow.com/questions/1427608/fast-stable-sorting-algorithm-implementation-in-javascript/45422645#45422645
+ *
+ * @param {array} array to sort
+ * @param {function} sort compare function
+ * @return {array}
+ */
+const stableSort = (array, compareFn) => {
+  // Using `.bind(compareFn)` on the wrapped anonymous function improves
+  // performance by avoiding the function call setup. We don't use an arrow
+  // function here as it binds `this` to the `stableSort` context rather than
+  // the `compareFn` context, which wouldn't give us the performance increase.
+  return array.map((a, index) => [index, a]).sort(function (a, b) {
+    return this(a[1], b[1]) || a[0] - b[0];
+  }.bind(compareFn)).map(e => e[1]);
+};
+
+export { stableSort };

package/dist/vendor/bootstrap-vue/src/utils/string.js

@@ -0,0 +1,47 @@
+import { RX_HYPHENATE, RX_UNDERSCORE, RX_LOWER_UPPER, RX_START_SPACE_WORD, RX_REGEXP_REPLACE, RX_TRIM_LEFT, RX_TRIM_RIGHT } from '../constants/regex';
+import { isString, isUndefinedOrNull, isArray, isPlainObject } from './inspect';
+
+// String utilities
+
+// --- Utilities ---
+
+// Converts PascalCase or camelCase to kebab-case
+const kebabCase = str => {
+  return str.replace(RX_HYPHENATE, '-$1').toLowerCase();
+};
+
+// Converts a string, including strings in camelCase or snake_case, into Start Case
+// It keeps original single quote and hyphen in the word
+// https://github.com/UrbanCompass/to-start-case
+const startCase = str => str.replace(RX_UNDERSCORE, ' ').replace(RX_LOWER_UPPER, (str, $1, $2) => $1 + ' ' + $2).replace(RX_START_SPACE_WORD, (str, $1, $2) => $1 + $2.toUpperCase());
+
+// Uppercases the first letter of a string and returns a new string
+const upperFirst = str => {
+  str = isString(str) ? str.trim() : String(str);
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+
+// Escape characters to be used in building a regular expression
+const escapeRegExp = str => str.replace(RX_REGEXP_REPLACE, '\\$&');
+
+// Convert a value to a string that can be rendered
+// `undefined`/`null` will be converted to `''`
+// Plain objects and arrays will be JSON stringified
+const toString = function (val) {
+  let spaces = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+  return isUndefinedOrNull(val) ? '' : isArray(val) || isPlainObject(val) && val.toString === Object.prototype.toString ? JSON.stringify(val, null, spaces) : String(val);
+};
+
+// Remove leading white space from a string
+const trimLeft = str => toString(str).replace(RX_TRIM_LEFT, '');
+
+// Remove Trailing white space from a string
+const trimRight = str => toString(str).replace(RX_TRIM_RIGHT, '');
+
+// Remove leading and trailing white space from a string
+const trim = str => toString(str).trim();
+
+// Lower case a string
+const lowerCase = str => toString(str).toLowerCase();
+
+export { escapeRegExp, kebabCase, lowerCase, startCase, toString, trim, trimLeft, trimRight, upperFirst };

package/dist/vendor/bootstrap-vue/src/utils/stringify-object-values.js

@@ -0,0 +1,31 @@
+import { isUndefinedOrNull, isObject, isDate } from './inspect';
+import { keys } from './object';
+import { toString } from './string';
+
+// Recursively stringifies the values of an object, space separated, in an
+// SSR safe deterministic way (keys are sorted before stringification)
+//
+//   ex:
+//     { b: 3, c: { z: 'zzz', d: null, e: 2 }, d: [10, 12, 11], a: 'one' }
+//   becomes
+//     'one 3 2 zzz 10 12 11'
+//
+// Strings are returned as-is
+// Numbers get converted to string
+// `null` and `undefined` values are filtered out
+// Dates are converted to their native string format
+const stringifyObjectValues = value => {
+  if (isUndefinedOrNull(value)) {
+    return '';
+  }
+  // Arrays are also object, and keys just returns the array indexes
+  // Date objects we convert to strings
+  if (isObject(value) && !isDate(value)) {
+    return keys(value).sort() // Sort to prevent SSR issues on pre-rendered sorted tables
+    .map(k => stringifyObjectValues(value[k])).filter(v => !!v) // Ignore empty strings
+    .join(' ');
+  }
+  return toString(value);
+};
+
+export { stringifyObjectValues };

package/dist/vendor/bootstrap-vue/src/utils/warn.js

@@ -0,0 +1,45 @@
+import { IS_BROWSER, HAS_MUTATION_OBSERVER_SUPPORT } from '../constants/env';
+import { getNoWarn } from './env';
+
+/**
+ * Log a warning message to the console with BootstrapVue formatting
+ * @param {string} message
+ */
+const warn = function (message) /* istanbul ignore next */{
+  let source = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  if (!getNoWarn()) {
+    console.warn(`[BootstrapVue warn]: ${source ? `${source} - ` : ''}${message}`);
+  }
+};
+
+/**
+ * Warn when no Promise support is given
+ * @param {string} source
+ * @returns {boolean} warned
+ */
+const warnNotClient = source => {
+  /* istanbul ignore else */
+  if (IS_BROWSER) {
+    return false;
+  } else {
+    warn(`${source}: Can not be called during SSR.`);
+    return true;
+  }
+};
+
+/**
+ * Warn when no MutationObserver support is given
+ * @param {string} source
+ * @returns {boolean} warned
+ */
+const warnNoMutationObserverSupport = source => {
+  /* istanbul ignore else */
+  if (HAS_MUTATION_OBSERVER_SUPPORT) {
+    return false;
+  } else {
+    warn(`${source}: Requires MutationObserver support.`);
+    return true;
+  }
+};
+
+export { warn, warnNoMutationObserverSupport, warnNotClient };

package/dist/vendor/bootstrap-vue/src/vue.js

@@ -0,0 +1,55 @@
+import Vue from 'vue';
+import { mergeData as mergeData$1 } from 'vue-functional-data-merge';
+
+// --- Constants ---
+const COMPONENT_UID_KEY = '_uid';
+const isGlobalVue3 = Vue.version.startsWith('3');
+const REF_FOR_KEY = isGlobalVue3 ? 'ref_for' : 'refInFor';
+if (isGlobalVue3) {
+  const originalVModelDynamicCreated = Vue.vModelDynamic.created;
+  const originalVModelDynamicBeforeUpdate = Vue.vModelDynamic.beforeUpdate;
+  let assignSymbol;
+
+  // See https://github.com/vuejs/vue-next/pull/4121 for details
+  Vue.vModelDynamic.created = function (el, binding, vnode) {
+    originalVModelDynamicCreated.call(this, el, binding, vnode);
+    if (!el._assign) {
+      el._assign = () => {};
+    }
+
+    // Added check for Symbol('_assign') to fix in compat 3.3.5+ based on https://github.com/bootstrap-vue/bootstrap-vue/issues/7181
+    if (!assignSymbol) {
+      assignSymbol = Object.getOwnPropertySymbols(el).find(s => s.description === '_assign');
+    }
+    if (!el[assignSymbol]) {
+      el[assignSymbol] = function () {};
+    }
+  };
+  Vue.vModelDynamic.beforeUpdate = function (el, binding, vnode) {
+    originalVModelDynamicBeforeUpdate.call(this, el, binding, vnode);
+    if (!el._assign) {
+      el._assign = () => {};
+    }
+
+    // Added check for Symbol('_assign') to fix in 3.3.5+ based on https://github.com/bootstrap-vue/bootstrap-vue/issues/7181
+    if (!assignSymbol) {
+      assignSymbol = Object.getOwnPropertySymbols(el).find(s => s.description === '_assign');
+    }
+    if (!el[assignSymbol]) {
+      el[assignSymbol] = function () {};
+    }
+  };
+}
+const isVue3 = instance => Boolean(instance.$);
+const extend = Vue.extend.bind(Vue);
+function mergeData() {
+  var _result$attrs, _result$props;
+  const result = mergeData$1(...arguments);
+  return {
+    ...result,
+    ...((_result$attrs = result.attrs) !== null && _result$attrs !== void 0 ? _result$attrs : {}),
+    ...((_result$props = result.props) !== null && _result$props !== void 0 ? _result$props : {})
+  };
+}
+
+export { COMPONENT_UID_KEY, REF_FOR_KEY, extend, isGlobalVue3, isVue3, mergeData };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitlab/ui",
-  "version": "132.0.1",
+  "version": "132.0.2",
   "description": "GitLab UI Components",
   "license": "MIT",
   "main": "dist/index.js",
@@ -36,6 +36,7 @@
   "scripts": {
     "build": "NODE_ENV=production rollup -c",
     "prebuild": "yarn build-tokens",
+    "prepack": "yarn build",
     "copy-fonts": "make copy-fonts",
     "build-tokens": "make tokens",
     "sync-tokens": "node --env-file=.figma.env bin/figma_sync_tokens.mjs",
@@ -90,7 +91,7 @@
     "chokidar": "^4.0.3",
     "sane": "^5.0.1",
     "jackspeak": "2.1.1",
-    "postcss": "8.5.9",
+    "postcss": "8.5.10",
     "json5": "2.2.3",
     "rollup-plugin-vue/@vue/component-compiler/postcss-modules-sync/generic-names/loader-utils": "3.3.1"
   },
@@ -153,7 +154,7 @@
     "pikaday": "^1.8.0",
     "playwright": "^1.59.1",
     "playwright-core": "^1.59.1",
-    "postcss": "8.5.9",
+    "postcss": "8.5.10",
     "postcss-loader": "8.2.1",
     "postcss-scss": "4.0.9",
     "react": "18.3.1",

package/src/vendor/bootstrap-vue/src/components/dropdown/dropdown.js

@@ -7,7 +7,7 @@ import {
   PROP_TYPE_STRING
 } from '../../constants/props'
 import { SLOT_NAME_BUTTON_CONTENT, SLOT_NAME_DEFAULT } from '../../constants/slots'
-import { arrayIncludes } from '../../utils/array'
+
 import { htmlOrText } from '../../utils/html'
 import { toString } from '../../utils/string'
 import { dropdownMixin, props as dropdownProps } from '../../mixins/dropdown'
@@ -67,7 +67,7 @@ export const props = sortKeys({
     required: false,
     default: 'button',
     validator: value => {
-      return arrayIncludes(['button', 'submit', 'reset'], value)
+      return ['button', 'submit', 'reset'].includes(value)
     }
   },
   splitClass: {

package/src/vendor/bootstrap-vue/src/components/form-group/form-group.js

@@ -14,7 +14,7 @@ import {
   SLOT_NAME_LABEL,
   SLOT_NAME_VALID_FEEDBACK
 } from '../../constants/slots'
-import { arrayIncludes } from '../../utils/array'
+
 import { getBreakpointsUpCached } from '../../utils/config'
 import { cssEscape } from '../../utils/css-escape'
 import {
@@ -185,7 +185,7 @@ export const BFormGroup = {
           // and ensuring the ID's are unique
           const ids = (getAttr($input, attr) || '')
             .split(RX_SPACE_SPLIT)
-            .filter(id => !arrayIncludes(oldIds, id))
+            .filter(id => !oldIds.includes(id))
             .concat(newIds)
             .filter((id, index, ids) => ids.indexOf(id) === index)
             .filter(identity)

package/src/vendor/bootstrap-vue/src/components/layout/col.js

@@ -7,7 +7,7 @@ import {
   PROP_TYPE_STRING
 } from '../../constants/props'
 import { RX_COL_CLASS } from '../../constants/regex'
-import { arrayIncludes } from '../../utils/array'
+
 import { getBreakpointsUpCached } from '../../utils/config'
 import { identity } from '../../utils/identity'
 import { isUndefinedOrNull } from '../../utils/inspect'
@@ -89,7 +89,7 @@ export const generateProps = () => {
     ...breakpointOrder,
     // Flex alignment
     alignSelf: makeProp(PROP_TYPE_STRING, null, value => {
-      return arrayIncludes(ALIGN_SELF_VALUES, value)
+      return ALIGN_SELF_VALUES.includes(value)
     }),
     // Generic flexbox 'col' (xs)
     col: makeProp(PROP_TYPE_BOOLEAN, false),

package/src/vendor/bootstrap-vue/src/components/modal/modal.js

@@ -31,7 +31,7 @@ import {
   SLOT_NAME_MODAL_OK,
   SLOT_NAME_MODAL_TITLE
 } from '../../constants/slots'
-import { arrayIncludes, concat } from '../../utils/array'
+import { concat } from '../../utils/array'
 import {
   attemptFocus,
   closest,
@@ -112,7 +112,7 @@ export const props = sortKeys({
     required: false,
     default: null,
     validator: value => {
-      return isUndefinedOrNull(value) || arrayIncludes(BUTTONS, value)
+      return isUndefinedOrNull(value) || BUTTONS.includes(value)
     }
   },
   bodyClass: {

package/src/vendor/bootstrap-vue/src/components/tabs/tabs.js

@@ -34,7 +34,7 @@ import {
   SLOT_NAME_TOOLBAR_START,
   SLOT_NAME_TITLE
 } from '../../constants/slots'
-import { arrayIncludes } from '../../utils/array'
+
 import { BvEvent } from '../../utils/bv-event.class'
 import { attemptFocus, selectAll, requestAF } from '../../utils/dom'
 import { stopEvent } from '../../utils/events'
@@ -410,7 +410,7 @@ export const BTabs = /*#__PURE__*/ extend({
   },
   methods: {
     registerTab($tab) {
-      if (!arrayIncludes(this.registeredTabs, $tab)) {
+      if (!this.registeredTabs.includes($tab)) {
         this.registeredTabs.push($tab)
       }
     },

package/src/vendor/bootstrap-vue/src/components/tooltip/helpers/bv-tooltip.js

@@ -22,7 +22,7 @@ import {
 } from '../../../constants/events'
 import { onInstanceDestroy } from '../../../utils/on-instance-destroy'
 import { useParentMixin } from '../../../mixins/use-parent'
-import { arrayIncludes, concat, from as arrayFrom } from '../../../utils/array'
+import { concat, from as arrayFrom } from '../../../utils/array'
 import { getInstanceFromElement } from '../../../utils/element-to-vue-instance-registry'
 import {
   attemptFocus,
@@ -208,7 +208,7 @@ export const BVTooltip = /*#__PURE__*/ extend({
           this.unListen()
           // Clear any active triggers that are no longer in the list of triggers
           oldTriggers.forEach(trigger => {
-            if (!arrayIncludes(newTriggers, trigger)) {
+            if (!newTriggers.includes(trigger)) {
               if (this.activeTrigger[trigger]) {
                 this.activeTrigger[trigger] = false
               }
@@ -805,19 +805,18 @@ export const BVTooltip = /*#__PURE__*/ extend({
       const type = event.type
       const triggers = this.computedTriggers
 
-      if (type === 'click' && arrayIncludes(triggers, 'click')) {
+      if (type === 'click' && triggers.includes('click')) {
         this.click(event)
-      } else if (type === 'mouseenter' && arrayIncludes(triggers, 'hover')) {
+      } else if (type === 'mouseenter' && triggers.includes('hover')) {
         // `mouseenter` is a non-bubbling event
         this.enter(event)
-      } else if (type === 'focusin' && arrayIncludes(triggers, 'focus')) {
+      } else if (type === 'focusin' && triggers.includes('focus')) {
         // `focusin` is a bubbling event
         // `event` includes `relatedTarget` (element losing focus)
         this.enter(event)
       } else if (
-        (type === 'focusout' &&
-          (arrayIncludes(triggers, 'focus') || arrayIncludes(triggers, 'blur'))) ||
-        (type === 'mouseleave' && arrayIncludes(triggers, 'hover'))
+        (type === 'focusout' && (triggers.includes('focus') || triggers.includes('blur'))) ||
+        (type === 'mouseleave' && triggers.includes('hover'))
       ) {
         // `focusout` is a bubbling event
         // `mouseleave` is a non-bubbling event
@@ -944,7 +943,7 @@ export const BVTooltip = /*#__PURE__*/ extend({
       if (event) {
         this.activeTrigger[event.type === 'focusout' ? 'focus' : 'hover'] = false
         /* istanbul ignore next */
-        if (event.type === 'focusout' && arrayIncludes(this.computedTriggers, 'blur')) {
+        if (event.type === 'focusout' && this.computedTriggers.includes('blur')) {
           // Special case for `blur`: we clear out the other triggers
           this.activeTrigger.click = false
           this.activeTrigger.hover = false

package/src/vendor/bootstrap-vue/src/mixins/listen-on-document.js

@@ -1,7 +1,6 @@
 import { extend } from '../vue'
 import { IS_BROWSER } from '../constants/env'
 import { EVENT_OPTIONS_NO_CAPTURE } from '../constants/events'
-import { arrayIncludes } from '../utils/array'
 import { eventOn, eventOff } from '../utils/events'
 import { keys } from '../utils/object'
 
@@ -33,7 +32,7 @@ export const listenOnDocumentMixin = extend({
     registerDocumentListener(event, callback) {
       if (this[PROP]) {
         this[PROP][event] = this[PROP][event] || []
-        if (!arrayIncludes(this[PROP][event], callback)) {
+        if (!this[PROP][event].includes(callback)) {
           this[PROP][event].push(callback)
         }
       }

package/src/vendor/bootstrap-vue/src/mixins/listen-on-root.js

@@ -1,5 +1,4 @@
 import { extend } from '../vue'
-import { arrayIncludes } from '../utils/array'
 import { keys } from '../utils/object'
 import { getEventRoot } from '../utils/get-event-root'
 // --- Constants ---
@@ -35,7 +34,7 @@ export const listenOnRootMixin = extend({
     registerRootListener(event, callback) {
       if (this[PROP]) {
         this[PROP][event] = this[PROP][event] || []
-        if (!arrayIncludes(this[PROP][event], callback)) {
+        if (!this[PROP][event].includes(callback)) {
           this[PROP][event].push(callback)
         }
       }