text: (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory();
  	else if(typeof define === 'function' && define.amd)
  		define([], factory);
  	else if(typeof exports === 'object')
  		exports["VueMaterial"] = factory();
  	else
  		root["VueMaterial"] = factory();
  })(this, (function() {
  return /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, {
  /******/ 				configurable: false,
  /******/ 				enumerable: true,
  /******/ 				get: getter
  /******/ 			});
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "/";
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 464);
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ 0:
  /***/ (function(module, exports) {
  
  /* globals __VUE_SSR_CONTEXT__ */
  
  // this module is a runtime utility for cleaner component module output and will
  // be included in the final webpack user bundle
  
  module.exports = function normalizeComponent (
    rawScriptExports,
    compiledTemplate,
    injectStyles,
    scopeId,
    moduleIdentifier /* server only */
  ) {
    var esModule
    var scriptExports = rawScriptExports = rawScriptExports || {}
  
    // ES6 modules interop
    var type = typeof rawScriptExports.default
    if (type === 'object' || type === 'function') {
      esModule = rawScriptExports
      scriptExports = rawScriptExports.default
    }
  
    // Vue.extend constructor export interop
    var options = typeof scriptExports === 'function'
      ? scriptExports.options
      : scriptExports
  
    // render functions
    if (compiledTemplate) {
      options.render = compiledTemplate.render
      options.staticRenderFns = compiledTemplate.staticRenderFns
    }
  
    // scopedId
    if (scopeId) {
      options._scopeId = scopeId
    }
  
    var hook
    if (moduleIdentifier) { // server build
      hook = function (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 (injectStyles) {
          injectStyles.call(this, context)
        }
        // register component module identifier for async chunk inferrence
        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 (injectStyles) {
      hook = injectStyles
    }
  
    if (hook) {
      var functional = options.functional
      var existing = functional
        ? options.render
        : options.beforeCreate
      if (!functional) {
        // inject component registration as beforeCreate hook
        options.beforeCreate = existing
          ? [].concat(existing, hook)
          : [hook]
      } else {
        // register for functioal component in vue file
        options.render = function renderWithStyleInjection (h, context) {
          hook.call(context)
          return existing(h, context)
        }
      }
    }
  
    return {
      esModule: esModule,
      exports: scriptExports,
      options: options
    }
  }
  
  
  /***/ }),
  
  /***/ 11:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var getClosestVueParent = function getClosestVueParent($parent, cssClass) {
    if (!$parent || !$parent.$el) {
      return false;
    }
  
    if ($parent._uid === 0) {
      return false;
    }
  
    if ($parent.$el.classList.contains(cssClass)) {
      return $parent;
    }
  
    return getClosestVueParent($parent.$parent, cssClass);
  };
  
  exports.default = getClosestVueParent;
  module.exports = exports["default"];
  
  /***/ }),
  
  /***/ 287:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = install;
  
  var _mdMenu = __webpack_require__(288);
  
  var _mdMenu2 = _interopRequireDefault(_mdMenu);
  
  var _mdMenuItem = __webpack_require__(293);
  
  var _mdMenuItem2 = _interopRequireDefault(_mdMenuItem);
  
  var _mdMenuContent = __webpack_require__(297);
  
  var _mdMenuContent2 = _interopRequireDefault(_mdMenuContent);
  
  var _mdMenu3 = __webpack_require__(300);
  
  var _mdMenu4 = _interopRequireDefault(_mdMenu3);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  function install(Vue) {
    Vue.component('md-menu', _mdMenu2.default);
    Vue.component('md-menu-item', _mdMenuItem2.default);
    Vue.component('md-menu-content', _mdMenuContent2.default);
  
    Vue.material.styles.push(_mdMenu4.default);
  }
  module.exports = exports['default'];
  
  /***/ }),
  
  /***/ 288:
  /***/ (function(module, exports, __webpack_require__) {
  
  var disposed = false
  function injectStyle (ssrContext) {
    if (disposed) return
    __webpack_require__(289)
  }
  var Component = __webpack_require__(0)(
    /* script */
    __webpack_require__(290),
    /* template */
    __webpack_require__(292),
    /* styles */
    injectStyle,
    /* scopeId */
    null,
    /* moduleIdentifier (server only) */
    null
  )
  Component.options.__file = "C:\\Work\\Github\\Vue-Material\\trunk\\src\\components\\mdMenu\\mdMenu.vue"
  if (Component.esModule && Object.keys(Component.esModule).some((function (key) {return key !== "default" && key.substr(0, 2) !== "__"}))) {console.error("named exports are not supported in *.vue files.")}
  if (Component.options.functional) {console.error("[vue-loader] mdMenu.vue: functional components are not supported with templates, they should use render functions.")}
  
  /* hot reload */
  if (false) {(function () {
    var hotAPI = require("vue-hot-reload-api")
    hotAPI.install(require("vue"), false)
    if (!hotAPI.compatible) return
    module.hot.accept()
    if (!module.hot.data) {
      hotAPI.createRecord("data-v-0e0b5d4a", Component.options)
    } else {
      hotAPI.reload("data-v-0e0b5d4a", Component.options)
    }
    module.hot.dispose((function (data) {
      disposed = true
    }))
  })()}
  
  module.exports = Component.exports
  
  
  /***/ }),
  
  /***/ 289:
  /***/ (function(module, exports) {
  
  // removed by extract-text-webpack-plugin
  
  /***/ }),
  
  /***/ 290:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  var _transitionEndEventName = __webpack_require__(42);
  
  var _transitionEndEventName2 = _interopRequireDefault(_transitionEndEventName);
  
  var _getInViewPosition = __webpack_require__(291);
  
  var _getInViewPosition2 = _interopRequireDefault(_getInViewPosition);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  
  exports.default = {
    name: 'md-menu',
    props: {
      mdSize: {
        type: [Number, String],
        default: 0
      },
      mdDirection: {
        type: String,
        default: 'bottom right'
      },
      mdAlignTrigger: {
        type: Boolean,
        default: false
      },
      mdOffsetX: {
        type: [Number, String],
        default: 0
      },
      mdOffsetY: {
        type: [Number, String],
        default: 0
      },
      mdCloseOnSelect: {
        type: Boolean,
        default: true
      },
      mdAutoWidth: {
        type: Boolean,
        default: false
      },
      mdFixed: {
        type: Boolean,
        default: false
      },
      mdNoFocus: {
        type: Boolean,
        default: false
      },
      mdManualToggle: {
        type: Boolean,
        default: false
      },
      mdMaxHeight: {
        type: Number,
        default: 0
      }
    },
    data: function data() {
      return {
        active: false
      };
    },
    watch: {
      mdSize: function mdSize(current, previous) {
        if (current >= 1 && current <= 7) {
          this.removeLastSizeMenuContentClass(previous);
          this.addNewSizeMenuContentClass(current);
        }
      },
      mdDirection: function mdDirection(current, previous) {
        this.removeLastDirectionMenuContentClass(previous);
        this.addNewDirectionMenuContentClass(current);
      },
      mdAlignTrigger: function mdAlignTrigger(trigger) {
        this.handleAlignTriggerClass(trigger);
      }
    },
    methods: {
      validateMenu: function validateMenu() {
        if (!this.menuContent) {
          this.$destroy();
  
          throw new Error('You must have a md-menu-content inside your menu.');
        }
  
        if (!this.menuTrigger) {
          this.$destroy();
  
          throw new Error('You must have an element with a md-menu-trigger attribute inside your menu.');
        }
      },
      removeLastSizeMenuContentClass: function removeLastSizeMenuContentClass(size) {
        this.menuContent.classList.remove('md-size-' + size);
      },
      removeLastDirectionMenuContentClass: function removeLastDirectionMenuContentClass(direction) {
        this.menuContent.classList.remove('md-direction-' + direction.replace(/ /g, '-'));
      },
      addNewSizeMenuContentClass: function addNewSizeMenuContentClass(size) {
        this.menuContent.classList.add('md-size-' + size);
      },
      addNewDirectionMenuContentClass: function addNewDirectionMenuContentClass(direction) {
        this.menuContent.classList.add('md-direction-' + direction.replace(/ /g, '-'));
      },
      handleAlignTriggerClass: function handleAlignTriggerClass(trigger) {
        if (trigger) {
          this.menuContent.classList.add('md-align-trigger');
        }
      },
      getPosition: function getPosition(vertical, horizontal) {
        var menuTriggerRect = this.menuTrigger.getBoundingClientRect();
  
        var top = vertical === 'top' ? menuTriggerRect.top + menuTriggerRect.height - this.menuContent.offsetHeight : menuTriggerRect.top;
  
        var left = horizontal === 'left' ? menuTriggerRect.left - this.menuContent.offsetWidth + menuTriggerRect.width : menuTriggerRect.left;
  
        top += parseInt(this.mdOffsetY, 10);
        left += parseInt(this.mdOffsetX, 10);
  
        if (this.mdAlignTrigger) {
          if (vertical === 'top') {
            top -= menuTriggerRect.height + 11;
          } else {
            top += menuTriggerRect.height + 11;
          }
        }
  
        return { top: top, left: left };
      },
      calculateMenuContentPos: function calculateMenuContentPos() {
        var position = void 0;
        var width = void 0;
  
        var margin = 8;
  
        if (this._destroyed) {
          return;
        }
  
        if (!this.mdDirection) {
          position = this.getPosition('bottom', 'right');
        } else {
          position = this.getPosition.apply(this, this.mdDirection.trim().split(' '));
        }
  
        if (this.mdAutoWidth) {
          width = this.menuTrigger.getBoundingClientRect().width;
          this.menuContent.style.width = parseInt(width, 10) + 'px';
        }
  
        if (!this.mdFixed) {
          position = (0, _getInViewPosition2.default)(this.menuContent, position);
        } else if (this.mdMaxHeight === 0) {
          this.menuContent.style.maxHeight = window.innerHeight - this.menuTrigger.getBoundingClientRect().bottom - margin + 'px';
        } else if (this.menuContent.children[0].children.length > 0) {
          var listElemHeight = this.menuContent.children[0].children[0].clientHeight;
  
          this.menuContent.style.maxHeight = margin * 2 + listElemHeight * this.mdMaxHeight + 'px';
        }
  
        this.menuContent.style.top = position.top + window.pageYOffset + 'px';
        this.menuContent.style.left = position.left + window.pageXOffset + 'px';
      },
      recalculateOnResize: function recalculateOnResize() {
        window.requestAnimationFrame(this.calculateMenuContentPos);
      },
      open: function open() {
        if (document.body.contains(this.menuContent)) {
          document.body.removeChild(this.menuContent);
        }
  
        document.body.appendChild(this.menuContent);
        document.body.appendChild(this.backdropElement);
        window.addEventListener('resize', this.recalculateOnResize);
  
        this.calculateMenuContentPos();
  
        getComputedStyle(this.menuContent).top;
        this.menuContent.classList.add('md-active');
  
        if (!this.mdNoFocus) {
          this.menuContent.focus();
        }
  
        this.active = true;
        this.$emit('open');
      },
      close: function close() {
        var _this = this;
  
        var close = function close(event) {
          if (_this.menuContent && event.target === _this.menuContent) {
            var activeRipple = _this.menuContent.querySelector('.md-ripple.md-active');
  
            _this.menuContent.removeEventListener(_transitionEndEventName2.default, close);
  
            if (!_this.mdNoFocus) {
              _this.menuTrigger.focus();
            }
  
            _this.active = false;
  
            if (activeRipple) {
              activeRipple.classList.remove('md-active');
            }
  
            if (document.body.contains(_this.menuContent)) {
              document.body.removeChild(_this.menuContent);
            }
  
            if (document.body.contains(_this.backdropElement)) {
              document.body.removeChild(_this.backdropElement);
            }
  
            window.removeEventListener('resize', _this.recalculateOnResize);
          }
        };
  
        this.menuContent.addEventListener(_transitionEndEventName2.default, close);
        this.menuContent.classList.remove('md-active');
        this.$emit('close');
      },
      toggle: function toggle() {
        if (this.active) {
          this.close();
        } else {
          this.open();
        }
      }
    },
    mounted: function mounted() {
      var _this2 = this;
  
      this.$nextTick((function () {
        _this2.menuTrigger = _this2.$el.querySelector('[md-menu-trigger]');
        _this2.menuContent = _this2.$el.querySelector('.md-menu-content');
        _this2.backdropElement = _this2.$refs.backdrop.$el;
        _this2.validateMenu();
        _this2.handleAlignTriggerClass(_this2.mdAlignTrigger);
        _this2.addNewSizeMenuContentClass(_this2.mdSize);
        _this2.addNewDirectionMenuContentClass(_this2.mdDirection);
        _this2.$el.removeChild(_this2.$refs.backdrop.$el);
        _this2.menuContent.parentNode.removeChild(_this2.menuContent);
  
        if (!_this2.mdManualToggle) {
          _this2.menuTrigger.addEventListener('click', _this2.toggle);
        }
      }));
    },
    beforeDestroy: function beforeDestroy() {
      if (document.body.contains(this.menuContent)) {
        document.body.removeChild(this.menuContent);
        document.body.removeChild(this.backdropElement);
      }
  
      if (!this.mdManualToggle) {
        this.menuTrigger.removeEventListener('click', this.toggle);
      }
  
      window.removeEventListener('resize', this.recalculateOnResize);
  
      this._destroyed = true;
    }
  };
  module.exports = exports['default'];
  
  /***/ }),
  
  /***/ 291:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var margin = 0;
  
  var isAboveOfViewport = function isAboveOfViewport(element, position) {
    return position.top <= margin - parseInt(getComputedStyle(element).marginTop, 10);
  };
  
  var isBelowOfViewport = function isBelowOfViewport(element, position) {
    return position.top + element.offsetHeight + margin >= window.innerHeight - parseInt(getComputedStyle(element).marginTop, 10);
  };
  
  var isOnTheLeftOfViewport = function isOnTheLeftOfViewport(element, position) {
    return position.left <= margin - parseInt(getComputedStyle(element).marginLeft, 10);
  };
  
  var isOnTheRightOfViewport = function isOnTheRightOfViewport(element, position) {
    return position.left + element.offsetWidth + margin >= window.innerWidth - parseInt(getComputedStyle(element).marginLeft, 10);
  };
  
  var getInViewPosition = function getInViewPosition(element, position) {
    var computedStyle = getComputedStyle(element);
  
    if (isAboveOfViewport(element, position)) {
      position.top = margin - parseInt(computedStyle.marginTop, 10);
    }
  
    if (isOnTheLeftOfViewport(element, position)) {
      position.left = margin - parseInt(computedStyle.marginLeft, 10);
    }
  
    if (isOnTheRightOfViewport(element, position)) {
      position.left = window.innerWidth - margin - element.offsetWidth - parseInt(computedStyle.marginLeft, 10);
    }
  
    if (isBelowOfViewport(element, position)) {
      position.top = window.innerHeight - margin - element.offsetHeight - parseInt(computedStyle.marginTop, 10);
    }
  
    return position;
  };
  
  exports.default = getInViewPosition;
  module.exports = exports["default"];
  
  /***/ }),
  
  /***/ 292:
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
    return _c('div', {
      staticClass: "md-menu"
    }, [_vm._t("default"), _vm._v(" "), _c('md-backdrop', {
      ref: "backdrop",
      staticClass: "md-menu-backdrop md-transparent md-active",
      on: {
        "close": _vm.close
      }
    })], 2)
  },staticRenderFns: []}
  module.exports.render._withStripped = true
  if (false) {
    module.hot.accept()
    if (module.hot.data) {
       require("vue-hot-reload-api").rerender("data-v-0e0b5d4a", module.exports)
    }
  }
  
  /***/ }),
  
  /***/ 293:
  /***/ (function(module, exports, __webpack_require__) {
  
  var disposed = false
  var Component = __webpack_require__(0)(
    /* script */
    __webpack_require__(294),
    /* template */
    __webpack_require__(296),
    /* styles */
    null,
    /* scopeId */
    null,
    /* moduleIdentifier (server only) */
    null
  )
  Component.options.__file = "C:\\Work\\Github\\Vue-Material\\trunk\\src\\components\\mdMenu\\mdMenuItem.vue"
  if (Component.esModule && Object.keys(Component.esModule).some((function (key) {return key !== "default" && key.substr(0, 2) !== "__"}))) {console.error("named exports are not supported in *.vue files.")}
  if (Component.options.functional) {console.error("[vue-loader] mdMenuItem.vue: functional components are not supported with templates, they should use render functions.")}
  
  /* hot reload */
  if (false) {(function () {
    var hotAPI = require("vue-hot-reload-api")
    hotAPI.install(require("vue"), false)
    if (!hotAPI.compatible) return
    module.hot.accept()
    if (!module.hot.data) {
      hotAPI.createRecord("data-v-b9565c06", Component.options)
    } else {
      hotAPI.reload("data-v-b9565c06", Component.options)
    }
    module.hot.dispose((function (data) {
      disposed = true
    }))
  })()}
  
  module.exports = Component.exports
  
  
  /***/ }),
  
  /***/ 294:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  
  var _getClosestVueParent = __webpack_require__(11);
  
  var _getClosestVueParent2 = _interopRequireDefault(_getClosestVueParent);
  
  __webpack_require__(295);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  
  exports.default = {
    name: 'md-menu-item',
    props: {
      href: String,
      target: String,
      disabled: Boolean,
      listIndex: {
        type: Number,
        default: -1
      },
      manualHighlight: {
        type: Boolean,
        default: false
      }
    },
    data: function data() {
      return {
        parentContent: {},
        index: 0,
        highlighted: false
      };
    },
    computed: {
      classes: function classes() {
        return {
          'md-highlighted': this.highlighted
        };
      },
      getHighlight: function getHighlight() {
        if (!this.manualHighlight) {
          if (this.index === this.parentContent.highlighted) {
            if (this.disabled) {
              if (this.parentContent.oldHighlight > this.parentContent.highlighted) {
                this.parentContent.highlighted--;
              } else {
                this.parentContent.highlighted++;
              }
            }
  
            if (this.index === 1) {
              this.parentContent.$el.scrollTop = 0;
            } else if (this.index === this.parentContent.itemsAmount) {
              this.parentContent.$el.scrollTop = this.parentContent.$el.scrollHeight;
            } else {
              this.$el.scrollIntoViewIfNeeded(false);
            }
  
            this.highlighted = true;
            return true;
          }
  
          this.highlighted = false;
          return false;
        }
      }
    },
    methods: {
      close: function close($event) {
        if (!this.parentMenu.mdManualToggle) {
          if (!this.disabled) {
            if (this.parentMenu.mdCloseOnSelect) {
              this.parentContent.close();
            }
  
            this.$emit('click', $event);
            this.$emit('selected', $event);
          }
        } else if (!this.disabled) {
          this.$emit('click', $event);
          this.$emit('selected', $event);
        }
      }
    },
    mounted: function mounted() {
      this.parentContent = (0, _getClosestVueParent2.default)(this.$parent, 'md-menu-content');
      this.parentMenu = (0, _getClosestVueParent2.default)(this.$parent, 'md-menu');
  
      if (!this.parentContent) {
        this.$destroy();
  
        throw new Error('You must wrap the md-menu-item in a md-menu-content');
      }
  
      if (this.listIndex === -1) {
        this.parentContent.itemListCount++;
        this.index = this.parentContent.itemListCount;
      } else {
        this.index = this.listIndex + 1;
      }
    }
  };
  module.exports = exports['default'];
  
  /***/ }),
  
  /***/ 295:
  /***/ (function(module, exports) {
  
  if (!Element.prototype.scrollIntoViewIfNeeded) {
    Element.prototype.scrollIntoViewIfNeeded = function (centerIfNeeded) {
      centerIfNeeded = arguments.length === 0 ? true : !!centerIfNeeded;
  
      var parent = this.parentNode,
          parentComputedStyle = window.getComputedStyle(parent, null),
          parentBorderTopWidth = parseInt(parentComputedStyle.getPropertyValue('border-top-width')),
          parentBorderLeftWidth = parseInt(parentComputedStyle.getPropertyValue('border-left-width')),
          overTop = this.offsetTop - parent.offsetTop < parent.scrollTop,
          overBottom = (this.offsetTop - parent.offsetTop + this.clientHeight - parentBorderTopWidth) > (parent.scrollTop + parent.clientHeight),
          overLeft = this.offsetLeft - parent.offsetLeft < parent.scrollLeft,
          overRight = (this.offsetLeft - parent.offsetLeft + this.clientWidth - parentBorderLeftWidth) > (parent.scrollLeft + parent.clientWidth),
          alignWithTop = overTop && !overBottom;
  
      if ((overTop || overBottom) && centerIfNeeded) {
        parent.scrollTop = this.offsetTop - parent.offsetTop - parent.clientHeight / 2 - parentBorderTopWidth + this.clientHeight / 2;
      }
  
      if ((overLeft || overRight) && centerIfNeeded) {
        parent.scrollLeft = this.offsetLeft - parent.offsetLeft - parent.clientWidth / 2 - parentBorderLeftWidth + this.clientWidth / 2;
      }
  
      if ((overTop || overBottom || overLeft || overRight) && !centerIfNeeded) {
        this.scrollIntoView(alignWithTop);
      }
    };
  }
  
  /***/ }),
  
  /***/ 296:
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
    return _c('md-list-item', {
      staticClass: "md-menu-item",
      class: _vm.classes,
      attrs: {
        "href": _vm.href,
        "target": _vm.target,
        "disabled": _vm.disabled
      },
      on: {
        "click": _vm.close
      }
    }, [_vm._t("default")], 2)
  },staticRenderFns: []}
  module.exports.render._withStripped = true
  if (false) {
    module.hot.accept()
    if (module.hot.data) {
       require("vue-hot-reload-api").rerender("data-v-b9565c06", module.exports)
    }
  }
  
  /***/ }),
  
  /***/ 297:
  /***/ (function(module, exports, __webpack_require__) {
  
  var disposed = false
  var Component = __webpack_require__(0)(
    /* script */
    __webpack_require__(298),
    /* template */
    __webpack_require__(299),
    /* styles */
    null,
    /* scopeId */
    null,
    /* moduleIdentifier (server only) */
    null
  )
  Component.options.__file = "C:\\Work\\Github\\Vue-Material\\trunk\\src\\components\\mdMenu\\mdMenuContent.vue"
  if (Component.esModule && Object.keys(Component.esModule).some((function (key) {return key !== "default" && key.substr(0, 2) !== "__"}))) {console.error("named exports are not supported in *.vue files.")}
  if (Component.options.functional) {console.error("[vue-loader] mdMenuContent.vue: functional components are not supported with templates, they should use render functions.")}
  
  /* hot reload */
  if (false) {(function () {
    var hotAPI = require("vue-hot-reload-api")
    hotAPI.install(require("vue"), false)
    if (!hotAPI.compatible) return
    module.hot.accept()
    if (!module.hot.data) {
      hotAPI.createRecord("data-v-260ff37f", Component.options)
    } else {
      hotAPI.reload("data-v-260ff37f", Component.options)
    }
    module.hot.dispose((function (data) {
      disposed = true
    }))
  })()}
  
  module.exports = Component.exports
  
  
  /***/ }),
  
  /***/ 298:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  
  exports.default = {
    name: 'md-menu-content',
    data: function data() {
      return {
        oldHighlight: false,
        highlighted: false,
        itemsAmount: 0,
        itemListCount: 0
      };
    },
  
    methods: {
      close: function close() {
        this.highlighted = false;
        this.$parent.close();
      },
      highlightItem: function highlightItem(direction) {
        this.itemsAmount = this.$children[0].$children.length;
  
        if (this.itemsAmount < this.highlighted - 1) {
          this.highlighted = 1;
        }
  
        this.oldHighlight = this.highlighted;
  
        if (direction === 'up') {
          if (this.highlighted === 1) {
            this.highlighted = this.itemsAmount;
          } else {
            this.highlighted--;
          }
        }
  
        if (direction === 'down') {
          if (this.highlighted === this.itemsAmount) {
            this.highlighted = 1;
          } else {
            this.highlighted++;
          }
        }
  
        this.$children[0].$children[this.highlighted - 1].$el.scrollIntoView({
          block: 'end', behavior: 'smooth'
        });
  
        for (var i = 0; i < this.itemsAmount; i++) {
          this.$children[0].$children[i].highlighted = false;
        }
  
        this.$children[0].$children[this.highlighted - 1].highlighted = true;
      },
      fireClick: function fireClick() {
        if (this.highlighted > 0) {
          this.getOptions()[this.highlighted - 1].$el.click();
        }
      },
      getOptions: function getOptions() {
        return this.$children[0].$children.filter((function (child) {
          return child.$el.classList.contains('md-option');
        }));
      }
    },
    mounted: function mounted() {
      if (!this.$parent.$el.classList.contains('md-menu')) {
        this.$destroy();
  
        throw new Error('You must wrap the md-menu-content in a md-menu');
      }
    }
  };
  module.exports = exports['default'];
  
  /***/ }),
  
  /***/ 299:
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
    return _c('div', {
      staticClass: "md-menu-content",
      attrs: {
        "tabindex": "-1"
      },
      on: {
        "keydown": [function($event) {
          if (!('button' in $event) && _vm._k($event.keyCode, "esc", 27, $event.key)) { return null; }
          $event.preventDefault();
          _vm.close($event)
        }, function($event) {
          if (!('button' in $event) && _vm._k($event.keyCode, "tab", 9, $event.key)) { return null; }
          $event.preventDefault();
          _vm.close($event)
        }, function($event) {
          if (!('button' in $event) && _vm._k($event.keyCode, "up", 38, $event.key)) { return null; }
          $event.preventDefault();
          _vm.highlightItem('up')
        }, function($event) {
          if (!('button' in $event) && _vm._k($event.keyCode, "down", 40, $event.key)) { return null; }
          $event.preventDefault();
          _vm.highlightItem('down')
        }, function($event) {
          if (!('button' in $event) && _vm._k($event.keyCode, "enter", 13, $event.key)) { return null; }
          _vm.fireClick($event)
        }, function($event) {
          if (!('button' in $event) && _vm._k($event.keyCode, "space", 32, $event.key)) { return null; }
          _vm.fireClick($event)
        }]
      }
    }, [_c('md-list', [_vm._t("default")], 2)], 1)
  },staticRenderFns: []}
  module.exports.render._withStripped = true
  if (false) {
    module.hot.accept()
    if (module.hot.data) {
       require("vue-hot-reload-api").rerender("data-v-260ff37f", module.exports)
    }
  }
  
  /***/ }),
  
  /***/ 300:
  /***/ (function(module, exports) {
  
  module.exports = ".md-menu-content .THEME_NAME.md-list {\n  background-color: BACKGROUND-COLOR;\n  color: BACKGROUND-CONTRAST; }\n  .md-menu-content .THEME_NAME.md-list .md-menu-item:hover .md-button:not([disabled]), .md-menu-content .THEME_NAME.md-list .md-menu-item:focus .md-button:not([disabled]), .md-menu-content .THEME_NAME.md-list .md-menu-item.md-highlighted .md-button:not([disabled]) {\n    background-color: BACKGROUND-CONTRAST-0.12; }\n  .md-menu-content .THEME_NAME.md-list .md-menu-item[disabled] {\n    color: BACKGROUND-CONTRAST-0.38; }\n"
  
  /***/ }),
  
  /***/ 42:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  function transitionEndEventName() {
    var el = document.createElement('span');
    var transitions = {
      transition: 'transitionend',
      OTransition: 'oTransitionEnd',
      MozTransition: 'transitionend',
      WebkitTransition: 'webkitTransitionEnd'
    };
  
    for (var transition in transitions) {
      if (el.style[transition] !== undefined) {
        return transitions[transition];
      }
    }
  }
  
  exports.default = transitionEndEventName();
  module.exports = exports['default'];
  
  /***/ }),
  
  /***/ 464:
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = __webpack_require__(287);
  
  
  /***/ })
  
  /******/ });
  }));