private async initialize() {
        try {
            // If we have a vsls: workspace open, we might be a guest, so wait until live share transitions into a mode
            if (
                workspace.workspaceFolders !== undefined &&
                workspace.workspaceFolders.some(f => f.uri.scheme === DocumentSchemes.Vsls)
            ) {
                setCommandContext(CommandContext.Readonly, true);
                this._waitForReady = new Promise(resolve => (this._onReady = resolve));
            }

            this._api = getApi();
            const api = await this._api;
            if (api == null) {
                setCommandContext(CommandContext.Vsls, false);
                // Tear it down if we can't talk to live share
                if (this._onReady !== undefined) {
                    this._onReady();
                    this._waitForReady = undefined;
                }

                return;
            }

            setCommandContext(CommandContext.Vsls, true);

            this._disposable = Disposable.from(
                api.onDidChangeSession(e => this.onLiveShareSessionChanged(api, e), this)
            );
        }
        catch (ex) {
            Logger.error(ex);
        }
    }

async function warnAboutMissingGit(): Promise<void> {
	const config = workspace.getConfiguration('git');
	const shouldIgnore = config.get<boolean>('ignoreMissingGitWarning') === true;

	if (shouldIgnore) {
		return;
	}

	if (!workspace.workspaceFolders) {
		return;
	}

	const areGitRepositories = await Promise.all(workspace.workspaceFolders.map(isGitRepository));

	if (areGitRepositories.every(isGitRepository => !isGitRepository)) {
		return;
	}

	const download = localize('downloadgit', "Download Git");
	const neverShowAgain = localize('neverShowAgain', "Don't Show Again");
	const choice = await window.showWarningMessage(
		localize('notfound', "Git not found. Install it or configure it using the 'git.path' setting."),
		download,
		neverShowAgain
	);

	if (choice === download) {
		commands.executeCommand('vscode.open', Uri.parse('https://git-scm.com/'));
	} else if (choice === neverShowAgain) {
		await config.update('ignoreMissingGitWarning', true, true);
	}
}

function createWatcher( func: (e: Uri)=>void, extension: string ): void {
    var dict: any[] = [];
    
        function addWatcher(wf: WorkspaceFolder) {
            var watcher = workspace.createFileSystemWatcher( new RelativePattern(wf, `**/*.${extension}` ) );  
            dict.push({key: wf.uri.fsPath, value: watcher});
            watcher.onDidCreate( (e) => {
                func( e );
                // cmUtils.addCopyright( e );
            } );
        }
    
        workspace.workspaceFolders.forEach( wf => {
           addWatcher( wf );
        });
    
        workspace.onDidChangeWorkspaceFolders( e => {
            e.added.forEach( a => {
                addWatcher(a);
            });
            e.removed.forEach( a => {
                let watcher: FileSystemWatcher = dict.find( o => o.key == a.uri.fsPath );
                watcher = null;
            })
        } );
}

workspace.onDidChangeConfiguration(event => {
    if (event.affectsConfiguration(sectionCSpell)) {
        folderSettings.delete(scopeToFolderSettingsKey(Scopes.Global));
        folderSettings.delete(scopeToFolderSettingsKey(Scopes.Workspace));
    }
    if (workspace.workspaceFolders) {
        workspace.workspaceFolders.forEach(folder => {
            if (event.affectsConfiguration(sectionCSpell, folder.uri)) {
                const key = scopeToFolderSettingsKey({ scope: Scopes.Folder, resource: folder.uri });
                folderSettings.delete(key);
            }
        });
    }
});

function sortedWorkspaceFolders(): string[] {
	if (_sortedWorkspaceFolders === void 0) {
		_sortedWorkspaceFolders = Workspace.workspaceFolders.map(folder => {
			let result = folder.uri.toString();
			if (result.charAt(result.length - 1) !== '/') {
				result = result + '/';
			}
			return result;
		}).sort(
			(a, b) => {
				return a.length - b.length;
			}
		);
	}
	return _sortedWorkspaceFolders;
}

/**
 * Build formatter selectors
 */
function selectors(): Selectors {
    const allLanguages = allEnabledLanguages();
    const allRangeLanguages = allJSLanguages();
    const { disableLanguages } = getConfig();
    const globalLanguageSelector = allLanguages.filter(
        l => !disableLanguages.includes(l)
    );
    const globalRangeLanguageSelector = allRangeLanguages.filter(
        l => !disableLanguages.includes(l)
    );
    if (workspace.workspaceFolders === undefined) {
        // no workspace opened
        return {
            languageSelector: globalLanguageSelector,
            rangeLanguageSelector: globalRangeLanguageSelector,
        };
    }

    // at least 1 workspace
    const untitledLanguageSelector: DocumentFilter[] = globalLanguageSelector.map(
        l => ({ language: l, scheme: 'untitled' })
    );
    const untitledRangeLanguageSelector: DocumentFilter[] = globalRangeLanguageSelector.map(
        l => ({ language: l, scheme: 'untitled' })
    );
    return workspace.workspaceFolders.reduce(
        (previous, workspaceFolder) => {
            let { languageSelector, rangeLanguageSelector } = previous;
            const select = selectorsCreator(workspaceFolder);
            return {
                languageSelector: languageSelector.concat(
                    select.languageSelector
                ),
                rangeLanguageSelector: rangeLanguageSelector.concat(
                    select.rangeLanguageSelector
                ),
            };
        },
        {
            languageSelector: untitledLanguageSelector,
            rangeLanguageSelector: untitledRangeLanguageSelector,
        }
    );
}

    return new Promise((resolve, reject) => {
        workspace.workspaceFolders.forEach( wf => {
            try {
                let data = fs.readFileSync( wf.uri.fsPath + "/vscode.scripts.cm", "utf8" );
                let myReg = /public\s+void\s+(.[^\(\)]*)\s*\(\)/g;
                let packageReg = /package\s(.[^;]*);/;
                scriptPackage = packageReg.exec( data )[1];
                var myArr;
                var myFuncs = [];
                while ( ( myArr = myReg.exec(data) ) !== null ) {
                    scriptFuncs.push(`${myArr[1]} (${scriptPackage})`);
                }
            } catch (err) {
                // couldn't find the scripts file
            }
        });

        if ( scriptFuncs.length == 0 ) {
            reject("No User Scripts Found");
        } else {
            didLoadScripts = true;
            resolve(scriptFuncs);
        }
    });

export function getDartWorkspaceFolders(): WorkspaceFolder[] {
	if (!workspace.workspaceFolders)
		return [];
	return workspace.workspaceFolders.filter(isDartWorkspaceFolder);
}