@gitlab/ui 84.2.0 → 85.0.1

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

@@ -0,0 +1,163 @@
+import { extend } from '../../vue';
+import { NAME_OVERLAY } from '../../constants/components';
+import { EVENT_NAME_CLICK, EVENT_NAME_SHOWN, EVENT_NAME_HIDDEN } from '../../constants/events';
+import { PROP_TYPE_STRING, PROP_TYPE_BOOLEAN, PROP_TYPE_NUMBER_STRING, PROP_TYPE_BOOLEAN_STRING } from '../../constants/props';
+import { SLOT_NAME_OVERLAY } from '../../constants/slots';
+import { toFloat } from '../../utils/number';
+import { normalizeSlotMixin } from '../../mixins/normalize-slot';
+import { makePropsConfigurable, makeProp } from '../../utils/props';
+import { BSpinner } from '../spinner/spinner';
+import { BVTransition } from '../transition/bv-transition';
+
+// --- Constants ---
+
+const POSITION_COVER = {
+  top: 0,
+  left: 0,
+  bottom: 0,
+  right: 0
+};
+
+// --- Props ---
+
+const props = makePropsConfigurable({
+  // Alternative to variant, allowing a specific
+  // CSS color to be applied to the overlay
+  bgColor: makeProp(PROP_TYPE_STRING),
+  blur: makeProp(PROP_TYPE_STRING, '2px'),
+  fixed: makeProp(PROP_TYPE_BOOLEAN, false),
+  noCenter: makeProp(PROP_TYPE_BOOLEAN, false),
+  noFade: makeProp(PROP_TYPE_BOOLEAN, false),
+  // If `true, does not render the default slot
+  // and switches to absolute positioning
+  noWrap: makeProp(PROP_TYPE_BOOLEAN, false),
+  opacity: makeProp(PROP_TYPE_NUMBER_STRING, 0.85, value => {
+    const number = toFloat(value, 0);
+    return number >= 0 && number <= 1;
+  }),
+  overlayTag: makeProp(PROP_TYPE_STRING, 'div'),
+  rounded: makeProp(PROP_TYPE_BOOLEAN_STRING, false),
+  show: makeProp(PROP_TYPE_BOOLEAN, false),
+  spinnerSmall: makeProp(PROP_TYPE_BOOLEAN, false),
+  spinnerType: makeProp(PROP_TYPE_STRING, 'border'),
+  spinnerVariant: makeProp(PROP_TYPE_STRING),
+  variant: makeProp(PROP_TYPE_STRING, 'light'),
+  wrapTag: makeProp(PROP_TYPE_STRING, 'div'),
+  zIndex: makeProp(PROP_TYPE_NUMBER_STRING, 10)
+}, NAME_OVERLAY);
+
+// --- Main component ---
+
+// @vue/component
+const BOverlay = /*#__PURE__*/extend({
+  name: NAME_OVERLAY,
+  mixins: [normalizeSlotMixin],
+  props,
+  computed: {
+    computedRounded() {
+      const {
+        rounded
+      } = this;
+      return rounded === true || rounded === '' ? 'rounded' : !rounded ? '' : `rounded-${rounded}`;
+    },
+    computedVariant() {
+      const {
+        variant
+      } = this;
+      return variant && !this.bgColor ? `bg-${variant}` : '';
+    },
+    slotScope() {
+      return {
+        spinnerType: this.spinnerType || null,
+        spinnerVariant: this.spinnerVariant || null,
+        spinnerSmall: this.spinnerSmall
+      };
+    }
+  },
+  methods: {
+    defaultOverlayFn(_ref) {
+      let {
+        spinnerType,
+        spinnerVariant,
+        spinnerSmall
+      } = _ref;
+      return this.$createElement(BSpinner, {
+        props: {
+          type: spinnerType,
+          variant: spinnerVariant,
+          small: spinnerSmall
+        }
+      });
+    }
+  },
+  render(h) {
+    const {
+      show,
+      fixed,
+      noFade,
+      noWrap,
+      slotScope
+    } = this;
+    let $overlay = h();
+    if (show) {
+      const $background = h('div', {
+        staticClass: 'position-absolute',
+        class: [this.computedVariant, this.computedRounded],
+        style: {
+          ...POSITION_COVER,
+          opacity: this.opacity,
+          backgroundColor: this.bgColor || null,
+          backdropFilter: this.blur ? `blur(${this.blur})` : null
+        }
+      });
+      const $content = h('div', {
+        staticClass: 'position-absolute',
+        style: this.noCenter ? /* istanbul ignore next */{
+          ...POSITION_COVER
+        } : {
+          top: '50%',
+          left: '50%',
+          transform: 'translateX(-50%) translateY(-50%)'
+        }
+      }, [this.normalizeSlot(SLOT_NAME_OVERLAY, slotScope) || this.defaultOverlayFn(slotScope)]);
+      $overlay = h(this.overlayTag, {
+        staticClass: 'b-overlay',
+        class: {
+          'position-absolute': !noWrap || noWrap && !fixed,
+          'position-fixed': noWrap && fixed
+        },
+        style: {
+          ...POSITION_COVER,
+          zIndex: this.zIndex || 10
+        },
+        on: {
+          click: event => this.$emit(EVENT_NAME_CLICK, event)
+        },
+        key: 'overlay'
+      }, [$background, $content]);
+    }
+
+    // Wrap in a fade transition
+    $overlay = h(BVTransition, {
+      props: {
+        noFade,
+        appear: true
+      },
+      on: {
+        'after-enter': () => this.$emit(EVENT_NAME_SHOWN),
+        'after-leave': () => this.$emit(EVENT_NAME_HIDDEN)
+      }
+    }, [$overlay]);
+    if (noWrap) {
+      return $overlay;
+    }
+    return h(this.wrapTag, {
+      staticClass: 'b-overlay-wrap position-relative',
+      attrs: {
+        'aria-busy': show ? 'true' : null
+      }
+    }, noWrap ? [$overlay] : [this.normalizeSlot(), $overlay]);
+  }
+});
+
+export { BOverlay, props };

package/dist/vendor/bootstrap-vue/src/components/pagination/index.js

@@ -0,0 +1,11 @@
+import { BPagination } from './pagination';
+export { BPagination } from './pagination';
+import { pluginFactory } from '../../utils/plugins';
+
+const PaginationPlugin = /*#__PURE__*/pluginFactory({
+  components: {
+    BPagination
+  }
+});
+
+export { PaginationPlugin };

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

@@ -0,0 +1,135 @@
+import { extend } from '../../vue';
+import { NAME_PAGINATION } from '../../constants/components';
+import { EVENT_NAME_PAGE_CLICK, EVENT_NAME_CHANGE } from '../../constants/events';
+import { PROP_TYPE_STRING, PROP_TYPE_NUMBER_STRING } from '../../constants/props';
+import { BvEvent } from '../../utils/bv-event.class';
+import { isVisible, attemptFocus } from '../../utils/dom';
+import { isUndefinedOrNull } from '../../utils/inspect';
+import { mathCeil, mathMax } from '../../utils/math';
+import { toInteger } from '../../utils/number';
+import { sortKeys } from '../../utils/object';
+import { makePropsConfigurable, makeProp } from '../../utils/props';
+import { props as props$1, paginationMixin, MODEL_PROP_NAME } from '../../mixins/pagination';
+
+// --- Constants ---
+
+const DEFAULT_PER_PAGE = 20;
+const DEFAULT_TOTAL_ROWS = 0;
+
+// --- Helper methods ---
+
+// Sanitize the provided per page number (converting to a number)
+const sanitizePerPage = value => mathMax(toInteger(value) || DEFAULT_PER_PAGE, 1);
+
+// Sanitize the provided total rows number (converting to a number)
+const sanitizeTotalRows = value => mathMax(toInteger(value) || DEFAULT_TOTAL_ROWS, 0);
+
+// --- Props ---
+
+const props = makePropsConfigurable(sortKeys({
+  ...props$1,
+  ariaControls: makeProp(PROP_TYPE_STRING),
+  perPage: makeProp(PROP_TYPE_NUMBER_STRING, DEFAULT_PER_PAGE),
+  totalRows: makeProp(PROP_TYPE_NUMBER_STRING, DEFAULT_TOTAL_ROWS)
+}), NAME_PAGINATION);
+
+// --- Main component ---
+
+// @vue/component
+const BPagination = /*#__PURE__*/extend({
+  name: NAME_PAGINATION,
+  // The render function is brought in via the `paginationMixin`
+  mixins: [paginationMixin],
+  props,
+  computed: {
+    numberOfPages() {
+      const result = mathCeil(sanitizeTotalRows(this.totalRows) / sanitizePerPage(this.perPage));
+      return result < 1 ? 1 : result;
+    },
+    // Used for watching changes to `perPage` and `numberOfPages`
+    pageSizeNumberOfPages() {
+      return {
+        perPage: sanitizePerPage(this.perPage),
+        totalRows: sanitizeTotalRows(this.totalRows),
+        numberOfPages: this.numberOfPages
+      };
+    }
+  },
+  watch: {
+    pageSizeNumberOfPages(newValue, oldValue) {
+      if (!isUndefinedOrNull(oldValue)) {
+        if (newValue.perPage !== oldValue.perPage && newValue.totalRows === oldValue.totalRows) {
+          // If the page size changes, reset to page 1
+          this.currentPage = 1;
+        } else if (newValue.numberOfPages !== oldValue.numberOfPages && this.currentPage > newValue.numberOfPages) {
+          // If `numberOfPages` changes and is less than
+          // the `currentPage` number, reset to page 1
+          this.currentPage = 1;
+        }
+      }
+      this.localNumberOfPages = newValue.numberOfPages;
+    }
+  },
+  created() {
+    // Set the initial page count
+    this.localNumberOfPages = this.numberOfPages;
+    // Set the initial page value
+    const currentPage = toInteger(this[MODEL_PROP_NAME], 0);
+    if (currentPage > 0) {
+      this.currentPage = currentPage;
+    } else {
+      this.$nextTick(() => {
+        // If this value parses to `NaN` or a value less than `1`
+        // trigger an initial emit of `null` if no page specified
+        this.currentPage = 0;
+      });
+    }
+  },
+  methods: {
+    // These methods are used by the render function
+    onClick(event, pageNumber) {
+      // Dont do anything if clicking the current active page
+      if (pageNumber === this.currentPage) {
+        return;
+      }
+      const {
+        target
+      } = event;
+
+      // Emit a user-cancelable `page-click` event
+      const clickEvent = new BvEvent(EVENT_NAME_PAGE_CLICK, {
+        cancelable: true,
+        vueTarget: this,
+        target
+      });
+      this.$emit(clickEvent.type, clickEvent, pageNumber);
+      if (clickEvent.defaultPrevented) {
+        return;
+      }
+
+      // Update the `v-model`
+      this.currentPage = pageNumber;
+      // Emit event triggered by user interaction
+      this.$emit(EVENT_NAME_CHANGE, this.currentPage);
+
+      // Keep the current button focused if possible
+      this.$nextTick(() => {
+        if (isVisible(target) && this.$el.contains(target)) {
+          attemptFocus(target);
+        } else {
+          this.focusCurrent();
+        }
+      });
+    },
+    makePage(pageNum) {
+      return pageNum;
+    },
+    /* istanbul ignore next */
+    linkProps() {
+      // No props, since we render a plain button
+      return {};
+    }
+  }
+});
+
+export { BPagination, props };

package/dist/vendor/bootstrap-vue/src/components/pagination-nav/index.js

@@ -0,0 +1,11 @@
+import { BPaginationNav } from './pagination-nav';
+export { BPaginationNav } from './pagination-nav';
+import { pluginFactory } from '../../utils/plugins';
+
+const PaginationNavPlugin = /*#__PURE__*/pluginFactory({
+  components: {
+    BPaginationNav
+  }
+});
+
+export { PaginationNavPlugin };

package/dist/vendor/bootstrap-vue/src/components/pagination-nav/pagination-nav.js

@@ -0,0 +1,299 @@
+import { extend } from '../../vue';
+import { NAME_PAGINATION_NAV } from '../../constants/components';
+import { IS_BROWSER } from '../../constants/env';
+import { EVENT_NAME_PAGE_CLICK, EVENT_NAME_CHANGE } from '../../constants/events';
+import { PROP_TYPE_STRING, PROP_TYPE_FUNCTION, PROP_TYPE_BOOLEAN, PROP_TYPE_NUMBER_STRING, PROP_TYPE_ARRAY } from '../../constants/props';
+import { BvEvent } from '../../utils/bv-event.class';
+import { requestAF, attemptBlur } from '../../utils/dom';
+import { isArray, isUndefined, isObject } from '../../utils/inspect';
+import { looseEqual } from '../../utils/loose-equal';
+import { mathMax } from '../../utils/math';
+import { toInteger } from '../../utils/number';
+import { omit, sortKeys } from '../../utils/object';
+import { makePropsConfigurable, makeProp, hasPropFunction, pluckProps } from '../../utils/props';
+import { computeHref, parseQuery } from '../../utils/router';
+import { toString } from '../../utils/string';
+import { warn } from '../../utils/warn';
+import { props as props$2, paginationMixin } from '../../mixins/pagination';
+import { props as props$1 } from '../link/link';
+
+// --- Helper methods ---
+
+// Sanitize the provided number of pages (converting to a number)
+const sanitizeNumberOfPages = value => mathMax(toInteger(value, 0), 1);
+
+// --- Props ---
+
+const linkProps = omit(props$1, ['event', 'routerTag']);
+const props = makePropsConfigurable(sortKeys({
+  ...props$2,
+  ...linkProps,
+  baseUrl: makeProp(PROP_TYPE_STRING, '/'),
+  linkGen: makeProp(PROP_TYPE_FUNCTION),
+  // Disable auto page number detection if `true`
+  noPageDetect: makeProp(PROP_TYPE_BOOLEAN, false),
+  numberOfPages: makeProp(PROP_TYPE_NUMBER_STRING, 1, /* istanbul ignore next */
+  value => {
+    const number = toInteger(value, 0);
+    if (number < 1) {
+      warn('Prop "number-of-pages" must be a number greater than "0"', NAME_PAGINATION_NAV);
+      return false;
+    }
+    return true;
+  }),
+  pageGen: makeProp(PROP_TYPE_FUNCTION),
+  // Optional array of page links
+  pages: makeProp(PROP_TYPE_ARRAY),
+  useRouter: makeProp(PROP_TYPE_BOOLEAN, false)
+}), NAME_PAGINATION_NAV);
+
+// --- Main component ---
+
+// @vue/component
+const BPaginationNav = /*#__PURE__*/extend({
+  name: NAME_PAGINATION_NAV,
+  // The render function is brought in via the pagination mixin
+  mixins: [paginationMixin],
+  props,
+  computed: {
+    // Used by render function to trigger wrapping in '<nav>' element
+    isNav() {
+      return true;
+    },
+    computedValue() {
+      // Returns the value prop as a number or `null` if undefined or < 1
+      const value = toInteger(this.value, 0);
+      return value < 1 ? null : value;
+    }
+  },
+  watch: {
+    numberOfPages() {
+      this.$nextTick(() => {
+        this.setNumberOfPages();
+      });
+    },
+    pages() {
+      this.$nextTick(() => {
+        this.setNumberOfPages();
+      });
+    }
+  },
+  created() {
+    this.setNumberOfPages();
+  },
+  mounted() {
+    if (this.$router) {
+      // We only add the watcher if vue router is detected
+      this.$watch('$route', () => {
+        this.$nextTick(() => {
+          requestAF(() => {
+            this.guessCurrentPage();
+          });
+        });
+      });
+    }
+  },
+  methods: {
+    setNumberOfPages() {
+      if (isArray(this.pages) && this.pages.length > 0) {
+        this.localNumberOfPages = this.pages.length;
+      } else {
+        this.localNumberOfPages = sanitizeNumberOfPages(this.numberOfPages);
+      }
+      this.$nextTick(() => {
+        this.guessCurrentPage();
+      });
+    },
+    onClick(event, pageNumber) {
+      // Dont do anything if clicking the current active page
+      if (pageNumber === this.currentPage) {
+        return;
+      }
+      const target = event.currentTarget || event.target;
+
+      // Emit a user-cancelable `page-click` event
+      const clickEvent = new BvEvent(EVENT_NAME_PAGE_CLICK, {
+        cancelable: true,
+        vueTarget: this,
+        target
+      });
+      this.$emit(clickEvent.type, clickEvent, pageNumber);
+      if (clickEvent.defaultPrevented) {
+        return;
+      }
+
+      // Update the `v-model`
+      // Done in in requestAF() to allow browser to complete the
+      // native browser click handling of a link
+      requestAF(() => {
+        this.currentPage = pageNumber;
+        this.$emit(EVENT_NAME_CHANGE, pageNumber);
+      });
+
+      // Emulate native link click page reloading behaviour by blurring the
+      // paginator and returning focus to the document
+      // Done in a `nextTick()` to ensure rendering complete
+      this.$nextTick(() => {
+        attemptBlur(target);
+      });
+    },
+    getPageInfo(pageNumber) {
+      if (!isArray(this.pages) || this.pages.length === 0 || isUndefined(this.pages[pageNumber - 1])) {
+        const link = `${this.baseUrl}${pageNumber}`;
+        return {
+          link: this.useRouter ? {
+            path: link
+          } : link,
+          text: toString(pageNumber)
+        };
+      }
+      const info = this.pages[pageNumber - 1];
+      if (isObject(info)) {
+        const link = info.link;
+        return {
+          // Normalize link for router use
+          link: isObject(link) ? link : this.useRouter ? {
+            path: link
+          } : link,
+          // Make sure text has a value
+          text: toString(info.text || pageNumber)
+        };
+      } else {
+        return {
+          link: toString(info),
+          text: toString(pageNumber)
+        };
+      }
+    },
+    makePage(pageNumber) {
+      const {
+        pageGen
+      } = this;
+      const info = this.getPageInfo(pageNumber);
+      if (hasPropFunction(pageGen)) {
+        return pageGen(pageNumber, info);
+      }
+      return info.text;
+    },
+    makeLink(pageNumber) {
+      const {
+        linkGen
+      } = this;
+      const info = this.getPageInfo(pageNumber);
+      if (hasPropFunction(linkGen)) {
+        return linkGen(pageNumber, info);
+      }
+      return info.link;
+    },
+    linkProps(pageNumber) {
+      const props = pluckProps(linkProps, this);
+      const link = this.makeLink(pageNumber);
+      if (this.useRouter || isObject(link)) {
+        props.to = link;
+      } else {
+        props.href = link;
+      }
+      return props;
+    },
+    resolveLink() {
+      let to = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      // Given a to (or href string), convert to normalized route-like structure
+      // Works only client side!
+      let link;
+      try {
+        // Convert the `to` to a HREF via a temporary `a` tag
+        link = document.createElement('a');
+        link.href = computeHref({
+          to
+        }, 'a', '/', '/');
+        // We need to add the anchor to the document to make sure the
+        // `pathname` is correctly detected in any browser (i.e. IE)
+        document.body.appendChild(link);
+        // Once href is assigned, the link will be normalized to the full URL bits
+        const {
+          pathname,
+          hash,
+          search
+        } = link;
+        // Remove link from document
+        document.body.removeChild(link);
+        // Return the location in a route-like object
+        return {
+          path: pathname,
+          hash,
+          query: parseQuery(search)
+        };
+      } catch (e) {
+        /* istanbul ignore next */
+        try {
+          link && link.parentNode && link.parentNode.removeChild(link);
+        } catch {}
+        /* istanbul ignore next */
+        return {};
+      }
+    },
+    resolveRoute() {
+      let to = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      // Given a to (or href string), convert to normalized route location structure
+      // Works only when router available!
+      try {
+        const route = this.$router.resolve(to, this.$route).route;
+        return {
+          path: route.path,
+          hash: route.hash,
+          query: route.query
+        };
+      } catch (e) {
+        /* istanbul ignore next */
+        return {};
+      }
+    },
+    guessCurrentPage() {
+      const {
+        $router,
+        $route
+      } = this;
+      let guess = this.computedValue;
+      // This section only occurs if we are client side, or server-side with `$router`
+      if (!this.noPageDetect && !guess && (IS_BROWSER || !IS_BROWSER && $router)) {
+        // Current route (if router available)
+        const currentRoute = $router && $route ? {
+          path: $route.path,
+          hash: $route.hash,
+          query: $route.query
+        } : {};
+        // Current page full HREF (if client side)
+        // Can't be done as a computed prop!
+        const loc = IS_BROWSER ? window.location || document.location : null;
+        const currentLink = loc ? {
+          path: loc.pathname,
+          hash: loc.hash,
+          query: parseQuery(loc.search)
+        } : /* istanbul ignore next */{};
+        // Loop through the possible pages looking for a match until found
+        for (let pageNumber = 1; !guess && pageNumber <= this.localNumberOfPages; pageNumber++) {
+          const to = this.makeLink(pageNumber);
+          if ($router && (isObject(to) || this.useRouter)) {
+            // Resolve the page via the `$router`
+            guess = looseEqual(this.resolveRoute(to), currentRoute) ? pageNumber : null;
+          } else if (IS_BROWSER) {
+            // If no `$router` available (or `!this.useRouter` when `to` is a string)
+            // we compare using parsed URIs
+            guess = looseEqual(this.resolveLink(to), currentLink) ? pageNumber : null;
+          } else {
+            // Probably SSR, but no `$router` so we can't guess,
+            // so lets break out of the loop early
+            /* istanbul ignore next */
+            guess = -1;
+          }
+        }
+      }
+      // We set `currentPage` to `0` to trigger an `$emit('input', null)`
+      // As the default for `currentPage` is `-1` when no value is specified
+      // Valid page numbers are greater than `0`
+      this.currentPage = guess > 0 ? guess : 0;
+    }
+  }
+});
+
+export { BPaginationNav, sanitizeNumberOfPages };

package/dist/vendor/bootstrap-vue/src/components/popover/helpers/bv-popover-template.js

@@ -0,0 +1,52 @@
+import { extend } from '../../../vue';
+import { NAME_POPOVER_TEMPLATE } from '../../../constants/components';
+import { isFunction, isUndefinedOrNull } from '../../../utils/inspect';
+import { BVTooltipTemplate } from '../../tooltip/helpers/bv-tooltip-template';
+
+// @vue/component
+const BVPopoverTemplate = /*#__PURE__*/extend({
+  name: NAME_POPOVER_TEMPLATE,
+  extends: BVTooltipTemplate,
+  computed: {
+    templateType() {
+      return 'popover';
+    }
+  },
+  methods: {
+    renderTemplate(h) {
+      const {
+        title,
+        content
+      } = this;
+
+      // Title and content could be a scoped slot function
+      const $title = isFunction(title) ? title({}) : title;
+      const $content = isFunction(content) ? content({}) : content;
+
+      // Directive usage only
+      const titleDomProps = this.html && !isFunction(title) ? {
+        innerHTML: title
+      } : {};
+      const contentDomProps = this.html && !isFunction(content) ? {
+        innerHTML: content
+      } : {};
+      return h('div', {
+        staticClass: 'popover b-popover',
+        class: this.templateClasses,
+        attrs: this.templateAttributes,
+        on: this.templateListeners
+      }, [h('div', {
+        staticClass: 'arrow',
+        ref: 'arrow'
+      }), isUndefinedOrNull($title) || $title === '' ? /* istanbul ignore next */h() : h('h3', {
+        staticClass: 'popover-header',
+        domProps: titleDomProps
+      }, [$title]), isUndefinedOrNull($content) || $content === '' ? /* istanbul ignore next */h() : h('div', {
+        staticClass: 'popover-body',
+        domProps: contentDomProps
+      }, [$content])]);
+    }
+  }
+});
+
+export { BVPopoverTemplate };

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

@@ -0,0 +1,26 @@
+import { extend } from '../../../vue';
+import { NAME_POPOVER_HELPER } from '../../../constants/components';
+import { BVTooltip } from '../../tooltip/helpers/bv-tooltip';
+import { BVPopoverTemplate } from './bv-popover-template';
+
+// Popover "Class" (Built as a renderless Vue instance)
+
+// @vue/component
+const BVPopover = /*#__PURE__*/extend({
+  name: NAME_POPOVER_HELPER,
+  extends: BVTooltip,
+  computed: {
+    // Overwrites BVTooltip
+    templateType() {
+      return 'popover';
+    }
+  },
+  methods: {
+    getTemplate() {
+      // Overwrites BVTooltip
+      return BVPopoverTemplate;
+    }
+  }
+});
+
+export { BVPopover };