monaco-editor11 1.0.7 → 1.0.9

package/dist/workers/editor/common/languagesAssociations.js

@@ -0,0 +1,193 @@
+import { parse } from '../../../base/common/glob.js';
+import { Mimes } from '../../../base/common/mime.js';
+import { Schemas } from '../../../base/common/network.js';
+import { basename, posix } from '../../../base/common/path.js';
+import { DataUri } from '../../../base/common/resources.js';
+import { startsWithUTF8BOM } from '../../../base/common/strings.js';
+import { PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+let registeredAssociations = [];
+let nonUserRegisteredAssociations = [];
+let userRegisteredAssociations = [];
+/**
+ * Associate a language to the registry (platform).
+ * * **NOTE**: This association will lose over associations registered using `registerConfiguredLanguageAssociation`.
+ * * **NOTE**: Use `clearPlatformLanguageAssociations` to remove all associations registered using this function.
+ */
+function registerPlatformLanguageAssociation(association, warnOnOverwrite = false) {
+    _registerLanguageAssociation(association, false, warnOnOverwrite);
+}
+function _registerLanguageAssociation(association, userConfigured, warnOnOverwrite) {
+    // Register
+    const associationItem = toLanguageAssociationItem(association, userConfigured);
+    registeredAssociations.push(associationItem);
+    if (!associationItem.userConfigured) {
+        nonUserRegisteredAssociations.push(associationItem);
+    }
+    else {
+        userRegisteredAssociations.push(associationItem);
+    }
+    // Check for conflicts unless this is a user configured association
+    if (warnOnOverwrite && !associationItem.userConfigured) {
+        registeredAssociations.forEach(a => {
+            if (a.mime === associationItem.mime || a.userConfigured) {
+                return; // same mime or userConfigured is ok
+            }
+            if (associationItem.extension && a.extension === associationItem.extension) {
+                console.warn(`Overwriting extension <<${associationItem.extension}>> to now point to mime <<${associationItem.mime}>>`);
+            }
+            if (associationItem.filename && a.filename === associationItem.filename) {
+                console.warn(`Overwriting filename <<${associationItem.filename}>> to now point to mime <<${associationItem.mime}>>`);
+            }
+            if (associationItem.filepattern && a.filepattern === associationItem.filepattern) {
+                console.warn(`Overwriting filepattern <<${associationItem.filepattern}>> to now point to mime <<${associationItem.mime}>>`);
+            }
+            if (associationItem.firstline && a.firstline === associationItem.firstline) {
+                console.warn(`Overwriting firstline <<${associationItem.firstline}>> to now point to mime <<${associationItem.mime}>>`);
+            }
+        });
+    }
+}
+function toLanguageAssociationItem(association, userConfigured) {
+    return {
+        id: association.id,
+        mime: association.mime,
+        filename: association.filename,
+        extension: association.extension,
+        filepattern: association.filepattern,
+        firstline: association.firstline,
+        userConfigured: userConfigured,
+        filenameLowercase: association.filename ? association.filename.toLowerCase() : undefined,
+        extensionLowercase: association.extension ? association.extension.toLowerCase() : undefined,
+        filepatternLowercase: association.filepattern ? parse(association.filepattern.toLowerCase()) : undefined,
+        filepatternOnPath: association.filepattern ? association.filepattern.indexOf(posix.sep) >= 0 : false
+    };
+}
+/**
+ * Clear language associations from the registry (platform).
+ */
+function clearPlatformLanguageAssociations() {
+    registeredAssociations = registeredAssociations.filter(a => a.userConfigured);
+    nonUserRegisteredAssociations = [];
+}
+/**
+ * @see `getMimeTypes`
+ */
+function getLanguageIds(resource, firstLine) {
+    return getAssociations(resource, firstLine).map(item => item.id);
+}
+function getAssociations(resource, firstLine) {
+    let path;
+    if (resource) {
+        switch (resource.scheme) {
+            case Schemas.file:
+                path = resource.fsPath;
+                break;
+            case Schemas.data: {
+                const metadata = DataUri.parseMetaData(resource);
+                path = metadata.get(DataUri.META_DATA_LABEL);
+                break;
+            }
+            case Schemas.vscodeNotebookCell:
+                // File path not relevant for language detection of cell
+                path = undefined;
+                break;
+            default:
+                path = resource.path;
+        }
+    }
+    if (!path) {
+        return [{ id: 'unknown', mime: Mimes.unknown }];
+    }
+    path = path.toLowerCase();
+    const filename = basename(path);
+    // 1.) User configured mappings have highest priority
+    const configuredLanguage = getAssociationByPath(path, filename, userRegisteredAssociations);
+    if (configuredLanguage) {
+        return [configuredLanguage, { id: PLAINTEXT_LANGUAGE_ID, mime: Mimes.text }];
+    }
+    // 2.) Registered mappings have middle priority
+    const registeredLanguage = getAssociationByPath(path, filename, nonUserRegisteredAssociations);
+    if (registeredLanguage) {
+        return [registeredLanguage, { id: PLAINTEXT_LANGUAGE_ID, mime: Mimes.text }];
+    }
+    // 3.) Firstline has lowest priority
+    if (firstLine) {
+        const firstlineLanguage = getAssociationByFirstline(firstLine);
+        if (firstlineLanguage) {
+            return [firstlineLanguage, { id: PLAINTEXT_LANGUAGE_ID, mime: Mimes.text }];
+        }
+    }
+    return [{ id: 'unknown', mime: Mimes.unknown }];
+}
+function getAssociationByPath(path, filename, associations) {
+    let filenameMatch = undefined;
+    let patternMatch = undefined;
+    let extensionMatch = undefined;
+    // We want to prioritize associations based on the order they are registered so that the last registered
+    // association wins over all other. This is for https://github.com/microsoft/vscode/issues/20074
+    for (let i = associations.length - 1; i >= 0; i--) {
+        const association = associations[i];
+        // First exact name match
+        if (filename === association.filenameLowercase) {
+            filenameMatch = association;
+            break; // take it!
+        }
+        // Longest pattern match
+        if (association.filepattern) {
+            if (!patternMatch || association.filepattern.length > patternMatch.filepattern.length) {
+                const target = association.filepatternOnPath ? path : filename; // match on full path if pattern contains path separator
+                if (association.filepatternLowercase?.(target)) {
+                    patternMatch = association;
+                }
+            }
+        }
+        // Longest extension match
+        if (association.extension) {
+            if (!extensionMatch || association.extension.length > extensionMatch.extension.length) {
+                if (filename.endsWith(association.extensionLowercase)) {
+                    extensionMatch = association;
+                }
+            }
+        }
+    }
+    // 1.) Exact name match has second highest priority
+    if (filenameMatch) {
+        return filenameMatch;
+    }
+    // 2.) Match on pattern
+    if (patternMatch) {
+        return patternMatch;
+    }
+    // 3.) Match on extension comes next
+    if (extensionMatch) {
+        return extensionMatch;
+    }
+    return undefined;
+}
+function getAssociationByFirstline(firstLine) {
+    if (startsWithUTF8BOM(firstLine)) {
+        firstLine = firstLine.substr(1);
+    }
+    if (firstLine.length > 0) {
+        // We want to prioritize associations based on the order they are registered so that the last registered
+        // association wins over all other. This is for https://github.com/microsoft/vscode/issues/20074
+        for (let i = registeredAssociations.length - 1; i >= 0; i--) {
+            const association = registeredAssociations[i];
+            if (!association.firstline) {
+                continue;
+            }
+            const matches = firstLine.match(association.firstline);
+            if (matches && matches.length > 0) {
+                return association;
+            }
+        }
+    }
+    return undefined;
+}
+
+export { clearPlatformLanguageAssociations, getLanguageIds, registerPlatformLanguageAssociation };

package/dist/workers/editor/common/languagesRegistry.js

@@ -0,0 +1,237 @@
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { regExpLeadsToEndlessLoop } from '../../../base/common/strings.js';
+import { clearPlatformLanguageAssociations, registerPlatformLanguageAssociation, getLanguageIds } from './languagesAssociations.js';
+import { ModesRegistry, PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
+import { Extensions } from '../../../platform/configuration/common/configurationRegistry.js';
+import { Registry } from '../../../platform/registry/common/platform.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const NULL_LANGUAGE_ID = 'vs.editor.nullLanguage';
+class LanguageIdCodec {
+    constructor() {
+        this._languageIdToLanguage = [];
+        this._languageToLanguageId = new Map();
+        this._register(NULL_LANGUAGE_ID, 0 /* LanguageId.Null */);
+        this._register(PLAINTEXT_LANGUAGE_ID, 1 /* LanguageId.PlainText */);
+        this._nextLanguageId = 2;
+    }
+    _register(language, languageId) {
+        this._languageIdToLanguage[languageId] = language;
+        this._languageToLanguageId.set(language, languageId);
+    }
+    register(language) {
+        if (this._languageToLanguageId.has(language)) {
+            return;
+        }
+        const languageId = this._nextLanguageId++;
+        this._register(language, languageId);
+    }
+    encodeLanguageId(languageId) {
+        return this._languageToLanguageId.get(languageId) || 0 /* LanguageId.Null */;
+    }
+    decodeLanguageId(languageId) {
+        return this._languageIdToLanguage[languageId] || NULL_LANGUAGE_ID;
+    }
+}
+class LanguagesRegistry extends Disposable {
+    static { this.instanceCount = 0; }
+    constructor(useModesRegistry = true, warnOnOverwrite = false) {
+        super();
+        this._onDidChange = this._register(new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        LanguagesRegistry.instanceCount++;
+        this._warnOnOverwrite = warnOnOverwrite;
+        this.languageIdCodec = new LanguageIdCodec();
+        this._dynamicLanguages = [];
+        this._languages = {};
+        this._mimeTypesMap = {};
+        this._nameMap = {};
+        this._lowercaseNameMap = {};
+        if (useModesRegistry) {
+            this._initializeFromRegistry();
+            this._register(ModesRegistry.onDidChangeLanguages((m) => {
+                this._initializeFromRegistry();
+            }));
+        }
+    }
+    dispose() {
+        LanguagesRegistry.instanceCount--;
+        super.dispose();
+    }
+    _initializeFromRegistry() {
+        this._languages = {};
+        this._mimeTypesMap = {};
+        this._nameMap = {};
+        this._lowercaseNameMap = {};
+        clearPlatformLanguageAssociations();
+        const desc = [].concat(ModesRegistry.getLanguages()).concat(this._dynamicLanguages);
+        this._registerLanguages(desc);
+    }
+    _registerLanguages(desc) {
+        for (const d of desc) {
+            this._registerLanguage(d);
+        }
+        // Rebuild fast path maps
+        this._mimeTypesMap = {};
+        this._nameMap = {};
+        this._lowercaseNameMap = {};
+        Object.keys(this._languages).forEach((langId) => {
+            const language = this._languages[langId];
+            if (language.name) {
+                this._nameMap[language.name] = language.identifier;
+            }
+            language.aliases.forEach((alias) => {
+                this._lowercaseNameMap[alias.toLowerCase()] = language.identifier;
+            });
+            language.mimetypes.forEach((mimetype) => {
+                this._mimeTypesMap[mimetype] = language.identifier;
+            });
+        });
+        Registry.as(Extensions.Configuration).registerOverrideIdentifiers(this.getRegisteredLanguageIds());
+        this._onDidChange.fire();
+    }
+    _registerLanguage(lang) {
+        const langId = lang.id;
+        let resolvedLanguage;
+        if (hasOwnProperty.call(this._languages, langId)) {
+            resolvedLanguage = this._languages[langId];
+        }
+        else {
+            this.languageIdCodec.register(langId);
+            resolvedLanguage = {
+                identifier: langId,
+                name: null,
+                mimetypes: [],
+                aliases: [],
+                extensions: [],
+                filenames: [],
+                configurationFiles: [],
+                icons: []
+            };
+            this._languages[langId] = resolvedLanguage;
+        }
+        this._mergeLanguage(resolvedLanguage, lang);
+    }
+    _mergeLanguage(resolvedLanguage, lang) {
+        const langId = lang.id;
+        let primaryMime = null;
+        if (Array.isArray(lang.mimetypes) && lang.mimetypes.length > 0) {
+            resolvedLanguage.mimetypes.push(...lang.mimetypes);
+            primaryMime = lang.mimetypes[0];
+        }
+        if (!primaryMime) {
+            primaryMime = `text/x-${langId}`;
+            resolvedLanguage.mimetypes.push(primaryMime);
+        }
+        if (Array.isArray(lang.extensions)) {
+            if (lang.configuration) {
+                // insert first as this appears to be the 'primary' language definition
+                resolvedLanguage.extensions = lang.extensions.concat(resolvedLanguage.extensions);
+            }
+            else {
+                resolvedLanguage.extensions = resolvedLanguage.extensions.concat(lang.extensions);
+            }
+            for (const extension of lang.extensions) {
+                registerPlatformLanguageAssociation({ id: langId, mime: primaryMime, extension: extension }, this._warnOnOverwrite);
+            }
+        }
+        if (Array.isArray(lang.filenames)) {
+            for (const filename of lang.filenames) {
+                registerPlatformLanguageAssociation({ id: langId, mime: primaryMime, filename: filename }, this._warnOnOverwrite);
+                resolvedLanguage.filenames.push(filename);
+            }
+        }
+        if (Array.isArray(lang.filenamePatterns)) {
+            for (const filenamePattern of lang.filenamePatterns) {
+                registerPlatformLanguageAssociation({ id: langId, mime: primaryMime, filepattern: filenamePattern }, this._warnOnOverwrite);
+            }
+        }
+        if (typeof lang.firstLine === 'string' && lang.firstLine.length > 0) {
+            let firstLineRegexStr = lang.firstLine;
+            if (firstLineRegexStr.charAt(0) !== '^') {
+                firstLineRegexStr = '^' + firstLineRegexStr;
+            }
+            try {
+                const firstLineRegex = new RegExp(firstLineRegexStr);
+                if (!regExpLeadsToEndlessLoop(firstLineRegex)) {
+                    registerPlatformLanguageAssociation({ id: langId, mime: primaryMime, firstline: firstLineRegex }, this._warnOnOverwrite);
+                }
+            }
+            catch (err) {
+                // Most likely, the regex was bad
+                console.warn(`[${lang.id}]: Invalid regular expression \`${firstLineRegexStr}\`: `, err);
+            }
+        }
+        resolvedLanguage.aliases.push(langId);
+        let langAliases = null;
+        if (typeof lang.aliases !== 'undefined' && Array.isArray(lang.aliases)) {
+            if (lang.aliases.length === 0) {
+                // signal that this language should not get a name
+                langAliases = [null];
+            }
+            else {
+                langAliases = lang.aliases;
+            }
+        }
+        if (langAliases !== null) {
+            for (const langAlias of langAliases) {
+                if (!langAlias || langAlias.length === 0) {
+                    continue;
+                }
+                resolvedLanguage.aliases.push(langAlias);
+            }
+        }
+        const containsAliases = (langAliases !== null && langAliases.length > 0);
+        if (containsAliases && langAliases[0] === null) ;
+        else {
+            const bestName = (containsAliases ? langAliases[0] : null) || langId;
+            if (containsAliases || !resolvedLanguage.name) {
+                resolvedLanguage.name = bestName;
+            }
+        }
+        if (lang.configuration) {
+            resolvedLanguage.configurationFiles.push(lang.configuration);
+        }
+        if (lang.icon) {
+            resolvedLanguage.icons.push(lang.icon);
+        }
+    }
+    isRegisteredLanguageId(languageId) {
+        if (!languageId) {
+            return false;
+        }
+        return hasOwnProperty.call(this._languages, languageId);
+    }
+    getRegisteredLanguageIds() {
+        return Object.keys(this._languages);
+    }
+    getLanguageIdByLanguageName(languageName) {
+        const languageNameLower = languageName.toLowerCase();
+        if (!hasOwnProperty.call(this._lowercaseNameMap, languageNameLower)) {
+            return null;
+        }
+        return this._lowercaseNameMap[languageNameLower];
+    }
+    getLanguageIdByMimeType(mimeType) {
+        if (!mimeType) {
+            return null;
+        }
+        if (hasOwnProperty.call(this._mimeTypesMap, mimeType)) {
+            return this._mimeTypesMap[mimeType];
+        }
+        return null;
+    }
+    guessLanguageIdByFilepathOrFirstLine(resource, firstLine) {
+        if (!resource && !firstLine) {
+            return [];
+        }
+        return getLanguageIds(resource, firstLine);
+    }
+}
+
+export { LanguageIdCodec, LanguagesRegistry };