/*! tether-shepherd 1.8.1 */

(function(root, factory) {
  if (typeof define === 'function' && define.amd) {
    define(["tether"], factory);
  } else if (typeof exports === 'object') {
    module.exports = factory(require('tether'));
  } else {
    root.Shepherd = factory(root.Tether);
  }
}(this, function(Tether) {

/* global Tether */

'use strict';

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

var _get = function get(_x5, _x6, _x7) { var _again = true; _function: while (_again) { var object = _x5, property = _x6, receiver = _x7; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x5 = parent; _x6 = property; _x7 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var _Tether$Utils = Tether.Utils;
var Evented = _Tether$Utils.Evented;
var addClass = _Tether$Utils.addClass;
var extend = _Tether$Utils.extend;
var hasClass = _Tether$Utils.hasClass;
var removeClass = _Tether$Utils.removeClass;
var uniqueId = _Tether$Utils.uniqueId;

var Shepherd = new Evented();

function isUndefined(obj) {
  return typeof obj === 'undefined';
};

function isArray(obj) {
  return obj && obj.constructor === Array;
};

function isObject(obj) {
  return obj && obj.constructor === Object;
};

function isObjectLoose(obj) {
  return typeof obj === 'object';
};

var ATTACHMENT = {
  'top right': 'bottom left',
  'top left': 'bottom right',
  'top center': 'bottom center',
  'middle right': 'middle left',
  'middle left': 'middle right',
  'middle center': 'middle center',
  'bottom left': 'top right',
  'bottom right': 'top left',
  'bottom center': 'top center',
  'top': 'bottom center',
  'left': 'middle right',
  'right': 'middle left',
  'bottom': 'top center',
  'center': 'middle center',
  'middle': 'middle center'
};

function createFromHTML(html) {
  var el = document.createElement('div');
  el.innerHTML = html;
  return el.children[0];
}

function matchesSelector(el, sel) {
  var matches = undefined;
  if (!isUndefined(el.matches)) {
    matches = el.matches;
  } else if (!isUndefined(el.matchesSelector)) {
    matches = el.matchesSelector;
  } else if (!isUndefined(el.msMatchesSelector)) {
    matches = el.msMatchesSelector;
  } else if (!isUndefined(el.webkitMatchesSelector)) {
    matches = el.webkitMatchesSelector;
  } else if (!isUndefined(el.mozMatchesSelector)) {
    matches = el.mozMatchesSelector;
  } else if (!isUndefined(el.oMatchesSelector)) {
    matches = el.oMatchesSelector;
  }
  return matches.call(el, sel);
}

var positionRe = /^(.+) (top|left|right|bottom|center|\[[a-z ]+\])$/;

function parsePosition(str) {
  if (isObjectLoose(str)) {
    if (str.hasOwnProperty("element") && str.hasOwnProperty("on")) {
      return str;
    }
    return null;
  }

  var matches = positionRe.exec(str);
  if (!matches) {
    return null;
  }

  var on = matches[2];
  if (on[0] === '[') {
    on = on.substring(1, on.length - 1);
  }

  return {
    'element': matches[1],
    'on': on
  };
}

function parseShorthand(obj, props) {
  if (obj === null || isUndefined(obj)) {
    return obj;
  } else if (isObjectLoose(obj)) {
    return obj;
  }

  var vals = obj.split(' ');
  var out = {};
  var j = props.length - 1;
  for (var i = vals.length - 1; i >= 0; i--) {
    if (j === 0) {
      out[props[j]] = vals.slice(0, i + 1).join(' ');
      break;
    } else {
      out[props[j]] = vals[i];
    }

    j--;
  }

  return out;
}

var Step = (function (_Evented) {
  _inherits(Step, _Evented);

  function Step(tour, options) {
    _classCallCheck(this, Step);

    _get(Object.getPrototypeOf(Step.prototype), 'constructor', this).call(this, tour, options);
    this.tour = tour;
    this.bindMethods();
    this.setOptions(options);
    return this;
  }

  _createClass(Step, [{
    key: 'bindMethods',
    value: function bindMethods() {
      var _this = this;

      var methods = ['_show', 'show', 'hide', 'isOpen', 'cancel', 'complete', 'scrollTo', 'destroy', 'render'];
      methods.map(function (method) {
        _this[method] = _this[method].bind(_this);
      });
    }
  }, {
    key: 'setOptions',
    value: function setOptions() {
      var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

      this.options = options;
      this.destroy();

      this.id = this.options.id || this.id || 'step-' + uniqueId();

      var when = this.options.when;
      if (when) {
        for (var _event in when) {
          if (({}).hasOwnProperty.call(when, _event)) {
            var handler = when[_event];
            this.on(_event, handler, this);
          }
        }
      }

      // Button configuration

      var buttonsJson = JSON.stringify(this.options.buttons);
      var buttonsAreDefault = isUndefined(buttonsJson) || buttonsJson === "true";

      var buttonsAreEmpty = buttonsJson === "{}" || buttonsJson === "[]" || buttonsJson === "null" || buttonsJson === "false";

      var buttonsAreArray = !buttonsAreDefault && isArray(this.options.buttons);

      var buttonsAreObject = !buttonsAreDefault && isObject(this.options.buttons);

      // Show default button if undefined or 'true'
      if (buttonsAreDefault) {
        this.options.buttons = [{
          text: 'Next',
          action: this.tour.next,
          classes: 'btn'
        }];

        // Can pass in an object which will assume asingle button
      } else if (!buttonsAreEmpty && buttonsAreObject) {
          this.options.buttons = [this.options.buttons];

          // Falsey/empty values or non-object values prevent buttons from rendering
        } else if (buttonsAreEmpty || !buttonsAreArray) {
            this.options.buttons = false;
          }
    }
  }, {
    key: 'getTour',
    value: function getTour() {
      return this.tour;
    }
  }, {
    key: 'bindAdvance',
    value: function bindAdvance() {
      var _this2 = this;

      // An empty selector matches the step element

      var _parseShorthand = parseShorthand(this.options.advanceOn, ['selector', 'event']);

      var event = _parseShorthand.event;
      var selector = _parseShorthand.selector;

      var handler = function handler(e) {
        if (!_this2.isOpen()) {
          return;
        }

        if (!isUndefined(selector)) {
          if (matchesSelector(e.target, selector)) {
            _this2.tour.next();
          }
        } else {
          if (_this2.el && e.target === _this2.el) {
            _this2.tour.next();
          }
        }
      };

      // TODO: this should also bind/unbind on show/hide
      document.body.addEventListener(event, handler);
      this.on('destroy', function () {
        return document.body.removeEventListener(event, handler);
      });
    }
  }, {
    key: 'getAttachTo',
    value: function getAttachTo() {
      var opts = parsePosition(this.options.attachTo) || {};
      var returnOpts = extend({}, opts);

      if (typeof opts.element === 'string') {
        // Can't override the element in user opts reference because we can't
        // guarantee that the element will exist in the future.
        returnOpts.element = document.querySelector(opts.element);
        if (!returnOpts.element) {
          console.error('The element for this Shepherd step was not found ' + opts.element);
        }
      }

      return returnOpts;
    }
  }, {
    key: 'setupTether',
    value: function setupTether() {
      if (isUndefined(Tether)) {
        throw new Error("Using the attachment feature of Shepherd requires the Tether library");
      }

      var opts = this.getAttachTo();
      var attachment = ATTACHMENT[opts.on] || ATTACHMENT.right;
      if (isUndefined(opts.element)) {
        opts.element = 'viewport';
        attachment = 'middle center';
      }

      var tetherOpts = {
        classPrefix: 'shepherd',
        element: this.el,
        constraints: [{
          to: 'window',
          pin: true,
          attachment: 'together'
        }],
        target: opts.element,
        offset: opts.offset || '0 0',
        attachment: attachment
      };

      if (this.tether) {
        this.tether.destroy();
      }

      this.tether = new Tether(extend(tetherOpts, this.options.tetherOptions));
    }
  }, {
    key: 'show',
    value: function show() {
      var _this3 = this;

      if (!isUndefined(this.options.beforeShowPromise)) {
        var beforeShowPromise = this.options.beforeShowPromise();
        if (!isUndefined(beforeShowPromise)) {
          return beforeShowPromise.then(function () {
            return _this3._show();
          });
        }
      }
      this._show();
    }
  }, {
    key: '_show',
    value: function _show() {
      var _this4 = this;

      this.trigger('before-show');

      if (!this.el) {
        this.render();
      }

      addClass(this.el, 'shepherd-open');

      document.body.setAttribute('data-shepherd-step', this.id);

      this.setupTether();

      if (this.options.scrollTo) {
        setTimeout(function () {
          _this4.scrollTo();
        });
      }

      this.trigger('show');
    }
  }, {
    key: 'hide',
    value: function hide() {
      this.trigger('before-hide');

      removeClass(this.el, 'shepherd-open');

      document.body.removeAttribute('data-shepherd-step');

      if (this.tether) {
        this.tether.destroy();
      }
      this.tether = null;

      this.trigger('hide');
    }
  }, {
    key: 'isOpen',
    value: function isOpen() {
      return this.el && hasClass(this.el, 'shepherd-open');
    }
  }, {
    key: 'cancel',
    value: function cancel() {
      this.tour.cancel();
      this.trigger('cancel');
    }
  }, {
    key: 'complete',
    value: function complete() {
      this.tour.complete();
      this.trigger('complete');
    }
  }, {
    key: 'scrollTo',
    value: function scrollTo() {
      var _getAttachTo = this.getAttachTo();

      var element = _getAttachTo.element;

      if (!isUndefined(this.options.scrollToHandler)) {
        this.options.scrollToHandler(element);
      } else if (!isUndefined(element)) {
        element.scrollIntoView();
      }
    }
  }, {
    key: 'destroy',
    value: function destroy() {
      if (!isUndefined(this.el) && this.el.parentNode) {
        this.el.parentNode.removeChild(this.el);
        delete this.el;
      }

      if (this.tether) {
        this.tether.destroy();
      }
      this.tether = null;

      this.trigger('destroy');
    }
  }, {
    key: 'render',
    value: function render() {
      var _this5 = this;

      if (!isUndefined(this.el)) {
        this.destroy();
      }

      this.el = createFromHTML('<div class=\'shepherd-step ' + (this.options.classes || '') + '\' data-id=\'' + this.id + '\' ' + (this.options.idAttribute ? 'id="' + this.options.idAttribute + '"' : '') + '></div>');

      var content = document.createElement('div');
      content.className = 'shepherd-content';
      this.el.appendChild(content);

      var header = document.createElement('header');
      content.appendChild(header);

      if (this.options.title) {
        header.innerHTML += '<h3 class=\'shepherd-title\'>' + this.options.title + '</h3>';
        this.el.className += ' shepherd-has-title';
      }

      if (this.options.showCancelLink) {
        var link = createFromHTML("<a href class='shepherd-cancel-link'>✕</a>");
        header.appendChild(link);

        this.el.className += ' shepherd-has-cancel-link';

        this.bindCancelLink(link);
      }

      if (!isUndefined(this.options.text)) {
        (function () {
          var text = createFromHTML("<div class='shepherd-text'></div>");
          var paragraphs = _this5.options.text;

          if (typeof paragraphs === 'function') {
            paragraphs = paragraphs.call(_this5, text);
          }

          if (paragraphs instanceof HTMLElement) {
            text.appendChild(paragraphs);
          } else {
            if (typeof paragraphs === 'string') {
              paragraphs = [paragraphs];
            }

            paragraphs.map(function (paragraph) {
              text.innerHTML += '<p>' + paragraph + '</p>';
            });
          }

          content.appendChild(text);
        })();
      }

      if (this.options.buttons) {
        (function () {
          var footer = document.createElement('footer');
          var buttons = createFromHTML("<ul class='shepherd-buttons'></ul>");

          _this5.options.buttons.map(function (cfg) {
            var button = createFromHTML('<li><a class=\'shepherd-button ' + (cfg.classes || '') + '\'>' + cfg.text + '</a>');
            buttons.appendChild(button);
            _this5.bindButtonEvents(cfg, button.querySelector('a'));
          });

          footer.appendChild(buttons);
          content.appendChild(footer);
        })();
      }

      document.body.appendChild(this.el);

      this.setupTether();

      if (this.options.advanceOn) {
        this.bindAdvance();
      }
    }
  }, {
    key: 'bindCancelLink',
    value: function bindCancelLink(link) {
      var _this6 = this;

      link.addEventListener('click', function (e) {
        e.preventDefault();
        _this6.cancel();
      });
    }
  }, {
    key: 'bindButtonEvents',
    value: function bindButtonEvents(cfg, el) {
      var _this7 = this;

      cfg.events = cfg.events || {};
      if (!isUndefined(cfg.action)) {
        // Including both a click event and an action is not supported
        cfg.events.click = cfg.action;
      }

      for (var _event2 in cfg.events) {
        if (({}).hasOwnProperty.call(cfg.events, _event2)) {
          var handler = cfg.events[_event2];
          if (typeof handler === 'string') {
            (function () {
              var page = handler;
              handler = function () {
                return _this7.tour.show(page);
              };
            })();
          }
          el.addEventListener(_event2, handler);
        }
      }

      this.on('destroy', function () {
        for (var _event3 in cfg.events) {
          if (({}).hasOwnProperty.call(cfg.events, _event3)) {
            var handler = cfg.events[_event3];
            el.removeEventListener(_event3, handler);
          }
        }
      });
    }
  }]);

  return Step;
})(Evented);

var Tour = (function (_Evented2) {
  _inherits(Tour, _Evented2);

  function Tour() {
    var _this8 = this;

    var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

    _classCallCheck(this, Tour);

    _get(Object.getPrototypeOf(Tour.prototype), 'constructor', this).call(this, options);
    this.bindMethods();
    this.options = options;
    this.steps = this.options.steps || [];

    // Pass these events onto the global Shepherd object
    var events = ['complete', 'cancel', 'hide', 'start', 'show', 'active', 'inactive'];
    events.map(function (event) {
      (function (e) {
        _this8.on(e, function (opts) {
          opts = opts || {};
          opts.tour = _this8;
          Shepherd.trigger(e, opts);
        });
      })(event);
    });

    return this;
  }

  _createClass(Tour, [{
    key: 'bindMethods',
    value: function bindMethods() {
      var _this9 = this;

      var methods = ['next', 'back', 'cancel', 'complete', 'hide'];
      methods.map(function (method) {
        _this9[method] = _this9[method].bind(_this9);
      });
    }
  }, {
    key: 'addStep',
    value: function addStep(name, step) {
      if (isUndefined(step)) {
        step = name;
      }

      if (!(step instanceof Step)) {
        if (typeof name === 'string' || typeof name === 'number') {
          step.id = name.toString();
        }
        step = extend({}, this.options.defaults, step);
        step = new Step(this, step);
      } else {
        step.tour = this;
      }

      this.steps.push(step);
      return this;
    }
  }, {
    key: 'removeStep',
    value: function removeStep(name) {
      var current = this.getCurrentStep();

      for (var i = 0; i < this.steps.length; ++i) {
        var step = this.steps[i];
        if (step.id === name) {
          if (step.isOpen()) {
            step.hide();
          }
          step.destroy();
          this.steps.splice(i, 1);
          break;
        }
      }

      if (current && current.id === name) {
        this.currentStep = undefined;

        if (this.steps.length) this.show(0);else this.hide();
      }
    }
  }, {
    key: 'getById',
    value: function getById(id) {
      for (var i = 0; i < this.steps.length; ++i) {
        var step = this.steps[i];
        if (step.id === id) {
          return step;
        }
      }
    }
  }, {
    key: 'getCurrentStep',
    value: function getCurrentStep() {
      return this.currentStep;
    }
  }, {
    key: 'next',
    value: function next() {
      var index = this.steps.indexOf(this.currentStep);

      if (index === this.steps.length - 1) {
        this.hide(index);
        this.trigger('complete');
        this.done();
      } else {
        this.show(index + 1, true);
      }
    }
  }, {
    key: 'back',
    value: function back() {
      var index = this.steps.indexOf(this.currentStep);
      this.show(index - 1, false);
    }
  }, {
    key: 'cancel',
    value: function cancel() {
      if (this.currentStep) {
        this.currentStep.hide();
      }
      this.trigger('cancel');
      this.done();
    }
  }, {
    key: 'complete',
    value: function complete() {
      if (this.currentStep) {
        this.currentStep.hide();
      }
      this.trigger('complete');
      this.done();
    }
  }, {
    key: 'hide',
    value: function hide() {
      if (this.currentStep) {
        this.currentStep.hide();
      }
      this.trigger('hide');
      this.done();
    }
  }, {
    key: 'done',
    value: function done() {
      Shepherd.activeTour = null;
      removeClass(document.body, 'shepherd-active');
      this.trigger('inactive', { tour: this });
    }
  }, {
    key: 'show',
    value: function show() {
      var key = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0];
      var forward = arguments.length <= 1 || arguments[1] === undefined ? true : arguments[1];

      if (this.currentStep) {
        this.currentStep.hide();
      } else {
        addClass(document.body, 'shepherd-active');
        this.trigger('active', { tour: this });
      }

      Shepherd.activeTour = this;

      var next = undefined;

      if (typeof key === 'string') {
        next = this.getById(key);
      } else {
        next = this.steps[key];
      }

      if (next) {
        if (!isUndefined(next.options.showOn) && !next.options.showOn()) {
          var index = this.steps.indexOf(next);
          var nextIndex = forward ? index + 1 : index - 1;
          this.show(nextIndex, forward);
        } else {
          this.trigger('show', {
            step: next,
            previous: this.currentStep
          });

          if (this.currentStep) {
            this.currentStep.hide();
          }

          this.currentStep = next;
          next.show();
        }
      }
    }
  }, {
    key: 'start',
    value: function start() {
      this.trigger('start');

      this.currentStep = null;
      this.next();
    }
  }]);

  return Tour;
})(Evented);

extend(Shepherd, { Tour: Tour, Step: Step, Evented: Evented });
return Shepherd;

}));
/**
 * Twenty Seventeen integration styles
 */
@import "mixins";
@import "animation";

/**
 * Fonts
 */
@font-face {
	font-family: "star";
	src: url("../fonts/star.eot");
	src:
		url("../fonts/star.eot?#iefix") format("embedded-opentype"),
		url("../fonts/star.woff") format("woff"),
		url("../fonts/star.ttf") format("truetype"),
		url("../fonts/star.svg#star") format("svg");
	font-weight: normal;
	font-style: normal;
}

@font-face {
	font-family: "WooCommerce";
	src: url("../fonts/WooCommerce.eot");
	src:
		url("../fonts/WooCommerce.eot?#iefix") format("embedded-opentype"),
		url("../fonts/WooCommerce.woff") format("woff"),
		url("../fonts/WooCommerce.ttf") format("truetype"),
		url("../fonts/WooCommerce.svg#WooCommerce") format("svg");
	font-weight: normal;
	font-style: normal;
}

/**
 * Mixins
 */
@mixin link() {
	box-shadow: 0 1px 0 rgba(15, 15, 15, 1);
	transition: box-shadow ease-in-out 130ms;

	&:hover {
		box-shadow: 0 3px 0 rgba(15, 15, 15, 1);
	}
}

@mixin link_white() {
	color: #fff;
	box-shadow: 0 1px 0 rgba(#fff, 1) !important;
	transition: box-shadow ease-in-out 130ms;

	&:hover {
		color: #fff !important;
		box-shadow: 0 3px 0 rgba(#fff, 1) !important;
	}
}

/**
 * Global elements
 */
.woocommerce {

	.blockUI.blockOverlay {
		position: relative;

		@include loader();
	}

	.loader {

		@include loader();
	}

	form .form-row {

		.required {
			color: firebrick;
			text-decoration: none;
			visibility: hidden; // Only show optional by default.

			&[title] {
				border: 0 !important;
			}
		}

		.optional {
			visibility: visible;
		}
	}

	.woocommerce-form-login {

		.woocommerce-form-login__submit {
			float: left;
			margin-right: 1em;
		}

		.woocommerce-form-login__rememberme {
			display: inline-block;
			line-height: 3em;
		}
	}
}

.woocommerce-breadcrumb {
	padding-bottom: 2em;
	margin-bottom: 4em;
	border-bottom: 1px solid #eee;
	font-size: 13px;
	font-size: 0.8125rem;

	a {

		@include link();
	}
}

.woocommerce-pagination {
	padding-top: 2em;
	margin-top: 4em;
	border-top: 1px solid #eee;
	font-size: 13px;
	font-size: 0.8125rem;

	ul.page-numbers {
		padding: 0;
		display: block;
	}

	span.page-numbers,
	a.page-numbers,
	.next.page-numbers,
	.prev.page-numbers {
		padding: 0.5em 1em;
		background: #ddd;
		display: inline-block;
		font-size: 1em;
		float: none;
		line-height: 1.5;
		border-radius: 2px;
		transition: background-color ease-in-out 0.3s;
	}

	span.page-numbers {
		background-color: #fff;
	}

	a.page-numbers:hover {
		background-color: #767676;
		color: #fff;
	}
}

.onsale {
	background-color: #fff;
	position: absolute;
	top: 0;
	left: 0;
	display: inline-block;
	padding: 0.5em 1em;
	font-size: 13px;
	font-size: 0.8125rem;
	text-transform: uppercase;
	font-weight: 800;
	z-index: 1;
}

.price {

	del {
		opacity: 0.5;
		display: inline-block;
	}

	ins {
		display: inline-block;
	}
}

.woocommerce-message,
.woocommerce-error,
.woocommerce-info {
	margin-bottom: 1.5em;
	padding: 2em;
	background: #eee;
}

.woocommerce-message {
	background: teal;
	color: #fff;
}

.woocommerce-error {
	background: firebrick;
	color: #fff;
}

.woocommerce-info {
	background: royalblue;
	color: #fff;
}

.woocommerce-message,
.woocommerce-error,
.woocommerce-info {

	a {

		@include link_white();
	}
}

.woocommerce-store-notice {
	background: royalblue;
	color: #fff;
	padding: 1em;
	position: absolute;
	top: 0;
	left: 0;
	width: 100%;
	z-index: 999;
}

.admin-bar .woocommerce-store-notice {
	top: 32px;
}

.woocommerce-store-notice__dismiss-link {
	float: right;
	color: #fff;

	&:hover {
		text-decoration: underline;
		color: #fff;
	}
}

/**
 * Shop page
 */
.woocommerce-result-count {
	padding: 0.75em 0;
}

/**
 * Products
 */
ul.products {

	li.product {
		list-style: none;

		.price,
		.star-rating {
			display: block;
			margin-bottom: 0.75em;
		}

		.woocommerce-placeholder {
			border: 1px solid #f2f2f2;
		}

		.button {

			@include link();

			&.loading {
				opacity: 0.5;
			}
		}

		.added_to_cart {

			@include link();
			margin-left: 0.5em;
		}
	}
}

.star-rating {
	overflow: hidden;
	position: relative;
	height: 1em;
	line-height: 1;
	font-size: 1em;
	width: 5.4em;
	font-family: "star";

	&::before {
		content: "\73\73\73\73\73";
		float: left;
		top: 0;
		left: 0;
		position: absolute;
	}

	span {
		overflow: hidden;
		float: left;
		top: 0;
		left: 0;
		position: absolute;
		padding-top: 1.5em;
	}

	span::before {
		content: "\53\53\53\53\53";
		top: 0;
		position: absolute;
		left: 0;
	}
}

.woocommerce-loop-product__title {
	font-size: 13px;
	font-size: 0.8125rem;
	text-transform: uppercase;
	font-weight: 800;
	letter-spacing: 0.15em;
}

a.remove {
	display: inline-block;
	width: 16px;
	height: 16px;
	line-height: 16px;
	font-size: 16px;
	text-align: center;
	border-radius: 100%;
	box-shadow: none !important;
	border: 1px solid #000;

	&:hover {
		background: #000;
		color: #fff !important;
	}
}

dl.variation,
.wc-item-meta {
	list-style: none outside;

	dt,
	.wc-item-meta-label {
		float: left;
		clear: both;
		margin-right: 0.25em;
		display: inline-block;
		list-style: none outside;
	}

	dd {
		margin: 0;
	}

	p,
	&:last-child {
		margin-bottom: 0;
	}
}

/**
 * Single product
 */
.single-product {

	div.product {
		position: relative;
	}

	.single-featured-image-header {
		display: none;
	}

	.summary {
		margin-bottom: 3em;

		p.price {
			margin-bottom: 2em;
		}
	}

	.woocommerce-product-rating {
		margin-bottom: 2em;
		line-height: 1;

		.star-rating {
			float: left;
			margin-right: 0.25em;
		}
	}

	form.cart {

		.quantity {
			float: left;
			margin-right: 0.5em;
		}

		input {
			width: 5em;
		}
	}

	.woocommerce-variation-add-to-cart {

		.button {
			padding-top: 0.72em;
			padding-bottom: 0.72em;
		}

		.button.disabled {
			opacity: 0.2;
		}
	}
}

table.variations {

	label {
		margin: 0;
	}

	select {
		margin-right: 0.5em;
	}
}

.woocommerce-product-gallery {
	position: relative;
	margin-bottom: 3em;

	figure {
		margin: 0;
		padding: 0;
	}

	.woocommerce-product-gallery__wrapper {
		margin: 0;
		padding: 0;
	}

	.zoomImg {
		background-color: #fff;
		opacity: 0;
	}

	.woocommerce-product-gallery__image--placeholder {
		border: 1px solid #f2f2f2;
	}

	.woocommerce-product-gallery__image:nth-child(n+2) {
		width: 25%;
		display: inline-block;
	}

	.flex-control-thumbs {

		li {
			list-style: none;
			cursor: pointer;
			float: left;
		}

		img {
			opacity: 0.5;

			&:hover,
			&.flex-active {
				opacity: 1;
			}
		}
	}

	img {
		display: block;
		height: auto;
	}
}

.woocommerce-product-gallery--columns-3 {

	.flex-control-thumbs li {
		width: 33.3333%;
	}

	.flex-control-thumbs li:nth-child(3n+1) {
		clear: left;
	}
}

.woocommerce-product-gallery--columns-4 {

	.flex-control-thumbs li {
		width: 25%;
	}

	.flex-control-thumbs li:nth-child(4n+1) {
		clear: left;
	}
}

.woocommerce-product-gallery--columns-5 {

	.flex-control-thumbs li {
		width: 20%;
	}

	.flex-control-thumbs li:nth-child(5n+1) {
		clear: left;
	}
}

.woocommerce-product-gallery__trigger {
	position: absolute;
	top: 1em;
	right: 1em;
	z-index: 99;
}

.woocommerce-tabs {
	margin-bottom: 2em;

	li {
		margin-right: 1em;

		&.active {

			a {
				box-shadow: 0 3px 0 rgba(15, 15, 15, 1);
			}
		}
	}

	a {

		@include link();
	}

	#comments {
		padding-top: 0;
	}

	.comment-reply-title {
		font-size: 22px;
		font-size: 1.375rem;
		font-weight: 300;
		line-height: 1.4;
		margin: 0 0 0.75em;
		display: block;
	}

	#reviews {

		li.review,
		li.comment {
			list-style: none;
			margin-right: 0;
			margin-bottom: 2.5em;

			.avatar {
				max-height: 36px;
				width: auto;
				float: right;
			}

			p.meta {
				margin-bottom: 0.5em;
			}
		}

		p.stars {

			a {
				position: relative;
				height: 1em;
				width: 1em;
				text-indent: -999em;
				display: inline-block;
				text-decoration: none;
				box-shadow: none;

				&::before {
					display: block;
					position: absolute;
					top: 0;
					left: 0;
					width: 1em;
					height: 1em;
					line-height: 1;
					font-family: "WooCommerce";
					content: "\e021";
					text-indent: 0;
				}

				&:hover {

					~ a::before {
						content: "\e021";
					}
				}
			}

			&:hover {

				a {

					&::before {
						content: "\e020";
					}
				}
			}

			&.selected {

				a.active {

					&::before {
						content: "\e020";
					}

					~ a::before {
						content: "\e021";
					}
				}

				a:not(.active) {

					&::before {
						content: "\e020";
					}
				}
			}
		}
	}
}

/**
 * Widgets
 */
.widget .product_list_widget,
.site-footer .widget .product_list_widget {
	margin-bottom: 1.5em;

	a {
		display: block;
		box-shadow: none;

		&:hover {
			box-shadow: none;
		}
	}

	li {
		padding: 1.5em 0;

		a.remove {
			float: right;
			margin-top: 2px;
		}
	}

	img {
		display: none;
	}
}

.widget_shopping_cart {

	.buttons {

		a {
			display: inline-block;
			margin: 0 0.5em 0 0;
		}
	}
}

.widget_layered_nav {

	.chosen {

		&::before {
			content: "×";
			display: inline-block;
			width: 16px;
			height: 16px;
			line-height: 16px;
			font-size: 16px;
			text-align: center;
			border-radius: 100%;
			border: 1px solid black;
			margin-right: 0.25em;
		}
	}
}

.widget_price_filter {

	.price_slider {
		margin-bottom: 1em;
	}

	.price_slider_amount {
		text-align: right;
		line-height: 2.4;
		font-size: 0.8751em;

		.button {
			float: left;
			padding: 0.4em 1em;
		}
	}

	.ui-slider {
		position: relative;
		text-align: left;
		margin-left: 0.5em;
		margin-right: 0.5em;
	}

	.ui-slider .ui-slider-handle {
		position: absolute;
		z-index: 2;
		width: 1em;
		height: 1em;
		background-color: #000;
		border-radius: 1em;
		cursor: ew-resize;
		outline: none;
		top: -0.3em;
		margin-left: -0.5em;
	}

	.ui-slider .ui-slider-range {
		position: absolute;
		z-index: 1;
		font-size: 0.7em;
		display: block;
		border: 0;
		border-radius: 1em;
		background-color: #000;
	}

	.price_slider_wrapper .ui-widget-content {
		border-radius: 1em;
		background-color: #666;
		border: 0;
	}

	.ui-slider-horizontal {
		height: 0.5em;
	}

	.ui-slider-horizontal .ui-slider-range {
		top: 0;
		height: 100%;
	}

	.ui-slider-horizontal .ui-slider-range-min {
		left: -1px;
	}

	.ui-slider-horizontal .ui-slider-range-max {
		right: -1px;
	}
}

.widget_rating_filter {

	li {
		text-align: right;

		.star-rating {
			float: left;
			margin-top: 0.3em;
		}
	}
}

.widget_product_search {

	form {
		position: relative;
	}

	.search-field {
		padding-right: 100px;
	}

	input[type=submit] {
		position: absolute;
		top: 0.5em;
		right: 0.5em;
		padding-left: 1em;
		padding-right: 1em;
	}
}

/**
 * Account section
 */
.woocommerce-account {

	.woocommerce-MyAccount-navigation {
		float: right;
		width: 25%;
		border-top: 1px solid #ddd;

		li {
			list-style: none;
			padding: 0.5em 0;
			border-bottom: 1px solid #ddd;

			a {
				box-shadow: none;

				&:hover {
					box-shadow: 0 3px 0 rgba(15, 15, 15, 1);
				}
			}

			&::before {
				content: "→";
				display: inline-block;
				margin-right: 0.25em;
				color: #ddd;
			}

			&.is-active {

				a {
					box-shadow: 0 3px 0 rgba(15, 15, 15, 1);
				}
			}
		}
	}

	.woocommerce-MyAccount-content {
		float: left;
	}
}

/**
 * Cart
 */
.woocommerce-cart-form {

	td {
		padding: 1em 0.5em;
	}

	img {
		max-width: 42px;
		height: auto;
		display: block;
	}

	dl.variation {
		margin-top: 0;

		p,
		&:last-child {
			margin-bottom: 0;
		}
	}

	.button {
		padding: 1.2em 2em;
	}

	.actions {

		.input-text {
			width: 130px !important;
			float: left;
			margin-right: 0.25em;
		}
	}

	.quantity {

		input {
			width: 4em;
		}
	}
}

.cart_totals {

	th,
	td {
		vertical-align: top;
		padding: 1em 0;
		line-height: 1.5em;
	}

	th {
		padding-right: 1em;
	}

	.woocommerce-shipping-destination {
		margin-bottom: 0;
	}
}

.shipping-calculator-button {
	margin-top: 0.5em;
	display: inline-block;
}

.shipping-calculator-form {
	margin: 1em 0 0 0;
}

#shipping_method {
	list-style: none;
	margin: 0;

	li {
		margin-bottom: 0.5em;

		input {
			float: left;
			margin-top: 0.17em;
		}

		label {
			line-height: 1.5em;
		}
	}
}

.checkout-button {
	display: block;
	padding: 1em 2em;
	border: 2px solid #000;
	text-align: center;
	font-weight: 800;
	box-shadow: none !important;

	&:hover {
		box-shadow: none !important;
		border-color: #999;
	}

	&::after {
		content: "→";
	}
}

/**
 * Checkout
 */
#ship-to-different-address {

	label {
		font-weight: 300;
		cursor: pointer;

		span {
			position: relative;
			display: block;

			&::before {
				content: "";
				display: block;
				height: 16px;
				width: 30px;
				border: 2px solid #bbb;
				background: #bbb;
				border-radius: 13em;
				box-sizing: content-box;
				transition: all ease-in-out 0.3s;
				position: absolute;
				top: 4px;
				right: 0;
			}

			&::after {
				content: "";
				display: block;
				width: 14px;
				height: 14px;
				background: white;
				position: absolute;
				top: 7px;
				right: 17px;
				border-radius: 13em;
				transition: all ease-in-out 0.3s;
			}
		}

		input[type=checkbox] {
			display: none;
		}

		input[type=checkbox]:checked + span::after {
			right: 3px;
		}

		input[type=checkbox]:checked + span::before {
			border-color: #000;
			background: #000;
		}
	}
}

.woocommerce-no-js {

	form.woocommerce-form-login,
	form.woocommerce-form-coupon {
		display: block !important;
	}

	.woocommerce-form-login-toggle,
	.woocommerce-form-coupon-toggle,
	.showcoupon {
		display: none !important;
	}
}

.woocommerce-terms-and-conditions {
	border: 1px solid rgba(0, 0, 0, 0.2);
	box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
	background: rgba(0, 0, 0, 0.05);
}

.woocommerce-terms-and-conditions-link {
	display: inline-block;

	&::after {
		content: "";
		display: inline-block;
		border-style: solid;
		margin-bottom: 2px;
		margin-left: 0.25em;
		border-width: 6px 6px 0 6px;
		border-color: #111 transparent transparent transparent;
	}

	&.woocommerce-terms-and-conditions-link--open::after {
		border-width: 0 6px 6px 6px;
		border-color: transparent transparent #111 transparent;
	}
}

.woocommerce-checkout {

	.woocommerce-input-wrapper {

		.description {
			background: royalblue;
			color: #fff;
			border-radius: 3px;
			padding: 1em;
			margin: 0.5em 0 0;
			clear: both;
			display: none;
			position: relative;

			a {
				color: #fff;
				text-decoration: underline;
				border: 0;
				box-shadow: none;
			}

			&::before {
				left: 50%;
				top: 0%;
				margin-top: -4px;
				transform: translateX(-50%) rotate(180deg);
				content: "";
				position: absolute;
				border-width: 4px 6px 0 6px;
				border-style: solid;
				border-color: royalblue transparent transparent transparent;
				z-index: 100;
				display: block;
			}
		}
	}

	.select2-choice,
	.select2-choice:hover {
		box-shadow: none !important;
	}

	.select2-choice {
		padding: 0.7em 0 0.7em 0.7em;
	}

	.select2-container .select2-selection--single {
		height: 48px;
	}

	.select2-container .select2-selection--single .select2-selection__rendered {
		line-height: 48px;
	}

	.select2-container--default .select2-selection--single .select2-selection__arrow {
		height: 46px;
	}

	.select2-container--focus .select2-selection {
		border-color: black;
	}
}

.woocommerce-checkout-review-order-table {

	td {
		padding: 1em 0.5em;
	}

	dl.variation {
		margin: 0;

		p {
			margin: 0;
		}
	}
}

.wc_payment_method {
	list-style: none;
	border-bottom: 1px solid #ddd;

	.payment_box {
		padding: 2em;
		background: #eee;

		ul,
		ol {

			&:last-of-type {
				margin-bottom: 0;
			}
		}

		fieldset {
			padding: 1.5em;
			padding-bottom: 0;
			border: 0;
			background: #f6f6f6;
		}

		li {
			list-style: none;
		}

		p:last-child {
			margin-bottom: 0;
		}
	}

	> label:first-of-type {
		margin: 1em 0;

		img {
			max-height: 24px;
			max-width: 200px;
			float: right;
		}
	}

	label {
		cursor: pointer;
	}

	input.input-radio[name=payment_method] {
		display: none;

		& + label {

			&::before {
				content: "";
				display: inline-block;
				width: 16px;
				height: 16px;
				border: 2px solid white;
				box-shadow: 0 0 0 2px black;
				background: white;
				margin-left: 4px;
				margin-right: 0.5em;
				border-radius: 100%;
				transform: translateY(2px);
			}
		}

		&:checked + label {

			&::before {
				background: black;
			}
		}
	}
}

.colors-dark {

	.page-numbers {
		color: #444;

		&.next,
		&.prev {
			color: #ddd;
		}
	}

	.checkout-button {
		border: 2px solid #555;

		&:hover {
			border-color: #fff;
		}
	}

	.wc_payment_method {

		.payment_box {
			background: #333;
		}
	}

	.select2-container--default {

		.select2-results {

			.select2-results__options {
				background: #333;
			}

			.select2-results__option[data-selected="true"] {
				color: #333;
			}
		}

		.select2-selection--single {
			background-color: #333;
			border: 1px solid #555;

			.select2-selection__rendered {
				color: #ccc;
			}
		}
	}

	.select2-container--focus .select2-selection {
		border-color: white;
	}
}

/**
 * Layout stuff
 */
@media screen and (min-width: 48em) {

	.has-sidebar.woocommerce-page:not(.error404) {

		#primary {
			width: 74%;
		}

		#secondary {
			width: 20%;
		}
	}

	body.page-two-column.woocommerce-cart:not(.archive) #primary .entry-header,
	body.page-two-column.woocommerce-checkout:not(.archive) #primary .entry-header,
	body.page-two-column.woocommerce-account:not(.archive) #primary .entry-header {
		width: 16%;
	}

	body.page-two-column.woocommerce-cart:not(.archive) #primary .entry-content,
	body.page-two-column.woocommerce-checkout:not(.archive) #primary .entry-content,
	body.page-two-column.woocommerce-account:not(.archive) #primary .entry-content {
		width: 78%;
	}
}
<h1 itemprop="name" class="product_title entry-title">Leovegas Casino 100 Free Spins Utan Omsättningskra</h1>