@cube-dev/ui-kit 0.0.0-canary-0692b88 → 0.0.0-canary-72a72ab

package/es/tasty/injector/sheet-manager.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-0692b88
+ * @cube-dev/ui-kit v0.0.0-canary-72a72ab
  * Released under the MIT license.
  */
 
@@ -38,10 +38,6 @@ export class SheetManager {
                 bulkCleanupTimeout: null,
                 metrics,
                 classCounter: 0,
-                batchedRules: new Map(),
-                batchedRuleMeta: new Map(),
-                classToBatchedKeys: new Map(),
-                unusedBatchedClasses: new Set(),
             };
             this.rootRegistries.set(root, registry);
         }
@@ -93,105 +89,113 @@ export class SheetManager {
      * Insert CSS rules as a single block
      */
     insertRule(registry, flattenedRules, className, root) {
+        // Find or create a sheet with available space
+        let targetSheet = this.findAvailableSheet(registry, root);
+        if (!targetSheet) {
+            targetSheet = this.createSheet(registry, root);
+        }
+        const ruleIndex = this.findAvailableRuleIndex(targetSheet);
+        const sheetIndex = registry.sheets.indexOf(targetSheet);
         try {
-            // Pre-merge identical selector+atRules declarations within the same class
+            // Group rules by selector and at-rules to combine declarations
             const groupedRules = [];
             const groupMap = new Map();
             const atKey = (at) => (at && at.length ? at.join('|') : '');
-            for (const r of flattenedRules) {
+            flattenedRules.forEach((r) => {
                 const key = `${atKey(r.atRules)}||${r.selector}`;
                 const existing = groupMap.get(key);
                 if (existing) {
-                    existing.rule.declarations = `${existing.rule.declarations} ${r.declarations}`;
+                    // Append declarations, preserving order
+                    existing.declarations = existing.declarations
+                        ? `${existing.declarations} ${r.declarations}`
+                        : r.declarations;
                 }
                 else {
-                    const clone = { ...r };
-                    groupMap.set(key, { idx: groupedRules.length, rule: clone });
-                    groupedRules.push(clone);
-                }
-            }
-            // Ensure registry maps exist for this class
-            if (!registry.classToBatchedKeys.has(className)) {
-                registry.classToBatchedKeys.set(className, new Set());
-            }
-            // Apply batching per grouped rule
-            for (const rule of groupedRules) {
-                const normalizedDecl = this.normalizeDeclarations(rule.declarations);
-                const { selectorTemplate } = this.makeSelectorTemplate(rule.selector, className);
-                const batchKey = this.getBatchKey(rule.atRules, selectorTemplate, normalizedDecl);
-                // Record meta
-                if (!registry.batchedRuleMeta.has(batchKey)) {
-                    registry.batchedRuleMeta.set(batchKey, {
-                        selectorTemplate,
-                        declarations: normalizedDecl,
-                        atRules: rule.atRules && rule.atRules.length
-                            ? [...rule.atRules]
-                            : undefined,
+                    groupMap.set(key, {
+                        idx: groupedRules.length,
+                        selector: r.selector,
+                        atRules: r.atRules,
+                        declarations: r.declarations,
                     });
+                    groupedRules.push({ ...r });
                 }
-                // Link class -> batch keys
-                registry.classToBatchedKeys.get(className).add(batchKey);
-                const existingEntry = registry.batchedRules.get(batchKey);
-                if (existingEntry) {
-                    if (!existingEntry.classNames.has(className)) {
-                        existingEntry.classNames.add(className);
-                        this.updateBatchedRuleCss(registry, existingEntry, root);
-                    }
-                    // Unmark class as unused if it was marked
-                    if (registry.unusedBatchedClasses.has(className)) {
-                        registry.unusedBatchedClasses.delete(className);
-                    }
-                    continue;
-                }
-                // Check if this exact rule already exists as a non-batched rule in any sheet
-                // and convert it to a batched rule instead of duplicating
-                const existingClassWithSameRule = this.findClassWithIdenticalRule(registry, batchKey, className);
-                if (existingClassWithSameRule) {
-                    // Convert existing rule to batched and add current class
-                    this.convertToBatchedRule(registry, existingClassWithSameRule, className, batchKey, root);
-                    continue;
-                }
-                // Need to create a new CSS rule for this batch key
-                const { sheet, sheetIndex, ruleIndex } = this.ensureTargetSheetAndIndex(registry, root);
-                const entry = {
-                    key: batchKey,
-                    selectorTemplate,
-                    declarations: normalizedDecl,
-                    atRules: rule.atRules && rule.atRules.length ? [...rule.atRules] : undefined,
-                    classNames: new Set([className]),
-                    sheetIndex,
-                    ruleIndex,
+            });
+            // Normalize groupedRules from map (with merged declarations)
+            groupMap.forEach((val) => {
+                groupedRules[val.idx] = {
+                    selector: val.selector,
+                    atRules: val.atRules,
+                    declarations: val.declarations,
                 };
-                const cssText = this.composeCssForEntry(entry);
-                const styleElement = sheet.sheet;
+            });
+            // Insert grouped rules
+            const insertedRuleTexts = [];
+            let currentRuleIndex = ruleIndex;
+            let firstInsertedIndex = null;
+            let lastInsertedIndex = null;
+            for (const rule of groupedRules) {
+                const declarations = rule.declarations;
+                const baseRule = `${rule.selector} { ${declarations} }`;
+                // Wrap with at-rules if present
+                let fullRule = baseRule;
+                if (rule.atRules && rule.atRules.length > 0) {
+                    fullRule = rule.atRules.reduce((css, atRule) => `${atRule} { ${css} }`, baseRule);
+                }
+                // Insert individual rule into style element
+                const styleElement = targetSheet.sheet;
                 const styleSheet = styleElement.sheet;
                 if (styleSheet && !this.config.forceTextInjection) {
                     const maxIndex = styleSheet.cssRules.length;
-                    const safeIndex = Math.min(Math.max(0, ruleIndex), maxIndex);
-                    styleSheet.insertRule(cssText, safeIndex);
+                    const safeIndex = Math.min(Math.max(0, currentRuleIndex), maxIndex);
+                    styleSheet.insertRule(fullRule, safeIndex);
+                    if (firstInsertedIndex == null)
+                        firstInsertedIndex = safeIndex;
+                    lastInsertedIndex = safeIndex;
+                    currentRuleIndex = safeIndex + 1;
                 }
                 else {
+                    // Use textContent (either as fallback or when forceTextInjection is enabled)
                     styleElement.textContent =
-                        (styleElement.textContent || '') + '\n' + cssText;
-                    entry.currentCssText = cssText;
+                        (styleElement.textContent || '') + '\n' + fullRule;
+                    if (firstInsertedIndex == null)
+                        firstInsertedIndex = currentRuleIndex;
+                    lastInsertedIndex = currentRuleIndex;
+                    currentRuleIndex++;
                 }
-                // Update bookkeeping
-                sheet.ruleCount = Math.max(sheet.ruleCount, ruleIndex + 1);
-                registry.batchedRules.set(batchKey, entry);
-                if (registry.metrics) {
-                    registry.metrics.totalInsertions++;
+                // CRITICAL DEBUG: Verify the style element is in DOM only if there are issues and we're not using forceTextInjection
+                if (!styleElement.parentNode && !this.config.forceTextInjection) {
+                    console.error('SheetManager: Style element is NOT in DOM! This is the problem!', {
+                        className,
+                        ruleIndex: currentRuleIndex,
+                    });
                 }
+                // Conditionally store cssText and track for debug
+                if (this.config.debugMode) {
+                    insertedRuleTexts.push(fullRule);
+                    try {
+                        registry.ruleTextSet.add(fullRule);
+                    }
+                    catch (_) {
+                        // noop: defensive in case ruleTextSet is unavailable
+                    }
+                }
+                // currentRuleIndex already adjusted above
+            }
+            // Update sheet info based on the number of rules inserted
+            const finalRuleIndex = currentRuleIndex - 1;
+            if (finalRuleIndex >= targetSheet.ruleCount) {
+                targetSheet.ruleCount = finalRuleIndex + 1;
             }
-            // For batched insertion, we don't create per-class RuleInfo ranges anymore
             return {
                 className,
-                ruleIndex: -1,
-                sheetIndex: -1,
-                cssText: [],
+                ruleIndex: firstInsertedIndex ?? ruleIndex,
+                sheetIndex,
+                cssText: this.config.debugMode ? insertedRuleTexts : [],
+                endRuleIndex: lastInsertedIndex ?? finalRuleIndex,
             };
         }
         catch (error) {
-            console.warn('Failed to insert CSS rules (batched):', error, {
+            console.warn('Failed to insert CSS rules:', error, {
                 flattenedRules,
                 className,
             });
@@ -296,34 +300,21 @@ export class SheetManager {
      * Mark a ruleset as unused but keep it in the stylesheet
      */
     markAsUnused(registry, className) {
-        // If this class participates in batched rules, just mark it as unused
-        const keys = registry.classToBatchedKeys.get(className);
-        if (keys && keys.size) {
-            registry.unusedBatchedClasses.add(className);
-            registry.refCounts.delete(className);
-            if (registry.metrics) {
-                registry.metrics.totalUnused++;
-            }
-            // Schedule cleanup when we have enough unused classes
-            const threshold = this.config.unusedStylesThreshold || 500;
-            if (registry.unusedBatchedClasses.size >= threshold) {
-                this.scheduleBulkCleanup(registry);
-            }
-            return; // handled via batched path
-        }
-        // Fallback to legacy unused path for non-batched rules
         const ruleInfo = registry.rules.get(className);
         if (!ruleInfo)
             return;
+        // Mark as unused (but keep in registry.rules)
         const unusedInfo = {
             ruleInfo,
             markedUnusedAt: Date.now(),
         };
         registry.unusedRules.set(className, unusedInfo);
         registry.refCounts.delete(className);
+        // Update metrics
         if (registry.metrics) {
             registry.metrics.totalUnused++;
         }
+        // Schedule bulk cleanup if threshold exceeded
         const threshold = this.config.unusedStylesThreshold || 500;
         if (registry.unusedRules.size >= threshold) {
             this.scheduleBulkCleanup(registry);
@@ -368,79 +359,41 @@ export class SheetManager {
      * Perform bulk cleanup of all unused styles
      */
     performBulkCleanup(registry) {
+        if (registry.unusedRules.size === 0)
+            return;
+        const classNamesToCleanup = Array.from(registry.unusedRules.keys());
         let cleanedUpCount = 0;
-        // Handle legacy unused rules
-        if (registry.unusedRules.size > 0) {
-            const classNamesToCleanup = Array.from(registry.unusedRules.keys());
-            // Group by sheet for efficient deletion
-            const rulesBySheet = new Map();
-            for (const className of classNamesToCleanup) {
-                const unusedInfo = registry.unusedRules.get(className);
-                if (!unusedInfo)
-                    continue;
-                const sheetIndex = unusedInfo.ruleInfo.sheetIndex;
-                if (!rulesBySheet.has(sheetIndex)) {
-                    rulesBySheet.set(sheetIndex, []);
-                }
-                rulesBySheet
-                    .get(sheetIndex)
-                    .push({ className, ruleInfo: unusedInfo.ruleInfo });
+        // Group by sheet for efficient deletion
+        const rulesBySheet = new Map();
+        for (const className of classNamesToCleanup) {
+            const unusedInfo = registry.unusedRules.get(className);
+            if (!unusedInfo)
+                continue;
+            const sheetIndex = unusedInfo.ruleInfo.sheetIndex;
+            if (!rulesBySheet.has(sheetIndex)) {
+                rulesBySheet.set(sheetIndex, []);
             }
-            // Delete rules from each sheet (in reverse order to preserve indices)
-            for (const [sheetIndex, rulesInSheet] of rulesBySheet) {
-                // Sort by rule index in descending order for safe deletion
-                rulesInSheet.sort((a, b) => b.ruleInfo.ruleIndex - a.ruleInfo.ruleIndex);
-                for (const { className, ruleInfo } of rulesInSheet) {
-                    this.deleteRule(registry, ruleInfo);
-                    registry.rules.delete(className);
-                    registry.unusedRules.delete(className);
-                    cleanedUpCount++;
-                }
+            rulesBySheet
+                .get(sheetIndex)
+                .push({ className, ruleInfo: unusedInfo.ruleInfo });
+        }
+        // Delete rules from each sheet (in reverse order to preserve indices)
+        for (const [sheetIndex, rulesInSheet] of rulesBySheet) {
+            // Sort by rule index in descending order for safe deletion
+            rulesInSheet.sort((a, b) => b.ruleInfo.ruleIndex - a.ruleInfo.ruleIndex);
+            for (const { className, ruleInfo } of rulesInSheet) {
+                this.deleteRule(registry, ruleInfo);
+                registry.rules.delete(className);
+                registry.unusedRules.delete(className);
+                cleanedUpCount++;
             }
         }
-        // Handle batched unused classes
-        if (registry.unusedBatchedClasses.size > 0) {
-            cleanedUpCount += this.cleanupBatchedUnusedClasses(registry);
-        }
         // Update metrics
         if (registry.metrics) {
             registry.metrics.bulkCleanups++;
             registry.metrics.stylesCleanedUp += cleanedUpCount;
         }
     }
-    /**
-     * Clean up unused classes from batched rules
-     */
-    cleanupBatchedUnusedClasses(registry) {
-        const unusedClasses = Array.from(registry.unusedBatchedClasses);
-        let cleanedUpCount = 0;
-        for (const className of unusedClasses) {
-            const keys = registry.classToBatchedKeys.get(className);
-            if (!keys)
-                continue;
-            for (const key of keys) {
-                const entry = registry.batchedRules.get(key);
-                if (!entry)
-                    continue;
-                // Remove class from the batched rule
-                entry.classNames.delete(className);
-                if (entry.classNames.size === 0) {
-                    // Remove the entire batched rule if no classes left
-                    this.removeBatchedEntry(registry, entry);
-                    registry.batchedRules.delete(key);
-                }
-                else {
-                    // Update the CSS to remove this class from the selector
-                    this.updateBatchedRuleCss(registry, entry, document);
-                }
-            }
-            // Clean up the class mappings
-            registry.classToBatchedKeys.delete(className);
-            registry.unusedBatchedClasses.delete(className);
-            cleanedUpCount++;
-        }
-        return cleanedUpCount;
-    }
     /**
      * Process the deletion queue for cleanup
      */
@@ -534,204 +487,6 @@ export class SheetManager {
         // Clear registry
         this.rootRegistries.delete(root);
     }
-    /** Normalize declaration list by sorting properties for stable keys */
-    normalizeDeclarations(declarations) {
-        return declarations
-            .split(';')
-            .map((d) => d.trim())
-            .filter(Boolean)
-            .sort((a, b) => a.localeCompare(b))
-            .join(';');
-    }
-    /** Build selector template normalizing class references to placeholders.
-     * Rules:
-     * - Replace any occurrence of :is(.class[, .class]*) with :is(__CLASS__)
-     * - If starts with .<name>.<name>, replace with __CLASS__.__CLASS__ (legacy specificity)
-     * - Else if starts with .<name>, replace with __CLASS__
-     */
-    makeSelectorTemplate(selector, className) {
-        // Normalize any :is(.tX, .tY) occurrences first
-        const isClassList = /:is\(\s*\.[A-Za-z0-9_-]+(?:\s*,\s*\.[A-Za-z0-9_-]+)*\s*\)/g;
-        let normalized = selector.replace(isClassList, ':is(__CLASS__)');
-        // Legacy patterns that may still start with plain class
-        const doubleRe = /^\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/;
-        const singleRe = /^\.[A-Za-z0-9_-]+/;
-        if (doubleRe.test(normalized)) {
-            normalized = normalized.replace(doubleRe, '__CLASS__.__CLASS__');
-        }
-        else if (singleRe.test(normalized)) {
-            normalized = normalized.replace(singleRe, '__CLASS__');
-        }
-        return { selectorTemplate: normalized };
-    }
-    /** Compose a unique batch key */
-    getBatchKey(atRules, selectorTemplate, normalizedDecl) {
-        const at = atRules && atRules.length ? atRules.join('|') : '';
-        return `${at}||${selectorTemplate}||${normalizedDecl}`;
-    }
-    /** Ensure there is a target sheet and available rule index */
-    ensureTargetSheetAndIndex(registry, root) {
-        let sheet = this.findAvailableSheet(registry, root);
-        if (!sheet) {
-            sheet = this.createSheet(registry, root);
-        }
-        const ruleIndex = this.findAvailableRuleIndex(sheet);
-        const sheetIndex = registry.sheets.indexOf(sheet);
-        return { sheet, sheetIndex, ruleIndex };
-    }
-    /** Compose CSS text for a batched rule entry */
-    composeCssForEntry(entry) {
-        const classList = Array.from(entry.classNames)
-            .sort((a, b) => {
-            const aNum = parseInt(a.slice(1));
-            const bNum = parseInt(b.slice(1));
-            return aNum - bNum;
-        })
-            .map((c) => `.${c}`)
-            .join(', ');
-        // If template expects doubled specificity, replicate :is twice
-        let selector = entry.selectorTemplate
-            .replace(/:is\(__CLASS__\)/g, `:is(${classList})`)
-            .replace(/__CLASS__\.__CLASS__/g, `:is(${classList}):is(${classList})`)
-            .replace(/__CLASS__/g, `:is(${classList})`);
-        const baseRule = `${selector} { ${entry.declarations} }`;
-        if (entry.atRules && entry.atRules.length) {
-            return entry.atRules.reduce((acc, at) => `${at} { ${acc} }`, baseRule);
-        }
-        return baseRule;
-    }
-    /** Update CSSOM/textContent for an existing batched rule */
-    updateBatchedRuleCss(registry, entry, root) {
-        const sheet = registry.sheets[entry.sheetIndex];
-        if (!sheet)
-            return;
-        const styleElement = sheet.sheet;
-        const styleSheet = styleElement.sheet;
-        const newCssText = this.composeCssForEntry(entry);
-        if (styleSheet && !this.config.forceTextInjection) {
-            // Replace rule at the same index
-            const idx = Math.max(0, Math.min(entry.ruleIndex, styleSheet.cssRules.length - 1));
-            try {
-                styleSheet.deleteRule(idx);
-            }
-            catch {
-                // Ignore CSSOM errors when deleting rules
-            }
-            const insertIdx = Math.min(idx, styleSheet.cssRules.length);
-            styleSheet.insertRule(newCssText, insertIdx);
-            entry.ruleIndex = insertIdx;
-        }
-        else {
-            // Text content replacement
-            const old = entry.currentCssText || '';
-            const fullText = styleElement.textContent || '';
-            if (old) {
-                styleElement.textContent = fullText.replace(old, newCssText);
-            }
-            else {
-                styleElement.textContent =
-                    (fullText ? fullText + '\n' : '') + newCssText;
-            }
-            entry.currentCssText = newCssText;
-        }
-    }
-    /** Remove a batched rule entirely from the stylesheet */
-    removeBatchedEntry(registry, entry) {
-        const sheet = registry.sheets[entry.sheetIndex];
-        if (!sheet)
-            return;
-        const styleElement = sheet.sheet;
-        const styleSheet = styleElement.sheet;
-        if (styleSheet && !this.config.forceTextInjection) {
-            const idx = entry.ruleIndex;
-            if (idx >= 0 && idx < styleSheet.cssRules.length) {
-                try {
-                    styleSheet.deleteRule(idx);
-                    sheet.ruleCount = Math.max(0, sheet.ruleCount - 1);
-                }
-                catch {
-                    // Ignore CSSOM errors when deleting rules
-                }
-            }
-        }
-        else {
-            const old = entry.currentCssText || '';
-            if (old) {
-                const fullText = styleElement.textContent || '';
-                styleElement.textContent = fullText.replace(old, '');
-            }
-            sheet.ruleCount = Math.max(0, sheet.ruleCount - 1);
-        }
-    }
-    /** Find existing class that has an identical rule (same batch key) */
-    findClassWithIdenticalRule(registry, batchKey, excludeClassName) {
-        const meta = registry.batchedRuleMeta.get(batchKey);
-        if (!meta)
-            return null;
-        // Look through all classes to find one that has this batch key but isn't batched yet
-        for (const [className, keys] of registry.classToBatchedKeys.entries()) {
-            if (className === excludeClassName)
-                continue;
-            if (keys.has(batchKey) && !registry.batchedRules.has(batchKey)) {
-                return className;
-            }
-        }
-        return null;
-    }
-    /** Convert an existing single-class rule to a batched rule with additional class */
-    convertToBatchedRule(registry, existingClassName, newClassName, batchKey, root) {
-        const meta = registry.batchedRuleMeta.get(batchKey);
-        if (!meta)
-            return;
-        // Find the existing rule info for the existing class
-        const existingRuleInfo = registry.rules.get(existingClassName);
-        if (!existingRuleInfo || existingRuleInfo.sheetIndex < 0)
-            return;
-        // Create a new batched entry at the same location
-        const entry = {
-            key: batchKey,
-            selectorTemplate: meta.selectorTemplate,
-            declarations: meta.declarations,
-            atRules: meta.atRules,
-            classNames: new Set([existingClassName, newClassName]),
-            sheetIndex: existingRuleInfo.sheetIndex,
-            ruleIndex: existingRuleInfo.ruleIndex,
-        };
-        // Update the CSS rule to use batched selector
-        const newCssText = this.composeCssForEntry(entry);
-        const sheet = registry.sheets[entry.sheetIndex];
-        if (!sheet)
-            return;
-        const styleElement = sheet.sheet;
-        const styleSheet = styleElement.sheet;
-        if (styleSheet && !this.config.forceTextInjection) {
-            try {
-                // Replace the existing rule
-                const idx = Math.max(0, Math.min(entry.ruleIndex, styleSheet.cssRules.length - 1));
-                styleSheet.deleteRule(idx);
-                styleSheet.insertRule(newCssText, idx);
-            }
-            catch {
-                // Ignore CSSOM errors when updating rules
-            }
-        }
-        else {
-            // Replace in text content
-            const oldCssText = existingRuleInfo.cssText?.[0] || '';
-            if (oldCssText) {
-                const fullText = styleElement.textContent || '';
-                styleElement.textContent = fullText.replace(oldCssText, newCssText);
-            }
-            entry.currentCssText = newCssText;
-        }
-        // Update registry
-        registry.batchedRules.set(batchKey, entry);
-        // Update class mappings
-        if (!registry.classToBatchedKeys.has(newClassName)) {
-            registry.classToBatchedKeys.set(newClassName, new Set());
-        }
-        registry.classToBatchedKeys.get(newClassName).add(batchKey);
-    }
 }
 
         

package/es/tasty/injector/types.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-0692b88
+ * @cube-dev/ui-kit v0.0.0-canary-72a72ab
  * Released under the MIT license.
  */
 

package/es/tasty/parser/classify.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-0692b88
+ * @cube-dev/ui-kit v0.0.0-canary-72a72ab
  * Released under the MIT license.
  */
 

package/es/tasty/parser/const.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-0692b88
+ * @cube-dev/ui-kit v0.0.0-canary-72a72ab
  * Released under the MIT license.
  */
 

package/es/tasty/parser/lru.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-0692b88
+ * @cube-dev/ui-kit v0.0.0-canary-72a72ab
  * Released under the MIT license.
  */
 

package/es/tasty/parser/parser.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-0692b88
+ * @cube-dev/ui-kit v0.0.0-canary-72a72ab
  * Released under the MIT license.
  */
 

package/es/tasty/parser/tokenizer.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-0692b88
+ * @cube-dev/ui-kit v0.0.0-canary-72a72ab
  * Released under the MIT license.
  */
 

package/es/tasty/parser/types.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-0692b88
+ * @cube-dev/ui-kit v0.0.0-canary-72a72ab
  * Released under the MIT license.
  */
 

package/es/tasty/providers/BreakpointsProvider.js

@@ -1,7 +1,7 @@
 /**
  * @license MIT
  * author: Cube Dev Team
- * @cube-dev/ui-kit v0.0.0-canary-0692b88
+ * @cube-dev/ui-kit v0.0.0-canary-72a72ab
  * 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-0692b88
+ * @cube-dev/ui-kit v0.0.0-canary-72a72ab
  * 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-0692b88
+ * @cube-dev/ui-kit v0.0.0-canary-72a72ab
  * 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-0692b88
+ * @cube-dev/ui-kit v0.0.0-canary-72a72ab
  * Released under the MIT license.
  */