buefy 1.0.0 → 1.0.2

package/dist/cjs/notification.js

@@ -0,0 +1,281 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var Icon = require('./Icon-lsDKE2wQ.js');
+var Progress = require('./Progress-DT9Qc8Id.js');
+var MessageMixin = require('./MessageMixin-bGuuzfev.js');
+var _pluginVue_exportHelper = require('./_plugin-vue_export-helper-Die8u8yB.js');
+var config = require('./config-DR826Ki2.js');
+var helpers = require('./helpers.js');
+var NoticeMixin = require('./NoticeMixin--3RjH43z.js');
+var plugins = require('./plugins-DbyYGVpp.js');
+
+const Notification$1 = vue.defineComponent({
+  name: "BNotification",
+  components: {
+    BIcon: Icon.BIcon,
+    // directly registers Progress
+    // in case Notification is programmatically opened
+    BProgress: Progress.Progress
+  },
+  mixins: [MessageMixin.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 = vue.resolveComponent("b-icon");
+  const _component_b_progress = vue.resolveComponent("b-progress");
+  return vue.openBlock(), vue.createBlock(vue.Transition, {
+    name: _ctx.animation,
+    persisted: ""
+  }, {
+    default: vue.withCtx(() => [
+      vue.withDirectives(vue.createElementVNode(
+        "article",
+        {
+          class: vue.normalizeClass(["notification", [_ctx.type, _ctx.position]]),
+          onClick: _cache[1] || (_cache[1] = (...args) => _ctx.click && _ctx.click(...args))
+        },
+        [
+          _ctx.closable ? (vue.openBlock(), vue.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)) : vue.createCommentVNode("v-if", true),
+          _ctx.$slots.default || _ctx.message ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
+            _ctx.computedIcon && _ctx.hasIcon ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3, [
+              vue.createVNode(_component_b_icon, {
+                icon: _ctx.computedIcon,
+                pack: _ctx.iconPack,
+                size: _ctx.newIconSize,
+                both: "",
+                "aria-hidden": ""
+              }, null, 8, ["icon", "pack", "size"])
+            ])) : vue.createCommentVNode("v-if", true),
+            vue.createElementVNode("div", _hoisted_4, [
+              _ctx.$slots.default ? vue.renderSlot(_ctx.$slots, "default", { key: 0 }) : (vue.openBlock(), vue.createElementBlock(
+                vue.Fragment,
+                { key: 1 },
+                [
+                  vue.createCommentVNode(" eslint-disable-next-line vue/no-v-html "),
+                  vue.createElementVNode("p", {
+                    class: "text",
+                    innerHTML: _ctx.message
+                  }, null, 8, _hoisted_5)
+                ],
+                64
+                /* STABLE_FRAGMENT */
+              ))
+            ])
+          ])) : vue.createCommentVNode("v-if", true),
+          _ctx.progressBar ? (vue.openBlock(), vue.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"])) : vue.createCommentVNode("v-if", true)
+        ],
+        2
+        /* CLASS */
+      ), [
+        [vue.vShow, _ctx.isActive]
+      ])
+    ]),
+    _: 3
+    /* FORWARDED */
+  }, 8, ["name"]);
+}
+var Notification = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(Notification$1, [["render", _sfc_render$1]]);
+
+const NotificationNotice$1 = vue.defineComponent({
+  name: "BNotificationNotice",
+  components: { BNotification: Notification },
+  mixins: [NoticeMixin.NoticeMixin],
+  data() {
+    return {
+      newDuration: this.duration || config.config.defaultNotificationDuration
+    };
+  },
+  emits: {
+    close: () => true
+  },
+  methods: {
+    close() {
+      if (!this.isPaused) {
+        clearTimeout(this.timer);
+        this.$refs.notification.isActive = false;
+        this.$emit("close");
+        setTimeout(() => {
+          helpers.removeElement(this.$el);
+        }, 150);
+      }
+    }
+  }
+});
+
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_b_notification = vue.resolveComponent("b-notification");
+  return _ctx.$slots.default != null ? (vue.openBlock(), vue.createBlock(_component_b_notification, vue.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: vue.withCtx(() => [
+      vue.renderSlot(_ctx.$slots, "default")
+    ]),
+    _: 3
+    /* FORWARDED */
+  }, 16, ["position", "model-value", "type", "message", "duration", "onClick", "onClose", "onMouseenter", "onMouseleave"])) : (vue.openBlock(), vue.createBlock(_component_b_notification, vue.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__ */ _pluginVue_exportHelper._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.config.defaultNotificationPosition || "is-top-right",
+      message
+    }, restParams);
+    const container = document.createElement("div");
+    const vueInstance = vue.createApp({
+      data() {
+        return {
+          noticeVNode: null
+        };
+      },
+      methods: {
+        close() {
+          const notice = helpers.getComponentFromVNode(this.noticeVNode);
+          if (notice) {
+            notice.close();
+          }
+        }
+      },
+      render() {
+        this.noticeVNode = vue.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) {
+      helpers.copyAppContext(this.app, vueInstance);
+    } else {
+      vueInstance.config.globalProperties.$buefy = {};
+    }
+    return vueInstance.mount(container);
+  }
+}
+const Plugin = {
+  install(Vue) {
+    plugins.registerComponent(Vue, Notification);
+    plugins.registerComponentProgrammatic(Vue, "notification", new NotificationProgrammatic(Vue));
+  }
+};
+
+exports.BNotification = Notification;
+exports.NotificationProgrammatic = NotificationProgrammatic;
+exports.default = Plugin;

package/dist/cjs/numberinput.js

@@ -0,0 +1,386 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var Icon = require('./Icon-lsDKE2wQ.js');
+var Input = require('./Input-BcloGeZ3.js');
+var CompatFallthroughMixin = require('./CompatFallthroughMixin-hhK0Gkhr.js');
+var FormElementMixin = require('./FormElementMixin-DavX4iOv.js');
+var _pluginVue_exportHelper = require('./_plugin-vue_export-helper-Die8u8yB.js');
+var plugins = require('./plugins-DbyYGVpp.js');
+require('./config-DR826Ki2.js');
+require('./helpers.js');
+
+const CONTROLS_ALIGNMENTS = ["left", "right", "center"];
+var _sfc_main = vue.defineComponent({
+  name: "BNumberinput",
+  components: {
+    BIcon: Icon.BIcon,
+    BInput: Input.BInput
+  },
+  mixins: [CompatFallthroughMixin.CompatFallthroughMixin, FormElementMixin.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 = vue.resolveComponent("b-icon");
+  const _component_b_input = vue.resolveComponent("b-input");
+  return vue.openBlock(), vue.createElementBlock(
+    "div",
+    vue.mergeProps({
+      class: ["b-numberinput field", _ctx.fieldClasses]
+    }, _ctx.rootAttrs),
+    [
+      (vue.openBlock(true), vue.createElementBlock(
+        vue.Fragment,
+        null,
+        vue.renderList(_ctx.controlsLeft, (control) => {
+          return vue.openBlock(), vue.createElementBlock(
+            "p",
+            {
+              key: control,
+              class: vue.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))
+            },
+            [
+              vue.createElementVNode("button", {
+                type: "button",
+                class: vue.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: vue.withModifiers(($event) => !_ctx.isDisabled(control) && _ctx.onStartLongPress($event, control === "plus"), ["prevent"]),
+                onClick: ($event) => !_ctx.isDisabled(control) && _ctx.onControlClick($event, control === "plus")
+              }, [
+                vue.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 */
+      )),
+      vue.createVNode(_component_b_input, vue.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"]),
+      (vue.openBlock(true), vue.createElementBlock(
+        vue.Fragment,
+        null,
+        vue.renderList(_ctx.controlsRight, (control) => {
+          return vue.openBlock(), vue.createElementBlock(
+            "p",
+            {
+              key: control,
+              class: vue.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))
+            },
+            [
+              vue.createElementVNode("button", {
+                type: "button",
+                class: vue.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: vue.withModifiers(($event) => !_ctx.isDisabled(control) && _ctx.onStartLongPress($event, control === "plus"), ["prevent"]),
+                onClick: ($event) => !_ctx.isDisabled(control) && _ctx.onControlClick($event, control === "plus")
+              }, [
+                vue.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__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render]]);
+
+const Plugin = {
+  install(Vue) {
+    plugins.registerComponent(Vue, Numberinput);
+  }
+};
+
+exports.BNumberinput = Numberinput;
+exports.default = Plugin;

package/dist/cjs/pagination.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Pagination = require('./Pagination-D1MVdiLp.js');
+var plugins = require('./plugins-DbyYGVpp.js');
+require('vue');
+require('./config-DR826Ki2.js');
+require('./_plugin-vue_export-helper-Die8u8yB.js');
+require('./Icon-lsDKE2wQ.js');
+require('./helpers.js');
+
+const Plugin = {
+  install(Vue) {
+    plugins.registerComponent(Vue, Pagination.BPagination);
+    plugins.registerComponent(Vue, Pagination.PaginationButton);
+  }
+};
+
+exports.BPagination = Pagination.BPagination;
+exports.BPaginationButton = Pagination.PaginationButton;
+exports.default = Plugin;

package/dist/cjs/plugins-DbyYGVpp.js

@@ -0,0 +1,16 @@
+'use strict';
+
+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;
+};
+
+exports.registerComponent = registerComponent;
+exports.registerComponentProgrammatic = registerComponentProgrammatic;