@nextsparkjs/core 0.1.0-beta.158 → 0.1.0-beta.159

package/dist/components/dashboard/block-editor/builder-editor-view.js

@@ -5,7 +5,13 @@ import { useRouter } from "next/navigation";
 import { useTranslations } from "next-intl";
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import { v4 as uuidv4 } from "uuid";
-import { copyBlockToClipboard, getBlockFromClipboard, hasBlockInClipboard } from "../../../lib/blocks/clipboard.js";
+import {
+  copyBlockToClipboard,
+  getBlockFromClipboard,
+  copyBlocksToClipboard,
+  getBlocksFromClipboard,
+  getClipboardBlockCount
+} from "../../../lib/blocks/clipboard.js";
 import { Button } from "../../ui/button.js";
 import { Input } from "../../ui/input.js";
 import { Separator } from "../../ui/separator.js";
@@ -16,11 +22,13 @@ import { sel } from "../../../lib/test/index.js";
 import { BlockPicker } from "./block-picker.js";
 import { BlockPreviewCanvas } from "./block-preview-canvas.js";
 import { BlockSettingsPanel } from "./block-settings-panel.js";
+import { BatchActionBar } from "./batch-action-bar.js";
 import { BlockService } from "../../../lib/services/block.service.js";
 import { ViewportToggle } from "./viewport-toggle.js";
 import { ConfigPanel } from "./config-panel.js";
 import { useSidebar } from "../../../contexts/sidebar-context.js";
 import { cn } from "../../../lib/utils/index.js";
+import { isPatternReference } from "../../../types/pattern-reference.js";
 function getTeamId() {
   if (typeof window !== "undefined") {
     return localStorage.getItem("activeTeamId");
@@ -49,7 +57,8 @@ function BuilderEditorView({ entitySlug, entityConfig, id, mode, onEntityFieldCh
   const queryClient = useQueryClient();
   const { isCollapsed } = useSidebar();
   const [blocks, setBlocks] = useState([]);
-  const [selectedBlockId, setSelectedBlockId] = useState(null);
+  const [selectedBlockIds, setSelectedBlockIds] = useState(/* @__PURE__ */ new Set());
+  const lastSelectedIdRef = useRef(null);
   const [title, setTitle] = useState("");
   const [slug, setSlug] = useState("");
   const [slugManuallyEdited, setSlugManuallyEdited] = useState(false);
@@ -234,17 +243,68 @@ function BuilderEditorView({ entitySlug, entityConfig, id, mode, onEntityFieldCh
     };
     saveMutation.mutate(data);
   }, [title, slug, blocks, pageSettings, entityFields, saveMutation, validateFields]);
+  const selectedBlockId = useMemo(() => {
+    if (selectedBlockIds.size === 1) return Array.from(selectedBlockIds)[0];
+    return null;
+  }, [selectedBlockIds]);
+  const setSelectedBlockId = useCallback((id2) => {
+    if (id2) {
+      setSelectedBlockIds(/* @__PURE__ */ new Set([id2]));
+      lastSelectedIdRef.current = id2;
+    } else {
+      setSelectedBlockIds(/* @__PURE__ */ new Set());
+      lastSelectedIdRef.current = null;
+    }
+  }, []);
+  const handleSelectBlock = useCallback((blockId, event) => {
+    if ((event == null ? void 0 : event.metaKey) || (event == null ? void 0 : event.ctrlKey)) {
+      setSelectedBlockIds((prev) => {
+        const next = new Set(prev);
+        if (next.has(blockId)) {
+          next.delete(blockId);
+        } else {
+          next.add(blockId);
+        }
+        lastSelectedIdRef.current = blockId;
+        return next;
+      });
+    } else if ((event == null ? void 0 : event.shiftKey) && lastSelectedIdRef.current) {
+      const anchorIdx = blocks.findIndex((b) => b.id === lastSelectedIdRef.current);
+      const targetIdx = blocks.findIndex((b) => b.id === blockId);
+      if (anchorIdx !== -1 && targetIdx !== -1) {
+        const start = Math.min(anchorIdx, targetIdx);
+        const end = Math.max(anchorIdx, targetIdx);
+        const rangeIds = blocks.slice(start, end + 1).map((b) => b.id);
+        setSelectedBlockIds((prev) => {
+          const next = new Set(prev);
+          rangeIds.forEach((id2) => next.add(id2));
+          return next;
+        });
+      }
+    } else {
+      setSelectedBlockIds(/* @__PURE__ */ new Set([blockId]));
+      lastSelectedIdRef.current = blockId;
+    }
+  }, [blocks]);
+  const handleSelectAll = useCallback(() => {
+    const nonPatternIds = blocks.filter((b) => !isPatternReference(b)).map((b) => b.id);
+    setSelectedBlockIds(new Set(nonPatternIds));
+  }, [blocks]);
+  const handleClearSelection = useCallback(() => {
+    setSelectedBlockIds(/* @__PURE__ */ new Set());
+  }, []);
+  const [clipboardCount, setClipboardCount] = useState(() => getClipboardBlockCount());
   const handleAddBlock = useCallback((blockSlug) => {
     const newBlock = {
       id: uuidv4(),
       blockSlug,
       props: {}
     };
-    if (selectedBlockId) {
-      const index = blocks.findIndex((b) => b.id === selectedBlockId);
-      if (index !== -1) {
+    if (selectedBlockIds.size > 0) {
+      const lastIdx = Math.max(...Array.from(selectedBlockIds).map((id2) => blocks.findIndex((b) => b.id === id2)));
+      if (lastIdx !== -1) {
         const newBlocks = [...blocks];
-        newBlocks.splice(index + 1, 0, newBlock);
+        newBlocks.splice(lastIdx + 1, 0, newBlock);
         setBlocks(newBlocks);
         setSelectedBlockId(newBlock.id);
         return;
@@ -252,29 +312,29 @@ function BuilderEditorView({ entitySlug, entityConfig, id, mode, onEntityFieldCh
     }
     setBlocks((prev) => [...prev, newBlock]);
     setSelectedBlockId(newBlock.id);
-  }, [blocks, selectedBlockId]);
+  }, [blocks, selectedBlockIds, setSelectedBlockId]);
   const handleAddPattern = useCallback((patternId) => {
     const patternRef = {
       type: "pattern",
       ref: patternId,
       id: uuidv4()
-      // Unique instance ID
     };
     setBlocks((prev) => [...prev, patternRef]);
     setSelectedBlockId(patternRef.id);
-  }, []);
+  }, [setSelectedBlockId]);
   const handleRemoveBlock = useCallback((blockId) => {
     setBlocks((prev) => prev.filter((b) => b.id !== blockId));
-    if (selectedBlockId === blockId) {
-      setSelectedBlockId(null);
-    }
-  }, [selectedBlockId]);
-  const [clipboardHasBlock, setClipboardHasBlock] = useState(() => hasBlockInClipboard());
+    setSelectedBlockIds((prev) => {
+      const next = new Set(prev);
+      next.delete(blockId);
+      return next;
+    });
+  }, []);
   const handleCopyBlock = useCallback((blockId) => {
     const block = blocks.find((b) => b.id === blockId);
     if (block) {
       copyBlockToClipboard(block);
-      setClipboardHasBlock(true);
+      setClipboardCount(1);
       toast.success(t("messages.blockCopied"));
     }
   }, [blocks, t]);
@@ -300,7 +360,68 @@ function BuilderEditorView({ entitySlug, entityConfig, id, mode, onEntityFieldCh
     setBlocks((prev) => [...prev, newBlock]);
     setSelectedBlockId(newBlock.id);
     toast.success(t("messages.blockPasted"));
-  }, [blocks, selectedBlockId, t]);
+  }, [blocks, selectedBlockId, t, setSelectedBlockId]);
+  const handleCopySelected = useCallback(() => {
+    const selected = blocks.filter((b) => selectedBlockIds.has(b.id) && !isPatternReference(b));
+    if (selected.length === 0) return;
+    copyBlocksToClipboard(selected, entitySlug);
+    setClipboardCount(selected.length);
+    toast.success(t("multiSelect.copied", { count: selected.length }));
+  }, [blocks, selectedBlockIds, entitySlug, t]);
+  const handleDeleteSelected = useCallback(() => {
+    const idsToDelete = selectedBlockIds;
+    setBlocks((prev) => prev.filter((b) => !idsToDelete.has(b.id)));
+    setSelectedBlockIds(/* @__PURE__ */ new Set());
+    toast.success(t("multiSelect.deleted", { count: idsToDelete.size }));
+  }, [selectedBlockIds, t]);
+  const handleDuplicateSelected = useCallback(() => {
+    const selectedOrdered = blocks.filter((b) => selectedBlockIds.has(b.id) && !isPatternReference(b));
+    if (selectedOrdered.length === 0) return;
+    const lastIdx = blocks.findIndex((b) => b.id === selectedOrdered[selectedOrdered.length - 1].id);
+    const duplicates = selectedOrdered.map((b) => ({
+      ...b,
+      id: uuidv4(),
+      props: { ...b.props }
+    }));
+    const newBlocks = [...blocks];
+    newBlocks.splice(lastIdx + 1, 0, ...duplicates);
+    setBlocks(newBlocks);
+    setSelectedBlockIds(new Set(duplicates.map((d) => d.id)));
+    toast.success(t("multiSelect.duplicated", { count: duplicates.length }));
+  }, [blocks, selectedBlockIds, t]);
+  const handlePasteBlocks = useCallback(() => {
+    const clipData = getBlocksFromClipboard();
+    if (!clipData || clipData.blocks.length === 0) {
+      handlePasteBlock();
+      return;
+    }
+    const allowedSlugs = new Set(BlockService.getForScope(entitySlug).map((b) => b.slug));
+    const compatible = clipData.blocks.filter((b) => allowedSlugs.has(b.blockSlug));
+    const skipped = clipData.blocks.length - compatible.length;
+    if (compatible.length === 0) {
+      toast.error(t("multiSelect.clipboardEmpty"));
+      return;
+    }
+    const newBlocks = compatible.map((b) => ({
+      id: uuidv4(),
+      blockSlug: b.blockSlug,
+      props: { ...b.props }
+    }));
+    const insertIdx = selectedBlockIds.size > 0 ? Math.max(...Array.from(selectedBlockIds).map((id2) => blocks.findIndex((b) => b.id === id2))) : blocks.length - 1;
+    const updatedBlocks = [...blocks];
+    updatedBlocks.splice(insertIdx + 1, 0, ...newBlocks);
+    setBlocks(updatedBlocks);
+    setSelectedBlockIds(new Set(newBlocks.map((b) => b.id)));
+    if (skipped > 0) {
+      toast.warning(t("multiSelect.pastedPartial", {
+        pasted: compatible.length,
+        total: clipData.blocks.length,
+        skipped
+      }));
+    } else {
+      toast.success(t("multiSelect.pasted", { count: newBlocks.length }));
+    }
+  }, [blocks, selectedBlockIds, entitySlug, t, handlePasteBlock]);
   const handleDuplicateBlock = useCallback((blockId) => {
     const block = blocks.find((b) => b.id === blockId);
     if (block) {
@@ -315,7 +436,7 @@ function BuilderEditorView({ entitySlug, entityConfig, id, mode, onEntityFieldCh
       setBlocks(newBlocks);
       setSelectedBlockId(duplicated.id);
     }
-  }, [blocks]);
+  }, [blocks, setSelectedBlockId]);
   const handleUpdateBlockProps = useCallback((blockId, props) => {
     setBlocks((prev) => prev.map(
       (block) => block.id === blockId ? { ...block, props } : block
@@ -342,6 +463,35 @@ function BuilderEditorView({ entitySlug, entityConfig, id, mode, onEntityFieldCh
       return newBlocks;
     });
   }, []);
+  useEffect(() => {
+    if (viewMode !== "preview") return;
+    const handler = (e) => {
+      const target = e.target;
+      const isInputFocused = target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable;
+      if (isInputFocused) return;
+      const isMod = e.metaKey || e.ctrlKey;
+      if (isMod && e.key === "a") {
+        e.preventDefault();
+        handleSelectAll();
+      } else if (e.key === "Escape") {
+        handleClearSelection();
+      } else if (isMod && e.key === "c" && selectedBlockIds.size > 0) {
+        e.preventDefault();
+        handleCopySelected();
+      } else if (isMod && e.key === "v") {
+        e.preventDefault();
+        handlePasteBlocks();
+      } else if (isMod && e.key === "d" && selectedBlockIds.size > 0) {
+        e.preventDefault();
+        handleDuplicateSelected();
+      } else if ((e.key === "Delete" || e.key === "Backspace") && selectedBlockIds.size > 0) {
+        e.preventDefault();
+        handleDeleteSelected();
+      }
+    };
+    document.addEventListener("keydown", handler);
+    return () => document.removeEventListener("keydown", handler);
+  }, [viewMode, selectedBlockIds, handleSelectAll, handleClearSelection, handleCopySelected, handlePasteBlocks, handleDuplicateSelected, handleDeleteSelected]);
   const handleEntityFieldChange = useCallback((field, value) => {
     setEntityFields((prev) => ({ ...prev, [field]: value }));
     onEntityFieldChangeProp == null ? void 0 : onEntityFieldChangeProp(field, value);
@@ -356,9 +506,9 @@ function BuilderEditorView({ entitySlug, entityConfig, id, mode, onEntityFieldCh
   const handleViewModeChange = useCallback((mode2) => {
     setViewMode(mode2);
     if (mode2 === "settings") {
-      setSelectedBlockId(null);
+      handleClearSelection();
     }
-  }, []);
+  }, [handleClearSelection]);
   const selectedBlock = selectedBlockId ? blocks.find((b) => b.id === selectedBlockId) : void 0;
   const publicUrl = useMemo(() => {
     var _a2, _b, _c;
@@ -613,16 +763,17 @@ function BuilderEditorView({ entitySlug, entityConfig, id, mode, onEntityFieldCh
           showPatternsTab,
           pageBlocks: blocks,
           selectedBlockId,
-          onSelectBlock: setSelectedBlockId,
+          selectedBlockIds,
+          onSelectBlock: handleSelectBlock,
           onReorderBlocks: handleReorderBlocks,
           onCopyBlock: handleCopyBlock,
           onDuplicateBlock: handleDuplicateBlock,
           onRemoveBlock: handleRemoveBlock,
-          onPasteBlock: handlePasteBlock,
-          hasClipboardBlock: clipboardHasBlock
+          onPasteBlock: handlePasteBlocks,
+          clipboardCount
         }
       ) }),
-      /* @__PURE__ */ jsxs("div", { className: "flex-1 overflow-hidden", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex-1 overflow-hidden relative", children: [
         /* @__PURE__ */ jsx(
           "div",
           {
@@ -644,8 +795,8 @@ function BuilderEditorView({ entitySlug, entityConfig, id, mode, onEntityFieldCh
                   BlockPreviewCanvas,
                   {
                     blocks,
-                    selectedBlockId,
-                    onSelectBlock: setSelectedBlockId,
+                    selectedBlockIds,
+                    onSelectBlock: handleSelectBlock,
                     onMoveUp: handleMoveBlockUp,
                     onMoveDown: handleMoveBlockDown,
                     onCopy: handleCopyBlock,
@@ -657,6 +808,18 @@ function BuilderEditorView({ entitySlug, entityConfig, id, mode, onEntityFieldCh
             )
           }
         ),
+        viewMode === "preview" && selectedBlockIds.size > 1 && /* @__PURE__ */ jsx(
+          BatchActionBar,
+          {
+            selectedCount: selectedBlockIds.size,
+            onCopy: handleCopySelected,
+            onDuplicate: handleDuplicateSelected,
+            onDelete: handleDeleteSelected,
+            onClearSelection: handleClearSelection,
+            clipboardCount,
+            onPaste: handlePasteBlocks
+          }
+        ),
         /* @__PURE__ */ jsx("div", { className: cn("h-full", viewMode !== "settings" && "hidden"), children: /* @__PURE__ */ jsx(
           ConfigPanel,
           {
@@ -672,6 +835,7 @@ function BuilderEditorView({ entitySlug, entityConfig, id, mode, onEntityFieldCh
         BlockSettingsPanel,
         {
           block: selectedBlock,
+          selectedCount: selectedBlockIds.size,
           onUpdateProps: (props) => {
             if (selectedBlockId) {
               handleUpdateBlockProps(selectedBlockId, props);
@@ -682,7 +846,7 @@ function BuilderEditorView({ entitySlug, entityConfig, id, mode, onEntityFieldCh
               handleRemoveBlock(selectedBlockId);
             }
           },
-          onClose: () => setSelectedBlockId(null)
+          onClose: handleClearSelection
         }
       ) })
     ] })

package/dist/components/dashboard/block-editor/tree-view-node.d.ts

@@ -3,12 +3,17 @@ import { type PatternReference } from '../../../types/pattern-reference';
 interface TreeViewNodeProps {
     block: BlockInstance | PatternReference;
     isSelected: boolean;
-    onSelect: () => void;
+    isMultiSelect?: boolean;
+    onSelect: (event?: {
+        metaKey?: boolean;
+        shiftKey?: boolean;
+        ctrlKey?: boolean;
+    }) => void;
     onCopy?: () => void;
     onDuplicate?: () => void;
     onRemove?: () => void;
     isPartOfPattern?: boolean;
 }
-export declare function TreeViewNode({ block, isSelected, onSelect, onCopy, onDuplicate, onRemove, isPartOfPattern }: TreeViewNodeProps): import("react/jsx-runtime").JSX.Element;
+export declare function TreeViewNode({ block, isSelected, isMultiSelect, onSelect, onCopy, onDuplicate, onRemove, isPartOfPattern }: TreeViewNodeProps): import("react/jsx-runtime").JSX.Element;
 export {};
 //# sourceMappingURL=tree-view-node.d.ts.map

package/dist/components/dashboard/block-editor/tree-view-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree-view-node.d.ts","sourceRoot":"","sources":["../../../../src/components/dashboard/block-editor/tree-view-node.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,EAAsB,KAAK,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AAE5F,UAAU,iBAAiB;IACzB,KAAK,EAAE,aAAa,GAAG,gBAAgB,CAAA;IACvC,UAAU,EAAE,OAAO,CAAA;IACnB,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;IACxB,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;IACrB,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;AAED,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,UAAU,EACV,QAAQ,EACR,MAAM,EACN,WAAW,EACX,QAAQ,EACR,eAAuB,EACxB,EAAE,iBAAiB,2CA6HnB"}
+{"version":3,"file":"tree-view-node.d.ts","sourceRoot":"","sources":["../../../../src/components/dashboard/block-editor/tree-view-node.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,EAAsB,KAAK,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AAE5F,UAAU,iBAAiB;IACzB,KAAK,EAAE,aAAa,GAAG,gBAAgB,CAAA;IACvC,UAAU,EAAE,OAAO,CAAA;IACnB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAA;IACxF,MAAM,CAAC,EAAE,MAAM,IAAI,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;IACxB,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;IACrB,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;AAED,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,UAAU,EACV,aAAqB,EACrB,QAAQ,EACR,MAAM,EACN,WAAW,EACX,QAAQ,EACR,eAAuB,EACxB,EAAE,iBAAiB,2CA6InB"}

package/dist/components/dashboard/block-editor/tree-view-node.js

@@ -2,7 +2,7 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { useSortable } from "@dnd-kit/sortable";
 import { CSS } from "@dnd-kit/utilities";
-import { GripVertical, ClipboardCopy, Copy, Trash2 } from "lucide-react";
+import { GripVertical, ClipboardCopy, Copy, Trash2, Check } from "lucide-react";
 import { cn } from "../../../lib/utils/index.js";
 import { sel } from "../../../lib/test/index.js";
 import { BlockService } from "../../../lib/services/block.service.js";
@@ -11,6 +11,7 @@ import { isPatternReference } from "../../../types/pattern-reference.js";
 function TreeViewNode({
   block,
   isSelected,
+  isMultiSelect = false,
   onSelect,
   onCopy,
   onDuplicate,
@@ -46,12 +47,24 @@ function TreeViewNode({
       className: cn(
         "group flex items-center gap-2 px-2 py-1.5 rounded-md cursor-pointer transition-colors",
         "hover:bg-muted/80",
-        isSelected && "bg-primary/10 ring-1 ring-primary",
+        isSelected && !isMultiSelect && "bg-primary/10 ring-1 ring-primary",
+        isSelected && isMultiSelect && "bg-primary/10 ring-1 ring-primary/70",
         isPartOfPattern && "ml-4 border-l-2 border-muted-foreground/20",
         isDragging && "z-50"
       ),
-      onClick: onSelect,
+      onClick: (e) => onSelect({ metaKey: e.metaKey, shiftKey: e.shiftKey, ctrlKey: e.ctrlKey }),
       children: [
+        isMultiSelect && !isPartOfPattern && /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: cn(
+              "flex items-center justify-center w-4 h-4 rounded border shrink-0 transition-colors",
+              isSelected ? "bg-primary border-primary text-primary-foreground" : "border-muted-foreground/30 hover:border-primary"
+            ),
+            "data-cy": sel("blockEditor.treeView.nodeCheckbox", { id: block.id }),
+            children: isSelected && /* @__PURE__ */ jsx(Check, { className: "h-3 w-3" })
+          }
+        ),
         !isPartOfPattern && /* @__PURE__ */ jsx(
           "div",
           {

package/dist/components/dashboard/block-editor/tree-view.d.ts

@@ -3,7 +3,12 @@ import type { BlockInstance } from '../../../types/blocks';
 interface TreeViewProps {
     blocks: (BlockInstance | PatternReference)[];
     selectedBlockId: string | null;
-    onSelectBlock: (id: string) => void;
+    selectedBlockIds?: Set<string>;
+    onSelectBlock: (id: string, event?: {
+        metaKey?: boolean;
+        shiftKey?: boolean;
+        ctrlKey?: boolean;
+    }) => void;
     onReorder: (blocks: (BlockInstance | PatternReference)[]) => void;
     onCopy?: (id: string) => void;
     onDuplicate?: (id: string) => void;
@@ -15,6 +20,6 @@ interface TreeViewProps {
  * Displays a tree structure of all blocks with drag & drop reordering.
  * Clicking a block selects it and scrolls to it in the preview.
  */
-export declare function TreeView({ blocks, selectedBlockId, onSelectBlock, onReorder, onCopy, onDuplicate, onRemove, emptyMessage }: TreeViewProps): import("react/jsx-runtime").JSX.Element;
+export declare function TreeView({ blocks, selectedBlockId, selectedBlockIds, onSelectBlock, onReorder, onCopy, onDuplicate, onRemove, emptyMessage }: TreeViewProps): import("react/jsx-runtime").JSX.Element;
 export {};
 //# sourceMappingURL=tree-view.d.ts.map

package/dist/components/dashboard/block-editor/tree-view.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree-view.d.ts","sourceRoot":"","sources":["../../../../src/components/dashboard/block-editor/tree-view.tsx"],"names":[],"mappings":"AAwBA,OAAO,EAAsB,KAAK,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AAC5F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAE1D,UAAU,aAAa;IACrB,MAAM,EAAE,CAAC,aAAa,GAAG,gBAAgB,CAAC,EAAE,CAAA;IAC5C,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,aAAa,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC,SAAS,EAAE,CAAC,MAAM,EAAE,CAAC,aAAa,GAAG,gBAAgB,CAAC,EAAE,KAAK,IAAI,CAAA;IACjE,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7B,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IAC/B,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,EACvB,MAAM,EACN,eAAe,EACf,aAAa,EACb,SAAS,EACT,MAAM,EACN,WAAW,EACX,QAAQ,EACR,YAAY,EACb,EAAE,aAAa,2CAkHf"}
+{"version":3,"file":"tree-view.d.ts","sourceRoot":"","sources":["../../../../src/components/dashboard/block-editor/tree-view.tsx"],"names":[],"mappings":"AAwBA,OAAO,EAAsB,KAAK,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AAC5F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAE1D,UAAU,aAAa;IACrB,MAAM,EAAE,CAAC,aAAa,GAAG,gBAAgB,CAAC,EAAE,CAAA;IAC5C,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,gBAAgB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC9B,aAAa,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAA;IACzG,SAAS,EAAE,CAAC,MAAM,EAAE,CAAC,aAAa,GAAG,gBAAgB,CAAC,EAAE,KAAK,IAAI,CAAA;IACjE,MAAM,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7B,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IAC/B,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,EACvB,MAAM,EACN,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,MAAM,EACN,WAAW,EACX,QAAQ,EACR,YAAY,EACb,EAAE,aAAa,2CAqHf"}

package/dist/components/dashboard/block-editor/tree-view.js

@@ -24,6 +24,7 @@ import { isPatternReference } from "../../../types/pattern-reference.js";
 function TreeView({
   blocks,
   selectedBlockId,
+  selectedBlockIds,
   onSelectBlock,
   onReorder,
   onCopy,
@@ -74,8 +75,9 @@ function TreeView({
       }
     }
   }, [selectedBlockId]);
-  const handleSelectBlock = useCallback((blockId) => {
-    onSelectBlock(blockId);
+  const isMultiSelect = ((selectedBlockIds == null ? void 0 : selectedBlockIds.size) ?? 0) > 1;
+  const handleSelectBlock = useCallback((blockId, event) => {
+    onSelectBlock(blockId, event);
   }, [onSelectBlock]);
   if (blocks.length === 0) {
     return /* @__PURE__ */ jsxs(
@@ -110,8 +112,9 @@ function TreeView({
                 TreeViewNode,
                 {
                   block: item.block,
-                  isSelected: selectedBlockId === item.id,
-                  onSelect: () => handleSelectBlock(item.id),
+                  isSelected: selectedBlockIds ? selectedBlockIds.has(item.id) : selectedBlockId === item.id,
+                  isMultiSelect,
+                  onSelect: (event) => handleSelectBlock(item.id, event),
                   onCopy: onCopy ? () => onCopy(item.id) : void 0,
                   onDuplicate: onDuplicate ? () => onDuplicate(item.id) : void 0,
                   onRemove: onRemove ? () => onRemove(item.id) : void 0,

package/dist/lib/blocks/clipboard.d.ts

@@ -2,10 +2,17 @@ import type { BlockInstance } from '../../types/blocks';
 export interface ClipboardBlock {
     blockSlug: string;
     props: Record<string, unknown>;
+}
+export interface ClipboardData {
+    blocks: ClipboardBlock[];
+    sourceEntitySlug?: string;
     copiedAt: number;
 }
+export declare function copyBlocksToClipboard(blocks: BlockInstance[], sourceEntitySlug?: string): void;
 export declare function copyBlockToClipboard(block: BlockInstance): void;
+export declare function getBlocksFromClipboard(): ClipboardData | null;
 export declare function getBlockFromClipboard(): ClipboardBlock | null;
-export declare function hasBlockInClipboard(): boolean;
+export declare function getClipboardBlockCount(): number;
+export declare function hasClipboardBlocks(): boolean;
 export declare function clearBlockClipboard(): void;
 //# sourceMappingURL=clipboard.d.ts.map

package/dist/lib/blocks/clipboard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clipboard.d.ts","sourceRoot":"","sources":["../../../src/lib/blocks/clipboard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAIvD,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAO/D;AAED,wBAAgB,qBAAqB,IAAI,cAAc,GAAG,IAAI,CAQ7D;AAED,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C"}
+{"version":3,"file":"clipboard.d.ts","sourceRoot":"","sources":["../../../src/lib/blocks/clipboard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAIvD,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,cAAc,EAAE,CAAA;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,EAAE,EAAE,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAU9F;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAE/D;AAED,wBAAgB,sBAAsB,IAAI,aAAa,GAAG,IAAI,CAY7D;AAED,wBAAgB,qBAAqB,IAAI,cAAc,GAAG,IAAI,CAI7D;AAED,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C;AAED,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C"}

package/dist/lib/blocks/clipboard.js

@@ -1,23 +1,42 @@
 const CLIPBOARD_KEY = "nextspark:block-clipboard";
-function copyBlockToClipboard(block) {
+function copyBlocksToClipboard(blocks, sourceEntitySlug) {
   const data = {
-    blockSlug: block.blockSlug,
-    props: { ...block.props },
+    blocks: blocks.map((b) => ({
+      blockSlug: b.blockSlug,
+      props: { ...b.props }
+    })),
+    sourceEntitySlug,
     copiedAt: Date.now()
   };
   localStorage.setItem(CLIPBOARD_KEY, JSON.stringify(data));
 }
-function getBlockFromClipboard() {
+function copyBlockToClipboard(block) {
+  copyBlocksToClipboard([block]);
+}
+function getBlocksFromClipboard() {
   const raw = localStorage.getItem(CLIPBOARD_KEY);
   if (!raw) return null;
   try {
-    return JSON.parse(raw);
+    const data = JSON.parse(raw);
+    if (Array.isArray(data == null ? void 0 : data.blocks)) {
+      return data;
+    }
+    return null;
   } catch {
     return null;
   }
 }
-function hasBlockInClipboard() {
-  return localStorage.getItem(CLIPBOARD_KEY) !== null;
+function getBlockFromClipboard() {
+  const data = getBlocksFromClipboard();
+  if (!data || data.blocks.length === 0) return null;
+  return data.blocks[data.blocks.length - 1];
+}
+function getClipboardBlockCount() {
+  var _a;
+  return ((_a = getBlocksFromClipboard()) == null ? void 0 : _a.blocks.length) ?? 0;
+}
+function hasClipboardBlocks() {
+  return getClipboardBlockCount() > 0;
 }
 function clearBlockClipboard() {
   localStorage.removeItem(CLIPBOARD_KEY);
@@ -25,6 +44,9 @@ function clearBlockClipboard() {
 export {
   clearBlockClipboard,
   copyBlockToClipboard,
+  copyBlocksToClipboard,
   getBlockFromClipboard,
-  hasBlockInClipboard
+  getBlocksFromClipboard,
+  getClipboardBlockCount,
+  hasClipboardBlocks
 };

package/dist/messages/en/admin.json

@@ -306,13 +306,32 @@
     },
     "layout": {
       "empty": "No blocks added yet",
-      "pasteBlock": "Paste block"
+      "pasteBlock": "Paste block",
+      "pasteBlocks": "Paste {count} blocks"
     },
     "messages": {
       "saved": "Saved successfully",
       "created": "Created successfully",
       "blockCopied": "Block copied to clipboard",
       "blockPasted": "Block pasted"
+    },
+    "multiSelect": {
+      "selected": "{count, plural, one {# block selected} other {# blocks selected}}",
+      "selectAll": "Select all",
+      "deselectAll": "Deselect all",
+      "copy": "Copy",
+      "copied": "{count, plural, one {Block copied} other {# blocks copied}}",
+      "paste": "Paste",
+      "pasted": "{count, plural, one {Block pasted} other {# blocks pasted}}",
+      "pastedPartial": "{pasted} of {total} blocks pasted ({skipped} incompatible)",
+      "duplicate": "Duplicate",
+      "duplicated": "{count, plural, one {Block duplicated} other {# blocks duplicated}}",
+      "delete": "Delete",
+      "deleteConfirm": "{count, plural, one {Delete this block?} other {Delete # blocks?}}",
+      "deleted": "{count, plural, one {Block deleted} other {# blocks deleted}}",
+      "patternSkipped": "Pattern references excluded from selection",
+      "clipboardEmpty": "Clipboard is empty",
+      "settingsHint": "Use the action bar to manage selected blocks"
     }
   },
   "patterns": {

package/dist/messages/en/index.d.ts

@@ -308,6 +308,7 @@ declare const _default: {
             layout: {
                 empty: string;
                 pasteBlock: string;
+                pasteBlocks: string;
             };
             messages: {
                 saved: string;
@@ -315,6 +316,24 @@ declare const _default: {
                 blockCopied: string;
                 blockPasted: string;
             };
+            multiSelect: {
+                selected: string;
+                selectAll: string;
+                deselectAll: string;
+                copy: string;
+                copied: string;
+                paste: string;
+                pasted: string;
+                pastedPartial: string;
+                duplicate: string;
+                duplicated: string;
+                delete: string;
+                deleteConfirm: string;
+                deleted: string;
+                patternSkipped: string;
+                clipboardEmpty: string;
+                settingsHint: string;
+            };
         };
         patterns: {
             delete: {

package/dist/messages/en/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/messages/en/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,wBAqBU"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/messages/en/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,wBAqBU"}