@cube-dev/ui-kit 0.0.0-canary-9b9355c → 0.0.0-canary-186a28f

package/es/tasty/pipeline/materialize.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 
@@ -93,34 +93,45 @@ function conditionToCSSInner(node) {
  * Convert a state condition to CSS
  */
 function stateToCSS(state) {
-    const variant = emptyVariant();
     switch (state.type) {
-        case 'modifier':
-            variant.modifierSelectors.push(modifierToCSS(state));
-            break;
-        case 'pseudo':
-            variant.modifierSelectors.push(pseudoToCSS(state));
-            break;
-        case 'media':
-            variant.mediaRules.push(mediaToCSS(state));
-            break;
-        case 'container':
-            variant.containerRules.push(containerToCSS(state));
-            break;
-        case 'root':
-            variant.rootPrefix = rootToCSS(state);
-            break;
-        case 'own':
-            variant.ownSelectors.push(...ownToCSS(state));
-            break;
-        case 'starting':
-            variant.startingStyle = !state.negated;
-            break;
+        case 'media': {
+            // Media rules can return multiple variants for negated ranges (OR branches)
+            const mediaResults = mediaToCSS(state);
+            const variants = mediaResults.map((mediaRule) => {
+                const v = emptyVariant();
+                v.mediaRules.push(mediaRule);
+                return v;
+            });
+            return { variants, isImpossible: false };
+        }
+        default: {
+            const variant = emptyVariant();
+            switch (state.type) {
+                case 'modifier':
+                    variant.modifierSelectors.push(modifierToCSS(state));
+                    break;
+                case 'pseudo':
+                    variant.modifierSelectors.push(pseudoToCSS(state));
+                    break;
+                case 'container':
+                    variant.containerRules.push(containerToCSS(state));
+                    break;
+                case 'root':
+                    variant.rootPrefix = rootToCSS(state);
+                    break;
+                case 'own':
+                    variant.ownSelectors.push(...ownToCSS(state));
+                    break;
+                case 'starting':
+                    variant.startingStyle = !state.negated;
+                    break;
+            }
+            return {
+                variants: [variant],
+                isImpossible: false,
+            };
+        }
     }
-    return {
-        variants: [variant],
-        isImpossible: false,
-    };
 }
 /**
  * Convert modifier condition to CSS selector
@@ -156,34 +167,44 @@ function pseudoToCSS(state) {
     return state.pseudo;
 }
 /**
- * Convert media condition to CSS at-rule
+ * Convert media condition to CSS at-rule(s)
+ * Returns an array because negated ranges produce OR branches (two separate rules)
  */
 function mediaToCSS(state) {
-    let condition;
     if (state.subtype === 'type') {
-        // @media:print → @media print
-        condition = state.mediaType || 'all';
+        // @media:print → @media print (or @media not print)
+        const mediaType = state.mediaType || 'all';
+        if (state.negated) {
+            return [`@media not ${mediaType}`];
+        }
+        return [`@media ${mediaType}`];
     }
     else if (state.subtype === 'feature') {
         // @media(prefers-contrast: high) → @media (prefers-contrast: high)
+        let condition;
         if (state.featureValue) {
             condition = `(${state.feature}: ${state.featureValue})`;
         }
         else {
             condition = `(${state.feature})`;
         }
+        // "not (condition)" is valid for feature queries like prefers-color-scheme
+        if (state.negated) {
+            return [`@media not ${condition}`];
+        }
+        return [`@media ${condition}`];
     }
     else {
-        // Dimension query
-        condition = dimensionToMediaCondition(state.dimension || 'width', state.lowerBound, state.upperBound);
+        // Dimension query - negation is handled by inverting the condition
+        // because "not (width < x)" doesn't work reliably in browsers
+        const conditions = dimensionToMediaCondition(state.dimension || 'width', state.lowerBound, state.upperBound, state.negated);
+        // dimensionToMediaCondition returns array for negated ranges (OR branches)
+        return conditions.map((c) => `@media ${c}`);
     }
-    if (state.negated) {
-        return `@media not ${condition}`;
-    }
-    return `@media ${condition}`;
 }
 /**
  * Convert container condition to CSS at-rule
+ * Container queries support "not (condition)" syntax, so we can use it directly
  */
 function containerToCSS(state) {
     const name = state.containerName ? `${state.containerName} ` : '';
@@ -198,8 +219,8 @@ function containerToCSS(state) {
         }
     }
     else {
-        // Dimension query
-        condition = dimensionToMediaCondition(state.dimension || 'width', state.lowerBound, state.upperBound);
+        // Dimension query - container queries support "not (condition)"
+        condition = dimensionToContainerCondition(state.dimension || 'width', state.lowerBound, state.upperBound);
     }
     if (state.negated) {
         return `@container ${name}not ${condition}`;
@@ -207,9 +228,10 @@ function containerToCSS(state) {
     return `@container ${name}${condition}`;
 }
 /**
- * Convert dimension bounds to a media/container condition string
+ * Convert dimension bounds to container query condition (single string)
+ * Container queries support "not (condition)", so no need to invert manually
  */
-function dimensionToMediaCondition(dimension, lowerBound, upperBound) {
+function dimensionToContainerCondition(dimension, lowerBound, upperBound) {
     if (lowerBound && upperBound) {
         const lowerOp = lowerBound.inclusive ? '<=' : '<';
         const upperOp = upperBound.inclusive ? '<=' : '<';
@@ -225,6 +247,58 @@ function dimensionToMediaCondition(dimension, lowerBound, upperBound) {
     }
     return '(width)'; // Fallback
 }
+/**
+ * Convert dimension bounds to media condition(s)
+ * Returns an array because negated ranges produce OR branches (two separate conditions)
+ */
+function dimensionToMediaCondition(dimension, lowerBound, upperBound, negated) {
+    if (negated) {
+        // Invert the condition manually since "not (width < x)" doesn't work in browsers
+        // Single bounds: flip the operator → returns single condition
+        // Range: NOT (a <= x < b) = (x < a) OR (x >= b) → returns two conditions (OR branches)
+        if (lowerBound && upperBound) {
+            // Range query: (lower <= dim < upper) negated is (dim < lower) OR (dim >= upper)
+            // Return two separate conditions - these become separate variants
+            const lowerOp = lowerBound.inclusive ? '<' : '<=';
+            const upperOp = upperBound.inclusive ? '>' : '>=';
+            return [
+                `(${dimension} ${lowerOp} ${lowerBound.value})`,
+                `(${dimension} ${upperOp} ${upperBound.value})`,
+            ];
+        }
+        else if (upperBound) {
+            // (dim < upper) negated is (dim >= upper)
+            // (dim <= upper) negated is (dim > upper)
+            const op = upperBound.inclusive ? '>' : '>=';
+            return [`(${dimension} ${op} ${upperBound.value})`];
+        }
+        else if (lowerBound) {
+            // (dim >= lower) negated is (dim < lower)
+            // (dim > lower) negated is (dim <= lower)
+            const op = lowerBound.inclusive ? '<' : '<=';
+            return [`(${dimension} ${op} ${lowerBound.value})`];
+        }
+        // Fallback - should not happen
+        return ['(width < 0px)'];
+    }
+    // Positive condition - always returns single condition
+    if (lowerBound && upperBound) {
+        const lowerOp = lowerBound.inclusive ? '<=' : '<';
+        const upperOp = upperBound.inclusive ? '<=' : '<';
+        return [
+            `(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`,
+        ];
+    }
+    else if (upperBound) {
+        const op = upperBound.inclusive ? '<=' : '<';
+        return [`(${dimension} ${op} ${upperBound.value})`];
+    }
+    else if (lowerBound) {
+        const op = lowerBound.inclusive ? '>=' : '>';
+        return [`(${dimension} ${op} ${lowerBound.value})`];
+    }
+    return ['(width)']; // Fallback
+}
 /**
  * Convert root condition to CSS selector prefix
  */
@@ -298,32 +372,164 @@ function mergeVariants(a, b) {
         startingStyle: a.startingStyle || b.startingStyle,
     };
 }
+function parseValue(str) {
+    const match = str.match(/^(\d+(?:\.\d+)?)(px|em|rem|vh|vw|%)$/i);
+    if (match) {
+        return { value: parseFloat(match[1]), unit: match[2].toLowerCase() };
+    }
+    return null;
+}
+function parseDimensionCondition(condition) {
+    // Try range syntax first: (600px <= width < 900px)
+    const rangeMatch = condition.match(/\(\s*(\d+(?:\.\d+)?(?:px|em|rem|vh|vw|%))\s*(<=?)\s*(width|height)\s*(<=?)\s*(\d+(?:\.\d+)?(?:px|em|rem|vh|vw|%))\s*\)/i);
+    if (rangeMatch) {
+        const lowerVal = parseValue(rangeMatch[1]);
+        const upperVal = parseValue(rangeMatch[5]);
+        if (lowerVal && upperVal && lowerVal.unit === upperVal.unit) {
+            return {
+                dimension: rangeMatch[3].toLowerCase(),
+                lowerBound: {
+                    value: lowerVal.value,
+                    unit: lowerVal.unit,
+                    inclusive: rangeMatch[2] === '<=',
+                },
+                upperBound: {
+                    value: upperVal.value,
+                    unit: upperVal.unit,
+                    inclusive: rangeMatch[4] === '<=',
+                },
+            };
+        }
+    }
+    // Try single bound: (width < 600px) or (width >= 900px)
+    const singleMatch = condition.match(/\(\s*(width|height)\s*(<=?|>=?)\s*(\d+(?:\.\d+)?(?:px|em|rem|vh|vw|%))\s*\)/i);
+    if (singleMatch) {
+        const val = parseValue(singleMatch[3]);
+        if (val) {
+            const op = singleMatch[2];
+            if (op === '<' || op === '<=') {
+                return {
+                    dimension: singleMatch[1].toLowerCase(),
+                    upperBound: {
+                        value: val.value,
+                        unit: val.unit,
+                        inclusive: op === '<=',
+                    },
+                };
+            }
+            else {
+                return {
+                    dimension: singleMatch[1].toLowerCase(),
+                    lowerBound: {
+                        value: val.value,
+                        unit: val.unit,
+                        inclusive: op === '>=',
+                    },
+                };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Check if two dimension conditions are contradictory
+ * e.g., "width >= 900px" and "width < 900px" are contradictory
+ * Also handles ranges: "(600px <= width < 900px)" and "(width < 600px)" are contradictory
+ */
+function areDimensionContradictions(a, b) {
+    if (a.dimension !== b.dimension)
+        return false;
+    // Get effective bounds - considering both single-bound and ranges
+    const aLower = a.lowerBound;
+    const aUpper = a.upperBound;
+    const bLower = b.lowerBound;
+    const bUpper = b.upperBound;
+    // Check if units are compatible (only compare if same unit)
+    const getUnit = (bound) => bound?.unit;
+    const units = [aLower, aUpper, bLower, bUpper]
+        .filter(Boolean)
+        .map((b) => b.unit);
+    if (units.length > 0 && !units.every((u) => u === units[0])) {
+        return false; // Different units, can't determine
+    }
+    // Two conditions contradict if their valid ranges don't overlap
+    // A range is [aLowerVal, aUpperVal) or similar
+    // Default: -Infinity to +Infinity
+    const aLowerVal = aLower?.value ?? -Infinity;
+    const aUpperVal = aUpper?.value ?? Infinity;
+    const bLowerVal = bLower?.value ?? -Infinity;
+    const bUpperVal = bUpper?.value ?? Infinity;
+    // For non-inclusive bounds, adjust slightly for comparison
+    // But for simplicity, we'll use strict non-overlap check
+    // Two ranges [aL, aU) and [bL, bU) don't overlap if:
+    // aU <= bL or bU <= aL (considering inclusivity)
+    // Check if a's upper bound is at or below b's lower bound
+    if (aUpper && bLower && aUpper.value === bLower.value) {
+        // Same value - check inclusivity
+        // If a.upper is exclusive (<) and b.lower is inclusive (>=), they don't overlap at this point
+        // If a.upper is inclusive (<=) and b.lower is exclusive (>), they don't overlap
+        if (!aUpper.inclusive && bLower.inclusive) {
+            return true; // a < X and X <= b → no overlap at X
+        }
+        if (aUpper.inclusive && !bLower.inclusive) {
+            return true; // a <= X and X > b → no overlap at X
+        }
+    }
+    if (aUpperVal < bLowerVal)
+        return true;
+    // Check if b's upper bound is at or below a's lower bound
+    if (bUpper && aLower && bUpper.value === aLower.value) {
+        if (!bUpper.inclusive && aLower.inclusive) {
+            return true;
+        }
+        if (bUpper.inclusive && !aLower.inclusive) {
+            return true;
+        }
+    }
+    if (bUpperVal < aLowerVal)
+        return true;
+    return false;
+}
 /**
  * Check if a set of media rules contains contradictions
  * e.g., "@media (prefers-color-scheme: light)" and "@media not (prefers-color-scheme: light)"
+ * or "@media (width >= 900px)" and "@media (width < 900px)"
  */
 function hasMediaContradiction(mediaRules) {
-    const features = new Map();
+    const conditions = new Map();
+    const dimensionConditions = [];
     for (const rule of mediaRules) {
-        // Parse the rule to extract the feature condition
-        // Format: "@media (feature: value)" or "@media not (feature: value)"
-        const notMatch = rule.match(/@media\s+not\s+\(([^:]+):\s*([^)]+)\)/i);
-        const posMatch = rule.match(/@media\s+\(([^:]+):\s*([^)]+)\)/i);
+        // Check for negated media rule: @media not (...)
+        const notMatch = rule.match(/@media\s+not\s+(\([^)]+\))/i);
+        // Check for positive media rule: @media (...)
+        const posMatch = rule.match(/@media\s+(\([^)]+\))/i);
         if (notMatch) {
-            const key = `${notMatch[1].trim()}:${notMatch[2].trim()}`;
-            const existing = features.get(key);
+            // Normalize the condition (remove extra whitespace)
+            const key = notMatch[1].replace(/\s+/g, ' ').trim();
+            const existing = conditions.get(key);
             if (existing && existing.positive) {
-                return true; // Found: (feature: value) AND not (feature: value)
+                return true; // Found: (condition) AND not (condition)
             }
-            features.set(key, { positive: false, rule });
+            conditions.set(key, { positive: false, rule });
         }
         else if (posMatch) {
-            const key = `${posMatch[1].trim()}:${posMatch[2].trim()}`;
-            const existing = features.get(key);
+            // Normalize the condition (remove extra whitespace)
+            const key = posMatch[1].replace(/\s+/g, ' ').trim();
+            const existing = conditions.get(key);
             if (existing && !existing.positive) {
-                return true; // Found: not (feature: value) AND (feature: value)
+                return true; // Found: not (condition) AND (condition)
+            }
+            conditions.set(key, { positive: true, rule });
+            // Also check for dimension contradictions
+            const dimCond = parseDimensionCondition(posMatch[1]);
+            if (dimCond) {
+                for (const existing of dimensionConditions) {
+                    if (areDimensionContradictions(dimCond, existing)) {
+                        return true;
+                    }
+                }
+                dimensionConditions.push(dimCond);
             }
-            features.set(key, { positive: true, rule });
         }
     }
     return false;
@@ -394,12 +600,69 @@ function getVariantKey(v) {
         v.startingStyle ? '1' : '0',
     ].join('###');
 }
+/**
+ * Check if variant A is a superset of variant B (A is more restrictive)
+ *
+ * If A has all of B's conditions plus more, then A is redundant
+ * because B already covers the same cases (and more).
+ *
+ * Example:
+ *   A: :not([size=large]):not([size=medium]):not([size=small])
+ *   B: :not([size=large])
+ *   A is a superset of B, so A is redundant when B exists.
+ */
+function isVariantSuperset(a, b) {
+    // Must have same context (root prefix, at-rules, etc.)
+    if (a.rootPrefix !== b.rootPrefix)
+        return false;
+    if (a.startingStyle !== b.startingStyle)
+        return false;
+    // Check if a.mediaRules is superset of b.mediaRules
+    if (!isArraySuperset(a.mediaRules, b.mediaRules))
+        return false;
+    // Check if a.containerRules is superset of b.containerRules
+    if (!isArraySuperset(a.containerRules, b.containerRules))
+        return false;
+    // Check if a.modifierSelectors is superset of b.modifierSelectors
+    if (!isArraySuperset(a.modifierSelectors, b.modifierSelectors))
+        return false;
+    // Check if a.ownSelectors is superset of b.ownSelectors
+    if (!isArraySuperset(a.ownSelectors, b.ownSelectors))
+        return false;
+    // A is a superset if it has all of B's items (possibly more)
+    // and at least one category has strictly more items
+    const aTotal = a.mediaRules.length +
+        a.containerRules.length +
+        a.modifierSelectors.length +
+        a.ownSelectors.length;
+    const bTotal = b.mediaRules.length +
+        b.containerRules.length +
+        b.modifierSelectors.length +
+        b.ownSelectors.length;
+    return aTotal > bTotal;
+}
+/**
+ * Check if array A contains all elements of array B (superset)
+ */
+function isArraySuperset(a, b) {
+    const setA = new Set(a);
+    for (const item of b) {
+        if (!setA.has(item))
+            return false;
+    }
+    return true;
+}
 /**
  * Deduplicate variants
+ *
+ * Removes:
+ * 1. Exact duplicates (same key)
+ * 2. Superset variants (more restrictive selectors that are redundant)
  */
 function dedupeVariants(variants) {
+    // First pass: exact deduplication
     const seen = new Set();
-    const result = [];
+    let result = [];
     for (const v of variants) {
         const key = getVariantKey(v);
         if (!seen.has(key)) {
@@ -407,7 +670,34 @@ function dedupeVariants(variants) {
             result.push(v);
         }
     }
-    return result;
+    // Second pass: remove supersets (more restrictive variants)
+    // Sort by total selector count (fewer selectors = less restrictive = keep)
+    result.sort((a, b) => {
+        const aCount = a.modifierSelectors.length +
+            a.ownSelectors.length +
+            a.mediaRules.length +
+            a.containerRules.length;
+        const bCount = b.modifierSelectors.length +
+            b.ownSelectors.length +
+            b.mediaRules.length +
+            b.containerRules.length;
+        return aCount - bCount;
+    });
+    // Remove variants that are supersets of earlier (less restrictive) variants
+    const filtered = [];
+    for (const candidate of result) {
+        let isRedundant = false;
+        for (const kept of filtered) {
+            if (isVariantSuperset(candidate, kept)) {
+                isRedundant = true;
+                break;
+            }
+        }
+        if (!isRedundant) {
+            filtered.push(candidate);
+        }
+    }
+    return filtered;
 }
 /**
  * Combine AND conditions into CSS
@@ -520,11 +810,18 @@ export function buildAtRulesFromVariant(variant) {
     const atRules = [];
     // Add media rules
     if (variant.mediaRules.length > 0) {
-        // Combine media rules with 'and'
-        const conditions = variant.mediaRules
-            .map((r) => r.replace(/^@media\s*/, ''))
-            .join(' and ');
-        atRules.push(`@media ${conditions}`);
+        // Each rule is either:
+        // - "@media (condition)" for positive conditions
+        // - "@media not (condition)" for negated conditions
+        // - "@media not print" for negated media types
+        // - "@media (inverted-condition)" for negated dimension queries (already inverted)
+        //
+        // We strip "@media " and join with " and "
+        // This produces valid CSS like:
+        // @media not (prefers-color-scheme: dark) and (width > 800px)
+        // which means: NOT(dark) AND (width > 800px)
+        const conditions = variant.mediaRules.map((r) => r.replace(/^@media\s*/, ''));
+        atRules.push(`@media ${conditions.join(' and ')}`);
     }
     // Add container rules
     atRules.push(...variant.containerRules);

package/es/tasty/pipeline/parseStateKey.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 

package/es/tasty/pipeline/simplify.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 

package/es/tasty/states/index.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 

package/es/tasty/styles/align.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 

package/es/tasty/styles/border.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 

package/es/tasty/styles/boxShadow.combinator.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 

package/es/tasty/styles/color.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 

package/es/tasty/styles/createStyle.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 

package/es/tasty/styles/dimension.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 

package/es/tasty/styles/display.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 

package/es/tasty/styles/fade.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 

package/es/tasty/styles/fill.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 

package/es/tasty/styles/flow.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 

package/es/tasty/styles/font.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */
 

package/es/tasty/styles/fontStyle.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-9b9355c
+ * @cube-dev/ui-kit v0.0.0-canary-186a28f
  * Released under the MIT license.
  */