(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory(require("react"));
	else if(typeof define === 'function' && define.amd)
		define(["react"], factory);
	else if(typeof exports === 'object')
		exports["components/paragraph/index"] = factory(require("react"));
	else
		root["components/paragraph/index"] = factory(root["react"]);
})(typeof self !== 'undefined' ? self : this, function(__WEBPACK_EXTERNAL_MODULE_0__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "/";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 41);
/******/ })
/************************************************************************/
/******/ ({

/***/ 0:
/***/ (function(module, exports) {

module.exports = __WEBPACK_EXTERNAL_MODULE_0__;

/***/ }),

/***/ 1:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export cache */
/* unused harmony export Box */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Block; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return Inline; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return InlineBlock; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return Row; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return Col; });
/* unused harmony export Grid */
/* unused harmony export install */
/* unused harmony export Table */
/* unused harmony export TableRow */
/* unused harmony export TableCell */
/* unused harmony export Flex */
/* unused harmony export InlineFlex */
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_jsxstyle_utils__ = __webpack_require__(12);



/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */

var extendStatics =
  Object.setPrototypeOf ||
  ({ __proto__: [] } instanceof Array &&
    function(d, b) {
      d.__proto__ = b;
    }) ||
  function(d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
  };

function __extends(d, b) {
  extendStatics(d, b);
  function __() {
    this.constructor = d;
  }
  d.prototype =
    b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
}

var __assign =
  Object.assign ||
  function __assign(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
      s = arguments[i];
      for (var p in s)
        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
    }
    return t;
  };

var cache = Object(__WEBPACK_IMPORTED_MODULE_1_jsxstyle_utils__["b" /* getStyleCache */])();
function factory(displayName, defaultProps) {
  var tagName = 'div';
  return (
    (_a = /** @class */ (function(_super) {
      __extends(JsxstyleComponent, _super);
      function JsxstyleComponent(props) {
        var _this = _super.call(this, props) || this;
        _this.component = props.component || tagName;
        _this.className = cache.getClassName(props, props.className);
        return _this;
      }
      JsxstyleComponent.prototype.componentWillReceiveProps = function(props) {
        this.component = props.component || tagName;
        this.className = cache.getClassName(props, props.className);
      };
      JsxstyleComponent.prototype.render = function() {
        var _a = this.props,
          props = _a.props,
          style = _a.style,
          children = _a.children;
        return Object(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])(
          this.component,
          __assign({}, props, { className: this.className, style: style }),
          children
        );
      };
      return JsxstyleComponent;
    })(__WEBPACK_IMPORTED_MODULE_0_react__["Component"])),
    (_a.defaultProps = defaultProps),
    (_a.displayName = displayName),
    _a
  );
  var _a;
}
var Box = factory('Box');
var Block = factory('Block', __WEBPACK_IMPORTED_MODULE_1_jsxstyle_utils__["a" /* componentStyles */].Block);
var Inline = factory('Inline', __WEBPACK_IMPORTED_MODULE_1_jsxstyle_utils__["a" /* componentStyles */].Inline);
var InlineBlock = factory('InlineBlock', __WEBPACK_IMPORTED_MODULE_1_jsxstyle_utils__["a" /* componentStyles */].InlineBlock);
var Row = factory('Row', __WEBPACK_IMPORTED_MODULE_1_jsxstyle_utils__["a" /* componentStyles */].Row);
var Col = factory('Col', __WEBPACK_IMPORTED_MODULE_1_jsxstyle_utils__["a" /* componentStyles */].Col);
var Grid = factory('Grid', __WEBPACK_IMPORTED_MODULE_1_jsxstyle_utils__["a" /* componentStyles */].Grid);
function install() {
  console.error(
    'jsxstyle\u2019s `install` method is no longer required and will be removed in jsxstyle 2.0.'
  );
}
function depFactory(displayName, defaultProps) {
  var hasWarned = false;
  return (
    (_a = /** @class */ (function(_super) {
      __extends(DeprecatedJsxstyleComponent, _super);
      function DeprecatedJsxstyleComponent() {
        return (_super !== null && _super.apply(this, arguments)) || this;
      }
      DeprecatedJsxstyleComponent.prototype.componentWillMount = function() {
        if (false) {
          if (!hasWarned) {
            hasWarned = true;
            console.error(
              'jsxstyle\u2019s `%s` component is deprecated and will be removed in future versions of jsxstyle.',
              displayName
            );
          }
        }
      };
      DeprecatedJsxstyleComponent.prototype.render = function() {
        return Object(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])(Box, __assign({}, this.props));
      };
      return DeprecatedJsxstyleComponent;
    })(__WEBPACK_IMPORTED_MODULE_0_react__["Component"])),
    (_a.displayName = displayName),
    (_a.defaultProps = defaultProps),
    _a
  );
  var _a;
}
// <Box component="table" />
var Table = depFactory('Table', { display: 'table' });
var TableRow = depFactory('TableRow', { display: 'table-row' });
var TableCell = depFactory('TableCell', { display: 'table-cell' });
// <Row display="inline-flex" />
var Flex = depFactory('Flex', { display: 'flex' });
var InlineFlex = depFactory('InlineFlex', { display: 'inline-flex' });




/***/ }),

/***/ 12:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export addStyleToHead */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return componentStyles; });
/* unused harmony export dangerousStyleValue */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getStyleCache; });
/* unused harmony export getStyleKeysForProps */
/* unused harmony export pseudoelements */
/* unused harmony export pseudoclasses */
/* unused harmony export hyphenateStyleName */
/* unused harmony export stringHash */
var canUseDOM = !!(
  typeof window !== 'undefined' &&
  window.document &&
  window.document.createElement
);
var styleElement;
if (
  false
) {
  // gross
  var hot = module.hot;
  if (typeof hot.data === 'object') {
    styleElement = hot.data.styleElement;
  }
  hot.addDisposeHandler(function(data) {
    data.styleElement = styleElement;
  });
}
if (canUseDOM && !styleElement) {
  styleElement = document.createElement('style');
  styleElement.type = 'text/css';
  styleElement.appendChild(document.createTextNode('/* jsxstyle */'));
  document.head.appendChild(styleElement);
}
function addStyleToHead(rule) {
  if (styleElement) {
    var sheet = styleElement.sheet;
    try {
      sheet.insertRule(rule, sheet.cssRules.length);
    } catch (insertError) {
      // insertRule will fail for rules with pseudoelements the browser doesn't support.
      // see: https://github.com/smyte/jsxstyle/issues/75
      if (false) {
        // eslint-disable-next-line no-console
        console.error(
          '[jsxstyle] Could not insert rule at position ' +
            sheet.cssRules.length +
            ': `' +
            rule +
            '`'
        );
      }
    }
  }
}

var componentStyles = {
  Box: null,
  Block: { display: 'block' },
  Inline: { display: 'inline' },
  InlineBlock: { display: 'inline-block' },
  Row: { display: 'flex', flexDirection: 'row' },
  Col: { display: 'flex', flexDirection: 'column' },
  Grid: { display: 'grid' },
};

/**
 * Copyright 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 */
//  A hearty blend of the following two files:
// https://github.com/facebook/react/blob/master/src/renderers/dom/shared/CSSProperty.js
// https://github.com/facebook/react/blob/master/src/renderers/dom/shared/dangerousStyleValue.js
var isUnitlessNumber = {
  animationIterationCount: true,
  borderImageOutset: true,
  borderImageSlice: true,
  borderImageWidth: true,
  boxFlex: true,
  boxFlexGroup: true,
  boxOrdinalGroup: true,
  columnCount: true,
  columns: true,
  flex: true,
  flexGrow: true,
  flexPositive: true,
  flexShrink: true,
  flexNegative: true,
  flexOrder: true,
  gridRow: true,
  gridRowEnd: true,
  gridRowSpan: true,
  gridRowStart: true,
  gridColumn: true,
  gridColumnEnd: true,
  gridColumnSpan: true,
  gridColumnStart: true,
  fontWeight: true,
  lineClamp: true,
  lineHeight: true,
  opacity: true,
  order: true,
  orphans: true,
  tabSize: true,
  widows: true,
  zIndex: true,
  zoom: true,
  // SVG-related properties
  fillOpacity: true,
  floodOpacity: true,
  stopOpacity: true,
  strokeDasharray: true,
  strokeDashoffset: true,
  strokeMiterlimit: true,
  strokeOpacity: true,
  strokeWidth: true,
};
function prefixKey(prefix, key) {
  return prefix + key.charAt(0).toUpperCase() + key.substring(1);
}
var prefixes = ['Webkit', 'ms', 'Moz', 'O'];
Object.keys(isUnitlessNumber).forEach(function(prop) {
  prefixes.forEach(function(prefix) {
    isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
  });
});
function dangerousStyleValue(name, value) {
  var isEmpty = value == null || typeof value === 'boolean' || value === '';
  if (isEmpty) {
    return '';
  }
  if (
    typeof value === 'number' &&
    value !== 0 &&
    !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])
  ) {
    if (value > -1 && value < 1) {
      return Math.round(value * 1e6) / 1e4 + '%';
    }
    return value + 'px';
  }
  return ('' + value).trim();
}

var uppercasePattern = /([A-Z])/g;
var msPattern = /^ms-/;
var hyphenateCache = {};
function hyphenateStyleName(styleName) {
  if (hyphenateCache.hasOwnProperty(styleName)) {
    return hyphenateCache[styleName];
  }
  var hyphenatedString = styleName
    .replace(uppercasePattern, '-$1')
    .toLowerCase()
    .replace(msPattern, '-ms-');
  hyphenateCache[styleName] = hyphenatedString;
  return hyphenateCache[styleName];
}

// global flag makes subsequent calls of capRegex.test advance to the next match
var capRegex = /[A-Z]/g;
var pseudoelements = {
  after: true,
  before: true,
  placeholder: true,
  selection: true,
};
var pseudoclasses = {
  active: true,
  checked: true,
  disabled: true,
  empty: true,
  enabled: true,
  focus: true,
  hover: true,
  invalid: true,
  required: true,
  target: true,
  valid: true,
};
var specialCaseProps = {
  children: true,
  class: true,
  className: true,
  component: true,
  props: true,
  style: true,
  mediaQueries: true,
};
function getStyleKeysForProps(props, pretty) {
  if (pretty === void 0) {
    pretty = false;
  }
  if (typeof props !== 'object' || props === null) {
    return null;
  }
  var propKeys = Object.keys(props).sort();
  var keyCount = propKeys.length;
  if (keyCount === 0) {
    return null;
  }
  var mediaQueries = props.mediaQueries;
  var hasMediaQueries = typeof mediaQueries === 'object';
  var usesMediaQueries = false;
  var styleKeyObj = {};
  var classNameKey = '';
  var seenMQs = {};
  var mqSortKeys = {};
  if (hasMediaQueries) {
    var idx = -1;
    for (var k in mediaQueries) {
      mqSortKeys[k] = '@' + (1000 + ++idx);
    }
  }
  for (var idx = -1; ++idx < keyCount; ) {
    var originalPropName = propKeys[idx];
    if (
      specialCaseProps.hasOwnProperty(originalPropName) ||
      !props.hasOwnProperty(originalPropName)
    ) {
      continue;
    }
    var propName = originalPropName;
    var propSansMQ = void 0;
    var pseudoelement = void 0;
    var pseudoclass = void 0;
    var mqKey = void 0;
    capRegex.lastIndex = 0;
    var splitIndex = 0;
    var prefix =
      capRegex.test(originalPropName) &&
      capRegex.lastIndex > 1 &&
      originalPropName.slice(0, capRegex.lastIndex - 1);
    // check for media query prefix
    if (prefix && hasMediaQueries && mediaQueries.hasOwnProperty(prefix)) {
      usesMediaQueries = true;
      mqKey = prefix;
      splitIndex = capRegex.lastIndex - 1;
      propSansMQ =
        originalPropName[splitIndex].toLowerCase() +
        originalPropName.slice(splitIndex + 1);
      prefix =
        capRegex.test(originalPropName) &&
        propSansMQ.slice(0, capRegex.lastIndex - splitIndex - 1);
    }
    // check for pseudoelement prefix
    if (prefix && pseudoelements.hasOwnProperty(prefix)) {
      pseudoelement = prefix;
      splitIndex = capRegex.lastIndex - 1;
      prefix =
        capRegex.test(originalPropName) &&
        originalPropName[splitIndex].toLowerCase() +
          originalPropName.slice(splitIndex + 1, capRegex.lastIndex - 1);
    }
    // check for pseudoclass prefix
    if (prefix && pseudoclasses.hasOwnProperty(prefix)) {
      pseudoclass = prefix;
      splitIndex = capRegex.lastIndex - 1;
    }
    // trim prefixes off propName
    if (splitIndex > 0) {
      propName =
        originalPropName[splitIndex].toLowerCase() +
        originalPropName.slice(splitIndex + 1);
    }
    var styleValue = dangerousStyleValue(propName, props[originalPropName]);
    if (styleValue === '') {
      continue;
    }
    var mediaQuery = mqKey && mediaQueries[mqKey];
    var mqSortKey = mqKey && mqSortKeys[mqKey];
    var key =
      '.' +
      (mqSortKey || '') +
      (pseudoclass ? ':' + pseudoclass : '') +
      (pseudoelement ? '::' + pseudoelement : '');
    if (!styleKeyObj.hasOwnProperty(key)) {
      styleKeyObj[key] = { styles: pretty ? '\n' : '' };
      if (mediaQuery) styleKeyObj[key].mediaQuery = mediaQuery;
      if (pseudoclass) styleKeyObj[key].pseudoclass = pseudoclass;
      if (pseudoelement) styleKeyObj[key].pseudoelement = pseudoelement;
    }
    if (mediaQuery) {
      seenMQs[mediaQuery] = seenMQs[mediaQuery] || '';
      seenMQs[mediaQuery] += propSansMQ + ':' + styleValue + ';';
    } else {
      classNameKey += originalPropName + ':' + styleValue + ';';
    }
    styleKeyObj[key].styles +=
      (pretty ? '  ' : '') +
      hyphenateStyleName(propName) +
      (pretty ? ': ' : ':') +
      styleValue +
      (pretty ? ';\n' : ';');
  }
  // append media query key
  if (usesMediaQueries) {
    var mqKeys = Object.keys(seenMQs).sort();
    for (var idx = -1, len = mqKeys.length; ++idx < len; ) {
      var mediaQuery = mqKeys[idx];
      classNameKey += '@' + mediaQuery + '~' + seenMQs[mediaQuery];
    }
  }
  if (classNameKey === '') {
    return null;
  }
  styleKeyObj.classNameKey = classNameKey;
  return styleKeyObj;
}

// thx darksky: https://git.io/v9kWO
function stringHash(str) {
  var hash = 5381,
    i = str.length;
  while (i) {
    hash = (hash * 33) ^ str.charCodeAt(--i);
  }
  /* JavaScript does bitwise operations (like XOR, above) on 32-bit signed
     * integers. Since we want the results to be always positive, convert the
     * signed int to an unsigned by doing an unsigned bitshift. */
  return hash >>> 0;
}

function cannotInject() {
  throw new Error(
    'jsxstyle error: `injectOptions` must be called before any jsxstyle components mount.'
  );
}
function alreadyInjected() {
  throw new Error(
    'jsxstyle error: `injectOptions` should be called once and only once.'
  );
}
function getStringHash(key) {
  return '_' + stringHash(key).toString(36);
}
function getStyleCache() {
  var _classNameCache = {};
  var getClassNameForKey = getStringHash;
  var onInsertRule;
  var pretty = false;
  var styleCache = {
    reset: function() {
      _classNameCache = {};
    },
    injectOptions: function(options) {
      if (options) {
        if (options.getClassName) getClassNameForKey = options.getClassName;
        if (options.onInsertRule) onInsertRule = options.onInsertRule;
        if (options.pretty) pretty = options.pretty;
      }
      styleCache.injectOptions = alreadyInjected;
    },
    getClassName: function(props, classNameProp) {
      styleCache.injectOptions = cannotInject;
      var styleObj = getStyleKeysForProps(props, pretty);
      if (typeof styleObj !== 'object' || styleObj === null) {
        return classNameProp || null;
      }
      var key = styleObj.classNameKey;
      if (key && !_classNameCache.hasOwnProperty(key)) {
        _classNameCache[key] = getClassNameForKey(key, props);
        delete styleObj.classNameKey;
        Object.keys(styleObj)
          .sort()
          .forEach(function(k) {
            var selector = '.' + _classNameCache[key];
            // prettier-ignore
            var _a = styleObj[k], pseudoclass = _a.pseudoclass, pseudoelement = _a.pseudoelement, mediaQuery = _a.mediaQuery, styles = _a.styles;
            var rule =
              selector +
              (pseudoclass ? ':' + pseudoclass : '') +
              (pseudoelement ? '::' + pseudoelement : '') +
              (' {' + styles + '}');
            if (mediaQuery) {
              rule = '@media ' + mediaQuery + ' { ' + rule + ' }';
            }
            if (
              onInsertRule &&
              // if the function returns false, bail.
              onInsertRule(rule, props) === false
            ) {
              return;
            }
            addStyleToHead(rule);
          });
      }
      return _classNameCache[key] && classNameProp
        ? classNameProp + ' ' + _classNameCache[key]
        : _classNameCache[key] || classNameProp || null;
    },
  };
  return styleCache;
}




/***/ }),

/***/ 41:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__paragraph__ = __webpack_require__(42);
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return __WEBPACK_IMPORTED_MODULE_0__paragraph__["a"]; });



/***/ }),

/***/ 42:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_jsxstyle__ = __webpack_require__(1);


const Paragraph = props => {
    return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_1_jsxstyle__["a" /* Block */], Object.assign({ margin: '1em 0' }, props));
};
/* harmony default export */ __webpack_exports__["a"] = (Paragraph);


/***/ })

/******/ });
});
//# sourceMappingURL=index.js.map