buefy 1.0.0 → 1.0.2

package/dist/esm/notification.js

@@ -0,0 +1,275 @@
+import { defineComponent, resolveComponent, createBlock, openBlock, Transition, withCtx, withDirectives, createElementVNode, normalizeClass, createElementBlock, createCommentVNode, createVNode, renderSlot, Fragment, vShow, mergeProps, createApp, h } from 'vue';
+import { B as BIcon } from './Icon-DPyGDeRK.js';
+import { P as Progress } from './Progress-BPGTVZgr.js';
+import { M as MessageMixin } from './MessageMixin-CQ7LIdvq.js';
+import { _ as _export_sfc } from './_plugin-vue_export-helper-OJRSZE6i.js';
+import { c as config } from './config-CKuo-p6e.js';
+import { removeElement, getComponentFromVNode, copyAppContext } from './helpers.js';
+import { N as NoticeMixin } from './NoticeMixin-ByNlva3T.js';
+import { a as registerComponent, r as registerComponentProgrammatic } from './plugins-B172kuKE.js';
+
+const Notification$1 = defineComponent({
+  name: "BNotification",
+  components: {
+    BIcon,
+    // directly registers Progress
+    // in case Notification is programmatically opened
+    BProgress: Progress
+  },
+  mixins: [MessageMixin],
+  props: {
+    position: String,
+    ariaCloseLabel: String,
+    animation: {
+      type: String,
+      default: "fade"
+    }
+  }
+});
+
+const _hoisted_1 = ["aria-label"];
+const _hoisted_2 = {
+  key: 1,
+  class: "media"
+};
+const _hoisted_3 = {
+  key: 0,
+  class: "media-left"
+};
+const _hoisted_4 = { class: "media-content" };
+const _hoisted_5 = ["innerHTML"];
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_b_icon = resolveComponent("b-icon");
+  const _component_b_progress = resolveComponent("b-progress");
+  return openBlock(), createBlock(Transition, {
+    name: _ctx.animation,
+    persisted: ""
+  }, {
+    default: withCtx(() => [
+      withDirectives(createElementVNode(
+        "article",
+        {
+          class: normalizeClass(["notification", [_ctx.type, _ctx.position]]),
+          onClick: _cache[1] || (_cache[1] = (...args) => _ctx.click && _ctx.click(...args))
+        },
+        [
+          _ctx.closable ? (openBlock(), createElementBlock("button", {
+            key: 0,
+            class: "delete",
+            type: "button",
+            onClick: _cache[0] || (_cache[0] = (...args) => _ctx.close && _ctx.close(...args)),
+            "aria-label": _ctx.ariaCloseLabel
+          }, null, 8, _hoisted_1)) : createCommentVNode("v-if", true),
+          _ctx.$slots.default || _ctx.message ? (openBlock(), createElementBlock("div", _hoisted_2, [
+            _ctx.computedIcon && _ctx.hasIcon ? (openBlock(), createElementBlock("div", _hoisted_3, [
+              createVNode(_component_b_icon, {
+                icon: _ctx.computedIcon,
+                pack: _ctx.iconPack,
+                size: _ctx.newIconSize,
+                both: "",
+                "aria-hidden": ""
+              }, null, 8, ["icon", "pack", "size"])
+            ])) : createCommentVNode("v-if", true),
+            createElementVNode("div", _hoisted_4, [
+              _ctx.$slots.default ? renderSlot(_ctx.$slots, "default", { key: 0 }) : (openBlock(), createElementBlock(
+                Fragment,
+                { key: 1 },
+                [
+                  createCommentVNode(" eslint-disable-next-line vue/no-v-html "),
+                  createElementVNode("p", {
+                    class: "text",
+                    innerHTML: _ctx.message
+                  }, null, 8, _hoisted_5)
+                ],
+                64
+                /* STABLE_FRAGMENT */
+              ))
+            ])
+          ])) : createCommentVNode("v-if", true),
+          _ctx.progressBar ? (openBlock(), createBlock(_component_b_progress, {
+            key: 2,
+            class: "auto-close-progress",
+            value: _ctx.remainingTime - 1,
+            max: _ctx.duration / 1e3 - 1,
+            type: _ctx.type,
+            rounded: false
+          }, null, 8, ["value", "max", "type"])) : createCommentVNode("v-if", true)
+        ],
+        2
+        /* CLASS */
+      ), [
+        [vShow, _ctx.isActive]
+      ])
+    ]),
+    _: 3
+    /* FORWARDED */
+  }, 8, ["name"]);
+}
+var Notification = /* @__PURE__ */ _export_sfc(Notification$1, [["render", _sfc_render$1]]);
+
+const NotificationNotice$1 = defineComponent({
+  name: "BNotificationNotice",
+  components: { BNotification: Notification },
+  mixins: [NoticeMixin],
+  data() {
+    return {
+      newDuration: this.duration || config.defaultNotificationDuration
+    };
+  },
+  emits: {
+    close: () => true
+  },
+  methods: {
+    close() {
+      if (!this.isPaused) {
+        clearTimeout(this.timer);
+        this.$refs.notification.isActive = false;
+        this.$emit("close");
+        setTimeout(() => {
+          removeElement(this.$el);
+        }, 150);
+      }
+    }
+  }
+});
+
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_b_notification = resolveComponent("b-notification");
+  return _ctx.$slots.default != null ? (openBlock(), createBlock(_component_b_notification, mergeProps({
+    key: 0,
+    ref: "notification",
+    position: _ctx.position,
+    "model-value": _ctx.isActive,
+    type: _ctx.type,
+    message: _ctx.message,
+    duration: _ctx.duration
+  }, _ctx.$attrs, {
+    onClick: _ctx.click,
+    onClose: _ctx.close,
+    onMouseenter: _ctx.pause,
+    onMouseleave: _ctx.removePause
+  }), {
+    default: withCtx(() => [
+      renderSlot(_ctx.$slots, "default")
+    ]),
+    _: 3
+    /* FORWARDED */
+  }, 16, ["position", "model-value", "type", "message", "duration", "onClick", "onClose", "onMouseenter", "onMouseleave"])) : (openBlock(), createBlock(_component_b_notification, mergeProps({
+    key: 1,
+    ref: "notification",
+    position: _ctx.position,
+    "model-value": _ctx.isActive,
+    type: _ctx.type,
+    message: _ctx.message,
+    duration: _ctx.duration
+  }, _ctx.$attrs, {
+    onClick: _ctx.click,
+    onClose: _ctx.close,
+    onMouseenter: _ctx.pause,
+    onMouseleave: _ctx.removePause
+  }), null, 16, ["position", "model-value", "type", "message", "duration", "onClick", "onClose", "onMouseenter", "onMouseleave"]));
+}
+var NotificationNotice = /* @__PURE__ */ _export_sfc(NotificationNotice$1, [["render", _sfc_render]]);
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+class NotificationProgrammatic {
+  constructor(app) {
+    __publicField(this, "app");
+    this.app = app;
+  }
+  open(params) {
+    if (typeof params === "string") {
+      params = {
+        message: params
+      };
+    }
+    let slot;
+    let _a = params, { message } = _a, restParams = __objRest(_a, ["message"]);
+    if (typeof message !== "string") {
+      slot = message;
+      message = void 0;
+    }
+    const propsData = __spreadValues({
+      position: config.defaultNotificationPosition || "is-top-right",
+      message
+    }, restParams);
+    const container = document.createElement("div");
+    const vueInstance = createApp({
+      data() {
+        return {
+          noticeVNode: null
+        };
+      },
+      methods: {
+        close() {
+          const notice = getComponentFromVNode(this.noticeVNode);
+          if (notice) {
+            notice.close();
+          }
+        }
+      },
+      render() {
+        this.noticeVNode = h(
+          NotificationNotice,
+          __spreadProps(__spreadValues({}, propsData), {
+            onClose: () => {
+              if (propsData.onClose != null) {
+                propsData.onClose();
+              }
+              setTimeout(() => {
+                vueInstance.unmount();
+              }, 150);
+            }
+          }),
+          slot != null ? { default: () => slot } : void 0
+        );
+        return this.noticeVNode;
+      }
+    });
+    if (this.app) {
+      copyAppContext(this.app, vueInstance);
+    } else {
+      vueInstance.config.globalProperties.$buefy = {};
+    }
+    return vueInstance.mount(container);
+  }
+}
+const Plugin = {
+  install(Vue) {
+    registerComponent(Vue, Notification);
+    registerComponentProgrammatic(Vue, "notification", new NotificationProgrammatic(Vue));
+  }
+};
+
+export { Notification as BNotification, NotificationProgrammatic, Plugin as default };

package/dist/esm/numberinput.js

@@ -0,0 +1,381 @@
+import { defineComponent, resolveComponent, createElementBlock, openBlock, mergeProps, createVNode, Fragment, renderList, normalizeClass, createElementVNode, withModifiers } from 'vue';
+import { B as BIcon } from './Icon-DPyGDeRK.js';
+import { B as BInput } from './Input-C4L520az.js';
+import { C as CompatFallthroughMixin } from './CompatFallthroughMixin-C8LPuwDr.js';
+import { F as FormElementMixin } from './FormElementMixin-Dd_wkBN5.js';
+import { _ as _export_sfc } from './_plugin-vue_export-helper-OJRSZE6i.js';
+import { a as registerComponent } from './plugins-B172kuKE.js';
+import './config-CKuo-p6e.js';
+import './helpers.js';
+
+const CONTROLS_ALIGNMENTS = ["left", "right", "center"];
+var _sfc_main = defineComponent({
+  name: "BNumberinput",
+  components: {
+    BIcon,
+    BInput
+  },
+  mixins: [CompatFallthroughMixin, FormElementMixin],
+  inject: {
+    field: {
+      from: "BField",
+      default: false
+    }
+  },
+  props: {
+    modelValue: [Number, null],
+    min: {
+      type: [Number, String]
+    },
+    max: [Number, String],
+    step: [Number, String],
+    minStep: [Number, String],
+    exponential: [Boolean, Number],
+    disabled: Boolean,
+    type: {
+      type: String,
+      default: "is-primary"
+    },
+    editable: {
+      type: Boolean,
+      default: true
+    },
+    controls: {
+      type: Boolean,
+      default: true
+    },
+    controlsAlignment: {
+      type: String,
+      default: "center",
+      validator: (value) => {
+        return CONTROLS_ALIGNMENTS.indexOf(value) >= 0;
+      }
+    },
+    controlsRounded: {
+      type: Boolean,
+      default: false
+    },
+    controlsPosition: String,
+    placeholder: [Number, String],
+    ariaMinusLabel: String,
+    ariaPlusLabel: String,
+    longPress: {
+      type: Boolean,
+      default: true
+    },
+    // Native options to use in HTML5 validation
+    autocomplete: String
+  },
+  emits: {
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    blur: (_event) => true,
+    focus: (_event) => true,
+    "update:modelValue": (_value) => true
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  },
+  data() {
+    return {
+      newValue: this.modelValue,
+      newStep: this.step || 1,
+      newMinStep: this.minStep,
+      timesPressed: 1,
+      _elementRef: "input",
+      _$intervalRef: void 0
+    };
+  },
+  computed: {
+    computedValue: {
+      // getter has to include `string` in the return type so that the
+      // setter can accept `string`
+      get() {
+        return this.newValue;
+      },
+      set(value) {
+        let newValue = Number(value) === 0 ? 0 : Number(value) || null;
+        if (value === "" || value === void 0 || value === null) {
+          newValue = null;
+        }
+        this.newValue = newValue;
+        if (newValue === null) {
+          this.$emit("update:modelValue", newValue);
+        } else if (!isNaN(newValue)) {
+          this.$emit("update:modelValue", Number(newValue));
+        }
+        this.$nextTick(() => {
+          if (this.$refs.input) {
+            this.$refs.input.checkHtml5Validity();
+          }
+        });
+      }
+    },
+    controlsLeft() {
+      if (this.controls && this.controlsAlignment !== "right") {
+        return this.controlsAlignment === "left" ? ["minus", "plus"] : ["minus"];
+      }
+      return [];
+    },
+    controlsRight() {
+      if (this.controls && this.controlsAlignment !== "left") {
+        return this.controlsAlignment === "right" ? ["minus", "plus"] : ["plus"];
+      }
+      return [];
+    },
+    fieldClasses() {
+      return [
+        { "has-addons": this.controlsPosition === "compact" },
+        { "is-grouped": this.controlsPosition !== "compact" },
+        { "is-expanded": this.expanded }
+      ];
+    },
+    buttonClasses() {
+      return [this.type, this.size, { "is-rounded": this.controlsRounded }];
+    },
+    minNumber() {
+      return typeof this.min === "string" ? parseFloat(this.min) : this.min;
+    },
+    maxNumber() {
+      return typeof this.max === "string" ? parseFloat(this.max) : this.max;
+    },
+    stepNumber() {
+      if (this.newStep === "any") {
+        return 1;
+      }
+      return typeof this.newStep === "string" ? parseFloat(this.newStep) : this.newStep;
+    },
+    minStepNumber() {
+      if (this.newStep === "any" && typeof this.newMinStep === "undefined") {
+        return "any";
+      }
+      const step = typeof this.newMinStep !== "undefined" ? this.newMinStep : this.newStep;
+      return typeof step === "string" ? parseFloat(step) : step;
+    },
+    disabledMin() {
+      return +this.computedValue - this.stepNumber < this.minNumber;
+    },
+    disabledMax() {
+      return +this.computedValue + this.stepNumber > this.maxNumber;
+    },
+    stepDecimals() {
+      const step = this.minStepNumber.toString();
+      const index = step.indexOf(".");
+      if (index >= 0) {
+        return step.substring(index + 1).length;
+      }
+      return 0;
+    },
+    disabledOrUndefined() {
+      return this.disabled || void 0;
+    }
+  },
+  watch: {
+    /*
+     * When v-model is changed:
+     *   1. Set internal value.
+     */
+    modelValue: {
+      immediate: true,
+      handler(value) {
+        this.newValue = value;
+      }
+    },
+    step(value) {
+      this.newStep = value;
+    },
+    minStep(value) {
+      this.newMinStep = value;
+    }
+  },
+  methods: {
+    isDisabled(control) {
+      return this.disabled || (control === "plus" ? this.disabledMax : this.disabledMin);
+    },
+    decrement() {
+      if (this.computedValue === null || typeof this.computedValue === "undefined") {
+        if (this.maxNumber !== null && typeof this.maxNumber !== "undefined") {
+          this.computedValue = this.maxNumber;
+          return;
+        }
+        this.computedValue = 0;
+      }
+      if (typeof this.minNumber === "undefined" || +this.computedValue - this.stepNumber >= this.minNumber) {
+        const value = +this.computedValue - this.stepNumber;
+        this.computedValue = parseFloat(value.toFixed(this.stepDecimals));
+      }
+    },
+    increment() {
+      if (this.computedValue === null || typeof this.computedValue === "undefined" || +this.computedValue < this.minNumber) {
+        if (this.minNumber !== null && typeof this.minNumber !== "undefined") {
+          this.computedValue = this.minNumber;
+          return;
+        }
+        this.computedValue = 0;
+      }
+      if (typeof this.maxNumber === "undefined" || +this.computedValue + this.stepNumber <= this.maxNumber) {
+        const value = +this.computedValue + this.stepNumber;
+        this.computedValue = parseFloat(value.toFixed(this.stepDecimals));
+      }
+    },
+    onControlClick(event, inc) {
+      if (event.detail !== 0 || event.type !== "click") return;
+      if (inc) this.increment();
+      else this.decrement();
+    },
+    longPressTick(inc) {
+      if (inc) this.increment();
+      else this.decrement();
+      if (!this.longPress) return;
+      this._$intervalRef = setTimeout(() => {
+        this.longPressTick(inc);
+      }, this.exponential ? 250 / (+this.exponential * this.timesPressed++) : 250);
+    },
+    onStartLongPress(event, inc) {
+      if (event.button !== 0 && event.type !== "touchstart") return;
+      clearTimeout(this._$intervalRef);
+      this.longPressTick(inc);
+    },
+    onStopLongPress() {
+      if (!this._$intervalRef) return;
+      this.timesPressed = 1;
+      clearTimeout(this._$intervalRef);
+      this._$intervalRef = void 0;
+    }
+  },
+  mounted() {
+    if (this.field === this.$parent) {
+      this.$parent.wrapNumberinput({
+        controlsPosition: this.controlsPosition,
+        size: this.size
+      });
+    }
+  },
+  beforeUnmount() {
+    clearTimeout(this._$intervalRef);
+  }
+});
+
+const _hoisted_1 = ["disabled", "aria-label", "onMousedown", "onTouchstart", "onClick"];
+const _hoisted_2 = ["disabled", "aria-label", "onMousedown", "onTouchstart", "onClick"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_b_icon = resolveComponent("b-icon");
+  const _component_b_input = resolveComponent("b-input");
+  return openBlock(), createElementBlock(
+    "div",
+    mergeProps({
+      class: ["b-numberinput field", _ctx.fieldClasses]
+    }, _ctx.rootAttrs),
+    [
+      (openBlock(true), createElementBlock(
+        Fragment,
+        null,
+        renderList(_ctx.controlsLeft, (control) => {
+          return openBlock(), createElementBlock(
+            "p",
+            {
+              key: control,
+              class: normalizeClass(["control", control]),
+              onMouseup: _cache[0] || (_cache[0] = (...args) => _ctx.onStopLongPress && _ctx.onStopLongPress(...args)),
+              onMouseleave: _cache[1] || (_cache[1] = (...args) => _ctx.onStopLongPress && _ctx.onStopLongPress(...args)),
+              onTouchend: _cache[2] || (_cache[2] = (...args) => _ctx.onStopLongPress && _ctx.onStopLongPress(...args)),
+              onTouchcancel: _cache[3] || (_cache[3] = (...args) => _ctx.onStopLongPress && _ctx.onStopLongPress(...args))
+            },
+            [
+              createElementVNode("button", {
+                type: "button",
+                class: normalizeClass(["button", _ctx.buttonClasses]),
+                disabled: _ctx.isDisabled(control) || void 0,
+                "aria-label": control === "plus" ? _ctx.ariaPlusLabel : _ctx.ariaMinusLabel,
+                onMousedown: ($event) => !_ctx.isDisabled(control) && _ctx.onStartLongPress($event, control === "plus"),
+                onTouchstart: withModifiers(($event) => !_ctx.isDisabled(control) && _ctx.onStartLongPress($event, control === "plus"), ["prevent"]),
+                onClick: ($event) => !_ctx.isDisabled(control) && _ctx.onControlClick($event, control === "plus")
+              }, [
+                createVNode(_component_b_icon, {
+                  both: "",
+                  icon: control,
+                  pack: _ctx.iconPack,
+                  size: _ctx.iconSize
+                }, null, 8, ["icon", "pack", "size"])
+              ], 42, _hoisted_1)
+            ],
+            34
+            /* CLASS, NEED_HYDRATION */
+          );
+        }),
+        128
+        /* KEYED_FRAGMENT */
+      )),
+      createVNode(_component_b_input, mergeProps({
+        type: "number",
+        ref: "input",
+        modelValue: _ctx.computedValue,
+        "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => _ctx.computedValue = $event)
+      }, _ctx.fallthroughAttrs, {
+        step: _ctx.minStepNumber,
+        max: _ctx.max,
+        min: _ctx.min,
+        size: _ctx.size,
+        disabled: _ctx.disabledOrUndefined,
+        readonly: !_ctx.editable,
+        loading: _ctx.loading,
+        rounded: _ctx.rounded,
+        icon: _ctx.icon,
+        "icon-pack": _ctx.iconPack,
+        autocomplete: _ctx.autocomplete,
+        expanded: _ctx.expanded,
+        placeholder: _ctx.placeholder,
+        "use-html5-validation": _ctx.useHtml5Validation,
+        onFocus: _cache[5] || (_cache[5] = ($event) => _ctx.$emit("focus", $event)),
+        onBlur: _cache[6] || (_cache[6] = ($event) => _ctx.$emit("blur", $event))
+      }), null, 16, ["modelValue", "step", "max", "min", "size", "disabled", "readonly", "loading", "rounded", "icon", "icon-pack", "autocomplete", "expanded", "placeholder", "use-html5-validation"]),
+      (openBlock(true), createElementBlock(
+        Fragment,
+        null,
+        renderList(_ctx.controlsRight, (control) => {
+          return openBlock(), createElementBlock(
+            "p",
+            {
+              key: control,
+              class: normalizeClass(["control", control]),
+              onMouseup: _cache[7] || (_cache[7] = (...args) => _ctx.onStopLongPress && _ctx.onStopLongPress(...args)),
+              onMouseleave: _cache[8] || (_cache[8] = (...args) => _ctx.onStopLongPress && _ctx.onStopLongPress(...args)),
+              onTouchend: _cache[9] || (_cache[9] = (...args) => _ctx.onStopLongPress && _ctx.onStopLongPress(...args)),
+              onTouchcancel: _cache[10] || (_cache[10] = (...args) => _ctx.onStopLongPress && _ctx.onStopLongPress(...args))
+            },
+            [
+              createElementVNode("button", {
+                type: "button",
+                class: normalizeClass(["button", _ctx.buttonClasses]),
+                disabled: _ctx.isDisabled(control) || void 0,
+                "aria-label": control === "plus" ? _ctx.ariaPlusLabel : _ctx.ariaMinusLabel,
+                onMousedown: ($event) => !_ctx.isDisabled(control) && _ctx.onStartLongPress($event, control === "plus"),
+                onTouchstart: withModifiers(($event) => !_ctx.isDisabled(control) && _ctx.onStartLongPress($event, control === "plus"), ["prevent"]),
+                onClick: ($event) => !_ctx.isDisabled(control) && _ctx.onControlClick($event, control === "plus")
+              }, [
+                createVNode(_component_b_icon, {
+                  both: "",
+                  icon: control,
+                  pack: _ctx.iconPack,
+                  size: _ctx.iconSize
+                }, null, 8, ["icon", "pack", "size"])
+              ], 42, _hoisted_2)
+            ],
+            34
+            /* CLASS, NEED_HYDRATION */
+          );
+        }),
+        128
+        /* KEYED_FRAGMENT */
+      ))
+    ],
+    16
+    /* FULL_PROPS */
+  );
+}
+var Numberinput = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+
+const Plugin = {
+  install(Vue) {
+    registerComponent(Vue, Numberinput);
+  }
+};
+
+export { Numberinput as BNumberinput, Plugin as default };

package/dist/esm/pagination.js

@@ -0,0 +1,16 @@
+import { B as BPagination, P as PaginationButton } from './Pagination-B-LAJQay.js';
+import { a as registerComponent } from './plugins-B172kuKE.js';
+import 'vue';
+import './config-CKuo-p6e.js';
+import './_plugin-vue_export-helper-OJRSZE6i.js';
+import './Icon-DPyGDeRK.js';
+import './helpers.js';
+
+const Plugin = {
+  install(Vue) {
+    registerComponent(Vue, BPagination);
+    registerComponent(Vue, PaginationButton);
+  }
+};
+
+export { BPagination, PaginationButton as BPaginationButton, Plugin as default };

package/dist/esm/plugins-B172kuKE.js

@@ -0,0 +1,13 @@
+const registerComponent = (Vue, component, name) => {
+  const componentName = name || component.name;
+  if (componentName == null) {
+    throw new Error("Buefy.registerComponent: missing component name");
+  }
+  Vue.component(componentName, component);
+};
+const registerComponentProgrammatic = (Vue, property, component) => {
+  if (!Vue.config.globalProperties.$buefy) Vue.config.globalProperties.$buefy = {};
+  Vue.config.globalProperties.$buefy[property] = component;
+};
+
+export { registerComponent as a, registerComponentProgrammatic as r };