(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["@open-condo/ui"] = factory();
	else
		root["@open-condo/ui"] = factory();
})(this, function() {
return /******/ (function() { // webpackBootstrap
/******/ 	"use strict";
/******/ 	// The require scope
/******/ 	var __webpack_require__ = {};
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/define property getters */
/******/ 	!function() {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = function(exports, definition) {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	!function() {
/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	!function() {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = function(exports) {
/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 			}
/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
/******/ 		};
/******/ 	}();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  colors: function() { return /* binding */ colors; }
});

;// ./src/colors/colors.ts
function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }

/**
 * This file was generated automatically
 * Do not edit directly
 */

/* eslint-disable no-empty */
// To parse this data:
//
//   import { Convert, ColorPalette } from "./file";
//
//   const colorPalette = Convert.toColorPalette(json);
//
// These functions will throw an error if the JSON doesn't
// match the expected interface, even if the JSON is valid.
// Converts JSON strings to/from your types
// and asserts the results of JSON.parse at runtime
var Convert = /*#__PURE__*/function () {
  function Convert() {
    _classCallCheck(this, Convert);
  }

  _createClass(Convert, null, [{
    key: "toColorPalette",
    value: function toColorPalette(json) {
      return cast(JSON.parse(json), r('ColorPalette'));
    }
  }, {
    key: "colorPaletteToJson",
    value: function colorPaletteToJson(value) {
      return JSON.stringify(uncast(value, r('ColorPalette')), null, 2);
    }
  }]);

  return Convert;
}();

function invalidValue(typ, val) {
  var key = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';

  if (key) {
    throw Error("Invalid value for key \"".concat(key, "\". Expected type ").concat(JSON.stringify(typ), " but got ").concat(JSON.stringify(val)));
  }

  throw Error("Invalid value ".concat(JSON.stringify(val), " for type ").concat(JSON.stringify(typ)));
}

function jsonToJSProps(typ) {
  if (typ.jsonToJS === undefined) {
    var map = {};
    typ.props.forEach(function (p) {
      return map[p.json] = {
        key: p.js,
        typ: p.typ
      };
    });
    typ.jsonToJS = map;
  }

  return typ.jsonToJS;
}

function jsToJSONProps(typ) {
  if (typ.jsToJSON === undefined) {
    var map = {};
    typ.props.forEach(function (p) {
      return map[p.js] = {
        key: p.json,
        typ: p.typ
      };
    });
    typ.jsToJSON = map;
  }

  return typ.jsToJSON;
}

function transform(val, typ, getProps) {
  var key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';

  function transformPrimitive(typ, val) {
    if (_typeof(typ) === _typeof(val)) return val;
    return invalidValue(typ, val, key);
  }

  function transformUnion(typs, val) {
    // val must validate against one typ in typs
    var l = typs.length;

    for (var i = 0; i < l; i++) {
      var _typ = typs[i];

      try {
        return transform(val, _typ, getProps);
      } catch (_) {}
    }

    return invalidValue(typs, val);
  }

  function transformEnum(cases, val) {
    if (cases.indexOf(val) !== -1) return val;
    return invalidValue(cases, val);
  }

  function transformArray(typ, val) {
    // val must be an array with no invalid elements
    if (!Array.isArray(val)) return invalidValue('array', val);
    return val.map(function (el) {
      return transform(el, typ, getProps);
    });
  }

  function transformDate(val) {
    if (val === null) {
      return null;
    }

    var d = new Date(val);

    if (isNaN(d.valueOf())) {
      return invalidValue('Date', val);
    }

    return d;
  }

  function transformObject(props, additional, val) {
    if (val === null || _typeof(val) !== 'object' || Array.isArray(val)) {
      return invalidValue('object', val);
    }

    var result = {};
    Object.getOwnPropertyNames(props).forEach(function (key) {
      var prop = props[key];
      var v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
      result[prop.key] = transform(v, prop.typ, getProps, prop.key);
    });
    Object.getOwnPropertyNames(val).forEach(function (key) {
      if (!Object.prototype.hasOwnProperty.call(props, key)) {
        result[key] = transform(val[key], additional, getProps, key);
      }
    });
    return result;
  }

  if (typ === 'any') return val;

  if (typ === null) {
    if (val === null) return val;
    return invalidValue(typ, val);
  }

  if (typ === false) return invalidValue(typ, val);

  while (_typeof(typ) === 'object' && typ.ref !== undefined) {
    typ = typeMap[typ.ref];
  }

  if (Array.isArray(typ)) return transformEnum(typ, val);

  if (_typeof(typ) === 'object') {
    return typ.hasOwnProperty('unionMembers') ? transformUnion(typ.unionMembers, val) : typ.hasOwnProperty('arrayItems') ? transformArray(typ.arrayItems, val) : typ.hasOwnProperty('props') ? transformObject(getProps(typ), typ.additional, val) : invalidValue(typ, val);
  } // Numbers can be parsed by Date but shouldn't be.


  if (typ === Date && typeof val !== 'number') return transformDate(val);
  return transformPrimitive(typ, val);
}

function cast(val, typ) {
  return transform(val, typ, jsonToJSProps);
}

function uncast(val, typ) {
  return transform(val, typ, jsToJSONProps);
} // eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore


function a(typ) {
  return {
    arrayItems: typ
  };
} // eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore


function u() {
  for (var _len = arguments.length, typs = new Array(_len), _key = 0; _key < _len; _key++) {
    typs[_key] = arguments[_key];
  }

  return {
    unionMembers: typs
  };
}

function o(props, additional) {
  return {
    props: props,
    additional: additional
  };
} // eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore


function m(additional) {
  return {
    props: [],
    additional: additional
  };
}

function r(name) {
  return {
    ref: name
  };
}

var typeMap = {
  'ColorPalette': o([{
    json: 'white',
    js: 'white',
    typ: ''
  }, {
    json: 'black',
    js: 'black',
    typ: ''
  }, {
    json: 'brandGradient',
    js: 'brandGradient',
    typ: m('')
  }, {
    json: 'green',
    js: 'green',
    typ: m('')
  }, {
    json: 'red',
    js: 'red',
    typ: m('')
  }, {
    json: 'yellow',
    js: 'yellow',
    typ: m('')
  }, {
    json: 'orange',
    js: 'orange',
    typ: m('')
  }, {
    json: 'blue',
    js: 'blue',
    typ: m('')
  }, {
    json: 'purple',
    js: 'purple',
    typ: m('')
  }, {
    json: 'pink',
    js: 'pink',
    typ: m('')
  }, {
    json: 'brown',
    js: 'brown',
    typ: m('')
  }, {
    json: 'teal',
    js: 'teal',
    typ: m('')
  }, {
    json: 'cyan',
    js: 'cyan',
    typ: m('')
  }, {
    json: 'gray',
    js: 'gray',
    typ: m('')
  }], false)
};
;// ./src/colors/colors.json
var colors_colors_namespaceObject = /*#__PURE__*/JSON.parse('{"white":"#fff","black":"#222222","brandGradient":{"1":"linear-gradient(90deg, #e2ffeb 0%, #e7f4ff 100%)","3":"linear-gradient(90deg, #85eba4 0%, #9fd5ff 100%)","5":"linear-gradient(90deg, #26c756 0%, #4ba2e4 100%)","7":"linear-gradient(90deg, #2abb56 0%, #3996dd 100%)"},"green":{"1":"#ebfaef","3":"#88e2a3","5":"#2bc359","7":"#00b538"},"red":{"1":"#ffeceb","3":"#ff938e","5":"#ff3b30","7":"#ec0000"},"yellow":{"1":"#fef8dd","3":"#fcea99","5":"#fadd56","7":"#e9c000"},"orange":{"1":"#fff5e6","3":"#ffbf66","5":"#ff9500","7":"#da7f00"},"blue":{"1":"#e7f4ff","3":"#7dc0f8","5":"#2696f3","7":"#0b78d2"},"purple":{"1":"#f2e9ff","3":"#9e7add","5":"#5e22c6","7":"#4b1c9e"},"pink":{"1":"#ffeef3","3":"#f38aa7","5":"#eb3468","7":"#d21f52"},"brown":{"1":"#f8f1e7","3":"#d2aa6e","5":"#b4710d","7":"#8d590c"},"teal":{"1":"#e9f3f2","3":"#6db8b3","5":"#1c7e79","7":"#135754"},"cyan":{"1":"#edfcf8","3":"#a0e5d2","5":"#5eceb0","7":"#249677"},"gray":{"1":"#f2f4f6","3":"#e1e5ed","5":"#d0d3e5","7":"#707695"}}');
;// ./src/colors/index.ts


var colors = Convert.toColorPalette(JSON.stringify(colors_colors_namespaceObject));

/******/ 	return __webpack_exports__;
/******/ })()
;
});