text: /*!
   * Module Spiral and sf.js v0.0.0
   * 
   */
  (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory(require("sf"));
  	else if(typeof define === 'function' && define.amd)
  		define(["sf"], factory);
  	else {
  		var a = typeof exports === 'object' ? factory(require("sf")) : factory(root["sf"]);
  		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
  	}
  })(this, function(__WEBPACK_EXTERNAL_MODULE_1__) {
  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] = {
  /******/ 			exports: {},
  /******/ 			id: moduleId,
  /******/ 			loaded: false
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.loaded = 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;
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(0);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	Object.defineProperty(exports, "__esModule", {
  	  value: true
  	});
  	exports.default = undefined;
  	
  	var _sf = __webpack_require__(1);
  	
  	var _sf2 = _interopRequireDefault(_sf);
  	
  	var _module = __webpack_require__(2);
  	
  	var _module2 = _interopRequireDefault(_module);
  	
  	__webpack_require__(52);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	//resolved by webpack's "externals"
  	
  	
  	_sf2.default.registerInstanceType(_module2.default, "js-sf-module-class");
  	
  	/**
  	 * optional, if *.less exist
  	 * without *.less these lines in the package.json can be removed
  	 * "less": "^2.6.0"
  	 * "less-loader": "^2.2.2"
  	 * "style-loader": "^0.13.0"
  	 * "css-loader": "^0.23.1"
  	 */
  	
  	exports.default = _module2.default;
  
  /***/ },
  /* 1 */
  /***/ function(module, exports) {
  
  	module.exports = __WEBPACK_EXTERNAL_MODULE_1__;
  
  /***/ },
  /* 2 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	Object.defineProperty(exports, "__esModule", {
  	    value: true
  	});
  	exports.default = undefined;
  	
  	var _getPrototypeOf = __webpack_require__(3);
  	
  	var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
  	
  	var _classCallCheck2 = __webpack_require__(15);
  	
  	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
  	
  	var _createClass2 = __webpack_require__(16);
  	
  	var _createClass3 = _interopRequireDefault(_createClass2);
  	
  	var _possibleConstructorReturn2 = __webpack_require__(20);
  	
  	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
  	
  	var _inherits2 = __webpack_require__(45);
  	
  	var _inherits3 = _interopRequireDefault(_inherits2);
  	
  	var _sf = __webpack_require__(1);
  	
  	var _sf2 = _interopRequireDefault(_sf);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	//resolved by webpack's "externals"
  	
  	var Module = function (_sf$modules$core$Base) {
  	    (0, _inherits3.default)(Module, _sf$modules$core$Base);
  	
  	    function Module(sf, node, options) {
  	        (0, _classCallCheck3.default)(this, Module);
  	        return (0, _possibleConstructorReturn3.default)(this, (0, _getPrototypeOf2.default)(Module).call(this));
  	    }
  	
  	    (0, _createClass3.default)(Module, [{
  	        key: 'die',
  	        value: function die() {}
  	    }, {
  	        key: 'name',
  	        get: function get() {
  	            return 'module';
  	        }
  	    }]);
  	    return Module;
  	}(_sf2.default.modules.core.BaseDOMConstructor);
  	
  	exports.default = Module;
  
  /***/ },
  /* 3 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = { "default": __webpack_require__(4), __esModule: true };
  
  /***/ },
  /* 4 */
  /***/ function(module, exports, __webpack_require__) {
  
  	__webpack_require__(5);
  	module.exports = __webpack_require__(11).Object.getPrototypeOf;
  
  /***/ },
  /* 5 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// 19.1.2.9 Object.getPrototypeOf(O)
  	var toObject = __webpack_require__(6);
  	
  	__webpack_require__(8)('getPrototypeOf', function($getPrototypeOf){
  	  return function getPrototypeOf(it){
  	    return $getPrototypeOf(toObject(it));
  	  };
  	});
  
  /***/ },
  /* 6 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// 7.1.13 ToObject(argument)
  	var defined = __webpack_require__(7);
  	module.exports = function(it){
  	  return Object(defined(it));
  	};
  
  /***/ },
  /* 7 */
  /***/ function(module, exports) {
  
  	// 7.2.1 RequireObjectCoercible(argument)
  	module.exports = function(it){
  	  if(it == undefined)throw TypeError("Can't call method on  " + it);
  	  return it;
  	};
  
  /***/ },
  /* 8 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// most Object methods by ES6 should accept primitives
  	var $export = __webpack_require__(9)
  	  , core    = __webpack_require__(11)
  	  , fails   = __webpack_require__(14);
  	module.exports = function(KEY, exec){
  	  var fn  = (core.Object || {})[KEY] || Object[KEY]
  	    , exp = {};
  	  exp[KEY] = exec(fn);
  	  $export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);
  	};
  
  /***/ },
  /* 9 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var global    = __webpack_require__(10)
  	  , core      = __webpack_require__(11)
  	  , ctx       = __webpack_require__(12)
  	  , PROTOTYPE = 'prototype';
  	
  	var $export = function(type, name, source){
  	  var IS_FORCED = type & $export.F
  	    , IS_GLOBAL = type & $export.G
  	    , IS_STATIC = type & $export.S
  	    , IS_PROTO  = type & $export.P
  	    , IS_BIND   = type & $export.B
  	    , IS_WRAP   = type & $export.W
  	    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})
  	    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]
  	    , key, own, out;
  	  if(IS_GLOBAL)source = name;
  	  for(key in source){
  	    // contains in native
  	    own = !IS_FORCED && target && key in target;
  	    if(own && key in exports)continue;
  	    // export native or passed
  	    out = own ? target[key] : source[key];
  	    // prevent global pollution for namespaces
  	    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
  	    // bind timers to global for call from export context
  	    : IS_BIND && own ? ctx(out, global)
  	    // wrap global constructors for prevent change them in library
  	    : IS_WRAP && target[key] == out ? (function(C){
  	      var F = function(param){
  	        return this instanceof C ? new C(param) : C(param);
  	      };
  	      F[PROTOTYPE] = C[PROTOTYPE];
  	      return F;
  	    // make static versions for prototype methods
  	    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
  	    if(IS_PROTO)(exports[PROTOTYPE] || (exports[PROTOTYPE] = {}))[key] = out;
  	  }
  	};
  	// type bitmap
  	$export.F = 1;  // forced
  	$export.G = 2;  // global
  	$export.S = 4;  // static
  	$export.P = 8;  // proto
  	$export.B = 16; // bind
  	$export.W = 32; // wrap
  	module.exports = $export;
  
  /***/ },
  /* 10 */
  /***/ function(module, exports) {
  
  	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
  	var global = module.exports = typeof window != 'undefined' && window.Math == Math
  	  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
  	if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
  
  /***/ },
  /* 11 */
  /***/ function(module, exports) {
  
  	var core = module.exports = {version: '1.2.6'};
  	if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
  
  /***/ },
  /* 12 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// optional / simple context binding
  	var aFunction = __webpack_require__(13);
  	module.exports = function(fn, that, length){
  	  aFunction(fn);
  	  if(that === undefined)return fn;
  	  switch(length){
  	    case 1: return function(a){
  	      return fn.call(that, a);
  	    };
  	    case 2: return function(a, b){
  	      return fn.call(that, a, b);
  	    };
  	    case 3: return function(a, b, c){
  	      return fn.call(that, a, b, c);
  	    };
  	  }
  	  return function(/* ...args */){
  	    return fn.apply(that, arguments);
  	  };
  	};
  
  /***/ },
  /* 13 */
  /***/ function(module, exports) {
  
  	module.exports = function(it){
  	  if(typeof it != 'function')throw TypeError(it + ' is not a function!');
  	  return it;
  	};
  
  /***/ },
  /* 14 */
  /***/ function(module, exports) {
  
  	module.exports = function(exec){
  	  try {
  	    return !!exec();
  	  } catch(e){
  	    return true;
  	  }
  	};
  
  /***/ },
  /* 15 */
  /***/ function(module, exports) {
  
  	"use strict";
  	
  	exports.__esModule = true;
  	
  	exports.default = function (instance, Constructor) {
  	  if (!(instance instanceof Constructor)) {
  	    throw new TypeError("Cannot call a class as a function");
  	  }
  	};
  
  /***/ },
  /* 16 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	exports.__esModule = true;
  	
  	var _defineProperty = __webpack_require__(17);
  	
  	var _defineProperty2 = _interopRequireDefault(_defineProperty);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	exports.default = (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;
  	      (0, _defineProperty2.default)(target, descriptor.key, descriptor);
  	    }
  	  }
  	
  	  return function (Constructor, protoProps, staticProps) {
  	    if (protoProps) defineProperties(Constructor.prototype, protoProps);
  	    if (staticProps) defineProperties(Constructor, staticProps);
  	    return Constructor;
  	  };
  	})();
  
  /***/ },
  /* 17 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = { "default": __webpack_require__(18), __esModule: true };
  
  /***/ },
  /* 18 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var $ = __webpack_require__(19);
  	module.exports = function defineProperty(it, key, desc){
  	  return $.setDesc(it, key, desc);
  	};
  
  /***/ },
  /* 19 */
  /***/ function(module, exports) {
  
  	var $Object = Object;
  	module.exports = {
  	  create:     $Object.create,
  	  getProto:   $Object.getPrototypeOf,
  	  isEnum:     {}.propertyIsEnumerable,
  	  getDesc:    $Object.getOwnPropertyDescriptor,
  	  setDesc:    $Object.defineProperty,
  	  setDescs:   $Object.defineProperties,
  	  getKeys:    $Object.keys,
  	  getNames:   $Object.getOwnPropertyNames,
  	  getSymbols: $Object.getOwnPropertySymbols,
  	  each:       [].forEach
  	};
  
  /***/ },
  /* 20 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	exports.__esModule = true;
  	
  	var _typeof2 = __webpack_require__(21);
  	
  	var _typeof3 = _interopRequireDefault(_typeof2);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	exports.default = function (self, call) {
  	  if (!self) {
  	    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  	  }
  	
  	  return call && ((typeof call === "undefined" ? "undefined" : (0, _typeof3.default)(call)) === "object" || typeof call === "function") ? call : self;
  	};
  
  /***/ },
  /* 21 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	var _Symbol = __webpack_require__(22)["default"];
  	
  	exports["default"] = function (obj) {
  	  return obj && obj.constructor === _Symbol ? "symbol" : typeof obj;
  	};
  	
  	exports.__esModule = true;
  
  /***/ },
  /* 22 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = { "default": __webpack_require__(23), __esModule: true };
  
  /***/ },
  /* 23 */
  /***/ function(module, exports, __webpack_require__) {
  
  	__webpack_require__(24);
  	__webpack_require__(44);
  	module.exports = __webpack_require__(11).Symbol;
  
  /***/ },
  /* 24 */
  /***/ function(module, exports, __webpack_require__) {
  
  	'use strict';
  	// ECMAScript 6 symbols shim
  	var $              = __webpack_require__(19)
  	  , global         = __webpack_require__(10)
  	  , has            = __webpack_require__(25)
  	  , DESCRIPTORS    = __webpack_require__(26)
  	  , $export        = __webpack_require__(9)
  	  , redefine       = __webpack_require__(27)
  	  , $fails         = __webpack_require__(14)
  	  , shared         = __webpack_require__(30)
  	  , setToStringTag = __webpack_require__(31)
  	  , uid            = __webpack_require__(33)
  	  , wks            = __webpack_require__(32)
  	  , keyOf          = __webpack_require__(34)
  	  , $names         = __webpack_require__(38)
  	  , enumKeys       = __webpack_require__(39)
  	  , isArray        = __webpack_require__(40)
  	  , anObject       = __webpack_require__(41)
  	  , toIObject      = __webpack_require__(35)
  	  , createDesc     = __webpack_require__(29)
  	  , getDesc        = $.getDesc
  	  , setDesc        = $.setDesc
  	  , _create        = $.create
  	  , getNames       = $names.get
  	  , $Symbol        = global.Symbol
  	  , $JSON          = global.JSON
  	  , _stringify     = $JSON && $JSON.stringify
  	  , setter         = false
  	  , HIDDEN         = wks('_hidden')
  	  , isEnum         = $.isEnum
  	  , SymbolRegistry = shared('symbol-registry')
  	  , AllSymbols     = shared('symbols')
  	  , useNative      = typeof $Symbol == 'function'
  	  , ObjectProto    = Object.prototype;
  	
  	// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
  	var setSymbolDesc = DESCRIPTORS && $fails(function(){
  	  return _create(setDesc({}, 'a', {
  	    get: function(){ return setDesc(this, 'a', {value: 7}).a; }
  	  })).a != 7;
  	}) ? function(it, key, D){
  	  var protoDesc = getDesc(ObjectProto, key);
  	  if(protoDesc)delete ObjectProto[key];
  	  setDesc(it, key, D);
  	  if(protoDesc && it !== ObjectProto)setDesc(ObjectProto, key, protoDesc);
  	} : setDesc;
  	
  	var wrap = function(tag){
  	  var sym = AllSymbols[tag] = _create($Symbol.prototype);
  	  sym._k = tag;
  	  DESCRIPTORS && setter && setSymbolDesc(ObjectProto, tag, {
  	    configurable: true,
  	    set: function(value){
  	      if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;
  	      setSymbolDesc(this, tag, createDesc(1, value));
  	    }
  	  });
  	  return sym;
  	};
  	
  	var isSymbol = function(it){
  	  return typeof it == 'symbol';
  	};
  	
  	var $defineProperty = function defineProperty(it, key, D){
  	  if(D && has(AllSymbols, key)){
  	    if(!D.enumerable){
  	      if(!has(it, HIDDEN))setDesc(it, HIDDEN, createDesc(1, {}));
  	      it[HIDDEN][key] = true;
  	    } else {
  	      if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;
  	      D = _create(D, {enumerable: createDesc(0, false)});
  	    } return setSymbolDesc(it, key, D);
  	  } return setDesc(it, key, D);
  	};
  	var $defineProperties = function defineProperties(it, P){
  	  anObject(it);
  	  var keys = enumKeys(P = toIObject(P))
  	    , i    = 0
  	    , l = keys.length
  	    , key;
  	  while(l > i)$defineProperty(it, key = keys[i++], P[key]);
  	  return it;
  	};
  	var $create = function create(it, P){
  	  return P === undefined ? _create(it) : $defineProperties(_create(it), P);
  	};
  	var $propertyIsEnumerable = function propertyIsEnumerable(key){
  	  var E = isEnum.call(this, key);
  	  return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key]
  	    ? E : true;
  	};
  	var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){
  	  var D = getDesc(it = toIObject(it), key);
  	  if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;
  	  return D;
  	};
  	var $getOwnPropertyNames = function getOwnPropertyNames(it){
  	  var names  = getNames(toIObject(it))
  	    , result = []
  	    , i      = 0
  	    , key;
  	  while(names.length > i)if(!has(AllSymbols, key = names[i++]) && key != HIDDEN)result.push(key);
  	  return result;
  	};
  	var $getOwnPropertySymbols = function getOwnPropertySymbols(it){
  	  var names  = getNames(toIObject(it))
  	    , result = []
  	    , i      = 0
  	    , key;
  	  while(names.length > i)if(has(AllSymbols, key = names[i++]))result.push(AllSymbols[key]);
  	  return result;
  	};
  	var $stringify = function stringify(it){
  	  if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined
  	  var args = [it]
  	    , i    = 1
  	    , $$   = arguments
  	    , replacer, $replacer;
  	  while($$.length > i)args.push($$[i++]);
  	  replacer = args[1];
  	  if(typeof replacer == 'function')$replacer = replacer;
  	  if($replacer || !isArray(replacer))replacer = function(key, value){
  	    if($replacer)value = $replacer.call(this, key, value);
  	    if(!isSymbol(value))return value;
  	  };
  	  args[1] = replacer;
  	  return _stringify.apply($JSON, args);
  	};
  	var buggyJSON = $fails(function(){
  	  var S = $Symbol();
  	  // MS Edge converts symbol values to JSON as {}
  	  // WebKit converts symbol values to JSON as null
  	  // V8 throws on boxed symbols
  	  return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}';
  	});
  	
  	// 19.4.1.1 Symbol([description])
  	if(!useNative){
  	  $Symbol = function Symbol(){
  	    if(isSymbol(this))throw TypeError('Symbol is not a constructor');
  	    return wrap(uid(arguments.length > 0 ? arguments[0] : undefined));
  	  };
  	  redefine($Symbol.prototype, 'toString', function toString(){
  	    return this._k;
  	  });
  	
  	  isSymbol = function(it){
  	    return it instanceof $Symbol;
  	  };
  	
  	  $.create     = $create;
  	  $.isEnum     = $propertyIsEnumerable;
  	  $.getDesc    = $getOwnPropertyDescriptor;
  	  $.setDesc    = $defineProperty;
  	  $.setDescs   = $defineProperties;
  	  $.getNames   = $names.get = $getOwnPropertyNames;
  	  $.getSymbols = $getOwnPropertySymbols;
  	
  	  if(DESCRIPTORS && !__webpack_require__(43)){
  	    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
  	  }
  	}
  	
  	var symbolStatics = {
  	  // 19.4.2.1 Symbol.for(key)
  	  'for': function(key){
  	    return has(SymbolRegistry, key += '')
  	      ? SymbolRegistry[key]
  	      : SymbolRegistry[key] = $Symbol(key);
  	  },
  	  // 19.4.2.5 Symbol.keyFor(sym)
  	  keyFor: function keyFor(key){
  	    return keyOf(SymbolRegistry, key);
  	  },
  	  useSetter: function(){ setter = true; },
  	  useSimple: function(){ setter = false; }
  	};
  	// 19.4.2.2 Symbol.hasInstance
  	// 19.4.2.3 Symbol.isConcatSpreadable
  	// 19.4.2.4 Symbol.iterator
  	// 19.4.2.6 Symbol.match
  	// 19.4.2.8 Symbol.replace
  	// 19.4.2.9 Symbol.search
  	// 19.4.2.10 Symbol.species
  	// 19.4.2.11 Symbol.split
  	// 19.4.2.12 Symbol.toPrimitive
  	// 19.4.2.13 Symbol.toStringTag
  	// 19.4.2.14 Symbol.unscopables
  	$.each.call((
  	  'hasInstance,isConcatSpreadable,iterator,match,replace,search,' +
  	  'species,split,toPrimitive,toStringTag,unscopables'
  	).split(','), function(it){
  	  var sym = wks(it);
  	  symbolStatics[it] = useNative ? sym : wrap(sym);
  	});
  	
  	setter = true;
  	
  	$export($export.G + $export.W, {Symbol: $Symbol});
  	
  	$export($export.S, 'Symbol', symbolStatics);
  	
  	$export($export.S + $export.F * !useNative, 'Object', {
  	  // 19.1.2.2 Object.create(O [, Properties])
  	  create: $create,
  	  // 19.1.2.4 Object.defineProperty(O, P, Attributes)
  	  defineProperty: $defineProperty,
  	  // 19.1.2.3 Object.defineProperties(O, Properties)
  	  defineProperties: $defineProperties,
  	  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
  	  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
  	  // 19.1.2.7 Object.getOwnPropertyNames(O)
  	  getOwnPropertyNames: $getOwnPropertyNames,
  	  // 19.1.2.8 Object.getOwnPropertySymbols(O)
  	  getOwnPropertySymbols: $getOwnPropertySymbols
  	});
  	
  	// 24.3.2 JSON.stringify(value [, replacer [, space]])
  	$JSON && $export($export.S + $export.F * (!useNative || buggyJSON), 'JSON', {stringify: $stringify});
  	
  	// 19.4.3.5 Symbol.prototype[@@toStringTag]
  	setToStringTag($Symbol, 'Symbol');
  	// 20.2.1.9 Math[@@toStringTag]
  	setToStringTag(Math, 'Math', true);
  	// 24.3.3 JSON[@@toStringTag]
  	setToStringTag(global.JSON, 'JSON', true);
  
  /***/ },
  /* 25 */
  /***/ function(module, exports) {
  
  	var hasOwnProperty = {}.hasOwnProperty;
  	module.exports = function(it, key){
  	  return hasOwnProperty.call(it, key);
  	};
  
  /***/ },
  /* 26 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// Thank's IE8 for his funny defineProperty
  	module.exports = !__webpack_require__(14)(function(){
  	  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
  	});
  
  /***/ },
  /* 27 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = __webpack_require__(28);
  
  /***/ },
  /* 28 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var $          = __webpack_require__(19)
  	  , createDesc = __webpack_require__(29);
  	module.exports = __webpack_require__(26) ? function(object, key, value){
  	  return $.setDesc(object, key, createDesc(1, value));
  	} : function(object, key, value){
  	  object[key] = value;
  	  return object;
  	};
  
  /***/ },
  /* 29 */
  /***/ function(module, exports) {
  
  	module.exports = function(bitmap, value){
  	  return {
  	    enumerable  : !(bitmap & 1),
  	    configurable: !(bitmap & 2),
  	    writable    : !(bitmap & 4),
  	    value       : value
  	  };
  	};
  
  /***/ },
  /* 30 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var global = __webpack_require__(10)
  	  , SHARED = '__core-js_shared__'
  	  , store  = global[SHARED] || (global[SHARED] = {});
  	module.exports = function(key){
  	  return store[key] || (store[key] = {});
  	};
  
  /***/ },
  /* 31 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var def = __webpack_require__(19).setDesc
  	  , has = __webpack_require__(25)
  	  , TAG = __webpack_require__(32)('toStringTag');
  	
  	module.exports = function(it, tag, stat){
  	  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
  	};
  
  /***/ },
  /* 32 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var store  = __webpack_require__(30)('wks')
  	  , uid    = __webpack_require__(33)
  	  , Symbol = __webpack_require__(10).Symbol;
  	module.exports = function(name){
  	  return store[name] || (store[name] =
  	    Symbol && Symbol[name] || (Symbol || uid)('Symbol.' + name));
  	};
  
  /***/ },
  /* 33 */
  /***/ function(module, exports) {
  
  	var id = 0
  	  , px = Math.random();
  	module.exports = function(key){
  	  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
  	};
  
  /***/ },
  /* 34 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var $         = __webpack_require__(19)
  	  , toIObject = __webpack_require__(35);
  	module.exports = function(object, el){
  	  var O      = toIObject(object)
  	    , keys   = $.getKeys(O)
  	    , length = keys.length
  	    , index  = 0
  	    , key;
  	  while(length > index)if(O[key = keys[index++]] === el)return key;
  	};
  
  /***/ },
  /* 35 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// to indexed object, toObject with fallback for non-array-like ES3 strings
  	var IObject = __webpack_require__(36)
  	  , defined = __webpack_require__(7);
  	module.exports = function(it){
  	  return IObject(defined(it));
  	};
  
  /***/ },
  /* 36 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// fallback for non-array-like ES3 and non-enumerable old V8 strings
  	var cof = __webpack_require__(37);
  	module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
  	  return cof(it) == 'String' ? it.split('') : Object(it);
  	};
  
  /***/ },
  /* 37 */
  /***/ function(module, exports) {
  
  	var toString = {}.toString;
  	
  	module.exports = function(it){
  	  return toString.call(it).slice(8, -1);
  	};
  
  /***/ },
  /* 38 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
  	var toIObject = __webpack_require__(35)
  	  , getNames  = __webpack_require__(19).getNames
  	  , toString  = {}.toString;
  	
  	var windowNames = typeof window == 'object' && Object.getOwnPropertyNames
  	  ? Object.getOwnPropertyNames(window) : [];
  	
  	var getWindowNames = function(it){
  	  try {
  	    return getNames(it);
  	  } catch(e){
  	    return windowNames.slice();
  	  }
  	};
  	
  	module.exports.get = function getOwnPropertyNames(it){
  	  if(windowNames && toString.call(it) == '[object Window]')return getWindowNames(it);
  	  return getNames(toIObject(it));
  	};
  
  /***/ },
  /* 39 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// all enumerable object keys, includes symbols
  	var $ = __webpack_require__(19);
  	module.exports = function(it){
  	  var keys       = $.getKeys(it)
  	    , getSymbols = $.getSymbols;
  	  if(getSymbols){
  	    var symbols = getSymbols(it)
  	      , isEnum  = $.isEnum
  	      , i       = 0
  	      , key;
  	    while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))keys.push(key);
  	  }
  	  return keys;
  	};
  
  /***/ },
  /* 40 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// 7.2.2 IsArray(argument)
  	var cof = __webpack_require__(37);
  	module.exports = Array.isArray || function(arg){
  	  return cof(arg) == 'Array';
  	};
  
  /***/ },
  /* 41 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var isObject = __webpack_require__(42);
  	module.exports = function(it){
  	  if(!isObject(it))throw TypeError(it + ' is not an object!');
  	  return it;
  	};
  
  /***/ },
  /* 42 */
  /***/ function(module, exports) {
  
  	module.exports = function(it){
  	  return typeof it === 'object' ? it !== null : typeof it === 'function';
  	};
  
  /***/ },
  /* 43 */
  /***/ function(module, exports) {
  
  	module.exports = true;
  
  /***/ },
  /* 44 */
  /***/ function(module, exports) {
  
  
  
  /***/ },
  /* 45 */
  /***/ function(module, exports, __webpack_require__) {
  
  	"use strict";
  	
  	var _Object$create = __webpack_require__(46)["default"];
  	
  	var _Object$setPrototypeOf = __webpack_require__(48)["default"];
  	
  	exports["default"] = function (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;
  	};
  	
  	exports.__esModule = true;
  
  /***/ },
  /* 46 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = { "default": __webpack_require__(47), __esModule: true };
  
  /***/ },
  /* 47 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var $ = __webpack_require__(19);
  	module.exports = function create(P, D){
  	  return $.create(P, D);
  	};
  
  /***/ },
  /* 48 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = { "default": __webpack_require__(49), __esModule: true };
  
  /***/ },
  /* 49 */
  /***/ function(module, exports, __webpack_require__) {
  
  	__webpack_require__(50);
  	module.exports = __webpack_require__(11).Object.setPrototypeOf;
  
  /***/ },
  /* 50 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// 19.1.3.19 Object.setPrototypeOf(O, proto)
  	var $export = __webpack_require__(9);
  	$export($export.S, 'Object', {setPrototypeOf: __webpack_require__(51).set});
  
  /***/ },
  /* 51 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// Works with __proto__ only. Old v8 can't work with null proto objects.
  	/* eslint-disable no-proto */
  	var getDesc  = __webpack_require__(19).getDesc
  	  , isObject = __webpack_require__(42)
  	  , anObject = __webpack_require__(41);
  	var check = function(O, proto){
  	  anObject(O);
  	  if(!isObject(proto) && proto !== null)throw TypeError(proto + ": can't set as prototype!");
  	};
  	module.exports = {
  	  set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line
  	    function(test, buggy, set){
  	      try {
  	        set = __webpack_require__(12)(Function.call, getDesc(Object.prototype, '__proto__').set, 2);
  	        set(test, []);
  	        buggy = !(test instanceof Array);
  	      } catch(e){ buggy = true; }
  	      return function setPrototypeOf(O, proto){
  	        check(O, proto);
  	        if(buggy)O.__proto__ = proto;
  	        else set(O, proto);
  	        return O;
  	      };
  	    }({}, false) : undefined),
  	  check: check
  	};
  
  /***/ },
  /* 52 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// style-loader: Adds some css to the DOM by adding a <style> tag
  	
  	// load the styles
  	var content = __webpack_require__(53);
  	if(typeof content === 'string') content = [[module.id, content, '']];
  	// add the styles to the DOM
  	var update = __webpack_require__(55)(content, {});
  	if(content.locals) module.exports = content.locals;
  	// Hot Module Replacement
  	if(false) {
  		// When the styles change, update the <style> tags
  		if(!content.locals) {
  			module.hot.accept("!!./../node_modules/css-loader/index.js?minimize!./../node_modules/less-loader/index.js!./module.less", function() {
  				var newContent = require("!!./../node_modules/css-loader/index.js?minimize!./../node_modules/less-loader/index.js!./module.less");
  				if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
  				update(newContent);
  			});
  		}
  		// When the module is disposed, remove the <style> tags
  		module.hot.dispose(function() { update(); });
  	}
  
  /***/ },
  /* 53 */
  /***/ function(module, exports, __webpack_require__) {
  
  	exports = module.exports = __webpack_require__(54)();
  	// imports
  	
  	
  	// module
  	exports.push([module.id, ".js-sf-module-class{margin:0}", ""]);
  	
  	// exports
  
  
  /***/ },
  /* 54 */
  /***/ function(module, exports) {
  
  	/*
  		MIT License http://www.opensource.org/licenses/mit-license.php
  		Author Tobias Koppers @sokra
  	*/
  	// css base code, injected by the css-loader
  	module.exports = function() {
  		var list = [];
  	
  		// return the list of modules as css string
  		list.toString = function toString() {
  			var result = [];
  			for(var i = 0; i < this.length; i++) {
  				var item = this[i];
  				if(item[2]) {
  					result.push("@media " + item[2] + "{" + item[1] + "}");
  				} else {
  					result.push(item[1]);
  				}
  			}
  			return result.join("");
  		};
  	
  		// import a list of modules into the list
  		list.i = function(modules, mediaQuery) {
  			if(typeof modules === "string")
  				modules = [[null, modules, ""]];
  			var alreadyImportedModules = {};
  			for(var i = 0; i < this.length; i++) {
  				var id = this[i][0];
  				if(typeof id === "number")
  					alreadyImportedModules[id] = true;
  			}
  			for(i = 0; i < modules.length; i++) {
  				var item = modules[i];
  				// skip already imported module
  				// this implementation is not 100% perfect for weird media query combinations
  				//  when a module is imported multiple times with different media queries.
  				//  I hope this will never occur (Hey this way we have smaller bundles)
  				if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
  					if(mediaQuery && !item[2]) {
  						item[2] = mediaQuery;
  					} else if(mediaQuery) {
  						item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
  					}
  					list.push(item);
  				}
  			}
  		};
  		return list;
  	};
  
  
  /***/ },
  /* 55 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/*
  		MIT License http://www.opensource.org/licenses/mit-license.php
  		Author Tobias Koppers @sokra
  	*/
  	var stylesInDom = {},
  		memoize = function(fn) {
  			var memo;
  			return function () {
  				if (typeof memo === "undefined") memo = fn.apply(this, arguments);
  				return memo;
  			};
  		},
  		isOldIE = memoize(function() {
  			return /msie [6-9]\b/.test(window.navigator.userAgent.toLowerCase());
  		}),
  		getHeadElement = memoize(function () {
  			return document.head || document.getElementsByTagName("head")[0];
  		}),
  		singletonElement = null,
  		singletonCounter = 0,
  		styleElementsInsertedAtTop = [];
  	
  	module.exports = function(list, options) {
  		if(false) {
  			if(typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
  		}
  	
  		options = options || {};
  		// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
  		// tags it will allow on a page
  		if (typeof options.singleton === "undefined") options.singleton = isOldIE();
  	
  		// By default, add <style> tags to the bottom of <head>.
  		if (typeof options.insertAt === "undefined") options.insertAt = "bottom";
  	
  		var styles = listToStyles(list);
  		addStylesToDom(styles, options);
  	
  		return function update(newList) {
  			var mayRemove = [];
  			for(var i = 0; i < styles.length; i++) {
  				var item = styles[i];
  				var domStyle = stylesInDom[item.id];
  				domStyle.refs--;
  				mayRemove.push(domStyle);
  			}
  			if(newList) {
  				var newStyles = listToStyles(newList);
  				addStylesToDom(newStyles, options);
  			}
  			for(var i = 0; i < mayRemove.length; i++) {
  				var domStyle = mayRemove[i];
  				if(domStyle.refs === 0) {
  					for(var j = 0; j < domStyle.parts.length; j++)
  						domStyle.parts[j]();
  					delete stylesInDom[domStyle.id];
  				}
  			}
  		};
  	}
  	
  	function addStylesToDom(styles, options) {
  		for(var i = 0; i < styles.length; i++) {
  			var item = styles[i];
  			var domStyle = stylesInDom[item.id];
  			if(domStyle) {
  				domStyle.refs++;
  				for(var j = 0; j < domStyle.parts.length; j++) {
  					domStyle.parts[j](item.parts[j]);
  				}
  				for(; j < item.parts.length; j++) {
  					domStyle.parts.push(addStyle(item.parts[j], options));
  				}
  			} else {
  				var parts = [];
  				for(var j = 0; j < item.parts.length; j++) {
  					parts.push(addStyle(item.parts[j], options));
  				}
  				stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
  			}
  		}
  	}
  	
  	function listToStyles(list) {
  		var styles = [];
  		var newStyles = {};
  		for(var i = 0; i < list.length; i++) {
  			var item = list[i];
  			var id = item[0];
  			var css = item[1];
  			var media = item[2];
  			var sourceMap = item[3];
  			var part = {css: css, media: media, sourceMap: sourceMap};
  			if(!newStyles[id])
  				styles.push(newStyles[id] = {id: id, parts: [part]});
  			else
  				newStyles[id].parts.push(part);
  		}
  		return styles;
  	}
  	
  	function insertStyleElement(options, styleElement) {
  		var head = getHeadElement();
  		var lastStyleElementInsertedAtTop = styleElementsInsertedAtTop[styleElementsInsertedAtTop.length - 1];
  		if (options.insertAt === "top") {
  			if(!lastStyleElementInsertedAtTop) {
  				head.insertBefore(styleElement, head.firstChild);
  			} else if(lastStyleElementInsertedAtTop.nextSibling) {
  				head.insertBefore(styleElement, lastStyleElementInsertedAtTop.nextSibling);
  			} else {
  				head.appendChild(styleElement);
  			}
  			styleElementsInsertedAtTop.push(styleElement);
  		} else if (options.insertAt === "bottom") {
  			head.appendChild(styleElement);
  		} else {
  			throw new Error("Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.");
  		}
  	}
  	
  	function removeStyleElement(styleElement) {
  		styleElement.parentNode.removeChild(styleElement);
  		var idx = styleElementsInsertedAtTop.indexOf(styleElement);
  		if(idx >= 0) {
  			styleElementsInsertedAtTop.splice(idx, 1);
  		}
  	}
  	
  	function createStyleElement(options) {
  		var styleElement = document.createElement("style");
  		styleElement.type = "text/css";
  		insertStyleElement(options, styleElement);
  		return styleElement;
  	}
  	
  	function createLinkElement(options) {
  		var linkElement = document.createElement("link");
  		linkElement.rel = "stylesheet";
  		insertStyleElement(options, linkElement);
  		return linkElement;
  	}
  	
  	function addStyle(obj, options) {
  		var styleElement, update, remove;
  	
  		if (options.singleton) {
  			var styleIndex = singletonCounter++;
  			styleElement = singletonElement || (singletonElement = createStyleElement(options));
  			update = applyToSingletonTag.bind(null, styleElement, styleIndex, false);
  			remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);
  		} else if(obj.sourceMap &&
  			typeof URL === "function" &&
  			typeof URL.createObjectURL === "function" &&
  			typeof URL.revokeObjectURL === "function" &&
  			typeof Blob === "function" &&
  			typeof btoa === "function") {
  			styleElement = createLinkElement(options);
  			update = updateLink.bind(null, styleElement);
  			remove = function() {
  				removeStyleElement(styleElement);
  				if(styleElement.href)
  					URL.revokeObjectURL(styleElement.href);
  			};
  		} else {
  			styleElement = createStyleElement(options);
  			update = applyToTag.bind(null, styleElement);
  			remove = function() {
  				removeStyleElement(styleElement);
  			};
  		}
  	
  		update(obj);
  	
  		return function updateStyle(newObj) {
  			if(newObj) {
  				if(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)
  					return;
  				update(obj = newObj);
  			} else {
  				remove();
  			}
  		};
  	}
  	
  	var replaceText = (function () {
  		var textStore = [];
  	
  		return function (index, replacement) {
  			textStore[index] = replacement;
  			return textStore.filter(Boolean).join('\n');
  		};
  	})();
  	
  	function applyToSingletonTag(styleElement, index, remove, obj) {
  		var css = remove ? "" : obj.css;
  	
  		if (styleElement.styleSheet) {
  			styleElement.styleSheet.cssText = replaceText(index, css);
  		} else {
  			var cssNode = document.createTextNode(css);
  			var childNodes = styleElement.childNodes;
  			if (childNodes[index]) styleElement.removeChild(childNodes[index]);
  			if (childNodes.length) {
  				styleElement.insertBefore(cssNode, childNodes[index]);
  			} else {
  				styleElement.appendChild(cssNode);
  			}
  		}
  	}
  	
  	function applyToTag(styleElement, obj) {
  		var css = obj.css;
  		var media = obj.media;
  		var sourceMap = obj.sourceMap;
  	
  		if(media) {
  			styleElement.setAttribute("media", media)
  		}
  	
  		if(styleElement.styleSheet) {
  			styleElement.styleSheet.cssText = css;
  		} else {
  			while(styleElement.firstChild) {
  				styleElement.removeChild(styleElement.firstChild);
  			}
  			styleElement.appendChild(document.createTextNode(css));
  		}
  	}
  	
  	function updateLink(linkElement, obj) {
  		var css = obj.css;
  		var media = obj.media;
  		var sourceMap = obj.sourceMap;
  	
  		if(sourceMap) {
  			// http://stackoverflow.com/a/26603875
  			css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
  		}
  	
  		var blob = new Blob([css], { type: "text/css" });
  	
  		var oldSrc = linkElement.href;
  	
  		linkElement.href = URL.createObjectURL(blob);
  	
  		if(oldSrc)
  			URL.revokeObjectURL(oldSrc);
  	}
  
  
  /***/ }
  /******/ ])
  });
  ;
  //# sourceMappingURL=sf.module.name.js.map