/// <summary>
        /// Try to retreive a default classification for <paramref name="name"/> if it isn't <see cref="PredefinedClassificationTypeNames.Identifier"/>
        /// </summary>
        public static bool TryGetDefaultNonIdentifierClassification(string name, out IClassificationType classification)
        {
            if (NonIdentifierClassifications.TryGetValue(name, out var classificationName))
            {
                classification = ServicesProvider.Instance.RegistryService.GetClassificationType(classificationName);
                return(!(classification is null));
            }

            classification = null;
            return(false);
        }
        /// <returns>
        /// Classifications are grouped by language
        /// </returns>
        public static IReadOnlyDictionary <string, ICollection <IClassificationType> > GetClassifications()
        {
            if (_classifications != null)
            {
                return(_classifications);
            }

            _classifications = new Dictionary <string, ICollection <IClassificationType> >();

            var registryService  = ServicesProvider.Instance.RegistryService;
            var formatMapService = ServicesProvider.Instance.FormatMapService;

            var formatMap          = formatMapService.GetClassificationFormatMap(category: "text");
            var identifierPosition = GetClassificationPosition(registryService, formatMap, PredefinedClassificationTypeNames.Identifier);

            formatMap.BeginBatchUpdate();
            foreach (var(language, names) in Names.All)
            {
                var languageClassifications = new List <IClassificationType>();
                foreach (var name in names)
                {
                    var classificationPosition = identifierPosition;
                    if (NonIdentifierClassifications.TryGetValue(name, out var relevantClassification))
                    {
                        classificationPosition = GetClassificationPosition(registryService, formatMap, relevantClassification);
                    }

                    var classificationType = registryService.GetClassificationType(name);
                    if (classificationType != null)
                    {
                        // TODO: need to carefully test this case
                        if (classificationPosition > 0)
                        {
                            // NOTE: Set priority of classification next to the relevant classification
                            SetPriority(formatMap, classificationType, classificationPosition);
                        }
                    }
                    else
                    {
                        classificationType = registryService.CreateClassificationType(name, new IClassificationType[0]);
                        var formatting = TextFormattingRunProperties.CreateTextFormattingRunProperties();
                        if (classificationPosition > 0)
                        {
                            // NOTE: Set priority of classification next to the relevant classification
                            var afterClassification = formatMap.CurrentPriorityOrder[classificationPosition + 1];
                            formatMap.AddExplicitTextProperties(classificationType, formatting, afterClassification);
                        }
                        else
                        {
                            // NOTE: Set the last priority
                            formatMap.AddExplicitTextProperties(classificationType, formatting);
                        }
                    }

                    languageClassifications.Add(classificationType);
                }
                _classifications.Add(language, languageClassifications);
            }
            formatMap.EndBatchUpdate();

            return(_classifications);
        }