text: import '@babel/runtime/helpers/objectWithoutProperties';
  import _extends from '@babel/runtime/helpers/esm/extends';
  import '@babel/runtime/helpers/slicedToArray';
  import _toConsumableArray from '@babel/runtime/helpers/esm/toConsumableArray';
  import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
  import _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck';
  import _createClass from '@babel/runtime/helpers/esm/createClass';
  import '@babel/runtime/helpers/assertThisInitialized';
  import _inherits from '@babel/runtime/helpers/esm/inherits';
  import _possibleConstructorReturn from '@babel/runtime/helpers/esm/possibleConstructorReturn';
  import _getPrototypeOf from '@babel/runtime/helpers/esm/getPrototypeOf';
  import React, { Component } from 'react';
  import 'memoize-one';
  import '@emotion/core';
  import 'react-dom';
  import '@babel/runtime/helpers/typeof';
  import { C as cleanValue } from '../../dist/index-75b02bac.browser.esm.js';
  import { S as Select } from '../../dist/Select-e1cf49ae.browser.esm.js';
  import '@emotion/css';
  import '@babel/runtime/helpers/taggedTemplateLiteral';
  import 'react-input-autosize';
  import { m as manageState } from '../../dist/stateManager-2f2b6f5b.browser.esm.js';
  
  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
  
  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
  
  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
  
  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
  
  var compareOption = function compareOption() {
    var inputValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
    var option = arguments.length > 1 ? arguments[1] : undefined;
    var candidate = String(inputValue).toLowerCase();
    var optionValue = String(option.value).toLowerCase();
    var optionLabel = String(option.label).toLowerCase();
    return optionValue === candidate || optionLabel === candidate;
  };
  
  var builtins = {
    formatCreateLabel: function formatCreateLabel(inputValue) {
      return "Create \"".concat(inputValue, "\"");
    },
    isValidNewOption: function isValidNewOption(inputValue, selectValue, selectOptions) {
      return !(!inputValue || selectValue.some(function (option) {
        return compareOption(inputValue, option);
      }) || selectOptions.some(function (option) {
        return compareOption(inputValue, option);
      }));
    },
    getNewOptionData: function getNewOptionData(inputValue, optionLabel) {
      return {
        label: optionLabel,
        value: inputValue,
        __isNew__: true
      };
    }
  };
  var defaultProps = _objectSpread({
    allowCreateWhileLoading: false,
    createOptionPosition: 'last'
  }, builtins);
  var makeCreatableSelect = function makeCreatableSelect(SelectComponent) {
    var _class, _temp;
  
    return _temp = _class = /*#__PURE__*/function (_Component) {
      _inherits(Creatable, _Component);
  
      var _super = _createSuper(Creatable);
  
      function Creatable(props) {
        var _this;
  
        _classCallCheck(this, Creatable);
  
        _this = _super.call(this, props);
        _this.select = void 0;
  
        _this.onChange = function (newValue, actionMeta) {
          var _this$props = _this.props,
              getNewOptionData = _this$props.getNewOptionData,
              inputValue = _this$props.inputValue,
              isMulti = _this$props.isMulti,
              onChange = _this$props.onChange,
              onCreateOption = _this$props.onCreateOption,
              value = _this$props.value,
              name = _this$props.name;
  
          if (actionMeta.action !== 'select-option') {
            return onChange(newValue, actionMeta);
          }
  
          var newOption = _this.state.newOption;
          var valueArray = Array.isArray(newValue) ? newValue : [newValue];
  
          if (valueArray[valueArray.length - 1] === newOption) {
            if (onCreateOption) onCreateOption(inputValue);else {
              var newOptionData = getNewOptionData(inputValue, inputValue);
              var newActionMeta = {
                action: 'create-option',
                name: name
              };
  
              if (isMulti) {
                onChange([].concat(_toConsumableArray(cleanValue(value)), [newOptionData]), newActionMeta);
              } else {
                onChange(newOptionData, newActionMeta);
              }
            }
            return;
          }
  
          onChange(newValue, actionMeta);
        };
  
        var options = props.options || [];
        _this.state = {
          newOption: undefined,
          options: options
        };
        return _this;
      }
  
      _createClass(Creatable, [{
        key: "UNSAFE_componentWillReceiveProps",
        value: function UNSAFE_componentWillReceiveProps(nextProps) {
          var allowCreateWhileLoading = nextProps.allowCreateWhileLoading,
              createOptionPosition = nextProps.createOptionPosition,
              formatCreateLabel = nextProps.formatCreateLabel,
              getNewOptionData = nextProps.getNewOptionData,
              inputValue = nextProps.inputValue,
              isLoading = nextProps.isLoading,
              isValidNewOption = nextProps.isValidNewOption,
              value = nextProps.value;
          var options = nextProps.options || [];
          var newOption = this.state.newOption;
  
          if (isValidNewOption(inputValue, cleanValue(value), options)) {
            newOption = getNewOptionData(inputValue, formatCreateLabel(inputValue));
          } else {
            newOption = undefined;
          }
  
          this.setState({
            newOption: newOption,
            options: (allowCreateWhileLoading || !isLoading) && newOption ? createOptionPosition === 'first' ? [newOption].concat(_toConsumableArray(options)) : [].concat(_toConsumableArray(options), [newOption]) : options
          });
        }
      }, {
        key: "focus",
        value: function focus() {
          this.select.focus();
        }
      }, {
        key: "blur",
        value: function blur() {
          this.select.blur();
        }
      }, {
        key: "render",
        value: function render() {
          var _this2 = this;
  
          var options = this.state.options;
          return /*#__PURE__*/React.createElement(SelectComponent, _extends({}, this.props, {
            ref: function ref(_ref) {
              _this2.select = _ref;
            },
            options: options,
            onChange: this.onChange
          }));
        }
      }]);
  
      return Creatable;
    }(Component), _class.defaultProps = defaultProps, _temp;
  }; // TODO: do this in package entrypoint
  
  var SelectCreatable = makeCreatableSelect(Select);
  var Creatable = manageState(SelectCreatable);
  
  export default Creatable;
  export { defaultProps, makeCreatableSelect };
  