internal static bool IsValidTheme(string file)
        {
            var bundle = new LanguageBundle("default", null);

            try {
                LoadFile(bundle, file, () => File.OpenRead(file), () => new UrlStreamProvider(file));
                return(bundle.EditorThemes.Count > 0);
            } catch (Exception ex) {
                LoggingService.LogError($"Invalid color theme file '{file}'.", ex);
            }
            return(false);
        }
        static object LoadFile(LanguageBundle bundle, string file, Func <Stream> openStream, Func <IStreamProvider> getStreamProvider)
        {
            if (file.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
            {
                using (var stream = openStream()) {
                    string     styleName;
                    JSonFormat format;
                    if (TryScanJSonStyle(stream, out styleName, out format, out List <string> fileTypes, out string scopeName))
                    {
                        switch (format)
                        {
                        case JSonFormat.OldSyntaxTheme:
                            var oldThemeProvider = AbstractThemeProvider.CreateProvider(EditorThemeFormat.XamarinStudio, styleName, getStreamProvider);
                            bundle.Add(oldThemeProvider);
                            return(oldThemeProvider);

                        case JSonFormat.TextMateJsonSyntax:
                            var syntaxProvider = AbstractSyntaxHighlightingDefinitionProvider.CreateProvider(SyntaxHighlightingDefinitionFormat.TextMateJson, styleName, scopeName, fileTypes, getStreamProvider);
                            bundle.Add(syntaxProvider);
                            return(syntaxProvider);
                        }
                    }
                }
            }
            else if (file.EndsWith(".tmTheme", StringComparison.OrdinalIgnoreCase))
            {
                using (var stream = openStream()) {
                    string styleName = ScanTextMateStyle(stream);
                    if (!string.IsNullOrEmpty(styleName))
                    {
                        var theme = AbstractThemeProvider.CreateProvider(EditorThemeFormat.TextMate, styleName, getStreamProvider);
                        bundle.Add(theme);
                        return(theme);
                    }
                    else
                    {
                        LoggingService.LogError("Invalid .tmTheme theme file : " + file);
                    }
                }
            }
            else if (file.EndsWith(".vssettings", StringComparison.OrdinalIgnoreCase))
            {
                using (var stream = openStream()) {
                    var theme = AbstractThemeProvider.CreateProvider(EditorThemeFormat.VisualStudio, file, getStreamProvider);
                    bundle.Add(theme);
                    return(theme);
                }
            }
            else if (file.EndsWith(".tmLanguage", StringComparison.OrdinalIgnoreCase))
            {
                using (var stream = openStream()) {
                    if (TryScanTextMateSyntax(stream, out List <string> fileTypes, out string styleName, out string scopeName))
                    {
                        var syntaxProvider = AbstractSyntaxHighlightingDefinitionProvider.CreateProvider(SyntaxHighlightingDefinitionFormat.TextMate, styleName, scopeName, fileTypes, getStreamProvider);
                        bundle.Add(syntaxProvider);
                        return(syntaxProvider);
                    }
                    else
                    {
                        LoggingService.LogError("Invalid .tmLanguage file : " + file);
                    }
                }
 internal static object LoadStyleOrMode(LanguageBundle bundle, string file)
 {
     return(LoadFile(bundle, file, () => File.OpenRead(file), () => new UrlStreamProvider(file)));
 }
 internal static void Remove(LanguageBundle style)
 {
     languageBundles.Remove(style);
 }
 internal static void Remove(LanguageBundle style)
 {
     InitializeStylesAndModes();
     languageBundles.Remove(style);
 }
        /*
         *              if (provider.Name.EndsWith (".vssettings", StringComparison.Ordinal)) {
         *              styles [name] = OldFormat.ImportVsSetting (provider.Name, stream);
         *      } else if (provider.Name.EndsWith (".json", StringComparison.Ordinal)) {
         *              styles [name] = OldFormat.ImportColorScheme (stream);
         *      } else {
         *              styles [name] = TextMateFormat.LoadEditorTheme (stream);
         *      }
         *      styles [name].FileName = provider.Name;
         *
         * */

        static object LoadFile(LanguageBundle bundle, string file, Func <Stream> openStream, Func <IStreamProvider> getStreamProvider)
        {
            if (file.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
            {
                using (var stream = openStream()) {
                    string     styleName;
                    JSonFormat format;
                    if (TryScanJSonStyle(stream, out styleName, out format))
                    {
                        switch (format)
                        {
                        case JSonFormat.OldSyntaxTheme:
                            var theme = OldFormat.ImportColorScheme(getStreamProvider().Open());
                            if (theme != null)
                            {
                                bundle.Add(theme);
                            }
                            return(theme);

                        case JSonFormat.TextMateJsonSyntax:
                            SyntaxHighlightingDefinition highlighting = TextMateFormat.ReadHighlightingFromJson(getStreamProvider().Open());
                            if (highlighting != null)
                            {
                                bundle.Add(highlighting);
                            }
                            return(highlighting);
                        }
                    }
                }
            }
            else if (file.EndsWith(".tmTheme", StringComparison.OrdinalIgnoreCase))
            {
                using (var stream = openStream()) {
                    string styleName = ScanTextMateStyle(stream);
                    if (!string.IsNullOrEmpty(styleName))
                    {
                        var theme = TextMateFormat.LoadEditorTheme(getStreamProvider().Open());
                        if (theme != null)
                        {
                            bundle.Add(theme);
                        }
                        return(theme);
                    }
                    else
                    {
                        LoggingService.LogError("Invalid .tmTheme theme file : " + file);
                    }
                }
            }
            else if (file.EndsWith(".vssettings", StringComparison.OrdinalIgnoreCase))
            {
                using (var stream = openStream()) {
                    string      styleName = Path.GetFileNameWithoutExtension(file);
                    EditorTheme theme;
                    try {
                        theme = OldFormat.ImportVsSetting(styleName, getStreamProvider().Open());
                    } catch (StyleImportException e) {
                        switch (e.Reason)
                        {
                        case StyleImportException.ImportFailReason.Unknown:
                            LoggingService.LogWarning("Unknown error in theme file : " + file, e);
                            break;

                        case StyleImportException.ImportFailReason.NoValidColorsFound:
                            LoggingService.LogWarning("No colors defined in vssettings : " + file, e);
                            break;
                        }
                        return(null);
                    } catch (Exception e) {
                        LoggingService.LogWarning("Invalid theme : " + file, e);
                        return(null);
                    }
                    if (theme != null)
                    {
                        bundle.Add(theme);
                    }
                    return(theme);
                }
            }
            else if (file.EndsWith(".tmLanguage", StringComparison.OrdinalIgnoreCase))
            {
                using (var stream = openStream()) {
                    var highlighting = TextMateFormat.ReadHighlighting(stream);
                    if (highlighting != null)
                    {
                        bundle.Add(highlighting);
                    }
                    return(highlighting);
                }
            }
            else if (file.EndsWith(".sublime-syntax", StringComparison.OrdinalIgnoreCase))
            {
                using (var stream = new StreamReader(openStream())) {
                    var highlighting = Sublime3Format.ReadHighlighting(stream);
                    if (highlighting != null)
                    {
                        bundle.Add(highlighting);
                    }
                    return(highlighting);
                }
            }
            else if (file.EndsWith(".sublime-package", StringComparison.OrdinalIgnoreCase) || file.EndsWith(".tmbundle", StringComparison.OrdinalIgnoreCase))
            {
                try {
                    using (var stream = new ICSharpCode.SharpZipLib.Zip.ZipInputStream(openStream())) {
                        var entry     = stream.GetNextEntry();
                        var newBundle = new LanguageBundle(Path.GetFileNameWithoutExtension(file), file);
                        while (entry != null)
                        {
                            if (entry.IsFile && !entry.IsCrypted)
                            {
                                if (stream.CanDecompressEntry)
                                {
                                    byte [] data = new byte [entry.Size];
                                    stream.Read(data, 0, (int)entry.Size);
                                    LoadFile(newBundle, entry.Name, () => new MemoryStream(data), () => new MemoryStreamProvider(data, entry.Name));
                                }
                            }
                            entry = stream.GetNextEntry();
                        }
                        languageBundles.Add(newBundle);
                        return(newBundle);
                    }
                } catch (Exception e) {
                    LoggingService.LogError("Error while reading : " + file, e);
                }
            }
            else if (file.EndsWith(".tmPreferences", StringComparison.OrdinalIgnoreCase))
            {
                using (var stream = openStream()) {
                    var preference = TextMateFormat.ReadPreferences(stream);
                    if (preference != null)
                    {
                        bundle.Add(preference);
                    }
                    return(preference);
                }
            }
            else if (file.EndsWith(".tmSnippet", StringComparison.OrdinalIgnoreCase))
            {
                using (var stream = openStream()) {
                    var snippet = TextMateFormat.ReadSnippet(stream);
                    if (snippet != null)
                    {
                        bundle.Add(snippet);
                    }
                    return(snippet);
                }
            }
            else if (file.EndsWith(".sublime-snippet", StringComparison.OrdinalIgnoreCase))
            {
                using (var stream = openStream()) {
                    var snippet = Sublime3Format.ReadSnippet(stream);
                    if (snippet != null)
                    {
                        bundle.Add(snippet);
                    }
                    return(snippet);
                }
            }
            return(null);
        }