{"version":3,"sources":["webpack:///./node_modules/bootstrap-vue/esm/utils/key-codes.js","webpack:///./node_modules/bootstrap-vue/esm/utils/pluck-props.js","webpack:///./node_modules/bootstrap-vue/esm/components/button/button.js","webpack:///./node_modules/bootstrap-vue/esm/utils/clone-deep.js","webpack:///./node_modules/bootstrap-vue/esm/utils/config-defaults.js","webpack:///./node_modules/bootstrap-vue/esm/utils/config.js","webpack:///./node_modules/bootstrap-vue/esm/utils/array.js","webpack:///./node_modules/bootstrap-vue/esm/utils/normalize-slot.js","webpack:///./node_modules/bootstrap-vue/esm/utils/identity.js","webpack:///./node_modules/bootstrap-vue/esm/utils/inspect.js","webpack:///./node_modules/bootstrap-vue/esm/mixins/normalize-slot.js","webpack:///./node_modules/bootstrap-vue/esm/utils/dom.js","webpack:///./node_modules/bootstrap-vue/esm/utils/env.js","webpack:///./node_modules/bootstrap-vue/esm/utils/safe-types.js","webpack:///./node_modules/bootstrap-vue/esm/utils/get.js","webpack:///./node_modules/bootstrap-vue/esm/utils/router.js","webpack:///./node_modules/bootstrap-vue/esm/components/link/link.js","webpack:///./node_modules/vue-functional-data-merge/dist/lib.esm.js","webpack:///./node_modules/bootstrap-vue/esm/utils/memoize.js","webpack:///./node_modules/bootstrap-vue/esm/utils/object.js","webpack:///./node_modules/bootstrap-vue/esm/utils/vue.js","webpack:///./node_modules/bootstrap-vue/esm/utils/string.js"],"names":["KEY_CODES","SPACE","ENTER","ESC","LEFT","UP","RIGHT","DOWN","PAGEUP","PAGEDOWN","HOME","END","TAB","SHIFT","CTRL","BACKSPACE","ALT","PAUSE","BREAK","INSERT","INS","DELETE","keysToPluck","objToPluck","transformFn","arguments","length","undefined","identity","slice","reduce","memo","prop","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","i","source","forEach","key","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","obj","value","configurable","writable","NAME","btnProps","block","type","Boolean","default","disabled","size","String","variant","tag","pill","squared","pressed","linkProps","href","to","linkPropKeys","name","toLowerCase","evt","isLink","props","isButton","isNonStandardTag","_ref","concat","computeAttrs","data","button","link","toggle","nonStandardTag","hashLink","role","attrs","tabindex","autocomplete","BButton","extend","functional","render","h","_ref2","listeners","children","on","keydown","keyCode","currentTarget","preventDefault","click","stopPropagation","fn","focusin","focusout","componentData","staticClass","class","_toConsumableArray","arr","_arrayWithoutHoles","_iterableToArray","_nonIterableSpread","TypeError","iter","Symbol","iterator","prototype","toString","call","Array","from","isArray","arr2","cloneDeep","defaultValue","result","val","breakpoints","formControls","BAlert","dismissLabel","BBadge","BButtonClose","content","textVariant","ariaLabel","BCardSubTitle","subTitleTextVariant","BCarousel","labelPrev","labelNext","labelGotoSlide","labelIndicators","BDropdown","toggleText","splitVariant","BFormFile","browseText","placeholder","dropPlaceholder","BFormTag","removeLabel","BFormTags","addButtonText","addButtonVariant","duplicateTagText","invalidTagText","tagRemoveLabel","tagVariant","BFormText","BImg","blankColor","BImgLazy","BInputGroup","BJumbotron","bgVariant","borderVariant","BListGroupItem","BModal","titleTag","headerBgVariant","headerBorderVariant","headerTextVariant","headerCloseVariant","bodyBgVariant","bodyTextVariant","footerBgVariant","footerBorderVariant","footerTextVariant","cancelTitle","cancelVariant","okTitle","okVariant","headerCloseContent","headerCloseLabel","BNavbar","BNavbarToggle","label","BPagination","BPaginationNav","BPopover","boundary","boundaryPadding","customClass","delay","BProgress","BProgressBar","BSpinner","BTable","selectedVariant","headVariant","footVariant","BToast","toaster","autoHideDelay","toastClass","headerClass","bodyClass","BToaster","ariaLive","ariaAtomic","BTooltip","PROP_NAME","VueProto","getConfigValue","get","getComponentConfig","cmpName","getBreakpoints","_getBreakpointsCached","memoize","getBreakpointsUpCached","arrayIncludes","array","indexOf","_len","args","_key","hasNormalizedSlot","names","$scopedSlots","$slots","some","normalizeSlot","slot","scope","x","_typeof","constructor","toType","isUndefined","isNull","isUndefinedOrNull","isFunction","isBoolean","isString","isDate","Date","isEvent","Event","methods","this","vNodes","w","window","d","document","elProto","Element","matchesEl","matches","msMatchesSelector","webkitMatchesSelector","closestEl","closest","sel","el","parentElement","parentNode","nodeType","Node","ELEMENT_NODE","requestAF","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","msRequestAnimationFrame","oRequestAnimationFrame","cb","setTimeout","isElement","MutationObserver","WebKitMutationObserver","MozMutationObserver","isVisible","contains","body","style","display","bcr","getBCR","height","width","reflow","offsetHeight","selectAll","selector","root","querySelectorAll","select","querySelector","includeRoot","parent","child","addClass","className","classList","add","removeClass","remove","hasClass","setAttr","attr","setAttribute","removeAttr","removeAttribute","getAttr","getAttribute","hasAttr","hasAttribute","getBoundingClientRect","getCS","getComputedStyle","hasWindowSupport","hasDocumentSupport","hasNavigatorSupport","navigator","hasPromiseSupport","Promise","hasMutationObserverSupport","isBrowser","userAgent","hasPassiveEventSupport","test","passiveEventSupported","options","addEventListener","removeEventListener","err","getEnv","documentElement","maxTouchPoints","PointerEvent","MSPointerEvent","IntersectionObserverEntry","fallback","env","process","getNoWarn","_classCallCheck","instance","Constructor","_possibleConstructorReturn","self","_assertThisInitialized","ReferenceError","_inherits","subClass","superClass","create","_setPrototypeOf","_wrapNativeSuper","Class","_cache","Map","_isNativeFunction","has","set","Wrapper","_construct","_getPrototypeOf","isNativeReflectConstruct","Reflect","construct","sham","Proxy","e","Parent","a","Function","bind","o","p","setPrototypeOf","__proto__","getPrototypeOf","_Object","HTMLElement","_Element","File","SVGElement","_Object2","RX_ARRAY_NOTATION","path","join","replace","steps","split","every","step","ANCHOR_TAG","commaRE","encodeReserveRE","encodeReserveReplacer","c","charCodeAt","str","encodeURIComponent","decodeURIComponent","query","map","results","val2","computeTag","thisOrParent","$router","$nuxt","rel","_ref3","toFallback","hash","charAt","propsFactory","active","append","event","activeClass","exact","exactActiveClass","routerTag","noPrefetch","BLink","mixins","inheritAttrs","computed","computedTag","isRouterLink","computedRel","computedHref","computedProps","$props","onClick","_arguments","evtIsEvent","suppliedHandler","$listeners","stopImmediatePropagation","__vue__","$emit","handler","$root","focus","$el","blur","$attrs","assign","t","r","s","hasOwnProperty","kebab","styleProp","styleList","toUpperCase","n","l","trim","y","f","cache","argsKey","JSON","stringify","proto","optionalProps","descr","freeze","isObject","isPlainObject","readonlyDescriptor","deepFreeze","upperFirst","spaces","lowerCase"],"mappings":"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","file":"js/chunk-f9ae706c.0cf14502.js","sourcesContent":["/*\n * Key Codes (events)\n */\nimport { freeze } from './object';\nvar KEY_CODES = freeze({\n  SPACE: 32,\n  ENTER: 13,\n  ESC: 27,\n  LEFT: 37,\n  UP: 38,\n  RIGHT: 39,\n  DOWN: 40,\n  PAGEUP: 33,\n  PAGEDOWN: 34,\n  HOME: 36,\n  END: 35,\n  TAB: 9,\n  SHIFT: 16,\n  CTRL: 17,\n  BACKSPACE: 8,\n  ALT: 18,\n  PAUSE: 19,\n  BREAK: 19,\n  INSERT: 45,\n  INS: 45,\n  DELETE: 46\n});\nexport default KEY_CODES;","import identity from './identity';\nimport { isArray } from './inspect';\nimport { keys } from './object';\n/**\n * Given an array of properties or an object of property keys,\n * plucks all the values off the target object, returning a new object\n * that has props that reference the original prop values\n *\n * @param {{}|string[]} keysToPluck\n * @param {{}} objToPluck\n * @param {Function} transformFn\n * @return {{}}\n */\n\nvar pluckProps = function pluckProps(keysToPluck, objToPluck) {\n  var transformFn = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : identity;\n  return (isArray(keysToPluck) ? keysToPluck.slice() : keys(keysToPluck)).reduce(function (memo, prop) {\n    memo[transformFn(prop)] = objToPluck[prop];\n    return memo;\n  }, {});\n};\n\nexport default pluckProps;","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport Vue from '../../utils/vue';\nimport { mergeData } from 'vue-functional-data-merge';\nimport KeyCodes from '../../utils/key-codes';\nimport pluckProps from '../../utils/pluck-props';\nimport { concat } from '../../utils/array';\nimport { getComponentConfig } from '../../utils/config';\nimport { addClass, removeClass } from '../../utils/dom';\nimport { isBoolean, isEvent, isFunction } from '../../utils/inspect';\nimport { keys } from '../../utils/object';\nimport { toString } from '../../utils/string';\nimport { BLink, propsFactory as linkPropsFactory } from '../link/link'; // --- Constants --\n\nvar NAME = 'BButton';\nvar btnProps = {\n  block: {\n    type: Boolean,\n    default: false\n  },\n  disabled: {\n    type: Boolean,\n    default: false\n  },\n  size: {\n    type: String,\n    default: function _default() {\n      return getComponentConfig(NAME, 'size');\n    }\n  },\n  variant: {\n    type: String,\n    default: function _default() {\n      return getComponentConfig(NAME, 'variant');\n    }\n  },\n  type: {\n    type: String,\n    default: 'button'\n  },\n  tag: {\n    type: String,\n    default: 'button'\n  },\n  pill: {\n    type: Boolean,\n    default: false\n  },\n  squared: {\n    type: Boolean,\n    default: false\n  },\n  pressed: {\n    // Tri-state: `true`, `false` or `null`\n    // => On, off, not a toggle\n    type: Boolean,\n    default: null\n  }\n};\nvar linkProps = linkPropsFactory();\ndelete linkProps.href.default;\ndelete linkProps.to.default;\nvar linkPropKeys = keys(linkProps);\nexport var props = _objectSpread({}, linkProps, {}, btnProps); // --- Helper methods ---\n// Returns `true` if a tag's name equals `name`\n\nvar tagIs = function tagIs(tag, name) {\n  return toString(tag).toLowerCase() === toString(name).toLowerCase();\n}; // Focus handler for toggle buttons\n// Needs class of 'focus' when focused\n\n\nvar handleFocus = function handleFocus(evt) {\n  if (evt.type === 'focusin') {\n    addClass(evt.target, 'focus');\n  } else if (evt.type === 'focusout') {\n    removeClass(evt.target, 'focus');\n  }\n}; // Is the requested button a link?\n// If tag prop is set to `a`, we use a <b-link> to get proper disabled handling\n\n\nvar isLink = function isLink(props) {\n  return props.href || props.to || tagIs(props.tag, 'a');\n}; // Is the button to be a toggle button?\n\n\nvar isToggle = function isToggle(props) {\n  return isBoolean(props.pressed);\n}; // Is the button \"really\" a button?\n\n\nvar isButton = function isButton(props) {\n  return !(isLink(props) || props.tag && !tagIs(props.tag, 'button'));\n}; // Is the requested tag not a button or link?\n\n\nvar isNonStandardTag = function isNonStandardTag(props) {\n  return !isLink(props) && !isButton(props);\n}; // Compute required classes (non static classes)\n\n\nvar computeClass = function computeClass(props) {\n  var _ref;\n\n  return [\"btn-\".concat(props.variant || getComponentConfig(NAME, 'variant')), (_ref = {}, _defineProperty(_ref, \"btn-\".concat(props.size), props.size), _defineProperty(_ref, 'btn-block', props.block), _defineProperty(_ref, 'rounded-pill', props.pill), _defineProperty(_ref, 'rounded-0', props.squared && !props.pill), _defineProperty(_ref, \"disabled\", props.disabled), _defineProperty(_ref, \"active\", props.pressed), _ref)];\n}; // Compute the link props to pass to b-link (if required)\n\n\nvar computeLinkProps = function computeLinkProps(props) {\n  return isLink(props) ? pluckProps(linkPropKeys, props) : null;\n}; // Compute the attributes for a button\n\n\nvar computeAttrs = function computeAttrs(props, data) {\n  var button = isButton(props);\n  var link = isLink(props);\n  var toggle = isToggle(props);\n  var nonStandardTag = isNonStandardTag(props);\n  var hashLink = link && props.href === '#';\n  var role = data.attrs && data.attrs.role ? data.attrs.role : null;\n  var tabindex = data.attrs ? data.attrs.tabindex : null;\n\n  if (nonStandardTag || hashLink) {\n    tabindex = '0';\n  }\n\n  return {\n    // Type only used for \"real\" buttons\n    type: button && !link ? props.type : null,\n    // Disabled only set on \"real\" buttons\n    disabled: button ? props.disabled : null,\n    // We add a role of button when the tag is not a link or button for ARIA\n    // Don't bork any role provided in `data.attrs` when `isLink` or `isButton`\n    // Except when link has `href` of `#`\n    role: nonStandardTag || hashLink ? 'button' : role,\n    // We set the `aria-disabled` state for non-standard tags\n    'aria-disabled': nonStandardTag ? String(props.disabled) : null,\n    // For toggles, we need to set the pressed state for ARIA\n    'aria-pressed': toggle ? String(props.pressed) : null,\n    // `autocomplete=\"off\"` is needed in toggle mode to prevent some browsers\n    // from remembering the previous setting when using the back button\n    autocomplete: toggle ? 'off' : null,\n    // `tabindex` is used when the component is not a button\n    // Links are tabbable, but don't allow disabled, while non buttons or links\n    // are not tabbable, so we mimic that functionality by disabling tabbing\n    // when disabled, and adding a `tabindex=\"0\"` to non buttons or non links\n    tabindex: props.disabled && !button ? '-1' : tabindex\n  };\n}; // @vue/component\n\n\nexport var BButton =\n/*#__PURE__*/\nVue.extend({\n  name: NAME,\n  functional: true,\n  props: props,\n  render: function render(h, _ref2) {\n    var props = _ref2.props,\n        data = _ref2.data,\n        listeners = _ref2.listeners,\n        children = _ref2.children;\n    var toggle = isToggle(props);\n    var link = isLink(props);\n    var nonStandardTag = isNonStandardTag(props);\n    var hashLink = link && props.href === '#';\n    var on = {\n      keydown: function keydown(evt) {\n        // When the link is a `href=\"#\"` or a non-standard tag (has `role=\"button\"`),\n        // we add a keydown handlers for SPACE/ENTER\n\n        /* istanbul ignore next */\n        if (props.disabled || !(nonStandardTag || hashLink)) {\n          return;\n        }\n\n        var keyCode = evt.keyCode; // Add SPACE handler for `href=\"#\"` and ENTER handler for non-standard tags\n\n        if (keyCode === KeyCodes.SPACE || keyCode === KeyCodes.ENTER && nonStandardTag) {\n          var target = evt.currentTarget || evt.target;\n          evt.preventDefault();\n          target.click();\n        }\n      },\n      click: function click(evt) {\n        /* istanbul ignore if: blink/button disabled should handle this */\n        if (props.disabled && isEvent(evt)) {\n          evt.stopPropagation();\n          evt.preventDefault();\n        } else if (toggle && listeners && listeners['update:pressed']) {\n          // Send `.sync` updates to any \"pressed\" prop (if `.sync` listeners)\n          // `concat()` will normalize the value to an array without\n          // double wrapping an array value in an array\n          concat(listeners['update:pressed']).forEach(function (fn) {\n            if (isFunction(fn)) {\n              fn(!props.pressed);\n            }\n          });\n        }\n      }\n    };\n\n    if (toggle) {\n      on.focusin = handleFocus;\n      on.focusout = handleFocus;\n    }\n\n    var componentData = {\n      staticClass: 'btn',\n      class: computeClass(props),\n      props: computeLinkProps(props),\n      attrs: computeAttrs(props, data),\n      on: on\n    };\n    return h(link ? BLink : props.tag, mergeData(data, componentData), children);\n  }\n});","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance\"); }\n\nfunction _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }\n\nimport { isArray, isPlainObject } from './inspect';\nimport { keys } from './object';\nexport var cloneDeep = function cloneDeep(obj) {\n  var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : obj;\n\n  if (isArray(obj)) {\n    return obj.reduce(function (result, val) {\n      return [].concat(_toConsumableArray(result), [cloneDeep(val, val)]);\n    }, []);\n  }\n\n  if (isPlainObject(obj)) {\n    return keys(obj).reduce(function (result, key) {\n      return _objectSpread({}, result, _defineProperty({}, key, cloneDeep(obj[key], obj[key])));\n    }, {});\n  }\n\n  return defaultValue;\n};\nexport default cloneDeep;","import { deepFreeze } from './object'; // --- General BootstrapVue configuration ---\n// NOTES\n//\n// The global config SHALL NOT be used to set defaults for Boolean props, as the props\n// would loose their semantic meaning, and force people writing 3rd party components to\n// explicity set a true or false value using the v-bind syntax on boolean props\n//\n// Supported config values (depending on the prop's supported type(s)):\n// `String`, `Array`, `Object`, `null` or `undefined`\n// BREAKPOINT DEFINITIONS\n//\n// Some components (`<b-col>` and `<b-form-group>`) generate props based on breakpoints,\n// and this occurs when the component is first loaded (evaluated), which may happen\n// before the config is created/modified\n//\n// To get around this we make these components' props async (lazy evaluation)\n// The component definition is only called/executed when the first access to the\n// component is used (and cached on subsequent uses)\n// PROP DEFAULTS\n//\n// For default values on props, we use the default value factory function approach so\n// that the default values are pulled in at each component instantiation\n//\n//  props: {\n//    variant: {\n//      type: String,\n//      default: () => getConfigComponent('BAlert', 'variant')\n//    }\n//  }\n//\n// We also provide a cached getter for breakpoints, which are \"frozen\" on first access\n// prettier-ignore\n\nexport default deepFreeze({\n  // Breakpoints\n  breakpoints: ['xs', 'sm', 'md', 'lg', 'xl'],\n  // Form controls\n  formControls: {\n    size: null\n  },\n  // Component specific defaults are keyed by the component\n  // name (PascalCase) and prop name (camelCase)\n  BAlert: {\n    dismissLabel: 'Close',\n    variant: 'info'\n  },\n  BBadge: {\n    variant: 'secondary'\n  },\n  BButton: {\n    size: null,\n    variant: 'secondary'\n  },\n  BButtonClose: {\n    content: '&times;',\n    // `textVariant` is `null` to inherit the current text color\n    textVariant: null,\n    ariaLabel: 'Close'\n  },\n  BCardSubTitle: {\n    // `<b-card>` and `<b-card-body>` also inherit this prop\n    subTitleTextVariant: 'muted'\n  },\n  BCarousel: {\n    labelPrev: 'Previous Slide',\n    labelNext: 'Next Slide',\n    labelGotoSlide: 'Goto Slide',\n    labelIndicators: 'Select a slide to display'\n  },\n  BDropdown: {\n    toggleText: 'Toggle Dropdown',\n    size: null,\n    variant: 'secondary',\n    splitVariant: null\n  },\n  BFormFile: {\n    browseText: 'Browse',\n    // Chrome default file prompt\n    placeholder: 'No file chosen',\n    dropPlaceholder: 'Drop files here'\n  },\n  BFormTag: {\n    removeLabel: 'Remove tag',\n    variant: 'secondary'\n  },\n  BFormTags: {\n    addButtonText: 'Add',\n    addButtonVariant: 'outline-secondary',\n    duplicateTagText: 'Duplicate tag(s)',\n    invalidTagText: 'Invalid tag(s)',\n    placeholder: 'Add tag...',\n    tagRemoveLabel: 'Remove tag',\n    tagVariant: 'secondary'\n  },\n  BFormText: {\n    textVariant: 'muted'\n  },\n  BImg: {\n    blankColor: 'transparent'\n  },\n  BImgLazy: {\n    blankColor: 'transparent'\n  },\n  BInputGroup: {\n    size: null\n  },\n  BJumbotron: {\n    bgVariant: null,\n    borderVariant: null,\n    textVariant: null\n  },\n  BListGroupItem: {\n    variant: null\n  },\n  BModal: {\n    titleTag: 'h5',\n    size: 'md',\n    headerBgVariant: null,\n    headerBorderVariant: null,\n    headerTextVariant: null,\n    headerCloseVariant: null,\n    bodyBgVariant: null,\n    bodyTextVariant: null,\n    footerBgVariant: null,\n    footerBorderVariant: null,\n    footerTextVariant: null,\n    cancelTitle: 'Cancel',\n    cancelVariant: 'secondary',\n    okTitle: 'OK',\n    okVariant: 'primary',\n    headerCloseContent: '&times;',\n    headerCloseLabel: 'Close'\n  },\n  BNavbar: {\n    variant: null\n  },\n  BNavbarToggle: {\n    label: 'Toggle navigation'\n  },\n  BPagination: {\n    size: null\n  },\n  BPaginationNav: {\n    size: null\n  },\n  BPopover: {\n    boundary: 'scrollParent',\n    boundaryPadding: 5,\n    customClass: null,\n    delay: 50,\n    variant: null\n  },\n  BProgress: {\n    variant: null\n  },\n  BProgressBar: {\n    variant: null\n  },\n  BSpinner: {\n    variant: null\n  },\n  BTable: {\n    selectedVariant: 'active',\n    headVariant: null,\n    footVariant: null\n  },\n  BToast: {\n    toaster: 'b-toaster-top-right',\n    autoHideDelay: 5000,\n    variant: null,\n    toastClass: null,\n    headerClass: null,\n    bodyClass: null\n  },\n  BToaster: {\n    ariaLive: null,\n    ariaAtomic: null,\n    role: null\n  },\n  BTooltip: {\n    boundary: 'scrollParent',\n    boundaryPadding: 5,\n    customClass: null,\n    delay: 50,\n    variant: null\n  }\n});","import Vue from './vue';\nimport cloneDeep from './clone-deep';\nimport get from './get';\nimport memoize from './memoize';\nimport DEFAULTS from './config-defaults'; // --- Constants ---\n\nvar PROP_NAME = '$bvConfig';\nvar VueProto = Vue.prototype; // --- Getter methods ---\n// All methods return a deep clone (immutable) copy of the config\n// value, to prevent mutation of the user config object.\n// Get the current user config. For testing purposes only\n\nexport var getConfig = function getConfig() {\n  return VueProto[PROP_NAME] ? VueProto[PROP_NAME].getConfig() : {};\n}; // Method to grab a config value based on a dotted/array notation key\n\nexport var getConfigValue = function getConfigValue(key) {\n  return VueProto[PROP_NAME] ? VueProto[PROP_NAME].getConfigValue(key) : cloneDeep(get(DEFAULTS, key));\n}; // Method to grab a config value for a particular component\n\nexport var getComponentConfig = function getComponentConfig(cmpName) {\n  var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n  // Return the particular config value for key for if specified,\n  // otherwise we return the full config (or an empty object if not found)\n  return key ? getConfigValue(\"\".concat(cmpName, \".\").concat(key)) : getConfigValue(cmpName) || {};\n}; // Convenience method for getting all breakpoint names\n\nexport var getBreakpoints = function getBreakpoints() {\n  return getConfigValue('breakpoints');\n}; // Private function for caching / locking-in breakpoint names\n\nvar _getBreakpointsCached = memoize(function () {\n  return getBreakpoints();\n}); // Convenience method for getting all breakpoint names.\n// Caches the results after first access.\n\n\nexport var getBreakpointsCached = function getBreakpointsCached() {\n  return cloneDeep(_getBreakpointsCached());\n}; // Convenience method for getting breakpoints with\n// the smallest breakpoint set as ''.\n// Useful for components that create breakpoint specific props.\n\nexport var getBreakpointsUp = function getBreakpointsUp() {\n  var breakpoints = getBreakpoints();\n  breakpoints[0] = '';\n  return breakpoints;\n}; // Convenience method for getting breakpoints with\n// the smallest breakpoint set as ''.\n// Useful for components that create breakpoint specific props.\n// Caches the results after first access.\n\nexport var getBreakpointsUpCached = memoize(function () {\n  var breakpoints = getBreakpointsCached();\n  breakpoints[0] = '';\n  return breakpoints;\n}); // Convenience method for getting breakpoints with\n// the largest breakpoint set as ''.\n// Useful for components that create breakpoint specific props.\n\nexport var getBreakpointsDown = function getBreakpointsDown() {\n  var breakpoints = getBreakpoints();\n  breakpoints[breakpoints.length - 1] = '';\n  return breakpoints;\n}; // Convenience method for getting breakpoints with\n// the largest breakpoint set as ''.\n// Useful for components that create breakpoint specific props.\n// Caches the results after first access.\n\n/* istanbul ignore next: we don't use this method anywhere, yet */\n\nexport var getBreakpointsDownCached = function getBreakpointsDownCached()\n/* istanbul ignore next */\n{\n  var breakpoints = getBreakpointsCached();\n  breakpoints[breakpoints.length - 1] = '';\n  return breakpoints;\n};","// --- Static ---\nexport var from = function from() {\n  return Array.from.apply(Array, arguments);\n};\nexport var isArray = function isArray(val) {\n  return Array.isArray(val);\n}; // --- Instance ---\n\nexport var arrayIncludes = function arrayIncludes(array, value) {\n  return array.indexOf(value) !== -1;\n};\nexport var concat = function concat() {\n  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n    args[_key] = arguments[_key];\n  }\n\n  return Array.prototype.concat.apply([], args);\n};","import identity from './identity';\nimport { concat } from './array';\nimport { isFunction } from './inspect'; // Note for functional components:\n// In functional components, `slots` is a function so it must be called\n// first before passing to the below methods. `scopedSlots` is always an\n// object and may be undefined (for Vue < 2.6.x)\n\n/**\n * Returns true if either scoped or unscoped named slot exists\n *\n * @param {String, Array} name or name[]\n * @param {Object} scopedSlots\n * @param {Object} slots\n * @returns {Array|undefined} VNodes\n */\n\nvar hasNormalizedSlot = function hasNormalizedSlot(names) {\n  var $scopedSlots = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var $slots = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  // Ensure names is an array\n  names = concat(names).filter(identity); // Returns true if the either a $scopedSlot or $slot exists with the specified name\n\n  return names.some(function (name) {\n    return $scopedSlots[name] || $slots[name];\n  });\n};\n/**\n * Returns VNodes for named slot either scoped or unscoped\n *\n * @param {String, Array} name or name[]\n * @param {String} scope\n * @param {Object} scopedSlots\n * @param {Object} slots\n * @returns {Array|undefined} VNodes\n */\n\n\nvar normalizeSlot = function normalizeSlot(names) {\n  var scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var $scopedSlots = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var $slots = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n  // Ensure names is an array\n  names = concat(names).filter(identity);\n  var slot;\n\n  for (var i = 0; i < names.length && !slot; i++) {\n    var name = names[i];\n    slot = $scopedSlots[name] || $slots[name];\n  } // Note: in Vue 2.6.x, all named slots are also scoped slots\n\n\n  return isFunction(slot) ? slot(scope) : slot;\n}; // Named exports\n\n\nexport { hasNormalizedSlot, normalizeSlot }; // Default export (backwards compatibility)\n\nexport default normalizeSlot;","var identity = function identity(x) {\n  return x;\n};\n\nexport default identity;","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nimport { isArray } from './array';\nimport { isObject, isPlainObject } from './object';\nimport { File } from './safe-types'; // --- Convenience inspection utilities ---\n\nexport var toType = function toType(val) {\n  return _typeof(val);\n};\nexport var toRawType = function toRawType(val) {\n  return Object.prototype.toString.call(val).slice(8, -1);\n};\nexport var toRawTypeLC = function toRawTypeLC(val) {\n  return toRawType(val).toLowerCase();\n};\nexport var isUndefined = function isUndefined(val) {\n  return val === undefined;\n};\nexport var isNull = function isNull(val) {\n  return val === null;\n};\nexport var isEmptyString = function isEmptyString(val) {\n  return val === '';\n};\nexport var isUndefinedOrNull = function isUndefinedOrNull(val) {\n  return isUndefined(val) || isNull(val);\n};\nexport var isUndefinedOrNullOrEmpty = function isUndefinedOrNullOrEmpty(val) {\n  return isUndefinedOrNull(val) || isEmptyString(val);\n};\nexport var isFunction = function isFunction(val) {\n  return toType(val) === 'function';\n};\nexport var isBoolean = function isBoolean(val) {\n  return toType(val) === 'boolean';\n};\nexport var isString = function isString(val) {\n  return toType(val) === 'string';\n};\nexport var isNumber = function isNumber(val) {\n  return toType(val) === 'number';\n};\nexport var isPrimitive = function isPrimitive(val) {\n  return isBoolean(val) || isString(val) || isNumber(val);\n};\nexport var isDate = function isDate(val) {\n  return val instanceof Date;\n};\nexport var isEvent = function isEvent(val) {\n  return val instanceof Event;\n};\nexport var isFile = function isFile(val) {\n  return val instanceof File;\n};\nexport var isRegExp = function isRegExp(val) {\n  return toRawType(val) === 'RegExp';\n};\nexport var isPromise = function isPromise(val) {\n  return !isUndefinedOrNull(val) && isFunction(val.then) && isFunction(val.catch);\n}; // Extra convenience named re-exports\n\nexport { isArray, isObject, isPlainObject };","import { hasNormalizedSlot as _hasNormalizedSlot, normalizeSlot as _normalizeSlot } from '../utils/normalize-slot';\nimport { concat } from '../utils/array';\nexport default {\n  methods: {\n    hasNormalizedSlot: function hasNormalizedSlot(names) {\n      // Returns true if the either a $scopedSlot or $slot exists with the specified name\n      // `names` can be a string name or an array of names\n      return _hasNormalizedSlot(names, this.$scopedSlots, this.$slots);\n    },\n    normalizeSlot: function normalizeSlot(names) {\n      var scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      // Returns an array of rendered VNodes if slot found.\n      // Returns undefined if not found.\n      // `names` can be a string name or an array of names\n      var vNodes = _normalizeSlot(names, scope, this.$scopedSlots, this.$slots);\n\n      return vNodes ? concat(vNodes) : vNodes;\n    }\n  }\n};","import { from as arrayFrom } from './array';\nimport { hasWindowSupport, hasDocumentSupport } from './env';\nimport { isFunction, isNull } from '../utils/inspect'; // --- Constants ---\n\nvar w = hasWindowSupport ? window : {};\nvar d = hasDocumentSupport ? document : {};\nvar elProto = typeof Element !== 'undefined' ? Element.prototype : {}; // --- Normalization utils ---\n// See: https://developer.mozilla.org/en-US/docs/Web/API/Element/matches#Polyfill\n\n/* istanbul ignore next */\n\nexport var matchesEl = elProto.matches || elProto.msMatchesSelector || elProto.webkitMatchesSelector; // See: https://developer.mozilla.org/en-US/docs/Web/API/Element/closest\n\n/* istanbul ignore next */\n\nexport var closestEl = elProto.closest || function (sel)\n/* istanbul ignore next */\n{\n  var el = this;\n\n  do {\n    // Use our \"patched\" matches function\n    if (matches(el, sel)) {\n      return el;\n    }\n\n    el = el.parentElement || el.parentNode;\n  } while (!isNull(el) && el.nodeType === Node.ELEMENT_NODE);\n\n  return null;\n}; // `requestAnimationFrame()` convenience method\n\nexport var requestAF = w.requestAnimationFrame || w.webkitRequestAnimationFrame || w.mozRequestAnimationFrame || w.msRequestAnimationFrame || w.oRequestAnimationFrame || // Fallback, but not a true polyfill\n// Only needed for Opera Mini\n\n/* istanbul ignore next */\nfunction (cb) {\n  return setTimeout(cb, 16);\n};\nexport var MutationObs = w.MutationObserver || w.WebKitMutationObserver || w.MozMutationObserver || null; // --- Utils ---\n// Remove a node from DOM\n\nexport var removeNode = function removeNode(el) {\n  return el && el.parentNode && el.parentNode.removeChild(el);\n}; // Determine if an element is an HTML element\n\nexport var isElement = function isElement(el) {\n  return !!(el && el.nodeType === Node.ELEMENT_NODE);\n}; // Determine if an HTML element is visible - Faster than CSS check\n\nexport var isVisible = function isVisible(el) {\n  if (!isElement(el) || !el.parentNode || !contains(d.body, el)) {\n    // Note this can fail for shadow dom elements since they\n    // are not a direct descendant of document.body\n    return false;\n  }\n\n  if (el.style.display === 'none') {\n    // We do this check to help with vue-test-utils when using v-show\n\n    /* istanbul ignore next */\n    return false;\n  } // All browsers support getBoundingClientRect(), except JSDOM as it returns all 0's for values :(\n  // So any tests that need isVisible will fail in JSDOM\n  // Except when we override the getBCR prototype in some tests\n\n\n  var bcr = getBCR(el);\n  return !!(bcr && bcr.height > 0 && bcr.width > 0);\n}; // Determine if an element is disabled\n\nexport var isDisabled = function isDisabled(el) {\n  return !isElement(el) || el.disabled || hasAttr(el, 'disabled') || hasClass(el, 'disabled');\n}; // Cause/wait-for an element to reflow its content (adjusting its height/width)\n\nexport var reflow = function reflow(el) {\n  // Requesting an elements offsetHight will trigger a reflow of the element content\n\n  /* istanbul ignore next: reflow doesn't happen in JSDOM */\n  return isElement(el) && el.offsetHeight;\n}; // Select all elements matching selector. Returns `[]` if none found\n\nexport var selectAll = function selectAll(selector, root) {\n  return arrayFrom((isElement(root) ? root : d).querySelectorAll(selector));\n}; // Select a single element, returns `null` if not found\n\nexport var select = function select(selector, root) {\n  return (isElement(root) ? root : d).querySelector(selector) || null;\n}; // Determine if an element matches a selector\n\nexport var matches = function matches(el, selector) {\n  return isElement(el) ? matchesEl.call(el, selector) : false;\n}; // Finds closest element matching selector. Returns `null` if not found\n\nexport var closest = function closest(selector, root) {\n  var includeRoot = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n  if (!isElement(root)) {\n    return null;\n  }\n\n  var el = closestEl.call(root, selector); // Native closest behaviour when `includeRoot` is truthy,\n  // else emulate jQuery closest and return `null` if match is\n  // the passed in root element when `includeRoot` is falsey\n\n  return includeRoot ? el : el === root ? null : el;\n}; // Returns true if the parent element contains the child element\n\nexport var contains = function contains(parent, child) {\n  return parent && isFunction(parent.contains) ? parent.contains(child) : false;\n}; // Get an element given an ID\n\nexport var getById = function getById(id) {\n  return d.getElementById(/^#/.test(id) ? id.slice(1) : id) || null;\n}; // Add a class to an element\n\nexport var addClass = function addClass(el, className) {\n  // We are checking for `el.classList` existence here since IE 11\n  // returns `undefined` for some elements (e.g. SVG elements)\n  // See https://github.com/bootstrap-vue/bootstrap-vue/issues/2713\n  if (className && isElement(el) && el.classList) {\n    el.classList.add(className);\n  }\n}; // Remove a class from an element\n\nexport var removeClass = function removeClass(el, className) {\n  // We are checking for `el.classList` existence here since IE 11\n  // returns `undefined` for some elements (e.g. SVG elements)\n  // See https://github.com/bootstrap-vue/bootstrap-vue/issues/2713\n  if (className && isElement(el) && el.classList) {\n    el.classList.remove(className);\n  }\n}; // Test if an element has a class\n\nexport var hasClass = function hasClass(el, className) {\n  // We are checking for `el.classList` existence here since IE 11\n  // returns `undefined` for some elements (e.g. SVG elements)\n  // See https://github.com/bootstrap-vue/bootstrap-vue/issues/2713\n  if (className && isElement(el) && el.classList) {\n    return el.classList.contains(className);\n  }\n\n  return false;\n}; // Set an attribute on an element\n\nexport var setAttr = function setAttr(el, attr, val) {\n  if (attr && isElement(el)) {\n    el.setAttribute(attr, val);\n  }\n}; // Remove an attribute from an element\n\nexport var removeAttr = function removeAttr(el, attr) {\n  if (attr && isElement(el)) {\n    el.removeAttribute(attr);\n  }\n}; // Get an attribute value from an element\n// Returns `null` if not found\n\nexport var getAttr = function getAttr(el, attr) {\n  return attr && isElement(el) ? el.getAttribute(attr) : null;\n}; // Determine if an attribute exists on an element\n// Returns `true` or `false`, or `null` if element not found\n\nexport var hasAttr = function hasAttr(el, attr) {\n  return attr && isElement(el) ? el.hasAttribute(attr) : null;\n}; // Return the Bounding Client Rect of an element\n// Returns `null` if not an element\n\n/* istanbul ignore next: getBoundingClientRect() doesn't work in JSDOM */\n\nexport var getBCR = function getBCR(el) {\n  return isElement(el) ? el.getBoundingClientRect() : null;\n}; // Get computed style object for an element\n\n/* istanbul ignore next: getComputedStyle() doesn't work in JSDOM */\n\nexport var getCS = function getCS(el) {\n  return hasWindowSupport && isElement(el) ? w.getComputedStyle(el) : {};\n}; // Returns a `Selection` object representing the range of text selected\n// Returns `null` if no window support is given\n\n/* istanbul ignore next: getSelection() doesn't work in JSDOM */\n\nexport var getSel = function getSel() {\n  return hasWindowSupport && w.getSelection ? w.getSelection() : null;\n}; // Return an element's offset with respect to document element\n// https://j11y.io/jquery/#v=git&fn=jQuery.fn.offset\n\nexport var offset = function offset(el)\n/* istanbul ignore next: getBoundingClientRect(), getClientRects() doesn't work in JSDOM */\n{\n  var _offset = {\n    top: 0,\n    left: 0\n  };\n\n  if (!isElement(el) || el.getClientRects().length === 0) {\n    return _offset;\n  }\n\n  var bcr = getBCR(el);\n\n  if (bcr) {\n    var win = el.ownerDocument.defaultView;\n    _offset.top = bcr.top + win.pageYOffset;\n    _offset.left = bcr.left + win.pageXOffset;\n  }\n\n  return _offset;\n}; // Return an element's offset with respect to to its offsetParent\n// https://j11y.io/jquery/#v=git&fn=jQuery.fn.position\n\nexport var position = function position(el)\n/* istanbul ignore next: getBoundingClientRect() doesn't work in JSDOM */\n{\n  var _offset = {\n    top: 0,\n    left: 0\n  };\n\n  if (!isElement(el)) {\n    return _offset;\n  }\n\n  var parentOffset = {\n    top: 0,\n    left: 0\n  };\n  var elStyles = getCS(el);\n\n  if (elStyles.position === 'fixed') {\n    _offset = getBCR(el) || _offset;\n  } else {\n    _offset = offset(el);\n    var doc = el.ownerDocument;\n    var offsetParent = el.offsetParent || doc.documentElement;\n\n    while (offsetParent && (offsetParent === doc.body || offsetParent === doc.documentElement) && getCS(offsetParent).position === 'static') {\n      offsetParent = offsetParent.parentNode;\n    }\n\n    if (offsetParent && offsetParent !== el && offsetParent.nodeType === Node.ELEMENT_NODE) {\n      parentOffset = offset(offsetParent);\n      var offsetParentStyles = getCS(offsetParent);\n      parentOffset.top += parseFloat(offsetParentStyles.borderTopWidth);\n      parentOffset.left += parseFloat(offsetParentStyles.borderLeftWidth);\n    }\n  }\n\n  return {\n    top: _offset.top - parentOffset.top - parseFloat(elStyles.marginTop),\n    left: _offset.left - parentOffset.left - parseFloat(elStyles.marginLeft)\n  };\n};","/**\n * Utilities to get information about the current environment\n */\n// --- Constants ---\nexport var hasWindowSupport = typeof window !== 'undefined';\nexport var hasDocumentSupport = typeof document !== 'undefined';\nexport var hasNavigatorSupport = typeof navigator !== 'undefined';\nexport var hasPromiseSupport = typeof Promise !== 'undefined';\nexport var hasMutationObserverSupport = typeof MutationObserver !== 'undefined' || typeof WebKitMutationObserver !== 'undefined' || typeof MozMutationObserver !== 'undefined';\nexport var isBrowser = hasWindowSupport && hasDocumentSupport && hasNavigatorSupport; // Browser type sniffing\n\nexport var userAgent = isBrowser ? window.navigator.userAgent.toLowerCase() : '';\nexport var isJSDOM = userAgent.indexOf('jsdom') > 0;\nexport var isIE = /msie|trident/.test(userAgent); // Determine if the browser supports the option passive for events\n\nexport var hasPassiveEventSupport = function () {\n  var passiveEventSupported = false;\n\n  if (isBrowser) {\n    try {\n      var options = {\n        get passive() {\n          // This function will be called when the browser\n          // attempts to access the passive property.\n\n          /* istanbul ignore next: will never be called in JSDOM */\n          passiveEventSupported = true;\n        }\n\n      };\n      window.addEventListener('test', options, options);\n      window.removeEventListener('test', options, options);\n    } catch (err) {\n      /* istanbul ignore next: will never be called in JSDOM */\n      passiveEventSupported = false;\n    }\n  }\n\n  return passiveEventSupported;\n}();\nexport var hasTouchSupport = isBrowser && ('ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0);\nexport var hasPointerEventSupport = isBrowser && Boolean(window.PointerEvent || window.MSPointerEvent);\nexport var hasIntersectionObserverSupport = isBrowser && 'IntersectionObserver' in window && 'IntersectionObserverEntry' in window && // Edge 15 and UC Browser lack support for `isIntersecting`\n// but we an use intersectionRatio > 0 instead\n// 'isIntersecting' in window.IntersectionObserverEntry.prototype &&\n'intersectionRatio' in window.IntersectionObserverEntry.prototype; // --- Getters ---\n\nexport var getEnv = function getEnv(key) {\n  var fallback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n  var env = typeof process !== 'undefined' && process ? process.env || {} : {};\n\n  if (!key) {\n    /* istanbul ignore next */\n    return env;\n  }\n\n  return env[key] || fallback;\n};\nexport var getNoWarn = function getNoWarn() {\n  return getEnv('BOOTSTRAP_VUE_NO_WARN');\n};","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \"function\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \"function\") { throw new TypeError(\"Super expression must either be null or a function\"); } if (typeof _cache !== \"undefined\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\n\nfunction isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\n\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\"[native code]\") !== -1; }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\n/**\n * SSR safe types\n */\nimport { hasWindowSupport } from './env';\nvar w = hasWindowSupport ? window : {};\nexport var Element = hasWindowSupport ? w.Element :\n/*#__PURE__*/\nfunction (_Object) {\n  _inherits(Element, _Object);\n\n  function Element() {\n    _classCallCheck(this, Element);\n\n    return _possibleConstructorReturn(this, _getPrototypeOf(Element).apply(this, arguments));\n  }\n\n  return Element;\n}(_wrapNativeSuper(Object));\nexport var HTMLElement = hasWindowSupport ? w.HTMLElement :\n/*#__PURE__*/\nfunction (_Element) {\n  _inherits(HTMLElement, _Element);\n\n  function HTMLElement() {\n    _classCallCheck(this, HTMLElement);\n\n    return _possibleConstructorReturn(this, _getPrototypeOf(HTMLElement).apply(this, arguments));\n  }\n\n  return HTMLElement;\n}(Element);\nexport var SVGElement = hasWindowSupport ? w.SVGElement :\n/*#__PURE__*/\nfunction (_Element2) {\n  _inherits(SVGElement, _Element2);\n\n  function SVGElement() {\n    _classCallCheck(this, SVGElement);\n\n    return _possibleConstructorReturn(this, _getPrototypeOf(SVGElement).apply(this, arguments));\n  }\n\n  return SVGElement;\n}(Element);\nexport var File = hasWindowSupport ? w.File :\n/*#__PURE__*/\nfunction (_Object2) {\n  _inherits(File, _Object2);\n\n  function File() {\n    _classCallCheck(this, File);\n\n    return _possibleConstructorReturn(this, _getPrototypeOf(File).apply(this, arguments));\n  }\n\n  return File;\n}(_wrapNativeSuper(Object));","import identity from './identity';\nimport { isArray, isObject } from './inspect';\nvar RX_ARRAY_NOTATION = /\\[(\\d+)]/g;\n/**\n * Get property defined by dot/array notation in string.\n *\n * @link https://gist.github.com/jeneg/9767afdcca45601ea44930ea03e0febf#gistcomment-1935901\n *\n * @param {Object} obj\n * @param {string|Array} path\n * @param {*} defaultValue (optional)\n * @return {*}\n */\n\nvar get = function get(obj, path) {\n  var defaultValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n  // Handle array of path values\n  path = isArray(path) ? path.join('.') : path; // If no path or no object passed\n\n  if (!path || !isObject(obj)) {\n    return defaultValue;\n  } // Handle edge case where user has dot(s) in top-level item field key\n  // See https://github.com/bootstrap-vue/bootstrap-vue/issues/2762\n  // Switched to `in` operator vs `hasOwnProperty` to handle obj.prototype getters\n  // https://github.com/bootstrap-vue/bootstrap-vue/issues/3463\n\n\n  if (path in obj) {\n    return obj[path];\n  } // Handle string array notation (numeric indices only)\n\n\n  path = String(path).replace(RX_ARRAY_NOTATION, '.$1');\n  var steps = path.split('.').filter(identity); // Handle case where someone passes a string of only dots\n\n  if (steps.length === 0) {\n    return defaultValue;\n  } // Traverse path in object to find result\n  // We use `!=` vs `!==` to test for both `null` and `undefined`\n  // Switched to `in` operator vs `hasOwnProperty` to handle obj.prototype getters\n  // https://github.com/bootstrap-vue/bootstrap-vue/issues/3463\n\n\n  return steps.every(function (step) {\n    return isObject(obj) && step in obj && (obj = obj[step]) != null;\n  }) ? obj : defaultValue;\n};\n\nexport default get;","import { isArray, isNull, isPlainObject, isString, isUndefined } from './inspect';\nimport { keys } from './object';\nimport { toString } from './string';\nvar ANCHOR_TAG = 'a'; // Precompile RegExp\n\nvar commaRE = /%2C/g;\nvar encodeReserveRE = /[!'()*]/g;\nvar plusRE = /\\+/g;\nvar queryStartRE = /^(\\?|#|&)/; // Method to replace reserved chars\n\nvar encodeReserveReplacer = function encodeReserveReplacer(c) {\n  return '%' + c.charCodeAt(0).toString(16);\n}; // Fixed encodeURIComponent which is more conformant to RFC3986:\n// - escapes [!'()*]\n// - preserve commas\n\n\nvar encode = function encode(str) {\n  return encodeURIComponent(toString(str)).replace(encodeReserveRE, encodeReserveReplacer).replace(commaRE, ',');\n};\n\nvar decode = decodeURIComponent; // Stringifies an object of query parameters\n// See: https://github.com/vuejs/vue-router/blob/dev/src/util/query.js\n\nexport var stringifyQueryObj = function stringifyQueryObj(obj) {\n  if (!isPlainObject(obj)) {\n    return '';\n  }\n\n  var query = keys(obj).map(function (key) {\n    var val = obj[key];\n\n    if (isUndefined(val)) {\n      return '';\n    } else if (isNull(val)) {\n      return encode(key);\n    } else if (isArray(val)) {\n      return val.reduce(function (results, val2) {\n        if (isNull(val2)) {\n          results.push(encode(key));\n        } else if (!isUndefined(val2)) {\n          // Faster than string interpolation\n          results.push(encode(key) + '=' + encode(val2));\n        }\n\n        return results;\n      }, []).join('&');\n    } // Faster than string interpolation\n\n\n    return encode(key) + '=' + encode(val);\n  })\n  /* must check for length, as we only want to filter empty strings, not things that look falsey! */\n  .filter(function (x) {\n    return x.length > 0;\n  }).join('&');\n  return query ? \"?\".concat(query) : '';\n};\nexport var parseQuery = function parseQuery(query) {\n  var parsed = {};\n  query = toString(query).trim().replace(queryStartRE, '');\n\n  if (!query) {\n    return parsed;\n  }\n\n  query.split('&').forEach(function (param) {\n    var parts = param.replace(plusRE, ' ').split('=');\n    var key = decode(parts.shift());\n    var val = parts.length > 0 ? decode(parts.join('=')) : null;\n\n    if (isUndefined(parsed[key])) {\n      parsed[key] = val;\n    } else if (isArray(parsed[key])) {\n      parsed[key].push(val);\n    } else {\n      parsed[key] = [parsed[key], val];\n    }\n  });\n  return parsed;\n};\nexport var isRouterLink = function isRouterLink(tag) {\n  return toString(tag).toLowerCase() !== ANCHOR_TAG;\n};\nexport var computeTag = function computeTag() {\n  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n      to = _ref.to,\n      disabled = _ref.disabled;\n\n  var thisOrParent = arguments.length > 1 ? arguments[1] : undefined;\n  return thisOrParent.$router && to && !disabled ? thisOrParent.$nuxt ? 'nuxt-link' : 'router-link' : ANCHOR_TAG;\n};\nexport var computeRel = function computeRel() {\n  var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n      target = _ref2.target,\n      rel = _ref2.rel;\n\n  if (target === '_blank' && isNull(rel)) {\n    return 'noopener';\n  }\n\n  return rel || null;\n};\nexport var computeHref = function computeHref() {\n  var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n      href = _ref3.href,\n      to = _ref3.to;\n\n  var tag = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ANCHOR_TAG;\n  var fallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '#';\n  var toFallback = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '/';\n\n  // We've already checked the $router in computeTag(), so isRouterLink() indicates a live router.\n  // When deferring to Vue Router's router-link, don't use the href attribute at all.\n  // We return null, and then remove href from the attributes passed to router-link\n  if (isRouterLink(tag)) {\n    return null;\n  } // Return `href` when explicitly provided\n\n\n  if (href) {\n    return href;\n  } // Reconstruct `href` when `to` used, but no router\n\n\n  if (to) {\n    // Fallback to `to` prop (if `to` is a string)\n    if (isString(to)) {\n      return to || toFallback;\n    } // Fallback to `to.path + to.query + to.hash` prop (if `to` is an object)\n\n\n    if (isPlainObject(to) && (to.path || to.query || to.hash)) {\n      var path = toString(to.path);\n      var query = stringifyQueryObj(to.query);\n      var hash = toString(to.hash);\n      hash = !hash || hash.charAt(0) === '#' ? hash : \"#\".concat(hash);\n      return \"\".concat(path).concat(query).concat(hash) || toFallback;\n    }\n  } // If nothing is provided return the fallback\n\n\n  return fallback;\n};","function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance\"); }\n\nfunction _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport Vue from '../../utils/vue';\nimport normalizeSlotMixin from '../../mixins/normalize-slot';\nimport { concat } from '../../utils/array';\nimport { isEvent, isFunction, isUndefined } from '../../utils/inspect';\nimport { computeHref, computeRel, computeTag, isRouterLink as _isRouterLink } from '../../utils/router';\n/**\n * The Link component is used in many other BV components.\n * As such, sharing its props makes supporting all its features easier.\n * However, some components need to modify the defaults for their own purpose.\n * Prefer sharing a fresh copy of the props to ensure mutations\n * do not affect other component references to the props.\n *\n * https://github.com/vuejs/vue-router/blob/dev/src/components/link.js\n * @return {{}}\n */\n\nexport var propsFactory = function propsFactory() {\n  return {\n    href: {\n      type: String,\n      default: null\n    },\n    rel: {\n      type: String,\n      default: null\n    },\n    target: {\n      type: String,\n      default: '_self'\n    },\n    active: {\n      type: Boolean,\n      default: false\n    },\n    disabled: {\n      type: Boolean,\n      default: false\n    },\n    // router-link specific props\n    to: {\n      type: [String, Object],\n      default: null\n    },\n    append: {\n      type: Boolean,\n      default: false\n    },\n    replace: {\n      type: Boolean,\n      default: false\n    },\n    event: {\n      type: [String, Array],\n      default: 'click'\n    },\n    activeClass: {\n      type: String // default: undefined\n\n    },\n    exact: {\n      type: Boolean,\n      default: false\n    },\n    exactActiveClass: {\n      type: String // default: undefined\n\n    },\n    routerTag: {\n      type: String,\n      default: 'a'\n    },\n    // nuxt-link specific prop(s)\n    noPrefetch: {\n      type: Boolean,\n      default: false\n    }\n  };\n};\nexport var props = propsFactory(); // @vue/component\n\nexport var BLink =\n/*#__PURE__*/\nVue.extend({\n  name: 'BLink',\n  mixins: [normalizeSlotMixin],\n  inheritAttrs: false,\n  props: propsFactory(),\n  computed: {\n    computedTag: function computedTag() {\n      // We don't pass `this` as the first arg as we need reactivity of the props\n      return computeTag({\n        to: this.to,\n        disabled: this.disabled\n      }, this);\n    },\n    isRouterLink: function isRouterLink() {\n      return _isRouterLink(this.computedTag);\n    },\n    computedRel: function computedRel() {\n      // We don't pass `this` as the first arg as we need reactivity of the props\n      return computeRel({\n        target: this.target,\n        rel: this.rel\n      });\n    },\n    computedHref: function computedHref() {\n      // We don't pass `this` as the first arg as we need reactivity of the props\n      return computeHref({\n        to: this.to,\n        href: this.href\n      }, this.computedTag);\n    },\n    computedProps: function computedProps() {\n      return this.isRouterLink ? _objectSpread({}, this.$props, {\n        tag: this.routerTag\n      }) : {};\n    }\n  },\n  methods: {\n    onClick: function onClick(evt) {\n      var _arguments = arguments;\n      var evtIsEvent = isEvent(evt);\n      var isRouterLink = this.isRouterLink;\n      var suppliedHandler = this.$listeners.click;\n\n      if (evtIsEvent && this.disabled) {\n        // Stop event from bubbling up\n        evt.stopPropagation(); // Kill the event loop attached to this specific `EventTarget`\n        // Needed to prevent `vue-router` for doing its thing\n\n        evt.stopImmediatePropagation();\n      } else {\n        /* istanbul ignore next: difficult to test, but we know it works */\n        if (isRouterLink && evt.currentTarget.__vue__) {\n          // Router links do not emit instance `click` events, so we\n          // add in an `$emit('click', evt)` on its Vue instance\n          evt.currentTarget.__vue__.$emit('click', evt);\n        } // Call the suppliedHandler(s), if any provided\n\n\n        concat(suppliedHandler).filter(function (h) {\n          return isFunction(h);\n        }).forEach(function (handler) {\n          handler.apply(void 0, _toConsumableArray(_arguments));\n        }); // Emit the global `$root` click event\n\n        this.$root.$emit('clicked::link', evt);\n      } // Stop scroll-to-top behavior or navigation on\n      // regular links when href is just '#'\n\n\n      if (evtIsEvent && (this.disabled || !isRouterLink && this.computedHref === '#')) {\n        evt.preventDefault();\n      }\n    },\n    focus: function focus() {\n      if (this.$el && this.$el.focus) {\n        this.$el.focus();\n      }\n    },\n    blur: function blur() {\n      if (this.$el && this.$el.blur) {\n        this.$el.blur();\n      }\n    }\n  },\n  render: function render(h) {\n    var tag = this.computedTag;\n    var rel = this.computedRel;\n    var href = this.computedHref;\n    var isRouterLink = this.isRouterLink;\n    var componentData = {\n      class: {\n        active: this.active,\n        disabled: this.disabled\n      },\n      attrs: _objectSpread({}, this.$attrs, {\n        rel: rel,\n        target: this.target,\n        tabindex: this.disabled ? '-1' : isUndefined(this.$attrs.tabindex) ? null : this.$attrs.tabindex,\n        'aria-disabled': this.disabled ? 'true' : null\n      }),\n      props: this.computedProps\n    }; // Add the event handlers. We must use `nativeOn` for\n    // `<router-link>`/`<nuxt-link>` instead of `on`\n\n    componentData[isRouterLink ? 'nativeOn' : 'on'] = _objectSpread({}, this.$listeners, {\n      // We want to overwrite any click handler since our callback\n      // will invoke the user supplied handler(s) if `!this.disabled`\n      click: this.onClick\n    }); // If href attribute exists on <router-link> (even undefined or null) it fails working on\n    // SSR, so we explicitly add it here if needed (i.e. if computedHref() is truthy)\n\n    if (href) {\n      componentData.attrs.href = href;\n    } else {\n      // Ensure the prop HREF does not exist for router links\n      delete componentData.props.href;\n    }\n\n    return h(tag, componentData, this.normalizeSlot('default'));\n  }\n});","var e=function(){return(e=Object.assign||function(e){for(var t,r=1,s=arguments.length;r<s;r++)for(var a in t=arguments[r])Object.prototype.hasOwnProperty.call(t,a)&&(e[a]=t[a]);return e}).apply(this,arguments)},t={kebab:/-(\\w)/g,styleProp:/:(.*)/,styleList:/;(?![^(]*\\))/g};function r(e,t){return t?t.toUpperCase():\"\"}function s(e){for(var s,a={},c=0,o=e.split(t.styleList);c<o.length;c++){var n=o[c].split(t.styleProp),i=n[0],l=n[1];(i=i.trim())&&(\"string\"==typeof l&&(l=l.trim()),a[(s=i,s.replace(t.kebab,r))]=l)}return a}function a(){for(var t,r,a={},c=arguments.length;c--;)for(var o=0,n=Object.keys(arguments[c]);o<n.length;o++)switch(t=n[o]){case\"class\":case\"style\":case\"directives\":if(Array.isArray(a[t])||(a[t]=[]),\"style\"===t){var i=void 0;i=Array.isArray(arguments[c].style)?arguments[c].style:[arguments[c].style];for(var l=0;l<i.length;l++){var y=i[l];\"string\"==typeof y&&(i[l]=s(y))}arguments[c].style=i}a[t]=a[t].concat(arguments[c][t]);break;case\"staticClass\":if(!arguments[c][t])break;void 0===a[t]&&(a[t]=\"\"),a[t]&&(a[t]+=\" \"),a[t]+=arguments[c][t].trim();break;case\"on\":case\"nativeOn\":a[t]||(a[t]={});for(var p=0,f=Object.keys(arguments[c][t]||{});p<f.length;p++)r=f[p],a[t][r]?a[t][r]=[].concat(a[t][r],arguments[c][t][r]):a[t][r]=arguments[c][t][r];break;case\"attrs\":case\"props\":case\"domProps\":case\"scopedSlots\":case\"staticStyle\":case\"hook\":case\"transition\":a[t]||(a[t]={}),a[t]=e({},arguments[c][t],a[t]);break;case\"slot\":case\"key\":case\"ref\":case\"tag\":case\"show\":case\"keepAlive\":default:a[t]||(a[t]=arguments[c][t])}return a}export{a as mergeData};\n//# sourceMappingURL=lib.esm.js.map\n","import { create } from './object';\n\nvar memoize = function memoize(fn) {\n  var cache = create(null);\n  return function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    var argsKey = JSON.stringify(args);\n    return cache[argsKey] = cache[argsKey] || fn.apply(null, args);\n  };\n};\n\nexport default memoize;","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nimport { isArray } from './array'; // --- Static ---\n\nexport var assign = function assign() {\n  return Object.assign.apply(Object, arguments);\n};\nexport var create = function create(proto, optionalProps) {\n  return Object.create(proto, optionalProps);\n};\nexport var defineProperties = function defineProperties(obj, props) {\n  return Object.defineProperties(obj, props);\n};\nexport var defineProperty = function defineProperty(obj, prop, descr) {\n  return Object.defineProperty(obj, prop, descr);\n};\nexport var freeze = function freeze(obj) {\n  return Object.freeze(obj);\n};\nexport var getOwnPropertyNames = function getOwnPropertyNames(obj) {\n  return Object.getOwnPropertyNames(obj);\n};\nexport var getOwnPropertyDescriptor = function getOwnPropertyDescriptor(obj, prop) {\n  return Object.getOwnPropertyDescriptor(obj, prop);\n};\nexport var getOwnPropertySymbols = function getOwnPropertySymbols(obj) {\n  return Object.getOwnPropertySymbols(obj);\n};\nexport var getPrototypeOf = function getPrototypeOf(obj) {\n  return Object.getPrototypeOf(obj);\n};\nexport var is = function is(value1, value2) {\n  return Object.is(value1, value2);\n};\nexport var isFrozen = function isFrozen(obj) {\n  return Object.isFrozen(obj);\n};\nexport var keys = function keys(obj) {\n  return Object.keys(obj);\n}; // --- \"Instance\" ---\n\nexport var hasOwnProperty = function hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\nexport var toString = function toString(obj) {\n  return Object.prototype.toString.call(obj);\n}; // --- Utilities ---\n\n/**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n * Note object could be a complex type like array, date, etc.\n */\n\nexport var isObject = function isObject(obj) {\n  return obj !== null && _typeof(obj) === 'object';\n};\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n */\n\nexport var isPlainObject = function isPlainObject(obj) {\n  return Object.prototype.toString.call(obj) === '[object Object]';\n};\n/**\n * Shallow copy an object. If the passed in object\n * is null or undefined, returns an empty object\n */\n\nexport var clone = function clone(obj) {\n  return _objectSpread({}, obj);\n};\n/**\n * Return a shallow copy of object with\n * the specified properties omitted\n * @link https://gist.github.com/bisubus/2da8af7e801ffd813fab7ac221aa7afc\n */\n\nexport var omit = function omit(obj, props) {\n  return keys(obj).filter(function (key) {\n    return props.indexOf(key) === -1;\n  }).reduce(function (result, key) {\n    return _objectSpread({}, result, _defineProperty({}, key, obj[key]));\n  }, {});\n};\n/**\n * Convenience method to create a read-only descriptor\n */\n\nexport var readonlyDescriptor = function readonlyDescriptor() {\n  return {\n    enumerable: true,\n    configurable: false,\n    writable: false\n  };\n};\n/**\n * Deep-freezes and object, making it immutable / read-only.\n * Returns the same object passed-in, but frozen.\n * Freezes inner object/array/values first.\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze\n * Note: this method will not work for property values using Symbol() as a key\n */\n\nexport var deepFreeze = function deepFreeze(obj) {\n  // Retrieve the property names defined on object/array\n  // Note: `keys` will ignore properties that are keyed by a `Symbol()`\n  var props = keys(obj); // Iterate over each prop and recursively freeze it\n\n  props.forEach(function (prop) {\n    var value = obj[prop]; // If value is a plain object or array, we deepFreeze it\n\n    obj[prop] = value && (isPlainObject(value) || isArray(value)) ? deepFreeze(value) : value;\n  });\n  return freeze(obj);\n};","//\n// Single point of contact for Vue\n//\n// TODO:\n//   Conditionally import Vue if no global Vue\n//\nimport Vue from 'vue';\nexport default Vue;","// String utilities\nimport { isArray, isPlainObject, isString, isUndefinedOrNull } from './inspect'; // --- Constants ---\n\nvar RX_TRIM_LEFT = /^\\s+/;\nvar RX_TRIM_RIGHT = /\\s+$/;\nvar RX_REGEXP_REPLACE = /[-/\\\\^$*+?.()|[\\]{}]/g;\nvar RX_UN_KEBAB = /-(\\w)/g;\nvar RX_HYPHENATE = /\\B([A-Z])/g; // --- Utilities ---\n// Converts PascalCase or camelCase to kebab-case\n\nexport var kebabCase = function kebabCase(str) {\n  return str.replace(RX_HYPHENATE, '-$1').toLowerCase();\n}; // Converts a kebab-case or camelCase string to PascalCase\n\nexport var pascalCase = function pascalCase(str) {\n  str = kebabCase(str).replace(RX_UN_KEBAB, function (_, c) {\n    return c ? c.toUpperCase() : '';\n  });\n  return str.charAt(0).toUpperCase() + str.slice(1);\n}; // Lowercases the first letter of a string and returns a new string\n\nexport var lowerFirst = function lowerFirst(str) {\n  str = isString(str) ? str.trim() : String(str);\n  return str.charAt(0).toLowerCase() + str.slice(1);\n}; // Uppercases the first letter of a string and returns a new string\n\nexport var upperFirst = function upperFirst(str) {\n  str = isString(str) ? str.trim() : String(str);\n  return str.charAt(0).toUpperCase() + str.slice(1);\n}; // Escape characters to be used in building a regular expression\n\nexport var escapeRegExp = function escapeRegExp(str) {\n  return str.replace(RX_REGEXP_REPLACE, '\\\\$&');\n}; // Convert a value to a string that can be rendered\n// `undefined`/`null` will be converted to `''`\n// Plain objects and arrays will be JSON stringified\n\nexport var toString = function toString(val) {\n  var spaces = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;\n  return isUndefinedOrNull(val) ? '' : isArray(val) || isPlainObject(val) && val.toString === Object.prototype.toString ? JSON.stringify(val, null, spaces) : String(val);\n}; // Remove leading white space from a string\n\nexport var trimLeft = function trimLeft(str) {\n  return toString(str).replace(RX_TRIM_LEFT, '');\n}; // Remove Trailing white space from a string\n\nexport var trimRight = function trimRight(str) {\n  return toString(str).replace(RX_TRIM_RIGHT, '');\n}; // Remove leading and trailing white space from a string\n\nexport var trim = function trim(str) {\n  return toString(str).trim();\n}; // Lower case a string\n\nexport var lowerCase = function lowerCase(str) {\n  return toString(str).toLowerCase();\n}; // Upper case a string\n\nexport var upperCase = function upperCase(str) {\n  return toString(str).toUpperCase();\n};"],"sourceRoot":""}