atomicuilibrary 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,111 @@
+[![Built With Stencil](https://img.shields.io/badge/-Built%20With%20Stencil-16161d.svg?logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6IEFkb2JlIElsbHVzdHJhdG9yIDE5LjIuMSwgU1ZHIEV4cG9ydCBQbHVnLUluIC4gU1ZHIFZlcnNpb246IDYuMDAgQnVpbGQgMCkgIC0tPgo8c3ZnIHZlcnNpb249IjEuMSIgaWQ9IkxheWVyXzEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IgoJIHZpZXdCb3g9IjAgMCA1MTIgNTEyIiBzdHlsZT0iZW5hYmxlLWJhY2tncm91bmQ6bmV3IDAgMCA1MTIgNTEyOyIgeG1sOnNwYWNlPSJwcmVzZXJ2ZSI%2BCjxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI%2BCgkuc3Qwe2ZpbGw6I0ZGRkZGRjt9Cjwvc3R5bGU%2BCjxwYXRoIGNsYXNzPSJzdDAiIGQ9Ik00MjQuNywzNzMuOWMwLDM3LjYtNTUuMSw2OC42LTkyLjcsNjguNkgxODAuNGMtMzcuOSwwLTkyLjctMzAuNy05Mi43LTY4LjZ2LTMuNmgzMzYuOVYzNzMuOXoiLz4KPHBhdGggY2xhc3M9InN0MCIgZD0iTTQyNC43LDI5Mi4xSDE4MC40Yy0zNy42LDAtOTIuNy0zMS05Mi43LTY4LjZ2LTMuNkgzMzJjMzcuNiwwLDkyLjcsMzEsOTIuNyw2OC42VjI5Mi4xeiIvPgo8cGF0aCBjbGFzcz0ic3QwIiBkPSJNNDI0LjcsMTQxLjdIODcuN3YtMy42YzAtMzcuNiw1NC44LTY4LjYsOTIuNy02OC42SDMzMmMzNy45LDAsOTIuNywzMC43LDkyLjcsNjguNlYxNDEuN3oiLz4KPC9zdmc%2BCg%3D%3D&colorA=16161d&style=flat-square)](https://stenciljs.com)
+
+# Stencil Component Starter
+
+> This is a starter project for building a standalone Web Components using Stencil.
+
+Stencil is a compiler for building fast web apps using Web Components.
+
+Stencil combines the best concepts of the most popular frontend frameworks into a compile-time rather than runtime tool. Stencil takes TypeScript, JSX, a tiny virtual DOM layer, efficient one-way data binding, an asynchronous rendering pipeline (similar to React Fiber), and lazy-loading out of the box, and generates 100% standards-based Web Components that run in any browser supporting the Custom Elements specification.
+
+Stencil components are just Web Components, so they work in any major framework or with no framework at all.
+
+## Getting Started
+
+To start building a new web component using Stencil, clone this repo to a new directory:
+
+```bash
+git clone https://github.com/stenciljs/component-starter.git my-component
+cd my-component
+git remote rm origin
+```
+
+and run:
+
+```bash
+npm install
+npm start
+```
+
+To build the component for production, run:
+
+```bash
+npm run build
+```
+
+To run the unit tests for the components, run:
+
+```bash
+npm test
+```
+
+Need help? Check out our docs [here](https://stenciljs.com/docs/my-first-component).
+
+## Naming Components
+
+When creating new component tags, we recommend _not_ using `stencil` in the component name (ex: `<stencil-datepicker>`). This is because the generated component has little to nothing to do with Stencil; it's just a web component!
+
+Instead, use a prefix that fits your company or any name for a group of related components. For example, all of the [Ionic-generated](https://ionicframework.com/) web components use the prefix `ion`.
+
+## Using this component
+
+There are two strategies we recommend for using web components built with Stencil.
+
+The first step for all two of these strategies is to [publish to NPM](https://docs.npmjs.com/getting-started/publishing-npm-packages).
+
+You can read more about these different approaches in the [Stencil docs](https://stenciljs.com/docs/publishing).
+
+### Lazy Loading
+
+If your Stencil project is built with the [`dist`](https://stenciljs.com/docs/distribution) output target, you can import a small bootstrap script that registers all components and allows you to load individual component scripts lazily.
+
+For example, given your Stencil project namespace is called `my-design-system`, to use `my-component` on any website, inject this into your HTML:
+
+```html
+<script type="module" src="https://unpkg.com/my-design-system"></script>
+<!--
+To avoid unpkg.com redirects to the actual file, you can also directly import:
+https://unpkg.com/foobar-design-system@0.0.1/dist/foobar-design-system/foobar-design-system.esm.js
+-->
+<my-component first="Stencil" middle="'Don't call me a framework'" last="JS"></my-component>
+```
+
+This will only load the necessary scripts needed to render `<my-component />`. Once more components of this package are used, they will automatically be loaded lazily.
+
+You can also import the script as part of your `node_modules` in your applications entry file:
+
+```tsx
+import 'foobar-design-system/dist/foobar-design-system/foobar-design-system.esm.js';
+```
+
+Check out this [Live Demo](https://stackblitz.com/edit/vitejs-vite-y6v26a?file=src%2Fmain.tsx).
+
+### Standalone
+
+If you are using a Stencil component library with `dist-custom-elements`, we recommend importing Stencil components individually in those files where they are needed.
+
+To export Stencil components as standalone components make sure you have the [`dist-custom-elements`](https://stenciljs.com/docs/custom-elements) output target defined in your `stencil.config.ts`.
+
+For example, given you'd like to use `<my-component />` as part of a React component, you can import the component directly via:
+
+```tsx
+import 'foobar-design-system/my-component';
+
+function App() {
+  return (
+    <>
+      <div>
+        <my-component
+          first="Stencil"
+          middle="'Don't call me a framework'"
+          last="JS"
+        ></my-component>
+      </div>
+    </>
+  );
+}
+
+export default App;
+```
+
+Check out this [Live Demo](https://stackblitz.com/edit/vitejs-vite-b6zuds?file=src%2FApp.tsx).

package/dist/cjs/category-section.cjs.entry.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var index = require('./index-ClkOYpT8.js');
+
+const categorySectionCss = () => `.sr-only{position:absolute !important;width:1px !important;height:1px !important;padding:0 !important;margin:-1px !important;overflow:hidden !important;clip:rect(0, 0, 0, 0) !important;white-space:nowrap !important;border-width:0 !important}.a11y-sr-only{position:absolute !important;width:1px !important;height:1px !important;padding:0 !important;margin:-1px !important;overflow:hidden !important;clip:rect(0, 0, 0, 0) !important;white-space:nowrap !important;border-width:0 !important}:host{display:block;margin-bottom:32px}.category{background:linear-gradient(135deg, rgba(30, 41, 59, 0.6), rgba(15, 23, 42, 0.8));border:1px solid rgba(255, 255, 255, 0.08);border-radius:24px;overflow:hidden;transition:all 0.3s cubic-bezier(0.4, 0, 0.2, 1)}.category:hover{border-color:rgba(99, 102, 241, 0.3)}.category-header{display:flex;align-items:center;gap:16px;padding:24px 28px;background:transparent;border:none;width:100%;cursor:pointer;text-align:left;color:inherit;font-family:inherit;transition:background 0.2s ease}.category-header:hover{background:rgba(255, 255, 255, 0.03)}.category-icon{font-size:1.8rem;width:52px;height:52px;display:flex;align-items:center;justify-content:center;background:linear-gradient(135deg, rgba(99, 102, 241, 0.2), rgba(168, 85, 247, 0.15));border-radius:14px;flex-shrink:0}.category-title{margin:0;font-size:1.4rem;font-weight:700;color:#f1f5f9;flex:1;letter-spacing:-0.02em}.category-count{font-size:0.85rem;font-weight:600;padding:6px 14px;background:rgba(99, 102, 241, 0.15);color:#a5b4fc;border-radius:20px}.chevron{color:#64748b;transition:transform 0.3s cubic-bezier(0.4, 0, 0.2, 1)}.chevron.rotated{transform:rotate(-90deg)}.category-content{padding:0 24px 24px;max-height:2000px;overflow:hidden;transition:all 0.4s cubic-bezier(0.4, 0, 0.2, 1);opacity:1}.category.collapsed .category-content{max-height:0;padding-top:0;padding-bottom:0;opacity:0}.cards-grid{display:grid;grid-template-columns:repeat(auto-fill, minmax(300px, 1fr));gap:16px}@media (max-width: 768px){.cards-grid{grid-template-columns:1fr}.category-header{padding:16px 20px}.category-content{padding:0 16px 16px}.category-title{font-size:1.2rem}}:host-context(.light) .category{background:linear-gradient(135deg, rgba(255, 255, 255, 0.95), rgba(248, 250, 252, 0.9));border-color:rgba(0, 0, 0, 0.08)}:host-context(.light) .category-title{color:#1e293b}:host-context(.light) .chevron{color:#94a3b8}`;
+
+const CategorySection = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+    }
+    /** Category name */
+    categoryName;
+    /** Category icon */
+    categoryIcon = '📦';
+    /** Components in this category */
+    components = [];
+    /** Whether the section is expanded */
+    expanded = true;
+    /** Mode: 'demo' or 'doc' */
+    mode = 'demo';
+    toggleExpanded = () => {
+        this.expanded = !this.expanded;
+    };
+    render() {
+        return (index.h(index.Host, { key: 'e3a09ce08fdb7d41a84a0513c9bd9307d7d0fb2f' }, index.h("div", { key: '68321cc0d827decbd472217460b97dc7955c818c', class: { 'category': true, 'collapsed': !this.expanded } }, index.h("ui-button", { key: '4b232b38aa4f84d8526206801aa1c562a051da64', class: "category-header", onButtonClick: this.toggleExpanded, variant: "plain", fullWidth: true, align: "start" }, index.h("span", { key: 'c4d4449576357c8a85e131fd6e51d550b61bcb0e', class: "category-icon" }, this.categoryIcon), index.h("h2", { key: 'dd646cf30106d5665fd7cf16a33a1646dd576be5', class: "category-title" }, this.categoryName), index.h("span", { key: 'e174d5fa4e6eeaf3e6998f583c5a38329e66e176', class: "category-count" }, this.components.length), index.h("svg", { key: '5e926d6ace89797270d978e2c51aeeb362e57e33', class: { 'chevron': true, 'rotated': !this.expanded }, width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2" }, index.h("polyline", { key: 'f02857e200d2f5562c19a1fecc3a4584fd52271e', points: "6,9 12,15 18,9" }))), index.h("div", { key: '3e70d09a10eda7220b63253dca6638220326ea0a', class: "category-content" }, index.h("div", { key: 'a51ebf47c0fafe095ca8616ee3f661ee4124c805', class: "cards-grid" }, this.components.map(comp => (index.h("library-card", { key: comp.id, "component-id": comp.id, "card-title": comp.name, description: comp.description, icon: comp.icon, badge: comp.badge, docs: comp.docs, mode: this.mode }))))))));
+    }
+};
+CategorySection.style = categorySectionCss();
+
+exports.category_section = CategorySection;

package/dist/cjs/component-size-DsYFUZcz.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const COMPONENT_SIZE_ALIAS_MAP = {
+    xxxs: 'xxxs',
+    xxs: 'xxs',
+    xs: 'xs',
+    sm: 'sm',
+    small: 'sm',
+    md: 'md',
+    medium: 'md',
+    lg: 'lg',
+    large: 'lg',
+    xl: 'xl',
+    xlarge: 'xl',
+    'extra-large': 'xl',
+    extralarge: 'xl',
+    xxl: 'xxl',
+    xxxl: 'xxxl',
+    default: 'md',
+};
+function normalizeComponentSize(size, fallback = 'md') {
+    const rawSize = String(size ?? fallback).trim();
+    if (!rawSize) {
+        return fallback;
+    }
+    return COMPONENT_SIZE_ALIAS_MAP[rawSize.toLowerCase()] ?? rawSize;
+}
+
+exports.normalizeComponentSize = normalizeComponentSize;

package/dist/cjs/dom-oP1E4Rd3.js

@@ -0,0 +1,267 @@
+'use strict';
+
+/**
+ * Finds the nearest ancestor that creates a new containing block for position:fixed elements.
+ * This function is fully Shadow DOM and Flat Tree aware, accounting for slots and shadow boundaries.
+ */
+function getTransformedAncestor(element) {
+    let el = element;
+    while (el && el !== document.documentElement) {
+        // If it's not a standard element (e.g. ShadowRoot), jump to its host
+        if (el.nodeType !== 1) {
+            el = el.host || el.parentNode;
+            continue;
+        }
+        const style = window.getComputedStyle(el);
+        if (!style) {
+            // Move up the tree (Flat Tree aware)
+            el = el.assignedSlot || el.parentElement || el.getRootNode().host;
+            continue;
+        }
+        const s = style;
+        const transform = s.transform || s.webkitTransform || s.mozTransform || s.msTransform || s.oTransform;
+        const translate = s.translate || '';
+        const rotate = s.rotate || '';
+        const scale = s.scale || '';
+        const filter = s.filter || s.webkitFilter || s.mozFilter || s.msFilter || s.oFilter;
+        const backdropFilter = s.backdropFilter || s.webkitBackdropFilter || s.mozBackdropFilter || s.msBackdropFilter || s.oBackdropFilter;
+        const perspective = s.perspective || s.webkitPerspective || s.mozPerspective || s.msPerspective || s.oPerspective;
+        const mask = s.mask || s.webkitMask || '';
+        const clipPath = s.clipPath || s.webkitClipPath || '';
+        const willChange = s.willChange || '';
+        const hasTransform = (transform && transform !== 'none') || (translate && translate !== 'none') || (rotate && rotate !== 'none') || (scale && scale !== 'none');
+        const hasFilter = filter && filter !== 'none';
+        const hasBackdropFilter = backdropFilter && backdropFilter !== 'none';
+        const hasPerspective = perspective && perspective !== 'none';
+        const hasMask = mask && mask !== 'none';
+        const hasClipPath = clipPath && clipPath !== 'none';
+        const hasWillChange = willChange &&
+            (willChange.includes('transform') ||
+                willChange.includes('perspective') ||
+                willChange.includes('filter') ||
+                willChange.includes('backdrop-filter') ||
+                willChange.includes('translate') ||
+                willChange.includes('rotate') ||
+                willChange.includes('scale') ||
+                willChange.includes('mask') ||
+                willChange.includes('clip-path') ||
+                willChange.includes('contain'));
+        // contain: layout, paint, strict, or content also creates a containing block
+        const contain = style.contain;
+        const hasContain = contain && (contain.includes('layout') || contain.includes('paint') || contain.includes('strict') || contain.includes('content'));
+        if (hasTransform || hasFilter || hasBackdropFilter || hasPerspective || hasMask || hasClipPath || hasWillChange || hasContain) {
+            return el;
+        }
+        // Move up (Flat Tree aware)
+        // Priority: 1. Assigned Slot (for projected content) 2. Parent Element 3. Shadow Host
+        el = el.assignedSlot || el.parentElement || el.getRootNode().host;
+    }
+    return null;
+}
+/**
+ * Returns the viewport-relative offset of the nearest transformed ancestor.
+ */
+function getTransformedAncestorOffset(element) {
+    const ancestor = getTransformedAncestor(element);
+    if (ancestor) {
+        const rect = ancestor.getBoundingClientRect();
+        return { x: rect.left, y: rect.top, el: ancestor };
+    }
+    return { x: 0, y: 0, el: null };
+}
+/**
+ * Calculates a robust, environment-proof position for floating elements (dropdowns, menus).
+ * It automatically handles:
+ * 1. Nested CSS transforms (containing blocks)
+ * 2. Viewport boundary detection (clamping)
+ * 3. Vertical space detection (flipping top/bottom)
+ * 4. Aligning to trigger element
+ */
+/**
+ * Modern auto-update utility that tracks element positions and re-triggers placement logic.
+ */
+function autoUpdate(reference, floating, update, options = {}) {
+    const { animationFrame = false } = options;
+    let frameId = null;
+    const handleUpdate = () => {
+        update();
+        if (animationFrame) {
+            frameId = requestAnimationFrame(handleUpdate);
+        }
+    };
+    if (animationFrame) {
+        frameId = requestAnimationFrame(handleUpdate);
+    }
+    else {
+        update(); // Initial update
+    }
+    window.addEventListener('scroll', update, { capture: true, passive: true });
+    window.addEventListener('resize', update, { passive: true });
+    const resizeObserver = new ResizeObserver(() => update());
+    resizeObserver.observe(reference);
+    resizeObserver.observe(floating);
+    const cleanup = () => {
+        if (frameId !== null)
+            cancelAnimationFrame(frameId);
+        window.removeEventListener('scroll', update, { capture: true });
+        window.removeEventListener('resize', update);
+        resizeObserver.disconnect();
+    };
+    return cleanup;
+}
+/**
+ * Calculates a robust, environment-proof position for floating elements (popovers, dropdowns, menus).
+ * Supports all 4 sides, alignment, and boundary detection.
+ */
+function calculateUniversalPlacement(trigger, options) {
+    const { menuWidth, menuHeight, gap = 4, placement = 'auto', align = 'center', padding = 8, useTransformedAncestorOffset = true } = options;
+    if (!trigger) {
+        return { left: 0, top: 0, width: 0, availableWidth: 0, availableHeight: 0, placement: 'bottom', isClamped: false };
+    }
+    const triggerRect = trigger.getBoundingClientRect();
+    const screenW = window.innerWidth;
+    const screenH = window.innerHeight;
+    const ancestorOffset = useTransformedAncestorOffset
+        ? getTransformedAncestorOffset(trigger)
+        : { x: 0, y: 0, el: null };
+    // 1. Determine Vertical/Horizontal Placement
+    const requestedPlacement = placement === 'auto' ? 'bottom' : placement;
+    let finalPlacement = requestedPlacement;
+    if (placement === 'auto') {
+        const spaceBelow = screenH - triggerRect.bottom - gap - padding;
+        const spaceAbove = triggerRect.top - gap - padding;
+        const spaceRight = screenW - triggerRect.right - gap - padding;
+        const spaceLeft = triggerRect.left - gap - padding;
+        // Preference: If requestedPlacement is blocked, try opposite, then try other axis if both blocked
+        if (requestedPlacement === 'bottom' && spaceBelow < menuHeight && spaceAbove > spaceBelow) {
+            finalPlacement = 'top';
+        }
+        else if (requestedPlacement === 'top' && spaceAbove < menuHeight && spaceBelow > spaceAbove) {
+            finalPlacement = 'bottom';
+        }
+        else if (requestedPlacement === 'right' && spaceRight < menuWidth && spaceLeft > spaceRight) {
+            finalPlacement = 'left';
+        }
+        else if (requestedPlacement === 'left' && spaceLeft < menuWidth && spaceRight > spaceLeft) {
+            finalPlacement = 'right';
+        }
+        // Secondary: If still not enough space on the main axis, pick the one with most space
+        if (finalPlacement === 'top' || finalPlacement === 'bottom') {
+            if (Math.max(spaceAbove, spaceBelow) < menuHeight) {
+                if (spaceRight >= menuWidth || spaceLeft >= menuWidth) {
+                    finalPlacement = spaceRight > spaceLeft ? 'right' : 'left';
+                }
+            }
+        }
+        else {
+            if (Math.max(spaceLeft, spaceRight) < menuWidth) {
+                if (spaceAbove >= menuHeight || spaceBelow >= menuHeight) {
+                    finalPlacement = spaceAbove > spaceBelow ? 'top' : 'bottom';
+                }
+            }
+        }
+    }
+    // 2. Calculate initial coordinates and available dimensions
+    let left = 0;
+    let top = 0;
+    let availableWidth = screenW - (padding * 2);
+    let availableHeight = screenH - (padding * 2);
+    switch (finalPlacement) {
+        case 'top':
+            top = triggerRect.top - menuHeight - gap;
+            availableHeight = triggerRect.top - gap - padding;
+            break;
+        case 'bottom':
+            top = triggerRect.bottom + gap;
+            availableHeight = screenH - triggerRect.bottom - gap - padding;
+            break;
+        case 'left':
+            left = triggerRect.left - menuWidth - gap;
+            availableWidth = triggerRect.left - gap - padding;
+            break;
+        case 'right':
+            left = triggerRect.right + gap;
+            availableWidth = screenW - triggerRect.right - gap - padding;
+            break;
+    }
+    // Handle alignment for the cross-axis
+    if (finalPlacement === 'top' || finalPlacement === 'bottom') {
+        // Horizontal alignment
+        if (align === 'start')
+            left = triggerRect.left;
+        else if (align === 'end')
+            left = triggerRect.right - menuWidth;
+        else
+            left = triggerRect.left + (triggerRect.width / 2) - (menuWidth / 2);
+        availableWidth = screenW - (padding * 2);
+    }
+    else {
+        // Vertical alignment
+        if (align === 'start')
+            top = triggerRect.top;
+        else if (align === 'end')
+            top = triggerRect.bottom - menuHeight;
+        else
+            top = triggerRect.top + (triggerRect.height / 2) - (menuHeight / 2);
+        availableHeight = screenH - (padding * 2);
+    }
+    // Apply ancestor offset
+    left -= ancestorOffset.x;
+    top -= ancestorOffset.y;
+    // 3. Clamping to viewport (account for transform ancestors)
+    const containerWidth = ancestorOffset.el ? ancestorOffset.el.getBoundingClientRect().width : screenW;
+    const containerHeight = ancestorOffset.el ? ancestorOffset.el.getBoundingClientRect().height : screenH;
+    const originalLeft = left;
+    const originalTop = top;
+    // Cross-axis clamping
+    if (finalPlacement === 'top' || finalPlacement === 'bottom') {
+        left = Math.max(padding, Math.min(left, containerWidth - menuWidth - padding));
+    }
+    else {
+        top = Math.max(padding, Math.min(top, containerHeight - menuHeight - padding));
+    }
+    const isClamped = left !== originalLeft || top !== originalTop;
+    // 4. Calculate arrow position (local to the floating element)
+    let arrowX = 0;
+    let arrowY = 0;
+    const arrowPadding = 12; // Minimum distance from corners
+    if (finalPlacement === 'top' || finalPlacement === 'bottom') {
+        const triggerCenter = triggerRect.left + (triggerRect.width / 2);
+        const menuAbsoluteLeft = left + ancestorOffset.x;
+        arrowX = triggerCenter - menuAbsoluteLeft;
+        arrowX = Math.max(arrowPadding, Math.min(arrowX, menuWidth - arrowPadding));
+    }
+    else {
+        const triggerCenter = triggerRect.top + (triggerRect.height / 2);
+        const menuAbsoluteTop = top + ancestorOffset.y;
+        arrowY = triggerCenter - menuAbsoluteTop;
+        arrowY = Math.max(arrowPadding, Math.min(arrowY, menuHeight - arrowPadding));
+    }
+    return {
+        left,
+        top,
+        width: menuWidth,
+        availableWidth,
+        availableHeight,
+        placement: finalPlacement,
+        isClamped,
+        arrowX,
+        arrowY
+    };
+}
+/**
+ * Corrects viewport-relative coordinates (e.g., from MouseEvent.clientX/Y)
+ * to work correctly when the target element is inside a transformed container.
+ */
+function correctViewportCoordinates(x, y, element) {
+    const offset = getTransformedAncestorOffset(element);
+    return {
+        x: x - offset.x,
+        y: y - offset.y,
+    };
+}
+
+exports.autoUpdate = autoUpdate;
+exports.calculateUniversalPlacement = calculateUniversalPlacement;
+exports.correctViewportCoordinates = correctViewportCoordinates;
+exports.getTransformedAncestorOffset = getTransformedAncestorOffset;

package/dist/cjs/event-bus-B6M2f8CQ.js

@@ -0,0 +1,23 @@
+'use strict';
+
+class EventBus {
+    listeners = new Map();
+    on(event, cb) {
+        const arr = this.listeners.get(event) || [];
+        arr.push(cb);
+        this.listeners.set(event, arr);
+        return () => this.off(event, cb);
+    }
+    off(event, cb) {
+        const arr = this.listeners.get(event) || [];
+        this.listeners.set(event, arr.filter(l => l !== cb));
+    }
+    emit(event, ...args) {
+        const arr = this.listeners.get(event) || [];
+        for (const l of arr.slice())
+            l(...args);
+    }
+}
+const GlobalEventBus = new EventBus();
+
+exports.GlobalEventBus = GlobalEventBus;