shadow-claw 1.23.4 → 1.24.0

package/src/components/shadow-claw-file-viewer/shadow-claw-file-viewer.test.ts

@@ -1862,4 +1862,277 @@ describe("shadow-claw-file-viewer", () => {
       expect(resolved).toContain("data:image/png;base64,iVBORw==");
     });
   });
+
+  describe("syncIframeTheme & storage proxy bridge", () => {
+    it("syncs theme and custom properties to previewFrameWindow", () => {
+      const component = new ShadowClawFileViewer() as any;
+      const mockPostMessage = jest.fn();
+      component.previewFrameWindow = { postMessage: mockPostMessage };
+
+      component.syncIframeTheme();
+
+      expect(mockPostMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: "shadow-claw-theme-update",
+          theme: expect.any(String),
+          customProperties: expect.any(Object),
+        }),
+        "*",
+      );
+    });
+
+    it("handles storage proxy requests (setItem, removeItem, getAllItems, idb-put, idb-get)", async () => {
+      const component = new ShadowClawFileViewer() as any;
+      const mockSource = { postMessage: jest.fn() };
+
+      (fileViewerStore as any).file = { path: "demo.html", name: "demo.html" };
+
+      // 1. setItem
+      await component.handleStorageProxyRequest(
+        mockSource,
+        "req-1",
+        "setItem",
+        {
+          key: "pref",
+          value: "dark",
+        },
+      );
+      expect(mockSource.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: "shadow-claw-storage-proxy-result",
+          requestId: "req-1",
+          result: null,
+        }),
+        "*",
+      );
+
+      // 2. idb-put
+      await component.handleStorageProxyRequest(
+        mockSource,
+        "req-2",
+        "idb-put",
+        {
+          dbName: "test-db",
+          storeName: "items",
+          key: "k1",
+          value: { foo: "bar" },
+        },
+      );
+      expect(mockSource.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: "shadow-claw-storage-proxy-result",
+          requestId: "req-2",
+          result: "k1",
+        }),
+        "*",
+      );
+
+      // 3. Unknown method sends error
+      await component.handleStorageProxyRequest(
+        mockSource,
+        "req-3",
+        "unknownMethod",
+        {},
+      );
+      expect(mockSource.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: "shadow-claw-storage-proxy-result",
+          requestId: "req-3",
+          error: expect.stringContaining("Unknown storage proxy method"),
+        }),
+        "*",
+      );
+    });
+
+    it("builds web share File instances from native files and binary buffers", () => {
+      const component = new ShadowClawFileViewer() as any;
+
+      const native = new File(["content"], "test.txt", {
+        type: "text/plain",
+      });
+      expect(component.buildWebShareFile({ nativeFile: native })).toBe(native);
+
+      const binaryFile = component.buildWebShareFile({
+        name: "data.bin",
+        binaryContent: new Uint8Array([1, 2, 3]),
+        mimeType: "application/octet-stream",
+      });
+      expect(binaryFile).toBeInstanceOf(File);
+      expect(binaryFile.name).toBe("data.bin");
+
+      expect(component.buildWebShareFile(null)).toBeNull();
+      expect(component.buildWebShareFile({ binaryContent: null })).toBeNull();
+      expect(
+        component.buildWebShareFile({ binaryContent: new Uint8Array([]) }),
+      ).toBeNull();
+    });
+
+    it("cleans up resources and disconnects observers on disconnectedCallback", () => {
+      const component = new ShadowClawFileViewer() as any;
+      const disposeMock = jest.fn();
+      component.broadcastProxy = { dispose: disposeMock };
+      const disconnectMock = jest.fn();
+      component.themeObserver = { disconnect: disconnectMock };
+      const revokeMock = jest.spyOn(component, "revokeObjectUrl");
+
+      component.disconnectedCallback();
+
+      expect(disposeMock).toHaveBeenCalledTimes(1);
+      expect(component.broadcastProxy).toBeNull();
+      expect(disconnectMock).toHaveBeenCalledTimes(1);
+      expect(component.themeObserver).toBeNull();
+      expect(revokeMock).toHaveBeenCalledTimes(1);
+    });
+
+    it("synchronizes iframe theme with document dark/light mode class", () => {
+      const component = new ShadowClawFileViewer() as any;
+      const mockPostMessage = jest.fn();
+      component.previewFrameWindow = { postMessage: mockPostMessage };
+
+      document.documentElement.className = "dark-theme";
+      component.syncIframeTheme();
+
+      expect(mockPostMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: "shadow-claw-theme-update",
+        }),
+        "*",
+      );
+    });
+
+    it("handles openFolderInFilesView, openWorkspaceLink, and viewer dismissal", async () => {
+      const component = new ShadowClawFileViewer() as any;
+      component.db = {} as any;
+
+      // 1. openFolderInFilesView
+      await component.openFolderInFilesView("docs/subfolder/");
+      expect(orchestratorStore.setCurrentPath).toHaveBeenCalledWith(
+        component.db,
+        "docs/subfolder",
+      );
+      expect(fileViewerStore.closeFile).toHaveBeenCalled();
+
+      // 2. openWorkspaceLink with extension
+      await component.openWorkspaceLink("notes.txt", "docs");
+      expect(fileViewerStore.openFile).toHaveBeenCalledWith(
+        component.db,
+        expect.any(String),
+        expect.any(String),
+      );
+
+      // 3. canDismissViewer when not dirty
+      component.isDirty = false;
+      const canDismiss = await component.canDismissViewer();
+      expect(canDismiss).toBe(true);
+
+      // 4. canDismissViewer when dirty
+      component.isDirty = true;
+      component.requestConfirmation = jest.fn<any>().mockResolvedValue(true);
+      const canDismissDirty = await component.canDismissViewer();
+      expect(canDismissDirty).toBe(true);
+
+      // 5. requestCloseViewer
+      component.isDirty = false;
+      const closed = await component.requestCloseViewer();
+      expect(closed).toBe(true);
+      expect(fileViewerStore.closeFile).toHaveBeenCalled();
+    });
+
+    it("handles handleSave, handleShareFile, and toggleFullscreenMode", async () => {
+      const { ShadowClawFileViewer } =
+        await import("./shadow-claw-file-viewer.js");
+      const { writeGroupFile } =
+        await import("../../storage/writeGroupFile.js");
+
+      const component = new ShadowClawFileViewer() as any;
+      document.body.appendChild(component);
+      component.db = {} as any;
+
+      // 1. handleSave
+      (fileViewerStore as any).file = {
+        name: "test.txt",
+        path: "docs/test.txt",
+        kind: "text",
+        content: "old content",
+        groupId: "g1",
+      };
+      let editor = component.shadowRoot?.querySelector(".file-editor");
+      if (!editor) {
+        editor = document.createElement("textarea");
+        editor.className = "file-editor";
+        component.shadowRoot?.appendChild(editor);
+      }
+      editor.value = "new content";
+
+      await component.handleSave();
+      expect(writeGroupFile).toHaveBeenCalledWith(
+        component.db,
+        "g1",
+        "docs/test.txt",
+        "new content",
+      );
+
+      // 2. handleShareFile
+      const mockShare = jest.fn<any>().mockResolvedValue(undefined);
+      Object.defineProperty(navigator, "share", {
+        value: mockShare,
+        configurable: true,
+        writable: true,
+      });
+      await component.handleShareFile();
+      expect(mockShare).toHaveBeenCalledWith(
+        expect.objectContaining({ title: "test.txt" }),
+      );
+
+      // 3. renderBinaryPreview - empty
+      const contentEl = document.createElement("div");
+      component.renderBinaryPreview(contentEl, {
+        name: "empty.bin",
+        mimeType: "application/octet-stream",
+        binaryContent: new Uint8Array(0),
+      });
+      expect(contentEl.textContent).toBe("Binary content unavailable.");
+
+      // 4. renderBinaryPreview - image
+      (global.URL.createObjectURL as any) = jest
+        .fn<any>()
+        .mockReturnValue("blob:image-url");
+      component.renderBinaryPreview(contentEl, {
+        name: "img.jpg",
+        mimeType: "image/jpeg",
+        binaryContent: new Uint8Array([1, 2, 3]),
+      });
+      expect(contentEl.querySelector("img")).not.toBeNull();
+
+      // 5. renderBinaryPreview - video
+      component.renderBinaryPreview(contentEl, {
+        name: "clip.mp4",
+        mimeType: "video/mp4",
+        binaryContent: new Uint8Array([1, 2, 3]),
+      });
+      expect(contentEl.querySelector("video")).not.toBeNull();
+
+      // 6. renderBinaryPreview - audio
+      component.renderBinaryPreview(contentEl, {
+        name: "song.mp3",
+        mimeType: "audio/mp3",
+        binaryContent: new Uint8Array([1, 2, 3]),
+      });
+      expect(contentEl.querySelector("audio")).not.toBeNull();
+
+      // 7. renderBinaryPreview - iframe/pdf
+      component.renderBinaryPreview(contentEl, {
+        name: "doc.pdf",
+        mimeType: "application/pdf",
+        binaryContent: new Uint8Array([1, 2, 3]),
+      });
+      expect(contentEl.querySelector("iframe")).not.toBeNull();
+
+      // 8. resetContent
+      component.resetContent();
+      expect(component.isFullscreenMode).toBe(false);
+
+      document.body.removeChild(component);
+    });
+  });
 });

package/src/components/shadow-claw-files/shadow-claw-files.test.ts

@@ -92,7 +92,7 @@ jest.unstable_mockModule("../../stores/orchestrator.js", () => ({
     pages: [] as Array<{ groupId: string; path: string }>,
     addPage: mockAddPage,
     removePage: mockRemovePage,
-    loadFiles: jest.fn(),
+    loadFiles: jest.fn<any>().mockResolvedValue(undefined),
     db: {},
     triggerFilesRefresh: jest.fn(),
     orchestrator: {
@@ -136,6 +136,12 @@ describe("shadow-claw-files", () => {
     (orchestratorStore as any).files = [];
     (mockAddPage as any).mockResolvedValue(undefined);
     (mockRemovePage as any).mockResolvedValue(undefined);
+    (writeGroupFile as any).mockResolvedValue(undefined);
+    (createGroupDirectory as any).mockResolvedValue(undefined);
+    (renameGroupEntry as any).mockResolvedValue(undefined);
+    (copyGroupEntry as any).mockResolvedValue(undefined);
+    (moveGroupEntry as any).mockResolvedValue(undefined);
+    (uploadGroupFile as any).mockResolvedValue(undefined);
   });
 
   it("registers custom element", () => {
@@ -1129,4 +1135,405 @@ describe("shadow-claw-files", () => {
 
     document.body.removeChild(component);
   });
+
+  describe("files component helpers and operations", () => {
+    it("escapes html text", () => {
+      const component = new ShadowClawFiles();
+      expect(component.escapeHtml("<tag>")).toBe("&lt;tag&gt;");
+    });
+
+    it("identifies page candidate files correctly", () => {
+      const component = new ShadowClawFiles();
+      expect(component.isPageCandidateFile("index.md", false)).toBe(true);
+      expect(component.isPageCandidateFile("index.html", false)).toBe(true);
+      expect(component.isPageCandidateFile("index.htm", false)).toBe(true);
+      expect(component.isPageCandidateFile("index.xhtml", false)).toBe(true);
+      expect(component.isPageCandidateFile("index.markdown", false)).toBe(true);
+      expect(component.isPageCandidateFile("script.js", false)).toBe(false);
+      expect(component.isPageCandidateFile("folder.md", true)).toBe(false);
+    });
+
+    it("detects invalid folder paste targets", () => {
+      const component = new ShadowClawFiles();
+      expect(
+        component.isInvalidFolderPasteTarget(
+          { sourcePath: "docs", isDirectory: false },
+          "docs/sub",
+        ),
+      ).toBe(false);
+      expect(
+        component.isInvalidFolderPasteTarget(
+          { sourcePath: "docs", isDirectory: true },
+          ".",
+        ),
+      ).toBe(false);
+      expect(
+        component.isInvalidFolderPasteTarget(
+          { sourcePath: "docs", isDirectory: true },
+          "docs",
+        ),
+      ).toBe(true);
+      expect(
+        component.isInvalidFolderPasteTarget(
+          { sourcePath: "docs", isDirectory: true },
+          "docs/nested",
+        ),
+      ).toBe(true);
+      expect(
+        component.isInvalidFolderPasteTarget(
+          { sourcePath: "docs", isDirectory: true },
+          "other-dir",
+        ),
+      ).toBe(false);
+    });
+
+    it("detects drag files in DragEvent", () => {
+      const component = new ShadowClawFiles();
+      expect(component.hasDragFiles({ dataTransfer: null } as any)).toBe(false);
+      expect(
+        component.hasDragFiles({
+          dataTransfer: { types: ["text/plain"] },
+        } as any),
+      ).toBe(false);
+      expect(
+        component.hasDragFiles({ dataTransfer: { types: ["Files"] } } as any),
+      ).toBe(true);
+    });
+
+    it("handles syncHostToVM action", () => {
+      const component = new ShadowClawFiles();
+      document.body.appendChild(component);
+
+      const button = document.createElement("button");
+      button.className = "files__sync-host-btn";
+      component.shadowRoot?.appendChild(button);
+
+      (orchestratorStore as any).syncHostWorkspaceToVM = jest.fn();
+
+      component.handleSyncHostToVM();
+
+      expect(
+        (orchestratorStore as any).syncHostWorkspaceToVM,
+      ).toHaveBeenCalled();
+      expect(showSuccess).toHaveBeenCalledWith(
+        "Requested host → VM workspace sync",
+        2200,
+      );
+
+      document.body.removeChild(component);
+    });
+
+    it("handles syncVMToHost action", async () => {
+      const component = new ShadowClawFiles();
+      document.body.appendChild(component);
+
+      const button = document.createElement("button");
+      button.className = "files__sync-vm-btn";
+      component.shadowRoot?.appendChild(button);
+
+      (orchestratorStore as any).syncVMWorkspaceToHost = jest.fn();
+
+      await component.handleSyncVMToHost({} as any);
+
+      expect(
+        (orchestratorStore as any).syncVMWorkspaceToHost,
+      ).toHaveBeenCalled();
+      expect(showSuccess).toHaveBeenCalledWith(
+        "Requested VM → host workspace sync",
+        2200,
+      );
+
+      document.body.removeChild(component);
+    });
+
+    it("handles backup (download all zip) and clear all files", async () => {
+      const component = new ShadowClawFiles();
+      const db = {} as any;
+
+      const { downloadAllGroupFilesAsZip } =
+        await import("../../storage/downloadAllGroupFilesAsZip.js");
+      const { deleteAllGroupFiles } =
+        await import("../../storage/deleteAllGroupFiles.js");
+
+      // 1. Backup
+      await component.handleBackup(db);
+      expect(downloadAllGroupFilesAsZip).toHaveBeenCalledWith(db, "default");
+      expect(showSuccess).toHaveBeenCalledWith(
+        "Backup created successfully",
+        3000,
+      );
+
+      // 2. Clear all
+      component.requestConfirmation = jest.fn<any>().mockResolvedValue(true);
+      (orchestratorStore as any).resetToRootFolder = jest.fn();
+
+      await component.handleClearAll(db);
+      expect(deleteAllGroupFiles).toHaveBeenCalledWith(db, "default");
+      expect(showSuccess).toHaveBeenCalledWith("All files deleted", 3500);
+    });
+
+    it("handles create new file and folder flows with validation", async () => {
+      const component = new ShadowClawFiles() as any;
+      document.body.appendChild(component);
+      const db = {} as any;
+
+      const { writeGroupFile } =
+        await import("../../storage/writeGroupFile.js");
+      const { createGroupDirectory } =
+        await import("../../storage/createGroupDirectory.js");
+
+      const dialog = component.shadowRoot?.querySelector(".files__new-dialog");
+      if (dialog) (dialog as any).close = jest.fn();
+
+      const input = component.shadowRoot?.querySelector(
+        ".files__new-input",
+      ) as HTMLInputElement;
+      const isFolderInput = component.shadowRoot?.querySelector(
+        ".files__new-is-folder",
+      ) as HTMLInputElement;
+
+      // 1. Validation: empty name
+      if (input) input.value = "";
+      await component.handleCreateNewFile(db);
+      expect(showWarning).toHaveBeenCalledWith(
+        "Please enter a file name",
+        3000,
+      );
+
+      // 2. Validation: slashes in name
+      if (input) input.value = "folder/file.txt";
+      await component.handleCreateNewFile(db);
+      expect(showWarning).toHaveBeenCalledWith(
+        "Use only a file name, not a path",
+        3500,
+      );
+
+      // 3. Create file successfully
+      if (input) input.value = "test.txt";
+      if (isFolderInput) isFolderInput.checked = false;
+      await component.handleCreateNewFile(db);
+      expect(writeGroupFile).toHaveBeenCalledWith(
+        db,
+        "default",
+        "test.txt",
+        "",
+      );
+      expect(showSuccess).toHaveBeenCalledWith("Created file: test.txt", 3000);
+
+      // 4. Create folder successfully
+      if (input) input.value = "docs";
+      if (isFolderInput) isFolderInput.checked = true;
+      await component.handleCreateNewFile(db);
+      expect(createGroupDirectory).toHaveBeenCalledWith(db, "default", "docs");
+      expect(showSuccess).toHaveBeenCalledWith("Created folder: docs", 3000);
+
+      document.body.removeChild(component);
+    });
+
+    it("handles rename entry flow for files and folders", async () => {
+      const component = new ShadowClawFiles() as any;
+      document.body.appendChild(component);
+      const db = {} as any;
+
+      const { renameGroupEntry } =
+        await import("../../storage/renameGroupEntry.js");
+
+      const dialog = component.shadowRoot?.querySelector(
+        ".files__rename-dialog",
+      );
+      if (dialog) (dialog as any).close = jest.fn();
+
+      const input = component.shadowRoot?.querySelector(
+        ".files__rename-input",
+      ) as HTMLInputElement;
+
+      component._pendingRenamePath = "old.txt";
+      component._pendingRenameName = "old.txt";
+      component._pendingRenameIsDirectory = false;
+
+      // 1. Validation: empty name
+      if (input) input.value = "";
+      await component.handleRenameEntry(db);
+      expect(showWarning).toHaveBeenCalledWith("Please enter a name", 3000);
+
+      // 2. Validation: path with slashes
+      if (input) input.value = "sub/new.txt";
+      await component.handleRenameEntry(db);
+      expect(showWarning).toHaveBeenCalledWith(
+        "Use only a name, not a path",
+        3500,
+      );
+
+      // 3. Same name closes dialog without calling renameGroupEntry
+      if (input) input.value = "old.txt";
+      await component.handleRenameEntry(db);
+      expect(renameGroupEntry).not.toHaveBeenCalled();
+
+      // 4. Successful file rename
+      component._pendingRenamePath = "old.txt";
+      component._pendingRenameName = "old.txt";
+      component._pendingRenameIsDirectory = false;
+      if (input) input.value = "new.txt";
+      await component.handleRenameEntry(db);
+      expect(renameGroupEntry).toHaveBeenCalledWith(
+        db,
+        "default",
+        "old.txt",
+        "new.txt",
+      );
+      expect(showSuccess).toHaveBeenCalledWith(
+        "Renamed file: old.txt -> new.txt",
+        3200,
+      );
+
+      // 5. Successful folder rename
+      component._pendingRenamePath = "old-folder";
+      component._pendingRenameName = "old-folder";
+      component._pendingRenameIsDirectory = true;
+      if (input) input.value = "new-folder";
+      await component.handleRenameEntry(db);
+      expect(renameGroupEntry).toHaveBeenCalledWith(
+        db,
+        "default",
+        "old-folder",
+        "new-folder",
+      );
+      expect(showSuccess).toHaveBeenCalledWith(
+        "Renamed folder: old-folder -> new-folder",
+        3200,
+      );
+
+      document.body.removeChild(component);
+    });
+
+    it("handles restore and upload file actions", async () => {
+      const component = new ShadowClawFiles() as any;
+      document.body.appendChild(component);
+      const db = {} as any;
+
+      const { restoreAllGroupFilesFromZip } =
+        await import("../../storage/restoreAllGroupFilesFromZip.js");
+      const { uploadGroupFile } =
+        await import("../../storage/uploadGroupFile.js");
+
+      // 1. Restore non-zip warning
+      const nonZipInput = {
+        files: [{ name: "test.txt" }],
+        value: "test.txt",
+      } as any;
+      await component.handleRestore(db, nonZipInput);
+      expect(showWarning).toHaveBeenCalledWith(
+        "Please select a .zip file",
+        3500,
+      );
+
+      // 2. Restore cancelled confirmation
+      component.requestConfirmation = jest.fn<any>().mockResolvedValue(false);
+      const zipFile = new File(["zipcontent"], "backup.zip", {
+        type: "application/zip",
+      });
+      const zipInput = {
+        files: [zipFile],
+        value: "backup.zip",
+      } as any;
+      await component.handleRestore(db, zipInput);
+      expect(restoreAllGroupFilesFromZip).not.toHaveBeenCalled();
+
+      // 3. Restore confirmed
+      component.requestConfirmation = jest.fn<any>().mockResolvedValue(true);
+      await component.handleRestore(db, zipInput);
+      expect(restoreAllGroupFilesFromZip).toHaveBeenCalledWith(
+        db,
+        "default",
+        zipFile,
+      );
+      expect(showSuccess).toHaveBeenCalledWith(
+        "Files restored successfully",
+        3500,
+      );
+
+      // 4. Upload file
+      const uploadFile = new File(["content"], "upload.txt", {
+        type: "text/plain",
+      });
+      const uploadInput = {
+        files: [uploadFile],
+        value: "upload.txt",
+      } as any;
+      await component.handleUpload(db, uploadInput);
+      expect(uploadGroupFile).toHaveBeenCalledWith(
+        db,
+        "default",
+        "upload.txt",
+        uploadFile,
+      );
+      expect(showSuccess).toHaveBeenCalledWith("Uploaded 1 file", 3000);
+
+      // 5. handleSyncVMToHost
+      const syncBtn = document.createElement("button");
+      syncBtn.className = "files__sync-vm-btn";
+      component.shadowRoot?.appendChild(syncBtn);
+      await component.handleSyncVMToHost(db);
+      expect(orchestratorStore.syncVMWorkspaceToHost).toHaveBeenCalled();
+
+      // 6. handleRenameEntry
+      const { renameGroupEntry } =
+        await import("../../storage/renameGroupEntry.js");
+      component._pendingRenamePath = "docs/old.txt";
+      component._pendingRenameName = "old.txt";
+
+      const renameInput = component.shadowRoot?.querySelector(
+        ".files__rename-input",
+      ) as HTMLInputElement;
+      if (renameInput) renameInput.value = "new.txt";
+
+      await component.handleRenameEntry(db);
+      expect(renameGroupEntry).toHaveBeenCalledWith(
+        db,
+        "default",
+        "docs/old.txt",
+        "new.txt",
+      );
+
+      // 7. updateBreadcrumbs
+      (orchestratorStore as any).currentPath = "docs/guides";
+      let breadcrumbsContainer = component.shadowRoot?.querySelector(
+        "[data-breadcrumb-path]",
+      );
+      if (!breadcrumbsContainer) {
+        breadcrumbsContainer = document.createElement("div");
+        breadcrumbsContainer.setAttribute("data-breadcrumb-path", "");
+        component.shadowRoot?.appendChild(breadcrumbsContainer);
+      }
+      component.updateBreadcrumbs(db);
+
+      const breadcrumbButtons = breadcrumbsContainer.querySelectorAll(
+        ".files__breadcrumb-btn",
+      );
+      expect(breadcrumbButtons.length).toBeGreaterThan(0);
+      // Click root
+      (breadcrumbButtons[0] as HTMLButtonElement).click();
+      expect(orchestratorStore.resetToRootFolder).toHaveBeenCalled();
+
+      // 8. updateFileList
+      let listContainer = component.shadowRoot?.querySelector(".files__list");
+      if (!listContainer) {
+        listContainer = document.createElement("div");
+        listContainer.className = "files__list";
+        component.shadowRoot?.appendChild(listContainer);
+      }
+      (orchestratorStore as any).files = ["readme.md", "src/"];
+      component.updateFileList(db);
+      expect(listContainer.children.length).toBe(2);
+
+      // empty files
+      (orchestratorStore as any).files = [];
+      component.updateFileList(db);
+      expect(
+        listContainer.querySelector("shadow-claw-empty-state"),
+      ).not.toBeNull();
+
+      document.body.removeChild(component);
+    });
+  });
 });