@signiphi/page-assembly 0.2.0-beta.1

package/dist/index.js

@@ -0,0 +1,1872 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React7 = require('react');
+var reactDnd = require('react-dnd');
+var reactDndHtml5Backend = require('react-dnd-html5-backend');
+var lucideReact = require('lucide-react');
+var reactSlot = require('@radix-ui/react-slot');
+var classVarianceAuthority = require('class-variance-authority');
+var clsx = require('clsx');
+var tailwindMerge = require('tailwind-merge');
+var jsxRuntime = require('react/jsx-runtime');
+var LabelPrimitive = require('@radix-ui/react-label');
+var SelectPrimitive = require('@radix-ui/react-select');
+var AlertDialogPrimitive = require('@radix-ui/react-alert-dialog');
+var DropdownMenuPrimitive = require('@radix-ui/react-dropdown-menu');
+var TooltipPrimitive = require('@radix-ui/react-tooltip');
+var pdfjsLib = require('pdfjs-dist');
+var pdfLib = require('pdf-lib');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React7__namespace = /*#__PURE__*/_interopNamespace(React7);
+var LabelPrimitive__namespace = /*#__PURE__*/_interopNamespace(LabelPrimitive);
+var SelectPrimitive__namespace = /*#__PURE__*/_interopNamespace(SelectPrimitive);
+var AlertDialogPrimitive__namespace = /*#__PURE__*/_interopNamespace(AlertDialogPrimitive);
+var DropdownMenuPrimitive__namespace = /*#__PURE__*/_interopNamespace(DropdownMenuPrimitive);
+var TooltipPrimitive__namespace = /*#__PURE__*/_interopNamespace(TooltipPrimitive);
+var pdfjsLib__namespace = /*#__PURE__*/_interopNamespace(pdfjsLib);
+
+// src/components/PageAssembler.tsx
+function cn(...inputs) {
+  return tailwindMerge.twMerge(clsx.clsx(inputs));
+}
+var buttonVariants = classVarianceAuthority.cva(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+        outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline"
+      },
+      size: {
+        default: "h-10 px-4 py-2",
+        sm: "h-9 rounded-md px-3",
+        lg: "h-11 md:h-12 rounded-md px-8",
+        icon: "h-10 w-10"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+var Button = React7__namespace.forwardRef(
+  ({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Comp = asChild ? reactSlot.Slot : "button";
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Comp,
+      {
+        className: cn(buttonVariants({ variant, size }), className),
+        ref,
+        ...props
+      }
+    );
+  }
+);
+Button.displayName = "Button";
+var Card = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  "div",
+  {
+    ref,
+    className: cn(
+      "rounded-lg bg-card text-card-foreground shadow-sm",
+      className
+    ),
+    style: {
+      border: "1px solid hsl(var(--xpa-border))",
+      ...props.style || {}
+    },
+    ...props
+  }
+));
+Card.displayName = "Card";
+var CardHeader = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  "div",
+  {
+    ref,
+    className: cn("flex flex-col space-y-1.5 p-6", className),
+    ...props
+  }
+));
+CardHeader.displayName = "CardHeader";
+var CardTitle = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  "h3",
+  {
+    ref,
+    className: cn(
+      "text-2xl font-semibold leading-none tracking-tight",
+      className
+    ),
+    ...props
+  }
+));
+CardTitle.displayName = "CardTitle";
+var CardDescription = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  "p",
+  {
+    ref,
+    className: cn("text-sm text-muted-foreground", className),
+    ...props
+  }
+));
+CardDescription.displayName = "CardDescription";
+var CardContent = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: cn("p-6 pt-0", className), ...props }));
+CardContent.displayName = "CardContent";
+var CardFooter = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  "div",
+  {
+    ref,
+    className: cn("flex items-center p-6 pt-0", className),
+    ...props
+  }
+));
+CardFooter.displayName = "CardFooter";
+var Input = React7__namespace.forwardRef(
+  ({ className, type, ...props }, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        type,
+        className: cn(
+          "flex h-10 w-full rounded-md border-2 border-input bg-background px-3 py-2 text-sm file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground transition-all duration-200 focus:outline-none focus:border-primary focus:ring-0 focus:shadow-[0_0_0_3px_rgba(0,153,205,0.15)] focus-visible:outline-none focus-visible:border-primary focus-visible:ring-0 focus-visible:shadow-[0_0_0_3px_rgba(0,153,205,0.15)] disabled:cursor-not-allowed disabled:opacity-50",
+          className
+        ),
+        ref,
+        ...props
+      }
+    );
+  }
+);
+Input.displayName = "Input";
+var labelVariants = classVarianceAuthority.cva(
+  "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
+);
+var Label = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  LabelPrimitive__namespace.Root,
+  {
+    ref,
+    className: cn(labelVariants(), className),
+    ...props
+  }
+));
+Label.displayName = LabelPrimitive__namespace.Root.displayName;
+var badgeVariants = classVarianceAuthority.cva(
+  "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
+  {
+    variants: {
+      variant: {
+        default: "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
+        secondary: "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        destructive: "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
+        outline: "text-foreground"
+      }
+    },
+    defaultVariants: {
+      variant: "default"
+    }
+  }
+);
+function Badge({ className, variant, ...props }) {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn(badgeVariants({ variant }), className), ...props });
+}
+var Select = SelectPrimitive__namespace.Root;
+var SelectValue = SelectPrimitive__namespace.Value;
+var SelectTrigger = React7__namespace.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsxs(
+  SelectPrimitive__namespace.Trigger,
+  {
+    ref,
+    className: cn(
+      "flex h-10 w-full items-center justify-between rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1",
+      className
+    ),
+    ...props,
+    children: [
+      children,
+      /* @__PURE__ */ jsxRuntime.jsx(SelectPrimitive__namespace.Icon, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronDown, { className: "h-4 w-4 opacity-50" }) })
+    ]
+  }
+));
+SelectTrigger.displayName = SelectPrimitive__namespace.Trigger.displayName;
+var SelectScrollUpButton = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  SelectPrimitive__namespace.ScrollUpButton,
+  {
+    ref,
+    className: cn(
+      "flex cursor-default items-center justify-center py-1",
+      className
+    ),
+    ...props,
+    children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronUp, { className: "h-4 w-4" })
+  }
+));
+SelectScrollUpButton.displayName = SelectPrimitive__namespace.ScrollUpButton.displayName;
+var SelectScrollDownButton = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  SelectPrimitive__namespace.ScrollDownButton,
+  {
+    ref,
+    className: cn(
+      "flex cursor-default items-center justify-center py-1",
+      className
+    ),
+    ...props,
+    children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronDown, { className: "h-4 w-4" })
+  }
+));
+SelectScrollDownButton.displayName = SelectPrimitive__namespace.ScrollDownButton.displayName;
+var SelectContent = React7__namespace.forwardRef(({ className, children, position = "popper", ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(SelectPrimitive__namespace.Portal, { children: /* @__PURE__ */ jsxRuntime.jsxs(
+  SelectPrimitive__namespace.Content,
+  {
+    ref,
+    className: cn(
+      "relative max-h-96 min-w-[12rem] overflow-hidden 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 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+      position === "popper" && "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
+      className
+    ),
+    position,
+    style: {
+      zIndex: 99999,
+      backgroundColor: "#ffffff",
+      border: "1px solid #e2e8f0",
+      borderRadius: "0.5rem",
+      boxShadow: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)",
+      marginTop: "4px"
+    },
+    ...props,
+    children: [
+      /* @__PURE__ */ jsxRuntime.jsx(SelectScrollUpButton, {}),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        SelectPrimitive__namespace.Viewport,
+        {
+          className: cn(
+            position === "popper" && "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"
+          ),
+          style: { padding: "6px" },
+          children
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(SelectScrollDownButton, {})
+    ]
+  }
+) }));
+SelectContent.displayName = SelectPrimitive__namespace.Content.displayName;
+var SelectLabel = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  SelectPrimitive__namespace.Label,
+  {
+    ref,
+    className: cn("py-1.5 pl-8 pr-2 text-sm font-semibold", className),
+    ...props
+  }
+));
+SelectLabel.displayName = SelectPrimitive__namespace.Label.displayName;
+var SelectItem = React7__namespace.forwardRef(({ className, children, ...props }, ref) => {
+  const [isHovered, setIsHovered] = React7__namespace.useState(false);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    SelectPrimitive__namespace.Item,
+    {
+      ref,
+      className: cn(
+        "relative flex w-full cursor-pointer select-none items-center outline-none transition-colors data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+        className
+      ),
+      style: {
+        backgroundColor: isHovered ? "#f1f5f9" : "transparent",
+        color: "#1e293b",
+        padding: "8px 12px",
+        borderRadius: "6px",
+        fontSize: "14px",
+        marginBottom: "2px"
+      },
+      onMouseEnter: () => setIsHovered(true),
+      onMouseLeave: () => setIsHovered(false),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(SelectPrimitive__namespace.ItemText, { children }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          SelectPrimitive__namespace.ItemIndicator,
+          {
+            style: {
+              marginLeft: "auto",
+              paddingLeft: "8px",
+              color: "#0099cd"
+            },
+            children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { className: "h-4 w-4" })
+          }
+        )
+      ]
+    }
+  );
+});
+SelectItem.displayName = SelectPrimitive__namespace.Item.displayName;
+var SelectSeparator = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  SelectPrimitive__namespace.Separator,
+  {
+    ref,
+    className: cn("-mx-1 my-1 h-px bg-muted", className),
+    ...props
+  }
+));
+SelectSeparator.displayName = SelectPrimitive__namespace.Separator.displayName;
+var AlertDialog = AlertDialogPrimitive__namespace.Root;
+var AlertDialogPortal = AlertDialogPrimitive__namespace.Portal;
+var AlertDialogOverlay = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  AlertDialogPrimitive__namespace.Overlay,
+  {
+    className: cn(
+      "fixed inset-0 z-[9998] bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+      className
+    ),
+    ...props,
+    ref
+  }
+));
+AlertDialogOverlay.displayName = AlertDialogPrimitive__namespace.Overlay.displayName;
+var AlertDialogContent = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsxs(AlertDialogPortal, { container: document.querySelector(".signiphi-page-assembly"), children: [
+  /* @__PURE__ */ jsxRuntime.jsx(AlertDialogOverlay, {}),
+  /* @__PURE__ */ jsxRuntime.jsx(
+    AlertDialogPrimitive__namespace.Content,
+    {
+      ref,
+      className: cn(
+        "fixed left-[50%] top-[50%] z-[9999] grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 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 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
+        className
+      ),
+      ...props
+    }
+  )
+] }));
+AlertDialogContent.displayName = AlertDialogPrimitive__namespace.Content.displayName;
+var AlertDialogHeader = ({
+  className,
+  ...props
+}) => /* @__PURE__ */ jsxRuntime.jsx(
+  "div",
+  {
+    className: cn(
+      "flex flex-col space-y-2 text-center sm:text-left",
+      className
+    ),
+    ...props
+  }
+);
+AlertDialogHeader.displayName = "AlertDialogHeader";
+var AlertDialogFooter = ({
+  className,
+  ...props
+}) => /* @__PURE__ */ jsxRuntime.jsx(
+  "div",
+  {
+    className: cn(
+      "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
+      className
+    ),
+    ...props
+  }
+);
+AlertDialogFooter.displayName = "AlertDialogFooter";
+var AlertDialogTitle = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  AlertDialogPrimitive__namespace.Title,
+  {
+    ref,
+    className: cn("text-lg font-semibold", className),
+    ...props
+  }
+));
+AlertDialogTitle.displayName = AlertDialogPrimitive__namespace.Title.displayName;
+var AlertDialogDescription = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  AlertDialogPrimitive__namespace.Description,
+  {
+    ref,
+    className: cn("text-sm text-muted-foreground", className),
+    ...props
+  }
+));
+AlertDialogDescription.displayName = AlertDialogPrimitive__namespace.Description.displayName;
+var AlertDialogAction = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  AlertDialogPrimitive__namespace.Action,
+  {
+    ref,
+    className: cn(buttonVariants(), className),
+    ...props
+  }
+));
+AlertDialogAction.displayName = AlertDialogPrimitive__namespace.Action.displayName;
+var AlertDialogCancel = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  AlertDialogPrimitive__namespace.Cancel,
+  {
+    ref,
+    className: cn(
+      buttonVariants({ variant: "outline" }),
+      "mt-2 sm:mt-0",
+      className
+    ),
+    ...props
+  }
+));
+AlertDialogCancel.displayName = AlertDialogPrimitive__namespace.Cancel.displayName;
+var DropdownMenu = DropdownMenuPrimitive__namespace.Root;
+var DropdownMenuTrigger = DropdownMenuPrimitive__namespace.Trigger;
+var DropdownMenuSubTrigger = React7__namespace.forwardRef(({ className, inset, children, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsxs(
+  DropdownMenuPrimitive__namespace.SubTrigger,
+  {
+    ref,
+    className: cn(
+      "flex cursor-default gap-2 select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent data-[state=open]:bg-accent [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
+      inset && "pl-8",
+      className
+    ),
+    ...props,
+    children: [
+      children,
+      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronRight, { className: "ml-auto" })
+    ]
+  }
+));
+DropdownMenuSubTrigger.displayName = DropdownMenuPrimitive__namespace.SubTrigger.displayName;
+var DropdownMenuSubContent = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  DropdownMenuPrimitive__namespace.SubContent,
+  {
+    ref,
+    className: cn(
+      "z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-lg 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 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+      className
+    ),
+    ...props
+  }
+));
+DropdownMenuSubContent.displayName = DropdownMenuPrimitive__namespace.SubContent.displayName;
+var DropdownMenuContent = React7__namespace.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(DropdownMenuPrimitive__namespace.Portal, { children: /* @__PURE__ */ jsxRuntime.jsx(
+  DropdownMenuPrimitive__namespace.Content,
+  {
+    ref,
+    sideOffset,
+    className: cn(
+      "min-w-[12rem] overflow-hidden 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 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+      className
+    ),
+    style: {
+      zIndex: 99999,
+      backgroundColor: "#ffffff",
+      border: "1px solid #e2e8f0",
+      borderRadius: "0.5rem",
+      boxShadow: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)",
+      padding: "6px"
+    },
+    ...props
+  }
+) }));
+DropdownMenuContent.displayName = DropdownMenuPrimitive__namespace.Content.displayName;
+var DropdownMenuItem = React7__namespace.forwardRef(({ className, inset, ...props }, ref) => {
+  const [isHovered, setIsHovered] = React7__namespace.useState(false);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    DropdownMenuPrimitive__namespace.Item,
+    {
+      ref,
+      className: cn(
+        "relative flex cursor-pointer select-none items-center gap-2 outline-none transition-colors data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&>svg]:size-4 [&>svg]:shrink-0",
+        inset && "pl-8",
+        className
+      ),
+      style: {
+        backgroundColor: isHovered ? "#f1f5f9" : "transparent",
+        color: "#1e293b",
+        padding: "8px 12px",
+        borderRadius: "6px",
+        fontSize: "14px",
+        marginBottom: "2px"
+      },
+      onMouseEnter: () => setIsHovered(true),
+      onMouseLeave: () => setIsHovered(false),
+      ...props
+    }
+  );
+});
+DropdownMenuItem.displayName = DropdownMenuPrimitive__namespace.Item.displayName;
+var DropdownMenuCheckboxItem = React7__namespace.forwardRef(({ className, children, checked, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsxs(
+  DropdownMenuPrimitive__namespace.CheckboxItem,
+  {
+    ref,
+    className: cn(
+      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      className
+    ),
+    checked,
+    ...props,
+    children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(DropdownMenuPrimitive__namespace.ItemIndicator, { children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { className: "h-4 w-4" }) }) }),
+      children
+    ]
+  }
+));
+DropdownMenuCheckboxItem.displayName = DropdownMenuPrimitive__namespace.CheckboxItem.displayName;
+var DropdownMenuRadioItem = React7__namespace.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsxs(
+  DropdownMenuPrimitive__namespace.RadioItem,
+  {
+    ref,
+    className: cn(
+      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      className
+    ),
+    ...props,
+    children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(DropdownMenuPrimitive__namespace.ItemIndicator, { children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Circle, { className: "h-2 w-2 fill-current" }) }) }),
+      children
+    ]
+  }
+));
+DropdownMenuRadioItem.displayName = DropdownMenuPrimitive__namespace.RadioItem.displayName;
+var DropdownMenuLabel = React7__namespace.forwardRef(({ className, inset, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  DropdownMenuPrimitive__namespace.Label,
+  {
+    ref,
+    className: cn(
+      "px-2 py-1.5 text-sm font-semibold",
+      inset && "pl-8",
+      className
+    ),
+    ...props
+  }
+));
+DropdownMenuLabel.displayName = DropdownMenuPrimitive__namespace.Label.displayName;
+var DropdownMenuSeparator = React7__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  DropdownMenuPrimitive__namespace.Separator,
+  {
+    ref,
+    className: cn("-mx-1 my-1 h-px bg-muted", className),
+    ...props
+  }
+));
+DropdownMenuSeparator.displayName = DropdownMenuPrimitive__namespace.Separator.displayName;
+var TooltipProvider = TooltipPrimitive__namespace.Provider;
+var Tooltip = TooltipPrimitive__namespace.Root;
+var TooltipTrigger = TooltipPrimitive__namespace.Trigger;
+var TooltipContent = React7__namespace.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  TooltipPrimitive__namespace.Content,
+  {
+    ref,
+    sideOffset,
+    className: cn(
+      "z-50 overflow-hidden rounded-md border bg-popover px-3 py-1.5 text-sm text-popover-foreground shadow-md animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+      className
+    ),
+    ...props
+  }
+));
+TooltipContent.displayName = TooltipPrimitive__namespace.Content.displayName;
+if (typeof window !== "undefined") {
+  pdfjsLib__namespace.GlobalWorkerOptions.workerSrc = "/pdfjs/build/pdf.worker.mjs";
+}
+async function pdfToImages(pdfBytes, options) {
+  try {
+    const header = new TextDecoder().decode(pdfBytes.slice(0, 10));
+    if (!header.startsWith("%PDF-")) {
+      console.error("Invalid PDF: Does not start with %PDF- header");
+      throw new Error("Invalid PDF format: Missing PDF header");
+    }
+    if (typeof window !== "undefined") {
+      pdfjsLib__namespace.GlobalWorkerOptions.workerSrc = "/pdfjs/build/pdf.worker.mjs";
+    }
+    const loadingTask = pdfjsLib__namespace.getDocument({
+      data: pdfBytes,
+      verbosity: 0
+    });
+    const pdfDoc = await loadingTask.promise;
+    const pages = [];
+    let pdfLibDoc = null;
+    try {
+      pdfLibDoc = await pdfLib.PDFDocument.load(pdfBytes);
+    } catch {
+    }
+    for (let pageNum = 1; pageNum <= pdfDoc.numPages; pageNum++) {
+      const page = await pdfDoc.getPage(pageNum);
+      const viewport = page.getViewport({ scale: 2 });
+      let pdfWidth = viewport.width / 2;
+      let pdfHeight = viewport.height / 2;
+      if (pdfLibDoc) {
+        try {
+          const pdfLibPage = pdfLibDoc.getPage(pageNum - 1);
+          const pdfLibWidth = pdfLibPage.getWidth();
+          const pdfLibHeight = pdfLibPage.getHeight();
+          pdfWidth = pdfLibWidth;
+          pdfHeight = pdfLibHeight;
+        } catch {
+        }
+      }
+      const canvas = document.createElement("canvas");
+      const context = canvas.getContext("2d");
+      canvas.height = viewport.height;
+      canvas.width = viewport.width;
+      const hideFormFields = options?.hideFormFields ?? false;
+      const renderContext = {
+        canvasContext: context,
+        viewport,
+        // Hide annotations/form fields when specified
+        renderInteractiveForms: !hideFormFields,
+        // Additional options to ensure form fields are hidden
+        ...hideFormFields && {
+          annotationMode: 0,
+          // Disable annotations
+          renderAnnotations: false,
+          renderForms: false
+        }
+      };
+      await page.render(renderContext).promise;
+      const imageUrl = canvas.toDataURL("image/png");
+      pages.push({
+        imageUrl,
+        width: pdfWidth,
+        height: pdfHeight
+      });
+    }
+    return pages;
+  } catch (error) {
+    console.error("Error converting PDF to images with PDF.js:", error);
+    throw error;
+  }
+}
+async function imageToPdf(imageFile) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    img.onload = async () => {
+      try {
+        canvas.width = img.width;
+        canvas.height = img.height;
+        ctx.drawImage(img, 0, 0);
+        canvas.toBlob(
+          async (blob) => {
+            if (!blob) {
+              reject(new Error("Failed to convert image to blob"));
+              return;
+            }
+            const imageBytes = new Uint8Array(await blob.arrayBuffer());
+            const pdfDoc = await pdfLib.PDFDocument.create();
+            const embeddedImage = await pdfDoc.embedPng(imageBytes);
+            const { width, height } = embeddedImage.scale(1);
+            const maxWidth = 595;
+            const maxHeight = 842;
+            let pageWidth = width;
+            let pageHeight = height;
+            if (width > maxWidth || height > maxHeight) {
+              const scale = Math.min(maxWidth / width, maxHeight / height);
+              pageWidth = width * scale;
+              pageHeight = height * scale;
+            }
+            const page = pdfDoc.addPage([
+              Math.max(pageWidth, 100),
+              Math.max(pageHeight, 100)
+            ]);
+            const x = (page.getWidth() - pageWidth) / 2;
+            const y = (page.getHeight() - pageHeight) / 2;
+            page.drawImage(embeddedImage, {
+              x: Math.max(x, 0),
+              y: Math.max(y, 0),
+              width: pageWidth,
+              height: pageHeight
+            });
+            const pdfBytes = await pdfDoc.save();
+            resolve(pdfBytes);
+          },
+          "image/png",
+          0.95
+        );
+      } catch (error) {
+        reject(error);
+      }
+    };
+    img.onerror = () => {
+      reject(new Error("Failed to load image"));
+    };
+    const objectUrl = URL.createObjectURL(imageFile);
+    img.src = objectUrl;
+  });
+}
+function createPdfBlobUrl(pdfBytes) {
+  const blob = new Blob([pdfBytes], {
+    type: "application/pdf"
+  });
+  return URL.createObjectURL(blob);
+}
+function downloadPdf(pdfBytes, filename) {
+  const blob = new Blob([pdfBytes], {
+    type: "application/pdf"
+  });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+var isMultiSelectModifier = (event) => {
+  return event.ctrlKey || event.metaKey;
+};
+var isRangeSelectModifier = (event) => {
+  return event.shiftKey;
+};
+var handleContextMenu = (event) => {
+  if (event.ctrlKey && /Mac|iPod|iPhone|iPad/.test(navigator.userAgent)) {
+    event.preventDefault();
+  }
+};
+var getPageRange = (files, startPageId, endPageId) => {
+  const allPages = [];
+  files.forEach((file) => {
+    file.pages.forEach((page) => {
+      allPages.push({ id: page.id, fileId: file.id });
+    });
+  });
+  const startIndex = allPages.findIndex((p) => p.id === startPageId);
+  const endIndex = allPages.findIndex((p) => p.id === endPageId);
+  if (startIndex === -1 || endIndex === -1) return [];
+  const start = Math.min(startIndex, endIndex);
+  const end = Math.max(startIndex, endIndex);
+  return allPages.slice(start, end + 1).map((p) => p.id);
+};
+function assemblerReducer(state, action) {
+  switch (action.type) {
+    case "ADD_FILE": {
+      const existingFileById = state.files.find((f) => f.id === action.payload.id);
+      if (existingFileById) return state;
+      return {
+        ...state,
+        files: [...state.files, action.payload]
+      };
+    }
+    case "REMOVE_FILE":
+      return {
+        ...state,
+        files: state.files.filter((f) => f.id !== action.payload),
+        selection: state.selection.filter(
+          (pageId) => !state.files.find((f) => f.id === action.payload)?.pages.some((p) => p.id === pageId)
+        )
+      };
+    case "UPDATE_FILE":
+      return {
+        ...state,
+        files: state.files.map(
+          (f) => f.id === action.payload.fileId ? { ...f, ...action.payload.updates } : f
+        )
+      };
+    case "REORDER_PAGES":
+      return {
+        ...state,
+        files: state.files.map(
+          (f) => f.id === action.payload.fileId ? { ...f, pages: action.payload.newOrder } : f
+        )
+      };
+    case "REORDER_FILES":
+      return {
+        ...state,
+        files: action.payload.newOrder
+      };
+    case "MOVE_PAGES": {
+      const { pageIds, targetFileId } = action.payload;
+      const existingPageIds = state.files.flatMap((f) => f.pages.map((p) => p.id));
+      const pagesToActuallyMove = pageIds.filter((id) => existingPageIds.includes(id));
+      if (pagesToActuallyMove.length === 0) return state;
+      const pagesToMove = [];
+      for (const file of state.files) {
+        for (const page of file.pages) {
+          if (pagesToActuallyMove.includes(page.id)) {
+            pagesToMove.push(page);
+          }
+        }
+      }
+      const updatedFiles = state.files.map((file) => {
+        if (file.id === targetFileId) {
+          const existingPageIds2 = file.pages.map((p) => p.id);
+          const newPages = pagesToMove.filter((p) => !existingPageIds2.includes(p.id));
+          return {
+            ...file,
+            pages: [...file.pages, ...newPages]
+          };
+        } else {
+          return {
+            ...file,
+            pages: file.pages.filter((page) => !pagesToActuallyMove.includes(page.id))
+          };
+        }
+      });
+      return {
+        ...state,
+        files: updatedFiles,
+        selection: []
+      };
+    }
+    case "DELETE_PAGES": {
+      const pageIdsToDelete = action.payload;
+      const existingPageIds = state.files.flatMap((f) => f.pages.map((p) => p.id));
+      const pagesToActuallyDelete = pageIdsToDelete.filter((id) => existingPageIds.includes(id));
+      if (pagesToActuallyDelete.length === 0) return state;
+      const updatedFiles = state.files.map((file) => {
+        const remainingPages = file.pages.filter((page) => !pagesToActuallyDelete.includes(page.id));
+        return {
+          ...file,
+          pages: remainingPages
+        };
+      }).filter((file) => file.pages.length > 0);
+      return {
+        ...state,
+        files: updatedFiles,
+        selection: state.selection.filter((id) => !pagesToActuallyDelete.includes(id))
+      };
+    }
+    case "SET_SELECTION":
+      return {
+        ...state,
+        selection: action.payload
+      };
+    case "TOGGLE_PAGE_SELECTION": {
+      const { pageId } = action.payload;
+      const isSelected = state.selection.includes(pageId);
+      if (isSelected) {
+        return {
+          ...state,
+          selection: state.selection.filter((id) => id !== pageId),
+          lastSelectedPageId: pageId
+        };
+      } else {
+        return {
+          ...state,
+          selection: [...state.selection, pageId],
+          lastSelectedPageId: pageId
+        };
+      }
+    }
+    case "RANGE_SELECT_PAGES": {
+      const { pageId, files } = action.payload;
+      if (!state.lastSelectedPageId) {
+        return {
+          ...state,
+          selection: [pageId],
+          lastSelectedPageId: pageId
+        };
+      }
+      const rangePageIds = getPageRange(files, state.lastSelectedPageId, pageId);
+      const newSelection = [.../* @__PURE__ */ new Set([...state.selection, ...rangePageIds])];
+      return {
+        ...state,
+        selection: newSelection,
+        lastSelectedPageId: pageId
+      };
+    }
+    case "SINGLE_SELECT_PAGE": {
+      return {
+        ...state,
+        selection: [action.payload],
+        lastSelectedPageId: action.payload
+      };
+    }
+    case "CLEAR_SELECTION":
+      return {
+        ...state,
+        selection: [],
+        lastSelectedPageId: void 0
+      };
+    case "RENAME_FILE":
+      return {
+        ...state,
+        files: state.files.map(
+          (f) => f.id === action.payload.fileId ? { ...f, name: action.payload.name } : f
+        )
+      };
+    case "RESET":
+      return action.payload || { files: [], selection: [], lastSelectedPageId: void 0 };
+    default:
+      return state;
+  }
+}
+var DND_TYPES = {
+  PAGE: "page",
+  FILE: "file"
+};
+var DraggablePageThumbnail = ({
+  page,
+  fileId,
+  index,
+  isSelected,
+  onSingleSelect,
+  onToggleSelect,
+  onRangeSelect,
+  movePageInFile,
+  isDraggingPageRef
+}) => {
+  const ref = React7.useRef(null);
+  const [{ isDragging }, drag] = reactDnd.useDrag({
+    type: DND_TYPES.PAGE,
+    item: () => {
+      if (isDraggingPageRef?.current !== void 0) {
+        isDraggingPageRef.current = true;
+      }
+      return { pageId: page.id, fileId, index };
+    },
+    collect: (monitor) => ({
+      isDragging: monitor.isDragging()
+    }),
+    end: () => {
+      if (isDraggingPageRef?.current !== void 0) {
+        isDraggingPageRef.current = false;
+      }
+    }
+  });
+  const [{ handlerId }, drop] = reactDnd.useDrop({
+    accept: DND_TYPES.PAGE,
+    collect(monitor) {
+      return {
+        handlerId: monitor.getHandlerId()
+      };
+    },
+    hover(item, monitor) {
+      if (!ref.current) return;
+      if (item.fileId !== fileId) return;
+      const dragIndex = item.index;
+      const hoverIndex = index;
+      if (dragIndex === hoverIndex) return;
+      const hoverBoundingRect = ref.current?.getBoundingClientRect();
+      const hoverMiddleY = (hoverBoundingRect.bottom - hoverBoundingRect.top) / 2;
+      const clientOffset = monitor.getClientOffset();
+      const hoverClientY = clientOffset.y - hoverBoundingRect.top;
+      if (dragIndex < hoverIndex && hoverClientY < hoverMiddleY) return;
+      if (dragIndex > hoverIndex && hoverClientY > hoverMiddleY) return;
+      movePageInFile(dragIndex, hoverIndex);
+      item.index = hoverIndex;
+    }
+  });
+  React7.useEffect(() => {
+    drag(drop(ref));
+  }, [drag, drop]);
+  const handleClick = (e) => {
+    e.preventDefault();
+    handleContextMenu(e);
+    if (isRangeSelectModifier(e)) {
+      onRangeSelect(page.id);
+    } else if (isMultiSelectModifier(e)) {
+      onToggleSelect(page.id);
+    } else {
+      onSingleSelect(page.id);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ref,
+      "data-handler-id": handlerId,
+      className: cn(
+        "relative group cursor-pointer border-2 rounded-lg overflow-hidden bg-white transition-all",
+        isDragging && "opacity-50 scale-95",
+        isSelected ? "border-primary shadow-md" : "border-gray-200 hover:border-gray-300"
+      ),
+      onClick: handleClick,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute top-1 right-1 opacity-0 group-hover:opacity-100 transition-opacity bg-black/50 rounded p-1 z-10", children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.GripVertical, { className: "h-3 w-3 text-white" }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: "absolute top-2 left-2 z-10",
+            onClick: (e) => e.stopPropagation(),
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "input",
+              {
+                type: "checkbox",
+                checked: isSelected,
+                onChange: (e) => {
+                  const nativeEvent = e.nativeEvent;
+                  if (nativeEvent && "shiftKey" in nativeEvent && nativeEvent.shiftKey) {
+                    onRangeSelect(page.id);
+                  } else if (nativeEvent && ("ctrlKey" in nativeEvent && nativeEvent.ctrlKey || "metaKey" in nativeEvent && nativeEvent.metaKey)) {
+                    onToggleSelect(page.id);
+                  } else {
+                    onSingleSelect(page.id);
+                  }
+                },
+                onContextMenu: handleContextMenu,
+                className: "h-4 w-4 rounded border-gray-300 text-primary focus:ring-primary focus:ring-2 bg-white/90 cursor-pointer"
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "aspect-[3/4] relative", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "img",
+            {
+              src: page.thumbUrl,
+              alt: `Page ${index + 1}`,
+              className: "w-full h-full object-cover"
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            Badge,
+            {
+              variant: "secondary",
+              className: "absolute bottom-1 right-1 text-xs px-1 py-0",
+              children: index + 1
+            }
+          )
+        ] })
+      ]
+    }
+  );
+};
+var ReorderablePageGrid = ({
+  file,
+  selectedPageIds,
+  onSingleSelectPage,
+  onTogglePageSelect,
+  onRangeSelectPage,
+  onReorderPages,
+  isDraggingPageRef
+}) => {
+  const movePageInFile = React7.useCallback((dragIndex, hoverIndex) => {
+    const newPages = [...file.pages];
+    const draggedPage = newPages[dragIndex];
+    newPages.splice(dragIndex, 1);
+    newPages.splice(hoverIndex, 0, draggedPage);
+    onReorderPages(file.id, newPages);
+  }, [file.id, file.pages, onReorderPages]);
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-6 gap-4", children: file.pages.map((page, index) => /* @__PURE__ */ jsxRuntime.jsx(
+    DraggablePageThumbnail,
+    {
+      page,
+      fileId: file.id,
+      index,
+      isSelected: selectedPageIds.includes(page.id),
+      onSingleSelect: onSingleSelectPage,
+      onToggleSelect: onTogglePageSelect,
+      onRangeSelect: onRangeSelectPage,
+      movePageInFile,
+      isDraggingPageRef
+    },
+    page.id
+  )) });
+};
+var FileDropZone = ({
+  targetIndex,
+  onReorderFiles,
+  files
+}) => {
+  const [{ isOver, canDrop }, drop] = reactDnd.useDrop({
+    accept: DND_TYPES.FILE,
+    drop: (item) => {
+      const currentIndex = files.findIndex((f) => f.id === item.fileId);
+      if (currentIndex === -1) return;
+      let newIndex = targetIndex;
+      if (currentIndex < targetIndex) {
+        newIndex = targetIndex - 1;
+      }
+      if (currentIndex === newIndex) return;
+      const newFiles = [...files];
+      const [movedFile] = newFiles.splice(currentIndex, 1);
+      newFiles.splice(newIndex, 0, movedFile);
+      onReorderFiles(newFiles);
+    },
+    collect: (monitor) => ({
+      isOver: monitor.isOver(),
+      canDrop: monitor.canDrop()
+    })
+  });
+  const isActive = isOver && canDrop;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: drop,
+      className: cn(
+        "h-2 transition-all duration-200 mx-4",
+        isActive ? "h-8 bg-primary/20 border-2 border-dashed border-primary rounded-lg" : ""
+      ),
+      children: isActive && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-center h-full text-primary text-sm font-medium", children: "Drop here to reorder" })
+    }
+  );
+};
+var FileCard = ({
+  file,
+  selectedPageIds,
+  onSingleSelectPage,
+  onTogglePageSelect,
+  onRangeSelectPage,
+  onSelectAllInFile,
+  onRemoveFile,
+  onRenameFile,
+  onReorderPages,
+  isDraggingPageRef
+}) => {
+  const [isRenaming, setIsRenaming] = React7.useState(false);
+  const [newName, setNewName] = React7.useState(file.name);
+  const fileSelectedPages = file.pages.filter((p) => selectedPageIds.includes(p.id));
+  const allPagesSelected = file.pages.length > 0 && fileSelectedPages.length === file.pages.length;
+  const [{ isDraggingFile }, dragFile] = reactDnd.useDrag({
+    type: DND_TYPES.FILE,
+    item: () => {
+      if (isDraggingPageRef?.current !== void 0) {
+        isDraggingPageRef.current = true;
+      }
+      return { fileId: file.id, file };
+    },
+    collect: (monitor) => ({
+      isDraggingFile: monitor.isDragging()
+    }),
+    end: () => {
+      if (isDraggingPageRef?.current !== void 0) {
+        isDraggingPageRef.current = false;
+      }
+    }
+  });
+  const [, drop] = reactDnd.useDrop({
+    accept: DND_TYPES.PAGE,
+    drop: (_item) => {
+    }
+  });
+  const handleRename = () => {
+    if (newName.trim() && newName !== file.name) {
+      onRenameFile(file.id, newName.trim());
+    }
+    setIsRenaming(false);
+  };
+  const combineRefs = React7.useCallback((el) => {
+    drop(el);
+    dragFile(el);
+  }, [drop, dragFile]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    Card,
+    {
+      className: cn(
+        "mb-6 transition-all cursor-move",
+        isDraggingFile ? "opacity-50 rotate-2 scale-105 shadow-2xl z-50" : "opacity-100"
+      ),
+      ref: combineRefs,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(CardHeader, { className: "pb-3", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
+            file.type === "pdf" ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.FileText, { className: "h-5 w-5 text-red-500" }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Image, { className: "h-5 w-5 text-blue-500" }),
+            isRenaming ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                Input,
+                {
+                  value: newName,
+                  onChange: (e) => setNewName(e.target.value),
+                  onKeyDown: (e) => {
+                    if (e.key === "Enter") handleRename();
+                    if (e.key === "Escape") {
+                      setIsRenaming(false);
+                      setNewName(file.name);
+                    }
+                  },
+                  className: "h-8 text-sm",
+                  autoFocus: true
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(Button, { type: "button", size: "sm", variant: "ghost", onClick: handleRename, children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { className: "h-3 w-3" }) }),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                Button,
+                {
+                  type: "button",
+                  size: "sm",
+                  variant: "ghost",
+                  onClick: () => {
+                    setIsRenaming(false);
+                    setNewName(file.name);
+                  },
+                  children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.X, { className: "h-3 w-3" })
+                }
+              )
+            ] }) : /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(CardTitle, { className: "text-base", children: file.name }),
+              /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-sm text-muted-foreground", children: [
+                file.pages.length,
+                " page",
+                file.pages.length !== 1 ? "s" : ""
+              ] })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(TooltipProvider, { children: /* @__PURE__ */ jsxRuntime.jsxs(Tooltip, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsxs(
+                Button,
+                {
+                  type: "button",
+                  variant: "outline",
+                  size: "sm",
+                  onClick: () => onSelectAllInFile(file.id),
+                  disabled: file.pages.length === 0,
+                  children: [
+                    allPagesSelected && /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { className: "h-3 w-3 mr-2" }),
+                    "Select All"
+                  ]
+                }
+              ) }),
+              /* @__PURE__ */ jsxRuntime.jsx(TooltipContent, { children: "Select all pages in this file" })
+            ] }) }),
+            /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenu, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(Button, { type: "button", variant: "ghost", size: "sm", className: "hover:bg-gray-100 rounded-lg", children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.MoreHorizontal, { className: "h-4 w-4" }) }) }),
+              /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenuContent, { align: "end", className: "w-52", children: [
+                /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenuItem, { onClick: () => setIsRenaming(true), children: [
+                  /* @__PURE__ */ jsxRuntime.jsx("svg", { className: "h-4 w-4 mr-2", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsxRuntime.jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z" }) }),
+                  "Rename File"
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsxs(
+                  DropdownMenuItem,
+                  {
+                    onClick: () => onRemoveFile(file.id),
+                    className: "text-red-600 hover:text-red-700 hover:bg-red-50 focus:text-red-700 focus:bg-red-50",
+                    children: [
+                      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Trash2, { className: "h-4 w-4 mr-2" }),
+                      "Remove File"
+                    ]
+                  }
+                )
+              ] })
+            ] })
+          ] })
+        ] }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(CardContent, { children: /* @__PURE__ */ jsxRuntime.jsx(
+          ReorderablePageGrid,
+          {
+            file,
+            selectedPageIds,
+            onSingleSelectPage,
+            onTogglePageSelect,
+            onRangeSelectPage,
+            onReorderPages,
+            isDraggingPageRef
+          }
+        ) })
+      ]
+    }
+  );
+};
+var BulkActionBar = ({
+  selectedCount,
+  files,
+  onMovePages,
+  onDeletePages,
+  onClearSelection
+}) => {
+  if (selectedCount === 0) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sticky top-4 z-10 mb-4", children: /* @__PURE__ */ jsxRuntime.jsx(Card, { className: "p-4 shadow-lg border-primary/20 bg-blue-50", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between flex-wrap gap-4", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-4 flex-wrap", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "span",
+        {
+          className: "inline-flex items-center text-sm font-medium text-white rounded-full",
+          style: {
+            backgroundColor: "#0099cd",
+            padding: "6px 14px"
+          },
+          children: [
+            selectedCount,
+            " page",
+            selectedCount !== 1 ? "s" : "",
+            " selected"
+          ]
+        }
+      ),
+      files.length > 1 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(TooltipProvider, { children: /* @__PURE__ */ jsxRuntime.jsxs(Tooltip, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(Label, { htmlFor: "move-select", className: "text-sm font-medium text-gray-700", children: "Move to file:" }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(TooltipContent, { children: /* @__PURE__ */ jsxRuntime.jsx("p", { children: "Move selected pages to another file" }) })
+        ] }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(Select, { onValueChange: onMovePages, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(SelectTrigger, { id: "move-select", className: "w-48 bg-white", children: /* @__PURE__ */ jsxRuntime.jsx(SelectValue, { placeholder: "Choose file..." }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(SelectContent, { children: files.map((file) => /* @__PURE__ */ jsxRuntime.jsx(SelectItem, { value: file.id, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+            file.type === "pdf" ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.FileText, { className: "h-4 w-4" }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Image, { className: "h-4 w-4" }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate", children: file.name })
+          ] }) }, file.id)) })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        Button,
+        {
+          type: "button",
+          variant: "destructive",
+          size: "sm",
+          onClick: onDeletePages,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Trash2, { className: "h-4 w-4 mr-2" }),
+            "Delete Selected"
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        Button,
+        {
+          type: "button",
+          variant: "outline",
+          size: "sm",
+          onClick: onClearSelection,
+          className: "bg-white",
+          children: "Clear Selection"
+        }
+      )
+    ] })
+  ] }) }) });
+};
+var PageAssembler = React7.forwardRef(
+  (props, ref) => {
+    const {
+      initialPdf,
+      initialState,
+      onChange,
+      onValidityChange,
+      limits,
+      disableFileUpload = false,
+      className
+    } = props;
+    const [state, dispatch] = React7.useReducer(
+      assemblerReducer,
+      initialState || {
+        files: [],
+        selection: [],
+        lastSelectedPageId: void 0
+      }
+    );
+    const [isLoading, setIsLoading] = React7.useState(false);
+    const [processingStatus, setProcessingStatus] = React7.useState("");
+    const [showDeleteConfirm, setShowDeleteConfirm] = React7.useState(false);
+    const [showRemoveFileConfirm, setShowRemoveFileConfirm] = React7.useState(false);
+    const [fileToRemove, setFileToRemove] = React7.useState(null);
+    const fileInputRef = React7.useRef(null);
+    const processedInitialPdfRef = React7.useRef(null);
+    const isDraggingPage = React7.useRef(false);
+    const onChangeRef = React7.useRef(onChange);
+    const summary = React7.useMemo(() => ({
+      totalFiles: state.files.length,
+      totalPages: state.files.reduce((sum, file) => sum + file.pages.length, 0)
+    }), [state.files]);
+    const isValid = summary.totalPages > 0;
+    React7.useEffect(() => {
+      onChangeRef.current = onChange;
+    }, [onChange]);
+    const debouncedOnChange = React7.useMemo(
+      () => debounce((newState) => {
+        onChangeRef.current?.(newState);
+      }, 200),
+      []
+    );
+    React7.useEffect(() => {
+      debouncedOnChange(state);
+    }, [state, debouncedOnChange]);
+    React7.useEffect(() => {
+      onValidityChange?.(isValid);
+    }, [isValid, onValidityChange]);
+    const processInitialPdf = React7.useCallback(async (pdf) => {
+      setIsLoading(true);
+      setProcessingStatus("Processing initial PDF...");
+      try {
+        let pdfBytes;
+        if (pdf instanceof Blob) {
+          const arrayBuffer = await pdf.arrayBuffer();
+          pdfBytes = new Uint8Array(arrayBuffer);
+        } else if (pdf instanceof ArrayBuffer) {
+          pdfBytes = new Uint8Array(pdf);
+        } else {
+          pdfBytes = new Uint8Array(pdf);
+        }
+        const defensiveCopy = new Uint8Array(pdfBytes);
+        const pages = await pdfToImages(defensiveCopy, { hideFormFields: true });
+        if (pages.length === 0) {
+          throw new Error("Failed to process PDF pages");
+        }
+        let originalBytes;
+        let originalFile;
+        try {
+          new Uint8Array(pdfBytes.buffer || pdfBytes, 0, 1);
+          originalBytes = new Uint8Array(pdfBytes);
+          originalFile = new File([pdfBytes.buffer], "Initial Document.pdf", { type: "application/pdf" });
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          if (errorMessage.includes("detached") || errorMessage.includes("ArrayBuffer")) {
+            throw new Error("Initial PDF data is no longer available. Please try refreshing the page.");
+          }
+          throw error;
+        }
+        const fileName = pdf instanceof File ? pdf.name : "Initial Document.pdf";
+        const fileId = generateId();
+        const file = {
+          id: fileId,
+          name: fileName,
+          type: "pdf",
+          originalFile,
+          originalBytes,
+          pages: pages.map((page, index) => ({
+            id: generateId(),
+            srcIndex: index,
+            thumbUrl: page.imageUrl,
+            width: page.width,
+            height: page.height,
+            mime: "application/pdf",
+            originalFileId: fileId
+          }))
+        };
+        dispatch({ type: "ADD_FILE", payload: file });
+      } catch (error) {
+        console.error("Error processing initial PDF:", error);
+      } finally {
+        setIsLoading(false);
+        setProcessingStatus("");
+      }
+    }, []);
+    React7.useEffect(() => {
+      if (initialPdf && !initialState) {
+        const pdfIdentifier = initialPdf instanceof Uint8Array ? `uint8array-${initialPdf.length}-${initialPdf[0]}-${initialPdf[initialPdf.length - 1]}` : `${initialPdf.constructor.name}-${initialPdf.size || initialPdf.byteLength}`;
+        if (processedInitialPdfRef.current === pdfIdentifier) {
+          return;
+        }
+        processedInitialPdfRef.current = pdfIdentifier;
+        processInitialPdf(initialPdf);
+      }
+    }, [initialPdf, initialState, processInitialPdf]);
+    React7.useEffect(() => {
+      if (initialState) {
+        dispatch({ type: "RESET", payload: initialState });
+      }
+    }, [initialState]);
+    const processFiles = React7.useCallback(async (files) => {
+      const fileArray = Array.from(files);
+      const maxFileSize = (limits?.maxFileSizeMB || 10) * 1024 * 1024;
+      setIsLoading(true);
+      setProcessingStatus(`Processing ${fileArray.length} file${fileArray.length !== 1 ? "s" : ""}...`);
+      for (const file of fileArray) {
+        try {
+          if (file.size > maxFileSize) {
+            console.error(`File ${file.name} is too large`);
+            continue;
+          }
+          const validTypes = ["application/pdf", "image/png", "image/jpeg", "image/jpg", "image/webp"];
+          if (!validTypes.includes(file.type)) {
+            console.error(`Unsupported file type: ${file.name}`);
+            continue;
+          }
+          const fileInfo = {
+            id: generateId(),
+            name: file.name,
+            type: file.type === "application/pdf" ? "pdf" : "image",
+            originalFile: file,
+            originalBytes: new Uint8Array(),
+            pages: []
+          };
+          if (file.type === "application/pdf") {
+            setProcessingStatus(`Processing PDF: ${file.name}`);
+            const arrayBuffer = await file.arrayBuffer();
+            const pdfBytes = new Uint8Array(arrayBuffer);
+            fileInfo.originalBytes = new Uint8Array(pdfBytes);
+            const defensiveCopy = new Uint8Array(pdfBytes);
+            const pages = await pdfToImages(defensiveCopy, { hideFormFields: true });
+            fileInfo.pages = pages.map((page, index) => ({
+              id: generateId(),
+              srcIndex: index,
+              thumbUrl: page.imageUrl,
+              width: page.width,
+              height: page.height,
+              mime: file.type,
+              originalFileId: fileInfo.id
+            }));
+          } else {
+            setProcessingStatus(`Processing image: ${file.name}`);
+            const arrayBuffer = await file.arrayBuffer();
+            const imageBytes = new Uint8Array(arrayBuffer);
+            fileInfo.originalBytes = new Uint8Array(imageBytes);
+            const thumbUrl = URL.createObjectURL(file);
+            const img = new Image();
+            const dimensions = await new Promise((resolve) => {
+              img.onload = () => resolve({ width: img.width, height: img.height });
+              img.src = thumbUrl;
+            });
+            const maxWidth = 595;
+            const maxHeight = 842;
+            let pdfWidth = dimensions.width;
+            let pdfHeight = dimensions.height;
+            if (dimensions.width > maxWidth || dimensions.height > maxHeight) {
+              const scaleX = maxWidth / dimensions.width;
+              const scaleY = maxHeight / dimensions.height;
+              const scale = Math.min(scaleX, scaleY);
+              pdfWidth = dimensions.width * scale;
+              pdfHeight = dimensions.height * scale;
+            }
+            fileInfo.pages = [{
+              id: generateId(),
+              srcIndex: 0,
+              thumbUrl,
+              width: Math.max(pdfWidth, 100),
+              height: Math.max(pdfHeight, 100),
+              mime: file.type,
+              originalFileId: fileInfo.id
+            }];
+          }
+          dispatch({ type: "ADD_FILE", payload: fileInfo });
+        } catch (error) {
+          console.error(`Error processing file ${file.name}:`, error);
+        }
+      }
+      setIsLoading(false);
+      setProcessingStatus("");
+    }, [limits]);
+    const handleFileUpload = React7.useCallback(() => {
+      fileInputRef.current?.click();
+    }, []);
+    const handleFileChange = React7.useCallback((e) => {
+      const files = e.target.files;
+      if (files) {
+        processFiles(files);
+      }
+      if (fileInputRef.current) {
+        fileInputRef.current.value = "";
+      }
+    }, [processFiles]);
+    const handleDrop = React7.useCallback((e) => {
+      e.preventDefault();
+      const files = e.dataTransfer.files;
+      if (files && files.length > 0) {
+        if (isDraggingPage.current) {
+          return;
+        }
+        processFiles(files);
+      }
+    }, [processFiles]);
+    const handleDragOver = React7.useCallback((e) => {
+      e.preventDefault();
+    }, []);
+    const handleSingleSelectPage = React7.useCallback((pageId) => {
+      dispatch({ type: "SINGLE_SELECT_PAGE", payload: pageId });
+    }, []);
+    const handleTogglePageSelect = React7.useCallback((pageId) => {
+      dispatch({ type: "TOGGLE_PAGE_SELECTION", payload: { pageId, files: state.files } });
+    }, [state.files]);
+    const handleRangeSelectPage = React7.useCallback((pageId) => {
+      dispatch({ type: "RANGE_SELECT_PAGES", payload: { pageId, files: state.files } });
+    }, [state.files]);
+    const handleSelectAllInFile = React7.useCallback((fileId) => {
+      const file = state.files.find((f) => f.id === fileId);
+      if (!file) return;
+      const filePageIds = file.pages.map((p) => p.id);
+      const allSelected = filePageIds.every((id) => state.selection.includes(id));
+      if (allSelected) {
+        dispatch({
+          type: "SET_SELECTION",
+          payload: state.selection.filter((id) => !filePageIds.includes(id))
+        });
+      } else {
+        const newSelection = [.../* @__PURE__ */ new Set([...state.selection, ...filePageIds])];
+        dispatch({ type: "SET_SELECTION", payload: newSelection });
+      }
+    }, [state.files, state.selection]);
+    const handleMovePages = React7.useCallback((targetFileId) => {
+      if (state.selection.length === 0) return;
+      dispatch({ type: "MOVE_PAGES", payload: { pageIds: state.selection, targetFileId } });
+    }, [state.selection]);
+    const handleDeletePages = React7.useCallback(() => {
+      setShowDeleteConfirm(true);
+    }, []);
+    const confirmDeletePages = React7.useCallback(() => {
+      dispatch({ type: "DELETE_PAGES", payload: state.selection });
+      setShowDeleteConfirm(false);
+    }, [state.selection]);
+    const handleRemoveFile = React7.useCallback((fileId) => {
+      const file = state.files.find((f) => f.id === fileId);
+      if (!file) return;
+      if (file.pages.length > 0) {
+        setFileToRemove({
+          id: file.id,
+          name: file.name,
+          pageCount: file.pages.length
+        });
+        setShowRemoveFileConfirm(true);
+      } else {
+        dispatch({ type: "REMOVE_FILE", payload: fileId });
+      }
+    }, [state.files]);
+    const confirmRemoveFile = React7.useCallback(() => {
+      if (fileToRemove) {
+        dispatch({ type: "REMOVE_FILE", payload: fileToRemove.id });
+        setFileToRemove(null);
+      }
+      setShowRemoveFileConfirm(false);
+    }, [fileToRemove]);
+    const handleRenameFile = React7.useCallback((fileId, name) => {
+      dispatch({ type: "RENAME_FILE", payload: { fileId, name } });
+    }, []);
+    const handleReorderFiles = React7.useCallback((newOrder) => {
+      dispatch({ type: "REORDER_FILES", payload: { newOrder } });
+    }, []);
+    React7.useImperativeHandle(ref, () => ({
+      assemble: async () => {
+        setIsLoading(true);
+        setProcessingStatus("Assembling PDF...");
+        try {
+          const { PDFDocument: PDFDocument2 } = await import('pdf-lib');
+          const combinedDoc = await PDFDocument2.create();
+          const loadedPdfs = /* @__PURE__ */ new Map();
+          const fileMap = /* @__PURE__ */ new Map();
+          for (const file of state.files) {
+            fileMap.set(file.id, file);
+            if (file.type === "pdf" && file.originalBytes) {
+              try {
+                const sourcePdf = await PDFDocument2.load(file.originalBytes);
+                loadedPdfs.set(file.id, sourcePdf);
+              } catch (error) {
+                console.error(`Error loading PDF for file ${file.id}:`, error);
+              }
+            }
+          }
+          for (const file of state.files) {
+            if (file.pages.length === 0) continue;
+            for (const page of file.pages) {
+              const originalFileId = page.originalFileId || file.id;
+              const sourceFile = fileMap.get(originalFileId);
+              if (!sourceFile) {
+                console.warn(`Source file not found for page ${page.id}`);
+                continue;
+              }
+              if (sourceFile.type === "pdf") {
+                const sourcePdf = loadedPdfs.get(originalFileId);
+                if (!sourcePdf) {
+                  console.warn(`Source PDF not loaded for page ${page.id}`);
+                  continue;
+                }
+                const sourcePageCount = sourcePdf.getPageCount();
+                if (page.srcIndex >= 0 && page.srcIndex < sourcePageCount) {
+                  try {
+                    const copiedPages = await combinedDoc.copyPages(sourcePdf, [page.srcIndex]);
+                    copiedPages.forEach((copiedPage) => combinedDoc.addPage(copiedPage));
+                  } catch (copyError) {
+                    console.error(`Error copying page ${page.srcIndex}:`, copyError);
+                    throw new Error(`Failed to copy page: ${copyError instanceof Error ? copyError.message : String(copyError)}`);
+                  }
+                }
+              } else if (sourceFile.type === "image" && sourceFile.originalFile) {
+                try {
+                  const imagePdfBytes = await imageToPdf(sourceFile.originalFile);
+                  const imagePdf = await PDFDocument2.load(imagePdfBytes);
+                  const copiedPages = await combinedDoc.copyPages(imagePdf, [0]);
+                  copiedPages.forEach((copiedPage) => combinedDoc.addPage(copiedPage));
+                } catch (imageError) {
+                  console.error(`Error converting image page:`, imageError);
+                  throw new Error(`Failed to convert image: ${imageError instanceof Error ? imageError.message : String(imageError)}`);
+                }
+              }
+            }
+          }
+          const pdfBytes = await combinedDoc.save();
+          const blob = new Blob([pdfBytes.buffer], { type: "application/pdf" });
+          return blob;
+        } catch (error) {
+          console.error("Error assembling PDF:", error);
+          throw error;
+        } finally {
+          setIsLoading(false);
+          setProcessingStatus("");
+        }
+      },
+      getSummary: () => summary,
+      isBusy: () => isLoading,
+      getState: () => state
+    }), [state, summary, isLoading]);
+    return /* @__PURE__ */ jsxRuntime.jsx(TooltipProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(reactDnd.DndProvider, { backend: reactDndHtml5Backend.HTML5Backend, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn("space-y-6 pb-6", className), children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+          /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-lg font-medium", children: "Page Assembly" }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground", children: "Upload, arrange, and combine pages into a single PDF document" })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-4", children: [
+          summary.totalPages > 0 && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-sm text-gray-500", children: [
+            summary.totalFiles,
+            " file",
+            summary.totalFiles !== 1 ? "s" : "",
+            ", ",
+            summary.totalPages,
+            " page",
+            summary.totalPages !== 1 ? "s" : ""
+          ] }),
+          !disableFileUpload && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+            /* @__PURE__ */ jsxRuntime.jsxs(Button, { type: "button", onClick: handleFileUpload, disabled: isLoading, children: [
+              /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Upload, { className: "h-4 w-4 mr-2" }),
+              "Add Files"
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "input",
+              {
+                ref: fileInputRef,
+                type: "file",
+                multiple: true,
+                accept: ".pdf,image/*",
+                onChange: handleFileChange,
+                className: "hidden"
+              }
+            )
+          ] })
+        ] })
+      ] }),
+      isLoading && /* @__PURE__ */ jsxRuntime.jsx(Card, { className: "p-4", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "animate-spin rounded-full h-4 w-4 border-b-2 border-primary" }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm", children: processingStatus })
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        BulkActionBar,
+        {
+          selectedCount: state.selection.length,
+          files: state.files,
+          onMovePages: handleMovePages,
+          onDeletePages: handleDeletePages,
+          onClearSelection: () => dispatch({ type: "CLEAR_SELECTION" })
+        }
+      ),
+      state.files.length > 0 ? /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          onDrop: handleDrop,
+          onDragOver: handleDragOver,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              FileDropZone,
+              {
+                targetIndex: 0,
+                onReorderFiles: handleReorderFiles,
+                files: state.files
+              }
+            ),
+            state.files.map((file, index) => /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                FileCard,
+                {
+                  file,
+                  selectedPageIds: state.selection,
+                  onSingleSelectPage: handleSingleSelectPage,
+                  onTogglePageSelect: handleTogglePageSelect,
+                  onRangeSelectPage: handleRangeSelectPage,
+                  onSelectAllInFile: handleSelectAllInFile,
+                  onRemoveFile: handleRemoveFile,
+                  onRenameFile: handleRenameFile,
+                  onReorderPages: (fileId, newOrder) => dispatch({ type: "REORDER_PAGES", payload: { fileId, newOrder } }),
+                  isDraggingPageRef: isDraggingPage
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                FileDropZone,
+                {
+                  targetIndex: index + 1,
+                  onReorderFiles: handleReorderFiles,
+                  files: state.files
+                }
+              )
+            ] }, file.id))
+          ]
+        }
+      ) : !disableFileUpload && /* @__PURE__ */ jsxRuntime.jsx(
+        Card,
+        {
+          className: "p-12 border-dashed border-2 border-gray-300 hover:border-gray-400 transition-colors cursor-pointer",
+          onClick: handleFileUpload,
+          onDrop: handleDrop,
+          onDragOver: handleDragOver,
+          children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-center", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.FolderOpen, { className: "h-12 w-12 mx-auto text-gray-400 mb-4" }),
+            /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-lg font-medium text-gray-900 mb-2", children: "No files added" }),
+            /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-gray-500 mb-4", children: "Upload PDF files and images to start building your document" }),
+            /* @__PURE__ */ jsxRuntime.jsxs(Button, { type: "button", variant: "outline", children: [
+              /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Upload, { className: "h-4 w-4 mr-2" }),
+              "Choose Files"
+            ] })
+          ] })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(AlertDialog, { open: showDeleteConfirm, onOpenChange: setShowDeleteConfirm, children: /* @__PURE__ */ jsxRuntime.jsxs(AlertDialogContent, { children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(AlertDialogHeader, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(AlertDialogTitle, { children: "Delete Pages" }),
+          /* @__PURE__ */ jsxRuntime.jsxs(AlertDialogDescription, { children: [
+            "Are you sure you want to delete ",
+            state.selection.length,
+            " selected page",
+            state.selection.length !== 1 ? "s" : "",
+            "? This action cannot be undone."
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(AlertDialogFooter, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(AlertDialogCancel, { children: "Cancel" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            AlertDialogAction,
+            {
+              className: "bg-destructive text-white hover:bg-destructive/90",
+              onClick: confirmDeletePages,
+              children: "Delete"
+            }
+          )
+        ] })
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(AlertDialog, { open: showRemoveFileConfirm, onOpenChange: setShowRemoveFileConfirm, children: /* @__PURE__ */ jsxRuntime.jsxs(AlertDialogContent, { children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(AlertDialogHeader, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(AlertDialogTitle, { children: "Remove File" }),
+          /* @__PURE__ */ jsxRuntime.jsxs(AlertDialogDescription, { children: [
+            'Are you sure you want to remove "',
+            fileToRemove?.name,
+            '" and all its ',
+            fileToRemove?.pageCount,
+            " page",
+            fileToRemove?.pageCount !== 1 ? "s" : "",
+            "? This action cannot be undone."
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(AlertDialogFooter, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(AlertDialogCancel, { onClick: () => {
+            setFileToRemove(null);
+            setShowRemoveFileConfirm(false);
+          }, children: "Cancel" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            AlertDialogAction,
+            {
+              className: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+              onClick: confirmRemoveFile,
+              children: "Remove File"
+            }
+          )
+        ] })
+      ] }) })
+    ] }) }) });
+  }
+);
+PageAssembler.displayName = "PageAssembler";
+function generateId() {
+  return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+function debounce(func, wait) {
+  let timeout;
+  return ((...args) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => func(...args), wait);
+  });
+}
+var PageAssembler_default = PageAssembler;
+
+exports.Button = Button;
+exports.PageAssembler = PageAssembler;
+exports.createPdfBlobUrl = createPdfBlobUrl;
+exports.default = PageAssembler_default;
+exports.downloadPdf = downloadPdf;
+exports.imageToPdf = imageToPdf;
+exports.pdfToImages = pdfToImages;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map