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["Dropzone"] = factory();
  	else
  		root["Dropzone"] = 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] = {
  /******/ 			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
  	});
  	
  	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
  	
  	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 _attrAccept = __webpack_require__(1);
  	
  	var _attrAccept2 = _interopRequireDefault(_attrAccept);
  	
  	var _preact = __webpack_require__(2);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
  	
  	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  	
  	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; } /* eslint prefer-template: 0 */
  	
  	var supportMultiple = typeof document !== 'undefined' && document && document.createElement ? 'multiple' in document.createElement('input') : true;
  	
  	var Dropzone = function (_Component) {
  	  _inherits(Dropzone, _Component);
  	
  	  function Dropzone(props, context) {
  	    _classCallCheck(this, Dropzone);
  	
  	    var _this = _possibleConstructorReturn(this, (Dropzone.__proto__ || Object.getPrototypeOf(Dropzone)).call(this, props, context));
  	
  	    _this.onClick = _this.onClick.bind(_this);
  	    _this.onDragStart = _this.onDragStart.bind(_this);
  	    _this.onDragEnter = _this.onDragEnter.bind(_this);
  	    _this.onDragLeave = _this.onDragLeave.bind(_this);
  	    _this.onDragOver = _this.onDragOver.bind(_this);
  	    _this.onDrop = _this.onDrop.bind(_this);
  	    _this.onFileDialogCancel = _this.onFileDialogCancel.bind(_this);
  	    _this.fileAccepted = _this.fileAccepted.bind(_this);
  	    _this.isFileDialogActive = false;
  	
  	    _this.state = {
  	      isDragActive: false
  	    };
  	    return _this;
  	  }
  	
  	  _createClass(Dropzone, [{
  	    key: 'componentDidMount',
  	    value: function componentDidMount() {
  	      this.enterCounter = 0;
  	      // Tried implementing addEventListener, but didn't work out
  	      document.body.onfocus = this.onFileDialogCancel;
  	    }
  	  }, {
  	    key: 'componentWillUnmount',
  	    value: function componentWillUnmount() {
  	      // Can be replaced with removeEventListener, if addEventListener works
  	      document.body.onfocus = null;
  	    }
  	  }, {
  	    key: 'onDragStart',
  	    value: function onDragStart(e) {
  	      if (this.props.onDragStart) {
  	        this.props.onDragStart.call(this, e);
  	      }
  	    }
  	  }, {
  	    key: 'onDragEnter',
  	    value: function onDragEnter(e) {
  	      e.preventDefault();
  	
  	      // Count the dropzone and any children that are entered.
  	      ++this.enterCounter;
  	
  	      // This is tricky. During the drag even the dataTransfer.files is null
  	      // But Chrome implements some drag store, which is accesible via dataTransfer.items
  	      var dataTransferItems = e.dataTransfer && e.dataTransfer.items ? e.dataTransfer.items : [];
  	
  	      // Now we need to convert the DataTransferList to Array
  	      var allFilesAccepted = this.allFilesAccepted(Array.prototype.slice.call(dataTransferItems));
  	
  	      this.setState({
  	        isDragActive: allFilesAccepted,
  	        isDragReject: !allFilesAccepted
  	      });
  	
  	      if (this.props.onDragEnter) {
  	        this.props.onDragEnter.call(this, e);
  	      }
  	    }
  	  }, {
  	    key: 'onDragOver',
  	    value: function onDragOver(e) {
  	      e.preventDefault();
  	      e.stopPropagation();
  	      e.dataTransfer.dropEffect = 'copy'; // eslint-disable-line no-param-reassign
  	      return false;
  	    }
  	  }, {
  	    key: 'onDragLeave',
  	    value: function onDragLeave(e) {
  	      e.preventDefault();
  	
  	      // Only deactivate once the dropzone and all children was left.
  	      if (--this.enterCounter > 0) {
  	        return;
  	      }
  	
  	      this.setState({
  	        isDragActive: false,
  	        isDragReject: false
  	      });
  	
  	      if (this.props.onDragLeave) {
  	        this.props.onDragLeave.call(this, e);
  	      }
  	    }
  	  }, {
  	    key: 'onDrop',
  	    value: function onDrop(e) {
  	      e.preventDefault();
  	
  	      // Reset the counter along with the drag on a drop.
  	      this.enterCounter = 0;
  	
  	      this.setState({
  	        isDragActive: false,
  	        isDragReject: false
  	      });
  	
  	      var droppedFiles = e.dataTransfer ? e.dataTransfer.files : e.target.files;
  	      var max = this.props.multiple ? droppedFiles.length : Math.min(droppedFiles.length, 1);
  	      var acceptedFiles = [];
  	      var rejectedFiles = [];
  	
  	      for (var i = 0; i < max; i++) {
  	        var file = droppedFiles[i];
  	        // We might want to disable the preview creation to support big files
  	        if (!this.props.disablePreview) {
  	          file.preview = window.URL.createObjectURL(file);
  	        }
  	
  	        if (this.fileAccepted(file) && this.fileMatchSize(file)) {
  	          acceptedFiles.push(file);
  	        } else {
  	          rejectedFiles.push(file);
  	        }
  	      }
  	
  	      if (this.props.onDrop) {
  	        this.props.onDrop.call(this, acceptedFiles, rejectedFiles, e);
  	      }
  	
  	      if (rejectedFiles.length > 0) {
  	        if (this.props.onDropRejected) {
  	          this.props.onDropRejected.call(this, rejectedFiles, e);
  	        }
  	      } else if (acceptedFiles.length > 0) {
  	        if (this.props.onDropAccepted) {
  	          this.props.onDropAccepted.call(this, acceptedFiles, e);
  	        }
  	      }
  	      this.isFileDialogActive = false;
  	    }
  	  }, {
  	    key: 'onClick',
  	    value: function onClick() {
  	      if (!this.props.disableClick) {
  	        this.open();
  	      }
  	    }
  	  }, {
  	    key: 'onFileDialogCancel',
  	    value: function onFileDialogCancel() {
  	      // timeout will not recognize context of this method
  	      var onFileDialogCancel = this.props.onFileDialogCancel;
  	      var fileInputEl = this.fileInputEl;
  	      var isFileDialogActive = this.isFileDialogActive;
  	      // execute the timeout only if the onFileDialogCancel is defined and FileDialog
  	      // is opened in the browser
  	
  	      if (onFileDialogCancel && isFileDialogActive) {
  	        setTimeout(function () {
  	          // Returns an object as FileList
  	          var FileList = fileInputEl.files;
  	          if (!FileList.length) {
  	            isFileDialogActive = false;
  	            onFileDialogCancel();
  	          }
  	        }, 300);
  	      }
  	    }
  	  }, {
  	    key: 'fileAccepted',
  	    value: function fileAccepted(file) {
  	      return (0, _attrAccept2.default)(file, this.props.accept);
  	    }
  	  }, {
  	    key: 'fileMatchSize',
  	    value: function fileMatchSize(file) {
  	      return file.size <= this.props.maxSize && file.size >= this.props.minSize;
  	    }
  	  }, {
  	    key: 'allFilesAccepted',
  	    value: function allFilesAccepted(files) {
  	      return files.every(this.fileAccepted);
  	    }
  	  }, {
  	    key: 'open',
  	    value: function open() {
  	      this.isFileDialogActive = true;
  	      this.fileInputEl.value = null;
  	      this.fileInputEl.click();
  	    }
  	  }, {
  	    key: 'render',
  	    value: function render() {
  	      var _this2 = this;
  	
  	      var _props = this.props;
  	      var accept = _props.accept;
  	      var activeClassName = _props.activeClassName;
  	      var inputProps = _props.inputProps;
  	      var multiple = _props.multiple;
  	      var name = _props.name;
  	      var rejectClassName = _props.rejectClassName;
  	
  	      var rest = _objectWithoutProperties(_props, ['accept', 'activeClassName', 'inputProps', 'multiple', 'name', 'rejectClassName']);
  	
  	      var activeStyle = rest.activeStyle;
  	      var className = rest.className;
  	      var rejectStyle = rest.rejectStyle;
  	      var style = rest.style;
  	
  	      var props = _objectWithoutProperties(rest, ['activeStyle', 'className', 'rejectStyle', 'style']);
  	
  	      var _state = this.state;
  	      var isDragActive = _state.isDragActive;
  	      var isDragReject = _state.isDragReject;
  	
  	
  	      className = className || '';
  	
  	      if (isDragActive && activeClassName) {
  	        className += ' ' + activeClassName;
  	      }
  	      if (isDragReject && rejectClassName) {
  	        className += ' ' + rejectClassName;
  	      }
  	
  	      if (!className && !style && !activeStyle && !rejectStyle) {
  	        style = {
  	          width: 200,
  	          height: 200,
  	          borderWidth: 2,
  	          borderColor: '#666',
  	          borderStyle: 'dashed',
  	          borderRadius: 5
  	        };
  	        activeStyle = {
  	          borderStyle: 'solid',
  	          backgroundColor: '#eee'
  	        };
  	        rejectStyle = {
  	          borderStyle: 'solid',
  	          backgroundColor: '#ffdddd'
  	        };
  	      }
  	
  	      var appliedStyle = void 0;
  	      if (activeStyle && isDragActive) {
  	        appliedStyle = _extends({}, style, activeStyle);
  	      } else if (rejectStyle && isDragReject) {
  	        appliedStyle = _extends({}, style, rejectStyle);
  	      } else {
  	        appliedStyle = _extends({}, style);
  	      }
  	
  	      var inputAttributes = {
  	        accept: accept,
  	        type: 'file',
  	        style: { display: 'none' },
  	        multiple: supportMultiple && multiple,
  	        ref: function ref(el) {
  	          return _this2.fileInputEl = el;
  	        }, // eslint-disable-line
  	        onChange: this.onDrop
  	      };
  	
  	      if (name && name.length) {
  	        inputAttributes.name = name;
  	      }
  	
  	      // Remove custom properties before passing them to the wrapper div element
  	      var customProps = ['disablePreview', 'disableClick', 'onDropAccepted', 'onDropRejected', 'maxSize', 'minSize', 'onFileDialogCancel'];
  	      var divProps = _extends({}, props);
  	      customProps.forEach(function (prop) {
  	        return delete divProps[prop];
  	      });
  	
  	      return (0, _preact.h)(
  	        'div',
  	        _extends({
  	          'class': className,
  	          style: appliedStyle
  	        }, divProps /* expand user provided props first so event handlers are never overridden */, {
  	          onClick: this.onClick,
  	          onDragStart: this.onDragStart,
  	          onDragEnter: this.onDragEnter,
  	          onDragOver: this.onDragOver,
  	          onDragLeave: this.onDragLeave,
  	          onDrop: this.onDrop
  	        }),
  	        this.props.children,
  	        (0, _preact.h)('input', _extends({}, inputProps /* expand user provided inputProps first so inputAttributes override them */, inputAttributes))
  	      );
  	    }
  	  }]);
  	
  	  return Dropzone;
  	}(_preact.Component);
  	
  	Dropzone.defaultProps = {
  	  disablePreview: false,
  	  disableClick: false,
  	  multiple: true,
  	  maxSize: Infinity,
  	  minSize: 0
  	};
  	
  	/* Prop Types are not used in Preact, but are good as Documentation
  	Dropzone.propTypes = {
  	  // Overriding drop behavior
  	  onDrop: React.PropTypes.func,
  	  onDropAccepted: React.PropTypes.func,
  	  onDropRejected: React.PropTypes.func,
  	
  	  // Overriding drag behavior
  	  onDragStart: React.PropTypes.func,
  	  onDragEnter: React.PropTypes.func,
  	  onDragLeave: React.PropTypes.func,
  	
  	  children: React.PropTypes.node, // Contents of the dropzone
  	  style: React.PropTypes.object, // CSS styles to apply
  	  activeStyle: React.PropTypes.object, // CSS styles to apply when drop will be accepted
  	  rejectStyle: React.PropTypes.object, // CSS styles to apply when drop will be rejected
  	  className: React.PropTypes.string, // Optional className
  	  activeClassName: React.PropTypes.string, // className for accepted state
  	  rejectClassName: React.PropTypes.string, // className for rejected state
  	
  	  disablePreview: React.PropTypes.bool, // Enable/disable preview generation
  	  disableClick: React.PropTypes.bool, // Disallow clicking on the dropzone container to open file dialog
  	  onFileDialogCancel: React.PropTypes.func, // Provide a callback on clicking the cancel button of the file dialog
  	
  	  inputProps: React.PropTypes.object, // Pass additional attributes to the <input type="file"/> tag
  	  multiple: React.PropTypes.bool, // Allow dropping multiple files
  	  accept: React.PropTypes.string, // Allow specific types of files. See https://github.com/okonet/attr-accept for more information
  	  name: React.PropTypes.string, // name attribute for the input tag
  	  maxSize: React.PropTypes.number,
  	  minSize: React.PropTypes.number
  	};
  	*/
  	exports.default = Dropzone;
  
  /***/ },
  /* 1 */
  /***/ function(module, exports) {
  
  	module.exports=function(t){function n(e){if(r[e])return r[e].exports;var o=r[e]={exports:{},id:e,loaded:!1};return t[e].call(o.exports,o,o.exports,n),o.loaded=!0,o.exports}var r={};return n.m=t,n.c=r,n.p="",n(0)}([function(t,n,r){"use strict";n.__esModule=!0,r(8),r(9),n["default"]=function(t,n){if(t&&n){var r=function(){var r=n.split(","),e=t.name||"",o=t.type||"",i=o.replace(/\/.*$/,"");return{v:r.some(function(t){var n=t.trim();return"."===n.charAt(0)?e.toLowerCase().endsWith(n.toLowerCase()):/\/\*$/.test(n)?i===n.replace(/\/.*$/,""):o===n})}}();if("object"==typeof r)return r.v}return!0},t.exports=n["default"]},function(t,n){var r=t.exports={version:"1.2.2"};"number"==typeof __e&&(__e=r)},function(t,n){var r=t.exports="undefined"!=typeof window&&window.Math==Math?window:"undefined"!=typeof self&&self.Math==Math?self:Function("return this")();"number"==typeof __g&&(__g=r)},function(t,n,r){var e=r(2),o=r(1),i=r(4),u=r(19),c="prototype",f=function(t,n){return function(){return t.apply(n,arguments)}},s=function(t,n,r){var a,p,l,d,y=t&s.G,h=t&s.P,v=y?e:t&s.S?e[n]||(e[n]={}):(e[n]||{})[c],x=y?o:o[n]||(o[n]={});y&&(r=n);for(a in r)p=!(t&s.F)&&v&&a in v,l=(p?v:r)[a],d=t&s.B&&p?f(l,e):h&&"function"==typeof l?f(Function.call,l):l,v&&!p&&u(v,a,l),x[a]!=l&&i(x,a,d),h&&((x[c]||(x[c]={}))[a]=l)};e.core=o,s.F=1,s.G=2,s.S=4,s.P=8,s.B=16,s.W=32,t.exports=s},function(t,n,r){var e=r(5),o=r(18);t.exports=r(22)?function(t,n,r){return e.setDesc(t,n,o(1,r))}:function(t,n,r){return t[n]=r,t}},function(t,n){var r=Object;t.exports={create:r.create,getProto:r.getPrototypeOf,isEnum:{}.propertyIsEnumerable,getDesc:r.getOwnPropertyDescriptor,setDesc:r.defineProperty,setDescs:r.defineProperties,getKeys:r.keys,getNames:r.getOwnPropertyNames,getSymbols:r.getOwnPropertySymbols,each:[].forEach}},function(t,n){var r=0,e=Math.random();t.exports=function(t){return"Symbol(".concat(void 0===t?"":t,")_",(++r+e).toString(36))}},function(t,n,r){var e=r(20)("wks"),o=r(2).Symbol;t.exports=function(t){return e[t]||(e[t]=o&&o[t]||(o||r(6))("Symbol."+t))}},function(t,n,r){r(26),t.exports=r(1).Array.some},function(t,n,r){r(25),t.exports=r(1).String.endsWith},function(t,n){t.exports=function(t){if("function"!=typeof t)throw TypeError(t+" is not a function!");return t}},function(t,n){var r={}.toString;t.exports=function(t){return r.call(t).slice(8,-1)}},function(t,n,r){var e=r(10);t.exports=function(t,n,r){if(e(t),void 0===n)return t;switch(r){case 1:return function(r){return t.call(n,r)};case 2:return function(r,e){return t.call(n,r,e)};case 3:return function(r,e,o){return t.call(n,r,e,o)}}return function(){return t.apply(n,arguments)}}},function(t,n){t.exports=function(t){if(void 0==t)throw TypeError("Can't call method on  "+t);return t}},function(t,n,r){t.exports=function(t){var n=/./;try{"/./"[t](n)}catch(e){try{return n[r(7)("match")]=!1,!"/./"[t](n)}catch(o){}}return!0}},function(t,n){t.exports=function(t){try{return!!t()}catch(n){return!0}}},function(t,n){t.exports=function(t){return"object"==typeof t?null!==t:"function"==typeof t}},function(t,n,r){var e=r(16),o=r(11),i=r(7)("match");t.exports=function(t){var n;return e(t)&&(void 0!==(n=t[i])?!!n:"RegExp"==o(t))}},function(t,n){t.exports=function(t,n){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:n}}},function(t,n,r){var e=r(2),o=r(4),i=r(6)("src"),u="toString",c=Function[u],f=(""+c).split(u);r(1).inspectSource=function(t){return c.call(t)},(t.exports=function(t,n,r,u){"function"==typeof r&&(o(r,i,t[n]?""+t[n]:f.join(String(n))),"name"in r||(r.name=n)),t===e?t[n]=r:(u||delete t[n],o(t,n,r))})(Function.prototype,u,function(){return"function"==typeof this&&this[i]||c.call(this)})},function(t,n,r){var e=r(2),o="__core-js_shared__",i=e[o]||(e[o]={});t.exports=function(t){return i[t]||(i[t]={})}},function(t,n,r){var e=r(17),o=r(13);t.exports=function(t,n,r){if(e(n))throw TypeError("String#"+r+" doesn't accept regex!");return String(o(t))}},function(t,n,r){t.exports=!r(15)(function(){return 7!=Object.defineProperty({},"a",{get:function(){return 7}}).a})},function(t,n){var r=Math.ceil,e=Math.floor;t.exports=function(t){return isNaN(t=+t)?0:(t>0?e:r)(t)}},function(t,n,r){var e=r(23),o=Math.min;t.exports=function(t){return t>0?o(e(t),9007199254740991):0}},function(t,n,r){"use strict";var e=r(3),o=r(24),i=r(21),u="endsWith",c=""[u];e(e.P+e.F*r(14)(u),"String",{endsWith:function(t){var n=i(this,t,u),r=arguments,e=r.length>1?r[1]:void 0,f=o(n.length),s=void 0===e?f:Math.min(o(e),f),a=String(t);return c?c.call(n,a,s):n.slice(s-a.length,s)===a}})},function(t,n,r){var e=r(5),o=r(3),i=r(1).Array||Array,u={},c=function(t,n){e.each.call(t.split(","),function(t){void 0==n&&t in i?u[t]=i[t]:t in[]&&(u[t]=r(12)(Function.call,[][t],n))})};c("pop,reverse,shift,keys,values,entries",1),c("indexOf,every,some,forEach,map,filter,find,findIndex,includes",3),c("join,slice,concat,push,splice,unshift,sort,lastIndexOf,reduce,reduceRight,copyWithin,fill"),o(o.S,"Array",u)}]);
  
  /***/ },
  /* 2 */
  /***/ function(module, exports, __webpack_require__) {
  
  	!function(global, factory) {
  	     true ? factory(exports) : 'function' == typeof define && define.amd ? define([ 'exports' ], factory) : factory(global.preact = global.preact || {});
  	}(this, function(exports) {
  	    function VNode(nodeName, attributes, children) {
  	        this.nodeName = nodeName;
  	        this.attributes = attributes;
  	        this.children = children;
  	        this.key = attributes && attributes.key;
  	    }
  	    function h(nodeName, attributes) {
  	        var lastSimple, child, simple, i, children = [];
  	        for (i = arguments.length; i-- > 2; ) stack.push(arguments[i]);
  	        if (attributes && attributes.children) {
  	            if (!stack.length) stack.push(attributes.children);
  	            delete attributes.children;
  	        }
  	        while (stack.length) if ((child = stack.pop()) instanceof Array) for (i = child.length; i--; ) stack.push(child[i]); else if (null != child && child !== !1) {
  	            if ('number' == typeof child || child === !0) child = String(child);
  	            simple = 'string' == typeof child;
  	            if (simple && lastSimple) children[children.length - 1] += child; else {
  	                children.push(child);
  	                lastSimple = simple;
  	            }
  	        }
  	        var p = new VNode(nodeName, attributes || void 0, children);
  	        if (options.vnode) options.vnode(p);
  	        return p;
  	    }
  	    function extend(obj, props) {
  	        if (props) for (var i in props) obj[i] = props[i];
  	        return obj;
  	    }
  	    function clone(obj) {
  	        return extend({}, obj);
  	    }
  	    function delve(obj, key) {
  	        for (var p = key.split('.'), i = 0; i < p.length && obj; i++) obj = obj[p[i]];
  	        return obj;
  	    }
  	    function isFunction(obj) {
  	        return 'function' == typeof obj;
  	    }
  	    function isString(obj) {
  	        return 'string' == typeof obj;
  	    }
  	    function hashToClassName(c) {
  	        var str = '';
  	        for (var prop in c) if (c[prop]) {
  	            if (str) str += ' ';
  	            str += prop;
  	        }
  	        return str;
  	    }
  	    function cloneElement(vnode, props) {
  	        return h(vnode.nodeName, extend(clone(vnode.attributes), props), arguments.length > 2 ? [].slice.call(arguments, 2) : vnode.children);
  	    }
  	    function createLinkedState(component, key, eventPath) {
  	        var path = key.split('.'), p0 = path[0];
  	        return function(e) {
  	            var _component$setState;
  	            var i, t = e && e.currentTarget || this, s = component.state, obj = s, v = isString(eventPath) ? delve(e, eventPath) : t.nodeName ? (t.nodeName + t.type).match(/^input(che|rad)/i) ? t.checked : t.value : e;
  	            if (path.length > 1) {
  	                for (i = 0; i < path.length - 1; i++) obj = obj[path[i]] || (obj[path[i]] = {});
  	                obj[path[i]] = v;
  	                v = s[p0];
  	            }
  	            component.setState((_component$setState = {}, _component$setState[p0] = v, _component$setState));
  	        };
  	    }
  	    function enqueueRender(component) {
  	        if (!component._dirty && (component._dirty = !0) && 1 == items.push(component)) (options.debounceRendering || defer)(rerender);
  	    }
  	    function rerender() {
  	        var p, list = items;
  	        items = [];
  	        while (p = list.pop()) if (p._dirty) renderComponent(p);
  	    }
  	    function isFunctionalComponent(vnode) {
  	        var nodeName = vnode && vnode.nodeName;
  	        return nodeName && isFunction(nodeName) && !(nodeName.prototype && nodeName.prototype.render);
  	    }
  	    function buildFunctionalComponent(vnode, context) {
  	        return vnode.nodeName(getNodeProps(vnode), context || EMPTY);
  	    }
  	    function isSameNodeType(node, vnode) {
  	        if (isString(vnode)) return node instanceof Text;
  	        if (isString(vnode.nodeName)) return isNamedNode(node, vnode.nodeName);
  	        if (isFunction(vnode.nodeName)) return node._componentConstructor === vnode.nodeName || isFunctionalComponent(vnode); else ;
  	    }
  	    function isNamedNode(node, nodeName) {
  	        return node.normalizedNodeName === nodeName || toLowerCase(node.nodeName) === toLowerCase(nodeName);
  	    }
  	    function getNodeProps(vnode) {
  	        var props = clone(vnode.attributes);
  	        props.children = vnode.children;
  	        var defaultProps = vnode.nodeName.defaultProps;
  	        if (defaultProps) for (var i in defaultProps) if (void 0 === props[i]) props[i] = defaultProps[i];
  	        return props;
  	    }
  	    function removeNode(node) {
  	        var p = node.parentNode;
  	        if (p) p.removeChild(node);
  	    }
  	    function setAccessor(node, name, old, value, isSvg) {
  	        if ('className' === name) name = 'class';
  	        if ('class' === name && value && 'object' == typeof value) value = hashToClassName(value);
  	        if ('key' === name) ; else if ('class' === name && !isSvg) node.className = value || ''; else if ('style' === name) {
  	            if (!value || isString(value) || isString(old)) node.style.cssText = value || '';
  	            if (value && 'object' == typeof value) {
  	                if (!isString(old)) for (var i in old) if (!(i in value)) node.style[i] = '';
  	                for (var i in value) node.style[i] = 'number' == typeof value[i] && !NON_DIMENSION_PROPS[i] ? value[i] + 'px' : value[i];
  	            }
  	        } else if ('dangerouslySetInnerHTML' === name) {
  	            if (value) node.innerHTML = value.__html;
  	        } else if ('o' == name[0] && 'n' == name[1]) {
  	            var l = node._listeners || (node._listeners = {});
  	            name = toLowerCase(name.substring(2));
  	            if (value) {
  	                if (!l[name]) node.addEventListener(name, eventProxy, !!NON_BUBBLING_EVENTS[name]);
  	            } else if (l[name]) node.removeEventListener(name, eventProxy, !!NON_BUBBLING_EVENTS[name]);
  	            l[name] = value;
  	        } else if ('list' !== name && 'type' !== name && !isSvg && name in node) {
  	            setProperty(node, name, null == value ? '' : value);
  	            if (null == value || value === !1) node.removeAttribute(name);
  	        } else {
  	            var ns = isSvg && name.match(/^xlink\:?(.+)/);
  	            if (null == value || value === !1) if (ns) node.removeAttributeNS('http://www.w3.org/1999/xlink', toLowerCase(ns[1])); else node.removeAttribute(name); else if ('object' != typeof value && !isFunction(value)) if (ns) node.setAttributeNS('http://www.w3.org/1999/xlink', toLowerCase(ns[1]), value); else node.setAttribute(name, value);
  	        }
  	    }
  	    function setProperty(node, name, value) {
  	        try {
  	            node[name] = value;
  	        } catch (e) {}
  	    }
  	    function eventProxy(e) {
  	        return this._listeners[e.type](options.event && options.event(e) || e);
  	    }
  	    function collectNode(node) {
  	        removeNode(node);
  	        if (node instanceof Element) {
  	            node._component = node._componentConstructor = null;
  	            var _name = node.normalizedNodeName || toLowerCase(node.nodeName);
  	            (nodes[_name] || (nodes[_name] = [])).push(node);
  	        }
  	    }
  	    function createNode(nodeName, isSvg) {
  	        var name = toLowerCase(nodeName), node = nodes[name] && nodes[name].pop() || (isSvg ? document.createElementNS('http://www.w3.org/2000/svg', nodeName) : document.createElement(nodeName));
  	        node.normalizedNodeName = name;
  	        return node;
  	    }
  	    function flushMounts() {
  	        var c;
  	        while (c = mounts.pop()) if (c.componentDidMount) c.componentDidMount();
  	    }
  	    function diff(dom, vnode, context, mountAll, parent, componentRoot) {
  	        if (!diffLevel++) isSvgMode = parent instanceof SVGElement;
  	        var ret = idiff(dom, vnode, context, mountAll);
  	        if (parent && ret.parentNode !== parent) parent.appendChild(ret);
  	        if (!--diffLevel && !componentRoot) flushMounts();
  	        return ret;
  	    }
  	    function idiff(dom, vnode, context, mountAll) {
  	        var originalAttributes = vnode && vnode.attributes;
  	        while (isFunctionalComponent(vnode)) vnode = buildFunctionalComponent(vnode, context);
  	        if (null == vnode) vnode = '';
  	        if (isString(vnode)) {
  	            if (dom) {
  	                if (dom instanceof Text && dom.parentNode) {
  	                    dom.nodeValue = vnode;
  	                    return dom;
  	                }
  	                recollectNodeTree(dom);
  	            }
  	            return document.createTextNode(vnode);
  	        }
  	        if (isFunction(vnode.nodeName)) return buildComponentFromVNode(dom, vnode, context, mountAll);
  	        var out = dom, nodeName = vnode.nodeName, prevSvgMode = isSvgMode;
  	        if (!isString(nodeName)) nodeName = String(nodeName);
  	        isSvgMode = 'svg' === nodeName ? !0 : 'foreignObject' === nodeName ? !1 : isSvgMode;
  	        if (!dom) out = createNode(nodeName, isSvgMode); else if (!isNamedNode(dom, nodeName)) {
  	            out = createNode(nodeName, isSvgMode);
  	            while (dom.firstChild) out.appendChild(dom.firstChild);
  	            recollectNodeTree(dom);
  	        }
  	        if (vnode.children && 1 === vnode.children.length && 'string' == typeof vnode.children[0] && 1 === out.childNodes.length && out.firstChild instanceof Text) out.firstChild.nodeValue = vnode.children[0]; else if (vnode.children && vnode.children.length || out.firstChild) innerDiffNode(out, vnode.children, context, mountAll);
  	        var props = out[ATTR_KEY];
  	        if (!props) {
  	            out[ATTR_KEY] = props = {};
  	            for (var a = out.attributes, i = a.length; i--; ) props[a[i].name] = a[i].value;
  	        }
  	        diffAttributes(out, vnode.attributes, props);
  	        if (originalAttributes && 'function' == typeof originalAttributes.ref) (props.ref = originalAttributes.ref)(out);
  	        isSvgMode = prevSvgMode;
  	        return out;
  	    }
  	    function innerDiffNode(dom, vchildren, context, mountAll) {
  	        var j, c, vchild, child, originalChildren = dom.childNodes, children = [], keyed = {}, keyedLen = 0, min = 0, len = originalChildren.length, childrenLen = 0, vlen = vchildren && vchildren.length;
  	        if (len) for (var i = 0; i < len; i++) {
  	            var _child = originalChildren[i], key = vlen ? (c = _child._component) ? c.__key : (c = _child[ATTR_KEY]) ? c.key : null : null;
  	            if (key || 0 === key) {
  	                keyedLen++;
  	                keyed[key] = _child;
  	            } else children[childrenLen++] = _child;
  	        }
  	        if (vlen) for (var i = 0; i < vlen; i++) {
  	            vchild = vchildren[i];
  	            child = null;
  	            var key = vchild.key;
  	            if (null != key) {
  	                if (keyedLen && key in keyed) {
  	                    child = keyed[key];
  	                    keyed[key] = void 0;
  	                    keyedLen--;
  	                }
  	            } else if (!child && min < childrenLen) {
  	                for (j = min; j < childrenLen; j++) {
  	                    c = children[j];
  	                    if (c && isSameNodeType(c, vchild)) {
  	                        child = c;
  	                        children[j] = void 0;
  	                        if (j === childrenLen - 1) childrenLen--;
  	                        if (j === min) min++;
  	                        break;
  	                    }
  	                }
  	                if (!child && min < childrenLen && isFunction(vchild.nodeName) && mountAll) {
  	                    child = children[min];
  	                    children[min++] = void 0;
  	                }
  	            }
  	            child = idiff(child, vchild, context, mountAll);
  	            if (child && child !== dom && child !== originalChildren[i]) dom.insertBefore(child, originalChildren[i] || null);
  	        }
  	        if (keyedLen) for (var i in keyed) if (keyed[i]) recollectNodeTree(keyed[i]);
  	        if (min < childrenLen) removeOrphanedChildren(children);
  	    }
  	    function removeOrphanedChildren(children, unmountOnly) {
  	        for (var i = children.length; i--; ) if (children[i]) recollectNodeTree(children[i], unmountOnly);
  	    }
  	    function recollectNodeTree(node, unmountOnly) {
  	        var component = node._component;
  	        if (component) unmountComponent(component, !unmountOnly); else {
  	            if (node[ATTR_KEY] && node[ATTR_KEY].ref) node[ATTR_KEY].ref(null);
  	            if (!unmountOnly) collectNode(node);
  	            if (node.childNodes && node.childNodes.length) removeOrphanedChildren(node.childNodes, unmountOnly);
  	        }
  	    }
  	    function diffAttributes(dom, attrs, old) {
  	        for (var _name in old) if (!(attrs && _name in attrs) && null != old[_name]) setAccessor(dom, _name, old[_name], old[_name] = void 0, isSvgMode);
  	        if (attrs) for (var _name2 in attrs) if (!('children' === _name2 || 'innerHTML' === _name2 || _name2 in old && attrs[_name2] === ('value' === _name2 || 'checked' === _name2 ? dom[_name2] : old[_name2]))) setAccessor(dom, _name2, old[_name2], old[_name2] = attrs[_name2], isSvgMode);
  	    }
  	    function collectComponent(component) {
  	        var name = component.constructor.name, list = components[name];
  	        if (list) list.push(component); else components[name] = [ component ];
  	    }
  	    function createComponent(Ctor, props, context) {
  	        var inst = new Ctor(props, context), list = components[Ctor.name];
  	        Component.call(inst, props, context);
  	        if (list) for (var i = list.length; i--; ) if (list[i].constructor === Ctor) {
  	            inst.nextBase = list[i].nextBase;
  	            list.splice(i, 1);
  	            break;
  	        }
  	        return inst;
  	    }
  	    function setComponentProps(component, props, opts, context, mountAll) {
  	        if (!component._disable) {
  	            component._disable = !0;
  	            if (component.__ref = props.ref) delete props.ref;
  	            if (component.__key = props.key) delete props.key;
  	            if (!component.base || mountAll) {
  	                if (component.componentWillMount) component.componentWillMount();
  	            } else if (component.componentWillReceiveProps) component.componentWillReceiveProps(props, context);
  	            if (context && context !== component.context) {
  	                if (!component.prevContext) component.prevContext = component.context;
  	                component.context = context;
  	            }
  	            if (!component.prevProps) component.prevProps = component.props;
  	            component.props = props;
  	            component._disable = !1;
  	            if (0 !== opts) if (1 === opts || options.syncComponentUpdates !== !1 || !component.base) renderComponent(component, 1, mountAll); else enqueueRender(component);
  	            if (component.__ref) component.__ref(component);
  	        }
  	    }
  	    function renderComponent(component, opts, mountAll, isChild) {
  	        if (!component._disable) {
  	            var skip, rendered, inst, cbase, props = component.props, state = component.state, context = component.context, previousProps = component.prevProps || props, previousState = component.prevState || state, previousContext = component.prevContext || context, isUpdate = component.base, nextBase = component.nextBase, initialBase = isUpdate || nextBase, initialChildComponent = component._component;
  	            if (isUpdate) {
  	                component.props = previousProps;
  	                component.state = previousState;
  	                component.context = previousContext;
  	                if (2 !== opts && component.shouldComponentUpdate && component.shouldComponentUpdate(props, state, context) === !1) skip = !0; else if (component.componentWillUpdate) component.componentWillUpdate(props, state, context);
  	                component.props = props;
  	                component.state = state;
  	                component.context = context;
  	            }
  	            component.prevProps = component.prevState = component.prevContext = component.nextBase = null;
  	            component._dirty = !1;
  	            if (!skip) {
  	                if (component.render) rendered = component.render(props, state, context);
  	                if (component.getChildContext) context = extend(clone(context), component.getChildContext());
  	                while (isFunctionalComponent(rendered)) rendered = buildFunctionalComponent(rendered, context);
  	                var toUnmount, base, childComponent = rendered && rendered.nodeName;
  	                if (isFunction(childComponent)) {
  	                    inst = initialChildComponent;
  	                    var childProps = getNodeProps(rendered);
  	                    if (inst && inst.constructor === childComponent) setComponentProps(inst, childProps, 1, context); else {
  	                        toUnmount = inst;
  	                        inst = createComponent(childComponent, childProps, context);
  	                        inst.nextBase = inst.nextBase || nextBase;
  	                        inst._parentComponent = component;
  	                        component._component = inst;
  	                        setComponentProps(inst, childProps, 0, context);
  	                        renderComponent(inst, 1, mountAll, !0);
  	                    }
  	                    base = inst.base;
  	                } else {
  	                    cbase = initialBase;
  	                    toUnmount = initialChildComponent;
  	                    if (toUnmount) cbase = component._component = null;
  	                    if (initialBase || 1 === opts) {
  	                        if (cbase) cbase._component = null;
  	                        base = diff(cbase, rendered, context, mountAll || !isUpdate, initialBase && initialBase.parentNode, !0);
  	                    }
  	                }
  	                if (initialBase && base !== initialBase && inst !== initialChildComponent) {
  	                    var baseParent = initialBase.parentNode;
  	                    if (baseParent && base !== baseParent) baseParent.replaceChild(base, initialBase);
  	                    if (!cbase && !toUnmount && component._parentComponent) {
  	                        initialBase._component = null;
  	                        recollectNodeTree(initialBase);
  	                    }
  	                }
  	                if (toUnmount) unmountComponent(toUnmount, base !== initialBase);
  	                component.base = base;
  	                if (base && !isChild) {
  	                    var componentRef = component, t = component;
  	                    while (t = t._parentComponent) componentRef = t;
  	                    base._component = componentRef;
  	                    base._componentConstructor = componentRef.constructor;
  	                }
  	            }
  	            if (!isUpdate || mountAll) mounts.unshift(component); else if (!skip && component.componentDidUpdate) component.componentDidUpdate(previousProps, previousState, previousContext);
  	            var fn, cb = component._renderCallbacks;
  	            if (cb) while (fn = cb.pop()) fn.call(component);
  	            if (!diffLevel && !isChild) flushMounts();
  	        }
  	    }
  	    function buildComponentFromVNode(dom, vnode, context, mountAll) {
  	        var c = dom && dom._component, oldDom = dom, isDirectOwner = c && dom._componentConstructor === vnode.nodeName, isOwner = isDirectOwner, props = getNodeProps(vnode);
  	        while (c && !isOwner && (c = c._parentComponent)) isOwner = c.constructor === vnode.nodeName;
  	        if (c && isOwner && (!mountAll || c._component)) {
  	            setComponentProps(c, props, 3, context, mountAll);
  	            dom = c.base;
  	        } else {
  	            if (c && !isDirectOwner) {
  	                unmountComponent(c, !0);
  	                dom = oldDom = null;
  	            }
  	            c = createComponent(vnode.nodeName, props, context);
  	            if (dom && !c.nextBase) c.nextBase = dom;
  	            setComponentProps(c, props, 1, context, mountAll);
  	            dom = c.base;
  	            if (oldDom && dom !== oldDom) {
  	                oldDom._component = null;
  	                recollectNodeTree(oldDom);
  	            }
  	        }
  	        return dom;
  	    }
  	    function unmountComponent(component, remove) {
  	        var base = component.base;
  	        component._disable = !0;
  	        if (component.componentWillUnmount) component.componentWillUnmount();
  	        component.base = null;
  	        var inner = component._component;
  	        if (inner) unmountComponent(inner, remove); else if (base) {
  	            if (base[ATTR_KEY] && base[ATTR_KEY].ref) base[ATTR_KEY].ref(null);
  	            component.nextBase = base;
  	            if (remove) {
  	                removeNode(base);
  	                collectComponent(component);
  	            }
  	            removeOrphanedChildren(base.childNodes, !remove);
  	        }
  	        if (component.__ref) component.__ref(null);
  	        if (component.componentDidUnmount) component.componentDidUnmount();
  	    }
  	    function Component(props, context) {
  	        this._dirty = !0;
  	        this.context = context;
  	        this.props = props;
  	        if (!this.state) this.state = {};
  	    }
  	    function render(vnode, parent, merge) {
  	        return diff(merge, vnode, {}, !1, parent);
  	    }
  	    var options = {};
  	    var stack = [];
  	    var lcCache = {};
  	    var toLowerCase = function(s) {
  	        return lcCache[s] || (lcCache[s] = s.toLowerCase());
  	    };
  	    var resolved = 'undefined' != typeof Promise && Promise.resolve();
  	    var defer = resolved ? function(f) {
  	        resolved.then(f);
  	    } : setTimeout;
  	    var EMPTY = {};
  	    var ATTR_KEY = 'undefined' != typeof Symbol ? Symbol.for('preactattr') : '__preactattr_';
  	    var NON_DIMENSION_PROPS = {
  	        boxFlex: 1,
  	        boxFlexGroup: 1,
  	        columnCount: 1,
  	        fillOpacity: 1,
  	        flex: 1,
  	        flexGrow: 1,
  	        flexPositive: 1,
  	        flexShrink: 1,
  	        flexNegative: 1,
  	        fontWeight: 1,
  	        lineClamp: 1,
  	        lineHeight: 1,
  	        opacity: 1,
  	        order: 1,
  	        orphans: 1,
  	        strokeOpacity: 1,
  	        widows: 1,
  	        zIndex: 1,
  	        zoom: 1
  	    };
  	    var NON_BUBBLING_EVENTS = {
  	        blur: 1,
  	        error: 1,
  	        focus: 1,
  	        load: 1,
  	        resize: 1,
  	        scroll: 1
  	    };
  	    var items = [];
  	    var nodes = {};
  	    var mounts = [];
  	    var diffLevel = 0;
  	    var isSvgMode = !1;
  	    var components = {};
  	    extend(Component.prototype, {
  	        linkState: function(key, eventPath) {
  	            var c = this._linkedStates || (this._linkedStates = {});
  	            return c[key + eventPath] || (c[key + eventPath] = createLinkedState(this, key, eventPath));
  	        },
  	        setState: function(state, callback) {
  	            var s = this.state;
  	            if (!this.prevState) this.prevState = clone(s);
  	            extend(s, isFunction(state) ? state(s, this.props) : state);
  	            if (callback) (this._renderCallbacks = this._renderCallbacks || []).push(callback);
  	            enqueueRender(this);
  	        },
  	        forceUpdate: function() {
  	            renderComponent(this, 2);
  	        },
  	        render: function() {}
  	    });
  	    exports.h = h;
  	    exports.cloneElement = cloneElement;
  	    exports.Component = Component;
  	    exports.render = render;
  	    exports.rerender = rerender;
  	    exports.options = options;
  	});
  	//# sourceMappingURL=preact.js.map
  
  /***/ }
  /******/ ])
  });
  ;
  //# sourceMappingURL=index.js.map