lido-player 0.0.2-alpha-49 → 0.0.2-alpha-43-dev

package/dist/collection/utils/utilsHandlers/matrixHandler.js

@@ -0,0 +1,298 @@
+import { LidoContainer } from "../constants";
+import { getElementScale } from "./dragDropHandler";
+export function handlingMatrix(element) {
+    const container = document.querySelector(LidoContainer);
+    if (!container)
+        return;
+    const defualtMatrix = element;
+    adjustSizeForSlots(container, defualtMatrix);
+    splitSlots(container, defualtMatrix);
+}
+const splitSlots = (container, defualtMatrix) => {
+    const defualtElements = defualtMatrix.querySelectorAll('.slot');
+    const allDropMatrixes = container.querySelectorAll('lido-math-matrix[type="drop"]');
+    const allDragMatrixes = container.querySelectorAll('lido-math-matrix[type="drag"]');
+    let slot = 1;
+    for (let i = 0; i < allDropMatrixes.length; i++) {
+        const el = allDropMatrixes[i];
+        const rowCount = el.getAttribute('rows') ? parseInt(el.getAttribute('rows')) : 1;
+        const colCount = el.getAttribute('cols') ? parseInt(el.getAttribute('cols')) : 1;
+        if (rowCount === 1 || colCount === 1) {
+            if (rowCount === colCount) {
+                const numbers = Array.from({ length: 100 }, (_, i) => i + 1)
+                    .sort(() => Math.random() - 0.5) // Shuffle
+                    .slice(0, 10); // Take first 10 unique numbers
+                allDropMatrixes.forEach((item, index) => {
+                    const dropElement = item;
+                    const dropPosition = defualtElements[numbers[index]];
+                    // Safeguard if index > available numbers
+                    if (!dropPosition)
+                        return;
+                    postioningDropElement(dropElement, dropPosition);
+                    const dragElement = allDragMatrixes[index];
+                    dragElement.setAttribute('text', (numbers[index] + 1).toString());
+                });
+                // return;
+            }
+            if (rowCount === 2 && colCount === 1) {
+                const pairs = generateDoubleSquares(10);
+                console.log('pairs double : ', pairs);
+                allDropMatrixes.forEach((item, index) => {
+                    const dropElement = item;
+                    const dropPosition = defualtElements[pairs[index][0] - 1];
+                    postioningDropElement(dropElement, dropPosition);
+                });
+                allDragMatrixes.forEach((item, index) => {
+                    const dragElement = item;
+                    dragElement.setAttribute('text', pairs[index].toString());
+                });
+                break;
+            }
+            if (rowCount === 5) {
+                const dropPositionElements = generateHalfHorizontalStripes(i);
+                const dropPosition = defualtElements[dropPositionElements[0] - 1];
+                const dragElement = allDragMatrixes[i];
+                dragElement.setAttribute('text', dropPositionElements.toString());
+                postioningDropElement(el, dropPosition);
+            }
+            if (rowCount === 10) {
+                const dropPosition = defualtElements[slot];
+                const dragElement = allDragMatrixes[i];
+                dragElement.setAttribute('text', Array.from({ length: 10 }, (_, i) => slot + 1 + i * 10).toString());
+                postioningDropElement(el, dropPosition);
+                slot = slot + 2;
+            }
+            else if (colCount === 10) {
+                const dropPosition = defualtElements[10 + (slot - 1)];
+                const dragElement = allDragMatrixes[i];
+                dragElement.setAttribute('text', Array.from({ length: 10 }, (_, i) => i + 10 + slot).toString());
+                postioningDropElement(el, dropPosition);
+                slot = slot + 20;
+            }
+        }
+        else if (rowCount === 3 || colCount === 3) {
+            const slotCell = generateSlotsFromDrops(container);
+            const cellNumbers = Object.keys(slotCell).map(key => slotCell[key].cells);
+            allDragMatrixes.forEach((matrix, index) => {
+                const dragElement = matrix;
+                // let dragTextAttr = dragElement.getAttribute('text');
+                if (dragElement) {
+                    dragElement.setAttribute('text', cellNumbers[index].toString());
+                }
+            });
+            allDropMatrixes.forEach((matrix, index) => {
+                const dropElement = matrix;
+                const dropPosition = defualtElements[slotCell[`slot-${index + 1}`].cells[0] - 1];
+                postioningDropElement(dropElement, dropPosition);
+            });
+            break; // stops the loop immediately
+        }
+        else if (rowCount === 2 || colCount === 2) {
+            if (rowCount === colCount) {
+                const pairs = generate2by2Squares(10);
+                allDropMatrixes.forEach((item, index) => {
+                    const dropElement = item;
+                    const dropPosition = defualtElements[pairs[index][0] - 1];
+                    postioningDropElement(dropElement, dropPosition);
+                });
+                allDragMatrixes.forEach((item, index) => {
+                    const dragElement = item;
+                    dragElement.setAttribute('text', pairs[index].toString());
+                });
+                break;
+            }
+        }
+    }
+};
+function generateSlotsFromDrops(container) {
+    const gridSize = 10;
+    let availableCells = Array.from({ length: 100 }, (_, i) => i + 1);
+    const occupied = new Set();
+    const slots = {};
+    let generated = 0;
+    const getCell = (row, col) => row * gridSize + col + 1;
+    // Get all <lido-math-matrix type="drop">
+    const allDropMatrixes = container.querySelectorAll('lido-math-matrix[type="drop"]');
+    for (const matrix of Array.from(allDropMatrixes)) {
+        const width = parseInt(matrix.getAttribute('cols') || '1');
+        const height = parseInt(matrix.getAttribute('rows') || '1');
+        const possiblePositions = [];
+        // generate all possible top-left positions
+        for (let row = 0; row <= gridSize - height; row++) {
+            for (let col = 0; col <= gridSize - width; col++) {
+                const cells = [];
+                let canPlace = true;
+                for (let r = 0; r < height; r++) {
+                    for (let c = 0; c < width; c++) {
+                        const cell = getCell(row + r, col + c);
+                        if (occupied.has(cell)) {
+                            canPlace = false;
+                            break;
+                        }
+                        cells.push(cell);
+                    }
+                    if (!canPlace)
+                        break;
+                }
+                if (canPlace)
+                    possiblePositions.push(cells);
+            }
+        }
+        if (possiblePositions.length === 0) {
+            console.warn(`No space left for matrix ${generated + 1}`);
+            continue;
+        }
+        // Pick a random valid position
+        const randomCells = possiblePositions[Math.floor(Math.random() * possiblePositions.length)];
+        // Mark as occupied & remove from available
+        randomCells.forEach(c => {
+            occupied.add(c);
+            availableCells = availableCells.filter(x => x !== c);
+        });
+        generated++;
+        slots[`slot-${generated}`] = { cells: randomCells, width, height };
+    }
+    return slots;
+}
+const postioningDropElement = (dropElement, dropPosition) => {
+    const container = document.getElementById(LidoContainer);
+    const containerScale = getElementScale(container);
+    dropElement.style.transform = 'translate(0,0)';
+    const posRect = dropPosition.getBoundingClientRect();
+    const dropRect = dropElement.getBoundingClientRect();
+    const posCenterX = posRect.left + posRect.width / 2;
+    const posCenterY = posRect.top + posRect.height / 2;
+    const dropCenterX = dropRect.left + dropRect.width / 2;
+    const dropCenterY = dropRect.top + dropRect.height / 2;
+    const scaledLeft = (posCenterX - dropCenterX) / containerScale;
+    const scaledTop = (posCenterY - dropCenterY) / containerScale;
+    const rowCount = dropElement.getAttribute('rows') ? parseInt(dropElement.getAttribute('rows')) : 1;
+    const colCount = dropElement.getAttribute('cols') ? parseInt(dropElement.getAttribute('cols')) : 1;
+    const elementWidth = parseInt(dropPosition.style.width);
+    if (rowCount === 1 || colCount === 1) {
+        if (rowCount === colCount) {
+            dropElement.style.transform = `translate(${scaledLeft}px, ${scaledTop}px)`;
+            return;
+        }
+        else if (rowCount > colCount) {
+            if (rowCount === 10) {
+                dropElement.style.transform = `translate(${scaledLeft + (elementWidth * 4 + elementWidth / 2)}px, ${scaledTop}px)`;
+            }
+            else if (rowCount === 5) {
+                dropElement.style.transform = `translate(${scaledLeft + elementWidth * 2}px, ${scaledTop}px)`;
+            }
+            else if (rowCount === 2) {
+                dropElement.style.transform = `translate(${scaledLeft + elementWidth / 2}px, ${scaledTop}px)`;
+            }
+        }
+        else if (rowCount < colCount) {
+            if (colCount === 10) {
+                dropElement.style.transform = `translate(${scaledLeft}px, ${scaledTop + elementWidth * 4 + elementWidth * 0.2 + elementWidth / 2}px)`;
+            }
+            else if (colCount === 5) {
+                dropElement.style.transform = `translate(${scaledLeft}px, ${scaledTop + elementWidth * 2 + elementWidth * 0.0921}px)`;
+            }
+        }
+        return;
+    }
+    if (rowCount === colCount) {
+        if (rowCount === 2) {
+            dropElement.style.transform = `translate(${scaledLeft + elementWidth / 2}px, ${scaledTop + elementWidth / 2 + 4}px)`;
+            return;
+        }
+        dropElement.style.transform = `translate(${scaledLeft + elementWidth}px, ${scaledTop + elementWidth + 4}px)`;
+        return;
+    }
+    if (rowCount === 3) {
+        if (colCount === 2) {
+            dropElement.style.transform = `translate(${scaledLeft + elementWidth}px, ${scaledTop + elementWidth / 2 + 4}px)`;
+            return;
+        }
+        else if (colCount === 1) {
+            dropElement.style.transform = `translate(${scaledLeft + elementWidth}px, ${scaledTop}px)`;
+            return;
+        }
+    }
+    if (rowCount === 2) {
+        if (colCount === 3) {
+            dropElement.style.transform = `translate(${scaledLeft + elementWidth / 2}px, ${scaledTop + elementWidth + 4}px)`;
+            return;
+        }
+        else if (colCount === 1) {
+            dropElement.style.transform = `translate(${scaledLeft + elementWidth / 2}px, ${scaledTop}px)`;
+            return;
+        }
+    }
+};
+const adjustSizeForSlots = (container, defualtMatrix) => {
+    const defualtElement = defualtMatrix.querySelector('.slot');
+    const width = defualtElement.style.width;
+    const allDropMatrixes = container.querySelectorAll('lido-math-matrix[type="drop"]');
+    const allDragMatrixes = container.querySelectorAll('lido-math-matrix[type="drag"]');
+    allDragMatrixes.forEach(item => {
+        const el = item;
+        Array.from(el.querySelectorAll('.slot')).forEach(slot => {
+            const slotEl = slot;
+            slotEl.parentElement.style.width = width;
+            slotEl.style.width = width;
+            slotEl.style.height = width;
+        });
+    });
+    allDropMatrixes.forEach(item => {
+        const el = item;
+        Array.from(el.querySelectorAll('.slot')).forEach(slot => {
+            const slotEl = slot;
+            slotEl.parentElement.style.width = width;
+            slotEl.style.width = width;
+            slotEl.style.height = width;
+        });
+    });
+};
+function generateHalfHorizontalStripes(index) {
+    const numbers = Array.from({ length: 10 }, (_, i) => index + 1 + i * 10);
+    const randomPlace = Math.floor(Math.random() * 6);
+    const startSlot = numbers[randomPlace];
+    console.log('kedachuruchu', Array.from({ length: 5 }, (_, i) => startSlot + i * 10));
+    return Array.from({ length: 5 }, (_, i) => startSlot + i * 10);
+}
+function generate2by2Squares(count = 16) {
+    const gridSize = 10;
+    const squares = [];
+    const usedCells = new Set();
+    function getCell(row, col) {
+        return (row - 1) * gridSize + col;
+    }
+    while (squares.length < count) {
+        const row = Math.floor(Math.random() * (gridSize - 1)) + 1; // 1–9
+        const col = Math.floor(Math.random() * (gridSize - 1)) + 1; // 1–9
+        const square = [getCell(row, col), getCell(row, col + 1), getCell(row + 1, col), getCell(row + 1, col + 1)];
+        // Skip if overlapping with previous
+        if (square.some(cell => usedCells.has(cell)))
+            continue;
+        // Mark cells as used
+        square.forEach(cell => usedCells.add(cell));
+        squares.push(square);
+    }
+    return squares;
+}
+function generateDoubleSquares(count = 16) {
+    const gridSize = 10;
+    const pairs = [];
+    const usedCells = new Set();
+    function getCell(row, col) {
+        return (row - 1) * gridSize + col;
+    }
+    while (pairs.length < count) {
+        const row = Math.floor(Math.random() * (gridSize - 1)) + 1; // 1–9
+        const col = Math.floor(Math.random() * gridSize) + 1; // 1–10
+        const top = getCell(row, col);
+        const bottom = getCell(row + 1, col);
+        // Skip if already used
+        if (usedCells.has(top) || usedCells.has(bottom))
+            continue;
+        pairs.push([top, bottom]);
+        usedCells.add(top);
+        usedCells.add(bottom);
+    }
+    return pairs;
+}

package/dist/collection/utils/utilsHandlers/slideHandler.js

@@ -242,13 +242,15 @@ export function slidingWithScaling(element) {
     });
 }
 const slideCompleted = (slideElement) => {
-    const slideArr = JSON.parse(localStorage.getItem(SelectedValuesKey)) || [];
+    var _a;
+    const container = document.getElementById(LidoContainer);
+    const slideArr = JSON.parse((_a = container.getAttribute(SelectedValuesKey)) !== null && _a !== void 0 ? _a : '[]');
     const allSlideElements = document.querySelectorAll("[type='slide']");
     let index = 0;
     allSlideElements.forEach(item => {
         slideArr[index++] = item['value'];
     });
-    localStorage.setItem(SelectedValuesKey, JSON.stringify(slideArr));
+    container.setAttribute(SelectedValuesKey, JSON.stringify(slideArr));
     const objectiveString = document.getElementById(LidoContainer)['objective'];
     const objectiveArray = objectiveString.split(',');
     const elementIndex = slideArr.indexOf(slideElement['value']);

package/dist/collection/utils/utilsHandlers/sortHandler.js

@@ -1,5 +1,5 @@
-import { DragSelectedMapKey, LidoContainer, SelectedValuesKey } from "../constants";
-import { calculateScale, executeActions, handleShowCheck, matchStringPattern, onActivityComplete, storingEachActivityScore } from "../utils";
+import { LidoContainer, SelectedValuesKey, DropToAttr } from "../constants";
+import { buildDragSelectedMapFromDOM, executeActions, handleShowCheck, matchStringPattern, onActivityComplete, storingEachActivityScore } from "../utils";
 let preOverlap;
 function getElementScale(element) {
     const transform = window.getComputedStyle(element).transform;
@@ -106,7 +106,7 @@ export function enableReorderDrag(element) {
         isClicked = false;
         event.preventDefault();
         const containerRect = container.getBoundingClientRect();
-        const containerScale = calculateScale();
+        const containerScale = getElementScale(container);
         const newLeft = (point.clientX - containerRect.left - offsetXInElement) / containerScale;
         const newTop = (point.clientY - containerRect.top - offsetYInElement) / containerScale;
         element.style.left = `${newLeft}px`;
@@ -173,16 +173,18 @@ export function enableReorderDrag(element) {
             else {
                 if (element.parentElement['type'] !== 'category') {
                     executeActions('this.alignMatch=true', divEl, element);
-                    divEl.replaceWith(element);
+                    setTimeout(() => {
+                        divEl.replaceWith(element);
+                    }, 500);
                 }
                 else {
                     const categoryElement = element.parentElement;
-                    const dragValues = JSON.parse(localStorage.getItem(DragSelectedMapKey)) || {};
+                    const dragValues = buildDragSelectedMapFromDOM();
                     const tabKey = categoryElement.getAttribute('tab-index');
                     const targetValue = element['value'];
                     if (dragValues[tabKey]) {
                         dragValues[tabKey] = dragValues[tabKey].filter((el) => el !== targetValue);
-                        localStorage.setItem(DragSelectedMapKey, JSON.stringify(dragValues));
+                        // localStorage.setItem(DragSelectedMapKey, JSON.stringify(dragValues));
                     }
                     optionArea.scrollTo({
                         top: optionArea.scrollHeight,
@@ -190,6 +192,7 @@ export function enableReorderDrag(element) {
                     });
                     optionArea.appendChild(element);
                     element.classList.remove('dropped');
+                    element.removeAttribute('drop-to');
                     if (dummy) {
                         dummy.remove();
                     }
@@ -228,12 +231,12 @@ export function enableReorderDrag(element) {
                 category = categoryArr[0];
             }
             if (element.parentElement.getAttribute('type') === 'category') {
-                const dragValues = JSON.parse(localStorage.getItem(DragSelectedMapKey)) || {};
+                const dragValues = buildDragSelectedMapFromDOM();
                 const tabKey = category.getAttribute('tab-index');
                 const targetValue = element['value'];
                 if (dragValues[tabKey]) {
                     dragValues[tabKey] = dragValues[tabKey].filter((el) => el !== targetValue);
-                    localStorage.setItem(DragSelectedMapKey, JSON.stringify(dragValues));
+                    // localStorage.setItem(DragSelectedMapKey, JSON.stringify(dragValues));
                 }
                 const dummy = createDummyElement(element);
                 optionArea.appendChild(dummy);
@@ -247,6 +250,7 @@ export function enableReorderDrag(element) {
                     resetElementStyles(element);
                     dummy.replaceWith(element);
                     element.classList.remove('dropped');
+                    element.removeAttribute('drop-to');
                 }, 100);
                 return;
             }
@@ -395,13 +399,15 @@ function moveWithAnimation(target, overlapped) {
 }
 // Drop Completed
 const wordDropComplete = (block, element) => {
+    var _a;
+    console.log("worddrop");
     const container = document.getElementById(LidoContainer);
     const objective = container.getAttribute('objective');
     const objectiveArray = objective.split(',');
-    let wordArray = JSON.parse(localStorage.getItem(SelectedValuesKey)) || [];
+    let wordArray = JSON.parse((_a = container.getAttribute(SelectedValuesKey)) !== null && _a !== void 0 ? _a : '[]');
     const wordBlock = block.children;
     wordArray = Array.from(wordBlock).map(child => child.getAttribute('value'));
-    localStorage.setItem(SelectedValuesKey, JSON.stringify(wordArray));
+    container.setAttribute(SelectedValuesKey, JSON.stringify(wordArray));
     const elementIndex = wordArray.indexOf(element['value']);
     if (elementIndex >= 0) {
         const res = matchStringPattern(element['value'], [objectiveArray[elementIndex].trim()]);
@@ -416,7 +422,7 @@ const wordDropComplete = (block, element) => {
 };
 async function onDropToCategory(dragElement, categoryElement) {
     dragElement.classList.add('dropped');
-    let dragSelected = JSON.parse(localStorage.getItem(DragSelectedMapKey)) || {};
+    let dragSelected = buildDragSelectedMapFromDOM();
     let elementArr = dragSelected[categoryElement.getAttribute('tab-index')];
     if (Array.isArray(elementArr)) {
         if (elementArr.includes(dragElement['value']))
@@ -428,6 +434,9 @@ async function onDropToCategory(dragElement, categoryElement) {
             dragSelected[key].splice(index, 1);
         }
     }
-    localStorage.setItem(DragSelectedMapKey, JSON.stringify(dragSelected));
+    if (categoryElement === null || categoryElement === void 0 ? void 0 : categoryElement.id) {
+        dragElement.setAttribute(DropToAttr, categoryElement.id);
+    }
+    // localStorage.setItem(DragSelectedMapKey, JSON.stringify(dragSelected));
     await onActivityComplete(dragElement, categoryElement);
 }

package/dist/components/index.js

@@ -1 +1 @@
-export { f as format, g as getAssetPath, s as setAssetPath, a as setNonce, b as setPlatformOptions } from './p-cfa2aec8.js';
+export { f as format, g as getAssetPath, s as setAssetPath, a as setNonce, b as setPlatformOptions } from './p-bed94c37.js';

package/dist/components/lido-avatar.js

@@ -1,4 +1,4 @@
-import { L as LidoAvatar$1, d as defineCustomElement$1 } from './p-7f11a624.js';
+import { L as LidoAvatar$1, d as defineCustomElement$1 } from './p-cbac3cbc.js';
 
 const LidoAvatar = LidoAvatar$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/lido-balance.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface LidoBalance extends Components.LidoBalance, HTMLElement {}
+export const LidoBalance: {
+    prototype: LidoBalance;
+    new (): LidoBalance;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/lido-balance.js

@@ -0,0 +1,6 @@
+import { L as LidoBalance$1, d as defineCustomElement$1 } from './p-44808985.js';
+
+const LidoBalance = LidoBalance$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { LidoBalance, defineCustomElement };

package/dist/components/lido-calculator.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface LidoCalculator extends Components.LidoCalculator, HTMLElement {}
+export const LidoCalculator: {
+    prototype: LidoCalculator;
+    new (): LidoCalculator;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/lido-calculator.js

@@ -0,0 +1,6 @@
+import { L as LidoCalculator$1, d as defineCustomElement$1 } from './p-e36ddcc1.js';
+
+const LidoCalculator = LidoCalculator$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { LidoCalculator, defineCustomElement };

package/dist/components/lido-cell.js

@@ -1,4 +1,4 @@
-import { L as LidoCell$1, d as defineCustomElement$1 } from './p-b43ce4e1.js';
+import { L as LidoCell$1, d as defineCustomElement$1 } from './p-29bdd953.js';
 
 const LidoCell = LidoCell$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/lido-col.js

@@ -1,4 +1,4 @@
-import { L as LidoCol$1, d as defineCustomElement$1 } from './p-4cabbf28.js';
+import { L as LidoCol$1, d as defineCustomElement$1 } from './p-52844fa4.js';
 
 const LidoCol = LidoCol$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/lido-container.js

@@ -1,4 +1,4 @@
-import { L as LidoContainer$1, d as defineCustomElement$1 } from './p-e735dce9.js';
+import { L as LidoContainer$1, d as defineCustomElement$1 } from './p-9be56729.js';
 
 const LidoContainer = LidoContainer$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/lido-flash-card.js

@@ -1,4 +1,4 @@
-import { L as LidoFlash, d as defineCustomElement$1 } from './p-03e4cafe.js';
+import { L as LidoFlash, d as defineCustomElement$1 } from './p-e4e42677.js';
 
 const LidoFlashCard = LidoFlash;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/lido-float.js

@@ -1,4 +1,4 @@
-import { L as LidoFloat$1, d as defineCustomElement$1 } from './p-0bf92c7f.js';
+import { L as LidoFloat$1, d as defineCustomElement$1 } from './p-1fbdb431.js';
 
 const LidoFloat = LidoFloat$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/lido-home.js

@@ -1,4 +1,4 @@
-import { L as LidoHome$1, d as defineCustomElement$1 } from './p-b8af26e6.js';
+import { L as LidoHome$1, d as defineCustomElement$1 } from './p-322acda6.js';
 
 const LidoHome = LidoHome$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/lido-image.js

@@ -1,4 +1,4 @@
-import { L as LidoImage$1, d as defineCustomElement$1 } from './p-b5b6ad27.js';
+import { L as LidoImage$1, d as defineCustomElement$1 } from './p-15971ede.js';
 
 const LidoImage = LidoImage$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/lido-keyboard.js

@@ -1,4 +1,4 @@
-import { L as LidoKeyboard$1, d as defineCustomElement$1 } from './p-af54a485.js';
+import { L as LidoKeyboard$1, d as defineCustomElement$1 } from './p-74849cdd.js';
 
 const LidoKeyboard = LidoKeyboard$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/lido-math-matrix.js

@@ -1,4 +1,4 @@
-import { L as LidoMathMatrix$1, d as defineCustomElement$1 } from './p-a8ab771b.js';
+import { L as LidoMathMatrix$1, d as defineCustomElement$1 } from './p-08d0deab.js';
 
 const LidoMathMatrix = LidoMathMatrix$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/lido-pos.js

@@ -1,4 +1,4 @@
-import { L as LidoPos$1, d as defineCustomElement$1 } from './p-61d97438.js';
+import { L as LidoPos$1, d as defineCustomElement$1 } from './p-d37ab4dc.js';
 
 const LidoPos = LidoPos$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/lido-random.js

@@ -1,4 +1,4 @@
-import { L as LidoRandom$1, d as defineCustomElement$1 } from './p-51943db6.js';
+import { L as LidoRandom$1, d as defineCustomElement$1 } from './p-3f406017.js';
 
 const LidoRandom = LidoRandom$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/lido-root.js

@@ -1,22 +1,24 @@
-import { p as proxyCustomElement, H, g as getAssetPath, h } from './p-cfa2aec8.js';
-import { d as defineCustomElement$j } from './p-7f11a624.js';
-import { d as defineCustomElement$i } from './p-b43ce4e1.js';
-import { d as defineCustomElement$h } from './p-4cabbf28.js';
-import { d as defineCustomElement$g } from './p-e735dce9.js';
-import { d as defineCustomElement$f } from './p-03e4cafe.js';
-import { d as defineCustomElement$e } from './p-0bf92c7f.js';
-import { d as defineCustomElement$d } from './p-b8af26e6.js';
-import { d as defineCustomElement$c } from './p-b5b6ad27.js';
-import { d as defineCustomElement$b } from './p-af54a485.js';
-import { d as defineCustomElement$a } from './p-a8ab771b.js';
-import { d as defineCustomElement$9 } from './p-61d97438.js';
-import { d as defineCustomElement$8 } from './p-51943db6.js';
-import { d as defineCustomElement$7 } from './p-9c56f378.js';
-import { d as defineCustomElement$6 } from './p-cae021c6.js';
-import { d as defineCustomElement$5 } from './p-4882df37.js';
-import { d as defineCustomElement$4 } from './p-cac6c8bf.js';
-import { d as defineCustomElement$3 } from './p-b55af747.js';
-import { d as defineCustomElement$2 } from './p-4dbae73b.js';
+import { p as proxyCustomElement, H, g as getAssetPath, h } from './p-bed94c37.js';
+import { d as defineCustomElement$l } from './p-cbac3cbc.js';
+import { d as defineCustomElement$k } from './p-44808985.js';
+import { d as defineCustomElement$j } from './p-e36ddcc1.js';
+import { d as defineCustomElement$i } from './p-29bdd953.js';
+import { d as defineCustomElement$h } from './p-52844fa4.js';
+import { d as defineCustomElement$g } from './p-9be56729.js';
+import { d as defineCustomElement$f } from './p-e4e42677.js';
+import { d as defineCustomElement$e } from './p-1fbdb431.js';
+import { d as defineCustomElement$d } from './p-322acda6.js';
+import { d as defineCustomElement$c } from './p-15971ede.js';
+import { d as defineCustomElement$b } from './p-74849cdd.js';
+import { d as defineCustomElement$a } from './p-08d0deab.js';
+import { d as defineCustomElement$9 } from './p-d37ab4dc.js';
+import { d as defineCustomElement$8 } from './p-3f406017.js';
+import { d as defineCustomElement$7 } from './p-7f7e5672.js';
+import { d as defineCustomElement$6 } from './p-904711c8.js';
+import { d as defineCustomElement$5 } from './p-73e31a86.js';
+import { d as defineCustomElement$4 } from './p-afbc196f.js';
+import { d as defineCustomElement$3 } from './p-90465904.js';
+import { d as defineCustomElement$2 } from './p-835b973d.js';
 
 const LidoRoot$1 = /*@__PURE__*/ proxyCustomElement(class LidoRoot extends H {
     constructor() {
@@ -95,7 +97,7 @@ function defineCustomElement$1() {
     if (typeof customElements === "undefined") {
         return;
     }
-    const components = ["lido-root", "lido-avatar", "lido-cell", "lido-col", "lido-container", "lido-flash-card", "lido-float", "lido-home", "lido-image", "lido-keyboard", "lido-math-matrix", "lido-pos", "lido-random", "lido-row", "lido-shape", "lido-slide-fill", "lido-text", "lido-trace", "lido-wrap"];
+    const components = ["lido-root", "lido-avatar", "lido-balance", "lido-calculator", "lido-cell", "lido-col", "lido-container", "lido-flash-card", "lido-float", "lido-home", "lido-image", "lido-keyboard", "lido-math-matrix", "lido-pos", "lido-random", "lido-row", "lido-shape", "lido-slide-fill", "lido-text", "lido-trace", "lido-wrap"];
     components.forEach(tagName => { switch (tagName) {
         case "lido-root":
             if (!customElements.get(tagName)) {
@@ -103,6 +105,16 @@ function defineCustomElement$1() {
             }
             break;
         case "lido-avatar":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$l();
+            }
+            break;
+        case "lido-balance":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$k();
+            }
+            break;
+        case "lido-calculator":
             if (!customElements.get(tagName)) {
                 defineCustomElement$j();
             }

package/dist/components/lido-row.js

@@ -1,4 +1,4 @@
-import { L as LidoRow$1, d as defineCustomElement$1 } from './p-9c56f378.js';
+import { L as LidoRow$1, d as defineCustomElement$1 } from './p-7f7e5672.js';
 
 const LidoRow = LidoRow$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/lido-shape.js

@@ -1,4 +1,4 @@
-import { L as LidoShape$1, d as defineCustomElement$1 } from './p-cae021c6.js';
+import { L as LidoShape$1, d as defineCustomElement$1 } from './p-904711c8.js';
 
 const LidoShape = LidoShape$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/lido-slide-fill.js

@@ -1,4 +1,4 @@
-import { L as LidoSlideFill$1, d as defineCustomElement$1 } from './p-4882df37.js';
+import { L as LidoSlideFill$1, d as defineCustomElement$1 } from './p-73e31a86.js';
 
 const LidoSlideFill = LidoSlideFill$1;
 const defineCustomElement = defineCustomElement$1;