@@ -19,7 +19,7 @@
     "extension_url": "https://s3.amazonaws.com/extend.brackets/{0}/{0}-{1}.zip",
     "extension_store_url": "https://store.core.ai/src/",
     "linting.enabled_by_default": true,
-    "build_timestamp": "2022-06-30T10:30:55.948Z",
+    "build_timestamp": "2022-07-02T08:10:33.817Z",
     "googleAnalyticsID": "G-FP5S9BKDSJ",
     "mixPanelID": "a7e08ffd43c37767c29b13df1d2e6c62",
     "coreAnalyticsID": "phoenix",
 
@@ -65,22 +65,27 @@ define(function (require, exports, module) {
     }
 
     async function _getDefaultPreviewDetails() {
-        return new Promise(async (resolve)=>{
-            let projectRoot = ProjectManager.getProjectRoot().fullPath;
-            const projectRootUrl = `${window.fsServerUrl}${projectRoot}`;
-            let indexFiles = ['index.html', "index.htm"];
-            for(let indexFile of indexFiles){
-                let file = FileSystem.getFileForPath(`${projectRoot}${indexFile}`);
-                if(await file.existsAsync()){
-                    const relativePath = path.relative(projectRoot, file.fullPath);
-                    resolve({
-                        URL: `${projectRootUrl}${relativePath}`,
-                        filePath: relativePath
-                    });
-                    return;
+        return new Promise(async (resolve, reject)=>{ // eslint-disable-line
+            // async is explicitly caught
+            try{
+                let projectRoot = ProjectManager.getProjectRoot().fullPath;
+                const projectRootUrl = `${window.fsServerUrl}${projectRoot}`;
+                let indexFiles = ['index.html', "index.htm"];
+                for(let indexFile of indexFiles){
+                    let file = FileSystem.getFileForPath(`${projectRoot}${indexFile}`);
+                    if(await file.existsAsync()){
+                        const relativePath = path.relative(projectRoot, file.fullPath);
+                        resolve({
+                            URL: `${projectRootUrl}${relativePath}`,
+                            filePath: relativePath
+                        });
+                        return;
+                    }
                 }
+                resolve({URL: getNoPreviewURL()});
+            } catch (e) {
+                reject(e);
             }
-            resolve({URL: getNoPreviewURL()});
         });
     }
 
@@ -90,30 +95,35 @@ define(function (require, exports, module) {
      * @return {Promise<*>}
      */
     async function getPreviewDetails() {
-        return new Promise(async (resolve)=>{
-            const projectRoot = ProjectManager.getProjectRoot().fullPath;
-            const projectRootUrl = `${window.fsServerUrl}${projectRoot}`;
-            const currentDocument = DocumentManager.getCurrentDocument();
-            const currentFile = currentDocument? currentDocument.file : ProjectManager.getSelectedItem();
-            if(currentFile){
-                let fullPath = currentFile.fullPath;
-                let httpFilePath = null;
-                if(fullPath.startsWith("http://") || fullPath.startsWith("https://")){
-                    httpFilePath = fullPath;
-                }
-                if(_isPreviewableFile(fullPath)){
-                    const filePath = httpFilePath || path.relative(projectRoot, fullPath);
-                    resolve({
-                        URL: httpFilePath || `${projectRootUrl}${filePath}`,
-                        filePath: filePath,
-                        fullPath: fullPath,
-                        isMarkdownFile: _isMarkdownFile(fullPath)
-                    });
-                } else {
-                    resolve({}); // not a previewable file
+        return new Promise(async (resolve, reject)=>{ // eslint-disable-line
+            // async is explicitly caught
+            try {
+                const projectRoot = ProjectManager.getProjectRoot().fullPath;
+                const projectRootUrl = `${window.fsServerUrl}${projectRoot}`;
+                const currentDocument = DocumentManager.getCurrentDocument();
+                const currentFile = currentDocument? currentDocument.file : ProjectManager.getSelectedItem();
+                if(currentFile){
+                    let fullPath = currentFile.fullPath;
+                    let httpFilePath = null;
+                    if(fullPath.startsWith("http://") || fullPath.startsWith("https://")){
+                        httpFilePath = fullPath;
+                    }
+                    if(_isPreviewableFile(fullPath)){
+                        const filePath = httpFilePath || path.relative(projectRoot, fullPath);
+                        resolve({
+                            URL: httpFilePath || `${projectRootUrl}${filePath}`,
+                            filePath: filePath,
+                            fullPath: fullPath,
+                            isMarkdownFile: _isMarkdownFile(fullPath)
+                        });
+                    } else {
+                        resolve({}); // not a previewable file
+                    }
                 }
+                resolve(await _getDefaultPreviewDetails());
+            }catch (e) {
+                reject(e);
             }
-            resolve(await _getDefaultPreviewDetails());
         });
     }
 
 
@@ -143,7 +143,7 @@ define(function (require, exports, module) {
     }
 
     async function _validateProjectFolder(projectPath) {
-        return new Promise(async (resolve, reject)=>{
+        return new Promise((resolve, reject)=>{
             let dir = FileSystem.getDirectoryForPath(projectPath);
             let displayPath = projectPath.replace(Phoenix.VFS.getMountDir(), "");
             if(!dir){
@@ -177,45 +177,54 @@ define(function (require, exports, module) {
     }
 
     async function _findFreeFolderName(basePath) {
-        return new Promise(async (resolve, reject)=>{
-            for(let i=0; i< MAX_DEDUPE_COUNT; i++){
-                let newPath = `${basePath}-${i}`;
-                let exists = await window.Phoenix.VFS.existsAsync(newPath);
-                if(!exists){
-                    await window.Phoenix.VFS.ensureExistsDirAsync(newPath);
-                    resolve(newPath);
-                    return;
+        return new Promise(async (resolve, reject)=>{ // eslint-disable-line
+            try {
+                for(let i=0; i< MAX_DEDUPE_COUNT; i++){
+                    let newPath = `${basePath}-${i}`;
+                    let exists = await window.Phoenix.VFS.existsAsync(newPath);
+                    if(!exists){
+                        await window.Phoenix.VFS.ensureExistsDirAsync(newPath);
+                        resolve(newPath);
+                        return;
+                    }
                 }
+                reject();
+            } catch (e) {
+                reject(e);
             }
-            reject();
         });
     }
 
     async function alreadyExists(suggestedProjectName) {
         let projectPath = `${ProjectManager.getLocalProjectsPath()}${suggestedProjectName}`; // try suggested path first
-        return await window.Phoenix.VFS.existsAsync(projectPath);
+        return window.Phoenix.VFS.existsAsync(projectPath);
     }
 
     async function _getSuggestedProjectDir(suggestedProjectName) {
-        return new Promise(async (resolve, reject)=>{
-            let projectPath = `${ProjectManager.getLocalProjectsPath()}${suggestedProjectName}`; // try suggested path first
-            let exists = await window.Phoenix.VFS.existsAsync(projectPath);
-            if(!exists){
-                resolve(projectPath);
-                return;
-            }
-            _showReplaceKeepProjectConfirmDialogue(suggestedProjectName).done(function (id) {
-                if (id === Dialogs.DIALOG_BTN_OK) {
+        return new Promise(async (resolve, reject)=>{ // eslint-disable-line
+            try{
+                // try suggested path first
+                let projectPath = `${ProjectManager.getLocalProjectsPath()}${suggestedProjectName}`;
+                let exists = await window.Phoenix.VFS.existsAsync(projectPath);
+                if(!exists){
                     resolve(projectPath);
                     return;
-                } else if(id === Dialogs.DIALOG_BTN_CANCEL){
-                    reject();
-                    return;
                 }
-                _findFreeFolderName(projectPath)
-                    .then(projectPath=>resolve(projectPath))
-                    .catch(reject);
-            });
+                _showReplaceKeepProjectConfirmDialogue(suggestedProjectName).done(function (id) {
+                    if (id === Dialogs.DIALOG_BTN_OK) {
+                        resolve(projectPath);
+                        return;
+                    } else if(id === Dialogs.DIALOG_BTN_CANCEL){
+                        reject();
+                        return;
+                    }
+                    _findFreeFolderName(projectPath)
+                        .then(projectPath=>resolve(projectPath))
+                        .catch(reject);
+                });
+            } catch (e) {
+                reject(e);
+            }
         });
     }
 
@@ -267,55 +276,61 @@ define(function (require, exports, module) {
      * @returns {Promise<void>}
      */
     async function downloadAndOpenProject(downloadURL, projectPath, suggestedProjectName, flattenFirstLevelInZip) {
-        return new Promise(async (resolve, reject)=>{
-            // if project path is null, create one in default folder
-            if(!projectPath){
-                projectPath = await _getSuggestedProjectDir(suggestedProjectName);
-            } else {
-                await _validateProjectFolder(projectPath);
-            }
-            console.log(`downloadAndOpenProject ${suggestedProjectName} from URL: ${downloadURL} to: ${projectPath}`);
-
-            downloadCancelled = false;
-            _showCreateProjectDialogue(Strings.SETTING_UP_PROJECT, Strings.DOWNLOADING).done(function (id) {
-                if (id === Dialogs.DIALOG_BTN_CANCEL) {
-                    downloadCancelled = true;
+        return new Promise(async (resolve, reject)=>{ // eslint-disable-line
+            try {
+                // if project path is null, create one in default folder
+                if(!projectPath){
+                    projectPath = await _getSuggestedProjectDir(suggestedProjectName);
+                } else {
+                    await _validateProjectFolder(projectPath);
                 }
-            });
-            window.JSZipUtils.getBinaryContent(downloadURL, {
-                callback: async function(err, data) {
-                    if(downloadCancelled){
-                        reject();
-                    } else if(err) {
-                        console.error("could not load phoenix default project from zip file!", err);
-                        _closeCreateProjectDialogue();
-                        showErrorDialogue(Strings.DOWNLOAD_FAILED, Strings.DOWNLOAD_FAILED_MESSAGE);
-                        reject();
-                    } else {
-                        _unzipProject(data, projectPath, flattenFirstLevelInZip)
-                            .then(()=>{
-                                _closeCreateProjectDialogue();
-                                ProjectManager.openProject(projectPath)
-                                    .then(resolve)
-                                    .fail(reject);
-                                console.log("Project Setup complete: ", projectPath);
-                            })
-                            .catch(()=>{
-                                _closeCreateProjectDialogue();
-                                showErrorDialogue(Strings.ERROR_LOADING_PROJECT, Strings.UNZIP_FAILED);
-                                reject();
-                            });
+                console.log(
+                    `downloadAndOpenProject ${suggestedProjectName} from URL: ${downloadURL} to: ${projectPath}`);
+
+                downloadCancelled = false;
+                _showCreateProjectDialogue(Strings.SETTING_UP_PROJECT, Strings.DOWNLOADING).done(function (id) {
+                    if (id === Dialogs.DIALOG_BTN_CANCEL) {
+                        downloadCancelled = true;
                     }
-                },
-                progress: function (status){
-                    if(status.percent > 0){
-                        _updateCreateProjectDialogueMessage(`${Strings.DOWNLOADING} ${Math.round(status.percent)}%`);
+                });
+                window.JSZipUtils.getBinaryContent(downloadURL, {
+                    callback: async function(err, data) {
+                        if(downloadCancelled){
+                            reject();
+                        } else if(err) {
+                            console.error("could not load phoenix default project from zip file!", err);
+                            _closeCreateProjectDialogue();
+                            showErrorDialogue(Strings.DOWNLOAD_FAILED, Strings.DOWNLOAD_FAILED_MESSAGE);
+                            reject();
+                        } else {
+                            _unzipProject(data, projectPath, flattenFirstLevelInZip)
+                                .then(()=>{
+                                    _closeCreateProjectDialogue();
+                                    ProjectManager.openProject(projectPath)
+                                        .then(resolve)
+                                        .fail(reject);
+                                    console.log("Project Setup complete: ", projectPath);
+                                })
+                                .catch(()=>{
+                                    _closeCreateProjectDialogue();
+                                    showErrorDialogue(Strings.ERROR_LOADING_PROJECT, Strings.UNZIP_FAILED);
+                                    reject();
+                                });
+                        }
+                    },
+                    progress: function (status){
+                        if(status.percent > 0){
+                            _updateCreateProjectDialogueMessage(
+                                `${Strings.DOWNLOADING} ${Math.round(status.percent)}%`);
+                        }
+                    },
+                    abortCheck: function (){
+                        return downloadCancelled;
                     }
-                },
-                abortCheck: function (){
-                    return downloadCancelled;
-                }
-            });
+                });
+            } catch (e) {
+                reject(e);
+            }
         });
     }
 
 
@@ -35,30 +35,34 @@ define(function (require, exports, module) {
     }
 
     function _copyZippedItemToFS(path, item, destProjectDir, flattenFirstLevel) {
-        return new Promise(async (resolve, reject) =>{
-            let destPath = `${destProjectDir}${path}`;
-            if(flattenFirstLevel){
-                // contents/index.html to index.html
-                let newPath = path.substr(path.indexOf("/") + 1);
-                destPath = `${destProjectDir}${newPath}`;
-                console.log(destPath);
-            }
-            if(item.dir){
-                await _ensureExistsAsync(destPath);
-                resolve(destPath);
-            } else {
-                await _ensureExistsAsync(window.path.dirname(destPath));
-                item.async("uint8array").then(function (data) {
-                    window.fs.writeFile(destPath, Filer.Buffer.from(data), writeErr=>{
-                        if(writeErr){
-                            reject(writeErr);
-                        } else {
-                            resolve(destPath);
-                        }
+        return new Promise(async (resolve, reject) =>{ // eslint-disable-line
+            try {
+                let destPath = `${destProjectDir}${path}`;
+                if(flattenFirstLevel){
+                    // contents/index.html to index.html
+                    let newPath = path.substr(path.indexOf("/") + 1);
+                    destPath = `${destProjectDir}${newPath}`;
+                    console.log(destPath);
+                }
+                if(item.dir){
+                    await _ensureExistsAsync(destPath);
+                    resolve(destPath);
+                } else {
+                    await _ensureExistsAsync(window.path.dirname(destPath));
+                    item.async("uint8array").then(function (data) {
+                        window.fs.writeFile(destPath, Filer.Buffer.from(data), writeErr=>{
+                            if(writeErr){
+                                reject(writeErr);
+                            } else {
+                                resolve(destPath);
+                            }
+                        });
+                    }).catch(error=>{
+                        reject(error);
                     });
-                }).catch(error=>{
-                    reject(error);
-                });
+                }
+            } catch (e) {
+                reject(e);
             }
         });
     }