najm-kit 2.11.23 → 2.12.0

package/dist/chunk-GYPQLOQ5.mjs

@@ -0,0 +1,2202 @@
+import { NLoadingState } from './chunk-FZX3DONZ.mjs';
+import { NajmScroll } from './chunk-QJ22WAQY.mjs';
+import { inputBorderClasses, Button, surfaceBorderClasses, NIcon } from './chunk-WHGRN7PP.mjs';
+import { useNajmComponentStyle, NajmThemeContainerCtx } from './chunk-TZRTOQCC.mjs';
+import { cn } from './chunk-5UY7U2ED.mjs';
+import { resolveRadiusValue } from './chunk-TFHWLE7N.mjs';
+import * as React12 from 'react';
+import React12__default, { createContext, useContext, useState, useCallback, useMemo } from 'react';
+import { MapPin, CircleAlert, MapPinCheck, X, Search, Plus, Minus, Crosshair, LoaderCircle, Trash2, Check, XIcon, Menu } from 'lucide-react';
+import { cva } from 'class-variance-authority';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import * as SheetPrimitive from '@radix-ui/react-dialog';
+import { create } from 'zustand';
+import { FormProvider, Controller, useFormContext } from 'react-hook-form';
+import { Slot } from '@radix-ui/react-slot';
+import * as LabelPrimitive from '@radix-ui/react-label';
+
+// src/theme/focus.ts
+var focusRingClasses = "outline-none focus-visible:ring-[3px] focus-visible:ring-ring/50";
+var focusRingWithinClasses = "focus-visible:ring-[3px] focus-visible:ring-ring/50 has-[:focus-visible]:ring-[3px] has-[:focus-visible]:ring-ring/50";
+var NO_SHADE = /* @__PURE__ */ new Set(["black", "white"]);
+var PRESETS = {
+  muted: "border-muted-foreground",
+  primary: "border-primary",
+  accent: "border-accent",
+  success: "border-green-600",
+  warning: "border-amber-600",
+  destructive: "border-red-600"
+};
+var inputVariants = cva(
+  "relative w-full flex items-center h-10 bg-card text-foreground overflow-hidden transition-colors",
+  {
+    variants: {
+      variant: {
+        default: "p-2 rounded-md",
+        rounded: "p-2 rounded-full",
+        ghost: "p-0! !bg-transparent !bg-none"
+      },
+      status: {
+        default: "",
+        error: ""
+      },
+      hasIcon: { true: "pl-8", false: "pl-3" },
+      disabled: { true: "cursor-not-allowed", false: "" }
+    },
+    defaultVariants: { variant: "default", status: "default", hasIcon: false, disabled: false }
+  }
+);
+var ERROR_BORDER = "border !border-red-600";
+var ERROR_FOCUS_RING = "focus-visible:ring-destructive/20 has-[:focus-visible]:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:has-[:focus-visible]:ring-destructive/40";
+var FOCUS_INTERACTIVE_BASE = "border focus-within:border-primary";
+var HOVER_INTERACTIVE_BASE = "hover:border-primary";
+var STATIC_BASE = "border";
+var BaseInput = React12__default.forwardRef(
+  ({ children, variant = "default", status = "default", bordered, borderColor, className, style, disabled = false, onHover, onClick, hasIcon, ...rest }, ref) => {
+    const recipe = useNajmComponentStyle("input");
+    const isGhost = variant === "ghost";
+    const isError = status === "error";
+    const hasExplicitColor = !!borderColor;
+    const isBordered = bordered !== false;
+    const recipeRadius = variant === "default" ? resolveRadiusValue(recipe?.radius) : void 0;
+    let colorClass = "";
+    let borderClass = "";
+    if (!isGhost) {
+      if (isError) {
+        borderClass = ERROR_BORDER;
+      } else if (hasExplicitColor) {
+        borderClass = `${STATIC_BASE} ${FOCUS_INTERACTIVE_BASE} ${HOVER_INTERACTIVE_BASE}`;
+        colorClass = PRESETS[borderColor] ?? (NO_SHADE.has(borderColor) ? `border-${borderColor}` : `border-${borderColor}-600`);
+      } else {
+        const restingBorderClass = inputBorderClasses(isBordered);
+        borderClass = isBordered ? `${STATIC_BASE} ${restingBorderClass} [&:not(:focus-within):not([data-state=open]):hover]:border-input focus-within:border-ring data-[state=open]:border-ring` : restingBorderClass;
+      }
+    }
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        "data-bordered": !isGhost && !isBordered ? "false" : !isGhost ? "true" : void 0,
+        style: recipeRadius ? { borderRadius: recipeRadius, ...style } : style,
+        className: cn(
+          inputVariants({ variant, status, hasIcon, disabled }),
+          // The wrapper is what the user reads as "the field": the inner
+          // control is stripped of its own ring precisely so this element can
+          // carry the border. Until this was added, the border merely changed
+          // colour on focus — a 1px hue shift and nothing else — and the number
+          // fields and the multi-select trigger came out of the acceptance walk
+          // as tab stops with no visible indicator at all.
+          !isGhost && focusRingWithinClasses,
+          !isGhost && isError && ERROR_FOCUS_RING,
+          !isGhost && borderClass,
+          !isGhost && colorClass,
+          className
+        ),
+        onMouseEnter: disabled ? void 0 : onHover,
+        onClick: disabled ? void 0 : onClick,
+        ...rest,
+        children
+      }
+    );
+  }
+);
+BaseInput.displayName = "BaseInput";
+var variantClasses = {
+  primary: "bg-primary text-primary-foreground hover:bg-primary/90",
+  secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+  ghost: "bg-transparent text-muted-foreground hover:bg-accent hover:text-accent-foreground",
+  destructive: "bg-transparent text-destructive hover:bg-destructive/10"
+};
+var sizeClasses = {
+  sm: "h-6 w-6",
+  md: "h-8 w-8",
+  lg: "h-10 w-10"
+};
+var IconButton = React12.forwardRef(
+  ({
+    className,
+    variant = "ghost",
+    size = "md",
+    active = false,
+    type = "button",
+    children,
+    style,
+    ...props
+  }, ref) => {
+    const recipe = useNajmComponentStyle("button");
+    const recipeRadius = resolveRadiusValue(recipe?.radius);
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        ref,
+        type,
+        "aria-pressed": active || void 0,
+        style: recipeRadius ? { borderRadius: recipeRadius, ...style } : style,
+        className: cn(
+          "inline-flex shrink-0 cursor-pointer items-center justify-center rounded-md transition-colors",
+          "outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background",
+          "disabled:cursor-not-allowed disabled:opacity-50",
+          variantClasses[variant],
+          sizeClasses[size],
+          active && "bg-accent text-accent-foreground",
+          className
+        ),
+        ...props,
+        children
+      }
+    );
+  }
+);
+IconButton.displayName = "IconButton";
+var Input = React12.forwardRef(function Input2({ className, type, ...props }, ref) {
+  return /* @__PURE__ */ jsx(
+    "input",
+    {
+      ref,
+      type,
+      "data-slot": "input",
+      className: cn(
+        "file:text-foreground placeholder:text-muted-foreground selection:bg-primary selection:text-primary-foreground border-input flex h-9 w-full min-w-0 rounded-md border bg-card px-3 py-1 text-base text-foreground shadow-xs transition-[color,box-shadow] outline-none file:inline-flex file:h-7 file:border-0 file:bg-transparent file:text-sm file:font-medium disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+        "focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]",
+        "aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
+        className
+      ),
+      ...props
+    }
+  );
+});
+
+// src/location/contracts.ts
+var DEFAULT_LOCATION_VALUE = {
+  address: "",
+  latitude: null,
+  longitude: null
+};
+function isCompleteCoordinatePair(value) {
+  const { latitude, longitude } = value;
+  return typeof latitude === "number" && Number.isFinite(latitude) && latitude >= -90 && latitude <= 90 && typeof longitude === "number" && Number.isFinite(longitude) && longitude >= -180 && longitude <= 180;
+}
+function normalizeLocationValue(value) {
+  const address = typeof value?.address === "string" ? value.address : "";
+  if (!isCompleteCoordinatePair({ latitude: value?.latitude ?? null, longitude: value?.longitude ?? null })) {
+    return { address, latitude: null, longitude: null };
+  }
+  return { address, latitude: value.latitude, longitude: value.longitude };
+}
+function locationCoordinates(value) {
+  return isCompleteCoordinatePair(value) ? { latitude: value.latitude, longitude: value.longitude } : null;
+}
+function moveCoordinates(value, latitudeDelta, longitudeDelta) {
+  return {
+    latitude: Math.max(-90, Math.min(90, value.latitude + latitudeDelta)),
+    longitude: Math.max(-180, Math.min(180, value.longitude + longitudeDelta))
+  };
+}
+function Sheet({ ...props }) {
+  return /* @__PURE__ */ jsx(SheetPrimitive.Root, { "data-slot": "sheet", ...props });
+}
+function SheetTrigger({ ...props }) {
+  return /* @__PURE__ */ jsx(SheetPrimitive.Trigger, { "data-slot": "sheet-trigger", ...props });
+}
+function SheetClose({ ...props }) {
+  return /* @__PURE__ */ jsx(SheetPrimitive.Close, { "data-slot": "sheet-close", ...props });
+}
+function SheetPortal({ ...props }) {
+  const container = React12.useContext(NajmThemeContainerCtx);
+  return /* @__PURE__ */ jsx(SheetPrimitive.Portal, { "data-slot": "sheet-portal", container: container ?? void 0, ...props });
+}
+function SheetOverlay({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    SheetPrimitive.Overlay,
+    {
+      "data-slot": "sheet-overlay",
+      className: cn(
+        "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50",
+        className
+      ),
+      ...props
+    }
+  );
+}
+var sheetVariants = cva(
+  "bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:duration-300 data-[state=open]:duration-500 fixed z-50 gap-4 shadow-lg transition ease-in-out border-border",
+  {
+    variants: {
+      side: {
+        top: "data-[state=closed]:slide-out-to-top data-[state=open]:slide-in-from-top inset-x-0 top-0 border-b",
+        bottom: "data-[state=closed]:slide-out-to-bottom data-[state=open]:slide-in-from-bottom inset-x-0 bottom-0 border-t",
+        left: "data-[state=closed]:slide-out-to-left data-[state=open]:slide-in-from-left inset-y-0 left-0 h-full w-3/4 border-r sm:max-w-sm",
+        right: "data-[state=closed]:slide-out-to-right data-[state=open]:slide-in-from-right inset-y-0 right-0 h-full w-3/4 border-l sm:max-w-sm"
+      }
+    },
+    defaultVariants: { side: "right" }
+  }
+);
+function SheetContent({ className, portalClassName, side, children, ...props }) {
+  return /* @__PURE__ */ jsx(SheetPortal, { children: /* @__PURE__ */ jsxs("div", { className: portalClassName, children: [
+    /* @__PURE__ */ jsx(SheetOverlay, {}),
+    /* @__PURE__ */ jsxs(
+      SheetPrimitive.Content,
+      {
+        "data-slot": "sheet-content",
+        className: cn(sheetVariants({ side }), className),
+        ...props,
+        children: [
+          children,
+          /* @__PURE__ */ jsxs(SheetPrimitive.Close, { className: "ring-offset-background focus:ring-ring data-[state=open]:bg-secondary absolute top-4 end-4 rounded-xs opacity-70 transition-opacity hover:opacity-100 focus:ring-2 focus:ring-offset-2 focus:outline-hidden disabled:pointer-events-none", children: [
+            /* @__PURE__ */ jsx(X, { className: "size-4" }),
+            /* @__PURE__ */ jsx("span", { className: "sr-only", children: "Close" })
+          ] })
+        ]
+      }
+    )
+  ] }) });
+}
+function SheetHeader({ className, ...props }) {
+  return /* @__PURE__ */ jsx("div", { "data-slot": "sheet-header", className: cn("flex flex-col gap-1.5 p-6", className), ...props });
+}
+function SheetFooter({ className, ...props }) {
+  return /* @__PURE__ */ jsx("div", { "data-slot": "sheet-footer", className: cn("mt-auto flex flex-col gap-2 p-6", className), ...props });
+}
+function SheetTitle({ className, ...props }) {
+  return /* @__PURE__ */ jsx(SheetPrimitive.Title, { "data-slot": "sheet-title", className: cn("text-foreground font-semibold", className), ...props });
+}
+function SheetDescription({ className, ...props }) {
+  return /* @__PURE__ */ jsx(SheetPrimitive.Description, { "data-slot": "sheet-description", className: cn("text-muted-foreground text-sm", className), ...props });
+}
+var PortalScopeContext = createContext(void 0);
+function NPortalScopeProvider({ className, children }) {
+  return /* @__PURE__ */ jsx(PortalScopeContext.Provider, { value: className, children });
+}
+var useNPortalScope = () => useContext(PortalScopeContext);
+var responsiveSectionPadding = "px-3 py-3 lg:px-3 2xl:px-4";
+function NSheet({
+  open,
+  onOpenChange,
+  icon: Icon,
+  title,
+  description,
+  width = 480,
+  side = "right",
+  portalClassName,
+  classNames,
+  bodyClassName,
+  contentClassName,
+  children,
+  footer
+}) {
+  const inheritedScope = useNPortalScope();
+  const portal = portalClassName ?? inheritedScope;
+  const style = {
+    width: `min(${width}px, 95vw)`,
+    maxWidth: `${width}px`
+  };
+  return /* @__PURE__ */ jsx(Sheet, { open, onOpenChange, children: /* @__PURE__ */ jsxs(
+    SheetContent,
+    {
+      side,
+      portalClassName: portal,
+      className: cn(
+        "flex h-dvh max-h-dvh flex-col gap-0 overflow-hidden bg-background p-0 text-foreground",
+        contentClassName,
+        classNames?.content
+      ),
+      style,
+      children: [
+        /* @__PURE__ */ jsx(
+          SheetHeader,
+          {
+            className: cn(
+              "shrink-0 border-b border-border p-0",
+              responsiveSectionPadding,
+              classNames?.header
+            ),
+            children: /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 items-center gap-2 lg:gap-3 xl:gap-3 2xl:gap-4", children: [
+              /* @__PURE__ */ jsx("div", { className: "flex size-8 shrink-0 items-center justify-center rounded-lg bg-primary/10", children: /* @__PURE__ */ jsx(Icon, { className: "size-4 text-primary" }) }),
+              /* @__PURE__ */ jsxs("div", { className: "min-w-0", children: [
+                /* @__PURE__ */ jsx(SheetTitle, { className: "truncate text-sm font-semibold text-foreground", children: title }),
+                description && /* @__PURE__ */ jsx(SheetDescription, { className: "truncate text-xs text-muted-foreground", children: description })
+              ] })
+            ] })
+          }
+        ),
+        /* @__PURE__ */ jsx(NajmScroll, { axis: "y", className: "min-h-0 flex-1", children: /* @__PURE__ */ jsx(
+          "div",
+          {
+            "data-slot": "sheet-body",
+            className: cn(responsiveSectionPadding, bodyClassName, classNames?.body),
+            children
+          }
+        ) }),
+        footer && /* @__PURE__ */ jsx(
+          "div",
+          {
+            "data-slot": "sheet-footer",
+            className: cn(
+              "shrink-0 border-t border-border",
+              responsiveSectionPadding,
+              classNames?.footer
+            ),
+            children: footer
+          }
+        )
+      ]
+    }
+  ) });
+}
+function Dialog({ ...props }) {
+  return /* @__PURE__ */ jsx(SheetPrimitive.Root, { "data-slot": "dialog", ...props });
+}
+function DialogTrigger({ ...props }) {
+  return /* @__PURE__ */ jsx(SheetPrimitive.Trigger, { "data-slot": "dialog-trigger", ...props });
+}
+function DialogPortal({ ...props }) {
+  const container = React12.useContext(NajmThemeContainerCtx);
+  return /* @__PURE__ */ jsx(SheetPrimitive.Portal, { "data-slot": "dialog-portal", container: container ?? void 0, ...props });
+}
+function DialogClose({ ...props }) {
+  return /* @__PURE__ */ jsx(SheetPrimitive.Close, { "data-slot": "dialog-close cursor-pointer", ...props });
+}
+function DialogOverlay({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    SheetPrimitive.Overlay,
+    {
+      "data-slot": "dialog-overlay",
+      className: cn(
+        "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50 backdrop-blur-sm",
+        className
+      ),
+      ...props
+    }
+  );
+}
+var dialogPaddingMap = {
+  none: "p-0 gap-0 overflow-hidden",
+  sm: "p-3",
+  md: "p-6",
+  lg: "p-8"
+};
+var MOBILE_PADDING_QUERY = "(max-width: 639.98px)";
+function getDefaultPadding() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") return "md";
+  return window.matchMedia(MOBILE_PADDING_QUERY).matches ? "sm" : "md";
+}
+function useResponsivePadding(value) {
+  const [resolved, setResolved] = React12.useState(() => value ?? getDefaultPadding());
+  React12.useEffect(() => {
+    if (value) {
+      setResolved(value);
+      return;
+    }
+    if (typeof window === "undefined" || typeof window.matchMedia !== "function") return;
+    const mql = window.matchMedia(MOBILE_PADDING_QUERY);
+    const update = () => setResolved(mql.matches ? "sm" : "md");
+    update();
+    mql.addEventListener("change", update);
+    return () => mql.removeEventListener("change", update);
+  }, [value]);
+  return resolved;
+}
+function DialogContent({
+  className,
+  children,
+  padding,
+  hideClose = false,
+  onOpenAutoFocus,
+  onCloseAutoFocus,
+  ...props
+}) {
+  const resolvedPadding = useResponsivePadding(padding);
+  const portalClassName = useNPortalScope();
+  const openerRef = React12.useRef(null);
+  return /* @__PURE__ */ jsx(DialogPortal, { "data-slot": "dialog-portal", children: /* @__PURE__ */ jsxs("div", { className: portalClassName, children: [
+    /* @__PURE__ */ jsx(DialogOverlay, {}),
+    /* @__PURE__ */ jsxs(
+      SheetPrimitive.Content,
+      {
+        "data-slot": "dialog-content",
+        "data-padding": resolvedPadding,
+        onOpenAutoFocus: (event) => {
+          const active = document.activeElement;
+          openerRef.current = active instanceof HTMLElement && active !== document.body ? active : null;
+          onOpenAutoFocus?.(event);
+        },
+        onCloseAutoFocus: (event) => {
+          onCloseAutoFocus?.(event);
+          if (event.defaultPrevented) return;
+          const opener = openerRef.current;
+          setTimeout(() => {
+            if (!opener?.isConnected) return;
+            const active = document.activeElement;
+            const lost = !active || active === document.body || active === document.documentElement || !active.isConnected;
+            if (lost) opener.focus();
+          }, 0);
+        },
+        className: cn(
+          "bg-card text-card-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-sm translate-x-[-50%] translate-y-[-50%] gap-4 rounded-none lg:rounded-lg najm-border border-border shadow-lg duration-200",
+          dialogPaddingMap[resolvedPadding],
+          className
+        ),
+        ...props,
+        children: [
+          children,
+          !hideClose && /* @__PURE__ */ jsxs(SheetPrimitive.Close, { className: "ring-offset-background cursor-pointer focus:ring-ring absolute top-4 end-4 rounded-xs text-muted-foreground hover:text-foreground transition-colors focus:ring-2 focus:ring-offset-2 focus:outline-hidden disabled:pointer-events-none [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", children: [
+            /* @__PURE__ */ jsx(XIcon, {}),
+            /* @__PURE__ */ jsx("span", { className: "sr-only", children: "Close" })
+          ] })
+        ]
+      }
+    )
+  ] }) });
+}
+function DialogHeader({ className, ...props }) {
+  return /* @__PURE__ */ jsx("div", { "data-slot": "dialog-header", className: cn("flex flex-col gap-2 text-center sm:text-start", className), ...props });
+}
+function DialogFooter({ className, ...props }) {
+  return /* @__PURE__ */ jsx("div", { "data-slot": "dialog-footer", className: cn("flex flex-col-reverse gap-2 sm:flex-row sm:justify-end", className), ...props });
+}
+function DialogTitle({ className, ...props }) {
+  return /* @__PURE__ */ jsx(SheetPrimitive.Title, { "data-slot": "dialog-title", className: cn("text-lg leading-none font-semibold", className), ...props });
+}
+function DialogDescription({ className, ...props }) {
+  return /* @__PURE__ */ jsx(SheetPrimitive.Description, { "data-slot": "dialog-description", className: cn("text-muted-foreground text-sm", className), ...props });
+}
+var NSidebarContext = createContext(null);
+function useNSidebar() {
+  return useContext(NSidebarContext);
+}
+function NSidebarProvider({
+  children,
+  defaultCollapsed = false,
+  mobileBreakpoint = "md"
+}) {
+  const [collapsed, setCollapsed] = useState(defaultCollapsed);
+  const [mobileOpen, setMobileOpen] = useState(false);
+  const openMobile = useCallback(() => setMobileOpen(true), []);
+  const closeMobile = useCallback(() => setMobileOpen(false), []);
+  const toggleCollapsed = useCallback(() => setCollapsed((prev) => !prev), []);
+  const value = useMemo(
+    () => ({
+      collapsed,
+      mobileOpen,
+      openMobile,
+      closeMobile,
+      setMobileOpen,
+      setCollapsed,
+      toggleCollapsed,
+      mobileBreakpoint
+    }),
+    [collapsed, mobileOpen, openMobile, closeMobile, toggleCollapsed, mobileBreakpoint]
+  );
+  return /* @__PURE__ */ jsx(NSidebarContext.Provider, { value, children });
+}
+function NPageHeaderActions({ children, className }) {
+  return /* @__PURE__ */ jsx("div", { className: cn("flex shrink-0 items-center gap-0 lg:gap-1 xl:gap-2 2xl:gap-2", className), children });
+}
+NPageHeaderActions.displayName = "NPageHeaderActions";
+function NPageHeaderCompactActions({ children, className }) {
+  return /* @__PURE__ */ jsx("div", { className: cn("flex shrink-0 items-center", className), children });
+}
+NPageHeaderCompactActions.displayName = "NPageHeaderCompactActions";
+function NPageHeaderFilters({ children, className }) {
+  return /* @__PURE__ */ jsx("div", { className: cn("py-3 lg:px-3 xl:px-4 2xl:px-5", className), children });
+}
+NPageHeaderFilters.displayName = "NPageHeaderFilters";
+function NPageHeaderTop({ children, className }) {
+  return /* @__PURE__ */ jsx("div", { className, children });
+}
+NPageHeaderTop.displayName = "NPageHeaderTop";
+function isPageHeaderSlot(child, slot) {
+  return React12__default.isValidElement(child) && child.type === slot;
+}
+function getSlotElements(children, slot) {
+  const matches = React12__default.Children.toArray(children).filter((child) => isPageHeaderSlot(child, slot));
+  return matches.length > 0 ? matches : void 0;
+}
+var responsiveClasses = {
+  sm: {
+    main: "sm:flex sm:justify-between",
+    identity: "sm:col-start-auto sm:row-start-auto sm:justify-self-auto",
+    controls: "sm:col-start-auto sm:row-start-auto sm:justify-self-auto",
+    fullActions: "sm:flex",
+    compactActions: "sm:hidden",
+    sidebarTrigger: "sm:hidden",
+    icon: "sm:flex",
+    subtitle: "sm:block",
+    minH: "sm:min-h-14"
+  },
+  md: {
+    main: "md:flex md:justify-between",
+    identity: "md:col-start-auto md:row-start-auto md:justify-self-auto",
+    controls: "md:col-start-auto md:row-start-auto md:justify-self-auto",
+    fullActions: "md:flex",
+    compactActions: "md:hidden",
+    sidebarTrigger: "md:hidden",
+    icon: "md:flex",
+    subtitle: "md:block",
+    minH: "md:min-h-14"
+  },
+  lg: {
+    main: "lg:flex lg:justify-between lg:px-3 2xl:px-4",
+    identity: "lg:col-start-auto lg:row-start-auto lg:justify-self-auto",
+    controls: "lg:col-start-auto lg:row-start-auto lg:justify-self-auto",
+    fullActions: "lg:flex",
+    compactActions: "lg:hidden",
+    sidebarTrigger: "lg:hidden",
+    icon: "lg:flex",
+    subtitle: "lg:block",
+    minH: "lg:min-h-14"
+  }
+};
+function NPageHeader({
+  icon: Icon,
+  title,
+  subtitle,
+  actions,
+  compactActions,
+  filters,
+  top,
+  mobileBreakpoint: mobileBreakpointProp,
+  onSidebarOpen,
+  sidebarTriggerLabel = "Open sidebar",
+  sidebarTriggerClassName,
+  search,
+  children,
+  className,
+  headerClassName,
+  card,
+  bordered
+}) {
+  const [internalSearch, setInternalSearch] = useState("");
+  const recipe = useNajmComponentStyle("pageHeader");
+  const sidebar = useNSidebar();
+  const resolvedOnSidebarOpen = onSidebarOpen ?? sidebar?.openMobile;
+  const mobileBreakpoint = mobileBreakpointProp ?? sidebar?.mobileBreakpoint ?? "md";
+  const searchValue = search?.value ?? internalSearch;
+  const handleSearchChange = useCallback((e) => {
+    setInternalSearch(e.currentTarget.value);
+    search?.onChange?.(e);
+  }, [search?.onChange]);
+  const slottedActions = getSlotElements(children, NPageHeaderActions);
+  const slottedCompactActions = getSlotElements(children, NPageHeaderCompactActions);
+  const slottedFilters = getSlotElements(children, NPageHeaderFilters);
+  const slottedTop = getSlotElements(children, NPageHeaderTop);
+  const resolvedActions = slottedActions ?? actions;
+  const resolvedCompactActions = slottedCompactActions ?? compactActions;
+  const resolvedFilters = slottedFilters ?? filters;
+  const resolvedTop = slottedTop ?? top;
+  const hasCompactActions = resolvedCompactActions !== void 0 && resolvedCompactActions !== null && resolvedCompactActions !== false;
+  const breakpointClasses = responsiveClasses[mobileBreakpoint];
+  const isCard = card ?? recipe?.card ?? bordered === true;
+  const recipeRadius = resolveRadiusValue(recipe?.radius);
+  const bleedStyle = isCard ? void 0 : {
+    marginTop: "calc(var(--najm-section-gap, 0px) * -1)",
+    marginInline: "calc(var(--najm-page-gutter, 0px) * -1)"
+  };
+  const recipeStyle = recipeRadius || recipe?.borderWidth || bleedStyle ? {
+    ...bleedStyle,
+    ...recipeRadius ? { borderRadius: recipeRadius } : {},
+    ...recipe?.borderWidth ? { borderWidth: recipe.borderWidth } : {}
+  } : void 0;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-slot": "page-header",
+      "data-card": isCard ? "true" : void 0,
+      "data-bordered": bordered === false ? "false" : bordered ? "true" : void 0,
+      style: recipeStyle,
+      className: cn(
+        isCard ? cn("rounded-xl bg-card text-card-foreground shadow-none", surfaceBorderClasses(true)) : cn(
+          "border-b bg-background text-foreground",
+          surfaceBorderClasses(true, "bottom").replace("najm-border-b", "najm-border-b")
+        ),
+        className
+      ),
+      children: [
+        resolvedTop,
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            "data-slot": "page-header-main",
+            className: cn(
+              // min-h-14 matches NSidebarHeader so the two bottom rules line up.
+              "relative grid min-h-14 grid-cols-[minmax(2.75rem,1fr)_minmax(0,auto)_minmax(2.75rem,1fr)] items-center gap-2 px-2 lg:px-3 2xl:px-4",
+              breakpointClasses.main,
+              breakpointClasses.minH,
+              headerClassName
+            ),
+            children: [
+              resolvedOnSidebarOpen && /* @__PURE__ */ jsx(
+                Button,
+                {
+                  type: "button",
+                  variant: "ghost",
+                  size: "icon",
+                  onClick: resolvedOnSidebarOpen,
+                  "aria-label": sidebarTriggerLabel,
+                  "data-slot": "page-header-sidebar-trigger",
+                  className: cn(
+                    "col-start-1 row-start-1 justify-self-start",
+                    breakpointClasses.sidebarTrigger,
+                    sidebarTriggerClassName
+                  ),
+                  children: /* @__PURE__ */ jsx(Menu, { className: "h-5 w-5" })
+                }
+              ),
+              /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  "data-slot": "page-header-identity",
+                  className: cn(
+                    "col-start-2 row-start-1 flex min-w-0 max-w-full items-center justify-self-center gap-2 lg:gap-3 xl:gap-3 2xl:gap-4",
+                    breakpointClasses.identity
+                  ),
+                  children: [
+                    /* @__PURE__ */ jsx("div", { className: cn("hidden h-8 w-8 shrink-0 rounded-lg bg-primary/10 items-center justify-center", breakpointClasses.icon), children: /* @__PURE__ */ jsx(Icon, { className: "h-4 w-4 text-primary" }) }),
+                    /* @__PURE__ */ jsxs("div", { className: "min-w-0", children: [
+                      /* @__PURE__ */ jsx("h2", { className: "truncate text-sm font-semibold text-foreground", children: title }),
+                      subtitle && /* @__PURE__ */ jsx("p", { className: cn("hidden truncate text-xs leading-relaxed text-muted-foreground sm:text-sm sm:leading-normal", breakpointClasses.subtitle), children: subtitle })
+                    ] })
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  "data-slot": "page-header-controls",
+                  className: cn(
+                    "col-start-3 row-start-1 flex min-w-0 shrink-0 items-center justify-self-end gap-3",
+                    breakpointClasses.controls
+                  ),
+                  children: [
+                    hasCompactActions && /* @__PURE__ */ jsx(
+                      "div",
+                      {
+                        "data-slot": "page-header-compact-actions",
+                        className: cn("flex items-center", breakpointClasses.compactActions),
+                        children: slottedCompactActions ? resolvedCompactActions : /* @__PURE__ */ jsx(NPageHeaderCompactActions, { children: resolvedCompactActions })
+                      }
+                    ),
+                    /* @__PURE__ */ jsxs(
+                      "div",
+                      {
+                        "data-slot": "page-header-full-actions",
+                        className: cn(
+                          "shrink-0 items-center gap-3",
+                          hasCompactActions ? "hidden" : "flex",
+                          hasCompactActions && breakpointClasses.fullActions
+                        ),
+                        children: [
+                          search && /* @__PURE__ */ jsxs("div", { className: "relative", children: [
+                            /* @__PURE__ */ jsx(Search, { size: 14, className: "absolute left-3 top-1/2 -translate-y-1/2 text-muted-foreground pointer-events-none" }),
+                            /* @__PURE__ */ jsx(
+                              "input",
+                              {
+                                ref: search.ref,
+                                type: "text",
+                                value: searchValue,
+                                placeholder: search.placeholder ?? "Search...",
+                                className: cn(
+                                  "h-9 w-full max-w-[280px] rounded-lg bg-background pl-9 pr-3 text-sm text-foreground placeholder:text-muted-foreground outline-none border border-border focus:border-primary focus:ring-1 focus:ring-primary/20 transition-colors",
+                                  search.className
+                                ),
+                                onChange: handleSearchChange
+                              }
+                            )
+                          ] }),
+                          resolvedActions && (slottedActions ? resolvedActions : /* @__PURE__ */ jsx(NPageHeaderActions, { children: resolvedActions }))
+                        ]
+                      }
+                    )
+                  ]
+                }
+              )
+            ]
+          }
+        ),
+        resolvedFilters && (slottedFilters ? resolvedFilters : /* @__PURE__ */ jsx(NPageHeaderFilters, { children: resolvedFilters }))
+      ]
+    }
+  );
+}
+var generateId = () => `dialog-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+var buildButtonConfig = (partial, defaults) => {
+  return { ...defaults, ...partial };
+};
+function createDialogStore() {
+  return create((set, get) => ({
+    dialogs: [],
+    pushDialog: (config) => {
+      return new Promise((resolve, reject) => {
+        const id = generateId();
+        const primaryButtonConfig = buildButtonConfig(config.primaryButton, {
+          text: "Confirm",
+          variant: "default",
+          loading: false,
+          disabled: false,
+          loadingText: "Processing..."
+        });
+        const secondaryButtonConfig = buildButtonConfig(config.secondaryButton, {
+          text: "Cancel",
+          variant: "outline",
+          loading: false,
+          disabled: false,
+          loadingText: "Processing..."
+        });
+        const dialogConfig = {
+          id,
+          title: config.title,
+          description: config.description,
+          pageHeader: config.pageHeader,
+          padding: config.padding,
+          children: config.children,
+          primaryButton: primaryButtonConfig,
+          secondaryButton: secondaryButtonConfig,
+          showButtons: config.showButtons ?? true,
+          size: config.size,
+          width: config.width,
+          height: config.height,
+          className: config.className,
+          actionMode: config.actionMode ?? "auto",
+          render: config.render,
+          resolve,
+          reject
+        };
+        set((state) => ({ dialogs: [...state.dialogs, dialogConfig] }));
+      });
+    },
+    popDialog: async (result) => {
+      const { dialogs } = get();
+      if (dialogs.length === 0) return;
+      const dialog = dialogs[dialogs.length - 1];
+      const closeCurrentDialog = () => {
+        dialog.resolve?.(result);
+        set((state) => ({ dialogs: state.dialogs.slice(0, -1) }));
+      };
+      const handler = dialog.primaryButton?.onClick ?? dialog.primaryButton?.onConfirm;
+      if (handler && result != null) {
+        get().setPrimaryLoading(true);
+        try {
+          await handler(result);
+          closeCurrentDialog();
+        } finally {
+          get().setPrimaryLoading(false);
+        }
+        return;
+      }
+      dialog.resolve?.(result);
+      set((state) => ({ dialogs: state.dialogs.slice(0, -1) }));
+    },
+    closeDialog: (id, result) => {
+      const { dialogs } = get();
+      const dialog = dialogs.find((d) => d.id === id);
+      if (!dialog) return;
+      dialog.resolve?.(result);
+      set((state) => ({ dialogs: state.dialogs.filter((d) => d.id !== id) }));
+    },
+    closeAllDialogs: () => {
+      const { dialogs } = get();
+      dialogs.forEach((d) => d.reject?.(new Error("All dialogs closed")));
+      set({ dialogs: [] });
+    },
+    getCurrentDialog: () => {
+      const { dialogs } = get();
+      return dialogs[dialogs.length - 1];
+    },
+    setPrimaryLoading: (loading) => {
+      set((state) => {
+        const newDialogs = [...state.dialogs];
+        const idx = newDialogs.length - 1;
+        if (idx < 0 || !newDialogs[idx].primaryButton) return state;
+        newDialogs[idx] = {
+          ...newDialogs[idx],
+          primaryButton: { ...newDialogs[idx].primaryButton, loading }
+        };
+        return { dialogs: newDialogs };
+      });
+    },
+    setSecondaryLoading: (loading) => {
+      set((state) => {
+        const newDialogs = [...state.dialogs];
+        const idx = newDialogs.length - 1;
+        if (idx < 0 || !newDialogs[idx].secondaryButton) return state;
+        newDialogs[idx] = {
+          ...newDialogs[idx],
+          secondaryButton: { ...newDialogs[idx].secondaryButton, loading }
+        };
+        return { dialogs: newDialogs };
+      });
+    },
+    updatePrimaryButton: (config, dialogId) => {
+      set((state) => {
+        const newDialogs = [...state.dialogs];
+        const idx = dialogId ? newDialogs.findIndex((d) => d.id === dialogId) : newDialogs.length - 1;
+        if (idx === -1 || !newDialogs[idx].primaryButton) return state;
+        newDialogs[idx] = {
+          ...newDialogs[idx],
+          primaryButton: { ...newDialogs[idx].primaryButton, ...config }
+        };
+        return { dialogs: newDialogs };
+      });
+    },
+    updateSecondaryButton: (config, dialogId) => {
+      set((state) => {
+        const newDialogs = [...state.dialogs];
+        const idx = dialogId ? newDialogs.findIndex((d) => d.id === dialogId) : newDialogs.length - 1;
+        if (idx === -1 || !newDialogs[idx].secondaryButton) return state;
+        newDialogs[idx] = {
+          ...newDialogs[idx],
+          secondaryButton: { ...newDialogs[idx].secondaryButton, ...config }
+        };
+        return { dialogs: newDialogs };
+      });
+    },
+    updateShowButtons: (show, dialogId) => {
+      set((state) => {
+        const newDialogs = [...state.dialogs];
+        const idx = dialogId ? newDialogs.findIndex((d) => d.id === dialogId) : newDialogs.length - 1;
+        if (idx === -1) return state;
+        newDialogs[idx] = { ...newDialogs[idx], showButtons: show };
+        return { dialogs: newDialogs };
+      });
+    },
+    handlePrimaryClick: async (dialogId, data) => {
+      const { dialogs, setPrimaryLoading, closeDialog } = get();
+      const dialog = dialogs.find((d) => d.id === dialogId);
+      if (!dialog?.primaryButton) return;
+      const handler = dialog.primaryButton.onClick ?? dialog.primaryButton.onConfirm;
+      if (handler) {
+        setPrimaryLoading(true);
+        try {
+          await handler(data);
+          closeDialog(dialogId, data);
+        } finally {
+          setPrimaryLoading(false);
+        }
+      } else {
+        closeDialog(dialogId, data);
+      }
+    },
+    handleSecondaryClick: async (dialogId, data) => {
+      const { dialogs, closeDialog } = get();
+      const dialog = dialogs.find((d) => d.id === dialogId);
+      if (!dialog?.secondaryButton) {
+        closeDialog(dialogId, null);
+        return;
+      }
+      const handler = dialog.secondaryButton.onClick ?? dialog.secondaryButton.onConfirm;
+      if (handler) {
+        await handler(data);
+      }
+      closeDialog(dialogId, null);
+    },
+    handleConfirm: async (data) => {
+      const { dialogs, handlePrimaryClick } = get();
+      const current = dialogs[dialogs.length - 1];
+      if (!current) return;
+      await handlePrimaryClick(current.id, data);
+    },
+    handleOpenChange: (dialogId, open) => {
+      if (!open) {
+        const { closeDialog } = get();
+        closeDialog(dialogId, null);
+      }
+    }
+  }));
+}
+var defaultStore = createDialogStore();
+function useDialogStore() {
+  return defaultStore;
+}
+function NDialogHeader(_props) {
+  return null;
+}
+function NDialogDescription(_props) {
+  return null;
+}
+function NDialogPrimaryButton(_props) {
+  return null;
+}
+function NDialogSecondaryButton(_props) {
+  return null;
+}
+function parseDirectDialogSlots(children) {
+  const body = [];
+  const parsed = {};
+  React12__default.Children.forEach(children, (child) => {
+    if (!React12__default.isValidElement(child)) {
+      body.push(child);
+      return;
+    }
+    if (child.type === NDialogHeader) {
+      parsed.header = child.props;
+      return;
+    }
+    if (child.type === NDialogDescription) {
+      parsed.description = child.props;
+      return;
+    }
+    if (child.type === NDialogPrimaryButton || child.type === NDialogSecondaryButton) {
+      const { children: text, label, ...config } = child.props;
+      const button = { ...config, text: label ?? text ?? (child.type === NDialogPrimaryButton ? "Confirm" : "Cancel") };
+      if (child.type === NDialogPrimaryButton) parsed.primaryButton = button;
+      else parsed.secondaryButton = button;
+      return;
+    }
+    body.push(child);
+  });
+  return { ...parsed, body };
+}
+var dialogVariants = cva(
+  "flex flex-col w-full max-w-full h-full max-h-screen",
+  {
+    variants: {
+      variant: {
+        default: "",
+        window: "rounded-none lg:rounded-sm"
+      },
+      size: {
+        sm: "lg:max-w-md",
+        md: "lg:max-w-lg",
+        lg: "lg:max-w-xl",
+        xl: "lg:max-w-2xl",
+        xxl: "lg:max-w-3xl",
+        full: "lg:max-w-4xl"
+      },
+      width: {
+        sm: "lg:max-w-sm",
+        md: "lg:max-w-md",
+        lg: "lg:max-w-lg",
+        xl: "lg:max-w-xl",
+        xxl: "lg:max-w-2xl",
+        "3xl": "lg:max-w-3xl",
+        "4xl": "lg:max-w-4xl",
+        "5xl": "lg:max-w-5xl",
+        "6xl": "lg:max-w-6xl",
+        "7xl": "lg:max-w-7xl",
+        full: "lg:max-w-5/6",
+        auto: "lg:w-auto"
+      },
+      height: {
+        auto: "lg:h-auto lg:max-h-[95vh]",
+        sm: "lg:h-[40vh]",
+        md: "lg:h-[60vh]",
+        lg: "lg:h-[70vh]",
+        xl: "lg:h-[80vh]",
+        xxl: "lg:h-[95vh]",
+        full: "lg:h-[95vh]"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "xl",
+      width: "3xl",
+      height: "auto"
+    }
+  }
+);
+var CONTENT_ACTIONS_SELECTOR = '[data-najm-dialog-actions="content"], [data-najm-wizard-form="true"]';
+function useContentOwnsActions() {
+  const [contentElement, setContentElement] = React12__default.useState(null);
+  const [contentOwnsActions, setContentOwnsActions] = React12__default.useState(false);
+  const contentElementRef = React12__default.useRef(null);
+  const handleContentElementRef = React12__default.useCallback((node) => {
+    if (contentElementRef.current === node) return;
+    contentElementRef.current = node;
+    setContentElement(node);
+  }, []);
+  React12__default.useLayoutEffect(() => {
+    if (!contentElement) {
+      setContentOwnsActions((current) => current ? false : current);
+      return;
+    }
+    const update = () => {
+      const next = !!contentElement.querySelector(CONTENT_ACTIONS_SELECTOR);
+      setContentOwnsActions((current) => current === next ? current : next);
+    };
+    update();
+    const observer = new MutationObserver(update);
+    observer.observe(contentElement, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["data-najm-dialog-actions", "data-najm-wizard-form"]
+    });
+    return () => observer.disconnect();
+  }, [contentElement]);
+  return { contentOwnsActions, setContentElement: handleContentElementRef };
+}
+function shouldRenderDialogButtons(showButtons, actionMode = "auto", contentOwnsActions) {
+  if (!showButtons || actionMode === "content") return false;
+  if (actionMode === "auto" && contentOwnsActions) return false;
+  return true;
+}
+var windowHeaderSpacing = {
+  none: "px-3 py-2",
+  sm: "-mx-3 -mt-3 px-3 py-2",
+  md: "-mx-6 -mt-6 px-3 py-2",
+  lg: "-mx-8 -mt-8 px-3 py-2"
+};
+function DialogChrome({
+  pageHeader,
+  title,
+  description,
+  padding,
+  variant = "default",
+  headerClassName,
+  titleClassName,
+  descriptionClassName,
+  closeButtonClassName,
+  contentRef,
+  children
+}) {
+  const resolvedPadding = useResponsivePadding(padding);
+  const noTitle = !title || title.trim() === "";
+  const noDescription = !description || description.trim() === "";
+  const noHeader = noTitle && noDescription;
+  const flush = resolvedPadding === "none";
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    pageHeader ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(DialogTitle, { className: cn("sr-only", titleClassName), children: pageHeader.title || title || "Dialog" }),
+      (pageHeader.subtitle || description) && /* @__PURE__ */ jsx(DialogDescription, { className: cn("sr-only", descriptionClassName), children: pageHeader.subtitle || description }),
+      /* @__PURE__ */ jsx("div", { className: cn("shrink-0", headerClassName), children: /* @__PURE__ */ jsx(
+        NPageHeader,
+        {
+          ...pageHeader,
+          card: false,
+          actions: /* @__PURE__ */ jsxs(Fragment, { children: [
+            pageHeader.actions,
+            /* @__PURE__ */ jsx(DialogClose, { asChild: true, children: /* @__PURE__ */ jsx(IconButton, { "aria-label": "Close", variant: "ghost", className: closeButtonClassName, children: /* @__PURE__ */ jsx(X, { className: "h-4 w-4" }) }) })
+          ] })
+        }
+      ) })
+    ] }) : variant === "window" ? /* @__PURE__ */ jsxs(
+      DialogHeader,
+      {
+        className: cn(
+          "flex-row items-center justify-between gap-3 border-b border-border bg-secondary text-start text-secondary-foreground",
+          windowHeaderSpacing[resolvedPadding],
+          headerClassName
+        ),
+        children: [
+          /* @__PURE__ */ jsxs("div", { className: "min-w-0 space-y-1", children: [
+            /* @__PURE__ */ jsx(DialogTitle, { className: cn("truncate text-sm", noTitle && "sr-only", titleClassName), children: title || "Dialog" }),
+            /* @__PURE__ */ jsx(DialogDescription, { className: cn("text-xs", noDescription && "sr-only", descriptionClassName), children: description })
+          ] }),
+          /* @__PURE__ */ jsx(DialogClose, { asChild: true, children: /* @__PURE__ */ jsx(
+            IconButton,
+            {
+              "aria-label": "Close",
+              variant: "ghost",
+              size: "sm",
+              className: cn("border border-border bg-background text-foreground hover:bg-accent", closeButtonClassName),
+              children: /* @__PURE__ */ jsx(X, { className: "h-3.5 w-3.5" })
+            }
+          ) })
+        ]
+      }
+    ) : /* @__PURE__ */ jsxs(DialogHeader, { className: cn(noHeader && "sr-only", headerClassName), children: [
+      /* @__PURE__ */ jsx(DialogTitle, { className: cn(noTitle && "sr-only", titleClassName), children: title }),
+      /* @__PURE__ */ jsx(DialogDescription, { className: cn(noDescription && "sr-only", descriptionClassName), children: description })
+    ] }),
+    flush ? (
+      // Full-bleed content owns its own layout/scrolling; no outer scroll wrapper.
+      /* @__PURE__ */ jsx("div", { ref: contentRef, className: "flex min-h-0 flex-1 flex-col", children })
+    ) : /* @__PURE__ */ jsx(NajmScroll, { axis: "y", className: "flex-1 px-1 -mx-1", children: /* @__PURE__ */ jsx("div", { ref: contentRef, style: { display: "contents" }, children }) })
+  ] });
+}
+function DialogItem({ dialog, index, store }) {
+  if (dialog.render) {
+    return /* @__PURE__ */ jsx(Fragment, { children: dialog.render({
+      dialog,
+      index,
+      zIndex: 9990 + index,
+      close: (result) => store.getState().closeDialog(dialog.id, result),
+      confirm: (data) => store.getState().handlePrimaryClick(dialog.id, data),
+      cancel: (data) => store.getState().handleSecondaryClick(dialog.id, data),
+      onOpenChange: (open) => store.getState().handleOpenChange(dialog.id, open)
+    }) });
+  }
+  const {
+    id,
+    title,
+    description,
+    pageHeader,
+    padding,
+    children,
+    primaryButton,
+    secondaryButton,
+    showButtons,
+    size,
+    width,
+    height,
+    className,
+    headerClassName,
+    titleClassName,
+    descriptionClassName,
+    closeButtonClassName,
+    variant = "default",
+    actionMode = "auto"
+  } = dialog;
+  const { contentOwnsActions, setContentElement } = useContentOwnsActions();
+  const renderDialogButtons = shouldRenderDialogButtons(showButtons, actionMode, contentOwnsActions);
+  const handlePrimary = async (e) => {
+    const hasForm = !!primaryButton?.form;
+    if (!hasForm && e) e.preventDefault();
+    await store.getState().handlePrimaryClick(id);
+  };
+  const handleSecondary = async (e) => {
+    const hasForm = !!secondaryButton?.form;
+    if (!hasForm && e) e.preventDefault();
+    await store.getState().handleSecondaryClick(id);
+  };
+  return /* @__PURE__ */ jsx(Dialog, { open: true, onOpenChange: (open) => store.getState().handleOpenChange(id, open), children: /* @__PURE__ */ jsxs(
+    DialogContent,
+    {
+      "data-dialog-id": id,
+      "data-variant": variant,
+      padding,
+      hideClose: !!pageHeader || variant === "window",
+      className: cn(dialogVariants({ variant, size, width, height }), className),
+      style: { zIndex: 9990 + index },
+      children: [
+        /* @__PURE__ */ jsx(
+          DialogChrome,
+          {
+            pageHeader,
+            title,
+            description,
+            padding,
+            variant,
+            headerClassName,
+            titleClassName,
+            descriptionClassName,
+            closeButtonClassName,
+            contentRef: setContentElement,
+            children
+          }
+        ),
+        /* @__PURE__ */ jsxs(DialogFooter, { className: cn(!renderDialogButtons && "sr-only"), children: [
+          renderDialogButtons && secondaryButton && /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: secondaryButton.form ? "submit" : "button",
+              "data-button-type": "secondary",
+              onClick: secondaryButton.form ? void 0 : handleSecondary,
+              disabled: secondaryButton.disabled || secondaryButton.loading || false,
+              variant: secondaryButton.variant || "outline",
+              leftIcon: secondaryButton.icon,
+              loading: secondaryButton.loading,
+              loadingText: secondaryButton.loadingText,
+              form: secondaryButton.form,
+              className: cn("w-auto", secondaryButton.className),
+              children: secondaryButton.text
+            }
+          ),
+          renderDialogButtons && primaryButton && /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: primaryButton.form ? "submit" : "button",
+              "data-button-type": "primary",
+              onClick: primaryButton.form ? void 0 : handlePrimary,
+              disabled: primaryButton.disabled || primaryButton.loading || false,
+              variant: primaryButton.variant || "default",
+              leftIcon: primaryButton.icon,
+              loading: primaryButton.loading,
+              loadingText: primaryButton.loadingText,
+              form: primaryButton.form,
+              className: cn("w-auto", primaryButton.className),
+              children: primaryButton.text
+            }
+          )
+        ] })
+      ]
+    }
+  ) }, id);
+}
+function NMultiDialog({ store: storeProp }) {
+  const defaultStore2 = useDialogStore();
+  const store = storeProp ?? defaultStore2;
+  const dialogs = store((s) => s.dialogs);
+  return /* @__PURE__ */ jsx(Fragment, { children: dialogs.map((dialog, index) => /* @__PURE__ */ jsx(DialogItem, { dialog, index, store }, dialog.id)) });
+}
+var buildButtonConfig2 = (partial, defaults) => {
+  return { ...defaults, ...partial };
+};
+var isDirectDialogProps = (props) => {
+  return "trigger" in props || "open" in props || "defaultOpen" in props || "onOpenChange" in props || "title" in props || "description" in props || "children" in props || "primaryButton" in props || "secondaryButton" in props || "showButtons" in props || "size" in props || "width" in props || "height" in props || "className" in props || "headerClassName" in props || "titleClassName" in props || "descriptionClassName" in props || "closeButtonClassName" in props || "variant" in props || "pageHeader" in props || "padding" in props;
+};
+function NDirectDialog({
+  trigger,
+  open,
+  defaultOpen = false,
+  onOpenChange,
+  title,
+  description,
+  pageHeader,
+  padding,
+  children,
+  primaryButton,
+  secondaryButton,
+  showButtons = true,
+  size,
+  width,
+  height,
+  className,
+  headerClassName,
+  titleClassName,
+  descriptionClassName,
+  closeButtonClassName,
+  variant = "default",
+  actionMode = "auto",
+  closeOnPrimary = true,
+  closeOnSecondary = true
+}) {
+  const slots = parseDirectDialogSlots(children);
+  const resolvedTitle = title ?? slots.header?.label ?? slots.header?.children;
+  const resolvedDescription = description ?? slots.description?.label ?? slots.description?.children;
+  const resolvedHeaderClassName = cn(slots.header?.className, headerClassName);
+  const resolvedTitleClassName = cn(slots.header?.titleClassName, titleClassName);
+  const resolvedDescriptionClassName = cn(slots.description?.className, descriptionClassName);
+  const [internalOpen, setInternalOpen] = React12__default.useState(defaultOpen);
+  const [primaryLoading, setPrimaryLoading] = React12__default.useState(false);
+  const isControlled = open !== void 0;
+  const currentOpen = isControlled ? open : internalOpen;
+  const setOpen = (nextOpen) => {
+    if (!isControlled) {
+      setInternalOpen(nextOpen);
+    }
+    onOpenChange?.(nextOpen);
+  };
+  const resolvedPrimaryButton = buildButtonConfig2(primaryButton ?? slots.primaryButton, {
+    text: "Confirm",
+    variant: "default",
+    loading: false,
+    disabled: false,
+    loadingText: "Processing..."
+  });
+  const resolvedSecondaryButton = buildButtonConfig2(secondaryButton ?? slots.secondaryButton, {
+    text: "Cancel",
+    variant: "outline",
+    loading: false,
+    disabled: false,
+    loadingText: "Processing..."
+  });
+  const isPrimaryLoading = primaryLoading || !!resolvedPrimaryButton.loading;
+  const { contentOwnsActions, setContentElement } = useContentOwnsActions();
+  const renderDialogButtons = shouldRenderDialogButtons(showButtons, actionMode, contentOwnsActions);
+  const handlePrimary = async (e) => {
+    const hasForm = !!resolvedPrimaryButton.form;
+    if (!hasForm && e) e.preventDefault();
+    if (resolvedPrimaryButton.onClick) {
+      setPrimaryLoading(true);
+      try {
+        await resolvedPrimaryButton.onClick();
+      } finally {
+        setPrimaryLoading(false);
+      }
+    }
+    if (closeOnPrimary) {
+      setOpen(false);
+    }
+  };
+  const handleSecondary = async (e) => {
+    const hasForm = !!resolvedSecondaryButton.form;
+    if (!hasForm && e) e.preventDefault();
+    if (resolvedSecondaryButton.onClick) {
+      await resolvedSecondaryButton.onClick();
+    }
+    if (closeOnSecondary) {
+      setOpen(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs(Dialog, { open: currentOpen, onOpenChange: setOpen, children: [
+    trigger ? /* @__PURE__ */ jsx(DialogTrigger, { asChild: true, children: trigger }) : null,
+    /* @__PURE__ */ jsxs(
+      DialogContent,
+      {
+        "data-variant": variant,
+        padding,
+        hideClose: !!pageHeader || variant === "window",
+        className: cn(dialogVariants({ variant, size, width, height }), className),
+        children: [
+          /* @__PURE__ */ jsx(
+            DialogChrome,
+            {
+              pageHeader,
+              title: resolvedTitle,
+              description: resolvedDescription,
+              padding,
+              variant,
+              headerClassName: resolvedHeaderClassName,
+              titleClassName: resolvedTitleClassName,
+              descriptionClassName: resolvedDescriptionClassName,
+              closeButtonClassName,
+              contentRef: setContentElement,
+              children: slots.body
+            }
+          ),
+          /* @__PURE__ */ jsx(DialogFooter, { className: cn(!renderDialogButtons && "sr-only"), children: renderDialogButtons && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                type: resolvedSecondaryButton.form ? "submit" : "button",
+                "data-button-type": "secondary",
+                onClick: resolvedSecondaryButton.form ? void 0 : handleSecondary,
+                disabled: resolvedSecondaryButton.disabled || resolvedSecondaryButton.loading || false,
+                variant: resolvedSecondaryButton.variant || "outline",
+                leftIcon: resolvedSecondaryButton.icon,
+                loading: resolvedSecondaryButton.loading,
+                loadingText: resolvedSecondaryButton.loadingText,
+                form: resolvedSecondaryButton.form,
+                className: cn("w-auto", resolvedSecondaryButton.className),
+                children: resolvedSecondaryButton.text
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                type: resolvedPrimaryButton.form ? "submit" : "button",
+                "data-button-type": "primary",
+                onClick: resolvedPrimaryButton.form ? void 0 : handlePrimary,
+                disabled: resolvedPrimaryButton.disabled || isPrimaryLoading || false,
+                variant: resolvedPrimaryButton.variant || "default",
+                leftIcon: resolvedPrimaryButton.icon,
+                loading: isPrimaryLoading,
+                loadingText: resolvedPrimaryButton.loadingText,
+                form: resolvedPrimaryButton.form,
+                className: cn("w-auto", resolvedPrimaryButton.className),
+                children: resolvedPrimaryButton.text
+              }
+            )
+          ] }) })
+        ]
+      }
+    )
+  ] });
+}
+function NDialog(props) {
+  if (isDirectDialogProps(props)) {
+    return /* @__PURE__ */ jsx(NDirectDialog, { ...props });
+  }
+  return /* @__PURE__ */ jsx(NMultiDialog, { ...props });
+}
+function NConfirmDialog({
+  open,
+  onOpenChange,
+  title = "Are you sure?",
+  description,
+  confirmLabel = "Confirm",
+  cancelLabel = "Cancel",
+  onConfirm,
+  variant = "default",
+  loading = false,
+  children,
+  icon
+}) {
+  const isDestructive = variant === "destructive";
+  const resolvedIcon = icon ?? (isDestructive ? "alert-triangle" : "circle-help");
+  return /* @__PURE__ */ jsx(Dialog, { open, onOpenChange: (value) => {
+    if (!value && loading) return;
+    onOpenChange(value);
+  }, children: /* @__PURE__ */ jsxs(DialogContent, { children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center gap-3 text-center pt-1", children: [
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: cn(
+            "flex size-16 items-center justify-center rounded-full",
+            isDestructive ? "bg-destructive/10 text-destructive" : "bg-primary/10 text-primary"
+          ),
+          children: /* @__PURE__ */ jsx(NIcon, { icon: resolvedIcon, className: "size-8" })
+        }
+      ),
+      /* @__PURE__ */ jsxs(DialogHeader, { className: "text-center sm:text-center", children: [
+        /* @__PURE__ */ jsx(DialogTitle, { className: isDestructive ? "text-destructive" : "", children: title }),
+        description && /* @__PURE__ */ jsx(DialogDescription, { children: description })
+      ] })
+    ] }),
+    children,
+    /* @__PURE__ */ jsxs(DialogFooter, { children: [
+      /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: () => onOpenChange(false), disabled: loading, children: cancelLabel }),
+      /* @__PURE__ */ jsx(Button, { variant: isDestructive ? "destructive" : "default", onClick: onConfirm, disabled: loading, children: loading ? "Processing..." : confirmLabel })
+    ] })
+  ] }) });
+}
+function NDeleteDialogContent({
+  title = "Delete",
+  itemName,
+  itemType,
+  icon: Icon = "trash-2",
+  warningText = "Are you sure you want to delete?",
+  className
+}) {
+  return /* @__PURE__ */ jsx("form", { id: "najm-delete-form", onSubmit: (e) => e.preventDefault(), children: /* @__PURE__ */ jsxs("div", { className: cn("flex flex-col items-center text-center", className), children: [
+    /* @__PURE__ */ jsx("div", { className: "mb-6 flex size-16 items-center justify-center rounded-[20px] bg-destructive/10 text-destructive", children: /* @__PURE__ */ jsx(NIcon, { icon: Icon, className: "size-7" }) }),
+    /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+      /* @__PURE__ */ jsx("h2", { className: "text-xl font-semibold leading-none text-card-foreground", children: title }),
+      /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+        /* @__PURE__ */ jsx("p", { className: "text-sm font-medium leading-5 text-muted-foreground", children: warningText }),
+        /* @__PURE__ */ jsxs("p", { className: "mx-auto max-w-[280px] break-words text-center text-sm font-bold leading-5 text-card-foreground", children: [
+          '"',
+          itemName,
+          '"',
+          itemType ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            " (",
+            itemType,
+            ")"
+          ] }) : null
+        ] })
+      ] })
+    ] })
+  ] }) });
+}
+function NDeleteDialog({
+  open = true,
+  title = "Delete",
+  description,
+  itemName,
+  itemType,
+  icon,
+  warningText,
+  confirmText = "Confirm",
+  cancelText = "Cancel",
+  loading,
+  zIndex,
+  className,
+  contentClassName,
+  onOpenChange,
+  onConfirm,
+  onCancel
+}) {
+  return /* @__PURE__ */ jsx(Dialog, { open, onOpenChange, children: /* @__PURE__ */ jsxs(
+    DialogContent,
+    {
+      className: cn(
+        "h-auto max-w-[380px] gap-0 rounded-[18px] border border-border bg-card p-6 pt-8 shadow-2xl",
+        "[&>button]:end-4 [&>button]:top-4 [&>button]:flex [&>button]:size-6 [&>button]:items-center [&>button]:justify-center",
+        "[&>button]:rounded-full [&>button]:bg-muted [&>button]:text-muted-foreground [&>button]:opacity-100 [&>button]:ring-offset-0",
+        "[&>button]:hover:bg-secondary [&>button]:hover:text-foreground",
+        className
+      ),
+      style: { zIndex },
+      children: [
+        /* @__PURE__ */ jsxs(DialogHeader, { className: "sr-only", children: [
+          /* @__PURE__ */ jsx(DialogTitle, { children: title }),
+          /* @__PURE__ */ jsx(DialogDescription, { children: description })
+        ] }),
+        /* @__PURE__ */ jsx(
+          NDeleteDialogContent,
+          {
+            title,
+            itemName,
+            itemType,
+            icon,
+            warningText,
+            className: contentClassName
+          }
+        ),
+        /* @__PURE__ */ jsxs(DialogFooter, { className: "mt-6 grid grid-cols-2 gap-3 sm:grid-cols-2", children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: "button",
+              "data-button-type": "secondary",
+              variant: "outline",
+              onClick: onCancel,
+              disabled: loading,
+              className: "h-10 w-full rounded-[10px] border border-destructive bg-transparent text-sm font-bold text-card-foreground shadow-none hover:bg-transparent hover:text-card-foreground",
+              children: cancelText
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: "button",
+              "data-button-type": "primary",
+              variant: "destructive",
+              onClick: onConfirm,
+              loading,
+              className: "h-10 w-full rounded-[10px] bg-destructive text-sm font-bold text-destructive-foreground shadow-none hover:bg-destructive/90 focus-visible:ring-destructive/40",
+              children: confirmText
+            }
+          )
+        ] })
+      ]
+    }
+  ) });
+}
+function useDialog(store) {
+  const resolvedStore = store ?? useDialogStore();
+  const custom = async (options) => {
+    try {
+      return await resolvedStore.getState().pushDialog(options);
+    } catch (error) {
+      console.error("[useDialog] Failed to push dialog:", error);
+      return null;
+    }
+  };
+  const confirmDelete = async (options) => {
+    try {
+      return await resolvedStore.getState().pushDialog({
+        title: options.title || "Delete",
+        description: options.description,
+        size: options.size || "sm",
+        className: options.className,
+        render: ({ dialog, zIndex, confirm, cancel, onOpenChange }) => React12__default.createElement(NDeleteDialog, {
+          itemName: options.itemName,
+          itemType: options.itemType,
+          icon: options.icon,
+          warningText: options.warningText,
+          title: dialog.title,
+          description: dialog.description,
+          confirmText: dialog.primaryButton?.text,
+          cancelText: dialog.secondaryButton?.text,
+          loading: dialog.primaryButton?.loading,
+          className: dialog.className,
+          zIndex,
+          onOpenChange,
+          onConfirm: () => confirm(),
+          onCancel: () => cancel()
+        }),
+        primaryButton: {
+          text: options.confirmText || "Confirm",
+          variant: "destructive",
+          loading: options.loading,
+          onClick: options.onConfirm
+        },
+        secondaryButton: {
+          text: options.cancelText || "Cancel",
+          variant: "outline"
+        },
+        showButtons: true
+      });
+    } catch (error) {
+      console.error("[useDialog] Failed to show confirmDelete:", error);
+      return null;
+    }
+  };
+  return {
+    custom,
+    openDialog: custom,
+    confirmDelete,
+    closeAll: () => resolvedStore.getState().closeAllDialogs(),
+    push: (opts) => resolvedStore.getState().pushDialog(opts),
+    pop: (result) => resolvedStore.getState().popDialog(result)
+  };
+}
+
+// src/location/labels.ts
+var DEFAULT_LOCATION_LABELS = {
+  dialogTitle: "Pick an address",
+  dialogDescription: "Search or select a location on the map.",
+  openMap: "Select location on map",
+  close: "Close",
+  cancel: "Cancel",
+  confirm: "Confirm address",
+  clearPin: "Clear pin",
+  searchPlaceholder: "Search by street, city, or postal code",
+  search: "Search",
+  searching: "Searching\u2026",
+  searchEmpty: "No locations found.",
+  searchError: "Location search is unavailable.",
+  findingAddress: "Finding the address...",
+  selected: "Delivery location selected",
+  notSelected: "Delivery location not selected",
+  changedAfterPin: "Address changed after the pin was selected",
+  loading: "Loading map\u2026",
+  unavailable: "Map selection is unavailable",
+  retry: "Retry",
+  currentLocation: "Use current location",
+  zoomIn: "Zoom in",
+  zoomOut: "Zoom out",
+  mapInstructions: "Map. Use arrow keys to move the selected pin. Hold Shift for a larger step.",
+  readyAnnouncement: "Map is ready.",
+  selectedAnnouncement: "Location selected.",
+  addressUpdatedAnnouncement: "Address updated for the selected location.",
+  clearedAnnouncement: "Location pin cleared.",
+  geolocationUnsupported: "Current location is not supported by this browser.",
+  geolocationDenied: "Location permission was denied.",
+  geolocationTimeout: "Current location timed out.",
+  geolocationUnavailable: "Current location is unavailable.",
+  providerError: "The map could not be loaded.",
+  resultsAnnouncement: (count) => `${count} location result${count === 1 ? "" : "s"} available.`
+};
+var DEFAULT_CENTER = { latitude: 33.5731, longitude: -7.5898 };
+var NLocationContext = React12__default.createContext(null);
+function NLocationProvider({
+  children,
+  adapter = null,
+  geocoder = null,
+  defaultCenter = DEFAULT_CENTER,
+  defaultZoom = 12,
+  labels,
+  searchMode = "submit",
+  unavailableReason
+}) {
+  const value = React12__default.useMemo(() => ({
+    adapter,
+    geocoder,
+    defaultCenter,
+    defaultZoom,
+    labels: { ...DEFAULT_LOCATION_LABELS, ...labels },
+    searchMode,
+    unavailableReason
+  }), [adapter, defaultCenter, defaultZoom, geocoder, labels, searchMode, unavailableReason]);
+  return /* @__PURE__ */ jsx(NLocationContext.Provider, { value, children });
+}
+function useNLocationProvider() {
+  const value = React12__default.useContext(NLocationContext);
+  if (!value) {
+    return {
+      adapter: null,
+      geocoder: null,
+      defaultCenter: DEFAULT_CENTER,
+      defaultZoom: 12,
+      labels: DEFAULT_LOCATION_LABELS,
+      searchMode: "submit",
+      unavailableReason: DEFAULT_LOCATION_LABELS.unavailable
+    };
+  }
+  return value;
+}
+function useLocationDraft(committed, open) {
+  const [draft, setDraft] = React12__default.useState(() => normalizeLocationValue(committed));
+  React12__default.useEffect(() => {
+    if (open) setDraft(normalizeLocationValue(committed));
+  }, [committed, open]);
+  const discard = React12__default.useCallback(() => setDraft(normalizeLocationValue(committed)), [committed]);
+  return { draft, setDraft, discard };
+}
+var SEARCH_DELAY_MS = 350;
+function geolocationMessage(error, labels) {
+  if (error.code === error.PERMISSION_DENIED) return labels.geolocationDenied;
+  if (error.code === error.TIMEOUT) return labels.geolocationTimeout;
+  return labels.geolocationUnavailable;
+}
+function NLocationDialog({ open, value, onOpenChange, onConfirm, labels: labelOverrides, classNames }) {
+  const provider = useNLocationProvider();
+  const labels = React12__default.useMemo(() => ({ ...provider.labels, ...labelOverrides }), [labelOverrides, provider.labels]);
+  const { draft, setDraft, discard } = useLocationDraft(value, open);
+  const [announcement, setAnnouncement] = React12__default.useState("");
+  const [providerLoading, setProviderLoading] = React12__default.useState(false);
+  const [providerError, setProviderError] = React12__default.useState(null);
+  const [providerAttempt, setProviderAttempt] = React12__default.useState(0);
+  const [mapControls, setMapControls] = React12__default.useState(null);
+  const [query, setQuery] = React12__default.useState("");
+  const [results, setResults] = React12__default.useState([]);
+  const [searchPerformed, setSearchPerformed] = React12__default.useState(false);
+  const [searchLoading, setSearchLoading] = React12__default.useState(false);
+  const [searchError, setSearchError] = React12__default.useState(false);
+  const [reverseLoading, setReverseLoading] = React12__default.useState(false);
+  const searchAbort = React12__default.useRef(null);
+  const reverseAbort = React12__default.useRef(null);
+  const reverseRequest = React12__default.useRef(0);
+  const geoRequest = React12__default.useRef(0);
+  const searchInputRef = React12__default.useRef(null);
+  const mapInstructionRef = React12__default.useRef(null);
+  const coordinates = locationCoordinates(draft);
+  const coordinatesRef = React12__default.useRef(coordinates);
+  coordinatesRef.current = coordinates;
+  const AdapterMap = provider.adapter?.Map;
+  React12__default.useEffect(() => {
+    if (!open) {
+      searchAbort.current?.abort();
+      reverseAbort.current?.abort();
+      reverseRequest.current += 1;
+      provider.geocoder?.resetSession?.();
+      geoRequest.current += 1;
+      setProviderLoading(false);
+      setSearchLoading(false);
+      setReverseLoading(false);
+      return;
+    }
+    setAnnouncement("");
+    setProviderError(null);
+    setResults([]);
+    setQuery("");
+    setSearchError(false);
+    setSearchPerformed(false);
+    setSearchLoading(false);
+    setReverseLoading(false);
+  }, [open, provider.geocoder]);
+  const close = React12__default.useCallback(() => {
+    discard();
+    onOpenChange(false);
+  }, [discard, onOpenChange]);
+  const updateCoordinates = React12__default.useCallback((next) => {
+    setDraft((current) => ({ ...current, ...next }));
+    setAnnouncement(labels.selectedAnnouncement);
+    if (!provider.geocoder?.reverse) return;
+    reverseAbort.current?.abort();
+    const controller = new AbortController();
+    const request = ++reverseRequest.current;
+    reverseAbort.current = controller;
+    setReverseLoading(true);
+    void provider.geocoder.reverse(next, controller.signal).then((candidate) => {
+      if (controller.signal.aborted || request !== reverseRequest.current || !candidate?.label) return;
+      setDraft((current) => ({ ...current, address: candidate.label }));
+      setAnnouncement(labels.addressUpdatedAnnouncement);
+    }).catch(() => {
+    }).finally(() => {
+      if (request === reverseRequest.current) setReverseLoading(false);
+    });
+  }, [labels.addressUpdatedAnnouncement, labels.selectedAnnouncement, provider.geocoder, setDraft]);
+  const performSearch = React12__default.useCallback(async (rawQuery) => {
+    const nextQuery = rawQuery.trim();
+    if (!provider.geocoder || nextQuery.length < 2) {
+      setResults([]);
+      return;
+    }
+    searchAbort.current?.abort();
+    const controller = new AbortController();
+    searchAbort.current = controller;
+    setSearchLoading(true);
+    setSearchError(false);
+    setSearchPerformed(false);
+    try {
+      const found = await provider.geocoder.search(nextQuery, {
+        signal: controller.signal,
+        center: coordinatesRef.current ?? provider.defaultCenter,
+        language: document.documentElement.lang || void 0
+      });
+      if (controller.signal.aborted) return;
+      setResults(found);
+      setSearchPerformed(true);
+      setAnnouncement(labels.resultsAnnouncement(found.length));
+    } catch {
+      if (controller.signal.aborted) return;
+      setResults([]);
+      setSearchError(true);
+      setSearchPerformed(true);
+      setAnnouncement(labels.searchError);
+    } finally {
+      if (!controller.signal.aborted) setSearchLoading(false);
+    }
+  }, [labels, provider.defaultCenter, provider.geocoder]);
+  React12__default.useEffect(() => {
+    if (!open || provider.searchMode !== "autocomplete" || !provider.geocoder || query.trim().length < 2) return;
+    const timeout = setTimeout(() => void performSearch(query), SEARCH_DELAY_MS);
+    return () => clearTimeout(timeout);
+  }, [open, performSearch, provider.geocoder, provider.searchMode, query]);
+  const selectCandidate = async (candidate) => {
+    if (!provider.geocoder) return;
+    reverseAbort.current?.abort();
+    reverseRequest.current += 1;
+    setReverseLoading(false);
+    searchAbort.current?.abort();
+    const controller = new AbortController();
+    searchAbort.current = controller;
+    setSearchLoading(true);
+    try {
+      const resolved = candidate.coordinates ? candidate : provider.geocoder.resolve ? await provider.geocoder.resolve(candidate, controller.signal) : candidate;
+      if (controller.signal.aborted || !resolved.coordinates) return;
+      setDraft((current) => ({
+        ...current,
+        address: resolved.label || current.address,
+        latitude: resolved.coordinates.latitude,
+        longitude: resolved.coordinates.longitude
+      }));
+      mapControls?.recenter(resolved.coordinates);
+      setQuery("");
+      setResults([]);
+      setSearchPerformed(false);
+      setAnnouncement(labels.selectedAnnouncement);
+    } catch {
+      if (!controller.signal.aborted) setSearchError(true);
+    } finally {
+      if (!controller.signal.aborted) setSearchLoading(false);
+    }
+  };
+  const useCurrentLocation = () => {
+    if (!navigator.geolocation) {
+      setAnnouncement(labels.geolocationUnsupported);
+      return;
+    }
+    const request = ++geoRequest.current;
+    setProviderLoading(true);
+    navigator.geolocation.getCurrentPosition(
+      (position) => {
+        if (request !== geoRequest.current || !open) return;
+        const next = { latitude: position.coords.latitude, longitude: position.coords.longitude };
+        updateCoordinates(next);
+        mapControls?.recenter(next);
+        setProviderLoading(false);
+      },
+      (error) => {
+        if (request !== geoRequest.current || !open) return;
+        setProviderLoading(false);
+        setAnnouncement(geolocationMessage(error, labels));
+      },
+      { enableHighAccuracy: false, timeout: 1e4, maximumAge: 6e4 }
+    );
+  };
+  const handleMapKeyDown = (event) => {
+    if (!coordinates || !["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].includes(event.key)) return;
+    event.preventDefault();
+    const step = event.shiftKey ? 1e-3 : 1e-4;
+    const latitudeDelta = event.key === "ArrowUp" ? step : event.key === "ArrowDown" ? -step : 0;
+    const longitudeDelta = event.key === "ArrowRight" ? step : event.key === "ArrowLeft" ? -step : 0;
+    updateCoordinates(moveCoordinates(coordinates, latitudeDelta, longitudeDelta));
+  };
+  const clearPin = () => {
+    reverseAbort.current?.abort();
+    reverseRequest.current += 1;
+    setReverseLoading(false);
+    setDraft((current) => ({ ...current, latitude: null, longitude: null }));
+    setAnnouncement(labels.clearedAnnouncement);
+  };
+  const confirm = () => {
+    const normalized = normalizeLocationValue(draft);
+    if ((draft.latitude !== null || draft.longitude !== null) && !isCompleteCoordinatePair(draft)) return;
+    onConfirm(normalized);
+    onOpenChange(false);
+  };
+  const pending = providerLoading || searchLoading || reverseLoading;
+  const invalidPair = (draft.latitude !== null || draft.longitude !== null) && !isCompleteCoordinatePair(draft);
+  return /* @__PURE__ */ jsx(Dialog, { open, onOpenChange: (next) => next ? onOpenChange(true) : close(), children: /* @__PURE__ */ jsxs(
+    DialogContent,
+    {
+      padding: "none",
+      hideClose: true,
+      className: cn(
+        "nlocation-dialog !flex flex-col gap-0 inset-0 top-0 left-0 h-dvh max-h-dvh max-w-none translate-x-0 translate-y-0 rounded-none sm:inset-auto sm:top-1/2 sm:left-1/2 sm:h-[min(46rem,calc(100dvh-2rem))] sm:max-h-[calc(100dvh-2rem)] sm:max-w-4xl sm:-translate-x-1/2 sm:-translate-y-1/2 sm:rounded-lg",
+        classNames?.dialog
+      ),
+      onOpenAutoFocus: (event) => {
+        event.preventDefault();
+        queueMicrotask(() => (provider.geocoder ? searchInputRef.current : mapInstructionRef.current)?.focus());
+      },
+      children: [
+        /* @__PURE__ */ jsxs(DialogHeader, { className: "shrink-0 flex-row items-start justify-between gap-4 border-b border-border px-4 py-4 text-start sm:px-6", children: [
+          /* @__PURE__ */ jsxs("div", { className: "min-w-0 space-y-1", children: [
+            /* @__PURE__ */ jsx(DialogTitle, { children: labels.dialogTitle }),
+            /* @__PURE__ */ jsx(DialogDescription, { children: labels.dialogDescription })
+          ] }),
+          /* @__PURE__ */ jsx(DialogClose, { asChild: true, children: /* @__PURE__ */ jsx(IconButton, { "aria-label": labels.close, variant: "ghost", onClick: discard, children: /* @__PURE__ */ jsx(X, {}) }) })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex min-h-0 flex-1 flex-col gap-3 overflow-y-auto px-4 py-3 sm:px-6", children: [
+          provider.geocoder && /* @__PURE__ */ jsxs("form", { className: cn("relative shrink-0", classNames?.search), onSubmit: (event) => {
+            event.preventDefault();
+            void performSearch(query);
+          }, children: [
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                ref: searchInputRef,
+                value: query,
+                onChange: (event) => {
+                  searchAbort.current?.abort();
+                  searchAbort.current = null;
+                  setSearchLoading(false);
+                  setQuery(event.target.value);
+                  setResults([]);
+                  setSearchError(false);
+                  setSearchPerformed(false);
+                },
+                placeholder: labels.searchPlaceholder,
+                className: "pe-24",
+                autoComplete: "off"
+              }
+            ),
+            /* @__PURE__ */ jsx(Button, { type: "submit", size: "sm", variant: "ghost", className: "absolute end-1 top-1 h-7", disabled: searchLoading || query.trim().length < 2, leftIcon: Search, children: searchLoading ? labels.searching : labels.search }),
+            (results.length > 0 || searchError || searchPerformed) && /* @__PURE__ */ jsx("div", { className: "absolute inset-x-0 top-full z-[60] mt-1 overflow-hidden rounded-md border border-border bg-popover text-popover-foreground shadow-md", children: searchError ? /* @__PURE__ */ jsx("p", { className: "p-3 text-sm text-destructive", children: labels.searchError }) : results.length === 0 ? /* @__PURE__ */ jsx("p", { className: "p-3 text-sm text-muted-foreground", children: labels.searchEmpty }) : /* @__PURE__ */ jsx("div", { role: "listbox", "aria-label": labels.searchPlaceholder, className: "max-h-52 overflow-y-auto p-1", children: results.map((candidate) => /* @__PURE__ */ jsxs("button", { type: "button", role: "option", "aria-selected": "false", className: "flex w-full flex-col rounded-sm px-3 py-2 text-start text-sm hover:bg-accent focus-visible:bg-accent focus-visible:outline-none", onClick: () => void selectCandidate(candidate), children: [
+              /* @__PURE__ */ jsx("span", { className: "font-medium", children: candidate.label }),
+              candidate.description && /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: candidate.description })
+            ] }, candidate.id)) }) })
+          ] }),
+          /* @__PURE__ */ jsxs(
+            "div",
+            {
+              ref: mapInstructionRef,
+              tabIndex: 0,
+              role: "application",
+              "aria-label": labels.mapInstructions,
+              onKeyDown: handleMapKeyDown,
+              className: cn("relative min-h-72 flex-1 overflow-hidden rounded-lg border border-border bg-muted focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring", classNames?.map),
+              children: [
+                AdapterMap ? /* @__PURE__ */ jsx(React12__default.Suspense, { fallback: /* @__PURE__ */ jsx(NLoadingState, { surface: "panel", label: labels.loading, className: "h-full min-h-72" }), children: /* @__PURE__ */ jsx(
+                  AdapterMap,
+                  {
+                    value: coordinates,
+                    initialCenter: provider.defaultCenter,
+                    initialZoom: provider.defaultZoom,
+                    onChange: updateCoordinates,
+                    onReady: () => {
+                      setProviderLoading(false);
+                      setProviderError(null);
+                      setAnnouncement(labels.readyAnnouncement);
+                    },
+                    onLoadingChange: setProviderLoading,
+                    onError: () => {
+                      setProviderLoading(false);
+                      setProviderError(labels.providerError);
+                      setAnnouncement(labels.providerError);
+                    },
+                    onControlsReady: setMapControls,
+                    reducedMotion: typeof window !== "undefined" && window.matchMedia?.("(prefers-reduced-motion: reduce)").matches,
+                    className: "h-full min-h-72 w-full"
+                  },
+                  providerAttempt
+                ) }) : /* @__PURE__ */ jsx("div", { className: "flex h-full min-h-72 items-center justify-center p-6 text-center text-sm text-muted-foreground", children: provider.unavailableReason || labels.unavailable }),
+                providerError && /* @__PURE__ */ jsxs("div", { className: "absolute inset-0 z-20 flex flex-col items-center justify-center gap-3 bg-background/90 p-6 text-center", children: [
+                  /* @__PURE__ */ jsx("p", { role: "alert", className: "text-sm text-destructive", children: providerError }),
+                  /* @__PURE__ */ jsx(Button, { type: "button", variant: "outline", onClick: () => {
+                    setProviderError(null);
+                    setProviderAttempt((n) => n + 1);
+                  }, children: labels.retry })
+                ] }),
+                /* @__PURE__ */ jsxs("div", { className: "absolute bottom-3 end-3 z-10 flex flex-col gap-1 rounded-md border border-border bg-card/95 p-1 shadow-sm", children: [
+                  /* @__PURE__ */ jsx(IconButton, { "aria-label": labels.zoomIn, onClick: () => mapControls?.zoomIn(), disabled: !mapControls, children: /* @__PURE__ */ jsx(Plus, {}) }),
+                  /* @__PURE__ */ jsx(IconButton, { "aria-label": labels.zoomOut, onClick: () => mapControls?.zoomOut(), disabled: !mapControls, children: /* @__PURE__ */ jsx(Minus, {}) }),
+                  /* @__PURE__ */ jsx(IconButton, { "aria-label": labels.currentLocation, onClick: useCurrentLocation, disabled: !AdapterMap || pending, children: /* @__PURE__ */ jsx(Crosshair, {}) })
+                ] })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs("label", { className: "grid shrink-0 gap-1 text-sm font-medium", children: [
+            labels.dialogTitle,
+            /* @__PURE__ */ jsxs("div", { className: "relative", children: [
+              /* @__PURE__ */ jsx(
+                Input,
+                {
+                  value: draft.address,
+                  "aria-busy": reverseLoading,
+                  className: reverseLoading ? "pe-10" : void 0,
+                  onChange: (event) => {
+                    reverseAbort.current?.abort();
+                    reverseRequest.current += 1;
+                    setReverseLoading(false);
+                    setDraft((current) => ({ ...current, address: event.target.value }));
+                  }
+                }
+              ),
+              reverseLoading && /* @__PURE__ */ jsx("span", { role: "status", "aria-label": labels.findingAddress, className: "pointer-events-none absolute inset-y-0 end-3 flex items-center text-muted-foreground", children: /* @__PURE__ */ jsx(LoaderCircle, { "aria-hidden": "true", className: "h-4 w-4 animate-spin motion-reduce:animate-none" }) })
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "sr-only", "aria-live": "polite", "aria-atomic": "true", children: announcement }),
+        /* @__PURE__ */ jsxs(DialogFooter, { className: cn("shrink-0 border-t border-border bg-card px-4 py-3 pb-[max(.75rem,env(safe-area-inset-bottom))] sm:px-6", classNames?.footer), children: [
+          /* @__PURE__ */ jsx(Button, { type: "button", variant: "ghost", className: "sm:me-auto", onClick: clearPin, disabled: !coordinates || pending, leftIcon: Trash2, children: labels.clearPin }),
+          /* @__PURE__ */ jsx(Button, { type: "button", variant: "outline", onClick: close, children: labels.cancel }),
+          /* @__PURE__ */ jsx(Button, { type: "button", onClick: confirm, disabled: pending || invalidPair, leftIcon: Check, children: labels.confirm })
+        ] })
+      ]
+    }
+  ) });
+}
+var NLocationInput = React12__default.forwardRef(function NLocationInput2({
+  value,
+  onChange,
+  labels: labelOverrides,
+  classNames,
+  status = "default",
+  bordered,
+  className,
+  disabled = false,
+  readOnly = false,
+  ...inputProps
+}, ref) {
+  const provider = useNLocationProvider();
+  const labels = React12__default.useMemo(() => ({ ...provider.labels, ...labelOverrides }), [labelOverrides, provider.labels]);
+  const normalized = normalizeLocationValue(value);
+  const hasPin = isCompleteCoordinatePair(normalized);
+  const [open, setOpen] = React12__default.useState(false);
+  const [pinnedAddress, setPinnedAddress] = React12__default.useState(() => hasPin ? normalized.address : "");
+  const coordinateKey = hasPin ? `${normalized.latitude}:${normalized.longitude}` : "";
+  const pinnedCoordinateKey = React12__default.useRef(coordinateKey);
+  React12__default.useEffect(() => {
+    if (coordinateKey === pinnedCoordinateKey.current) return;
+    pinnedCoordinateKey.current = coordinateKey;
+    setPinnedAddress(hasPin ? normalized.address : "");
+  }, [coordinateKey, hasPin, normalized.address]);
+  const changedAfterPin = hasPin && pinnedAddress !== "" && pinnedAddress !== normalized.address;
+  const mapAvailable = Boolean(provider.adapter);
+  const stateLabel = !mapAvailable ? provider.unavailableReason || labels.unavailable : changedAfterPin ? labels.changedAfterPin : hasPin ? labels.selected : labels.notSelected;
+  const StateIcon = !mapAvailable || changedAfterPin ? CircleAlert : hasPin ? MapPinCheck : MapPin;
+  return /* @__PURE__ */ jsxs("div", { className: cn("grid gap-1.5", classNames?.root), children: [
+    /* @__PURE__ */ jsxs(BaseInput, { status, bordered, disabled, className: cn("gap-2", classNames?.input, className), children: [
+      /* @__PURE__ */ jsx(
+        Input,
+        {
+          ...inputProps,
+          ref,
+          value: normalized.address,
+          onChange: (event) => onChange({ ...normalized, address: event.target.value }),
+          disabled,
+          readOnly,
+          className: "h-auto flex-1 border-0 bg-transparent p-0 shadow-none focus-visible:ring-0"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        IconButton,
+        {
+          "aria-label": labels.openMap,
+          variant: "ghost",
+          size: "md",
+          disabled: disabled || readOnly || !mapAvailable,
+          onClick: () => setOpen(true),
+          children: /* @__PURE__ */ jsx(MapPin, {})
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("p", { className: cn("flex items-center gap-1.5 text-xs text-muted-foreground", changedAfterPin && "text-warning", classNames?.status), children: [
+      /* @__PURE__ */ jsx(StateIcon, { "aria-hidden": "true", className: "h-3.5 w-3.5 shrink-0" }),
+      stateLabel
+    ] }),
+    /* @__PURE__ */ jsx(
+      NLocationDialog,
+      {
+        open,
+        value: normalized,
+        onOpenChange: setOpen,
+        onConfirm: (next) => {
+          setPinnedAddress(next.latitude === null ? "" : next.address);
+          onChange(next);
+        },
+        labels: labelOverrides,
+        classNames
+      }
+    )
+  ] });
+});
+function Label({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    LabelPrimitive.Root,
+    {
+      "data-slot": "label",
+      className: cn("flex items-center gap-2 text-sm leading-none font-medium text-foreground select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50", className),
+      ...props
+    }
+  );
+}
+var Form = FormProvider;
+var FormFieldContext = React12.createContext({});
+var FormField = ({ ...props }) => /* @__PURE__ */ jsx(FormFieldContext.Provider, { value: { name: props.name }, children: /* @__PURE__ */ jsx(Controller, { ...props }) });
+var useFormField = () => {
+  const fieldContext = React12.useContext(FormFieldContext);
+  const itemContext = React12.useContext(FormItemContext);
+  const { getFieldState, formState } = useFormContext();
+  const fieldState = getFieldState(fieldContext.name, formState);
+  if (!fieldContext) throw new Error("useFormField should be used within <FormField>");
+  const { id } = itemContext;
+  return { id, name: fieldContext.name, formItemId: `${id}-form-item`, formDescriptionId: `${id}-form-item-description`, formMessageId: `${id}-form-item-message`, ...fieldState };
+};
+var FormItemContext = React12.createContext({});
+function FormItem({ className, ...props }) {
+  const id = React12.useId();
+  return /* @__PURE__ */ jsx(FormItemContext.Provider, { value: { id }, children: /* @__PURE__ */ jsx("div", { "data-slot": "form-item", className: cn("grid gap-2", className), ...props }) });
+}
+function FormLabel({ className, ...props }) {
+  const { error, formItemId } = useFormField();
+  return /* @__PURE__ */ jsx(Label, { "data-slot": "form-label", "data-error": !!error, className: cn("data-[error=true]:text-destructive", className), htmlFor: formItemId, ...props });
+}
+function FormControl({ ...props }) {
+  const { error, formItemId, formDescriptionId, formMessageId } = useFormField();
+  return /* @__PURE__ */ jsx(Slot, { "data-slot": "form-control", id: formItemId, "aria-describedby": !error ? `${formDescriptionId}` : `${formDescriptionId} ${formMessageId}`, "aria-invalid": !!error, ...props });
+}
+function FormDescription({ className, ...props }) {
+  const { formDescriptionId } = useFormField();
+  return /* @__PURE__ */ jsx("p", { "data-slot": "form-description", id: formDescriptionId, className: cn("text-muted-foreground text-[0.8rem]", className), ...props });
+}
+function FormMessage({ className, children, ...props }) {
+  const { error, formMessageId } = useFormField();
+  const findMessage = (value) => {
+    if (!value || typeof value !== "object") return void 0;
+    if ("message" in value && typeof value.message === "string") return value.message;
+    for (const child of Object.values(value)) {
+      const nested = findMessage(child);
+      if (nested) return nested;
+    }
+  };
+  const body = error ? findMessage(error) : children;
+  if (!body) return null;
+  return /* @__PURE__ */ jsx("p", { "data-slot": "form-message", id: formMessageId, className: cn("text-destructive text-[0.8rem] font-medium", className), ...props, children: body });
+}
+var VARIANT_PRESETS = {
+  default: {
+    item: "flex flex-col w-full",
+    label: "text-foreground flex items-center gap-2",
+    input: "",
+    description: "",
+    error: ""
+  },
+  studio: {
+    item: "space-y-1.5 w-full",
+    label: "text-[11px] uppercase tracking-[0.16em] text-muted-foreground flex items-center gap-2",
+    input: "h-10 bg-card",
+    description: "text-xs text-muted-foreground",
+    error: "text-xs text-destructive"
+  },
+  compact: {
+    item: "flex flex-col w-full gap-1",
+    label: "text-xs text-foreground flex items-center gap-2",
+    input: "h-8 text-sm",
+    description: "text-xs",
+    error: "text-xs"
+  }
+};
+var VariantContext = createContext({ variant: "default" });
+var VariantProvider = ({ variant = "default", bordered, children }) => /* @__PURE__ */ jsx(VariantContext.Provider, { value: { variant, bordered }, children });
+var useVariant = () => useContext(VariantContext).variant;
+var useBordered = () => useContext(VariantContext).bordered;
+var useVariantPreset = () => VARIANT_PRESETS[useContext(VariantContext).variant];
+var PrefixContext = createContext(void 0);
+var PrefixProvider = ({ prefix, children }) => /* @__PURE__ */ jsx(PrefixContext.Provider, { value: prefix, children });
+var usePrefix = () => useContext(PrefixContext);
+var backgrounds = {
+  card: "!bg-card",
+  background: "!bg-background",
+  secondary: "!bg-secondary",
+  muted: "!bg-muted",
+  transparent: "!bg-transparent"
+};
+function nestedMessage(error) {
+  if (!error || typeof error !== "object") return void 0;
+  if ("message" in error && typeof error.message === "string") return error.message;
+  for (const child of Object.values(error)) {
+    const message = nestedMessage(child);
+    if (message) return message;
+  }
+}
+function FormLocationInput({ name, formLabel, formDescription, required = false, disabled = false, readOnly = false, hidden = false, background, classNames, onChange: consumerOnChange, ...props }) {
+  const { control } = useFormContext();
+  const prefix = usePrefix();
+  const preset = useVariantPreset();
+  const bordered = useBordered();
+  const fieldName = prefix ? `${prefix}.${name}` : name;
+  return /* @__PURE__ */ jsx(FormField, { control, name: fieldName, render: ({ field, fieldState }) => {
+    const message = nestedMessage(fieldState.error);
+    const handleChange = (next) => {
+      field.onChange(next);
+      consumerOnChange?.(next);
+    };
+    return /* @__PURE__ */ jsxs(FormItem, { className: cn(preset.item, classNames?.item, hidden && "hidden"), children: [
+      formLabel && /* @__PURE__ */ jsxs(FormLabel, { className: cn(preset.label, classNames?.label), children: [
+        formLabel,
+        required && !disabled && !readOnly && /* @__PURE__ */ jsx("span", { className: "ms-1 text-destructive", children: "*" })
+      ] }),
+      /* @__PURE__ */ jsx(FormControl, { children: /* @__PURE__ */ jsx(
+        NLocationInput,
+        {
+          ...props,
+          name: field.name,
+          ref: field.ref,
+          value: field.value ?? DEFAULT_LOCATION_VALUE,
+          onChange: handleChange,
+          onBlur: field.onBlur,
+          disabled,
+          readOnly,
+          bordered,
+          status: fieldState.error ? "error" : "default",
+          className: cn(background && backgrounds[background], classNames?.input),
+          classNames
+        }
+      ) }),
+      !fieldState.error && !disabled && !readOnly && formDescription && /* @__PURE__ */ jsx(FormDescription, { className: cn(preset.description, classNames?.description), children: formDescription }),
+      message ? /* @__PURE__ */ jsx(FormMessage, { className: cn(preset.error, classNames?.error), children: message }) : null
+    ] });
+  } });
+}
+
+export { BaseInput, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, Form, FormControl, FormDescription, FormField, FormItem, FormLabel, FormLocationInput, FormMessage, IconButton, Input, Label, NConfirmDialog, NDeleteDialog, NDeleteDialogContent, NDialog, NDialogDescription, NDialogHeader, NDialogPrimaryButton, NDialogSecondaryButton, NLocationDialog, NLocationInput, NLocationProvider, NMultiDialog, NPageHeader, NPageHeaderActions, NPageHeaderCompactActions, NPageHeaderFilters, NPageHeaderTop, NPortalScopeProvider, NSheet, NSidebarProvider, PrefixProvider, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, VariantProvider, createDialogStore, dialogVariants, focusRingClasses, focusRingWithinClasses, isCompleteCoordinatePair, normalizeLocationValue, useBordered, useDialog, useDialogStore, useFormField, useNLocationProvider, useNPortalScope, useNSidebar, usePrefix, useVariant, useVariantPreset };