{"version":3,"sources":["webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/text-selection-active.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/tfoot.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-stacked.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/normalize-fields.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-items.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-tfoot.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/filter-event.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/constants.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-colgroup.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/thead.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-thead.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/td.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/th.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/tbody.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-tbody-row.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-tbody.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/mixins/has-listener.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/tr.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-caption.js","webpack:////build/source/node_modules/@gitlab/ui/dist/vendor/bootstrap-vue/src/components/table/helpers/mixin-table-renderer.js"],"names":["textSelectionActive","el","arguments","length","undefined","document","sel","toString","trim","containsNode","props","footVariant","BTfoot","name","mixins","getBvTableRowGroup","this","inject","getBvTable","default","inheritAttrs","computed","isTfoot","bvTable","dark","isStacked","isResponsive","isStickyHeader","stickyHeader","tableVariant","bvAttrs","role","h","class","tfootClasses","attrs","tfootAttrs","on","bvListeners","normalizeSlot","stacked","stackedMixin","isStackedAlways","normalizeFields","origFields","items","fields","filter","identity","forEach","f","push","key","label","field","value","formatter","processField","sample","k","memo","mixin","modelMixin","modelProps","prop","MODEL_PROP_NAME","event","MODEL_EVENT_NAME","type","defaultValue","primaryKey","itemsMixin","localItems","slice","bvParent","computedFields","reduce","obj","paginatedItems","sortedItems","filteredItems","perPage","currentPage","localFilter","sortBy","localSortBy","sortDesc","localSortDesc","math","apiUrl","watch","newValue","oldValue","$emit","computedItems","methods","computedFieldsObj","footClone","footRowVariant","tfootClass","tfootTrClass","tfootMixin","$createElement","hasNormalizedSlot","headVariant","columns","renderThead","renderTFootCustom","TABLE_TAG_NAMES","filterEvent","target","disabled","indexOf","tagName","labelFor","input","FIELD_KEY_CELL_VARIANT","FIELD_KEY_ROW_VARIANT","FIELD_KEY_SHOW_DETAILS","IGNORED_FIELD_KEYS","result","EVENT_FILTER","join","colgroupMixin","$colgroup","BThead","listeners","isThead","theadClasses","theadAttrs","getHeadSlotName","getFootSlotName","headRowVariant","theadClass","theadTrClass","theadMixin","fieldClasses","thClass","isFoot","stopIfBusy","$el","isSortable","isSelectable","hasHeadClickListener","hasListener","selectAllRows","noop","clearSelected","$cells","map","colIndex","labelHtml","variant","stickyColumn","ariaLabel","headerTitle","click","headClicked","keydown","keyCode","sortAttrs","sortTheadThAttrs","sortClass","sortTheadThClasses","sortLabel","sortTheadThLabel","data","style","thStyle","tabindex","sortable","abbr","headerAbbr","title","getThValues","thAttr","slotNames","toLowerCase","scope","column","$content","domProps","html","$srLabel","staticClass","$trs","parseSpan","spanValidator","colspan","rowspan","stackedHeading","BTd","getBvTableTr","tag","bvTableTr","inTbody","inThead","inTfoot","isDark","hasStickyHeader","isStickyColumn","rowVariant","headOrFoot","computedColspan","computedRowspan","isStackedCell","cellClasses","cellAttrs","BTh","extends","tbodyTransitionHandlers","tbodyTransitionProps","BTbody","isTbody","tbodyProps","tbodyAttrs","isTransitionGroup","nativeOn","detailsTdClass","tbodyTrAttr","tbodyTrClass","tbodyRowMixin","item","tdValue","get","thValue","getFieldFormatter","hasDetailsSlot","$set","tbodyRowEventStopped","emitTbodyRowEvent","rowIndex","isRowHeader","formatted","getFormattedValue","cellTag","cellVariant","getTdValues","tdClass","String","tdAttr","slotScope","index","unformatted","toggleDetails","toggleDetailsFactory","detailsShowing","Boolean","supportsSelectableRows","rowSelected","isRowSelected","selectRow","unselectRow","slotName","$_bodyFieldSlotNameCache","$childNodes","striped","hasSelectableRowClick","rowShowDetails","hasRowClickHandler","$listeners","$rows","detailsId","safeId","$tds","renderTbodyRowCell","ariaRowIndex","primaryKeyValue","rowKey","rowId","selectableClasses","selectableRowClasses","selectableAttrs","selectableRowAttrs","userTrClasses","userTrAttrs","id","mouseenter","rowHovered","mouseleave","rowUnhovered","ref","detailsScope","$details","userDetailsTrClasses","userDetailsTrAttrs","getCellSlotName","tbodyClass","tbodyMixin","$refs","tbody","trs","tr","children","array","getTbodyTrs","getTbodyTrIndex","tabIndex","onTBodyRowClicked","shift","shiftKey","which","renderBusy","renderTopRow","renderEmpty","renderBottomRow","$busy","cache","defaultSlotName","lowercaseSlotName","renderTbodyRow","handlers","auxclick","onTbodyRowMiddleMouseRowClicked","contextmenu","onTbodyRowContextmenu","dblclick","onTbodyRowDblClicked","onTbodyRowKeydown","$props","hasListenerMixin","$events","_events","BTr","bvTableRowGroup","isRowDark","trClasses","trAttrs","caption","captionHtml","captionMixin","$caption","hasCaptionSlot","captionId","bordered","borderless","captionTop","fixed","hover","noBorderCollapse","outlined","responsive","small","tableClass","tableRendererMixin","isTableSimple","maxHeight","selectableTableClasses","stackedTableClasses","computedBusy","selectableTableAttrs","ariaAttrs","wrapperClasses","renderCaption","renderColgroup","renderTbody","renderTfoot","$table","tableClasses","tableAttrs","wrapperStyles"],"mappings":"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","file":"20.7c3b1421.chunk.js","sourcesContent":["import { getSel, isElement } from '../../../utils/dom';\n\n// Helper to determine if a there is an active text selection on the document page\n// Used to filter out click events caused by the mouse up at end of selection\n//\n// Accepts an element as only argument to test to see if selection overlaps or is\n// contained within the element\nconst textSelectionActive = function () {\n  let el = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;\n  const sel = getSel();\n  return sel && sel.toString().trim() !== '' && sel.containsNode && isElement(el) ? /* istanbul ignore next */sel.containsNode(el, true) : false;\n};\n\nexport { textSelectionActive };\n","import { extend } from '../../vue';\nimport { NAME_TFOOT } from '../../constants/components';\nimport { PROP_TYPE_STRING } from '../../constants/props';\nimport { makePropsConfigurable, makeProp } from '../../utils/props';\nimport { attrsMixin } from '../../mixins/attrs';\nimport { listenersMixin } from '../../mixins/listeners';\nimport { normalizeSlotMixin } from '../../mixins/normalize-slot';\n\n// --- Props ---\n\nconst props = makePropsConfigurable({\n  // Supported values: 'lite', 'dark', or null\n  footVariant: makeProp(PROP_TYPE_STRING)\n}, NAME_TFOOT);\n\n// --- Main component ---\n\n// TODO:\n//   In Bootstrap v5, we won't need \"sniffing\" as table element variants properly inherit\n//   to the child elements, so this can be converted to a functional component\n// @vue/component\nconst BTfoot = /*#__PURE__*/extend({\n  name: NAME_TFOOT,\n  mixins: [attrsMixin, listenersMixin, normalizeSlotMixin],\n  provide() {\n    return {\n      getBvTableRowGroup: () => this\n    };\n  },\n  inject: {\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    getBvTable: {\n      default: /* istanbul ignore next */() => () => ({})\n    }\n  },\n  inheritAttrs: false,\n  props,\n  computed: {\n    bvTable() {\n      return this.getBvTable();\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    isTfoot() {\n      return true;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    isDark() {\n      return this.bvTable.dark;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    isStacked() {\n      return this.bvTable.isStacked;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    isResponsive() {\n      return this.bvTable.isResponsive;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    // Sticky headers are only supported in thead\n    isStickyHeader() {\n      return false;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    // Needed to handle header background classes, due to lack of\n    // background color inheritance with Bootstrap v4 table CSS\n    hasStickyHeader() {\n      return !this.isStacked && this.bvTable.stickyHeader;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    tableVariant() {\n      return this.bvTable.tableVariant;\n    },\n    tfootClasses() {\n      return [this.footVariant ? `thead-${this.footVariant}` : null];\n    },\n    tfootAttrs() {\n      return {\n        ...this.bvAttrs,\n        role: 'rowgroup'\n      };\n    }\n  },\n  render(h) {\n    return h('tfoot', {\n      class: this.tfootClasses,\n      attrs: this.tfootAttrs,\n      // Pass down any native listeners\n      on: this.bvListeners\n    }, this.normalizeSlot());\n  }\n});\n\nexport { BTfoot, props };\n","import { extend } from '../../../vue';\nimport { PROP_TYPE_BOOLEAN_STRING } from '../../../constants/props';\nimport { makeProp } from '../../../utils/props';\n\n// --- Props ---\n\nconst props = {\n  stacked: makeProp(PROP_TYPE_BOOLEAN_STRING, false)\n};\n\n// --- Mixin ---\n\n// @vue/component\nconst stackedMixin = extend({\n  props,\n  computed: {\n    isStacked() {\n      const {\n        stacked\n      } = this;\n      // `true` when always stacked, or returns breakpoint specified\n      return stacked === '' ? true : stacked;\n    },\n    isStackedAlways() {\n      return this.isStacked === true;\n    },\n    stackedTableClasses() {\n      const {\n        isStackedAlways\n      } = this;\n      return {\n        'b-table-stacked': isStackedAlways,\n        [`b-table-stacked-${this.stacked}`]: !isStackedAlways && this.isStacked\n      };\n    }\n  }\n});\n\nexport { props, stackedMixin };\n","import { identity } from '../../../utils/identity';\nimport { isArray, isString, isObject, isFunction } from '../../../utils/inspect';\nimport { clone, keys } from '../../../utils/object';\nimport { startCase } from '../../../utils/string';\nimport { IGNORED_FIELD_KEYS } from './constants';\n\n// Private function to massage field entry into common object format\nconst processField = (key, value) => {\n  let field = null;\n  if (isString(value)) {\n    // Label shortcut\n    field = {\n      key,\n      label: value\n    };\n  } else if (isFunction(value)) {\n    // Formatter shortcut\n    field = {\n      key,\n      formatter: value\n    };\n  } else if (isObject(value)) {\n    field = clone(value);\n    field.key = field.key || key;\n  } else if (value !== false) {\n    // Fallback to just key\n    /* istanbul ignore next */\n    field = {\n      key\n    };\n  }\n  return field;\n};\n\n// We normalize fields into an array of objects\n// [ { key:..., label:..., ...}, {...}, ..., {..}]\nconst normalizeFields = (origFields, items) => {\n  const fields = [];\n  if (isArray(origFields)) {\n    // Normalize array Form\n    origFields.filter(identity).forEach(f => {\n      if (isString(f)) {\n        fields.push({\n          key: f,\n          label: startCase(f)\n        });\n      } else if (isObject(f) && f.key && isString(f.key)) {\n        // Full object definition. We use assign so that we don't mutate the original\n        fields.push(clone(f));\n      } else if (isObject(f) && keys(f).length === 1) {\n        // Shortcut object (i.e. { 'foo_bar': 'This is Foo Bar' }\n        const key = keys(f)[0];\n        const field = processField(key, f[key]);\n        if (field) {\n          fields.push(field);\n        }\n      }\n    });\n  }\n\n  // If no field provided, take a sample from first record (if exits)\n  if (fields.length === 0 && isArray(items) && items.length > 0) {\n    const sample = items[0];\n    keys(sample).forEach(k => {\n      if (!IGNORED_FIELD_KEYS[k]) {\n        fields.push({\n          key: k,\n          label: startCase(k)\n        });\n      }\n    });\n  }\n\n  // Ensure we have a unique array of fields and that they have String labels\n  const memo = {};\n  return fields.filter(f => {\n    if (!memo[f.key]) {\n      memo[f.key] = true;\n      f.label = isString(f.label) ? f.label : startCase(f.key);\n      return true;\n    }\n    return false;\n  });\n};\n\nexport { normalizeFields };\n","import { extend } from '../../../vue';\nimport { EVENT_NAME_CONTEXT_CHANGED } from '../../../constants/events';\nimport { PROP_TYPE_ARRAY, PROP_TYPE_STRING } from '../../../constants/props';\nimport { useParentMixin } from '../../../mixins/use-parent';\nimport { isArray, isString, isFunction } from '../../../utils/inspect';\nimport { looseEqual } from '../../../utils/loose-equal';\nimport { mathMax } from '../../../utils/math';\nimport { makeModelMixin } from '../../../utils/model';\nimport { toInteger } from '../../../utils/number';\nimport { sortKeys, clone } from '../../../utils/object';\nimport { makeProp } from '../../../utils/props';\nimport { safeVueInstance } from '../../../utils/safe-vue-instance';\nimport { normalizeFields } from './normalize-fields';\n\n// --- Constants ---\n\nconst {\n  mixin: modelMixin,\n  props: modelProps,\n  prop: MODEL_PROP_NAME,\n  event: MODEL_EVENT_NAME\n} = makeModelMixin('value', {\n  type: PROP_TYPE_ARRAY,\n  defaultValue: []\n});\n\n// --- Props ---\n\nconst props = sortKeys({\n  ...modelProps,\n  fields: makeProp(PROP_TYPE_ARRAY, null),\n  // Provider mixin adds in `Function` type\n  items: makeProp(PROP_TYPE_ARRAY, []),\n  // Primary key for record\n  // If provided the value in each row must be unique!\n  primaryKey: makeProp(PROP_TYPE_STRING),\n  // `v-model` for retrieving the current displayed rows\n  [MODEL_PROP_NAME]: makeProp(PROP_TYPE_ARRAY, [])\n});\n\n// --- Mixin ---\n\n// @vue/component\nconst itemsMixin = extend({\n  mixins: [modelMixin, useParentMixin],\n  props,\n  data() {\n    const {\n      items\n    } = this;\n    return {\n      // Our local copy of the items\n      // Must be an array\n      localItems: isArray(items) ? items.slice() : []\n    };\n  },\n  computed: {\n    computedFields() {\n      // We normalize fields into an array of objects\n      // `[ { key:..., label:..., ...}, {...}, ..., {..}]`\n      return normalizeFields(this.fields, this.localItems);\n    },\n    computedFieldsObj() {\n      // Fields as a simple lookup hash object\n      // Mainly for formatter lookup and use in `scopedSlots` for convenience\n      // If the field has a formatter, it normalizes formatter to a\n      // function ref or `undefined` if no formatter\n      const {\n        bvParent\n      } = this;\n      return this.computedFields.reduce((obj, f) => {\n        // We use object spread here so we don't mutate the original field object\n        obj[f.key] = clone(f);\n        if (f.formatter) {\n          // Normalize formatter to a function ref or `undefined`\n          let formatter = f.formatter;\n          if (isString(formatter) && isFunction(bvParent[formatter])) {\n            formatter = bvParent[formatter];\n          } else if (!isFunction(formatter)) {\n            /* istanbul ignore next */\n            formatter = undefined;\n          }\n          // Return formatter function or `undefined` if none\n          obj[f.key].formatter = formatter;\n        }\n        return obj;\n      }, {});\n    },\n    computedItems() {\n      const {\n        paginatedItems,\n        sortedItems,\n        filteredItems,\n        localItems\n      } = safeVueInstance(this);\n      // Fallback if various mixins not provided\n      return (paginatedItems || sortedItems || filteredItems || localItems || /* istanbul ignore next */\n      []).slice();\n    },\n    context() {\n      const {\n        perPage,\n        currentPage\n      } = safeVueInstance(this);\n      // Current state of sorting, filtering and pagination props/values\n      return {\n        filter: this.localFilter,\n        sortBy: this.localSortBy,\n        sortDesc: this.localSortDesc,\n        perPage: mathMax(toInteger(perPage, 0), 0),\n        currentPage: mathMax(toInteger(currentPage, 0), 1),\n        apiUrl: this.apiUrl\n      };\n    }\n  },\n  watch: {\n    items(newValue) {\n      // Set `localItems`/`filteredItems` to a copy of the provided array\n      this.localItems = isArray(newValue) ? newValue.slice() : [];\n    },\n    // Watch for changes on `computedItems` and update the `v-model`\n    computedItems(newValue, oldValue) {\n      if (!looseEqual(newValue, oldValue)) {\n        this.$emit(MODEL_EVENT_NAME, newValue);\n      }\n    },\n    // Watch for context changes\n    context(newValue, oldValue) {\n      // Emit context information for external paging/filtering/sorting handling\n      if (!looseEqual(newValue, oldValue)) {\n        this.$emit(EVENT_NAME_CONTEXT_CHANGED, newValue);\n      }\n    }\n  },\n  mounted() {\n    // Initially update the `v-model` of displayed items\n    this.$emit(MODEL_EVENT_NAME, this.computedItems);\n  },\n  methods: {\n    // Method to get the formatter method for a given field key\n    getFieldFormatter(key) {\n      const field = this.computedFieldsObj[key];\n      // `this.computedFieldsObj` has pre-normalized the formatter to a\n      // function ref if present, otherwise `undefined`\n      return field ? field.formatter : undefined;\n    }\n  }\n});\n\nexport { MODEL_EVENT_NAME, MODEL_PROP_NAME, itemsMixin, props };\n","import { extend } from '../../../vue';\nimport { PROP_TYPE_BOOLEAN, PROP_TYPE_STRING, PROP_TYPE_ARRAY_OBJECT_STRING } from '../../../constants/props';\nimport { SLOT_NAME_CUSTOM_FOOT } from '../../../constants/slots';\nimport { makeProp } from '../../../utils/props';\nimport { BTfoot } from '../tfoot';\n\n// --- Props ---\n\nconst props = {\n  footClone: makeProp(PROP_TYPE_BOOLEAN, false),\n  // Any Bootstrap theme variant (or custom)\n  // Falls back to `headRowVariant`\n  footRowVariant: makeProp(PROP_TYPE_STRING),\n  // 'dark', 'light', or `null` (or custom)\n  footVariant: makeProp(PROP_TYPE_STRING),\n  tfootClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING),\n  tfootTrClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING)\n};\n\n// --- Mixin ---\n\n// @vue/component\nconst tfootMixin = extend({\n  props,\n  methods: {\n    renderTFootCustom() {\n      const h = this.$createElement;\n      if (this.hasNormalizedSlot(SLOT_NAME_CUSTOM_FOOT)) {\n        return h(BTfoot, {\n          class: this.tfootClass || null,\n          props: {\n            footVariant: this.footVariant || this.headVariant || null\n          },\n          key: 'bv-tfoot-custom'\n        }, this.normalizeSlot(SLOT_NAME_CUSTOM_FOOT, {\n          items: this.computedItems.slice(),\n          fields: this.computedFields.slice(),\n          columns: this.computedFields.length\n        }));\n      }\n      return h();\n    },\n    renderTfoot() {\n      // Passing true to renderThead will make it render a tfoot\n      return this.footClone ? this.renderThead(true) : this.renderTFootCustom();\n    }\n  }\n});\n\nexport { props, tfootMixin };\n","import { closest, getAttr, getById, select, matches } from '../../../utils/dom';\nimport { EVENT_FILTER } from './constants';\n\nconst TABLE_TAG_NAMES = ['TD', 'TH', 'TR'];\n\n// Returns `true` if we should ignore the click/double-click/keypress event\n// Avoids having the user need to use `@click.stop` on the form control\nconst filterEvent = event => {\n  // Exit early when we don't have a target element\n  if (!event || !event.target) {\n    /* istanbul ignore next */\n    return false;\n  }\n  const el = event.target;\n  // Exit early when element is disabled or a table element\n  if (el.disabled || TABLE_TAG_NAMES.indexOf(el.tagName) !== -1) {\n    return false;\n  }\n  // Ignore the click when it was inside a dropdown menu\n  if (closest('.dropdown-menu', el)) {\n    return true;\n  }\n  const label = el.tagName === 'LABEL' ? el : closest('label', el);\n  // If the label's form control is not disabled then we don't propagate event\n  // Modern browsers have `label.control` that references the associated input, but IE 11\n  // does not have this property on the label element, so we resort to DOM lookups\n  if (label) {\n    const labelFor = getAttr(label, 'for');\n    const input = labelFor ? getById(labelFor) : select('input, select, textarea', label);\n    if (input && !input.disabled) {\n      return true;\n    }\n  }\n  // Otherwise check if the event target matches one of the selectors in the\n  // event filter (i.e. anchors, non disabled inputs, etc.)\n  // Return `true` if we should ignore the event\n  return matches(el, EVENT_FILTER);\n};\n\nexport { filterEvent };\n","// Constants used by table helpers\n\nconst FIELD_KEY_CELL_VARIANT = '_cellVariants';\nconst FIELD_KEY_ROW_VARIANT = '_rowVariant';\nconst FIELD_KEY_SHOW_DETAILS = '_showDetails';\n\n// Object of item keys that should be ignored for headers and\n// stringification and filter events\nconst IGNORED_FIELD_KEYS = [FIELD_KEY_CELL_VARIANT, FIELD_KEY_ROW_VARIANT, FIELD_KEY_SHOW_DETAILS].reduce((result, key) => ({\n  ...result,\n  [key]: true\n}), {});\n\n// Filter CSS selector for click/dblclick/etc. events\n// If any of these selectors match the clicked element, we ignore the event\nconst EVENT_FILTER = ['a', 'a *',\n// Include content inside links\n'button', 'button *',\n// Include content inside buttons\n'input:not(.disabled):not([disabled])', 'select:not(.disabled):not([disabled])', 'textarea:not(.disabled):not([disabled])', '[role=\"link\"]', '[role=\"link\"] *', '[role=\"button\"]', '[role=\"button\"] *', '[tabindex]:not(.disabled):not([disabled])'].join(',');\n\nexport { EVENT_FILTER, FIELD_KEY_CELL_VARIANT, FIELD_KEY_ROW_VARIANT, FIELD_KEY_SHOW_DETAILS, IGNORED_FIELD_KEYS };\n","import { extend } from '../../../vue';\nimport { SLOT_NAME_TABLE_COLGROUP } from '../../../constants/slots';\n\n// --- Props ---\n\nconst props = {};\n\n// --- Mixin ---\n\n// @vue/component\nconst colgroupMixin = extend({\n  methods: {\n    renderColgroup() {\n      const {\n        computedFields: fields\n      } = this;\n      const h = this.$createElement;\n      let $colgroup = h();\n      if (this.hasNormalizedSlot(SLOT_NAME_TABLE_COLGROUP)) {\n        $colgroup = h('colgroup', {\n          key: 'colgroup'\n        }, [this.normalizeSlot(SLOT_NAME_TABLE_COLGROUP, {\n          columns: fields.length,\n          fields\n        })]);\n      }\n      return $colgroup;\n    }\n  }\n});\n\nexport { colgroupMixin, props };\n","import { extend } from '../../vue';\nimport { NAME_THEAD } from '../../constants/components';\nimport { PROP_TYPE_STRING } from '../../constants/props';\nimport { makePropsConfigurable, makeProp } from '../../utils/props';\nimport { attrsMixin } from '../../mixins/attrs';\nimport { listenersMixin } from '../../mixins/listeners';\nimport { normalizeSlotMixin } from '../../mixins/normalize-slot';\n\n// --- Props ---\n\nconst props = makePropsConfigurable({\n  // Also sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n  // Supported values: 'lite', 'dark', or `null`\n  headVariant: makeProp(PROP_TYPE_STRING)\n}, NAME_THEAD);\n\n// --- Main component ---\n\n// TODO:\n//   In Bootstrap v5, we won't need \"sniffing\" as table element variants properly inherit\n//   to the child elements, so this can be converted to a functional component\n// @vue/component\nconst BThead = /*#__PURE__*/extend({\n  name: NAME_THEAD,\n  mixins: [attrsMixin, listenersMixin, normalizeSlotMixin],\n  provide() {\n    return {\n      getBvTableRowGroup: () => this\n    };\n  },\n  inject: {\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    getBvTable: {\n      default: /* istanbul ignore next */() => () => ({})\n    }\n  },\n  inheritAttrs: false,\n  props,\n  computed: {\n    bvTable() {\n      return this.getBvTable();\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    isThead() {\n      return true;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    isDark() {\n      return this.bvTable.dark;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    isStacked() {\n      return this.bvTable.isStacked;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    isResponsive() {\n      return this.bvTable.isResponsive;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    // Needed to handle header background classes, due to lack of\n    // background color inheritance with Bootstrap v4 table CSS\n    // Sticky headers only apply to cells in table `thead`\n    isStickyHeader() {\n      return !this.isStacked && this.bvTable.stickyHeader;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    // Needed to handle header background classes, due to lack of\n    // background color inheritance with Bootstrap v4 table CSS\n    hasStickyHeader() {\n      return !this.isStacked && this.bvTable.stickyHeader;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    tableVariant() {\n      return this.bvTable.tableVariant;\n    },\n    theadClasses() {\n      return [this.headVariant ? `thead-${this.headVariant}` : null];\n    },\n    theadAttrs() {\n      return {\n        role: 'rowgroup',\n        ...this.bvAttrs\n      };\n    }\n  },\n  render(h) {\n    return h('thead', {\n      class: this.theadClasses,\n      attrs: this.theadAttrs,\n      // Pass down any native listeners\n      on: this.bvListeners\n    }, this.normalizeSlot());\n  }\n});\n\nexport { BThead, props };\n","import { extend } from '../../../vue';\nimport { EVENT_NAME_HEAD_CLICKED } from '../../../constants/events';\nimport { CODE_ENTER, CODE_SPACE } from '../../../constants/key-codes';\nimport { PROP_TYPE_STRING, PROP_TYPE_ARRAY_OBJECT_STRING } from '../../../constants/props';\nimport { SLOT_NAME_THEAD_TOP } from '../../../constants/slots';\nimport { stopEvent } from '../../../utils/events';\nimport { htmlOrText } from '../../../utils/html';\nimport { identity } from '../../../utils/identity';\nimport { isUndefinedOrNull } from '../../../utils/inspect';\nimport { noop } from '../../../utils/noop';\nimport { makeProp } from '../../../utils/props';\nimport { safeVueInstance } from '../../../utils/safe-vue-instance';\nimport { startCase } from '../../../utils/string';\nimport { BThead } from '../thead';\nimport { BTfoot } from '../tfoot';\nimport { BTr } from '../tr';\nimport { BTh } from '../th';\nimport { filterEvent } from './filter-event';\nimport { textSelectionActive } from './text-selection-active';\n\n// --- Helper methods ---\n\nconst getHeadSlotName = value => `head(${value || ''})`;\nconst getFootSlotName = value => `foot(${value || ''})`;\n\n// --- Props ---\n\nconst props = {\n  // Any Bootstrap theme variant (or custom)\n  headRowVariant: makeProp(PROP_TYPE_STRING),\n  // 'light', 'dark' or `null` (or custom)\n  headVariant: makeProp(PROP_TYPE_STRING),\n  theadClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING),\n  theadTrClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING)\n};\n\n// --- Mixin ---\n\n// @vue/component\nconst theadMixin = extend({\n  props,\n  methods: {\n    fieldClasses(field) {\n      // Header field (<th>) classes\n      return [field.class ? field.class : '', field.thClass ? field.thClass : ''];\n    },\n    headClicked(event, field, isFoot) {\n      if (this.stopIfBusy && this.stopIfBusy(event)) {\n        // If table is busy (via provider) then don't propagate\n        return;\n      } else if (filterEvent(event)) {\n        // Clicked on a non-disabled control so ignore\n        return;\n      } else if (textSelectionActive(this.$el)) {\n        // User is selecting text, so ignore\n        /* istanbul ignore next: JSDOM doesn't support getSelection() */\n        return;\n      }\n      stopEvent(event);\n      this.$emit(EVENT_NAME_HEAD_CLICKED, field.key, field, event, isFoot);\n    },\n    renderThead() {\n      let isFoot = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n      const {\n        computedFields: fields,\n        isSortable,\n        isSelectable,\n        headVariant,\n        footVariant,\n        headRowVariant,\n        footRowVariant\n      } = safeVueInstance(this);\n      const h = this.$createElement;\n\n      // In always stacked mode, we don't bother rendering the head/foot\n      // Or if no field headings (empty table)\n      if (this.isStackedAlways || fields.length === 0) {\n        return h();\n      }\n      const hasHeadClickListener = isSortable || this.hasListener(EVENT_NAME_HEAD_CLICKED);\n\n      // Reference to `selectAllRows` and `clearSelected()`, if table is selectable\n      const selectAllRows = isSelectable ? this.selectAllRows : noop;\n      const clearSelected = isSelectable ? this.clearSelected : noop;\n\n      // Helper function to generate a field <th> cell\n      const makeCell = (field, colIndex) => {\n        const {\n          label,\n          labelHtml,\n          variant,\n          stickyColumn,\n          key\n        } = field;\n        let ariaLabel = null;\n        if (!field.label.trim() && !field.headerTitle) {\n          // In case field's label and title are empty/blank\n          // We need to add a hint about what the column is about for non-sighted users\n          /* istanbul ignore next */\n          ariaLabel = startCase(field.key);\n        }\n        const on = {};\n        if (hasHeadClickListener) {\n          on.click = event => {\n            this.headClicked(event, field, isFoot);\n          };\n          on.keydown = event => {\n            const keyCode = event.keyCode;\n            if (keyCode === CODE_ENTER || keyCode === CODE_SPACE) {\n              this.headClicked(event, field, isFoot);\n            }\n          };\n        }\n        const sortAttrs = isSortable ? this.sortTheadThAttrs(key, field, isFoot) : {};\n        const sortClass = isSortable ? this.sortTheadThClasses(key, field, isFoot) : null;\n        const sortLabel = isSortable ? this.sortTheadThLabel(key, field, isFoot) : null;\n        const data = {\n          class: [{\n            // We need to make the header cell relative when we have\n            // a `.gl-sr-only` sort label to work around overflow issues\n            'gl-relative': sortLabel\n          }, this.fieldClasses(field), sortClass],\n          props: {\n            variant,\n            stickyColumn\n          },\n          style: field.thStyle || {},\n          attrs: {\n            // We only add a `tabindex` of `0` if there is a head-clicked listener\n            // and the current field is sortable\n            tabindex: hasHeadClickListener && field.sortable ? '0' : null,\n            abbr: field.headerAbbr || null,\n            title: field.headerTitle || null,\n            'aria-colindex': colIndex + 1,\n            'aria-label': ariaLabel,\n            ...this.getThValues(null, key, field.thAttr, isFoot ? 'foot' : 'head', {}),\n            ...sortAttrs\n          },\n          on,\n          key\n        };\n\n        // Handle edge case where in-document templates are used with new\n        // `v-slot:name` syntax where the browser lower-cases the v-slot's\n        // name (attributes become lower cased when parsed by the browser)\n        // We have replaced the square bracket syntax with round brackets\n        // to prevent confusion with dynamic slot names\n        let slotNames = [getHeadSlotName(key), getHeadSlotName(key.toLowerCase()), getHeadSlotName()];\n        // Footer will fallback to header slot names\n        if (isFoot) {\n          slotNames = [getFootSlotName(key), getFootSlotName(key.toLowerCase()), getFootSlotName(), ...slotNames];\n        }\n        const scope = {\n          label,\n          column: key,\n          field,\n          isFoot,\n          // Add in row select methods\n          selectAllRows,\n          clearSelected\n        };\n        const $content = this.normalizeSlot(slotNames, scope) || h('div', {\n          domProps: htmlOrText(labelHtml, label)\n        });\n        const $srLabel = sortLabel ? h('span', {\n          staticClass: 'gl-sr-only'\n        }, ` (${sortLabel})`) : null;\n\n        // Return the header cell\n        return h(BTh, data, [$content, $srLabel].filter(identity));\n      };\n\n      // Generate the array of <th> cells\n      const $cells = fields.map(makeCell).filter(identity);\n\n      // Generate the row(s)\n      const $trs = [];\n      if (isFoot) {\n        $trs.push(h(BTr, {\n          class: this.tfootTrClass,\n          props: {\n            variant: isUndefinedOrNull(footRowVariant) ? headRowVariant : /* istanbul ignore next */footRowVariant\n          }\n        }, $cells));\n      } else {\n        const scope = {\n          columns: fields.length,\n          fields,\n          // Add in row select methods\n          selectAllRows,\n          clearSelected\n        };\n        $trs.push(this.normalizeSlot(SLOT_NAME_THEAD_TOP, scope) || h());\n        $trs.push(h(BTr, {\n          class: this.theadTrClass,\n          props: {\n            variant: headRowVariant\n          }\n        }, $cells));\n      }\n      return h(isFoot ? BTfoot : BThead, {\n        class: (isFoot ? this.tfootClass : this.theadClass) || null,\n        props: isFoot ? {\n          footVariant: footVariant || headVariant || null\n        } : {\n          headVariant: headVariant || null\n        },\n        key: isFoot ? 'bv-tfoot' : 'bv-thead'\n      }, $trs);\n    }\n  }\n});\n\nexport { props, theadMixin };\n","import { extend } from '../../vue';\nimport { NAME_TABLE_CELL } from '../../constants/components';\nimport { PROP_TYPE_NUMBER_STRING, PROP_TYPE_STRING, PROP_TYPE_BOOLEAN } from '../../constants/props';\nimport { isTag } from '../../utils/dom';\nimport { isUndefinedOrNull } from '../../utils/inspect';\nimport { toInteger } from '../../utils/number';\nimport { makePropsConfigurable, makeProp } from '../../utils/props';\nimport { toString } from '../../utils/string';\nimport { attrsMixin } from '../../mixins/attrs';\nimport { listenersMixin } from '../../mixins/listeners';\nimport { normalizeSlotMixin } from '../../mixins/normalize-slot';\n\n// --- Helper methods ---\n\n// Parse a rowspan or colspan into a digit (or `null` if < `1` )\nconst parseSpan = value => {\n  value = toInteger(value, 0);\n  return value > 0 ? value : null;\n};\n\n/* istanbul ignore next */\nconst spanValidator = value => isUndefinedOrNull(value) || parseSpan(value) > 0;\n\n// --- Props ---\n\nconst props = makePropsConfigurable({\n  colspan: makeProp(PROP_TYPE_NUMBER_STRING, null, spanValidator),\n  rowspan: makeProp(PROP_TYPE_NUMBER_STRING, null, spanValidator),\n  stackedHeading: makeProp(PROP_TYPE_STRING),\n  stickyColumn: makeProp(PROP_TYPE_BOOLEAN, false),\n  variant: makeProp(PROP_TYPE_STRING)\n}, NAME_TABLE_CELL);\n\n// --- Main component ---\n\n// TODO:\n//   In Bootstrap v5, we won't need \"sniffing\" as table element variants properly inherit\n//   to the child elements, so this can be converted to a functional component\n// @vue/component\nconst BTd = /*#__PURE__*/extend({\n  name: NAME_TABLE_CELL,\n  // Mixin order is important!\n  mixins: [attrsMixin, listenersMixin, normalizeSlotMixin],\n  inject: {\n    getBvTableTr: {\n      default: /* istanbul ignore next */() => () => ({})\n    }\n  },\n  inheritAttrs: false,\n  props,\n  computed: {\n    bvTableTr() {\n      return this.getBvTableTr();\n    },\n    // Overridden by `<b-th>`\n    tag() {\n      return 'td';\n    },\n    inTbody() {\n      return this.bvTableTr.inTbody;\n    },\n    inThead() {\n      return this.bvTableTr.inThead;\n    },\n    inTfoot() {\n      return this.bvTableTr.inTfoot;\n    },\n    isDark() {\n      return this.bvTableTr.isDark;\n    },\n    isStacked() {\n      return this.bvTableTr.isStacked;\n    },\n    // We only support stacked-heading in tbody in stacked mode\n    isStackedCell() {\n      return this.inTbody && this.isStacked;\n    },\n    isResponsive() {\n      return this.bvTableTr.isResponsive;\n    },\n    // Needed to handle header background classes, due to lack of\n    // background color inheritance with Bootstrap v4 table CSS\n    // Sticky headers only apply to cells in table `thead`\n    isStickyHeader() {\n      return this.bvTableTr.isStickyHeader;\n    },\n    // Needed to handle header background classes, due to lack of\n    // background color inheritance with Bootstrap v4 table CSS\n    hasStickyHeader() {\n      return this.bvTableTr.hasStickyHeader;\n    },\n    // Needed to handle background classes, due to lack of\n    // background color inheritance with Bootstrap v4 table CSS\n    // Sticky column cells are only available in responsive\n    // mode (horizontal scrolling) or when sticky header mode\n    // Applies to cells in `thead`, `tbody` and `tfoot`\n    isStickyColumn() {\n      return !this.isStacked && (this.isResponsive || this.hasStickyHeader) && this.stickyColumn;\n    },\n    rowVariant() {\n      return this.bvTableTr.variant;\n    },\n    headVariant() {\n      return this.bvTableTr.headVariant;\n    },\n    footVariant() {\n      return this.bvTableTr.footVariant;\n    },\n    tableVariant() {\n      return this.bvTableTr.tableVariant;\n    },\n    computedColspan() {\n      return parseSpan(this.colspan);\n    },\n    computedRowspan() {\n      return parseSpan(this.rowspan);\n    },\n    // We use computed props here for improved performance by caching\n    // the results of the string interpolation\n    cellClasses() {\n      let {\n        variant,\n        headVariant,\n        isStickyColumn\n      } = this;\n      if (!variant && this.isStickyHeader && !headVariant || !variant && isStickyColumn && this.inTfoot && !this.footVariant || !variant && isStickyColumn && this.inThead && !headVariant || !variant && isStickyColumn && this.inTbody) {\n        // Needed for sticky-header mode as Bootstrap v4 table cells do\n        // not inherit parent's `background-color`\n        variant = this.rowVariant || this.tableVariant || 'b-table-default';\n      }\n      return [variant ? `${this.isDark ? 'bg' : 'table'}-${variant}` : null, isStickyColumn ? 'b-table-sticky-column' : null];\n    },\n    cellAttrs() {\n      const {\n        stackedHeading\n      } = this;\n\n      // We use computed props here for improved performance by caching\n      // the results of the object spread (Object.assign)\n      const headOrFoot = this.inThead || this.inTfoot;\n      // Make sure col/rowspan's are > 0 or null\n      const colspan = this.computedColspan;\n      const rowspan = this.computedRowspan;\n      // Default role and scope\n      let role = 'cell';\n      let scope = null;\n\n      // Compute role and scope\n      // We only add scopes with an explicit span of 1 or greater\n      if (headOrFoot) {\n        // Header or footer cells\n        role = 'columnheader';\n        scope = colspan > 0 ? 'colspan' : 'col';\n      } else if (isTag(this.tag, 'th')) {\n        // th's in tbody\n        role = 'rowheader';\n        scope = rowspan > 0 ? 'rowgroup' : 'row';\n      }\n      return {\n        colspan,\n        rowspan,\n        role,\n        scope,\n        // Allow users to override role/scope plus add other attributes\n        ...this.bvAttrs,\n        // Add in the stacked cell label data-attribute if in\n        // stacked mode (if a stacked heading label is provided)\n        'data-label': this.isStackedCell && !isUndefinedOrNull(stackedHeading) ? /* istanbul ignore next */toString(stackedHeading) : null\n      };\n    }\n  },\n  render(h) {\n    const $content = [this.normalizeSlot()];\n    return h(this.tag, {\n      class: this.cellClasses,\n      attrs: this.cellAttrs,\n      // Transfer any native listeners\n      on: this.bvListeners\n    }, [this.isStackedCell ? h('div', [$content]) : $content]);\n  }\n});\n\nexport { BTd, props };\n","import { extend } from '../../vue';\nimport { NAME_TH } from '../../constants/components';\nimport { makePropsConfigurable } from '../../utils/props';\nimport { props as props$1, BTd } from './td';\n\n// --- Props ---\n\nconst props = makePropsConfigurable(props$1, NAME_TH);\n\n// --- Main component ---\n\n// TODO:\n//   In Bootstrap v5, we won't need \"sniffing\" as table element variants properly inherit\n//   to the child elements, so this can be converted to a functional component\n// @vue/component\nconst BTh = /*#__PURE__*/extend({\n  name: NAME_TH,\n  extends: BTd,\n  props,\n  computed: {\n    tag() {\n      return 'th';\n    }\n  }\n});\n\nexport { BTh, props };\n","import { extend } from '../../vue';\nimport { NAME_TBODY } from '../../constants/components';\nimport { PROP_TYPE_OBJECT } from '../../constants/props';\nimport { makePropsConfigurable, makeProp } from '../../utils/props';\nimport { attrsMixin } from '../../mixins/attrs';\nimport { listenersMixin } from '../../mixins/listeners';\nimport { normalizeSlotMixin } from '../../mixins/normalize-slot';\n\n// --- Props ---\n\nconst props = makePropsConfigurable({\n  tbodyTransitionHandlers: makeProp(PROP_TYPE_OBJECT),\n  tbodyTransitionProps: makeProp(PROP_TYPE_OBJECT)\n}, NAME_TBODY);\n\n// --- Main component ---\n\n// TODO:\n//   In Bootstrap v5, we won't need \"sniffing\" as table element variants properly inherit\n//   to the child elements, so this can be converted to a functional component\n// @vue/component\nconst BTbody = /*#__PURE__*/extend({\n  name: NAME_TBODY,\n  mixins: [attrsMixin, listenersMixin, normalizeSlotMixin],\n  provide() {\n    return {\n      getBvTableRowGroup: () => this\n    };\n  },\n  inject: {\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    getBvTable: {\n      default: /* istanbul ignore next */() => () => ({})\n    }\n  },\n  inheritAttrs: false,\n  props,\n  computed: {\n    bvTable() {\n      return this.getBvTable();\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    isTbody() {\n      return true;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    isDark() {\n      return this.bvTable.dark;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    isStacked() {\n      return this.bvTable.isStacked;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    isResponsive() {\n      return this.bvTable.isResponsive;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    // Sticky headers are only supported in thead\n    isStickyHeader() {\n      return false;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    // Needed to handle header background classes, due to lack of\n    // background color inheritance with Bootstrap v4 table CSS\n    hasStickyHeader() {\n      return !this.isStacked && this.bvTable.stickyHeader;\n    },\n    // Sniffed by `<b-tr>` / `<b-td>` / `<b-th>`\n    tableVariant() {\n      return this.bvTable.tableVariant;\n    },\n    isTransitionGroup() {\n      return this.tbodyTransitionProps || this.tbodyTransitionHandlers;\n    },\n    tbodyAttrs() {\n      return {\n        role: 'rowgroup',\n        ...this.bvAttrs\n      };\n    },\n    tbodyProps() {\n      const {\n        tbodyTransitionProps\n      } = this;\n      return tbodyTransitionProps ? {\n        ...tbodyTransitionProps,\n        tag: 'tbody'\n      } : {};\n    }\n  },\n  render(h) {\n    const data = {\n      props: this.tbodyProps,\n      attrs: this.tbodyAttrs\n    };\n    if (this.isTransitionGroup) {\n      // We use native listeners if a transition group for any delegated events\n      data.on = this.tbodyTransitionHandlers || {};\n      data.nativeOn = this.bvListeners;\n    } else {\n      // Otherwise we place any listeners on the tbody element\n      data.on = this.bvListeners;\n    }\n    return h(this.isTransitionGroup ? 'transition-group' : 'tbody', data, this.normalizeSlot());\n  }\n});\n\nexport { BTbody, props };\n","import { extend, REF_FOR_KEY } from '../../../vue';\nimport { EVENT_NAME_ROW_HOVERED, EVENT_NAME_ROW_UNHOVERED, EVENT_NAME_ROW_CLICKED } from '../../../constants/events';\nimport { PROP_TYPE_ARRAY_OBJECT_STRING, PROP_TYPE_OBJECT_FUNCTION, PROP_TYPE_FUNCTION } from '../../../constants/props';\nimport { SLOT_NAME_ROW_DETAILS } from '../../../constants/slots';\nimport { useParentMixin } from '../../../mixins/use-parent';\nimport { get } from '../../../utils/get';\nimport { isFunction, isString, isUndefinedOrNull } from '../../../utils/inspect';\nimport { makeProp } from '../../../utils/props';\nimport { safeVueInstance } from '../../../utils/safe-vue-instance';\nimport { toString } from '../../../utils/string';\nimport { BTr } from '../tr';\nimport { BTd } from '../td';\nimport { BTh } from '../th';\nimport { FIELD_KEY_SHOW_DETAILS, FIELD_KEY_CELL_VARIANT, FIELD_KEY_ROW_VARIANT } from './constants';\n\n// --- Props ---\n\nconst props = {\n  detailsTdClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING),\n  tbodyTrAttr: makeProp(PROP_TYPE_OBJECT_FUNCTION),\n  tbodyTrClass: makeProp([...PROP_TYPE_ARRAY_OBJECT_STRING, PROP_TYPE_FUNCTION])\n};\n\n// --- Mixin ---\n\n// @vue/component\nconst tbodyRowMixin = extend({\n  mixins: [useParentMixin],\n  props,\n  methods: {\n    // Methods for computing classes, attributes and styles for table cells\n    getTdValues(item, key, tdValue, defaultValue) {\n      const {\n        bvParent\n      } = this;\n      if (tdValue) {\n        const value = get(item, key, '');\n        if (isFunction(tdValue)) {\n          return tdValue(value, key, item);\n        } else if (isString(tdValue) && isFunction(bvParent[tdValue])) {\n          return bvParent[tdValue](value, key, item);\n        }\n        return tdValue;\n      }\n      return defaultValue;\n    },\n    getThValues(item, key, thValue, type, defaultValue) {\n      const {\n        bvParent\n      } = this;\n      if (thValue) {\n        const value = get(item, key, '');\n        if (isFunction(thValue)) {\n          return thValue(value, key, item, type);\n        } else if (isString(thValue) && isFunction(bvParent[thValue])) {\n          return bvParent[thValue](value, key, item, type);\n        }\n        return thValue;\n      }\n      return defaultValue;\n    },\n    // Method to get the value for a field\n    getFormattedValue(item, field) {\n      const {\n        key\n      } = field;\n      const formatter = this.getFieldFormatter(key);\n      let value = get(item, key, null);\n      if (isFunction(formatter)) {\n        value = formatter(value, key, item);\n      }\n      return isUndefinedOrNull(value) ? '' : value;\n    },\n    // Factory function methods\n    toggleDetailsFactory(hasDetailsSlot, item) {\n      // Returns a function to toggle a row's details slot\n      return () => {\n        if (hasDetailsSlot) {\n          this.$set(item, FIELD_KEY_SHOW_DETAILS, !item[FIELD_KEY_SHOW_DETAILS]);\n        }\n      };\n    },\n    // Row event handlers\n    rowHovered(event) {\n      // `mouseenter` handler (non-bubbling)\n      // `this.tbodyRowEventStopped` from tbody mixin\n      if (!this.tbodyRowEventStopped(event)) {\n        // `this.emitTbodyRowEvent` from tbody mixin\n        this.emitTbodyRowEvent(EVENT_NAME_ROW_HOVERED, event);\n      }\n    },\n    rowUnhovered(event) {\n      // `mouseleave` handler (non-bubbling)\n      // `this.tbodyRowEventStopped` from tbody mixin\n      if (!this.tbodyRowEventStopped(event)) {\n        // `this.emitTbodyRowEvent` from tbody mixin\n        this.emitTbodyRowEvent(EVENT_NAME_ROW_UNHOVERED, event);\n      }\n    },\n    // Renders a TD or TH for a row's field\n    renderTbodyRowCell(field, colIndex, item, rowIndex) {\n      const {\n        isStacked\n      } = this;\n      const {\n        key,\n        label,\n        isRowHeader\n      } = field;\n      const h = this.$createElement;\n      const hasDetailsSlot = this.hasNormalizedSlot(SLOT_NAME_ROW_DETAILS);\n      const formatted = this.getFormattedValue(item, field);\n      const stickyColumn = !isStacked && (this.isResponsive || this.stickyHeader) && field.stickyColumn;\n      // We only uses the helper components for sticky columns to\n      // improve performance of BTable/BTableLite by reducing the\n      // total number of vue instances created during render\n      const cellTag = stickyColumn ? isRowHeader ? BTh : BTd : isRowHeader ? 'th' : 'td';\n      const cellVariant = item[FIELD_KEY_CELL_VARIANT] && item[FIELD_KEY_CELL_VARIANT][key] ? item[FIELD_KEY_CELL_VARIANT][key] : field.variant || null;\n      const data = {\n        // For the Vue key, we concatenate the column index and\n        // field key (as field keys could be duplicated)\n        // TODO: Although we do prevent duplicate field keys...\n        //   So we could change this to: `row-${rowIndex}-cell-${key}`\n        class: [field.class ? field.class : '', this.getTdValues(item, key, field.tdClass, '')],\n        props: {},\n        attrs: {\n          'aria-colindex': String(colIndex + 1),\n          ...(isRowHeader ? this.getThValues(item, key, field.thAttr, 'row', {}) : this.getTdValues(item, key, field.tdAttr, {}))\n        },\n        key: `row-${rowIndex}-cell-${colIndex}-${key}`\n      };\n      if (stickyColumn) {\n        // We are using the helper BTd or BTh\n        data.props = {\n          stackedHeading: isStacked ? label : null,\n          stickyColumn: true,\n          variant: cellVariant\n        };\n      } else {\n        // Using native TD or TH element, so we need to\n        // add in the attributes and variant class\n        data.attrs['data-label'] = isStacked && !isUndefinedOrNull(label) ? toString(label) : null;\n        data.attrs.role = isRowHeader ? 'rowheader' : 'cell';\n        data.attrs.scope = isRowHeader ? 'row' : null;\n        // Add in the variant class\n        if (cellVariant) {\n          data.class.push(`${this.dark ? 'bg' : 'table'}-${cellVariant}`);\n        }\n      }\n      const slotScope = {\n        item,\n        index: rowIndex,\n        field,\n        unformatted: get(item, key, ''),\n        value: formatted,\n        toggleDetails: this.toggleDetailsFactory(hasDetailsSlot, item),\n        detailsShowing: Boolean(item[FIELD_KEY_SHOW_DETAILS])\n      };\n      // If table supports selectable mode, then add in the following scope\n      // this.supportsSelectableRows will be undefined if mixin isn't loaded\n      if (safeVueInstance(this).supportsSelectableRows) {\n        slotScope.rowSelected = this.isRowSelected(rowIndex);\n        slotScope.selectRow = () => this.selectRow(rowIndex);\n        slotScope.unselectRow = () => this.unselectRow(rowIndex);\n      }\n\n      // The new `v-slot` syntax doesn't like a slot name starting with\n      // a square bracket and if using in-document HTML templates, the\n      // v-slot attributes are lower-cased by the browser.\n      // Switched to round bracket syntax to prevent confusion with\n      // dynamic slot name syntax.\n      // We look for slots in this order: `cell(${key})`, `cell(${key.toLowerCase()})`, 'cell()'\n      // Slot names are now cached by mixin tbody in `this.$_bodyFieldSlotNameCache`\n      // Will be `null` if no slot (or fallback slot) exists\n      const slotName = this.$_bodyFieldSlotNameCache[key];\n      let $childNodes = slotName ? this.normalizeSlot(slotName, slotScope) : toString(formatted);\n      if (this.isStacked) {\n        // We wrap in a DIV to ensure rendered as a single cell when visually stacked!\n        $childNodes = [h('div', [$childNodes])];\n      }\n\n      // Render either a td or th cell\n      return h(cellTag, data, [$childNodes]);\n    },\n    // Renders an item's row (or rows if details supported)\n    renderTbodyRow(item, rowIndex) {\n      const {\n        computedFields: fields,\n        striped,\n        primaryKey,\n        currentPage,\n        perPage,\n        tbodyTrClass,\n        tbodyTrAttr,\n        hasSelectableRowClick\n      } = safeVueInstance(this);\n      const h = this.$createElement;\n      const hasDetailsSlot = this.hasNormalizedSlot(SLOT_NAME_ROW_DETAILS);\n      const rowShowDetails = item[FIELD_KEY_SHOW_DETAILS] && hasDetailsSlot;\n      const hasRowClickHandler = this.$listeners[EVENT_NAME_ROW_CLICKED] || hasSelectableRowClick;\n\n      // We can return more than one TR if rowDetails enabled\n      const $rows = [];\n\n      // Details ID needed for `aria-details` when details showing\n      // We set it to `null` when not showing so that attribute\n      // does not appear on the element\n      const detailsId = rowShowDetails ? this.safeId(`_details_${rowIndex}_`) : null;\n\n      // For each item data field in row\n      const $tds = fields.map((field, colIndex) => {\n        return this.renderTbodyRowCell(field, colIndex, item, rowIndex);\n      });\n\n      // Calculate the row number in the dataset (indexed from 1)\n      let ariaRowIndex = null;\n      if (currentPage && perPage && perPage > 0) {\n        ariaRowIndex = String((currentPage - 1) * perPage + rowIndex + 1);\n      }\n\n      // Create a unique :key to help ensure that sub components are re-rendered rather than\n      // re-used, which can cause issues. If a primary key is not provided we use the rendered\n      // rows index within the tbody.\n      // See: https://github.com/bootstrap-vue/bootstrap-vue/issues/2410\n      const primaryKeyValue = toString(get(item, primaryKey)) || null;\n      const rowKey = primaryKeyValue || toString(rowIndex);\n\n      // If primary key is provided, use it to generate a unique ID on each tbody > tr\n      // In the format of '{tableId}__row_{primaryKeyValue}'\n      const rowId = primaryKeyValue ? this.safeId(`_row_${primaryKeyValue}`) : null;\n\n      // Selectable classes and attributes\n      const selectableClasses = safeVueInstance(this).selectableRowClasses ? this.selectableRowClasses(rowIndex) : {};\n      const selectableAttrs = safeVueInstance(this).selectableRowAttrs ? this.selectableRowAttrs(rowIndex) : {};\n\n      // Additional classes and attributes\n      const userTrClasses = isFunction(tbodyTrClass) ? tbodyTrClass(item, 'row') : tbodyTrClass;\n      const userTrAttrs = isFunction(tbodyTrAttr) ? /* istanbul ignore next */tbodyTrAttr(item, 'row') : tbodyTrAttr;\n\n      // Add the item row\n      $rows.push(h(BTr, {\n        class: [userTrClasses, selectableClasses, rowShowDetails ? 'b-table-has-details' : ''],\n        props: {\n          variant: item[FIELD_KEY_ROW_VARIANT] || null\n        },\n        attrs: {\n          id: rowId,\n          ...userTrAttrs,\n          // Users cannot override the following attributes\n          tabindex: hasRowClickHandler ? '0' : null,\n          'data-pk': primaryKeyValue || null,\n          'aria-details': detailsId,\n          'aria-owns': detailsId,\n          'aria-rowindex': ariaRowIndex,\n          ...selectableAttrs\n        },\n        on: {\n          // Note: These events are not A11Y friendly!\n          mouseenter: this.rowHovered,\n          mouseleave: this.rowUnhovered\n        },\n        key: `__b-table-row-${rowKey}__`,\n        ref: 'item-rows',\n        [REF_FOR_KEY]: true\n      }, $tds));\n\n      // Row Details slot\n      if (rowShowDetails) {\n        const detailsScope = {\n          item,\n          index: rowIndex,\n          fields,\n          toggleDetails: this.toggleDetailsFactory(hasDetailsSlot, item)\n        };\n        // If table supports selectable mode, then add in the following scope\n        // this.supportsSelectableRows will be undefined if mixin isn't loaded\n        if (safeVueInstance(this).supportsSelectableRows) {\n          detailsScope.rowSelected = this.isRowSelected(rowIndex);\n          detailsScope.selectRow = () => this.selectRow(rowIndex);\n          detailsScope.unselectRow = () => this.unselectRow(rowIndex);\n        }\n\n        // Render the details slot in a TD\n        const $details = h(BTd, {\n          props: {\n            colspan: fields.length\n          },\n          class: this.detailsTdClass\n        }, [this.normalizeSlot(SLOT_NAME_ROW_DETAILS, detailsScope)]);\n\n        // Add a hidden row to keep table row striping consistent when details showing\n        // Only added if the table is striped\n        if (striped) {\n          $rows.push(\n          // We don't use `BTr` here as we don't need the extra functionality\n          h('tr', {\n            staticClass: 'd-none',\n            attrs: {\n              'aria-hidden': 'true',\n              role: 'presentation'\n            },\n            key: `__b-table-details-stripe__${rowKey}`\n          }));\n        }\n\n        // Add the actual details row\n        const userDetailsTrClasses = isFunction(this.tbodyTrClass) ? /* istanbul ignore next */this.tbodyTrClass(item, SLOT_NAME_ROW_DETAILS) : this.tbodyTrClass;\n        const userDetailsTrAttrs = isFunction(this.tbodyTrAttr) ? /* istanbul ignore next */this.tbodyTrAttr(item, SLOT_NAME_ROW_DETAILS) : this.tbodyTrAttr;\n        $rows.push(h(BTr, {\n          staticClass: 'b-table-details',\n          class: [userDetailsTrClasses],\n          props: {\n            variant: item[FIELD_KEY_ROW_VARIANT] || null\n          },\n          attrs: {\n            ...userDetailsTrAttrs,\n            // Users cannot override the following attributes\n            id: detailsId,\n            tabindex: '-1'\n          },\n          key: `__b-table-details__${rowKey}`\n        }, [$details]));\n      } else if (hasDetailsSlot) {\n        // Only add the placeholder if a the table has a row-details slot defined (but not shown)\n        $rows.push(h());\n        if (striped) {\n          // Add extra placeholder if table is striped\n          $rows.push(h());\n        }\n      }\n\n      // Return the row(s)\n      return $rows;\n    }\n  }\n});\n\nexport { props, tbodyRowMixin };\n","import { extend } from '../../../vue';\nimport { EVENT_NAME_ROW_CLICKED, EVENT_NAME_ROW_MIDDLE_CLICKED, EVENT_NAME_ROW_CONTEXTMENU, EVENT_NAME_ROW_DBLCLICKED } from '../../../constants/events';\nimport { CODE_ENTER, CODE_SPACE, CODE_UP, CODE_DOWN, CODE_HOME, CODE_END } from '../../../constants/key-codes';\nimport { PROP_TYPE_ARRAY_OBJECT_STRING } from '../../../constants/props';\nimport { from, arrayIncludes } from '../../../utils/array';\nimport { isElement, closest, isActiveElement, attemptFocus } from '../../../utils/dom';\nimport { safeVueInstance } from '../../../utils/safe-vue-instance';\nimport { stopEvent } from '../../../utils/events';\nimport { sortKeys } from '../../../utils/object';\nimport { makeProp, pluckProps } from '../../../utils/props';\nimport { props as props$1, BTbody } from '../tbody';\nimport { filterEvent } from './filter-event';\nimport { textSelectionActive } from './text-selection-active';\nimport { props as props$2, tbodyRowMixin } from './mixin-tbody-row';\n\n// --- Helper methods ---\n\nconst getCellSlotName = value => `cell(${value || ''})`;\n\n// --- Props ---\n\nconst props = sortKeys({\n  ...props$1,\n  ...props$2,\n  tbodyClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING)\n});\n\n// --- Mixin ---\n\n// @vue/component\nconst tbodyMixin = extend({\n  mixins: [tbodyRowMixin],\n  props,\n  beforeDestroy() {\n    this.$_bodyFieldSlotNameCache = null;\n  },\n  methods: {\n    // Returns all the item TR elements (excludes detail and spacer rows)\n    // `this.$refs['item-rows']` is an array of item TR components/elements\n    // Rows should all be `<b-tr>` components, but we map to TR elements\n    // Also note that `this.$refs['item-rows']` may not always be in document order\n    getTbodyTrs() {\n      const {\n        $refs\n      } = this;\n      const tbody = $refs.tbody ? $refs.tbody.$el || $refs.tbody : null;\n      const trs = ($refs['item-rows'] || []).map(tr => tr.$el || tr);\n      return tbody && tbody.children && tbody.children.length > 0 && trs && trs.length > 0 ? from(tbody.children).filter(tr => arrayIncludes(trs, tr)) : /* istanbul ignore next */[];\n    },\n    // Returns index of a particular TBODY item TR\n    // We set `true` on closest to include self in result\n    getTbodyTrIndex(el) {\n      /* istanbul ignore next: should not normally happen */\n      if (!isElement(el)) {\n        return -1;\n      }\n      const tr = el.tagName === 'TR' ? el : closest('tr', el, true);\n      return tr ? this.getTbodyTrs().indexOf(tr) : -1;\n    },\n    // Emits a row event, with the item object, row index and original event\n    emitTbodyRowEvent(type, event) {\n      if (type && this.hasListener(type) && event && event.target) {\n        const rowIndex = this.getTbodyTrIndex(event.target);\n        if (rowIndex > -1) {\n          // The array of TRs correlate to the `computedItems` array\n          const item = this.computedItems[rowIndex];\n          this.$emit(type, item, rowIndex, event);\n        }\n      }\n    },\n    tbodyRowEventStopped(event) {\n      return this.stopIfBusy && this.stopIfBusy(event);\n    },\n    // Delegated row event handlers\n    onTbodyRowKeydown(event) {\n      // Keyboard navigation and row click emulation\n      const {\n        target,\n        keyCode\n      } = event;\n      if (this.tbodyRowEventStopped(event) || target.tagName !== 'TR' || !isActiveElement(target) || target.tabIndex !== 0) {\n        // Early exit if not an item row TR\n        return;\n      }\n      if (arrayIncludes([CODE_ENTER, CODE_SPACE], keyCode)) {\n        // Emulated click for keyboard users, transfer to click handler\n        stopEvent(event);\n        this.onTBodyRowClicked(event);\n      } else if (arrayIncludes([CODE_UP, CODE_DOWN, CODE_HOME, CODE_END], keyCode)) {\n        // Keyboard navigation\n        const rowIndex = this.getTbodyTrIndex(target);\n        if (rowIndex > -1) {\n          stopEvent(event);\n          const trs = this.getTbodyTrs();\n          const shift = event.shiftKey;\n          if (keyCode === CODE_HOME || shift && keyCode === CODE_UP) {\n            // Focus first row\n            attemptFocus(trs[0]);\n          } else if (keyCode === CODE_END || shift && keyCode === CODE_DOWN) {\n            // Focus last row\n            attemptFocus(trs[trs.length - 1]);\n          } else if (keyCode === CODE_UP && rowIndex > 0) {\n            // Focus previous row\n            attemptFocus(trs[rowIndex - 1]);\n          } else if (keyCode === CODE_DOWN && rowIndex < trs.length - 1) {\n            // Focus next row\n            attemptFocus(trs[rowIndex + 1]);\n          }\n        }\n      }\n    },\n    onTBodyRowClicked(event) {\n      const {\n        $refs\n      } = this;\n      const tbody = $refs.tbody ? $refs.tbody.$el || $refs.tbody : null;\n      // Don't emit event when the table is busy, the user clicked\n      // on a non-disabled control or is selecting text\n      if (this.tbodyRowEventStopped(event) || filterEvent(event) || textSelectionActive(tbody || this.$el)) {\n        return;\n      }\n      this.emitTbodyRowEvent(EVENT_NAME_ROW_CLICKED, event);\n    },\n    onTbodyRowMiddleMouseRowClicked(event) {\n      if (!this.tbodyRowEventStopped(event) && event.which === 2) {\n        this.emitTbodyRowEvent(EVENT_NAME_ROW_MIDDLE_CLICKED, event);\n      }\n    },\n    onTbodyRowContextmenu(event) {\n      if (!this.tbodyRowEventStopped(event)) {\n        this.emitTbodyRowEvent(EVENT_NAME_ROW_CONTEXTMENU, event);\n      }\n    },\n    onTbodyRowDblClicked(event) {\n      if (!this.tbodyRowEventStopped(event) && !filterEvent(event)) {\n        this.emitTbodyRowEvent(EVENT_NAME_ROW_DBLCLICKED, event);\n      }\n    },\n    // Render the tbody element and children\n    // Note:\n    //   Row hover handlers are handled by the tbody-row mixin\n    //   As mouseenter/mouseleave events do not bubble\n    renderTbody() {\n      const {\n        computedItems: items,\n        renderBusy,\n        renderTopRow,\n        renderEmpty,\n        renderBottomRow,\n        hasSelectableRowClick\n      } = safeVueInstance(this);\n      const h = this.$createElement;\n      const hasRowClickHandler = this.hasListener(EVENT_NAME_ROW_CLICKED) || hasSelectableRowClick;\n\n      // Prepare the tbody rows\n      const $rows = [];\n\n      // Add the item data rows or the busy slot\n      const $busy = renderBusy ? renderBusy() : null;\n      if ($busy) {\n        // If table is busy and a busy slot, then return only the busy \"row\" indicator\n        $rows.push($busy);\n      } else {\n        // Table isn't busy, or we don't have a busy slot\n\n        // Create a slot cache for improved performance when looking up cell slot names\n        // Values will be keyed by the field's `key` and will store the slot's name\n        // Slots could be dynamic (i.e. `v-if`), so we must compute on each render\n        // Used by tbody-row mixin render helper\n        const cache = {};\n        let defaultSlotName = getCellSlotName();\n        defaultSlotName = this.hasNormalizedSlot(defaultSlotName) ? defaultSlotName : null;\n        this.computedFields.forEach(field => {\n          const {\n            key\n          } = field;\n          const slotName = getCellSlotName(key);\n          const lowercaseSlotName = getCellSlotName(key.toLowerCase());\n          cache[key] = this.hasNormalizedSlot(slotName) ? slotName : this.hasNormalizedSlot(lowercaseSlotName) ? /* istanbul ignore next */lowercaseSlotName : defaultSlotName;\n        });\n        // Created as a non-reactive property so to not trigger component updates\n        // Must be a fresh object each render\n        this.$_bodyFieldSlotNameCache = cache;\n\n        // Add static top row slot (hidden in visibly stacked mode\n        // as we can't control `data-label` attr)\n        $rows.push(renderTopRow ? renderTopRow() : h());\n\n        // Render the rows\n        items.forEach((item, rowIndex) => {\n          // Render the individual item row (rows if details slot)\n          $rows.push(this.renderTbodyRow(item, rowIndex));\n        });\n\n        // Empty items / empty filtered row slot (only shows if `items.length < 1`)\n        $rows.push(renderEmpty ? renderEmpty() : h());\n\n        // Static bottom row slot (hidden in visibly stacked mode\n        // as we can't control `data-label` attr)\n        $rows.push(renderBottomRow ? renderBottomRow() : h());\n      }\n\n      // Note: these events will only emit if a listener is registered\n      const handlers = {\n        auxclick: this.onTbodyRowMiddleMouseRowClicked,\n        // TODO:\n        //   Perhaps we do want to automatically prevent the\n        //   default context menu from showing if there is a\n        //   `row-contextmenu` listener registered\n        contextmenu: this.onTbodyRowContextmenu,\n        // The following event(s) is not considered A11Y friendly\n        dblclick: this.onTbodyRowDblClicked\n        // Hover events (`mouseenter`/`mouseleave`) are handled by `tbody-row` mixin\n      };\n      // Add in click/keydown listeners if needed\n      if (hasRowClickHandler) {\n        handlers.click = this.onTBodyRowClicked;\n        handlers.keydown = this.onTbodyRowKeydown;\n      }\n\n      // Assemble rows into the tbody\n      const $tbody = h(BTbody, {\n        class: this.tbodyClass || null,\n        props: pluckProps(props$1, this.$props),\n        // BTbody transfers all native event listeners to the root element\n        // TODO: Only set the handlers if the table is not busy\n        on: handlers,\n        ref: 'tbody'\n      }, $rows);\n\n      // Return the assembled tbody\n      return $tbody;\n    }\n  }\n});\n\nexport { props, tbodyMixin };\n","import { extend, isVue3 } from '../vue';\nimport { isUndefined, isArray } from '../utils/inspect';\n\n// Mixin to determine if an event listener has been registered\n\n// @vue/component\nconst hasListenerMixin = extend({\n  methods: {\n    hasListener(name) {\n      if (isVue3) {\n        return true;\n      }\n      // Only includes listeners registered via `v-on:name`\n      const $listeners = this.$listeners || {};\n      // Includes `v-on:name` and `this.$on('name')` registered listeners\n      // Note this property is not part of the public Vue API, but it is\n      // the only way to determine if a listener was added via `vm.$on`\n      const $events = this._events || {};\n      // Registered listeners in `this._events` are always an array,\n      // but might be zero length\n      return !isUndefined($listeners[name]) || isArray($events[name]) && $events[name].length > 0;\n    }\n  }\n});\n\nexport { hasListenerMixin };\n","import { extend } from '../../vue';\nimport { NAME_TR } from '../../constants/components';\nimport { PROP_TYPE_STRING } from '../../constants/props';\nimport { makePropsConfigurable, makeProp } from '../../utils/props';\nimport { attrsMixin } from '../../mixins/attrs';\nimport { listenersMixin } from '../../mixins/listeners';\nimport { normalizeSlotMixin } from '../../mixins/normalize-slot';\n\n// --- Constants ---\n\nconst LIGHT = 'light';\nconst DARK = 'dark';\n\n// --- Props ---\n\nconst props = makePropsConfigurable({\n  variant: makeProp(PROP_TYPE_STRING)\n}, NAME_TR);\n\n// --- Main component ---\n\n// TODO:\n//   In Bootstrap v5, we won't need \"sniffing\" as table element variants properly inherit\n//   to the child elements, so this can be converted to a functional component\n// @vue/component\nconst BTr = /*#__PURE__*/extend({\n  name: NAME_TR,\n  mixins: [attrsMixin, listenersMixin, normalizeSlotMixin],\n  provide() {\n    return {\n      getBvTableTr: () => this\n    };\n  },\n  inject: {\n    getBvTableRowGroup: {\n      default: /* istanbul ignore next */() => () => ({})\n    }\n  },\n  inheritAttrs: false,\n  props,\n  computed: {\n    bvTableRowGroup() {\n      return this.getBvTableRowGroup();\n    },\n    // Sniffed by `<b-td>` / `<b-th>`\n    inTbody() {\n      return this.bvTableRowGroup.isTbody;\n    },\n    // Sniffed by `<b-td>` / `<b-th>`\n    inThead() {\n      return this.bvTableRowGroup.isThead;\n    },\n    // Sniffed by `<b-td>` / `<b-th>`\n    inTfoot() {\n      return this.bvTableRowGroup.isTfoot;\n    },\n    // Sniffed by `<b-td>` / `<b-th>`\n    isDark() {\n      return this.bvTableRowGroup.isDark;\n    },\n    // Sniffed by `<b-td>` / `<b-th>`\n    isStacked() {\n      return this.bvTableRowGroup.isStacked;\n    },\n    // Sniffed by `<b-td>` / `<b-th>`\n    isResponsive() {\n      return this.bvTableRowGroup.isResponsive;\n    },\n    // Sniffed by `<b-td>` / `<b-th>`\n    // Sticky headers are only supported in thead\n    isStickyHeader() {\n      return this.bvTableRowGroup.isStickyHeader;\n    },\n    // Sniffed by <b-tr> / `<b-td>` / `<b-th>`\n    // Needed to handle header background classes, due to lack of\n    // background color inheritance with Bootstrap v4 table CSS\n    hasStickyHeader() {\n      return !this.isStacked && this.bvTableRowGroup.hasStickyHeader;\n    },\n    // Sniffed by `<b-td>` / `<b-th>`\n    tableVariant() {\n      return this.bvTableRowGroup.tableVariant;\n    },\n    // Sniffed by `<b-td>` / `<b-th>`\n    headVariant() {\n      return this.inThead ? this.bvTableRowGroup.headVariant : null;\n    },\n    // Sniffed by `<b-td>` / `<b-th>`\n    footVariant() {\n      return this.inTfoot ? this.bvTableRowGroup.footVariant : null;\n    },\n    isRowDark() {\n      return this.headVariant === LIGHT || this.footVariant === LIGHT ? /* istanbul ignore next */false : this.headVariant === DARK || this.footVariant === DARK ? /* istanbul ignore next */true : this.isDark;\n    },\n    trClasses() {\n      const {\n        variant\n      } = this;\n      return [variant ? `${this.isRowDark ? 'bg' : 'table'}-${variant}` : null];\n    },\n    trAttrs() {\n      return {\n        role: 'row',\n        ...this.bvAttrs\n      };\n    }\n  },\n  render(h) {\n    return h('tr', {\n      class: this.trClasses,\n      attrs: this.trAttrs,\n      // Pass native listeners to child\n      on: this.bvListeners\n    }, this.normalizeSlot());\n  }\n});\n\nexport { BTr, props };\n","import { extend } from '../../../vue';\nimport { PROP_TYPE_STRING } from '../../../constants/props';\nimport { SLOT_NAME_TABLE_CAPTION } from '../../../constants/slots';\nimport { htmlOrText } from '../../../utils/html';\nimport { makeProp } from '../../../utils/props';\n\n// --- Props ---\n\nconst props = {\n  caption: makeProp(PROP_TYPE_STRING),\n  captionHtml: makeProp(PROP_TYPE_STRING)\n  // `caption-top` is part of table-render mixin (styling)\n  // captionTop: makeProp(PROP_TYPE_BOOLEAN, false)\n};\n\n// --- Mixin ---\n\n// @vue/component\nconst captionMixin = extend({\n  props,\n  computed: {\n    captionId() {\n      return this.isStacked ? this.safeId('_caption_') : null;\n    }\n  },\n  methods: {\n    renderCaption() {\n      const {\n        caption,\n        captionHtml\n      } = this;\n      const h = this.$createElement;\n      let $caption = h();\n      const hasCaptionSlot = this.hasNormalizedSlot(SLOT_NAME_TABLE_CAPTION);\n      if (hasCaptionSlot || caption || captionHtml) {\n        $caption = h('caption', {\n          attrs: {\n            id: this.captionId\n          },\n          domProps: hasCaptionSlot ? {} : htmlOrText(captionHtml, caption),\n          key: 'caption',\n          ref: 'caption'\n        }, this.normalizeSlot(SLOT_NAME_TABLE_CAPTION));\n      }\n      return $caption;\n    }\n  }\n});\n\nexport { captionMixin, props };\n","import { extend } from '../../../vue';\nimport { PROP_TYPE_BOOLEAN, PROP_TYPE_BOOLEAN_STRING, PROP_TYPE_ARRAY_OBJECT_STRING, PROP_TYPE_STRING } from '../../../constants/props';\nimport { identity } from '../../../utils/identity';\nimport { isBoolean } from '../../../utils/inspect';\nimport { makeProp } from '../../../utils/props';\nimport { safeVueInstance } from '../../../utils/safe-vue-instance';\nimport { toString } from '../../../utils/string';\nimport { attrsMixin } from '../../../mixins/attrs';\n\n// Main `<table>` render mixin\n// Includes all main table styling options\n\n// --- Props ---\n\nconst props = {\n  bordered: makeProp(PROP_TYPE_BOOLEAN, false),\n  borderless: makeProp(PROP_TYPE_BOOLEAN, false),\n  captionTop: makeProp(PROP_TYPE_BOOLEAN, false),\n  dark: makeProp(PROP_TYPE_BOOLEAN, false),\n  fixed: makeProp(PROP_TYPE_BOOLEAN, false),\n  hover: makeProp(PROP_TYPE_BOOLEAN, false),\n  noBorderCollapse: makeProp(PROP_TYPE_BOOLEAN, false),\n  outlined: makeProp(PROP_TYPE_BOOLEAN, false),\n  responsive: makeProp(PROP_TYPE_BOOLEAN_STRING, false),\n  small: makeProp(PROP_TYPE_BOOLEAN, false),\n  // If a string, it is assumed to be the table `max-height` value\n  stickyHeader: makeProp(PROP_TYPE_BOOLEAN_STRING, false),\n  striped: makeProp(PROP_TYPE_BOOLEAN, false),\n  tableClass: makeProp(PROP_TYPE_ARRAY_OBJECT_STRING),\n  tableVariant: makeProp(PROP_TYPE_STRING)\n};\n\n// --- Mixin ---\n\n// @vue/component\nconst tableRendererMixin = extend({\n  mixins: [attrsMixin],\n  provide() {\n    return {\n      getBvTable: () => this\n    };\n  },\n  // Don't place attributes on root element automatically,\n  // as table could be wrapped in responsive `<div>`\n  inheritAttrs: false,\n  props,\n  computed: {\n    isTableSimple() {\n      return false;\n    },\n    // Layout related computed props\n    isResponsive() {\n      const {\n        responsive\n      } = this;\n      return responsive === '' ? true : responsive;\n    },\n    isStickyHeader() {\n      let {\n        stickyHeader\n      } = this;\n      stickyHeader = stickyHeader === '' ? true : stickyHeader;\n      return this.isStacked ? false : stickyHeader;\n    },\n    wrapperClasses() {\n      const {\n        isResponsive\n      } = this;\n      return [this.isStickyHeader ? 'b-table-sticky-header' : '', isResponsive === true ? 'table-responsive' : isResponsive ? `table-responsive-${this.responsive}` : ''].filter(identity);\n    },\n    wrapperStyles() {\n      const {\n        isStickyHeader\n      } = this;\n      return isStickyHeader && !isBoolean(isStickyHeader) ? {\n        maxHeight: isStickyHeader\n      } : {};\n    },\n    tableClasses() {\n      let {\n        hover,\n        tableVariant,\n        selectableTableClasses,\n        stackedTableClasses,\n        tableClass,\n        computedBusy\n      } = safeVueInstance(this);\n      hover = this.isTableSimple ? hover : hover && this.computedItems.length > 0 && !computedBusy;\n      return [\n      // User supplied classes\n      tableClass,\n      // Styling classes\n      {\n        'table-striped': this.striped,\n        'table-hover': hover,\n        'table-dark': this.dark,\n        'table-bordered': this.bordered,\n        'table-borderless': this.borderless,\n        'table-sm': this.small,\n        // The following are b-table custom styles\n        'gl-border': this.outlined,\n        'b-table-fixed': this.fixed,\n        'b-table-caption-top': this.captionTop,\n        'b-table-no-border-collapse': this.noBorderCollapse\n      }, tableVariant ? `${this.dark ? 'bg' : 'table'}-${tableVariant}` : '',\n      // Stacked table classes\n      stackedTableClasses,\n      // Selectable classes\n      selectableTableClasses];\n    },\n    tableAttrs() {\n      const {\n        computedItems: items,\n        filteredItems,\n        computedFields: fields,\n        selectableTableAttrs,\n        computedBusy\n      } = safeVueInstance(this);\n      const ariaAttrs = this.isTableSimple ? {} : {\n        'aria-busy': toString(computedBusy),\n        'aria-colcount': toString(fields.length),\n        // Preserve user supplied `aria-describedby`, if provided\n        'aria-describedby': this.bvAttrs['aria-describedby'] || this.$refs.caption ? this.captionId : null\n      };\n      const rowCount = items && filteredItems && filteredItems.length > items.length ? toString(filteredItems.length) : null;\n      return {\n        // We set `aria-rowcount` before merging in `$attrs`,\n        // in case user has supplied their own\n        'aria-rowcount': rowCount,\n        // Merge in user supplied `$attrs` if any\n        ...this.bvAttrs,\n        // Now we can override any `$attrs` here\n        id: this.safeId(),\n        role: this.bvAttrs.role || 'table',\n        ...ariaAttrs,\n        ...selectableTableAttrs\n      };\n    }\n  },\n  render(h) {\n    const {\n      wrapperClasses,\n      renderCaption,\n      renderColgroup,\n      renderThead,\n      renderTbody,\n      renderTfoot\n    } = safeVueInstance(this);\n    const $content = [];\n    if (this.isTableSimple) {\n      $content.push(this.normalizeSlot());\n    } else {\n      // Build the `<caption>` (from caption mixin)\n      $content.push(renderCaption ? renderCaption() : null);\n\n      // Build the `<colgroup>`\n      $content.push(renderColgroup ? renderColgroup() : null);\n\n      // Build the `<thead>`\n      $content.push(renderThead ? renderThead() : null);\n\n      // Build the `<tbody>`\n      $content.push(renderTbody ? renderTbody() : null);\n\n      // Build the `<tfoot>`\n      $content.push(renderTfoot ? renderTfoot() : null);\n    }\n\n    // Assemble `<table>`\n    const $table = h('table', {\n      staticClass: 'table b-table',\n      class: this.tableClasses,\n      attrs: this.tableAttrs,\n      key: 'b-table'\n    }, $content.filter(identity));\n\n    // Add responsive/sticky wrapper if needed and return table\n    return wrapperClasses.length > 0 ? h('div', {\n      class: wrapperClasses,\n      style: this.wrapperStyles,\n      key: 'wrap'\n    }, [$table]) : $table;\n  }\n});\n\nexport { props, tableRendererMixin };\n"],"sourceRoot":""}