@isopodlabs/vscode_utils 0.0.2

package/dist/fs.js

@@ -0,0 +1,625 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Change = exports.Glob = exports.SubfileFileSystem = exports.ReadOnlyFilesystem = exports.NormalFile = exports.BaseFileSystem = void 0;
+exports.isFile = isFile;
+exports.withOffset = withOffset;
+exports.openFile = openFile;
+exports.toOSPath = toOSPath;
+exports.readDirectory = readDirectory;
+exports.directories = directories;
+exports.files = files;
+exports.search = search;
+exports.mapDirs = mapDirs;
+exports.stat_reject = stat_reject;
+exports.exists = exists;
+exports.getStat = getStat;
+exports.isDirectory = isDirectory;
+exports.loadFile = loadFile;
+exports.writeFile = writeFile;
+exports.deleteFile = deleteFile;
+exports.createDirectory = createDirectory;
+exports.createNewName = createNewName;
+exports.copyFile = copyFile;
+exports.copyFileToDir = copyFileToDir;
+exports.copyDirectory = copyDirectory;
+exports.onChange = onChange;
+exports.arrayRemove = arrayRemove;
+exports.removeOnChange = removeOnChange;
+const vscode = __importStar(require("vscode"));
+const nodefs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function uri(value) {
+    return value instanceof vscode.Uri ? value : vscode.Uri.file(value);
+}
+function file(value) {
+    return value instanceof vscode.Uri ? value.fsPath : value;
+}
+function file_id(value) {
+    return typeof (value) === 'string' ? value : value.scheme === 'file' ? value.fsPath : value.toString();
+}
+function basename(value) {
+    return path.basename(file(value));
+}
+function ext(value) {
+    return path.extname(file(value));
+}
+function dirname(value) {
+    return path.dirname(file(value));
+}
+function pathComponents(value) {
+    return path.parse(file(value));
+}
+function withPathComponents(value, ...comp) {
+    const p = path.join(...comp);
+    return value instanceof vscode.Uri ? value.with({ path: p }) : p;
+}
+function join(directory, ...comp) {
+    return withPathComponents(directory, file(directory), ...comp);
+}
+function isFile(obj) {
+    return obj && typeof obj.dispose === 'function' && typeof obj.read === 'function' && typeof obj.write === 'function';
+}
+const filesystems = {};
+class BaseFileSystem {
+    _onDidChangeFile = new vscode.EventEmitter();
+    constructor(context, scheme) {
+        filesystems[scheme] = this;
+        context.subscriptions.push(vscode.workspace.registerFileSystemProvider(scheme, this, { isCaseSensitive: true }));
+    }
+    get onDidChangeFile() { return this._onDidChangeFile.event; }
+    //stubs
+    watch(_uri, _options) { throw 'not implemented'; }
+    stat(_uri) { throw 'not implemented'; }
+    readDirectory(_uri) { throw 'not implemented'; }
+    createDirectory(_uri) { throw 'not implemented'; }
+    writeFile(_uri, _content, _options) { throw 'not implemented'; }
+    delete(_uri, _options) { throw 'not implemented'; }
+    rename(_oldUri, _newUri, _options) { throw 'not implemented'; }
+}
+exports.BaseFileSystem = BaseFileSystem;
+function withOffset(file, offset) {
+    if (file instanceof vscode.Uri)
+        return SubfileFileSystem.makeUri(file, offset);
+    return new class {
+        length = offset.toOffset - offset.fromOffset;
+        dispose() { file.dispose(); }
+        read(pos, length) {
+            const start = pos + offset.fromOffset;
+            const end = Math.min(start + length, offset.toOffset);
+            return file.read(start, end - start);
+        }
+        write(pos, data) {
+            const start = pos + offset.fromOffset;
+            const end = Math.min(start + data.length, offset.toOffset);
+            return file.write(start, data.subarray(0, end - start));
+        }
+    };
+}
+function openFile(uri) {
+    switch (uri.scheme) {
+        case 'file':
+            return NormalFile.open(uri);
+        default:
+            return filesystems[uri.scheme]?.openFile(uri);
+    }
+}
+class NormalFile {
+    fd;
+    constructor(fd) {
+        this.fd = fd;
+    }
+    static open(uri) {
+        return new Promise((resolve, reject) => {
+            nodefs.open(uri.fsPath, 'r', (err, fd) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(new NormalFile(fd));
+            });
+        });
+    }
+    dispose() {
+        nodefs.close(this.fd);
+    }
+    read(pos, length) {
+        return new Promise((resolve, reject) => {
+            const buffer = Buffer.alloc(length);
+            nodefs.read(this.fd, buffer, 0, length, pos, (err, bytesRead, buffer) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(new Uint8Array(buffer));
+            });
+        });
+    }
+    write(pos, data) {
+        return new Promise((resolve, reject) => {
+            nodefs.write(this.fd, data, 0, data.length, pos, (err, bytesWritten) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(bytesWritten);
+            });
+        });
+    }
+}
+exports.NormalFile = NormalFile;
+function getEncapsulatedUri(uri) {
+    return uri.with({
+        scheme: uri.authority,
+        authority: '',
+    });
+    //	return vscode.Uri.parse(uri.fsPath);
+}
+class ReadOnlyFilesystem extends BaseFileSystem {
+    static SCHEME = 'readonly';
+    constructor(context) {
+        super(context, ReadOnlyFilesystem.SCHEME);
+    }
+    async stat(uri) {
+        return { ...await vscode.workspace.fs.stat(getEncapsulatedUri(uri)), permissions: vscode.FilePermission.Readonly };
+    }
+    openFile(uri) {
+        return openFile(getEncapsulatedUri(uri));
+    }
+    readFile(uri) {
+        return vscode.workspace.fs.readFile(getEncapsulatedUri(uri));
+    }
+}
+exports.ReadOnlyFilesystem = ReadOnlyFilesystem;
+class SubfileFileSystem extends BaseFileSystem {
+    static SCHEME = 'subfile';
+    static makeUri(uri, offset) {
+        return uri.with({
+            scheme: 'subfile',
+            authority: uri.scheme,
+            fragment: `${offset.fromOffset};${offset.toOffset}`
+        });
+    }
+    static parseUri(uri) {
+        const parts = uri.fragment.split(';');
+        return {
+            uri: getEncapsulatedUri(uri),
+            offset: { fromOffset: +parts[0], toOffset: +parts[1] }
+        };
+    }
+    constructor(context) {
+        super(context, SubfileFileSystem.SCHEME);
+    }
+    async stat(uri) {
+        const { uri: uri2, offset } = SubfileFileSystem.parseUri(uri);
+        return { ...await vscode.workspace.fs.stat(uri2), size: offset.toOffset - offset.fromOffset };
+    }
+    async readFile(uri) {
+        const { uri: uri2, offset } = SubfileFileSystem.parseUri(uri);
+        const file = await openFile(uri2);
+        if (file) {
+            try {
+                return file.read(offset.fromOffset, offset.toOffset - offset.fromOffset);
+            }
+            finally {
+                file.dispose();
+            }
+        }
+        else {
+            const data = await vscode.workspace.fs.readFile(uri2);
+            return data.subarray(offset.fromOffset, offset.toOffset);
+        }
+    }
+    async openFile(uri) {
+        const { uri: uri2, offset } = SubfileFileSystem.parseUri(uri);
+        return withOffset(await openFile(uri2), offset);
+    }
+}
+exports.SubfileFileSystem = SubfileFileSystem;
+//-----------------------------------------------------------------------------
+//	Glob
+//-----------------------------------------------------------------------------
+class Glob {
+    regexp;
+    constructor(pattern) {
+        if (typeof pattern === 'string' && pattern.includes(';'))
+            pattern = pattern.split(';');
+        const re = Array.isArray(pattern)
+            ? '(' + pattern.map(s => toRegExp(s)).join('|') + ')'
+            : toRegExp(pattern);
+        this.regexp = new RegExp(re + '$');
+    }
+    test(input) {
+        return this.regexp?.test(input) ?? false;
+    }
+}
+exports.Glob = Glob;
+function toOSPath(input) {
+    if (!input)
+        return '';
+    return input
+        .replace(/\\/g, path.sep)
+        .trim();
+    //.replace(new RegExp(`${path.sep}$`), '');
+}
+function toRegExp(pattern) {
+    let re = "", range = false, block = false;
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        switch (c) {
+            default:
+                re += c;
+                break;
+            case ".":
+            case "/":
+            case "\\":
+            case "$":
+            case "^":
+                re += "\\" + c;
+                break;
+            case "?":
+                re += ".";
+                break;
+            case "[":
+                re += "[";
+                range = true;
+                break;
+            case "]":
+                re += "]";
+                range = false;
+                break;
+            case "!":
+                re += range ? "^" : "!";
+                break;
+            case "{":
+                re += "(";
+                block = true;
+                break;
+            case "}":
+                re += ")";
+                block = false;
+                break;
+            case ",":
+                re += block ? "|" : "\\,";
+                break;
+            case "*":
+                if (pattern[i + 1] === "*") {
+                    re += ".*";
+                    i++;
+                    if (pattern[i + 1] === "/" || pattern[i + 1] === "\\")
+                        i++;
+                }
+                else {
+                    re += "[^/\\\\]*";
+                }
+                break;
+        }
+    }
+    return re;
+}
+function readDirectory(dir) {
+    return vscode.workspace.fs.stat(uri(dir)).then(stat => {
+        if (stat.type == vscode.FileType.Directory) {
+            return vscode.workspace.fs.readDirectory(uri(dir)).then(items => items, error => {
+                console.log(`readDirectory failed with ${error}`);
+                return [];
+            });
+        }
+        else {
+            console.log(`readDirectory ${dir} is not a directory`);
+            return Promise.resolve([]);
+        }
+    }, error => {
+        console.log(`readDirectory failed with ${error}`);
+        return Promise.resolve([]);
+    });
+}
+function directories(entries) {
+    return entries.filter(e => e[1] == vscode.FileType.Directory).map(e => e[0]);
+}
+function files(entries, glob) {
+    if (glob) {
+        const include = typeof glob === 'string' ? new Glob(glob) : glob;
+        return entries.filter(e => e[1] == vscode.FileType.File && include.test(e[0])).map(e => e[0]);
+    }
+    else {
+        return entries.filter(e => e[1] == vscode.FileType.File).map(e => e[0]);
+    }
+}
+async function search(pattern, _exclude, want = vscode.FileType.Unknown) {
+    const m = /[*?[{}]/.exec(pattern);
+    if (!m)
+        return [pattern];
+    const sep = pattern.lastIndexOf('\\', m.index);
+    const basePath = pattern.substring(0, sep);
+    const include = new Glob(pattern.substring(sep + 1));
+    const exclude = _exclude ? new Glob(_exclude) : undefined;
+    const keep = want || vscode.FileType.File;
+    const recurse = async (basePath) => {
+        const items = await readDirectory(basePath);
+        const result = [];
+        for (const i of items) {
+            if (want && i[1] !== want)
+                continue;
+            const filename = path.join(basePath, i[0]);
+            if (exclude && exclude.test(filename))
+                continue;
+            if (i[1] === keep && include.test(filename))
+                result.push(filename);
+            if (i[1] == vscode.FileType.Directory)
+                result.push(...await recurse(filename));
+        }
+        return result;
+    };
+    return recurse(basePath);
+}
+async function mapDirs(root, glob, onFile, combine) {
+    const glob2 = typeof glob === 'string' ? new Glob(glob) : glob;
+    return readDirectory(root).then(async (dir) => combine(...await Promise.all(files(dir, glob).map(i => onFile(path.join(root, i)))), ...await Promise.all(directories(dir).map(async (i) => mapDirs(path.join(root, i), glob2, onFile, combine)))));
+}
+//-----------------------------------------------------------------------------
+//	helpers
+//-----------------------------------------------------------------------------
+function stat_reject(value) {
+    return vscode.workspace.fs.stat(uri(value));
+}
+function exists(value) {
+    return vscode.workspace.fs.stat(uri(value)).then(() => true, () => false);
+}
+function getStat(value) {
+    return vscode.workspace.fs.stat(uri(value)).then(stat => stat, () => undefined);
+}
+function isDirectory(value) {
+    return vscode.workspace.fs.stat(uri(value)).then(stat => stat.type == vscode.FileType.Directory, () => ext(value) === "");
+}
+async function loadFile(file) {
+    return vscode.workspace.fs.readFile(uri(file)).then(bytes => bytes, error => console.log(`Failed to load ${file} : ${error}`));
+}
+function writeFile(file, bytes) {
+    return vscode.workspace.fs.writeFile(uri(file), bytes).then(() => true, error => (console.log(`Failed to save ${file} : ${error}`), false));
+}
+function deleteFile(file) {
+    return vscode.workspace.fs.delete(uri(file)).then(() => true, error => (console.log(`Failed to delete ${file} : ${error}`), false));
+}
+function createDirectory(path) {
+    return vscode.workspace.fs.createDirectory(uri(path)).then(() => true, error => (console.log(`Failed to create ${path} : ${error}`), false));
+}
+async function createNewName(filepath) {
+    const parsed = pathComponents(filepath);
+    let counter = 0;
+    const m = /\d+$/.exec(parsed.name);
+    if (m) {
+        counter = parseInt(m[0]);
+        parsed.name = parsed.name.substring(0, m.index);
+    }
+    while (await exists(filepath))
+        filepath = withPathComponents(filepath, parsed.dir, `${parsed.name}${++counter}${parsed.ext}`);
+    return filepath;
+}
+async function createCopyName(filepath) {
+    const parsed = pathComponents(filepath);
+    let counter = 1;
+    while (await exists(filepath)) {
+        filepath = withPathComponents(filepath, parsed.dir, `${parsed.name} copy${(counter > 1 ? ' ' + counter : '')}${parsed.ext}`);
+        counter++;
+    }
+    return filepath;
+}
+async function copyFile(sourcepath, destpath) {
+    return vscode.workspace.fs.readFile(uri(sourcepath)).then(async (bytes) => vscode.workspace.fs.writeFile(uri(destpath), bytes));
+}
+async function copyFileToDir(sourcepath, destdir) {
+    const dest = createCopyName(join(destdir, basename(sourcepath)));
+    const bytes = await vscode.workspace.fs.readFile(uri(sourcepath));
+    const destpath = await dest;
+    vscode.workspace.fs.writeFile(uri(destpath), bytes);
+    return destpath;
+}
+async function copyDirectory(sourcepath, targetpath) {
+    const dest = createCopyName(join(targetpath, basename(sourcepath)));
+    const dir = await readDirectory(sourcepath);
+    let result = [];
+    for (const i of dir) {
+        const sourcepath2 = join(sourcepath, i[0]);
+        if (i[1] === vscode.FileType.Directory)
+            result = [...result, ...await copyDirectory(sourcepath2, await dest)];
+        else
+            result.push(await copyFileToDir(sourcepath2, await dest));
+    }
+    return result;
+}
+//-----------------------------------------------------------------------------
+//	watchers
+//-----------------------------------------------------------------------------
+exports.Change = {
+    changed: 0,
+    created: 1,
+    deleted: 2,
+    renamed: 3,
+};
+const recWatchers = {};
+const dirWatchers = {};
+const fileModTimes = {};
+const recCallbacks = {};
+const dirCallbacks = {};
+const fileCallbacks = {};
+let wait_create = Promise.resolve();
+function runCallbacks(callbacks, id, mode) {
+    if (callbacks)
+        callbacks.forEach(func => func(id, mode));
+}
+function runGlobCallbacks(callbacks, id, mode) {
+    if (callbacks) {
+        const base = path.basename(id);
+        callbacks.forEach(func => func[0].test(base) && func[1](id, mode));
+    }
+}
+async function dirCallback(uri, mode) {
+    const id = file_id(uri);
+    switch (mode) {
+        case exports.Change.changed:
+            if (fileCallbacks[id] && await stat_reject(uri).then(stat => {
+                if (fileModTimes[stat.mtime] === id)
+                    return false;
+                fileModTimes[stat.mtime] = id;
+                return true;
+            }, _ => true)) {
+                console.log(`Changed: ${uri}`);
+                runCallbacks(fileCallbacks[id], id, mode);
+            }
+            break;
+        case exports.Change.created:
+            console.log(`Created: ${uri}`);
+            wait_create = wait_create.then(() => stat_reject(uri).then(stat => {
+                const _renamed = fileModTimes[stat.mtime];
+                if (_renamed) {
+                    const renamed = file_id(_renamed);
+                    console.log(`Rename: ${renamed} to ${uri}`);
+                    fileModTimes[stat.mtime] = id;
+                    fileCallbacks[id] = fileCallbacks[renamed];
+                    delete fileCallbacks[renamed];
+                    runCallbacks(fileCallbacks[id], id, 3);
+                }
+            }, _ => { }));
+            break;
+        case exports.Change.deleted:
+            console.log(`Deleted: ${uri}`);
+            wait_create.then(() => runCallbacks(fileCallbacks[id], id, mode));
+            break;
+    }
+    runGlobCallbacks(dirCallbacks[dirname(uri)], id, mode);
+}
+function recCallback(uri, mode) {
+    const id = file_id(uri);
+    fileCallbacks[id]?.forEach(func => func(id, mode));
+    runGlobCallbacks(dirCallbacks[dirname(uri)], id, mode);
+    for (const i in recCallbacks) {
+        if (id.startsWith(i))
+            runCallbacks(recCallbacks[i], id, mode);
+    }
+}
+function onChange(filename, func) {
+    const fulluri = uri(filename);
+    let dir = dirname(filename);
+    const rec = dir.indexOf('*');
+    if (rec !== -1)
+        dir = dir.substring(0, rec - 1);
+    let watcher = rec === -1 ? dirWatchers[dir] : recWatchers[dir];
+    if (!watcher && !Object.keys(recWatchers).some(i => dir.startsWith(i))) {
+        if (rec >= 0) {
+            for (const i in dirWatchers) {
+                if (i.startsWith(dir)) {
+                    dirWatchers[i].dispose();
+                    delete dirWatchers[i];
+                }
+            }
+            watcher = vscode.workspace.createFileSystemWatcher(new vscode.RelativePattern(withPathComponents(fulluri, dir), "**/*.*"));
+            watcher.onDidChange((uri) => recCallback(uri, exports.Change.changed));
+            watcher.onDidCreate((uri) => recCallback(uri, exports.Change.created));
+            watcher.onDidDelete((uri) => recCallback(uri, exports.Change.deleted));
+            recWatchers[dir] = watcher;
+        }
+        else {
+            watcher = vscode.workspace.createFileSystemWatcher(new vscode.RelativePattern(withPathComponents(fulluri, dir), "*.*"));
+            watcher.onDidChange((uri) => dirCallback(uri, exports.Change.changed));
+            watcher.onDidCreate((uri) => dirCallback(uri, exports.Change.created));
+            watcher.onDidDelete((uri) => dirCallback(uri, exports.Change.deleted));
+            dirWatchers[dir] = watcher;
+        }
+    }
+    if (rec >= 0) {
+        //recursive
+        (recCallbacks[dir] ??= []).push(func);
+    }
+    else if (basename(filename).indexOf('*') >= 0) {
+        //directory
+        (dirCallbacks[dir] ??= []).push([new Glob(basename(filename)), func]);
+    }
+    else {
+        //file
+        stat_reject(filename).then(stat => fileModTimes[stat.mtime] = file_id(filename), _ => { });
+        (fileCallbacks[filename.toString()] ??= []).push(func);
+    }
+}
+function arrayRemove(array, item) {
+    const index = array.indexOf(item);
+    if (index === -1)
+        return false;
+    array.splice(index, 1);
+    return true;
+}
+function removeOnChange(filename, func) {
+    const dir = dirname(filename);
+    if (dir.indexOf('*') >= 0) {
+        //recursive
+        const callbacks = recCallbacks[dir];
+        if (callbacks) {
+            arrayRemove(callbacks, func);
+            if (callbacks.length === 0) {
+                delete recCallbacks[dir];
+                const watcher = recWatchers[dir];
+                if (watcher) {
+                    watcher.dispose();
+                    delete recWatchers[dir];
+                }
+            }
+        }
+    }
+    else {
+        if (basename(filename).indexOf('*') === -1) {
+            //file
+            const callbacks = fileCallbacks[filename.toString()];
+            if (callbacks) {
+                arrayRemove(callbacks, func);
+                if (callbacks.length)
+                    return;
+                delete fileCallbacks[filename.toString()];
+            }
+        }
+        //directory
+        const callbacks = dirCallbacks[dir];
+        if (callbacks) {
+            const i = callbacks.findIndex(i => i[1] === func);
+            if (i !== -1) {
+                callbacks.splice(i, 1);
+                if (callbacks.length)
+                    return;
+                delete dirCallbacks[dir];
+                const watcher = dirWatchers[dir];
+                if (watcher) {
+                    watcher.dispose();
+                    delete dirWatchers[dir];
+                }
+            }
+        }
+    }
+}

package/dist/icon-theme.d.ts

@@ -0,0 +1,63 @@
+import * as vscode from 'vscode';
+interface ImageIcon {
+    iconPath: string;
+}
+interface FontIcon {
+    fontCharacter: string;
+    fontColor?: string;
+    fontSize?: number;
+    fontId?: string;
+}
+interface FontSource {
+    path: string;
+    format: string;
+}
+interface Font {
+    id: string;
+    src: FontSource[];
+    weight: string;
+    style: string;
+    size: string;
+}
+interface ThemeData {
+    iconDefinitions: Record<string, ImageIcon | FontIcon>;
+    fonts: Font[];
+    file: string;
+    folder: string;
+    folderExpanded: string;
+    rootFolder: string;
+    rootFolderExpanded: string;
+    folderNames: Record<string, string>;
+    folderNamesExpanded: Record<string, string>;
+    rootFolderNames: Record<string, string>;
+    rootFolderNamesExpanded: Record<string, string>;
+    languageIds: Record<string, string>;
+    fileExtensions: Record<string, string>;
+    fileNames: Record<string, string>;
+}
+export declare function getLanguage(ext: string): any;
+export declare class IconTheme {
+    themeFolder: vscode.Uri;
+    theme: ThemeData;
+    constructor(themeFolder: vscode.Uri, theme: ThemeData);
+    private getUri;
+    style(webview: vscode.Webview): string;
+    csp(webview: vscode.Webview): vscode.Uri;
+    get_def(webview: vscode.Webview, icon?: string): {
+        icon: vscode.Uri;
+    } | {
+        style?: string | undefined;
+        font: string;
+        icon: string;
+    } | undefined;
+    getLanguageIcon(ext: string): string | undefined;
+    getFileIcon(name: string): string | undefined;
+    getFolderIcon(name: string, expanded?: boolean): string | undefined;
+    getRootFolderIcon(name: string, expanded?: boolean): string | undefined;
+    getFileIconForUri(uri: vscode.Uri): string | undefined;
+    getFolderIconForUri(uri: vscode.Uri, expanded?: boolean, root?: vscode.Uri): string | undefined;
+    copyAssets(dest: vscode.Uri, changeFolder?: boolean): Promise<void>;
+}
+export declare function getIconTheme(id: string): vscode.Uri | undefined;
+export declare function loadIconTheme(): Promise<IconTheme | undefined>;
+export {};