text: 'use strict';Object.defineProperty(exports,'__esModule',{value:true});//
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  
  var script = {
    name: 'VueDashes',
    props: {
      color: {
        type: String,
        default: '#000',
      },
      numDashes: {
        type: Number,
        default: 10,
        validator: function (value) { return value > 0; },
      },
      dashHeight: {
        type: Number,
        default: 1,
      },
      dashLength: {
        type: Number,
        default: 1,
      },
      spaceLength: {
        type: Number,
        default: 1,
      },
    },
    data: function data() {
      return {
        lineStyles: {
          stroke: this.color,
          'stroke-width': this.dashHeight,
          'stroke-dasharray': ((this.dashLength) + " " + (this.spaceLength)),
        },
      }
    },
    computed: {
      svgWidth: function svgWidth() {
        return this.numDashes * this.dashLength + (this.numDashes - 1) * this.spaceLength
      },
      svgStyles: function svgStyles() {
        return {
          width: this.svgWidth,
          height: this.dashHeight,
        }
      },
    },
  };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 */
  var __vue_script__ = script;
  
  /* template */
  var __vue_render__ = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('svg',{style:(_vm.svgStyles),attrs:{"xmlns":"http://www.w3.org/2000/svg"}},[_vm._ssrNode("<line x1=\"0\""+(_vm._ssrAttr("y1",_vm.dashHeight/2))+(_vm._ssrAttr("x2",_vm.svgWidth))+(_vm._ssrAttr("y2",_vm.dashHeight/2))+(_vm._ssrStyle(null,_vm.lineStyles, null))+"></line>")])};
  var __vue_staticRenderFns__ = [];
  
    /* style */
    var __vue_inject_styles__ = undefined;
    /* scoped */
    var __vue_scope_id__ = undefined;
    /* module identifier */
    var __vue_module_identifier__ = "data-v-02b3e672";
    /* functional template */
    var __vue_is_functional_template__ = false;
    /* style inject */
    
    /* style inject SSR */
    
  
    
    var component = 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
    );// install function executed by Vue.use()
  function install(Vue) {
    if (install.installed) { return }
    install.installed = true;
    Vue.component('VueDashes', component);
  }
  
  // Create module definition for Vue.use()
  var plugin = {
    install: install,
  };
  
  // To auto-install when vue is found
  var GlobalVue = null;
  if (typeof window !== 'undefined') {
    GlobalVue = window.Vue;
  } else if (typeof global !== 'undefined') {
    GlobalVue = global.Vue;
  }
  if (GlobalVue) {
    GlobalVue.use(plugin);
  }
  
  // Inject install function into component - allows component
  // to be registered via Vue.use() as well as Vue.component()
  component.install = install;exports.default=component;