flikkui 0.1.0-beta.11

package/dist/hooks/useSelectPortal.js

@@ -0,0 +1,326 @@
+import { useRef, useState, useCallback, useLayoutEffect, useMemo } from 'react';
+
+// Simple debounce utility
+var debounce = function (func, wait) {
+    var timeout;
+    return function () {
+        clearTimeout(timeout);
+        timeout = setTimeout(func, wait);
+    };
+};
+/**
+ * Fixed dropdown positioning hook
+ * Uses position: fixed with pure viewport coordinates to properly follow scroll
+ * Fixes critical issues: dropdown not following scroll & multiple dropdowns not working
+ */
+var useSimpleDropdown = function (_a) {
+    var triggerRef = _a.triggerRef, isOpen = _a.isOpen, _b = _a.placement, placement = _b === void 0 ? "bottom-start" : _b, _c = _a.offset, offset = _c === void 0 ? 4 : _c, estimatedWidth = _a.estimatedWidth, _d = _a.autoWidth, autoWidth = _d === void 0 ? false : _d;
+    var contentRef = useRef(null);
+    var _e = useState({ top: -9999, left: -9999, width: 0 }), position = _e[0], setPosition = _e[1];
+    var _f = useState({}), cssVariables = _f[0], setCssVariables = _f[1];
+    var _g = useState(placement), actualPlacement = _g[0], setActualPlacement = _g[1];
+    var _h = useState(false), isFlipped = _h[0], setIsFlipped = _h[1];
+    var _j = useState(false), isReady = _j[0], setIsReady = _j[1];
+    var isInitialRenderRef = useRef(true);
+    var rafIdRef = useRef(null);
+    // Enhanced measurement system - use actual DOM measurements when available
+    var measureDropdownHeight = useCallback(function () {
+        if (contentRef.current) {
+            var rect = contentRef.current.getBoundingClientRect();
+            return rect.height || estimateDropdownHeight();
+        }
+        return estimateDropdownHeight();
+    }, []);
+    // Calculate estimated height based on content structure (fallback)
+    var estimateDropdownHeight = function () {
+        var baseHeight = 16; // Container padding/border
+        var itemHeight = 44; // Approximate height per option (padding + text)
+        var maxVisibleItems = 8; // Max items before scrolling kicks in
+        // Default to reasonable number if we can\'t determine actual count
+        var estimatedItems = Math.min(8, maxVisibleItems);
+        return baseHeight + (estimatedItems * itemHeight);
+    };
+    // Measure actual dropdown width from DOM
+    var measureDropdownWidth = useCallback(function () {
+        var _a;
+        // If autoWidth is true, ONLY measure from content.
+        if (autoWidth) {
+            if (contentRef.current) {
+                return contentRef.current.getBoundingClientRect().width;
+            }
+            return 0; // Return 0 initially, the rAF pass will correct it.
+        }
+        // If estimatedWidth is provided, ALWAYS use it (prevents width flickering during animations)
+        // This ensures dropdown width stays constant and matches trigger width
+        if (estimatedWidth) {
+            return estimatedWidth;
+        }
+        // Only measure content width if estimatedWidth was NOT provided
+        if (contentRef.current) {
+            var rect = contentRef.current.getBoundingClientRect();
+            return rect.width;
+        }
+        // Final fallback to trigger width
+        return ((_a = triggerRef.current) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect().width) || 0;
+    }, [contentRef, triggerRef, estimatedWidth, autoWidth]);
+    // Calculate position using viewport coordinates (for position: fixed)
+    var calculatePosition = useCallback(function () {
+        if (typeof window === "undefined")
+            return;
+        if (!triggerRef.current)
+            return;
+        var rect = triggerRef.current.getBoundingClientRect();
+        var viewportWidth = window.innerWidth;
+        var viewportHeight = window.innerHeight;
+        var margin = 16;
+        var dropdownHeight = measureDropdownHeight();
+        var dropdownWidth = measureDropdownWidth();
+        var spaceAbove = rect.top - margin;
+        var spaceBelow = viewportHeight - rect.bottom - margin;
+        var spaceLeft = rect.left - margin;
+        var spaceRight = viewportWidth - rect.right - margin;
+        // Improved edge detection logic using actual measurements
+        var shouldFlip = function (preferredPlacement) {
+            if (preferredPlacement.startsWith("bottom")) {
+                // Only flip if space below is insufficient AND space above is sufficient
+                return spaceBelow < dropdownHeight && spaceAbove >= dropdownHeight;
+            }
+            else if (preferredPlacement.startsWith("top")) {
+                // Only flip if space above is insufficient AND space below is sufficient
+                return spaceAbove < dropdownHeight && spaceBelow >= dropdownHeight;
+            }
+            else if (preferredPlacement.startsWith("right")) {
+                // Only flip if space right is insufficient AND space left is sufficient
+                return spaceRight < dropdownWidth && spaceLeft >= dropdownWidth;
+            }
+            else if (preferredPlacement.startsWith("left")) {
+                // Only flip if space left is insufficient AND space right is sufficient
+                return spaceLeft < dropdownWidth && spaceRight >= dropdownWidth;
+            }
+            return false;
+        };
+        // Determine optimal placement direction
+        var finalPlacement = placement;
+        var needsFlip = shouldFlip(placement);
+        if (needsFlip) {
+            // Preserve alignment when flipping
+            if (placement === "bottom-start")
+                finalPlacement = "top-start";
+            else if (placement === "bottom-end")
+                finalPlacement = "top-end";
+            else if (placement === "bottom")
+                finalPlacement = "top";
+            else if (placement === "top-start")
+                finalPlacement = "bottom-start";
+            else if (placement === "top-end")
+                finalPlacement = "bottom-end";
+            else if (placement === "top")
+                finalPlacement = "bottom";
+            else if (placement === "right-start")
+                finalPlacement = "left-start";
+            else if (placement === "right-end")
+                finalPlacement = "left-end";
+            else if (placement === "right")
+                finalPlacement = "left";
+            else if (placement === "left-start")
+                finalPlacement = "right-start";
+            else if (placement === "left-end")
+                finalPlacement = "right-end";
+            else if (placement === "left")
+                finalPlacement = "right";
+        }
+        setActualPlacement(finalPlacement);
+        setIsFlipped(needsFlip);
+        // Calculate position based on final placement
+        var top = 0;
+        var left = 0;
+        // Handle positioning based on placement direction
+        if (finalPlacement.startsWith("top") || finalPlacement.startsWith("bottom")) {
+            // TOP/BOTTOM PLACEMENTS: Handle horizontal alignment
+            if (finalPlacement.includes("start")) {
+                left = rect.left;
+            }
+            else if (finalPlacement.includes("end")) {
+                left = rect.right - dropdownWidth;
+            }
+            else {
+                // Center alignment
+                left = rect.left + (rect.width / 2) - (dropdownWidth / 2);
+            }
+            // Handle vertical positioning
+            if (finalPlacement.startsWith("top")) {
+                top = rect.top - dropdownHeight - offset;
+            }
+            else {
+                top = rect.bottom + offset;
+            }
+        }
+        else if (finalPlacement.startsWith("left") || finalPlacement.startsWith("right")) {
+            // LEFT/RIGHT PLACEMENTS: Handle vertical alignment
+            if (finalPlacement.includes("start")) {
+                top = rect.top;
+            }
+            else if (finalPlacement.includes("end")) {
+                top = rect.bottom - dropdownHeight;
+            }
+            else {
+                // Center alignment
+                top = rect.top + (rect.height / 2) - (dropdownHeight / 2);
+            }
+            // Handle horizontal positioning
+            if (finalPlacement.startsWith("left")) {
+                left = rect.left - dropdownWidth - offset;
+            }
+            else {
+                left = rect.right + offset;
+            }
+        }
+        // Collision detection - handle both horizontal and vertical overflow
+        // Horizontal bounds checking
+        var rightEdge = left + dropdownWidth;
+        var overflow = rightEdge - (viewportWidth - margin);
+        if (overflow > 0) {
+            // Shift left just enough to fit
+            var shiftedLeft = left - overflow;
+            if (shiftedLeft >= margin) {
+                left = shiftedLeft;
+            }
+            else {
+                // Clamp to viewport margin
+                left = margin;
+            }
+        }
+        // Handle left edge overflow
+        if (left < margin) {
+            left = margin;
+        }
+        // Vertical bounds checking
+        var bottomEdge = top + dropdownHeight;
+        var verticalOverflow = bottomEdge - (viewportHeight - margin);
+        if (verticalOverflow > 0) {
+            // Shift up just enough to fit
+            var shiftedTop = top - verticalOverflow;
+            if (shiftedTop >= margin) {
+                top = shiftedTop;
+            }
+            else {
+                // Clamp to viewport margin
+                top = margin;
+            }
+        }
+        // Handle top edge overflow
+        if (top < margin) {
+            top = margin;
+        }
+        setPosition({ top: top, left: left, width: dropdownWidth });
+        // Calculate available space based on placement direction
+        var availableSpace = 0;
+        if (finalPlacement.startsWith("top")) {
+            availableSpace = spaceAbove - offset;
+        }
+        else if (finalPlacement.startsWith("bottom")) {
+            availableSpace = spaceBelow - offset;
+        }
+        else if (finalPlacement.startsWith("left")) {
+            availableSpace = spaceLeft - offset;
+        }
+        else if (finalPlacement.startsWith("right")) {
+            availableSpace = spaceRight - offset;
+        }
+        var resolvedAvailableSpace = Math.max(0, availableSpace);
+        var cssVars = {
+            "--select-content-available-width": "".concat(rect.width, "px"),
+        };
+        if (resolvedAvailableSpace > 0) {
+            cssVars["--select-content-available-height"] = "".concat(resolvedAvailableSpace, "px");
+        }
+        else {
+            delete cssVars["--select-content-available-height"];
+        }
+        if (isInitialRenderRef.current) {
+            cssVars.visibility = "hidden";
+            cssVars.pointerEvents = "none";
+        }
+        setCssVariables(cssVars);
+        // Mark initial render as complete after first calculation
+    }, [measureDropdownHeight, measureDropdownWidth, offset, placement, triggerRef]);
+    // Reset initial render flag when dropdown opens
+    useLayoutEffect(function () {
+        if (!isOpen) {
+            if (rafIdRef.current !== null) {
+                cancelAnimationFrame(rafIdRef.current);
+                rafIdRef.current = null;
+            }
+            setIsReady(false);
+            return;
+        }
+        isInitialRenderRef.current = true;
+        setIsReady(false);
+        // Perform an initial measurement (hidden) immediately
+        calculatePosition();
+        // Recalculate on next animation frame to allow layout to settle
+        if (rafIdRef.current !== null) {
+            cancelAnimationFrame(rafIdRef.current);
+        }
+        rafIdRef.current = window.requestAnimationFrame(function () {
+            rafIdRef.current = null;
+            isInitialRenderRef.current = false;
+            calculatePosition();
+            setIsReady(true);
+        });
+        return function () {
+            if (rafIdRef.current !== null) {
+                cancelAnimationFrame(rafIdRef.current);
+                rafIdRef.current = null;
+            }
+        };
+    }, [isOpen, calculatePosition]);
+    // Initial position calculation
+    useLayoutEffect(function () {
+        if (!isOpen)
+            return;
+        calculatePosition();
+    }, [isOpen, calculatePosition]);
+    // Debounced position updates for better performance
+    var debouncedCalculatePosition = useMemo(function () { return debounce(calculatePosition, 16); }, // ~60fps
+    [calculatePosition]);
+    // Update position on scroll and resize - debounced for performance
+    useLayoutEffect(function () {
+        if (!isOpen)
+            return;
+        window.addEventListener("scroll", debouncedCalculatePosition, { passive: true, capture: true });
+        window.addEventListener("resize", debouncedCalculatePosition, { passive: true });
+        return function () {
+            window.removeEventListener("scroll", debouncedCalculatePosition, true);
+            window.removeEventListener("resize", debouncedCalculatePosition);
+        };
+    }, [isOpen, debouncedCalculatePosition]);
+    // Recalculate when dropdown content resizes (e.g. search filtering)
+    useLayoutEffect(function () {
+        if (!isOpen)
+            return;
+        if (!contentRef.current)
+            return;
+        if (typeof ResizeObserver === "undefined")
+            return;
+        var observer = new ResizeObserver(function () {
+            calculatePosition();
+        });
+        observer.observe(contentRef.current);
+        return function () {
+            observer.disconnect();
+        };
+    }, [isOpen, calculatePosition]);
+    return {
+        position: position,
+        cssVariables: cssVariables,
+        contentRef: contentRef,
+        actualPlacement: actualPlacement,
+        isFlipped: isFlipped,
+        isReady: isReady,
+    };
+};
+// Export with original name for backward compatibility
+var useSelectPortal = useSimpleDropdown;
+
+export { useSelectPortal, useSimpleDropdown };

package/dist/hooks/useSlidingNumber.d.ts

@@ -0,0 +1,60 @@
+export interface UseSlidingNumberOptions {
+    /**
+     * The current number value to display
+     */
+    value: number;
+    /**
+     * Whether the animation is enabled
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Format function to customize number display
+     * @default (n) => n.toString()
+     */
+    formatNumber?: (value: number) => string;
+}
+export interface UseSlidingNumberReturn {
+    /**
+     * The current formatted value
+     */
+    displayValue: string;
+    /**
+     * The direction of the change (1 for up, -1 for down, 0 for no change)
+     */
+    direction: number;
+    /**
+     * Array of digit positions and their values for animation
+     */
+    digits: Array<{
+        value: string;
+        isChanging: boolean;
+    }>;
+}
+/**
+ * Custom hook for sliding number animations
+ * Detects direction of change and provides digit-level animation data
+ *
+ * @example
+ * ```tsx
+ * const { displayValue, direction, digits } = useSlidingNumber({
+ *   value: count,
+ *   enabled: true,
+ *   formatNumber: (n) => n.toFixed(2)
+ * });
+ *
+ * return (
+ *   <div>
+ *     {digits.map((digit, i) => (
+ *       <motion.span
+ *         key={i}
+ *         animate={{ y: digit.isChanging ? [10, 0] : 0 }}
+ *       >
+ *         {digit.value}
+ *       </motion.span>
+ *     ))}
+ *   </div>
+ * );
+ * ```
+ */
+export declare const useSlidingNumber: ({ value, enabled, formatNumber, }: UseSlidingNumberOptions) => UseSlidingNumberReturn;

package/dist/hooks/useTypewriter.d.ts

@@ -0,0 +1,51 @@
+export interface UseTypewriterOptions {
+    /**
+     * The full text to animate
+     */
+    text: string;
+    /**
+     * Speed in milliseconds per word
+     * @default 100
+     */
+    speed?: number;
+    /**
+     * Whether the animation is enabled
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Callback when animation completes
+     */
+    onComplete?: () => void;
+}
+export interface UseTypewriterReturn {
+    /**
+     * The currently visible text
+     */
+    displayText: string;
+    /**
+     * Whether the animation is complete
+     */
+    isComplete: boolean;
+    /**
+     * Reset the animation
+     */
+    reset: () => void;
+}
+/**
+ * Custom hook for word-by-word typing animation
+ * Shows first sentence immediately to establish bubble width,
+ * then animates remaining text word-by-word
+ *
+ * @example
+ * ```tsx
+ * const { displayText, isComplete } = useTypewriter({
+ *   text: "Hello world. This is a typing animation",
+ *   speed: 100,
+ *   enabled: true
+ * });
+ *
+ * return <div>{displayText}</div>;
+ * ```
+ */
+export declare const useTypewriter: ({ text, speed, enabled, onComplete, }: UseTypewriterOptions) => UseTypewriterReturn;

package/dist/icons/Icon.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+export interface IconProps extends React.SVGProps<SVGSVGElement> {
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
+    color?: string;
+    strokeWidth?: number;
+    className?: string;
+}
+export interface IconComponent extends React.FC<IconProps> {
+    displayName?: string;
+}
+/**
+ * Icon factory function to create consistent icons
+ * @param Svg - The SVG component to render
+ * @param displayName - The display name for the component
+ * @returns A standardized Icon component
+ */
+export declare function createIcon(Svg: React.FC<IconProps>, displayName: string): IconComponent;

package/dist/icons/Icon.js

@@ -0,0 +1,28 @@
+import { __rest, __assign } from '../node_modules/tslib/tslib.es6.js';
+import React__default from 'react';
+
+/**
+ * Icon factory function to create consistent icons
+ * @param Svg - The SVG component to render
+ * @param displayName - The display name for the component
+ * @returns A standardized Icon component
+ */
+function createIcon(Svg, displayName) {
+    var Icon = function (_a) {
+        var _b = _a.size, size = _b === void 0 ? 'md' : _b, _c = _a.color, color = _c === void 0 ? 'currentColor' : _c, _d = _a.strokeWidth, strokeWidth = _d === void 0 ? 2 : _d, _e = _a.className, className = _e === void 0 ? '' : _e, props = __rest(_a, ["size", "color", "strokeWidth", "className"]);
+        // Map size names to pixel values
+        var sizeMap = {
+            xs: '16px',
+            sm: '20px',
+            md: '24px',
+            lg: '32px',
+            xl: '40px',
+        };
+        var pixelSize = typeof size === 'string' ? sizeMap[size] || '24px' : "".concat(size, "px");
+        return (React__default.createElement(Svg, __assign({ width: pixelSize, height: pixelSize, fill: "none", stroke: color, strokeWidth: strokeWidth, className: "".concat(className), "aria-hidden": "true", style: __assign({ width: pixelSize, height: pixelSize }, props.style) }, props)));
+    };
+    Icon.displayName = displayName;
+    return Icon;
+}
+
+export { createIcon };

package/dist/icons/Index.d.ts

@@ -0,0 +1,16 @@
+export * from './Icon';
+export * from './core/PlusIcon';
+export * from './core/MinusIcon';
+export * from './core/SearchIcon';
+export * from './core/LockIcon';
+export * from './core/DollarIcon';
+export * from './core/TickIcon';
+import React from 'react';
+interface IconProps {
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    className?: string;
+}
+export declare const CalendarIcon: React.FC<IconProps>;
+export declare const ClockIcon: React.FC<IconProps>;
+export declare const ChartBarIcon: React.FC<IconProps>;
+export declare const UserIcon: React.FC<IconProps>;

package/dist/icons/core/ChevronUpDown.d.ts

@@ -0,0 +1 @@
+export declare const ChevronUpDownIcon: import("../Icon").IconComponent;

package/dist/icons/core/ChevronUpDown.js

@@ -0,0 +1,10 @@
+import { __assign } from '../../node_modules/tslib/tslib.es6.js';
+import React__default from 'react';
+import { createIcon } from '../Icon.js';
+
+var ChevronUpDownSvg = function (props) { return (React__default.createElement("svg", __assign({ xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", strokeLinecap: "round", strokeLinejoin: "round" }, props),
+    React__default.createElement("path", { d: "m7 15 5 5 5-5" }),
+    React__default.createElement("path", { d: "m7 9 5-5 5 5" }))); };
+var ChevronUpDownIcon = createIcon(ChevronUpDownSvg, 'ChevronUpDownIcon');
+
+export { ChevronUpDownIcon };

package/dist/icons/core/DollarIcon.d.ts

@@ -0,0 +1 @@
+export declare const DollarIcon: import("../Icon").IconComponent;

package/dist/icons/core/DollarIcon.js

@@ -0,0 +1,8 @@
+import { __assign } from '../../node_modules/tslib/tslib.es6.js';
+import React__default from 'react';
+import { createIcon } from '../Icon.js';
+
+var DollarSvg = function (props) { return (React__default.createElement("svg", __assign({ xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", strokeLinecap: "round", strokeLinejoin: "round" }, props),
+    React__default.createElement("line", { x1: "12", x2: "12", y1: "2", y2: "22" }),
+    React__default.createElement("path", { d: "M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6" }))); };
+createIcon(DollarSvg, 'DollarIcon');

package/dist/icons/core/LockIcon.d.ts

@@ -0,0 +1 @@
+export declare const LockIcon: import("../Icon").IconComponent;

package/dist/icons/core/LockIcon.js

@@ -0,0 +1,8 @@
+import { __assign } from '../../node_modules/tslib/tslib.es6.js';
+import React__default from 'react';
+import { createIcon } from '../Icon.js';
+
+var LockSvg = function (props) { return (React__default.createElement("svg", __assign({ xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", strokeLinecap: "round", strokeLinejoin: "round" }, props),
+    React__default.createElement("rect", { width: "18", height: "11", x: "3", y: "11", rx: "2", ry: "2" }),
+    React__default.createElement("path", { d: "M7 11V7a5 5 0 0 1 10 0v4" }))); };
+createIcon(LockSvg, 'LockIcon');

package/dist/icons/core/MinusIcon.d.ts

@@ -0,0 +1 @@
+export declare const MinusIcon: import("../Icon").IconComponent;

package/dist/icons/core/MinusIcon.js

@@ -0,0 +1,9 @@
+import { __assign } from '../../node_modules/tslib/tslib.es6.js';
+import React__default from 'react';
+import { createIcon } from '../Icon.js';
+
+var MinusSvg = function (props) { return (React__default.createElement("svg", __assign({ xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", strokeLinecap: "round", strokeLinejoin: "round" }, props),
+    React__default.createElement("path", { d: "M5 12h14" }))); };
+var MinusIcon = createIcon(MinusSvg, 'MinusIcon');
+
+export { MinusIcon };

package/dist/icons/core/PlusIcon.d.ts

@@ -0,0 +1 @@
+export declare const PlusIcon: import("../Icon").IconComponent;

package/dist/icons/core/PlusIcon.js

@@ -0,0 +1,10 @@
+import { __assign } from '../../node_modules/tslib/tslib.es6.js';
+import React__default from 'react';
+import { createIcon } from '../Icon.js';
+
+var PlusSvg = function (props) { return (React__default.createElement("svg", __assign({ xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", strokeLinecap: "round", strokeLinejoin: "round" }, props),
+    React__default.createElement("path", { d: "M5 12h14" }),
+    React__default.createElement("path", { d: "M12 5v14" }))); };
+var PlusIcon = createIcon(PlusSvg, 'PlusIcon');
+
+export { PlusIcon };

package/dist/icons/core/SearchIcon.d.ts

@@ -0,0 +1 @@
+export declare const SearchIcon: import("../Icon").IconComponent;

package/dist/icons/core/SearchIcon.js

@@ -0,0 +1,10 @@
+import { __assign } from '../../node_modules/tslib/tslib.es6.js';
+import React__default from 'react';
+import { createIcon } from '../Icon.js';
+
+var SearchSvg = function (props) { return (React__default.createElement("svg", __assign({ xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", strokeLinecap: "round", strokeLinejoin: "round" }, props),
+    React__default.createElement("circle", { cx: "11", cy: "11", r: "8" }),
+    React__default.createElement("path", { d: "m21 21-4.3-4.3" }))); };
+var SearchIcon = createIcon(SearchSvg, 'SearchIcon');
+
+export { SearchIcon };

package/dist/icons/core/TickIcon.d.ts

@@ -0,0 +1 @@
+export declare const TickIcon: import("../Icon").IconComponent;

package/dist/icons/core/TickIcon.js

@@ -0,0 +1,9 @@
+import { __assign } from '../../node_modules/tslib/tslib.es6.js';
+import React__default from 'react';
+import { createIcon } from '../Icon.js';
+
+var TickSvg = function (props) { return (React__default.createElement("svg", __assign({ xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", strokeLinecap: "round", strokeLinejoin: "round" }, props),
+    React__default.createElement("path", { d: "M19 6L9 18L4.5 13.5" }))); };
+var TickIcon = createIcon(TickSvg, 'TickIcon');
+
+export { TickIcon };

package/dist/icons/core/User.d.ts

@@ -0,0 +1 @@
+export declare const UserIcon: import("../Icon").IconComponent;