lapikit 0.5.9 → 0.6.1

package/dist/@legacy/internal/core/actions/popover.svelte.js

@@ -1,134 +0,0 @@
-import { innerWidth, innerHeight } from 'svelte/reactivity/window';
-export function getPositions() {
-    // state
-    const axis = $state({
-        x: 0,
-        y: 0,
-        location: null
-    });
-    return {
-        get values() {
-            return axis;
-        },
-        update(activator, element, location, centered, avoidCollisions) {
-            if (!activator || !element)
-                return;
-            const elementRect = element.getBoundingClientRect();
-            if (activator instanceof HTMLElement) {
-                const activatorRect = activator.getBoundingClientRect();
-                const spacing = 6;
-                const _activator = activatorRect.y + activatorRect.height;
-                const _element = elementRect.height + spacing;
-                if (location === 'top' || location === 'bottom') {
-                    if (avoidCollisions) {
-                        if (location === 'top') {
-                            if (activatorRect.y - _element < 0) {
-                                axis.y = activatorRect.bottom + spacing;
-                                axis.location = 'bottom';
-                            }
-                            else {
-                                axis.y = activatorRect.top - _element;
-                                axis.location = 'top';
-                            }
-                        }
-                        else {
-                            if (_activator + _element > innerHeight.current) {
-                                axis.y = activatorRect.top - _element;
-                                axis.location = 'top';
-                            }
-                            else {
-                                axis.y = activatorRect.bottom + spacing;
-                                axis.location = 'bottom';
-                            }
-                        }
-                    }
-                    else {
-                        if (location === 'top') {
-                            axis.y = activatorRect.top - _element;
-                            axis.location = 'top';
-                        }
-                        else {
-                            axis.y = activatorRect.bottom + spacing;
-                            axis.location = 'bottom';
-                        }
-                    }
-                    if (centered &&
-                        activatorRect.left - (elementRect.width - activatorRect.width) / 2 > 0 &&
-                        activatorRect.left + elementRect.width < innerWidth.current) {
-                        axis.x = activatorRect.left - (elementRect.width - activatorRect.width) / 2;
-                    }
-                    else if (activatorRect.left + elementRect.width > innerWidth.current) {
-                        axis.x = activatorRect.left - (elementRect.width - activatorRect.width);
-                    }
-                    else {
-                        axis.x = activatorRect.left;
-                    }
-                }
-                else if (location === 'left' || location === 'right') {
-                    if (avoidCollisions) {
-                        if (location === 'left' && !(activatorRect.left - elementRect.width < 0)) {
-                            axis.x = activatorRect.left - (elementRect.width + spacing);
-                            axis.location = 'left';
-                        }
-                        else {
-                            if (activatorRect.left + activatorRect.width + elementRect.width + spacing >
-                                innerWidth.current) {
-                                axis.x = activatorRect.left - (elementRect.width + spacing);
-                                axis.location = 'left';
-                            }
-                            else {
-                                axis.x = activatorRect.left + activatorRect.width + spacing;
-                                axis.location = 'right';
-                            }
-                        }
-                    }
-                    else {
-                        if (location === 'left') {
-                            axis.x = activatorRect.left - (elementRect.width + spacing);
-                            axis.location = 'left';
-                        }
-                        else {
-                            axis.x = activatorRect.left + activatorRect.width + spacing;
-                            axis.location = 'right';
-                        }
-                    }
-                    if (centered &&
-                        activatorRect.top - (elementRect.height - activatorRect.height) / 2 > 0 &&
-                        activatorRect.top + elementRect.height < innerHeight.current) {
-                        axis.y = activatorRect.top - (elementRect.height - activatorRect.height) / 2;
-                    }
-                    else if (activatorRect.y + elementRect.height > innerHeight.current) {
-                        axis.y = activatorRect.y - elementRect.height + activatorRect.height;
-                    }
-                    else {
-                        axis.y = activatorRect.y;
-                    }
-                }
-                else {
-                    if (centered &&
-                        activatorRect.left - (elementRect.width - activatorRect.width) / 2 > 0 &&
-                        activatorRect.left + elementRect.width < innerWidth.current) {
-                        axis.x = activatorRect.left - (elementRect.width - activatorRect.width) / 2;
-                    }
-                    else if (activatorRect.left + elementRect.width > innerWidth.current) {
-                        axis.x = activatorRect.left - (elementRect.width - activatorRect.width);
-                    }
-                    else {
-                        axis.x = activatorRect.left;
-                    }
-                    if (centered &&
-                        activatorRect.top - (elementRect.height - activatorRect.height) / 2 > 0 &&
-                        activatorRect.top + elementRect.height < innerHeight.current) {
-                        axis.y = activatorRect.top - (elementRect.height - activatorRect.height) / 2;
-                    }
-                    else if (activatorRect.bottom + elementRect.height > innerHeight.current) {
-                        axis.y = activatorRect.top - elementRect.height;
-                    }
-                    else {
-                        axis.y = activatorRect.bottom;
-                    }
-                }
-            }
-        }
-    };
-}

package/dist/@legacy/internal/core/actions/tooltip.svelte.d.ts

@@ -1,7 +0,0 @@
-import type { PositionElement } from '../../../components/tooltip/types.js';
-type Location = 'top' | 'bottom' | 'left' | 'right';
-export declare function getPositionsTooltip(): {
-    readonly values: PositionElement;
-    update(activator: HTMLElement, element: HTMLElement, location?: Location, centered?: boolean, avoidCollisions?: boolean): void;
-};
-export {};

package/dist/@legacy/internal/core/actions/tooltip.svelte.js

@@ -1,131 +0,0 @@
-import { innerWidth, innerHeight } from 'svelte/reactivity/window';
-export function getPositionsTooltip() {
-    // state
-    const axis = $state({
-        x: 0,
-        y: 0,
-        location: null
-    });
-    return {
-        get values() {
-            return axis;
-        },
-        update(activator, element, location, centered, avoidCollisions) {
-            if (!activator || !element)
-                return;
-            const elementRect = element.getBoundingClientRect();
-            const activatorRect = activator.getBoundingClientRect();
-            const spacing = 6;
-            if (location === 'top' || location === 'bottom') {
-                if (avoidCollisions) {
-                    if (location === 'top') {
-                        if (activatorRect.y - (elementRect.height + spacing) < 0) {
-                            axis.y = activatorRect.bottom + spacing;
-                            axis.location = 'bottom';
-                        }
-                        else {
-                            axis.y = activatorRect.top - (elementRect.height + spacing);
-                            axis.location = 'top';
-                        }
-                    }
-                    else {
-                        if (activatorRect.y + activatorRect.height + (elementRect.height + spacing) >
-                            innerHeight.current) {
-                            axis.y = activatorRect.top - (elementRect.height + spacing);
-                            axis.location = 'top';
-                        }
-                        else {
-                            axis.y = activatorRect.bottom + spacing;
-                            axis.location = 'bottom';
-                        }
-                    }
-                }
-                else {
-                    if (location === 'top') {
-                        axis.y = activatorRect.top - (elementRect.height + spacing);
-                        axis.location = 'top';
-                    }
-                    else {
-                        axis.y = activatorRect.bottom + spacing;
-                        axis.location = 'bottom';
-                    }
-                }
-                if (centered &&
-                    activatorRect.left - (elementRect.width - activatorRect.width) / 2 > 0 &&
-                    activatorRect.left + elementRect.width < innerWidth.current) {
-                    axis.x = activatorRect.left - (elementRect.width - activatorRect.width) / 2;
-                }
-                else if (activatorRect.left + elementRect.width > innerWidth.current) {
-                    axis.x = activatorRect.left - (elementRect.width - activatorRect.width);
-                }
-                else {
-                    axis.x = activatorRect.left;
-                }
-            }
-            else if (location === 'left' || location === 'right') {
-                if (avoidCollisions) {
-                    if (location === 'left' && !(activatorRect.left - elementRect.width < 0)) {
-                        axis.x = activatorRect.left - (elementRect.width + spacing);
-                        axis.location = 'left';
-                    }
-                    else {
-                        if (activatorRect.left + activatorRect.width + elementRect.width + spacing >
-                            innerWidth.current) {
-                            axis.x = activatorRect.left - (elementRect.width + spacing);
-                            axis.location = 'left';
-                        }
-                        else {
-                            axis.x = activatorRect.left + activatorRect.width + spacing;
-                            axis.location = 'right';
-                        }
-                    }
-                }
-                else {
-                    if (location === 'left') {
-                        axis.x = activatorRect.left - (elementRect.width + spacing);
-                        axis.location = 'left';
-                    }
-                    else {
-                        axis.x = activatorRect.left + activatorRect.width + spacing;
-                        axis.location = 'right';
-                    }
-                }
-                if (centered &&
-                    activatorRect.top - (elementRect.height - activatorRect.height) / 2 > 0 &&
-                    activatorRect.top + elementRect.height < innerHeight.current) {
-                    axis.y = activatorRect.top - (elementRect.height - activatorRect.height) / 2;
-                }
-                else if (activatorRect.y + elementRect.height > innerHeight.current) {
-                    axis.y = activatorRect.y - elementRect.height + activatorRect.height;
-                }
-                else {
-                    axis.y = activatorRect.y;
-                }
-            }
-            else {
-                if (centered &&
-                    activatorRect.left - (elementRect.width - activatorRect.width) / 2 > 0 &&
-                    activatorRect.left + elementRect.width < innerWidth.current) {
-                    axis.x = activatorRect.left - (elementRect.width - activatorRect.width) / 2;
-                }
-                else if (activatorRect.left + elementRect.width > innerWidth.current) {
-                    axis.x = activatorRect.left - (elementRect.width - activatorRect.width);
-                }
-                else {
-                    axis.x = activatorRect.left;
-                }
-                if (centered &&
-                    activatorRect.top - (elementRect.height - activatorRect.height) / 2 > 0 &&
-                    activatorRect.top + elementRect.height < innerHeight.current) {
-                    axis.y = activatorRect.top - (elementRect.height - activatorRect.height) / 2;
-                }
-                else if (activatorRect.bottom + elementRect.height > innerHeight.current) {
-                    axis.y = activatorRect.top - elementRect.height;
-                }
-                else {
-                    axis.y = activatorRect.bottom;
-                }
-            }
-        }
-    };
-}

package/dist/@legacy/internal/core/animations/ripple.d.ts

@@ -1,12 +0,0 @@
-interface RippleOptions {
-    component?: string;
-    center?: boolean;
-    color?: string;
-    duration?: number;
-    disabled?: boolean;
-}
-export declare function ripple(el: HTMLElement, options?: RippleOptions): {
-    destroy(): void;
-    update(newOptions: RippleOptions): void;
-};
-export {};

package/dist/@legacy/internal/core/animations/ripple.js

@@ -1,96 +0,0 @@
-const triggerEvents = ['pointerdown', 'touchstart', 'keydown'];
-const cancelEvents = ['mouseleave', 'dragleave', 'touchmove', 'touchcancel', 'pointerup', 'keyup'];
-export function ripple(el, options = {}) {
-    const rippleContainer = document.createElement('div');
-    addClasses();
-    setOptions(options);
-    function isAriaDisabled() {
-        return el.getAttribute('aria-disabled') === 'true';
-    }
-    function addClasses(center) {
-        const shouldBeCentered = center || options.center;
-        if (!rippleContainer.classList.contains('kit-ripple--effect')) {
-            rippleContainer.classList.add('kit-ripple--effect');
-        }
-        if (!shouldBeCentered && rippleContainer.classList.contains('kit-ripple--center')) {
-            rippleContainer.classList.remove('kit-ripple--center');
-        }
-        if (shouldBeCentered) {
-            rippleContainer.classList.add('kit-ripple--center');
-        }
-    }
-    function setOptions(options) {
-        if (options.disabled || isAriaDisabled()) {
-            rippleContainer.remove();
-        }
-        else {
-            el.appendChild(rippleContainer);
-        }
-        if (options.duration && options.duration < 0) {
-            options.duration = undefined;
-        }
-        if (options.component) {
-            rippleContainer.style.setProperty('--system-ripple-radius', `var(--${options.component}-shape)`);
-        }
-        if (options.color) {
-            rippleContainer.style.setProperty('--system-ripple-color', options.color);
-        }
-        if (options.duration) {
-            rippleContainer.style.setProperty('--system-animation-ripple-duration', `${options.duration}ms`);
-        }
-    }
-    function createRipple(e, center) {
-        if (options.disabled || isAriaDisabled()) {
-            return;
-        }
-        if (e instanceof KeyboardEvent) {
-            if (!['Enter', 'Space'].includes(e.code) || e.repeat) {
-                return;
-            }
-            e.preventDefault();
-            const click = new PointerEvent('pointerdown');
-            createRipple(click, true);
-            return;
-        }
-        addClasses(center);
-        const rect = el.getBoundingClientRect();
-        const clientX = window.TouchEvent && e instanceof TouchEvent
-            ? e.touches[0].clientX
-            : e.clientX;
-        const clientY = window.TouchEvent && e instanceof TouchEvent
-            ? e.touches[0].clientY
-            : e.clientY;
-        const x = clientX - rect.left > el.offsetWidth / 2 ? 0 : el.offsetWidth;
-        const y = clientY - rect.top > el.offsetHeight / 2 ? 0 : el.offsetHeight;
-        const radius = Math.hypot(x - (clientX - rect.left), y - (clientY - rect.top));
-        const ripple = document.createElement('div');
-        ripple.classList.add('kit-ripple');
-        ripple.style.left = `${clientX - rect.left - radius}px`;
-        ripple.style.top = `${clientY - rect.top - radius}px`;
-        ripple.style.width = ripple.style.height = `${radius * 2}px`;
-        rippleContainer.appendChild(ripple);
-        function removeRipple() {
-            if (ripple === null) {
-                return;
-            }
-            ripple.style.opacity = '0';
-            setTimeout(() => {
-                ripple.remove();
-            }, options.duration || 1000);
-            cancelEvents.forEach((event) => el.removeEventListener(event, removeRipple));
-        }
-        cancelEvents.forEach((event) => el.addEventListener(event, removeRipple, { passive: true }));
-    }
-    triggerEvents.forEach((event) => el.addEventListener(event, createRipple, { passive: event === 'touchstart' }));
-    return {
-        destroy() {
-            triggerEvents.forEach((event) => {
-                el.removeEventListener(event, createRipple);
-            });
-        },
-        update(newOptions) {
-            options = newOptions;
-            setOptions(newOptions);
-        }
-    };
-}

package/dist/@legacy/internal/core/bin/ansi.d.ts

@@ -1,40 +0,0 @@
-export declare const ansi: {
-    color: {
-        red: (text: string) => string;
-        green: (text: string) => string;
-        yellow: (text: string) => string;
-        blue: (text: string) => string;
-        purple: (text: string) => string;
-        cyan: (text: string) => string;
-    };
-    variant: {
-        bold: (text: string) => string;
-        underline: (text: string) => string;
-        inverse: (text: string) => string;
-    };
-    bold: {
-        red: (text: string) => string;
-        green: (text: string) => string;
-        yellow: (text: string) => string;
-        blue: (text: string) => string;
-        purple: (text: string) => string;
-        cyan: (text: string) => string;
-    };
-    inverse: {
-        red: (text: string) => string;
-        green: (text: string) => string;
-        yellow: (text: string) => string;
-        blue: (text: string) => string;
-        purple: (text: string) => string;
-        cyan: (text: string) => string;
-    };
-    underline: {
-        red: (text: string) => string;
-        green: (text: string) => string;
-        yellow: (text: string) => string;
-        blue: (text: string) => string;
-        purple: (text: string) => string;
-        cyan: (text: string) => string;
-    };
-};
-export type Ansi = typeof ansi;

package/dist/@legacy/internal/core/bin/ansi.js

@@ -1,44 +0,0 @@
-const color = {
-    red: (text) => `\x1b[31m${text}\x1b[0m`,
-    green: (text) => `\x1b[32m${text}\x1b[0m`,
-    yellow: (text) => `\x1b[33m${text}\x1b[0m`,
-    blue: (text) => `\x1b[34m${text}\x1b[0m`,
-    purple: (text) => `\x1b[35m${text}\x1b[0m`,
-    cyan: (text) => `\x1b[36m${text}\x1b[0m`
-};
-const variant = {
-    bold: (text) => `\x1b[1m${text}\x1b[0m`,
-    underline: (text) => `\x1b[4m${text}\x1b[0m`,
-    inverse: (text) => `\x1b[7m${text}\x1b[0m`
-};
-const bold = {
-    red: (text) => `\x1b[1m\x1b[31m${text}\x1b[0m`,
-    green: (text) => `\x1b[1m\x1b[32m${text}\x1b[0m`,
-    yellow: (text) => `\x1b[1m\x1b[33m${text}\x1b[0m`,
-    blue: (text) => `\x1b[1m\x1b[34m${text}\x1b[0m`,
-    purple: (text) => `\x1b[1m\x1b[35m${text}\x1b[0m`,
-    cyan: (text) => `\x1b[1m\x1b[36m${text}\x1b[0m`
-};
-const inverse = {
-    red: (text) => `\x1b[7m\x1b[31m${text}\x1b[0m`,
-    green: (text) => `\x1b[7m\x1b[32m${text}\x1b[0m`,
-    yellow: (text) => `\x1b[7m\x1b[33m${text}\x1b[0m`,
-    blue: (text) => `\x1b[7m\x1b[34m${text}\x1b[0m`,
-    purple: (text) => `\x1b[7m\x1b[35m${text}\x1b[0m`,
-    cyan: (text) => `\x1b[7m\x1b[36m${text}\x1b[0m`
-};
-const underline = {
-    red: (text) => `\x1b[4m\x1b[31m${text}\x1b[0m`,
-    green: (text) => `\x1b[4m\x1b[32m${text}\x1b[0m`,
-    yellow: (text) => `\x1b[4m\x1b[33m${text}\x1b[0m`,
-    blue: (text) => `\x1b[4m\x1b[34m${text}\x1b[0m`,
-    purple: (text) => `\x1b[4m\x1b[35m${text}\x1b[0m`,
-    cyan: (text) => `\x1b[4m\x1b[36m${text}\x1b[0m`
-};
-export const ansi = {
-    color,
-    variant,
-    bold,
-    inverse,
-    underline
-};

package/dist/@legacy/internal/core/bin/terminal.d.ts

@@ -1 +0,0 @@
-export declare const terminal: (type: "info" | "error" | "warn" | "success" | undefined, msg: string) => void;

package/dist/@legacy/internal/core/bin/terminal.js

@@ -1,12 +0,0 @@
-import { ansi } from './ansi.js';
-export const terminal = (type = 'info', msg) => {
-    const name = ansi.color.cyan('lapikit');
-    if (type === 'error')
-        console.error(name, ansi.bold.red('[error]'), msg);
-    else if (type === 'warn')
-        console.warn(name, ansi.bold.yellow('[warn]'), msg);
-    else if (type === 'success')
-        console.warn(name, ansi.bold.green('[success]'), msg);
-    else
-        console.log(name, ansi.bold.blue('[info]'), msg);
-};

package/dist/@legacy/internal/core/css.d.ts

@@ -1 +0,0 @@
-export declare const processImportStyles: () => Promise<string>;

package/dist/@legacy/internal/core/css.js

@@ -1,16 +0,0 @@
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-import fs from 'fs';
-import path from 'path';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-export const processImportStyles = async () => {
-    const _reset = fs.readFileSync(path.resolve(__dirname, './../../styles/reset.css'), 'utf-8');
-    const _animation = fs.readFileSync(path.resolve(__dirname, './../../styles/animation.css'), 'utf-8');
-    const _keyframes = fs.readFileSync(path.resolve(__dirname, './../../styles/keyframes.css'), 'utf-8');
-    let styles = ``;
-    styles += `${_reset}\n`;
-    styles += `${_animation}\n`;
-    styles += `${_keyframes}\n`;
-    return styles;
-};

package/dist/@legacy/internal/core/formatter/component.d.ts

@@ -1,5 +0,0 @@
-export declare function componentFormatter({ breakpoints }: {
-    breakpoints: {
-        [key: string]: number | string;
-    };
-}): Promise<void>;

package/dist/@legacy/internal/core/formatter/component.js

@@ -1,60 +0,0 @@
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-import fs from 'fs';
-import path from 'path';
-import { parserCSSBreakpoints } from '../../helpers/parser.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-export async function componentFormatter({ breakpoints }) {
-    // load svelte component files (includes on components folders)
-    function loadSvelteFiles(directory) {
-        fs.readdirSync(directory).forEach((File) => {
-            const absolutePath = path.join(directory, File);
-            if (fs.statSync(absolutePath).isDirectory())
-                return loadSvelteFiles(absolutePath);
-            else if (absolutePath.endsWith('.css') && !absolutePath.includes('/_')) {
-                const fileCSS = fs.readFileSync(absolutePath, 'utf8');
-                const content = parserCSSBreakpoints(fileCSS);
-                let css = `${content.cleaned}\n`;
-                for (const property in breakpoints) {
-                    if (property !== 'base') {
-                        const name = `.${/^\d/.test(property) ? `\\3${property}` : property}\\:`;
-                        const value = typeof breakpoints[property] === 'number'
-                            ? `${breakpoints[property]}px`
-                            : breakpoints[property];
-                        if (content.base !== '' || content.minmax !== '' || content.min !== '') {
-                            css += `\n@media screen and (min-width: ${value}) {\n`;
-                            if (content.base !== '')
-                                css += content.base.replaceAll('[breakpoint]', name);
-                            if (content.minmax !== '')
-                                css += content.minmax.replaceAll('[breakpoint]', name);
-                            if (content.min !== '')
-                                css += content.min.replaceAll('[breakpoint]', name);
-                            css += `\n}\n`;
-                        }
-                        if (content.max !== '' || content.minmax !== '') {
-                            css += `\n@media screen and (max-width: ${value}) {\n`;
-                            if (content.max !== '')
-                                css += content.max.replaceAll('[breakpoint]', `max\\:${name}`);
-                            if (content.minmax !== '')
-                                css += content.all.replaceAll('[breakpoint]', `max\\:${name}`);
-                            css += `\n}\n`;
-                        }
-                    }
-                    else {
-                        css += `${content.base.replaceAll('[breakpoint]', '.')}\n`;
-                    }
-                }
-                const baseName = path.basename(absolutePath, '.css');
-                const svelteFilePath = path.join(path.dirname(absolutePath), `${baseName}.svelte`);
-                if (fs.existsSync(svelteFilePath)) {
-                    let svelteContent = fs.readFileSync(svelteFilePath, 'utf8');
-                    svelteContent = svelteContent.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
-                    svelteContent += `<style>\n${css}</style>`;
-                    fs.writeFileSync(svelteFilePath, svelteContent, 'utf8');
-                }
-            }
-        });
-    }
-    loadSvelteFiles(path.resolve(__dirname, '../../../components'));
-}

package/dist/@legacy/internal/core/formatter/device.d.ts

@@ -1,5 +0,0 @@
-export declare function devicesFormatter({ devices }: {
-    devices: {
-        [key: string]: number | string;
-    };
-}): Promise<string>;

package/dist/@legacy/internal/core/formatter/device.js

@@ -1,66 +0,0 @@
-import { parserValues } from '../../helpers/parser.js';
-export async function devicesFormatter({ devices }) {
-    let css = ``;
-    const sortedDevices = Object.entries(devices).sort(([, a], [, b]) => {
-        const valueA = typeof a === 'string' ? parseInt(a) : a;
-        const valueB = typeof b === 'string' ? parseInt(b) : b;
-        return valueB - valueA;
-    });
-    sortedDevices.forEach(([deviceName, breakpoint], index) => {
-        const value = parserValues(breakpoint);
-        if (index === 0) {
-            // the largest device
-            css += `@media (max-width: ${value}) {\n`;
-            css += ` .kit-device--d-${deviceName} {\n`;
-            css += `   display: none !important;\n`;
-            css += ` }\n`;
-            css += `}\n\n`;
-            css += `@media (min-width: ${value}) {\n`;
-            css += ` .kit-device--h-${deviceName} {\n`;
-            css += `   display: none !important;\n`;
-            css += ` }\n`;
-            css += `}\n\n`;
-        }
-        else if (index === sortedDevices.length - 1) {
-            const prevDevice = sortedDevices[index - 1];
-            const prevValue = parserValues(prevDevice[1]);
-            // the smallest device
-            css += `@media (min-width: ${prevValue}) {\n`;
-            css += ` .kit-device--d-${deviceName} {\n`;
-            css += `   display: none !important;\n`;
-            css += ` }\n`;
-            css += `}\n\n`;
-            css += `@media (max-width: ${prevValue}) {\n`;
-            css += ` .kit-device--h-${deviceName} {\n`;
-            css += `   display: none !important;\n`;
-            css += ` }\n`;
-            css += `}\n\n`;
-            css += `@media (min-width: ${value}) {\n`;
-            css += ` .kit-device--od-${deviceName} {\n`;
-            css += `   display: none !important;\n`;
-            css += ` }\n`;
-            css += `}\n\n`;
-            css += `@media (max-width: ${value}) {\n`;
-            css += ` .kit-device--oh-${deviceName} {\n`;
-            css += `   display: none !important;\n`;
-            css += ` }\n`;
-            css += `}\n\n`;
-        }
-        else {
-            //intermediate devices
-            const nextDevice = sortedDevices[index - 1];
-            const nextValue = parserValues(nextDevice[1]);
-            css += `@media (max-width: ${value}) {\n`;
-            css += ` .kit-device--d-${deviceName} {\n`;
-            css += `   display: none !important;\n`;
-            css += ` }\n`;
-            css += `}\n\n`;
-            css += `@media (min-width: ${nextValue}) {\n`;
-            css += ` .kit-device--h-${deviceName} {\n`;
-            css += `   display: none !important;\n`;
-            css += ` }\n`;
-            css += `}\n\n`;
-        }
-    });
-    return css.trim();
-}

package/dist/@legacy/internal/core/formatter/index.d.ts

@@ -1,7 +0,0 @@
-import type { DevConfiguration } from '../../types/index.js';
-export declare function liliRabbit(config: DevConfiguration): Promise<{
-    themes: string;
-    typography: string;
-    styles: string;
-    devices: string;
-}>;