text: /*! Buefy v0.9.4 | MIT License | github.com/buefy/buefy */
  (function (global, factory) {
      typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
      typeof define === 'function' && define.amd ? define(['exports'], factory) :
      (global = global || self, factory(global.Radio = {}));
  }(this, function (exports) { 'use strict';
  
      var CheckRadioMixin = {
        props: {
          value: [String, Number, Boolean, Function, Object, Array],
          nativeValue: [String, Number, Boolean, Function, Object, Array],
          type: String,
          disabled: Boolean,
          required: Boolean,
          name: String,
          size: String
        },
        data: function data() {
          return {
            newValue: this.value
          };
        },
        computed: {
          computedValue: {
            get: function get() {
              return this.newValue;
            },
            set: function set(value) {
              this.newValue = value;
              this.$emit('input', value);
            }
          }
        },
        watch: {
          /**
          * When v-model change, set internal value.
          */
          value: function value(_value) {
            this.newValue = _value;
          }
        },
        methods: {
          focus: function focus() {
            // MacOS FireFox and Safari do not focus when clicked
            this.$refs.input.focus();
          }
        }
      };
  
      //
      var script = {
        name: 'BRadio',
        mixins: [CheckRadioMixin]
      };
  
      function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier
      /* server only */
      , shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {
        if (typeof shadowMode !== 'boolean') {
          createInjectorSSR = createInjector;
          createInjector = shadowMode;
          shadowMode = false;
        } // Vue.extend constructor export interop.
  
  
        var options = typeof script === 'function' ? script.options : script; // render functions
  
        if (template && template.render) {
          options.render = template.render;
          options.staticRenderFns = template.staticRenderFns;
          options._compiled = true; // functional template
  
          if (isFunctionalTemplate) {
            options.functional = true;
          }
        } // scopedId
  
  
        if (scopeId) {
          options._scopeId = scopeId;
        }
  
        var hook;
  
        if (moduleIdentifier) {
          // server build
          hook = function hook(context) {
            // 2.3 injection
            context = context || // cached call
            this.$vnode && this.$vnode.ssrContext || // stateful
            this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext; // functional
            // 2.2 with runInNewContext: true
  
            if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
              context = __VUE_SSR_CONTEXT__;
            } // inject component styles
  
  
            if (style) {
              style.call(this, createInjectorSSR(context));
            } // register component module identifier for async chunk inference
  
  
            if (context && context._registeredComponents) {
              context._registeredComponents.add(moduleIdentifier);
            }
          }; // used by ssr in case component is cached and beforeCreate
          // never gets called
  
  
          options._ssrRegister = hook;
        } else if (style) {
          hook = shadowMode ? function () {
            style.call(this, createInjectorShadow(this.$root.$options.shadowRoot));
          } : function (context) {
            style.call(this, createInjector(context));
          };
        }
  
        if (hook) {
          if (options.functional) {
            // register for functional component in vue file
            var originalRender = options.render;
  
            options.render = function renderWithStyleInjection(h, context) {
              hook.call(context);
              return originalRender(h, context);
            };
          } else {
            // inject component registration as beforeCreate hook
            var existing = options.beforeCreate;
            options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
          }
        }
  
        return script;
      }
  
      var normalizeComponent_1 = normalizeComponent;
  
      /* script */
      const __vue_script__ = script;
  
      /* template */
      var __vue_render__ = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('label',{ref:"label",staticClass:"b-radio radio",class:[_vm.size, { 'is-disabled': _vm.disabled }],attrs:{"disabled":_vm.disabled},on:{"click":_vm.focus,"keydown":function($event){if(!$event.type.indexOf('key')&&_vm._k($event.keyCode,"enter",13,$event.key,"Enter")){ return null; }$event.preventDefault();return _vm.$refs.label.click()}}},[_c('input',{directives:[{name:"model",rawName:"v-model",value:(_vm.computedValue),expression:"computedValue"}],ref:"input",attrs:{"type":"radio","disabled":_vm.disabled,"required":_vm.required,"name":_vm.name},domProps:{"value":_vm.nativeValue,"checked":_vm._q(_vm.computedValue,_vm.nativeValue)},on:{"click":function($event){$event.stopPropagation();},"change":function($event){_vm.computedValue=_vm.nativeValue;}}}),_c('span',{staticClass:"check",class:_vm.type}),_c('span',{staticClass:"control-label"},[_vm._t("default")],2)])};
      var __vue_staticRenderFns__ = [];
  
        /* style */
        const __vue_inject_styles__ = undefined;
        /* scoped */
        const __vue_scope_id__ = undefined;
        /* module identifier */
        const __vue_module_identifier__ = undefined;
        /* functional template */
        const __vue_is_functional_template__ = false;
        /* style inject */
        
        /* style inject SSR */
        
  
        
        var Radio = normalizeComponent_1(
          { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },
          __vue_inject_styles__,
          __vue_script__,
          __vue_scope_id__,
          __vue_is_functional_template__,
          __vue_module_identifier__,
          undefined,
          undefined
        );
  
      //
      var script$1 = {
        name: 'BRadioButton',
        mixins: [CheckRadioMixin],
        props: {
          type: {
            type: String,
            default: 'is-primary'
          },
          expanded: Boolean
        },
        data: function data() {
          return {
            isFocused: false
          };
        }
      };
  
      /* script */
      const __vue_script__$1 = script$1;
  
      /* template */
      var __vue_render__$1 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:"control",class:{ 'is-expanded': _vm.expanded }},[_c('label',{ref:"label",staticClass:"b-radio radio button",class:[_vm.newValue === _vm.nativeValue ? _vm.type : null, _vm.size, {
                  'is-disabled': _vm.disabled,
                  'is-focused': _vm.isFocused
              }],attrs:{"disabled":_vm.disabled},on:{"click":_vm.focus,"keydown":function($event){if(!$event.type.indexOf('key')&&_vm._k($event.keyCode,"enter",13,$event.key,"Enter")){ return null; }$event.preventDefault();return _vm.$refs.label.click()}}},[_vm._t("default"),_c('input',{directives:[{name:"model",rawName:"v-model",value:(_vm.computedValue),expression:"computedValue"}],ref:"input",attrs:{"type":"radio","disabled":_vm.disabled,"required":_vm.required,"name":_vm.name},domProps:{"value":_vm.nativeValue,"checked":_vm._q(_vm.computedValue,_vm.nativeValue)},on:{"click":function($event){$event.stopPropagation();},"focus":function($event){_vm.isFocused = true;},"blur":function($event){_vm.isFocused = false;},"change":function($event){_vm.computedValue=_vm.nativeValue;}}})],2)])};
      var __vue_staticRenderFns__$1 = [];
  
        /* style */
        const __vue_inject_styles__$1 = undefined;
        /* scoped */
        const __vue_scope_id__$1 = undefined;
        /* module identifier */
        const __vue_module_identifier__$1 = undefined;
        /* functional template */
        const __vue_is_functional_template__$1 = false;
        /* style inject */
        
        /* style inject SSR */
        
  
        
        var RadioButton = normalizeComponent_1(
          { render: __vue_render__$1, staticRenderFns: __vue_staticRenderFns__$1 },
          __vue_inject_styles__$1,
          __vue_script__$1,
          __vue_scope_id__$1,
          __vue_is_functional_template__$1,
          __vue_module_identifier__$1,
          undefined,
          undefined
        );
  
      var use = function use(plugin) {
        if (typeof window !== 'undefined' && window.Vue) {
          window.Vue.use(plugin);
        }
      };
      var registerComponent = function registerComponent(Vue, component) {
        Vue.component(component.name, component);
      };
  
      var Plugin = {
        install: function install(Vue) {
          registerComponent(Vue, Radio);
          registerComponent(Vue, RadioButton);
        }
      };
      use(Plugin);
  
      exports.BRadio = Radio;
      exports.BRadioButton = RadioButton;
      exports.default = Plugin;
  
      Object.defineProperty(exports, '__esModule', { value: true });
  
  }));
  