@codingame/monaco-vscode-api 3.2.2 → 4.0.0

package/vscode/src/vs/platform/extensionManagement/common/extensionsScannerService.js

@@ -0,0 +1,901 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { coalesce } from '../../../base/common/arrays.js';
+import { ThrottledDelayer } from '../../../base/common/async.js';
+import { equals } from '../../../base/common/objects.js';
+import { VSBuffer } from '../../../base/common/buffer.js';
+import { getErrorMessage } from '../../../base/common/errors.js';
+import { parse, getNodeType } from '../../../base/common/json.js';
+import { getParseErrorMessage } from '../../../base/common/jsonErrorMessages.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { Schemas, FileAccess } from '../../../base/common/network.js';
+import { basename, normalize, join } from '../../../base/common/path.js';
+import { language } from '../../../base/common/platform.js';
+import { joinPath, isEqual, basename as basename$1 } from '../../../base/common/resources.js';
+import { semverExports } from '../../../../../../external/vscode-semver/semver.js';
+import Severity$1 from '../../../base/common/severity.js';
+import { isEmptyObject } from '../../../base/common/types.js';
+import { URI } from '../../../base/common/uri.js';
+import { localizeWithPath } from '../../../nls.js';
+import { IEnvironmentService } from '../../environment/common/environment.js';
+import { computeTargetPlatform, areSameExtensions, ExtensionKey, getGalleryExtensionId } from './extensionManagementUtil.js';
+import { UNDEFINED_PUBLISHER, BUILTIN_MANIFEST_CACHE_FILE, USER_MANIFEST_CACHE_FILE, ExtensionIdentifierMap } from '../../extensions/common/extensions.js';
+import { validateExtensionManifest } from '../../extensions/common/extensionValidator.js';
+import { toFileOperationResult, IFileService } from '../../files/common/files.js';
+import { createDecorator, IInstantiationService } from '../../instantiation/common/instantiation.js';
+import { ILogService } from '../../log/common/log.js';
+import { IProductService } from '../../product/common/productService.js';
+import { Emitter } from '../../../base/common/event.js';
+import { revive } from '../../../base/common/marshalling.js';
+import { ExtensionsProfileScanningError, IExtensionsProfileScannerService } from './extensionsProfileScannerService.js';
+import { IUserDataProfilesService } from '../../userDataProfile/common/userDataProfile.js';
+import { IUriIdentityService } from '../../uriIdentity/common/uriIdentity.js';
+import { localizeManifest } from './extensionNls.js';
+var Translations;
+( (function(Translations) {
+    function equals(a, b) {
+        if (a === b) {
+            return true;
+        }
+        const aKeys = ( Object.keys(a));
+        const bKeys = ( new Set());
+        for (const key of ( Object.keys(b))) {
+            bKeys.add(key);
+        }
+        if (aKeys.length !== bKeys.size) {
+            return false;
+        }
+        for (const key of aKeys) {
+            if (a[key] !== b[key]) {
+                return false;
+            }
+            bKeys.delete(key);
+        }
+        return bKeys.size === 0;
+    }
+    Translations.equals = equals;
+})(Translations || (Translations = {})));
+const IExtensionsScannerService = ( createDecorator('IExtensionsScannerService'));
+let AbstractExtensionsScannerService = class AbstractExtensionsScannerService extends Disposable {
+    constructor(systemExtensionsLocation, userExtensionsLocation, extensionsControlLocation, currentProfile, userDataProfilesService, extensionsProfileScannerService, fileService, logService, environmentService, productService, uriIdentityService, instantiationService) {
+        super();
+        this.systemExtensionsLocation = systemExtensionsLocation;
+        this.userExtensionsLocation = userExtensionsLocation;
+        this.extensionsControlLocation = extensionsControlLocation;
+        this.currentProfile = currentProfile;
+        this.userDataProfilesService = userDataProfilesService;
+        this.extensionsProfileScannerService = extensionsProfileScannerService;
+        this.fileService = fileService;
+        this.logService = logService;
+        this.environmentService = environmentService;
+        this.productService = productService;
+        this.uriIdentityService = uriIdentityService;
+        this.instantiationService = instantiationService;
+        this._onDidChangeCache = this._register(( new Emitter()));
+        this.onDidChangeCache = this._onDidChangeCache.event;
+        this.obsoleteFile = joinPath(this.userExtensionsLocation, '.obsolete');
+        this.systemExtensionsCachedScanner = this._register(this.instantiationService.createInstance(CachedExtensionsScanner, this.currentProfile, this.obsoleteFile));
+        this.userExtensionsCachedScanner = this._register(this.instantiationService.createInstance(CachedExtensionsScanner, this.currentProfile, this.obsoleteFile));
+        this.extensionsScanner = this._register(this.instantiationService.createInstance(ExtensionsScanner, this.obsoleteFile));
+        this.initializeDefaultProfileExtensionsPromise = undefined;
+        this._register(this.systemExtensionsCachedScanner.onDidChangeCache(() => this._onDidChangeCache.fire(0 )));
+        this._register(this.userExtensionsCachedScanner.onDidChangeCache(() => this._onDidChangeCache.fire(1 )));
+    }
+    getTargetPlatform() {
+        if (!this._targetPlatformPromise) {
+            this._targetPlatformPromise = computeTargetPlatform(this.fileService, this.logService);
+        }
+        return this._targetPlatformPromise;
+    }
+    async scanAllExtensions(systemScanOptions, userScanOptions, includeExtensionsUnderDev) {
+        const [system, user] = await Promise.all([
+            this.scanSystemExtensions(systemScanOptions),
+            this.scanUserExtensions(userScanOptions),
+        ]);
+        const development = includeExtensionsUnderDev ? await this.scanExtensionsUnderDevelopment(systemScanOptions, [...system, ...user]) : [];
+        return this.dedupExtensions(system, user, development, await this.getTargetPlatform(), true);
+    }
+    async scanSystemExtensions(scanOptions) {
+        const promises = [];
+        promises.push(this.scanDefaultSystemExtensions(!!scanOptions.useCache, scanOptions.language));
+        promises.push(this.scanDevSystemExtensions(scanOptions.language, !!scanOptions.checkControlFile));
+        const [defaultSystemExtensions, devSystemExtensions] = await Promise.all(promises);
+        return this.applyScanOptions([...defaultSystemExtensions, ...devSystemExtensions], 0 , scanOptions, false);
+    }
+    async scanUserExtensions(scanOptions) {
+        const location = scanOptions.profileLocation ?? this.userExtensionsLocation;
+        this.logService.trace('Started scanning user extensions', location);
+        const profileScanOptions = this.uriIdentityService.extUri.isEqual(scanOptions.profileLocation, this.userDataProfilesService.defaultProfile.extensionsResource) ? { bailOutWhenFileNotFound: true } : undefined;
+        const extensionsScannerInput = await this.createExtensionScannerInput(location, !!scanOptions.profileLocation, 1 , !scanOptions.includeUninstalled, scanOptions.language, true, profileScanOptions, scanOptions.productVersion ?? this.getProductVersion());
+        const extensionsScanner = scanOptions.useCache && !extensionsScannerInput.devMode && extensionsScannerInput.excludeObsolete ? this.userExtensionsCachedScanner : this.extensionsScanner;
+        let extensions;
+        try {
+            extensions = await extensionsScanner.scanExtensions(extensionsScannerInput);
+        }
+        catch (error) {
+            if (error instanceof ExtensionsProfileScanningError && error.code === "ERROR_PROFILE_NOT_FOUND" ) {
+                await this.doInitializeDefaultProfileExtensions();
+                extensions = await extensionsScanner.scanExtensions(extensionsScannerInput);
+            }
+            else {
+                throw error;
+            }
+        }
+        extensions = await this.applyScanOptions(extensions, 1 , scanOptions, true);
+        this.logService.trace('Scanned user extensions:', extensions.length);
+        return extensions;
+    }
+    async scanExtensionsUnderDevelopment(scanOptions, existingExtensions) {
+        if (this.environmentService.isExtensionDevelopment && this.environmentService.extensionDevelopmentLocationURI) {
+            const extensions = (await Promise.all(( this.environmentService.extensionDevelopmentLocationURI.filter(extLoc => extLoc.scheme === Schemas.file)
+                .map(async (extensionDevelopmentLocationURI) => {
+                const input = await this.createExtensionScannerInput(extensionDevelopmentLocationURI, false, 1 , true, scanOptions.language, false , undefined, scanOptions.productVersion ?? this.getProductVersion());
+                const extensions = await this.extensionsScanner.scanOneOrMultipleExtensions(input);
+                return ( extensions.map(extension => {
+                    extension.type = existingExtensions.find(e => areSameExtensions(e.identifier, extension.identifier))?.type ?? extension.type;
+                    return this.extensionsScanner.validate(extension, input);
+                }));
+            }))))
+                .flat();
+            return this.applyScanOptions(extensions, 'development', scanOptions, true);
+        }
+        return [];
+    }
+    async scanExistingExtension(extensionLocation, extensionType, scanOptions) {
+        const extensionsScannerInput = await this.createExtensionScannerInput(extensionLocation, false, extensionType, true, scanOptions.language, true, undefined, scanOptions.productVersion ?? this.getProductVersion());
+        const extension = await this.extensionsScanner.scanExtension(extensionsScannerInput);
+        if (!extension) {
+            return null;
+        }
+        if (!scanOptions.includeInvalid && !extension.isValid) {
+            return null;
+        }
+        return extension;
+    }
+    async scanOneOrMultipleExtensions(extensionLocation, extensionType, scanOptions) {
+        const extensionsScannerInput = await this.createExtensionScannerInput(extensionLocation, false, extensionType, true, scanOptions.language, true, undefined, scanOptions.productVersion ?? this.getProductVersion());
+        const extensions = await this.extensionsScanner.scanOneOrMultipleExtensions(extensionsScannerInput);
+        return this.applyScanOptions(extensions, extensionType, scanOptions, true);
+    }
+    async scanMultipleExtensions(extensionLocations, extensionType, scanOptions) {
+        const extensions = [];
+        await Promise.all(( extensionLocations.map(async (extensionLocation) => {
+            const scannedExtensions = await this.scanOneOrMultipleExtensions(extensionLocation, extensionType, scanOptions);
+            extensions.push(...scannedExtensions);
+        })));
+        return this.applyScanOptions(extensions, extensionType, scanOptions, true);
+    }
+    async scanMetadata(extensionLocation) {
+        const manifestLocation = joinPath(extensionLocation, 'package.json');
+        const content = ( (await this.fileService.readFile(manifestLocation)).value.toString());
+        const manifest = JSON.parse(content);
+        return manifest.__metadata;
+    }
+    async updateMetadata(extensionLocation, metaData) {
+        const manifestLocation = joinPath(extensionLocation, 'package.json');
+        const content = ( (await this.fileService.readFile(manifestLocation)).value.toString());
+        const manifest = JSON.parse(content);
+        if (metaData.isMachineScoped === false) {
+            delete metaData.isMachineScoped;
+        }
+        if (metaData.isBuiltin === false) {
+            delete metaData.isBuiltin;
+        }
+        manifest.__metadata = { ...manifest.__metadata, ...metaData };
+        await this.fileService.writeFile(joinPath(extensionLocation, 'package.json'), VSBuffer.fromString(JSON.stringify(manifest, null, '\t')));
+    }
+    async initializeDefaultProfileExtensions() {
+        try {
+            await this.extensionsProfileScannerService.scanProfileExtensions(this.userDataProfilesService.defaultProfile.extensionsResource, { bailOutWhenFileNotFound: true });
+        }
+        catch (error) {
+            if (error instanceof ExtensionsProfileScanningError && error.code === "ERROR_PROFILE_NOT_FOUND" ) {
+                await this.doInitializeDefaultProfileExtensions();
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async doInitializeDefaultProfileExtensions() {
+        if (!this.initializeDefaultProfileExtensionsPromise) {
+            this.initializeDefaultProfileExtensionsPromise = (async () => {
+                try {
+                    this.logService.info('Started initializing default profile extensions in extensions installation folder.', ( this.userExtensionsLocation.toString()));
+                    const userExtensions = await this.scanUserExtensions({ includeInvalid: true });
+                    if (userExtensions.length) {
+                        await this.extensionsProfileScannerService.addExtensionsToProfile(( userExtensions.map(e => [e, e.metadata])), this.userDataProfilesService.defaultProfile.extensionsResource);
+                    }
+                    else {
+                        try {
+                            await this.fileService.createFile(this.userDataProfilesService.defaultProfile.extensionsResource, VSBuffer.fromString(JSON.stringify([])));
+                        }
+                        catch (error) {
+                            if (toFileOperationResult(error) !== 1 ) {
+                                this.logService.warn('Failed to create default profile extensions manifest in extensions installation folder.', ( this.userExtensionsLocation.toString()), getErrorMessage(error));
+                            }
+                        }
+                    }
+                    this.logService.info('Completed initializing default profile extensions in extensions installation folder.', ( this.userExtensionsLocation.toString()));
+                }
+                catch (error) {
+                    this.logService.error(error);
+                }
+                finally {
+                    this.initializeDefaultProfileExtensionsPromise = undefined;
+                }
+            })();
+        }
+        return this.initializeDefaultProfileExtensionsPromise;
+    }
+    async applyScanOptions(extensions, type, scanOptions, pickLatest) {
+        if (!scanOptions.includeAllVersions) {
+            extensions = this.dedupExtensions(type === 0  ? extensions : undefined, type === 1  ? extensions : undefined, type === 'development' ? extensions : undefined, await this.getTargetPlatform(), pickLatest);
+        }
+        if (!scanOptions.includeInvalid) {
+            extensions = extensions.filter(extension => extension.isValid);
+        }
+        return extensions.sort((a, b) => {
+            const aLastSegment = basename(a.location.fsPath);
+            const bLastSegment = basename(b.location.fsPath);
+            if (aLastSegment < bLastSegment) {
+                return -1;
+            }
+            if (aLastSegment > bLastSegment) {
+                return 1;
+            }
+            return 0;
+        });
+    }
+    dedupExtensions(system, user, development, targetPlatform, pickLatest) {
+        const pick = (existing, extension, isDevelopment) => {
+            if (existing.isValid && !extension.isValid) {
+                return false;
+            }
+            if (existing.isValid === extension.isValid) {
+                if (pickLatest && semverExports.gt(existing.manifest.version, extension.manifest.version)) {
+                    this.logService.debug(`Skipping extension ${extension.location.path} with lower version ${extension.manifest.version} in favour of ${existing.location.path} with version ${existing.manifest.version}`);
+                    return false;
+                }
+                if (semverExports.eq(existing.manifest.version, extension.manifest.version)) {
+                    if (existing.type === 0 ) {
+                        this.logService.debug(`Skipping extension ${extension.location.path} in favour of system extension ${existing.location.path} with same version`);
+                        return false;
+                    }
+                    if (existing.targetPlatform === targetPlatform) {
+                        this.logService.debug(`Skipping extension ${extension.location.path} from different target platform ${extension.targetPlatform}`);
+                        return false;
+                    }
+                }
+            }
+            if (isDevelopment) {
+                this.logService.warn(`Overwriting user extension ${existing.location.path} with ${extension.location.path}.`);
+            }
+            else {
+                this.logService.debug(`Overwriting user extension ${existing.location.path} with ${extension.location.path}.`);
+            }
+            return true;
+        };
+        const result = ( new ExtensionIdentifierMap());
+        system?.forEach((extension) => {
+            const existing = result.get(extension.identifier.id);
+            if (!existing || pick(existing, extension, false)) {
+                result.set(extension.identifier.id, extension);
+            }
+        });
+        user?.forEach((extension) => {
+            const existing = result.get(extension.identifier.id);
+            if (!existing && system && extension.type === 0 ) {
+                this.logService.debug(`Skipping obsolete system extension ${extension.location.path}.`);
+                return;
+            }
+            if (!existing || pick(existing, extension, false)) {
+                result.set(extension.identifier.id, extension);
+            }
+        });
+        development?.forEach(extension => {
+            const existing = result.get(extension.identifier.id);
+            if (!existing || pick(existing, extension, true)) {
+                result.set(extension.identifier.id, extension);
+            }
+            result.set(extension.identifier.id, extension);
+        });
+        return [...( result.values())];
+    }
+    async scanDefaultSystemExtensions(useCache, language) {
+        this.logService.trace('Started scanning system extensions');
+        const extensionsScannerInput = await this.createExtensionScannerInput(this.systemExtensionsLocation, false, 0 , true, language, true, undefined, this.getProductVersion());
+        const extensionsScanner = useCache && !extensionsScannerInput.devMode ? this.systemExtensionsCachedScanner : this.extensionsScanner;
+        const result = await extensionsScanner.scanExtensions(extensionsScannerInput);
+        this.logService.trace('Scanned system extensions:', result.length);
+        return result;
+    }
+    async scanDevSystemExtensions(language, checkControlFile) {
+        const devSystemExtensionsList = this.environmentService.isBuilt ? [] : this.productService.builtInExtensions;
+        if (!devSystemExtensionsList?.length) {
+            return [];
+        }
+        this.logService.trace('Started scanning dev system extensions');
+        const builtinExtensionControl = checkControlFile ? await this.getBuiltInExtensionControl() : {};
+        const devSystemExtensionsLocations = [];
+        const devSystemExtensionsLocation = URI.file(normalize(join(( FileAccess.asFileUri('')).fsPath, '..', '.build', 'builtInExtensions')));
+        for (const extension of devSystemExtensionsList) {
+            const controlState = builtinExtensionControl[extension.name] || 'marketplace';
+            switch (controlState) {
+                case 'disabled':
+                    break;
+                case 'marketplace':
+                    devSystemExtensionsLocations.push(joinPath(devSystemExtensionsLocation, extension.name));
+                    break;
+                default:
+                    devSystemExtensionsLocations.push(URI.file(controlState));
+                    break;
+            }
+        }
+        const result = await Promise.all(( devSystemExtensionsLocations.map(
+            async (location) => this.extensionsScanner.scanExtension((await this.createExtensionScannerInput(location, false, 0 , true, language, true, undefined, this.getProductVersion())))
+        )));
+        this.logService.trace('Scanned dev system extensions:', result.length);
+        return coalesce(result);
+    }
+    async getBuiltInExtensionControl() {
+        try {
+            const content = await this.fileService.readFile(this.extensionsControlLocation);
+            return JSON.parse(( content.value.toString()));
+        }
+        catch (error) {
+            return {};
+        }
+    }
+    async createExtensionScannerInput(location, profile, type, excludeObsolete, language$1, validate, profileScanOptions, productVersion) {
+        const translations = await this.getTranslations(language$1 ?? language);
+        const mtime = await this.getMtime(location);
+        const applicationExtensionsLocation = profile && !this.uriIdentityService.extUri.isEqual(location, this.userDataProfilesService.defaultProfile.extensionsResource) ? this.userDataProfilesService.defaultProfile.extensionsResource : undefined;
+        const applicationExtensionsLocationMtime = applicationExtensionsLocation ? await this.getMtime(applicationExtensionsLocation) : undefined;
+        return ( new ExtensionScannerInput(
+            location,
+            mtime,
+            applicationExtensionsLocation,
+            applicationExtensionsLocationMtime,
+            profile,
+            profileScanOptions,
+            type,
+            excludeObsolete,
+            validate,
+            productVersion.version,
+            productVersion.date,
+            this.productService.commit,
+            !this.environmentService.isBuilt,
+            language$1,
+            translations
+        ));
+    }
+    async getMtime(location) {
+        try {
+            const stat = await this.fileService.stat(location);
+            if (typeof stat.mtime === 'number') {
+                return stat.mtime;
+            }
+        }
+        catch (err) {
+        }
+        return undefined;
+    }
+    getProductVersion() {
+        return {
+            version: this.productService.version,
+            date: this.productService.date,
+        };
+    }
+};
+AbstractExtensionsScannerService = ( __decorate([
+    ( __param(4, IUserDataProfilesService)),
+    ( __param(5, IExtensionsProfileScannerService)),
+    ( __param(6, IFileService)),
+    ( __param(7, ILogService)),
+    ( __param(8, IEnvironmentService)),
+    ( __param(9, IProductService)),
+    ( __param(10, IUriIdentityService)),
+    ( __param(11, IInstantiationService))
+], AbstractExtensionsScannerService));
+class ExtensionScannerInput {
+    constructor(location, mtime, applicationExtensionslocation, applicationExtensionslocationMtime, profile, profileScanOptions, type, excludeObsolete, validate, productVersion, productDate, productCommit, devMode, language, translations) {
+        this.location = location;
+        this.mtime = mtime;
+        this.applicationExtensionslocation = applicationExtensionslocation;
+        this.applicationExtensionslocationMtime = applicationExtensionslocationMtime;
+        this.profile = profile;
+        this.profileScanOptions = profileScanOptions;
+        this.type = type;
+        this.excludeObsolete = excludeObsolete;
+        this.validate = validate;
+        this.productVersion = productVersion;
+        this.productDate = productDate;
+        this.productCommit = productCommit;
+        this.devMode = devMode;
+        this.language = language;
+        this.translations = translations;
+    }
+    static createNlsConfiguration(input) {
+        return {
+            language: input.language,
+            pseudo: input.language === 'pseudo',
+            devMode: input.devMode,
+            translations: input.translations
+        };
+    }
+    static equals(a, b) {
+        return (isEqual(a.location, b.location)
+            && a.mtime === b.mtime
+            && isEqual(a.applicationExtensionslocation, b.applicationExtensionslocation)
+            && a.applicationExtensionslocationMtime === b.applicationExtensionslocationMtime
+            && a.profile === b.profile
+            && equals(a.profileScanOptions, b.profileScanOptions)
+            && a.type === b.type
+            && a.excludeObsolete === b.excludeObsolete
+            && a.validate === b.validate
+            && a.productVersion === b.productVersion
+            && a.productDate === b.productDate
+            && a.productCommit === b.productCommit
+            && a.devMode === b.devMode
+            && a.language === b.language
+            && Translations.equals(a.translations, b.translations));
+    }
+}
+let ExtensionsScanner = class ExtensionsScanner extends Disposable {
+    constructor(obsoleteFile, extensionsProfileScannerService, uriIdentityService, fileService, logService) {
+        super();
+        this.obsoleteFile = obsoleteFile;
+        this.extensionsProfileScannerService = extensionsProfileScannerService;
+        this.uriIdentityService = uriIdentityService;
+        this.fileService = fileService;
+        this.logService = logService;
+    }
+    async scanExtensions(input) {
+        const extensions = input.profile ? await this.scanExtensionsFromProfile(input) : await this.scanExtensionsFromLocation(input);
+        let obsolete = {};
+        if (input.excludeObsolete && input.type === 1 ) {
+            try {
+                const raw = ( (await this.fileService.readFile(this.obsoleteFile)).value.toString());
+                obsolete = JSON.parse(raw);
+            }
+            catch (error) {  }
+        }
+        return isEmptyObject(obsolete) ? extensions : extensions.filter(e => !obsolete[( ExtensionKey.create(e).toString())]);
+    }
+    async scanExtensionsFromLocation(input) {
+        const stat = await this.fileService.resolve(input.location);
+        if (!stat.children?.length) {
+            return [];
+        }
+        const extensions = await Promise.all(( stat.children.map(async (c) => {
+            if (!c.isDirectory) {
+                return null;
+            }
+            if (input.type === 1  && basename$1(c.resource).indexOf('.') === 0) {
+                return null;
+            }
+            const extensionScannerInput = ( new ExtensionScannerInput(
+                c.resource,
+                input.mtime,
+                input.applicationExtensionslocation,
+                input.applicationExtensionslocationMtime,
+                input.profile,
+                input.profileScanOptions,
+                input.type,
+                input.excludeObsolete,
+                input.validate,
+                input.productVersion,
+                input.productDate,
+                input.productCommit,
+                input.devMode,
+                input.language,
+                input.translations
+            ));
+            return this.scanExtension(extensionScannerInput);
+        })));
+        return coalesce(extensions)
+            .sort((a, b) => a.location.path < b.location.path ? -1 : 1);
+    }
+    async scanExtensionsFromProfile(input) {
+        let profileExtensions = await this.scanExtensionsFromProfileResource(input.location, () => true, input);
+        if (input.applicationExtensionslocation && !this.uriIdentityService.extUri.isEqual(input.location, input.applicationExtensionslocation)) {
+            profileExtensions = profileExtensions.filter(e => !e.metadata?.isApplicationScoped);
+            const applicationExtensions = await this.scanExtensionsFromProfileResource(input.applicationExtensionslocation, (e) => !!e.metadata?.isBuiltin || !!e.metadata?.isApplicationScoped, input);
+            profileExtensions.push(...applicationExtensions);
+        }
+        return profileExtensions;
+    }
+    async scanExtensionsFromProfileResource(profileResource, filter, input) {
+        const scannedProfileExtensions = await this.extensionsProfileScannerService.scanProfileExtensions(profileResource, input.profileScanOptions);
+        if (!scannedProfileExtensions.length) {
+            return [];
+        }
+        const extensions = await Promise.all(( scannedProfileExtensions.map(async (extensionInfo) => {
+            if (filter(extensionInfo)) {
+                const extensionScannerInput = ( new ExtensionScannerInput(
+                    extensionInfo.location,
+                    input.mtime,
+                    input.applicationExtensionslocation,
+                    input.applicationExtensionslocationMtime,
+                    input.profile,
+                    input.profileScanOptions,
+                    input.type,
+                    input.excludeObsolete,
+                    input.validate,
+                    input.productVersion,
+                    input.productDate,
+                    input.productCommit,
+                    input.devMode,
+                    input.language,
+                    input.translations
+                ));
+                return this.scanExtension(extensionScannerInput, extensionInfo.metadata);
+            }
+            return null;
+        })));
+        return coalesce(extensions);
+    }
+    async scanOneOrMultipleExtensions(input) {
+        try {
+            if (await this.fileService.exists(joinPath(input.location, 'package.json'))) {
+                const extension = await this.scanExtension(input);
+                return extension ? [extension] : [];
+            }
+            else {
+                return await this.scanExtensions(input);
+            }
+        }
+        catch (error) {
+            this.logService.error(`Error scanning extensions at ${input.location.path}:`, getErrorMessage(error));
+            return [];
+        }
+    }
+    async scanExtension(input, metadata) {
+        try {
+            let manifest = await this.scanExtensionManifest(input.location);
+            if (manifest) {
+                if (!manifest.publisher) {
+                    manifest.publisher = UNDEFINED_PUBLISHER;
+                }
+                metadata = metadata ?? manifest.__metadata;
+                delete manifest.__metadata;
+                const id = getGalleryExtensionId(manifest.publisher, manifest.name);
+                const identifier = metadata?.id ? { id, uuid: metadata.id } : { id };
+                const type = metadata?.isSystem ? 0  : input.type;
+                const isBuiltin = type === 0  || !!metadata?.isBuiltin;
+                manifest = await this.translateManifest(input.location, manifest, ExtensionScannerInput.createNlsConfiguration(input));
+                const extension = {
+                    type,
+                    identifier,
+                    manifest,
+                    location: input.location,
+                    isBuiltin,
+                    targetPlatform: metadata?.targetPlatform ?? "undefined" ,
+                    metadata,
+                    isValid: true,
+                    validations: []
+                };
+                return input.validate ? this.validate(extension, input) : extension;
+            }
+        }
+        catch (e) {
+            if (input.type !== 0 ) {
+                this.logService.error(e);
+            }
+        }
+        return null;
+    }
+    validate(extension, input) {
+        let isValid = true;
+        const validations = validateExtensionManifest(input.productVersion, input.productDate, input.location, extension.manifest, extension.isBuiltin);
+        for (const [severity, message] of validations) {
+            if (severity === Severity$1.Error) {
+                isValid = false;
+                this.logService.error(this.formatMessage(input.location, message));
+            }
+        }
+        extension.isValid = isValid;
+        extension.validations = validations;
+        return extension;
+    }
+    async scanExtensionManifest(extensionLocation) {
+        const manifestLocation = joinPath(extensionLocation, 'package.json');
+        let content;
+        try {
+            content = ( (await this.fileService.readFile(manifestLocation)).value.toString());
+        }
+        catch (error) {
+            if (toFileOperationResult(error) !== 1 ) {
+                this.logService.error(this.formatMessage(extensionLocation, ( localizeWithPath(
+                    'vs/platform/extensionManagement/common/extensionsScannerService',
+                    'fileReadFail',
+                    "Cannot read file {0}: {1}.",
+                    manifestLocation.path,
+                    error.message
+                ))));
+            }
+            return null;
+        }
+        let manifest;
+        try {
+            manifest = JSON.parse(content);
+        }
+        catch (err) {
+            const errors = [];
+            parse(content, errors);
+            for (const e of errors) {
+                this.logService.error(this.formatMessage(extensionLocation, ( localizeWithPath(
+                    'vs/platform/extensionManagement/common/extensionsScannerService',
+                    'jsonParseFail',
+                    "Failed to parse {0}: [{1}, {2}] {3}.",
+                    manifestLocation.path,
+                    e.offset,
+                    e.length,
+                    getParseErrorMessage(e.error)
+                ))));
+            }
+            return null;
+        }
+        if (getNodeType(manifest) !== 'object') {
+            this.logService.error(this.formatMessage(extensionLocation, ( localizeWithPath(
+                'vs/platform/extensionManagement/common/extensionsScannerService',
+                'jsonParseInvalidType',
+                "Invalid manifest file {0}: Not an JSON object.",
+                manifestLocation.path
+            ))));
+            return null;
+        }
+        return manifest;
+    }
+    async translateManifest(extensionLocation, extensionManifest, nlsConfiguration) {
+        const localizedMessages = await this.getLocalizedMessages(extensionLocation, extensionManifest, nlsConfiguration);
+        if (localizedMessages) {
+            try {
+                const errors = [];
+                const defaults = await this.resolveOriginalMessageBundle(localizedMessages.default, errors);
+                if (errors.length > 0) {
+                    errors.forEach((error) => {
+                        this.logService.error(this.formatMessage(extensionLocation, ( localizeWithPath(
+                            'vs/platform/extensionManagement/common/extensionsScannerService',
+                            'jsonsParseReportErrors',
+                            "Failed to parse {0}: {1}.",
+                            localizedMessages.default?.path,
+                            getParseErrorMessage(error.error)
+                        ))));
+                    });
+                    return extensionManifest;
+                }
+                else if (getNodeType(localizedMessages) !== 'object') {
+                    this.logService.error(this.formatMessage(extensionLocation, ( localizeWithPath(
+                        'vs/platform/extensionManagement/common/extensionsScannerService',
+                        'jsonInvalidFormat',
+                        "Invalid format {0}: JSON object expected.",
+                        localizedMessages.default?.path
+                    ))));
+                    return extensionManifest;
+                }
+                const localized = localizedMessages.values || Object.create(null);
+                return localizeManifest(this.logService, extensionManifest, localized, defaults);
+            }
+            catch (error) {
+            }
+        }
+        return extensionManifest;
+    }
+    async getLocalizedMessages(extensionLocation, extensionManifest, nlsConfiguration) {
+        const defaultPackageNLS = joinPath(extensionLocation, 'package.nls.json');
+        const reportErrors = (localized, errors) => {
+            errors.forEach((error) => {
+                this.logService.error(this.formatMessage(extensionLocation, ( localizeWithPath(
+                    'vs/platform/extensionManagement/common/extensionsScannerService',
+                    'jsonsParseReportErrors',
+                    "Failed to parse {0}: {1}.",
+                    localized?.path,
+                    getParseErrorMessage(error.error)
+                ))));
+            });
+        };
+        const reportInvalidFormat = (localized) => {
+            this.logService.error(this.formatMessage(extensionLocation, ( localizeWithPath(
+                'vs/platform/extensionManagement/common/extensionsScannerService',
+                'jsonInvalidFormat',
+                "Invalid format {0}: JSON object expected.",
+                localized?.path
+            ))));
+        };
+        const translationId = `${extensionManifest.publisher}.${extensionManifest.name}`;
+        const translationPath = nlsConfiguration.translations[translationId];
+        if (translationPath) {
+            try {
+                const translationResource = URI.file(translationPath);
+                const content = ( (await this.fileService.readFile(translationResource)).value.toString());
+                const errors = [];
+                const translationBundle = parse(content, errors);
+                if (errors.length > 0) {
+                    reportErrors(translationResource, errors);
+                    return { values: undefined, default: defaultPackageNLS };
+                }
+                else if (getNodeType(translationBundle) !== 'object') {
+                    reportInvalidFormat(translationResource);
+                    return { values: undefined, default: defaultPackageNLS };
+                }
+                else {
+                    const values = translationBundle.contents ? translationBundle.contents.package : undefined;
+                    return { values: values, default: defaultPackageNLS };
+                }
+            }
+            catch (error) {
+                return { values: undefined, default: defaultPackageNLS };
+            }
+        }
+        else {
+            const exists = await this.fileService.exists(defaultPackageNLS);
+            if (!exists) {
+                return undefined;
+            }
+            let messageBundle;
+            try {
+                messageBundle = await this.findMessageBundles(extensionLocation, nlsConfiguration);
+            }
+            catch (error) {
+                return undefined;
+            }
+            if (!messageBundle.localized) {
+                return { values: undefined, default: messageBundle.original };
+            }
+            try {
+                const messageBundleContent = ( (await this.fileService.readFile(messageBundle.localized)).value.toString());
+                const errors = [];
+                const messages = parse(messageBundleContent, errors);
+                if (errors.length > 0) {
+                    reportErrors(messageBundle.localized, errors);
+                    return { values: undefined, default: messageBundle.original };
+                }
+                else if (getNodeType(messages) !== 'object') {
+                    reportInvalidFormat(messageBundle.localized);
+                    return { values: undefined, default: messageBundle.original };
+                }
+                return { values: messages, default: messageBundle.original };
+            }
+            catch (error) {
+                return { values: undefined, default: messageBundle.original };
+            }
+        }
+    }
+    async resolveOriginalMessageBundle(originalMessageBundle, errors) {
+        if (originalMessageBundle) {
+            try {
+                const originalBundleContent = ( (await this.fileService.readFile(originalMessageBundle)).value.toString());
+                return parse(originalBundleContent, errors);
+            }
+            catch (error) {
+            }
+        }
+        return;
+    }
+    findMessageBundles(extensionLocation, nlsConfiguration) {
+        return ( new Promise((c, e) => {
+            const loop = (locale) => {
+                const toCheck = joinPath(extensionLocation, `package.nls.${locale}.json`);
+                this.fileService.exists(toCheck).then(exists => {
+                    if (exists) {
+                        c({ localized: toCheck, original: joinPath(extensionLocation, 'package.nls.json') });
+                    }
+                    const index = locale.lastIndexOf('-');
+                    if (index === -1) {
+                        c({ localized: joinPath(extensionLocation, 'package.nls.json'), original: null });
+                    }
+                    else {
+                        locale = locale.substring(0, index);
+                        loop(locale);
+                    }
+                });
+            };
+            if (nlsConfiguration.devMode || nlsConfiguration.pseudo || !nlsConfiguration.language) {
+                return c({ localized: joinPath(extensionLocation, 'package.nls.json'), original: null });
+            }
+            loop(nlsConfiguration.language);
+        }));
+    }
+    formatMessage(extensionLocation, message) {
+        return `[${extensionLocation.path}]: ${message}`;
+    }
+};
+ExtensionsScanner = ( __decorate([
+    ( __param(1, IExtensionsProfileScannerService)),
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, IFileService)),
+    ( __param(4, ILogService))
+], ExtensionsScanner));
+let CachedExtensionsScanner = class CachedExtensionsScanner extends ExtensionsScanner {
+    constructor(currentProfile, obsoleteFile, userDataProfilesService, extensionsProfileScannerService, uriIdentityService, fileService, logService) {
+        super(obsoleteFile, extensionsProfileScannerService, uriIdentityService, fileService, logService);
+        this.currentProfile = currentProfile;
+        this.userDataProfilesService = userDataProfilesService;
+        this.cacheValidatorThrottler = this._register(( new ThrottledDelayer(3000)));
+        this._onDidChangeCache = this._register(( new Emitter()));
+        this.onDidChangeCache = this._onDidChangeCache.event;
+    }
+    async scanExtensions(input) {
+        const cacheFile = this.getCacheFile(input);
+        const cacheContents = await this.readExtensionCache(cacheFile);
+        this.input = input;
+        if (cacheContents && cacheContents.input && ExtensionScannerInput.equals(cacheContents.input, this.input)) {
+            this.logService.debug('Using cached extensions scan result', ( input.location.toString()));
+            this.cacheValidatorThrottler.trigger(() => this.validateCache());
+            return ( cacheContents.result.map((extension) => {
+                extension.location = URI.revive(extension.location);
+                return extension;
+            }));
+        }
+        const result = await super.scanExtensions(input);
+        await this.writeExtensionCache(cacheFile, { input, result });
+        return result;
+    }
+    async readExtensionCache(cacheFile) {
+        try {
+            const cacheRawContents = await this.fileService.readFile(cacheFile);
+            const extensionCacheData = JSON.parse(( cacheRawContents.value.toString()));
+            return { result: extensionCacheData.result, input: revive(extensionCacheData.input) };
+        }
+        catch (error) {
+            this.logService.debug('Error while reading the extension cache file:', cacheFile.path, getErrorMessage(error));
+        }
+        return null;
+    }
+    async writeExtensionCache(cacheFile, cacheContents) {
+        try {
+            await this.fileService.writeFile(cacheFile, VSBuffer.fromString(JSON.stringify(cacheContents)));
+        }
+        catch (error) {
+            this.logService.debug('Error while writing the extension cache file:', cacheFile.path, getErrorMessage(error));
+        }
+    }
+    async validateCache() {
+        if (!this.input) {
+            return;
+        }
+        const cacheFile = this.getCacheFile(this.input);
+        const cacheContents = await this.readExtensionCache(cacheFile);
+        if (!cacheContents) {
+            return;
+        }
+        const actual = cacheContents.result;
+        const expected = JSON.parse(JSON.stringify(await super.scanExtensions(this.input)));
+        if (equals(expected, actual)) {
+            return;
+        }
+        try {
+            this.logService.info('Invalidating Cache', actual, expected);
+            await this.fileService.del(cacheFile);
+            this._onDidChangeCache.fire();
+        }
+        catch (error) {
+            this.logService.error(error);
+        }
+    }
+    getCacheFile(input) {
+        const profile = this.getProfile(input);
+        return this.uriIdentityService.extUri.joinPath(profile.cacheHome, input.type === 0  ? BUILTIN_MANIFEST_CACHE_FILE : USER_MANIFEST_CACHE_FILE);
+    }
+    getProfile(input) {
+        if (input.type === 0 ) {
+            return this.userDataProfilesService.defaultProfile;
+        }
+        if (!input.profile) {
+            return this.userDataProfilesService.defaultProfile;
+        }
+        if (this.uriIdentityService.extUri.isEqual(input.location, this.currentProfile.extensionsResource)) {
+            return this.currentProfile;
+        }
+        return this.userDataProfilesService.profiles.find(p => this.uriIdentityService.extUri.isEqual(input.location, p.extensionsResource)) ?? this.currentProfile;
+    }
+};
+CachedExtensionsScanner = ( __decorate([
+    ( __param(2, IUserDataProfilesService)),
+    ( __param(3, IExtensionsProfileScannerService)),
+    ( __param(4, IUriIdentityService)),
+    ( __param(5, IFileService)),
+    ( __param(6, ILogService))
+], CachedExtensionsScanner));
+export { AbstractExtensionsScannerService, ExtensionScannerInput, IExtensionsScannerService, Translations };