(function (global, factory) {
	if (typeof define === "function" && define.amd) {
		define(['exports', 'react', 'classnames'], factory);
	} else if (typeof exports !== "undefined") {
		factory(exports, require('react'), require('classnames'));
	} else {
		var mod = {
			exports: {}
		};
		factory(mod.exports, global.react, global.classnames);
		global.iconSet = mod.exports;
	}
})(this, function (exports, _react, _classnames) {
	'use strict';

	Object.defineProperty(exports, "__esModule", {
		value: true
	});

	var _react2 = _interopRequireDefault(_react);

	var _classnames2 = _interopRequireDefault(_classnames);

	function _interopRequireDefault(obj) {
		return obj && obj.__esModule ? obj : {
			default: obj
		};
	}

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

	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;
		};
	}();

	function _possibleConstructorReturn(self, call) {
		if (!self) {
			throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
		}

		return call && (typeof call === "object" || typeof call === "function") ? call : self;
	}

	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 IconSet = function (_React$Component) {
		_inherits(IconSet, _React$Component);

		function IconSet() {
			_classCallCheck(this, IconSet);

			return _possibleConstructorReturn(this, (IconSet.__proto__ || Object.getPrototypeOf(IconSet)).apply(this, arguments));
		}

		_createClass(IconSet, [{
			key: 'getIconNames',
			value: function getIconNames() {
				this._icons = this._createIconMap();
				return Object.keys(this._icons).map(function (n) {
					return this.name + ':' + n;
				}, this);
			}
		}, {
			key: 'removeIcon',
			value: function removeIcon(element) {
				if (element._svgIcon) {
					(this.refs.root || element).removeChild(element._svgIcon);
					element._svgIcon = null;
				}
			}
		}, {
			key: '_renderUseIcon',
			value: function _renderUseIcon(icon, size) {
				var style = {
					pointerEvents: 'none',
					display: 'block',
					width: '100%',
					height: '100%'
				};
				var _svg = _react2.default.createElement('svg', { viewBox: '0 0 ' + size + ' ' + size, preserveAspectRatio: 'xMidYMid meet', focusable: 'false', style: style });

				return _react2.default.createElement('use', { href: '#' + icon });
			}
		}, {
			key: '_renderIcon',
			value: function _renderIcon(icon, size) {
				var icons = this._createIconMap();
				var svg = this._prepareSvgClone(icons[icon], size);
				return svg;
			}
		}, {
			key: '_createIconMap',
			value: function _createIconMap() {
				var icons = Object.create(null);
				this.refs.root.querySelectorAll('[id]').forEach(function (icon) {
					icons[icon.id] = icon;
				});
				return icons;
			}
		}, {
			key: '_prepareSvgClone',
			value: function _prepareSvgClone(sourceSvg, size) {
				if (sourceSvg) {
					var content = sourceSvg.cloneNode(true),
					    svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg'),
					    viewBox = content.getAttribute('viewBox') || '0 0 ' + size + ' ' + size,
					    cssText = 'pointer-events: none; display: block; width: 100%; height: 100%;';
					svg.setAttribute('viewBox', viewBox);
					svg.setAttribute('preserveAspectRatio', 'xMidYMid meet');
					svg.setAttribute('focusable', 'false');
					svg.style.cssText = cssText;
					svg.appendChild(content).removeAttribute('id');
					return svg;
				}
				return null;
			}
		}, {
			key: 'render',
			value: function render() {
				var _this2 = this;

				var _props = this.props,
				    name = _props.name,
				    icon = _props.icon,
				    children = _props.children,
				    size = _props.size;

				return _react2.default.createElement(
					'div',
					{ ref: function ref(e) {
							_this2.refs.root = e;
						} },
					children
				);
			}
		}]);

		return IconSet;
	}(_react2.default.Component);

	exports.default = IconSet;
});