material-icon-theme 4.26.0 → 4.28.0

package/src/icons/generator/iconSaturation.ts

@@ -1,140 +0,0 @@
-import { readdirSync, readFileSync, writeFileSync } from 'fs';
-import { basename, join } from 'path';
-import { getCustomIconPaths } from '../../helpers/customIcons';
-import { IconJsonOptions } from '../../models';
-
-/**
- * Changes saturation of all icons in the set.
- * @param options Icon JSON options which include the saturation value.
- * @param fileNames Only change the saturation of certain file names.
- */
-export const setIconSaturation = (
-  options: IconJsonOptions,
-  fileNames?: string[]
-) => {
-  if (!validateSaturationValue(options.saturation)) {
-    return console.error(
-      'Invalid saturation value! Saturation must be a decimal number between 0 and 1!'
-    );
-  }
-
-  let iconsPath = '';
-  if (basename(__dirname) === 'dist') {
-    iconsPath = join(__dirname, '..', 'icons');
-  } else {
-    // executed via script
-    iconsPath = join(__dirname, '..', '..', '..', 'icons');
-  }
-
-  const customIconPaths = getCustomIconPaths(options);
-  const iconFiles = readdirSync(iconsPath);
-
-  // read all icon files from the icons folder
-  try {
-    (fileNames || iconFiles).forEach(adjustSaturation(iconsPath, options));
-
-    customIconPaths.forEach((iconPath) => {
-      const customIcons = readdirSync(iconPath);
-      customIcons.forEach(adjustSaturation(iconPath, options));
-    });
-  } catch (error) {
-    console.error(error);
-  }
-};
-
-/**
- * Get the SVG root element.
- * @param svg SVG file as string.
- */
-const getSVGRootElement = (svg: string) => {
-  const result = new RegExp(/<svg[^>]*>/).exec(svg);
-  return result?.[0];
-};
-
-/**
- * Add an filter attribute to the SVG icon.
- * @param svgRoot Root element of the SVG icon.
- */
-const addFilterAttribute = (svgRoot: string) => {
-  const pattern = new RegExp(/\sfilter="[^"]+?"/);
-  // if the filter attribute already exists
-  if (pattern.test(svgRoot)) {
-    return svgRoot.replace(pattern, ' filter="url(#saturation)"');
-  } else {
-    return svgRoot.replace(/^<svg/, '<svg filter="url(#saturation)"');
-  }
-};
-
-/**
- * Remove the filter attribute of the SVG icon.
- * @param svgRoot Root element of the SVG icon.
- */
-const removeFilterAttribute = (svgRoot: string) => {
-  const pattern = new RegExp(/\sfilter="[^"]+?"/);
-  return svgRoot.replace(pattern, '');
-};
-
-/**
- * Add filter element to the SVG icon.
- * @param svg SVG file as string.
- */
-const addFilterElement = (svg: string, value: number) => {
-  const pattern = new RegExp(/<filter id="saturation".+<\/filter>(.*<\/svg>)/);
-  const filterElement = `<filter id="saturation"><feColorMatrix type="saturate" values="${value}"/></filter>`;
-  if (pattern.test(svg)) {
-    return svg.replace(pattern, `${filterElement}$1`);
-  } else {
-    return svg.replace(/<\/svg>/, `${filterElement}</svg>`);
-  }
-};
-
-/**
- * Remove filter element from the SVG icon.
- * @param svg SVG file as string.
- */
-const removeFilterElement = (svg: string) => {
-  const pattern = new RegExp(/<filter id="saturation".+<\/filter>(.*<\/svg>)/);
-  return svg.replace(pattern, '$1');
-};
-
-/**
- * Validate the saturation value.
- * @param saturation Saturation value
- */
-export const validateSaturationValue = (saturation: number | undefined) => {
-  return saturation !== undefined && saturation <= 1 && saturation >= 0;
-};
-
-const adjustSaturation = (
-  iconsPath: any,
-  options: IconJsonOptions
-): ((value: string, index: number, array: string[]) => void) => {
-  return (iconFileName) => {
-    const svgFilePath = join(iconsPath, iconFileName);
-
-    // Read SVG file
-    const svg = readFileSync(svgFilePath, 'utf-8');
-
-    // Get the root element of the SVG file
-    const svgRootElement = getSVGRootElement(svg);
-    if (!svgRootElement) return;
-
-    let updatedRootElement: string;
-
-    if (options.saturation !== undefined && options.saturation < 1) {
-      updatedRootElement = addFilterAttribute(svgRootElement);
-    } else {
-      updatedRootElement = removeFilterAttribute(svgRootElement);
-    }
-
-    let updatedSVG = svg.replace(/<svg[^>]*>/, updatedRootElement);
-
-    if (options.saturation !== undefined && options.saturation < 1) {
-      updatedSVG = addFilterElement(updatedSVG, options.saturation);
-    } else {
-      updatedSVG = removeFilterElement(updatedSVG);
-    }
-
-    writeFileSync(svgFilePath, updatedSVG);
-  };
-};

package/src/icons/generator/index.ts

@@ -1,7 +0,0 @@
-export * from './fileGenerator';
-export * from './folderGenerator';
-export * from './languageGenerator';
-export * from './constants';
-export * from './jsonGenerator';
-export * from './iconOpacity';
-export * from './iconSaturation';

package/src/icons/generator/jsonGenerator.ts

@@ -1,207 +0,0 @@
-import {
-  existsSync,
-  readdirSync,
-  renameSync,
-  unlinkSync,
-  writeFileSync,
-} from 'fs';
-import merge from 'lodash.merge';
-import { basename, join } from 'path';
-import { getCustomIconPaths } from '../../helpers/customIcons';
-import { getFileConfigHash } from '../../helpers/fileConfig';
-import { IconConfiguration, IconJsonOptions } from '../../models/index';
-import { fileIcons } from '../fileIcons';
-import { folderIcons } from '../folderIcons';
-import { languageIcons } from '../languageIcons';
-import { iconJsonName } from './constants';
-import {
-  generateFileIcons,
-  generateFolderIcons,
-  loadFileIconDefinitions,
-  loadFolderIconDefinitions,
-  loadLanguageIconDefinitions,
-  setIconOpacity,
-  setIconSaturation,
-  validateHEXColorCode,
-  validateOpacityValue,
-  validateSaturationValue,
-} from './index';
-
-/**
- * Generate the complete icon configuration object that can be written as JSON file.
- */
-export const generateIconConfigurationObject = (
-  options: IconJsonOptions
-): IconConfiguration => {
-  const iconConfig = merge({}, new IconConfiguration(), { options });
-  const languageIconDefinitions = loadLanguageIconDefinitions(
-    languageIcons,
-    iconConfig,
-    options
-  );
-  const fileIconDefinitions = loadFileIconDefinitions(
-    fileIcons,
-    iconConfig,
-    options
-  );
-  const folderIconDefinitions = loadFolderIconDefinitions(
-    folderIcons,
-    iconConfig,
-    options
-  );
-
-  return merge(
-    {},
-    languageIconDefinitions,
-    fileIconDefinitions,
-    folderIconDefinitions
-  );
-};
-
-/**
- * Create the JSON file that is responsible for the icons in the editor.
- * @param updatedConfigs Options that have been changed.
- * @param updatedJSONConfig New JSON options that already include the updatedConfigs.
- */
-export const createIconFile = (
-  updatedConfigs?: IconJsonOptions,
-  updatedJSONConfig: IconJsonOptions = {}
-) => {
-  // override the default options with the new options
-  const options: IconJsonOptions = merge(
-    {},
-    getDefaultIconOptions(),
-    updatedJSONConfig
-  );
-  const json = generateIconConfigurationObject(options);
-
-  // make sure that the folder color, opacity and saturation values are entered correctly
-  if (
-    updatedConfigs?.opacity &&
-    !validateOpacityValue(updatedConfigs?.opacity)
-  ) {
-    throw Error('Material Icons: Invalid opacity value!');
-  }
-  if (
-    updatedConfigs?.saturation &&
-    !validateSaturationValue(updatedConfigs?.saturation)
-  ) {
-    throw Error('Material Icons: Invalid saturation value!');
-  }
-  if (
-    updatedConfigs?.folders?.color &&
-    !validateHEXColorCode(updatedConfigs?.folders?.color)
-  ) {
-    throw Error('Material Icons: Invalid folder color value!');
-  }
-  if (
-    updatedConfigs?.files?.color &&
-    !validateHEXColorCode(updatedConfigs?.files?.color)
-  ) {
-    throw Error('Material Icons: Invalid file color value!');
-  }
-
-  try {
-    let iconJsonPath = __dirname;
-    // if executed via script
-    if (basename(__dirname) !== 'dist') {
-      iconJsonPath = join(__dirname, '..', '..', '..', 'dist');
-    }
-    if (!updatedConfigs || (updatedConfigs.files || {}).color) {
-      // if updatedConfigs do not exist (because of initial setup)
-      // or new config value was detected by the change detection
-      generateFileIcons(options.files?.color);
-      setIconOpacity(options, ['file.svg']);
-    }
-    if (!updatedConfigs || (updatedConfigs.folders || {}).color) {
-      // if updatedConfigs do not exist (because of initial setup)
-      // or new config value was detected by the change detection
-      generateFolderIcons(options.folders?.color);
-      setIconOpacity(options, [
-        'folder.svg',
-        'folder-open.svg',
-        'folder-root.svg',
-        'folder-root-open.svg',
-      ]);
-    }
-    if (!updatedConfigs || updatedConfigs.opacity !== undefined) {
-      setIconOpacity(options);
-    }
-    if (!updatedConfigs || updatedConfigs.saturation !== undefined) {
-      setIconSaturation(options);
-    }
-    renameIconFiles(iconJsonPath, options);
-  } catch (error) {
-    throw new Error('Failed to update icons: ' + error);
-  }
-
-  try {
-    let iconJsonPath = __dirname;
-    // if executed via script
-    if (basename(__dirname) !== 'dist') {
-      iconJsonPath = join(__dirname, '..', '..', '..', 'dist');
-    }
-    writeFileSync(
-      join(iconJsonPath, iconJsonName),
-      JSON.stringify(json, undefined, 2),
-      'utf-8'
-    );
-  } catch (error) {
-    throw new Error('Failed to create icon file: ' + error);
-  }
-
-  return iconJsonName;
-};
-
-/**
- * The options control the generator and decide which icons are disabled or not.
- */
-export const getDefaultIconOptions = (): Required<IconJsonOptions> => ({
-  folders: {
-    theme: 'specific',
-    color: '#90a4ae',
-    associations: {},
-  },
-  activeIconPack: 'angular',
-  hidesExplorerArrows: false,
-  opacity: 1,
-  saturation: 1,
-  files: {
-    color: '#90a4ae',
-    associations: {},
-  },
-  languages: { associations: {} },
-});
-
-/**
- * Rename all icon files according their respective config
- * @param iconJsonPath Path of icon json folder
- * @param options Icon Json Options
- */
-const renameIconFiles = (iconJsonPath: string, options: IconJsonOptions) => {
-  const customPaths = getCustomIconPaths(options);
-  const defaultIconPath = join(iconJsonPath, '..', 'icons');
-  const iconPaths = [defaultIconPath, ...customPaths];
-
-  iconPaths.forEach((iconPath) => {
-    readdirSync(iconPath)
-      .filter((f) => f.match(/\.svg/gi))
-      .forEach((f) => {
-        const filePath = join(iconPath, f);
-        const fileConfigHash = getFileConfigHash(options);
-
-        // append file config to file name
-        const newFilePath = join(
-          iconPath,
-          f.replace(/(^[^\.~]+)(.*)\.svg/, `$1${fileConfigHash}.svg`)
-        );
-
-        // if generated files are already in place, do not overwrite them
-        if (filePath !== newFilePath && existsSync(newFilePath)) {
-          unlinkSync(filePath);
-        } else {
-          renameSync(filePath, newFilePath);
-        }
-      });
-  });
-};

package/src/icons/generator/languageGenerator.ts

@@ -1,127 +0,0 @@
-import merge from 'lodash.merge';
-import { getFileConfigHash } from '../../helpers/fileConfig';
-import {
-  DefaultIcon,
-  IconAssociations,
-  IconConfiguration,
-  IconJsonOptions,
-  LanguageIcon,
-} from '../../models/index';
-import {
-  highContrastColorFileEnding,
-  iconFolderPath,
-  lightColorFileEnding,
-} from './constants';
-
-/**
- * Get all file icons that can be used in this theme.
- */
-export const loadLanguageIconDefinitions = (
-  languages: LanguageIcon[],
-  config: IconConfiguration,
-  options: IconJsonOptions
-): IconConfiguration => {
-  config = merge({}, config);
-  const enabledLanguages = disableLanguagesByPack(
-    languages,
-    options.activeIconPack
-  );
-  const customIcons = getCustomIcons(options.languages?.associations);
-  const allLanguageIcons = [...enabledLanguages, ...customIcons];
-
-  allLanguageIcons.forEach((lang) => {
-    if (lang.disabled) return;
-    config = setIconDefinitions(config, lang.icon);
-    config = merge(
-      {},
-      config,
-      setLanguageIdentifiers(lang.icon.name, lang.ids)
-    );
-    config.light = lang.icon.light
-      ? merge(
-          {},
-          config.light,
-          setLanguageIdentifiers(
-            lang.icon.name + lightColorFileEnding,
-            lang.ids
-          )
-        )
-      : config.light;
-    config.highContrast = lang.icon.highContrast
-      ? merge(
-          {},
-          config.highContrast,
-          setLanguageIdentifiers(
-            lang.icon.name + highContrastColorFileEnding,
-            lang.ids
-          )
-        )
-      : config.highContrast;
-  });
-
-  return config;
-};
-
-const setIconDefinitions = (config: IconConfiguration, icon: DefaultIcon) => {
-  config = merge({}, config);
-  config = createIconDefinitions(config, icon.name);
-  config = merge(
-    {},
-    config,
-    icon.light
-      ? createIconDefinitions(config, icon.name + lightColorFileEnding)
-      : config.light
-  );
-  config = merge(
-    {},
-    config,
-    icon.highContrast
-      ? createIconDefinitions(config, icon.name + highContrastColorFileEnding)
-      : config.highContrast
-  );
-  return config;
-};
-
-const createIconDefinitions = (config: IconConfiguration, iconName: string) => {
-  config = merge({}, config);
-  const fileConfigHash = getFileConfigHash(config.options ?? {});
-  if (config.iconDefinitions) {
-    config.iconDefinitions[iconName] = {
-      iconPath: `${iconFolderPath}${iconName}${fileConfigHash}.svg`,
-    };
-  }
-  return config;
-};
-
-const setLanguageIdentifiers = (iconName: string, languageIds: string[]) => {
-  const obj: Partial<IconConfiguration> = { languageIds: {} };
-  languageIds.forEach((id) => {
-    obj.languageIds![id as keyof IconConfiguration] = iconName;
-  });
-  return obj;
-};
-
-const getCustomIcons = (languageAssociations: IconAssociations | undefined) => {
-  if (!languageAssociations) return [];
-
-  const icons: LanguageIcon[] = Object.keys(languageAssociations).map((fa) => ({
-    icon: { name: languageAssociations[fa].toLowerCase() },
-    ids: [fa.toLowerCase()],
-  }));
-
-  return icons;
-};
-
-/**
- * Disable all file icons that are in a pack which is disabled.
- */
-const disableLanguagesByPack = (
-  languageIcons: LanguageIcon[],
-  activatedIconPack: string | undefined
-) => {
-  return languageIcons.filter((language) => {
-    return !language.enabledFor
-      ? true
-      : language.enabledFor.some((p) => p === activatedIconPack);
-  });
-};

package/src/icons/index.ts

@@ -1,4 +0,0 @@
-export * from './generator';
-export * from './fileIcons';
-export * from './folderIcons';
-export * from './languageIcons';

package/src/icons/languageIcons.ts

@@ -1,144 +0,0 @@
-import { LanguageIcon } from '../models';
-
-/**
- * Defines icons for language ids
- */
-export const languageIcons: LanguageIcon[] = [
-  { icon: { name: 'git' }, ids: ['git', 'git-commit', 'git-rebase', 'ignore'] },
-  { icon: { name: 'yaml' }, ids: ['yaml'] },
-  { icon: { name: 'xml' }, ids: ['xml', 'xquery', 'xsl'] },
-  { icon: { name: 'matlab' }, ids: ['matlab'] },
-  {
-    icon: { name: 'settings' },
-    ids: ['makefile', 'toml', 'ini', 'properties'],
-  },
-  { icon: { name: 'shaderlab' }, ids: ['shaderlab'] },
-  { icon: { name: 'diff' }, ids: ['diff'] },
-  { icon: { name: 'json' }, ids: ['json', 'jsonc', 'json5'] },
-  { icon: { name: 'blink' }, ids: ['blink'] },
-  { icon: { name: 'java' }, ids: ['java'] },
-  { icon: { name: 'razor' }, ids: ['razor', 'aspnetcorerazor'] },
-  { icon: { name: 'python' }, ids: ['python'] },
-  { icon: { name: 'javascript' }, ids: ['javascript'] },
-  { icon: { name: 'typescript' }, ids: ['typescript'] },
-  { icon: { name: 'scala' }, ids: ['scala'] },
-  { icon: { name: 'handlebars' }, ids: ['handlebars'] },
-  { icon: { name: 'perl' }, ids: ['perl', 'perl6'] },
-  { icon: { name: 'haxe' }, ids: ['haxe', 'hxml'] },
-  { icon: { name: 'puppet' }, ids: ['puppet'] },
-  { icon: { name: 'elixir' }, ids: ['elixir'] },
-  { icon: { name: 'livescript' }, ids: ['livescript'] },
-  { icon: { name: 'erlang' }, ids: ['erlang'] },
-  { icon: { name: 'twig' }, ids: ['twig'] },
-  { icon: { name: 'julia' }, ids: ['julia'] },
-  { icon: { name: 'elm' }, ids: ['elm'] },
-  { icon: { name: 'purescript' }, ids: ['purescript'] },
-  { icon: { name: 'stylus' }, ids: ['stylus'] },
-  { icon: { name: 'nunjucks' }, ids: ['nunjucks'] },
-  { icon: { name: 'pug' }, ids: ['pug'] },
-  { icon: { name: 'robot' }, ids: ['robotframework'] },
-  { icon: { name: 'sass' }, ids: ['sass', 'scss'] },
-  { icon: { name: 'less' }, ids: ['less'] },
-  { icon: { name: 'css' }, ids: ['css'] },
-  { icon: { name: 'visualstudio' }, ids: ['testOutput', 'vb'] },
-  { icon: { name: 'angular' }, ids: ['ng-template'] },
-  { icon: { name: 'graphql' }, ids: ['graphql'] },
-  { icon: { name: 'solidity' }, ids: ['solidity'] },
-  { icon: { name: 'autoit' }, ids: ['autoit'] },
-  { icon: { name: 'haml' }, ids: ['haml'] },
-  { icon: { name: 'yang' }, ids: ['yang'] },
-  { icon: { name: 'terraform' }, ids: ['terraform'] },
-  { icon: { name: 'applescript' }, ids: ['applescript'] },
-  { icon: { name: 'cake' }, ids: ['cake'] },
-  { icon: { name: 'cucumber' }, ids: ['cucumber'] },
-  { icon: { name: 'nim' }, ids: ['nim', 'nimble'] },
-  { icon: { name: 'apiblueprint' }, ids: ['apiblueprint'] },
-  { icon: { name: 'riot' }, ids: ['riot'] },
-  { icon: { name: 'postcss' }, ids: ['postcss'] },
-  { icon: { name: 'coldfusion' }, ids: ['lang-cfml'] },
-  { icon: { name: 'haskell' }, ids: ['haskell'] },
-  { icon: { name: 'dhall' }, ids: ['dhall'] },
-  { icon: { name: 'cabal' }, ids: ['cabal'] },
-  { icon: { name: 'nix' }, ids: ['nix'] },
-  { icon: { name: 'ruby' }, ids: ['ruby'] },
-  { icon: { name: 'slim' }, ids: ['slim'] },
-  { icon: { name: 'php' }, ids: ['php'] },
-  { icon: { name: 'php_elephant' }, ids: [] },
-  { icon: { name: 'php_elephant_pink' }, ids: [] },
-  { icon: { name: 'hack' }, ids: ['hack'] },
-  { icon: { name: 'react' }, ids: ['javascriptreact'] },
-  { icon: { name: 'mjml' }, ids: ['mjml'] },
-  { icon: { name: 'processing' }, ids: ['processing'] },
-  { icon: { name: 'hcl' }, ids: ['hcl'] },
-  { icon: { name: 'go' }, ids: ['go'] },
-  { icon: { name: 'go_gopher' }, ids: [] },
-  { icon: { name: 'nodejs_alt' }, ids: [] },
-  { icon: { name: 'django' }, ids: ['django-html', 'django-txt'] },
-  { icon: { name: 'html' }, ids: ['html'] },
-  { icon: { name: 'godot' }, ids: ['gdscript'] },
-  { icon: { name: 'godot-assets' }, ids: ['gdresource', 'gdshader'] },
-  { icon: { name: 'vim' }, ids: ['viml'] },
-  { icon: { name: 'silverstripe' }, ids: [] },
-  { icon: { name: 'prolog' }, ids: ['prolog'] },
-  { icon: { name: 'pawn' }, ids: ['pawn'] },
-  { icon: { name: 'reason' }, ids: ['reason', 'reason_lisp'] },
-  { icon: { name: 'sml' }, ids: ['sml'] },
-  { icon: { name: 'tex' }, ids: ['tex', 'doctex', 'latex', 'latex-expl3'] },
-  { icon: { name: 'salesforce' }, ids: ['apex'] },
-  { icon: { name: 'sas' }, ids: ['sas'] },
-  { icon: { name: 'docker' }, ids: ['dockerfile'] },
-  { icon: { name: 'table' }, ids: ['csv', 'tsv', 'psv'] },
-  { icon: { name: 'csharp' }, ids: ['csharp'] },
-  { icon: { name: 'console' }, ids: ['bat', 'awk', 'shellscript'] },
-  { icon: { name: 'c' }, ids: ['c'] },
-  { icon: { name: 'cpp' }, ids: ['cpp'] },
-  { icon: { name: 'objective-c' }, ids: ['objective-c'] },
-  { icon: { name: 'objective-cpp' }, ids: ['objective-cpp'] },
-  { icon: { name: 'coffee' }, ids: ['coffeescript'] },
-  { icon: { name: 'fsharp' }, ids: ['fsharp'] },
-  { icon: { name: 'editorconfig' }, ids: ['editorconfig'] },
-  { icon: { name: 'clojure' }, ids: ['clojure'] },
-  { icon: { name: 'groovy' }, ids: ['groovy'] },
-  { icon: { name: 'markdown' }, ids: ['markdown'] },
-  { icon: { name: 'jinja' }, ids: ['jinja'] },
-  { icon: { name: 'proto' }, ids: ['proto'] },
-  { icon: { name: 'python-misc' }, ids: ['pip-requirements'] },
-  { icon: { name: 'vue' }, ids: ['vue', 'vue-postcss', 'vue-html'] },
-  { icon: { name: 'lua' }, ids: ['lua'] },
-  { icon: { name: 'lib' }, ids: ['bibtex', 'bibtex-style'] },
-  { icon: { name: 'log' }, ids: ['log'] },
-  { icon: { name: 'jupyter' }, ids: ['jupyter'] },
-  { icon: { name: 'document' }, ids: ['plaintext'] },
-  { icon: { name: 'pdf' }, ids: ['pdf'] },
-  { icon: { name: 'powershell' }, ids: ['powershell'] },
-  { icon: { name: 'pug' }, ids: ['jade'] },
-  { icon: { name: 'r' }, ids: ['r', 'rsweave'] },
-  { icon: { name: 'rust' }, ids: ['rust'] },
-  { icon: { name: 'database' }, ids: ['sql'] },
-  { icon: { name: 'kusto' }, ids: ['kql'] },
-  { icon: { name: 'lock' }, ids: ['ssh_config'] },
-  { icon: { name: 'svg' }, ids: ['svg'] },
-  { icon: { name: 'swift' }, ids: ['swift'] },
-  { icon: { name: 'react_ts' }, ids: ['typescriptreact'] },
-  { icon: { name: 'search' }, ids: ['search-result'] },
-  { icon: { name: 'minecraft' }, ids: ['mcfunction'] },
-  { icon: { name: 'rescript' }, ids: ['rescript'] },
-  { icon: { name: 'otne' }, ids: ['otne'] },
-  {
-    icon: { name: 'twine' },
-    ids: ['twee3', 'twee3-harlowe-3', 'twee3-chapbook-1', 'twee3-sugarcube-2'],
-  },
-  { icon: { name: 'grain' }, ids: ['grain'] },
-  { icon: { name: 'lolcode' }, ids: ['lolcode'] },
-  { icon: { name: 'idris' }, ids: ['idris'] },
-  { icon: { name: 'chess' }, ids: ['pgn'] },
-  { icon: { name: 'gemini' }, ids: ['gemini', 'text-gemini'] },
-  { icon: { name: 'vlang' }, ids: ['v'] },
-  { icon: { name: 'wolframlanguage' }, ids: ['wolfram'] },
-  { icon: { name: 'shader' }, ids: ['hlsl', 'glsl', 'wgsl'] },
-  { icon: { name: 'tree' }, ids: ['tree'] },
-  { icon: { name: 'svelte' }, ids: ['svelte'] },
-  { icon: { name: 'dart' }, ids: ['dart'] },
-  { icon: { name: 'cadence' }, ids: ['cadence'] },
-  { icon: { name: 'stylable' }, ids: ['stylable'] },
-];

package/src/models/i18n/index.ts

@@ -1 +0,0 @@
-export * from './translation';

package/src/models/i18n/translation.ts

@@ -1,43 +0,0 @@
-export interface Translation {
-  activate: string;
-  activated: string;
-  iconPacks: {
-    selectPack: string;
-    description: string;
-    disabled: string;
-  };
-  folders: {
-    toggleIcons: string;
-    disabled: string;
-    theme: {
-      description: string;
-    };
-  };
-  colorSelect: {
-    color: string;
-    hexCode: string;
-    wrongHexCode: string;
-  };
-  opacity: {
-    inputPlaceholder: string;
-    wrongValue: string;
-  };
-  toggleSwitch: {
-    on: string;
-    off: string;
-  };
-  explorerArrows: {
-    toggle: string;
-    enable: string;
-    disable: string;
-  };
-  grayscale: {
-    toggle: string;
-    enable: string;
-    disable: string;
-  };
-  saturation: {
-    inputPlaceholder: string;
-    wrongValue: string;
-  };
-}