@cleartrip/ct-design-style-manager 3.1.0-SNAPSHOT-test.6

package/dist/ct-design-styleManager.umd.js

@@ -0,0 +1,829 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@cleartrip/ct-design-theme'), require('react'), require('@emotion/css')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@cleartrip/ct-design-theme', 'react', '@emotion/css'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.CTDesignSystem = {}, global.ctDesignTheme, global.React, global.css));
+})(this, (function (exports, ctDesignTheme, react, css) { 'use strict';
+
+    var useStableMemo = function (callback, deps) {
+        return react.useMemo(function () {
+            return callback();
+        }, deps);
+    };
+
+    function normalizeColor(color) {
+        {
+            return color;
+        }
+    }
+    var isWebColor = function (color) {
+        return color === 'currentcolor' || color === 'currentColor' || color === 'inherit' || color.indexOf('var(') === 0;
+    };
+    var normalizeColorWrapper = function (color, opacity) {
+        if (color == null)
+            return;
+        if (typeof color === 'string' && isWebColor(color)) {
+            return color;
+        }
+    };
+    var colorProps = {
+        backgroundColor: true,
+        borderColor: true,
+        borderTopColor: true,
+        borderRightColor: true,
+        borderBottomColor: true,
+        borderLeftColor: true,
+        color: true,
+        shadowColor: true,
+        textDecorationColor: true,
+        textShadowColor: true,
+    };
+    var unitlessNumbers = {
+        animationIterationCount: true,
+        aspectRatio: true,
+        borderImageOutset: true,
+        borderImageSlice: true,
+        borderImageWidth: true,
+        boxFlex: true,
+        boxFlexGroup: true,
+        boxOrdinalGroup: true,
+        columnCount: true,
+        flex: true,
+        flexGrow: true,
+        flexOrder: true,
+        flexPositive: true,
+        flexShrink: true,
+        flexNegative: true,
+        fontWeight: true,
+        gridRow: true,
+        gridRowEnd: true,
+        gridRowGap: true,
+        gridRowStart: true,
+        gridColumn: true,
+        gridColumnEnd: true,
+        gridColumnGap: true,
+        gridColumnStart: true,
+        lineClamp: true,
+        opacity: true,
+        order: true,
+        orphans: true,
+        tabSize: true,
+        widows: true,
+        zIndex: true,
+        zoom: true,
+        fillOpacity: true,
+        floodOpacity: true,
+        stopOpacity: true,
+        strokeDasharray: true,
+        strokeDashoffset: true,
+        strokeMiterlimit: true,
+        strokeOpacity: true,
+        strokeWidth: true,
+        scale: true,
+        scaleX: true,
+        scaleY: true,
+        scaleZ: true,
+        shadowOpacity: true,
+    };
+    function normalizeValueWithProperty(value, property) {
+        var returnValue = value;
+        if ((property == null || !unitlessNumbers[property]) && typeof value === 'number') {
+            returnValue = "".concat(value, "px");
+        }
+        else if (property != null && colorProps[property]) {
+            returnValue = normalizeColor(value);
+        }
+        return returnValue;
+    }
+    var emptyObject = {};
+    var defaultOffset = { height: 0, width: 0 };
+    var createBoxShadowValue = function (style) {
+        var shadowColor = style.shadowColor, shadowOffset = style.shadowOffset; style.shadowOpacity; var shadowRadius = style.shadowRadius;
+        var _a = shadowOffset || defaultOffset, height = _a.height, width = _a.width;
+        var offsetX = normalizeValueWithProperty(width);
+        var offsetY = normalizeValueWithProperty(height);
+        var blurRadius = normalizeValueWithProperty(shadowRadius || 0);
+        var color = normalizeColorWrapper(shadowColor || 'black');
+        if (color != null && offsetX != null && offsetY != null && blurRadius != null) {
+            return "".concat(offsetX, " ").concat(offsetY, " ").concat(blurRadius, " ").concat(color);
+        }
+    };
+    var createTextShadowValue = function (style) {
+        var textShadowColor = style.textShadowColor, textShadowOffset = style.textShadowOffset, textShadowRadius = style.textShadowRadius;
+        var _a = textShadowOffset || defaultOffset, height = _a.height, width = _a.width;
+        var radius = textShadowRadius || 0;
+        var offsetX = normalizeValueWithProperty(width);
+        var offsetY = normalizeValueWithProperty(height);
+        var blurRadius = normalizeValueWithProperty(radius);
+        var color = normalizeValueWithProperty(textShadowColor, 'textShadowColor');
+        if (color &&
+            (height !== 0 || width !== 0 || radius !== 0) &&
+            offsetX != null &&
+            offsetY != null &&
+            blurRadius != null) {
+            return "".concat(offsetX, " ").concat(offsetY, " ").concat(blurRadius, " ").concat(color);
+        }
+    };
+    var mapTransform = function (transform) {
+        var type = Object.keys(transform)[0];
+        var value = transform[type];
+        if (type === 'matrix' || type === 'matrix3d') {
+            return "".concat(type, "(").concat(value.join(','), ")");
+        }
+        else {
+            var normalizedValue = normalizeValueWithProperty(value, type);
+            return "".concat(type, "(").concat(normalizedValue, ")");
+        }
+    };
+    var createTransformValue = function (value) {
+        return value.map(mapTransform).join(' ');
+    };
+    var PROPERTIES_STANDARD = {
+        borderBottomEndRadius: 'borderEndEndRadius',
+        borderBottomStartRadius: 'borderEndStartRadius',
+        borderTopEndRadius: 'borderStartEndRadius',
+        borderTopStartRadius: 'borderStartStartRadius',
+        borderEndColor: 'borderInlineEndColor',
+        borderEndStyle: 'borderInlineEndStyle',
+        borderEndWidth: 'borderInlineEndWidth',
+        borderStartColor: 'borderInlineStartColor',
+        borderStartStyle: 'borderInlineStartStyle',
+        borderStartWidth: 'borderInlineStartWidth',
+        end: 'insetInlineEnd',
+        marginEnd: 'marginInlineEnd',
+        marginHorizontal: 'marginInline',
+        marginStart: 'marginInlineStart',
+        marginVertical: 'marginBlock',
+        paddingEnd: 'paddingInlineEnd',
+        paddingHorizontal: 'paddingInline',
+        paddingStart: 'paddingInlineStart',
+        paddingVertical: 'paddingBlock',
+        start: 'insetInlineStart',
+    };
+    var ignoredProps = {
+        elevation: true,
+        overlayColor: true,
+        resizeMode: true,
+        tintColor: true,
+    };
+    var preprocess = function (originalStyle, options) {
+        if (options === void 0) { options = {}; }
+        var style = originalStyle || emptyObject;
+        var nextStyle = {};
+        if ((options.shadow === true,
+            style.shadowColor != null ||
+                style.shadowOffset != null ||
+                style.shadowOpacity != null ||
+                style.shadowRadius != null)) {
+            var boxShadowValue = createBoxShadowValue(style);
+            if (boxShadowValue != null && nextStyle.boxShadow == null) {
+                var boxShadow = style.boxShadow;
+                var value = boxShadow ? "".concat(boxShadow, ", ").concat(boxShadowValue) : boxShadowValue;
+                nextStyle.boxShadow = value;
+            }
+        }
+        if ((options.textShadow === true && style.textShadowColor != null) ||
+            style.textShadowOffset != null ||
+            style.textShadowRadius != null) {
+            var textShadowValue = createTextShadowValue(style);
+            if (textShadowValue != null && nextStyle.textShadow == null) {
+                var textShadow = style.textShadow;
+                var value = textShadow ? "".concat(textShadow, ", ").concat(textShadowValue) : textShadowValue;
+                nextStyle.textShadow = value;
+            }
+        }
+        for (var originalProp in style) {
+            if (ignoredProps[originalProp] != null ||
+                originalProp === 'shadowColor' ||
+                originalProp === 'shadowOffset' ||
+                originalProp === 'shadowOpacity' ||
+                originalProp === 'shadowRadius' ||
+                originalProp === 'textShadowColor' ||
+                originalProp === 'textShadowOffset' ||
+                originalProp === 'textShadowRadius') {
+                continue;
+            }
+            var originalValue = style[originalProp];
+            var prop = PROPERTIES_STANDARD[originalProp] || originalProp;
+            var value = originalValue;
+            if (!Object.prototype.hasOwnProperty.call(style, originalProp) || (prop !== originalProp && style[prop] != null)) {
+                continue;
+            }
+            if (prop === 'aspectRatio' && typeof value === 'number') {
+                nextStyle[prop] = value.toString();
+            }
+            else if (prop === 'fontVariant') {
+                if (Array.isArray(value) && value.length > 0) {
+                    value = value.join(' ');
+                }
+                nextStyle[prop] = value;
+            }
+            else if (prop === 'textAlignVertical') {
+                if (style.verticalAlign == null) {
+                    nextStyle.verticalAlign = value === 'center' ? 'middle' : value;
+                }
+            }
+            else if (prop === 'transform') {
+                if (Array.isArray(value)) {
+                    value = createTransformValue(value);
+                }
+                nextStyle.transform = value;
+            }
+            else {
+                nextStyle[prop] = normalizeValueWithProperty(value, prop);
+            }
+        }
+        return nextStyle;
+    };
+
+    var openParentheses = "(".charCodeAt(0);
+    var closeParentheses = ")".charCodeAt(0);
+    var singleQuote = "'".charCodeAt(0);
+    var doubleQuote = '"'.charCodeAt(0);
+    var backslash = "\\".charCodeAt(0);
+    var slash = "/".charCodeAt(0);
+    var comma = ",".charCodeAt(0);
+    var colon = ":".charCodeAt(0);
+    var star = "*".charCodeAt(0);
+    var uLower = "u".charCodeAt(0);
+    var uUpper = "U".charCodeAt(0);
+    var plus = "+".charCodeAt(0);
+    var isUnicodeRange = /^[a-f0-9?-]+$/i;
+    var parse$1 = function (input) {
+      var tokens = [];
+      var value = input;
+      var next, quote, prev, token, escape, escapePos, whitespacePos, parenthesesOpenPos;
+      var pos = 0;
+      var code = value.charCodeAt(pos);
+      var max = value.length;
+      var stack = [{
+        nodes: tokens
+      }];
+      var balanced = 0;
+      var parent;
+      var name = "";
+      var before = "";
+      var after = "";
+      while (pos < max) {
+        // Whitespaces
+        if (code <= 32) {
+          next = pos;
+          do {
+            next += 1;
+            code = value.charCodeAt(next);
+          } while (code <= 32);
+          token = value.slice(pos, next);
+          prev = tokens[tokens.length - 1];
+          if (code === closeParentheses && balanced) {
+            after = token;
+          } else if (prev && prev.type === "div") {
+            prev.after = token;
+            prev.sourceEndIndex += token.length;
+          } else if (code === comma || code === colon || code === slash && value.charCodeAt(next + 1) !== star && (!parent || parent && parent.type === "function" && parent.value !== "calc")) {
+            before = token;
+          } else {
+            tokens.push({
+              type: "space",
+              sourceIndex: pos,
+              sourceEndIndex: next,
+              value: token
+            });
+          }
+          pos = next;
+
+          // Quotes
+        } else if (code === singleQuote || code === doubleQuote) {
+          next = pos;
+          quote = code === singleQuote ? "'" : '"';
+          token = {
+            type: "string",
+            sourceIndex: pos,
+            quote: quote
+          };
+          do {
+            escape = false;
+            next = value.indexOf(quote, next + 1);
+            if (~next) {
+              escapePos = next;
+              while (value.charCodeAt(escapePos - 1) === backslash) {
+                escapePos -= 1;
+                escape = !escape;
+              }
+            } else {
+              value += quote;
+              next = value.length - 1;
+              token.unclosed = true;
+            }
+          } while (escape);
+          token.value = value.slice(pos + 1, next);
+          token.sourceEndIndex = token.unclosed ? next : next + 1;
+          tokens.push(token);
+          pos = next + 1;
+          code = value.charCodeAt(pos);
+
+          // Comments
+        } else if (code === slash && value.charCodeAt(pos + 1) === star) {
+          next = value.indexOf("*/", pos);
+          token = {
+            type: "comment",
+            sourceIndex: pos,
+            sourceEndIndex: next + 2
+          };
+          if (next === -1) {
+            token.unclosed = true;
+            next = value.length;
+            token.sourceEndIndex = next;
+          }
+          token.value = value.slice(pos + 2, next);
+          tokens.push(token);
+          pos = next + 2;
+          code = value.charCodeAt(pos);
+
+          // Operation within calc
+        } else if ((code === slash || code === star) && parent && parent.type === "function" && parent.value === "calc") {
+          token = value[pos];
+          tokens.push({
+            type: "word",
+            sourceIndex: pos - before.length,
+            sourceEndIndex: pos + token.length,
+            value: token
+          });
+          pos += 1;
+          code = value.charCodeAt(pos);
+
+          // Dividers
+        } else if (code === slash || code === comma || code === colon) {
+          token = value[pos];
+          tokens.push({
+            type: "div",
+            sourceIndex: pos - before.length,
+            sourceEndIndex: pos + token.length,
+            value: token,
+            before: before,
+            after: ""
+          });
+          before = "";
+          pos += 1;
+          code = value.charCodeAt(pos);
+
+          // Open parentheses
+        } else if (openParentheses === code) {
+          // Whitespaces after open parentheses
+          next = pos;
+          do {
+            next += 1;
+            code = value.charCodeAt(next);
+          } while (code <= 32);
+          parenthesesOpenPos = pos;
+          token = {
+            type: "function",
+            sourceIndex: pos - name.length,
+            value: name,
+            before: value.slice(parenthesesOpenPos + 1, next)
+          };
+          pos = next;
+          if (name === "url" && code !== singleQuote && code !== doubleQuote) {
+            next -= 1;
+            do {
+              escape = false;
+              next = value.indexOf(")", next + 1);
+              if (~next) {
+                escapePos = next;
+                while (value.charCodeAt(escapePos - 1) === backslash) {
+                  escapePos -= 1;
+                  escape = !escape;
+                }
+              } else {
+                value += ")";
+                next = value.length - 1;
+                token.unclosed = true;
+              }
+            } while (escape);
+            // Whitespaces before closed
+            whitespacePos = next;
+            do {
+              whitespacePos -= 1;
+              code = value.charCodeAt(whitespacePos);
+            } while (code <= 32);
+            if (parenthesesOpenPos < whitespacePos) {
+              if (pos !== whitespacePos + 1) {
+                token.nodes = [{
+                  type: "word",
+                  sourceIndex: pos,
+                  sourceEndIndex: whitespacePos + 1,
+                  value: value.slice(pos, whitespacePos + 1)
+                }];
+              } else {
+                token.nodes = [];
+              }
+              if (token.unclosed && whitespacePos + 1 !== next) {
+                token.after = "";
+                token.nodes.push({
+                  type: "space",
+                  sourceIndex: whitespacePos + 1,
+                  sourceEndIndex: next,
+                  value: value.slice(whitespacePos + 1, next)
+                });
+              } else {
+                token.after = value.slice(whitespacePos + 1, next);
+                token.sourceEndIndex = next;
+              }
+            } else {
+              token.after = "";
+              token.nodes = [];
+            }
+            pos = next + 1;
+            token.sourceEndIndex = token.unclosed ? next : pos;
+            code = value.charCodeAt(pos);
+            tokens.push(token);
+          } else {
+            balanced += 1;
+            token.after = "";
+            token.sourceEndIndex = pos + 1;
+            tokens.push(token);
+            stack.push(token);
+            tokens = token.nodes = [];
+            parent = token;
+          }
+          name = "";
+
+          // Close parentheses
+        } else if (closeParentheses === code && balanced) {
+          pos += 1;
+          code = value.charCodeAt(pos);
+          parent.after = after;
+          parent.sourceEndIndex += after.length;
+          after = "";
+          balanced -= 1;
+          stack[stack.length - 1].sourceEndIndex = pos;
+          stack.pop();
+          parent = stack[balanced];
+          tokens = parent.nodes;
+
+          // Words
+        } else {
+          next = pos;
+          do {
+            if (code === backslash) {
+              next += 1;
+            }
+            next += 1;
+            code = value.charCodeAt(next);
+          } while (next < max && !(code <= 32 || code === singleQuote || code === doubleQuote || code === comma || code === colon || code === slash || code === openParentheses || code === star && parent && parent.type === "function" && parent.value === "calc" || code === slash && parent.type === "function" && parent.value === "calc" || code === closeParentheses && balanced));
+          token = value.slice(pos, next);
+          if (openParentheses === code) {
+            name = token;
+          } else if ((uLower === token.charCodeAt(0) || uUpper === token.charCodeAt(0)) && plus === token.charCodeAt(1) && isUnicodeRange.test(token.slice(2))) {
+            tokens.push({
+              type: "unicode-range",
+              sourceIndex: pos,
+              sourceEndIndex: next,
+              value: token
+            });
+          } else {
+            tokens.push({
+              type: "word",
+              sourceIndex: pos,
+              sourceEndIndex: next,
+              value: token
+            });
+          }
+          pos = next;
+        }
+      }
+      for (pos = stack.length - 1; pos; pos -= 1) {
+        stack[pos].unclosed = true;
+        stack[pos].sourceEndIndex = value.length;
+      }
+      return stack[0].nodes;
+    };
+
+    var walk$1 = function walk(nodes, cb, bubble) {
+      var i, max, node, result;
+      for (i = 0, max = nodes.length; i < max; i += 1) {
+        node = nodes[i];
+        if (!bubble) {
+          result = cb(node, i, nodes);
+        }
+        if (result !== false && node.type === "function" && Array.isArray(node.nodes)) {
+          walk(node.nodes, cb, bubble);
+        }
+        if (bubble) {
+          cb(node, i, nodes);
+        }
+      }
+    };
+
+    function stringifyNode(node, custom) {
+      var type = node.type;
+      var value = node.value;
+      var buf;
+      var customResult;
+      if (custom && (customResult = custom(node)) !== undefined) {
+        return customResult;
+      } else if (type === "word" || type === "space") {
+        return value;
+      } else if (type === "string") {
+        buf = node.quote || "";
+        return buf + value + (node.unclosed ? "" : buf);
+      } else if (type === "comment") {
+        return "/*" + value + (node.unclosed ? "" : "*/");
+      } else if (type === "div") {
+        return (node.before || "") + value + (node.after || "");
+      } else if (Array.isArray(node.nodes)) {
+        buf = stringify$1(node.nodes, custom);
+        if (type !== "function") {
+          return buf;
+        }
+        return value + "(" + (node.before || "") + buf + (node.after || "") + (node.unclosed ? "" : ")");
+      }
+      return value;
+    }
+    function stringify$1(nodes, custom) {
+      var result, i;
+      if (Array.isArray(nodes)) {
+        result = "";
+        for (i = nodes.length - 1; ~i; i -= 1) {
+          result = stringifyNode(nodes[i], custom) + result;
+        }
+        return result;
+      }
+      return stringifyNode(nodes, custom);
+    }
+    var stringify_1 = stringify$1;
+
+    var unit;
+    var hasRequiredUnit;
+    function requireUnit() {
+      if (hasRequiredUnit) return unit;
+      hasRequiredUnit = 1;
+      var minus = "-".charCodeAt(0);
+      var plus = "+".charCodeAt(0);
+      var dot = ".".charCodeAt(0);
+      var exp = "e".charCodeAt(0);
+      var EXP = "E".charCodeAt(0);
+
+      // Check if three code points would start a number
+      // https://www.w3.org/TR/css-syntax-3/#starts-with-a-number
+      function likeNumber(value) {
+        var code = value.charCodeAt(0);
+        var nextCode;
+        if (code === plus || code === minus) {
+          nextCode = value.charCodeAt(1);
+          if (nextCode >= 48 && nextCode <= 57) {
+            return true;
+          }
+          var nextNextCode = value.charCodeAt(2);
+          if (nextCode === dot && nextNextCode >= 48 && nextNextCode <= 57) {
+            return true;
+          }
+          return false;
+        }
+        if (code === dot) {
+          nextCode = value.charCodeAt(1);
+          if (nextCode >= 48 && nextCode <= 57) {
+            return true;
+          }
+          return false;
+        }
+        if (code >= 48 && code <= 57) {
+          return true;
+        }
+        return false;
+      }
+
+      // Consume a number
+      // https://www.w3.org/TR/css-syntax-3/#consume-number
+      unit = function (value) {
+        var pos = 0;
+        var length = value.length;
+        var code;
+        var nextCode;
+        var nextNextCode;
+        if (length === 0 || !likeNumber(value)) {
+          return false;
+        }
+        code = value.charCodeAt(pos);
+        if (code === plus || code === minus) {
+          pos++;
+        }
+        while (pos < length) {
+          code = value.charCodeAt(pos);
+          if (code < 48 || code > 57) {
+            break;
+          }
+          pos += 1;
+        }
+        code = value.charCodeAt(pos);
+        nextCode = value.charCodeAt(pos + 1);
+        if (code === dot && nextCode >= 48 && nextCode <= 57) {
+          pos += 2;
+          while (pos < length) {
+            code = value.charCodeAt(pos);
+            if (code < 48 || code > 57) {
+              break;
+            }
+            pos += 1;
+          }
+        }
+        code = value.charCodeAt(pos);
+        nextCode = value.charCodeAt(pos + 1);
+        nextNextCode = value.charCodeAt(pos + 2);
+        if ((code === exp || code === EXP) && (nextCode >= 48 && nextCode <= 57 || (nextCode === plus || nextCode === minus) && nextNextCode >= 48 && nextNextCode <= 57)) {
+          pos += nextCode === plus || nextCode === minus ? 3 : 2;
+          while (pos < length) {
+            code = value.charCodeAt(pos);
+            if (code < 48 || code > 57) {
+              break;
+            }
+            pos += 1;
+          }
+        }
+        return {
+          number: value.slice(0, pos),
+          unit: value.slice(pos)
+        };
+      };
+      return unit;
+    }
+
+    var parse = parse$1;
+    var walk = walk$1;
+    var stringify = stringify_1;
+    function ValueParser(value) {
+      if (this instanceof ValueParser) {
+        this.nodes = parse(value);
+        return this;
+      }
+      return new ValueParser(value);
+    }
+    ValueParser.prototype.toString = function () {
+      return Array.isArray(this.nodes) ? stringify(this.nodes) : "";
+    };
+    ValueParser.prototype.walk = function (cb, bubble) {
+      walk(this.nodes, cb, bubble);
+      return this;
+    };
+    ValueParser.unit = requireUnit();
+    ValueParser.walk = walk;
+    ValueParser.stringify = stringify;
+    var lib = ValueParser;
+
+    var invalidShortforms = {
+        background: true,
+        borderBottom: true,
+        borderLeft: true,
+        borderRight: true,
+        borderTop: true,
+        font: true,
+        grid: true,
+        outline: true,
+        textDecoration: true,
+    };
+    var invalidMultiValueShortforms = {
+        flex: true,
+        margin: true,
+        padding: true,
+        borderColor: true,
+        borderRadius: true,
+        borderStyle: true,
+        borderWidth: true,
+        inset: true,
+        insetBlock: true,
+        insetInline: true,
+        marginBlock: true,
+        marginInline: true,
+        marginHorizontal: true,
+        marginVertical: true,
+        paddingBlock: true,
+        paddingInline: true,
+        paddingHorizontal: true,
+        paddingVertical: true,
+        overflow: true,
+        overscrollBehavior: true,
+        backgroundPosition: true,
+    };
+    function error(message) {
+        console.error(message);
+    }
+    function validate(obj) {
+        for (var k in obj) {
+            var prop = k.trim();
+            var value = obj[prop];
+            var isInvalid = false;
+            if (value === null) {
+                continue;
+            }
+            if (typeof value === 'string' && value.indexOf('!important') > -1) {
+                error("Invalid style declaration \"".concat(prop, ":").concat(value, "\". Values cannot include \"!important\""));
+                isInvalid = true;
+            }
+            else {
+                var suggestion = '';
+                if (prop === 'animation' || prop === 'animationName') {
+                    suggestion = 'Did you mean "animationKeyframes"?';
+                    isInvalid = true;
+                }
+                else if (prop === 'direction') {
+                    suggestion = 'Did you mean "writingDirection"?';
+                    isInvalid = true;
+                }
+                else if (invalidShortforms[prop]) {
+                    suggestion = 'Please use long-form properties.';
+                    isInvalid = true;
+                }
+                else if (invalidMultiValueShortforms[prop]) {
+                    if (typeof value === 'string' && lib(value).nodes.length > 1) {
+                        suggestion = "Value is \"".concat(value, "\" but only single values are supported.");
+                        isInvalid = true;
+                    }
+                }
+                if (suggestion !== '') {
+                    error("Invalid style property of \"".concat(prop, "\". ").concat(suggestion));
+                }
+            }
+            if (isInvalid) {
+                delete obj[k];
+            }
+        }
+    }
+
+    var makeStyles = function (styleFactory, customTheme) {
+        var theme = customTheme || ctDesignTheme.ThemeManager.get();
+        var styles = styleFactory(theme);
+        for (var _i = 0, _a = Object.entries(styles); _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], value = _b[1];
+            var updatedValue = typeof value === 'function' ? value(theme) : value;
+            styles[key] = updatedValue;
+        }
+        var classes = {};
+        for (var _c = 0, _d = Object.entries(styles); _c < _d.length; _c++) {
+            var _e = _d[_c], key = _e[0], value = _e[1];
+            var defaultPreprocessOptions = { shadow: true, textShadow: true };
+            validate(value);
+            var updatedStyle = preprocess(value, defaultPreprocessOptions);
+            classes[key] = css.css(updatedStyle);
+        }
+        return classes;
+    };
+
+    var useStyles = function (styleFactory, dep) {
+        var theme = ctDesignTheme.useTheme();
+        return useStableMemo(function () {
+            var adaptedFactory = function (providedTheme) {
+                return styleFactory(providedTheme);
+            };
+            return makeStyles(adaptedFactory, theme);
+        }, dep);
+    };
+
+    var StylingCacheManager = (function () {
+        function StylingCacheManager() {
+            if (StylingCacheManager.instance) {
+                throw new Error('You can only create one instance!');
+            }
+            StylingCacheManager.instance = this;
+            this.cache = new WeakMap();
+        }
+        StylingCacheManager.prototype.set = function (key, value) {
+            this.cache.set(key, value);
+        };
+        StylingCacheManager.prototype.get = function (key) {
+            return this.cache.get(key);
+        };
+        return StylingCacheManager;
+    }());
+    var StylingCache = Object.freeze(new StylingCacheManager());
+
+    var useWebMergeStyles = function (styles, deps) {
+        return useStableMemo(function () {
+            var classes = [];
+            styles.forEach(function (style) {
+                if (typeof style === 'string') {
+                    classes.push(style);
+                }
+                else {
+                    if (style) {
+                        var _style = StylingCache.get(style);
+                        if (_style) {
+                            classes.push(_style);
+                        }
+                        else {
+                            var defaultPreprocessOptions = { shadow: true, textShadow: true };
+                            var preprocessedStyle = preprocess(style, defaultPreprocessOptions);
+                            var emotionClass = css.css(preprocessedStyle);
+                            StylingCache.set(style, emotionClass);
+                            classes.push(emotionClass);
+                        }
+                    }
+                }
+            });
+            return css.css(classes);
+        }, deps);
+    };
+
+    exports.makeStyles = makeStyles;
+    exports.useStyles = useStyles;
+    exports.useWebMergeStyles = useWebMergeStyles;
+
+}));
+//# sourceMappingURL=ct-design-styleManager.umd.js.map