@cspell/filetypes 8.14.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jason Dent
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# `@cspell/filetypes`
+
+A library to help determine the type of a file.
+
+## Install
+
+```sh
+npm install -S @cspell/filetypes
+```
+
+## Usage
+
+```ts
+import { findMatchingFileTypes } from '@cspell/filetypes';
+
+console.log(findMatchingFileTypes('code.js')); // outputs: [ 'javascript' ]
+```

package/dist/definitions.d.ts

@@ -0,0 +1,3 @@
+import type { FileTypeDefinitions } from './types.js';
+export declare const definitions: FileTypeDefinitions;
+//# sourceMappingURL=definitions.d.ts.map

package/dist/definitions.js

@@ -0,0 +1,373 @@
+export const definitions = [
+    { id: 'ada', extensions: ['.adb', '.ads'] },
+    { id: 'apiblueprint', extensions: ['.apib', '.apiblueprint'] },
+    { id: 'argdown', extensions: ['.ad', '.adown', '.argdn', '.argdown'] },
+    { id: 'asciidoc', extensions: ['.adoc', '.asc', '.asciidoc'] },
+    { id: 'bat', extensions: ['.bat', '.cmd'] },
+    { id: 'bazel', extensions: ['.bazel', '.bzl'] },
+    { id: 'bibtex', extensions: ['.bib'] },
+    { id: 'bicep', extensions: ['.bicep'] },
+    { id: 'c', extensions: ['.c', '.i'] },
+    { id: 'cache_files', extensions: [], filenames: ['.DS_Store', '.cspellcache', '.eslintcache'] },
+    { id: 'clojure', extensions: ['.clj', '.cljc', '.cljs', '.cljx', '.clojure', '.edn'] },
+    { id: 'cmake', extensions: ['.cmake'], filenames: ['CMakeLists.txt'] },
+    { id: 'coffeescript', extensions: ['.coffee', '.cson', '.iced'] },
+    {
+        id: 'cpp',
+        extensions: [
+            '.c++',
+            '.c++m',
+            '.cc',
+            '.ccm',
+            '.cpp',
+            '.cppm',
+            '.cxx',
+            '.cxxm',
+            '.h',
+            '.h++',
+            '.h.in',
+            '.hh',
+            '.hpp',
+            '.hpp.in',
+            '.hxx',
+            '.ii',
+            '.inl',
+            '.ino',
+            '.ipp',
+            '.ixx',
+            '.mm',
+            '.tpp',
+            '.txx',
+        ],
+    },
+    { id: 'cpp_embedded_latex', extensions: [] },
+    { id: 'csharp', extensions: ['.cake', '.cs', '.csx'] },
+    { id: 'css', extensions: ['.css'] },
+    { id: 'cuda-cpp', extensions: ['.cu', '.cuh'] },
+    { id: 'dart', extensions: ['.dart'] },
+    { id: 'dhall', extensions: ['.dhall'] },
+    { id: 'diff', extensions: ['.diff', '.patch', '.rej'] },
+    { id: 'dockercompose', extensions: [], filenames: ['*docker*compose*.yaml', '*docker*compose*.yml', 'compose.*.yaml', 'compose.*.yml', 'compose.yaml', 'compose.yml'] },
+    {
+        id: 'dockerfile',
+        extensions: ['.containerfile', '.dockerfile'],
+        filenames: ['*.Dockerfile.*', 'Containerfile', 'Containerfile.*', 'Dockerfile', 'Dockerfile.*', 'Dockerfile.dev', 'dockerfile'],
+    },
+    { id: 'elisp', extensions: ['.el'] },
+    { id: 'elixir', extensions: ['.ex', '.exs'] },
+    { id: 'elm', extensions: ['.elm'] },
+    { id: 'erb', extensions: ['.erb', '.html.erb', '.rhtml'] },
+    { id: 'fsharp', extensions: ['.fs', '.fsi', '.fsscript', '.fsx'] },
+    { id: 'git-commit', extensions: [], filenames: ['COMMIT_EDITMSG', 'MERGE_MSG'] },
+    { id: 'git-rebase', extensions: [], filenames: ['git-rebase-todo'] },
+    { id: 'github-issues', extensions: ['.github-issues'] },
+    { id: 'go', extensions: ['.go'] },
+    { id: 'godot', extensions: ['.gd', '.godot', '.tres', '.tscn'] },
+    { id: 'gradle', extensions: ['.gradle'] },
+    { id: 'groovy', extensions: ['.gradle', '.groovy', '.gvy', '.jenkinsfile', '.nf'], filenames: ['Jenkinsfile', 'Jenkinsfile*'] },
+    { id: 'haml', extensions: ['.haml'] },
+    { id: 'handlebars', extensions: ['.handlebars', '.hbs', '.hjs'] },
+    { id: 'haskell', extensions: ['.hs', '.lhs'] },
+    { id: 'haxe', extensions: ['.hx'] },
+    { id: 'hlsl', extensions: ['.cginc', '.compute', '.fx', '.fxh', '.hlsl', '.hlsli', '.psh', '.vsh'] },
+    { id: 'html', extensions: ['.asp', '.aspx', '.ejs', '.htm', '.html', '.jshtm', '.jsp', '.mdoc', '.rhtml', '.shtml', '.volt', '.vue', '.xht', '.xhtml'] },
+    { id: 'ignore', extensions: ['.git-blame-ignore-revs', '.gitignore', '.gitignore_global', '.npmignore'], filenames: ['.vscodeignore'] },
+    { id: 'ini', extensions: ['.conf', '.ini'] },
+    { id: 'jade', extensions: ['.jade', '.pug'] },
+    { id: 'java', extensions: ['.jav', '.java'] },
+    { id: 'javascript', extensions: ['.cjs', '.es6', '.js', '.mjs', '.pac'], filenames: ['jakefile'] },
+    { id: 'javascriptreact', extensions: ['.jsx'] },
+    { id: 'jinja', extensions: ['.jinja'] },
+    {
+        id: 'json',
+        extensions: [
+            '.babelrc',
+            '.bowerrc',
+            '.code-profile',
+            '.css.map',
+            '.eslintrc',
+            '.geojson',
+            '.har',
+            '.ipynb',
+            '.js.map',
+            '.jscsrc',
+            '.jshintrc',
+            '.jslintrc',
+            '.json',
+            '.jsonc',
+            '.jsonld',
+            '.ts.map',
+            '.tsbuildinfo',
+            '.vuerc',
+            '.webmanifest',
+        ],
+        filenames: ['.watchmanconfig', 'composer.lock'],
+    },
+    {
+        id: 'jsonc',
+        extensions: [
+            '.babelrc',
+            '.code-workspace',
+            '.color-theme.json',
+            '.eslintrc',
+            '.eslintrc.json',
+            '.hintrc',
+            '.icon-theme.json',
+            '.jsfmtrc',
+            '.jshintrc',
+            '.jsonc',
+            '.language-configuration.json',
+            '.swcrc',
+        ],
+        filenames: [
+            '.babelrc.json',
+            '.code-workspace',
+            '.devcontainer.json',
+            '.ember-cli',
+            'argv.json',
+            'babel.config.json',
+            'devcontainer.json',
+            'extensions.json',
+            'jsconfig-*.json',
+            'jsconfig.*.json',
+            'jsconfig.json',
+            'keybindings.json',
+            'launch.json',
+            'profiles.json',
+            'settings.json',
+            'tasks.json',
+            'tsconfig-*.json',
+            'tsconfig.*.json',
+            'tsconfig.json',
+            'typedoc.json',
+        ],
+    },
+    { id: 'jsonl', extensions: ['.jsonl'] },
+    { id: 'jsx-tags', extensions: [] },
+    { id: 'julia', extensions: ['.jl'] },
+    { id: 'juliamarkdown', extensions: ['.jmd'] },
+    { id: 'jungle', extensions: ['.jungle'] },
+    { id: 'kotlin', extensions: ['.kt'] },
+    { id: 'latex', extensions: ['.ctx', '.ltx', '.tex'] },
+    { id: 'less', extensions: ['.less'] },
+    { id: 'lisp', extensions: ['.fasl', '.l', '.lisp', '.lsp'] },
+    { id: 'literate haskell', extensions: ['.lhs'] },
+    { id: 'lock', extensions: ['.lock'], filenames: ['Cargo.lock', 'berksfile.lock', 'composer.lock', 'package-lock.json'] },
+    { id: 'log', extensions: ['.log'], filenames: ['*.log.?'] },
+    { id: 'lua', extensions: ['.lua'] },
+    { id: 'makefile', extensions: ['.mak', '.mk'], filenames: ['GNUmakefile', 'Makefile', 'OCamlMakefile', 'makefile'] },
+    { id: 'map', extensions: ['.map', '.css.map', '.ts.map', '.js.map'] },
+    { id: 'markdown', extensions: ['.markdn', '.markdown', '.md', '.mdown', '.mdtext', '.mdtxt', '.mdwn', '.mkd', '.workbook'] },
+    { id: 'markdown_latex_combined', extensions: [] },
+    { id: 'markdown-math', extensions: [] },
+    { id: 'mdx', extensions: ['.mdx'] },
+    { id: 'monkeyc', extensions: ['.mb', '.mc'] },
+    { id: 'mustache', extensions: ['.mst', '.mu', '.mustache', '.stache'] },
+    { id: 'nix', extensions: ['.nix'] },
+    { id: 'nunjucks', extensions: ['.nj', '.njk', '.nunj', '.nunjs', '.nunjucks', '.tmpl', '.tpl'] },
+    { id: 'objective-c', extensions: ['.m'] },
+    { id: 'objective-cpp', extensions: ['.mm'] },
+    { id: 'ocaml', extensions: ['.eliom', '.eliomi', '.ml', '.mli', '.mll', '.mly'] },
+    { id: 'pdf', extensions: ['.pdf'] },
+    { id: 'pem', extensions: ['.pem', '.private-key.pem'] },
+    { id: 'pem-private-key', extensions: ['.private-key.pem'] },
+    { id: 'perl', extensions: ['.PL', '.pl', '.pm', '.pod', '.psgi', '.t'] },
+    { id: 'perl6', extensions: ['.nqp', '.p6', '.pl6', '.pm6'] },
+    { id: 'php', extensions: ['.ctp', '.php', '.php4', '.php5', '.phtml'] },
+    { id: 'plaintext', extensions: ['.txt'] },
+    { id: 'powershell', extensions: ['.ps1', '.psd1', '.psm1', '.psrc', '.pssc'] },
+    {
+        id: 'properties',
+        extensions: ['.cfg', '.conf', '.directory', '.editorconfig', '.gitattributes', '.gitconfig', '.gitmodules', '.npmrc', '.properties', '.repo'],
+        filenames: ['.env', 'gitconfig'],
+    },
+    { id: 'puppet', extensions: ['.puppet'] },
+    { id: 'purescript', extensions: ['.purs'] },
+    { id: 'python', extensions: ['.cpy', '.gyp', '.gypi', '.ipy', '.py', '.pyi', '.pyt', '.pyw', '.rpy'], filenames: ['SConscript', 'SConstruct'] },
+    { id: 'r', extensions: ['.R', '.r', '.rhistory', '.rprofile', '.rt'] },
+    { id: 'raku', extensions: ['.nqp', '.p6', '.pl6', '.pm6', '.raku', '.rakudoc', '.rakumod', '.rakutest'] },
+    { id: 'razor', extensions: ['.cshtml', '.razor'] },
+    { id: 'rescript', extensions: ['.res', '.resi'] },
+    { id: 'restructuredtext', extensions: ['.rst'] },
+    { id: 'rsa', extensions: ['.pub'], filenames: ['id_rsa', 'id_rsa.pub'] },
+    {
+        id: 'ruby',
+        extensions: ['.erb', '.gemspec', '.podspec', '.rake', '.rb', '.rbi', '.rbx', '.rjs', '.ru'],
+        filenames: [
+            'Gemfile',
+            'appfile',
+            'appraisals',
+            'berksfile',
+            'berksfile.lock',
+            'brewfile',
+            'capfile',
+            'cheffile',
+            'dangerfile',
+            'deliverfile',
+            'fastfile',
+            'gemfile',
+            'guardfile',
+            'gymfile',
+            'hobofile',
+            'matchfile',
+            'podfile',
+            'puppetfile',
+            'rakefile',
+            'rantfile',
+            'scanfile',
+            'snapfile',
+            'thorfile',
+            'vagrantfile',
+        ],
+    },
+    { id: 'rust', extensions: ['.rs'] },
+    { id: 'sass', extensions: ['.sass'] },
+    { id: 'scala', extensions: ['.sbt', '.sc', '.scala'] },
+    { id: 'scss', extensions: ['.scss'] },
+    { id: 'search-result', extensions: ['.code-search'] },
+    { id: 'shaderlab', extensions: ['.cginc', '.shader'] },
+    {
+        id: 'shellscript',
+        extensions: [
+            '.Xsession',
+            '.bash',
+            '.bash_aliases',
+            '.bash_login',
+            '.bash_logout',
+            '.bash_profile',
+            '.bashrc',
+            '.csh',
+            '.cshrc',
+            '.ebuild',
+            '.eclass',
+            '.fish',
+            '.install',
+            '.ksh',
+            '.profile',
+            '.sh',
+            '.tcshrc',
+            '.xprofile',
+            '.xsession',
+            '.xsessionrc',
+            '.yash_profile',
+            '.yashrc',
+            '.zlogin',
+            '.zlogout',
+            '.zprofile',
+            '.zsh',
+            '.zsh-theme',
+            '.zshenv',
+            '.zshrc',
+        ],
+        filenames: ['.env.*', '.envrc', '.hushlogin', 'APKBUILD', 'PKGBUILD', 'bashrc_Apple_Terminal', 'zlogin', 'zlogout', 'zprofile', 'zshenv', 'zshrc', 'zshrc_Apple_Terminal'],
+    },
+    { id: 'snippets', extensions: ['.code-snippets'] },
+    { id: 'sql', extensions: ['.dsql', '.sql'] },
+    { id: 'stylus', extensions: ['.styl'] },
+    { id: 'svelte', extensions: ['.svelte'] },
+    { id: 'swift', extensions: ['.swift'] },
+    { id: 'terraform', extensions: ['.hcl', '.tf', '.tf.json', '.tfvars'] },
+    { id: 'tex', extensions: ['.bbx', '.cbx', '.cls', '.sty'] },
+    { id: 'tfvars', extensions: ['.tfvars'], description: 'Terraform Variables' },
+    { id: 'todo', extensions: [], filenames: ['todo'] },
+    { id: 'toml', extensions: ['.toml'], filenames: ['Cargo.lock', 'Cargo.toml'] },
+    { id: 'typescript', extensions: ['.cts', '.mts', '.ts'] },
+    { id: 'typescriptreact', extensions: ['.tsx'] },
+    { id: 'typst', extensions: ['.typst'] },
+    { id: 'vala', extensions: ['.vala'] },
+    { id: 'vb', extensions: ['.bas', '.brs', '.vb', '.vba', '.vbs'] },
+    { id: 'vue', extensions: ['.vue'] },
+    {
+        id: 'xml',
+        extensions: [
+            '.ascx',
+            '.atom',
+            '.axaml',
+            '.axml',
+            '.bpmn',
+            '.config',
+            '.cpt',
+            '.csl',
+            '.csproj',
+            '.csproj.user',
+            '.dita',
+            '.ditamap',
+            '.dtd',
+            '.dtml',
+            '.ent',
+            '.fsproj',
+            '.fxml',
+            '.iml',
+            '.isml',
+            '.jmx',
+            '.launch',
+            '.menu',
+            '.mod',
+            '.mxml',
+            '.nuspec',
+            '.opml',
+            '.owl',
+            '.proj',
+            '.props',
+            '.pt',
+            '.publishsettings',
+            '.pubxml',
+            '.pubxml.user',
+            '.rbxlx',
+            '.rbxmx',
+            '.rdf',
+            '.rng',
+            '.rss',
+            '.shproj',
+            '.storyboard',
+            '.svg',
+            '.targets',
+            '.tld',
+            '.tmx',
+            '.vbproj',
+            '.vbproj.user',
+            '.vcxproj',
+            '.vcxproj.filters',
+            '.wsdl',
+            '.wxi',
+            '.wxl',
+            '.wxs',
+            '.xaml',
+            '.xbl',
+            '.xib',
+            '.xlf',
+            '.xliff',
+            '.xml',
+            '.xoml',
+            '.xpdl',
+            '.xsd',
+            '.xul',
+        ],
+    },
+    { id: 'xsl', extensions: ['.xsl', '.xslt'] },
+    { id: 'yaml', extensions: ['.cff', '.eyaml', '.eyml', '.yaml', '.yaml-tmlanguage', '.yaml-tmpreferences', '.yaml-tmtheme', '.yml'] },
+    { id: 'binary', extensions: ['.bin', '.cur', '.dll', '.eot', '.exe', '.gz', '.lib', '.o', '.obj', '.phar', '.zip'], format: 'Binary' },
+    { id: 'dll', extensions: ['.dll'], format: 'Binary' },
+    { id: 'exe', extensions: ['.exe'], format: 'Binary' },
+    { id: 'fonts', extensions: ['.ttf', '.woff', '.woff2'], format: 'Binary' },
+    { id: 'gzip', extensions: ['.gz'], format: 'Binary' },
+    {
+        id: 'image',
+        extensions: ['.bmp', '.exr', '.gif', '.heic', '.ico', '.jpeg', '.jpg', '.pbm', '.pgm', '.png', '.ppm', '.ras', '.sgi', '.tiff', '.webp', '.xbm'],
+        format: 'Binary',
+        description: 'Some image extensions',
+    },
+    { id: 'jar', extensions: ['.jar'], format: 'Binary' },
+    { id: 'mdb', extensions: ['.mdb'], format: 'Binary', description: 'Microsoft Access DB' },
+    { id: 'object-file', extensions: ['.o', '.obj'], format: 'Binary' },
+    { id: 'spv', extensions: ['.spv'], format: 'Binary', description: 'SPSS Output Document' },
+    { id: 'trie', extensions: ['.trie'], format: 'Binary', description: 'CSpell dictionary file.' },
+    { id: 'video', extensions: ['.avi', '.flv', '.mkv', '.mov', '.mp4', '.mpeg', '.mpg', '.wmv'], format: 'Binary' },
+    { id: 'webm', extensions: ['.webm'], format: 'Binary', description: 'WebM is an audiovisual media file format.' },
+    { id: 'wheel', extensions: ['.whl'], format: 'Binary' },
+];
+// cspell:ignoreRegExp /id: '.*?'/g
+// cspell:ignoreRegExp /extensions: \[[^\]]*?\]/g
+// cspell:ignoreRegExp /filenames: \[[^\]]*?\]/g
+// cspell:ignore SPSS
+//# sourceMappingURL=definitions.js.map

package/dist/filetypes.d.ts

@@ -0,0 +1,60 @@
+import { FileTypeId } from './types.js';
+export declare const binaryLanguages: Set<string>;
+export declare const generatedFiles: Set<string>;
+export declare const languageIds: FileTypeId[];
+/**
+ * Checks to see if a file type is considered to be a binary file type.
+ * @param ext - the file extension to check
+ * @returns true if the file type is known to be binary.
+ */
+export declare function isBinaryExt(ext: string): boolean;
+/**
+ * Checks to see if a file type is considered to be a binary file type.
+ * @param filename - the filename to check
+ * @returns true if the file type is known to be binary.
+ */
+export declare function isBinaryFile(filename: string): boolean;
+/**
+ * Checks to see if a file type is considered to be a binary file type.
+ * @param fileTypeId - the file type id to check
+ * @returns true if the file type is known to be binary.
+ */
+export declare function isBinaryFileType(fileTypeId: FileTypeId | FileTypeId[] | Iterable<FileTypeId>): boolean;
+/**
+ * Check if a file extension is associated with generated file.. Generated files are files that are not typically edited by a human.
+ * Example:
+ * - package-lock.json
+ * @param ext - the file extension to check.
+ * @returns true if the file type known to be generated.
+ */
+export declare function isGeneratedExt(ext: string): boolean;
+/**
+ * Check if a file is auto generated. Generated files are files that are not typically edited by a human.
+ * Example:
+ * - package-lock.json
+ * @param filename - the full filename to check
+ * @returns true if the file type known to be generated.
+ */
+export declare function isGeneratedFile(filename: string): boolean;
+/**
+ * Check if a file type is auto generated. Generated files are files that are not typically edited by a human.
+ * Example:
+ * - package-lock.json
+ * @param fileTypeId - the file type id to check
+ * @returns true if the file type known to be generated.
+ */
+export declare function isFileTypeGenerated(fileTypeId: FileTypeId | FileTypeId[] | Iterable<FileTypeId>): boolean;
+/**
+ * Tries to find a matching language for a given file extension.
+ * @param ext - the file extension to look up.
+ * @returns an array of language ids that match the extension. The array is empty if no matches are found.
+ */
+export declare function getFileTypesForExt(ext: string): FileTypeId[];
+/**
+ * Find the matching file types for a given filename.
+ * @param filename - the full filename
+ * @returns an array of language ids that match the filename. The array is empty if no matches are found.
+ */
+export declare function findMatchingFileTypes(filename: string): FileTypeId[];
+export declare function autoResolve<K, V>(map: Map<K, V>, key: K, resolve: (k: K) => V): V;
+//# sourceMappingURL=filetypes.d.ts.map

package/dist/filetypes.js

@@ -0,0 +1,185 @@
+import { definitions } from './definitions.js';
+const binaryFormatIds = definitions.filter((d) => d.format === 'Binary').map((d) => d.id);
+export const binaryLanguages = new Set(['binary', 'image', 'video', 'fonts', ...binaryFormatIds]);
+export const generatedFiles = new Set([
+    ...binaryLanguages,
+    'map',
+    'lock',
+    'pdf',
+    'cache_files',
+    'rsa',
+    'pem',
+    'trie',
+    'log',
+]);
+export const languageIds = definitions.map(({ id }) => id);
+const mapExtensionToSetOfLanguageIds = buildLanguageExtensionMapSet(definitions);
+const mapExtensionToLanguageIds = buildExtensionToLanguageIdMap(mapExtensionToSetOfLanguageIds);
+const idsWithRegExp = definitions.map(defToRegExp).filter((f) => !!f);
+/**
+ * Checks to see if a file type is considered to be a binary file type.
+ * @param ext - the file extension to check
+ * @returns true if the file type is known to be binary.
+ */
+export function isBinaryExt(ext) {
+    return isBinaryFileType(getFileTypesForExt(ext));
+}
+/**
+ * Checks to see if a file type is considered to be a binary file type.
+ * @param filename - the filename to check
+ * @returns true if the file type is known to be binary.
+ */
+export function isBinaryFile(filename) {
+    filename = basename(filename);
+    return isBinaryFileType(findMatchingFileTypes(filename));
+}
+/**
+ * Checks to see if a file type is considered to be a binary file type.
+ * @param fileTypeId - the file type id to check
+ * @returns true if the file type is known to be binary.
+ */
+export function isBinaryFileType(fileTypeId) {
+    return doesSetContainAnyOf(binaryLanguages, fileTypeId);
+}
+/**
+ * Check if a file extension is associated with generated file.. Generated files are files that are not typically edited by a human.
+ * Example:
+ * - package-lock.json
+ * @param ext - the file extension to check.
+ * @returns true if the file type known to be generated.
+ */
+export function isGeneratedExt(ext) {
+    return isFileTypeGenerated(getFileTypesForExt(ext));
+}
+/**
+ * Check if a file is auto generated. Generated files are files that are not typically edited by a human.
+ * Example:
+ * - package-lock.json
+ * @param filename - the full filename to check
+ * @returns true if the file type known to be generated.
+ */
+export function isGeneratedFile(filename) {
+    return isFileTypeGenerated(findMatchingFileTypes(filename));
+}
+/**
+ * Check if a file type is auto generated. Generated files are files that are not typically edited by a human.
+ * Example:
+ * - package-lock.json
+ * @param fileTypeId - the file type id to check
+ * @returns true if the file type known to be generated.
+ */
+export function isFileTypeGenerated(fileTypeId) {
+    return doesSetContainAnyOf(generatedFiles, fileTypeId);
+}
+function doesSetContainAnyOf(setOfIds, fileTypeId) {
+    if (typeof fileTypeId === 'string') {
+        return setOfIds.has(fileTypeId);
+    }
+    for (const id of fileTypeId) {
+        if (setOfIds.has(id)) {
+            return true;
+        }
+    }
+    return false;
+}
+function buildLanguageExtensionMapSet(defs) {
+    return defs.reduce((map, def) => {
+        function addId(value) {
+            autoResolve(map, value, () => new Set()).add(def.id);
+        }
+        def.extensions.forEach(addId);
+        def.filenames?.forEach((filename) => (typeof filename === 'string' ? addId(filename) : undefined));
+        return map;
+    }, new Map());
+}
+function buildExtensionToLanguageIdMap(map) {
+    return new Map([...map].map(([k, s]) => [k, [...s]]));
+}
+function _getLanguagesForExt(ext) {
+    return mapExtensionToLanguageIds.get(ext) || mapExtensionToLanguageIds.get('.' + ext);
+}
+/**
+ * Tries to find a matching language for a given file extension.
+ * @param ext - the file extension to look up.
+ * @returns an array of language ids that match the extension. The array is empty if no matches are found.
+ */
+export function getFileTypesForExt(ext) {
+    return _getLanguagesForExt(ext) || _getLanguagesForExt(ext.toLowerCase()) || [];
+}
+function matchPatternsToFilename(basename) {
+    return idsWithRegExp.filter(({ regexp }) => regexp.test(basename)).map(({ id }) => id);
+}
+function _getLanguagesForBasename(basename) {
+    const found = mapExtensionToLanguageIds.get(basename);
+    if (found)
+        return found;
+    const patternMatches = matchPatternsToFilename(basename);
+    if (patternMatches.length)
+        return patternMatches;
+    for (let pos = basename.indexOf('.'); pos >= 0; pos = basename.indexOf('.', pos + 1)) {
+        const ids = mapExtensionToLanguageIds.get(basename.slice(pos));
+        if (ids)
+            return ids;
+    }
+    return undefined;
+}
+/**
+ * Find the matching file types for a given filename.
+ * @param filename - the full filename
+ * @returns an array of language ids that match the filename. The array is empty if no matches are found.
+ */
+export function findMatchingFileTypes(filename) {
+    filename = basename(filename);
+    return _getLanguagesForBasename(filename) || _getLanguagesForBasename(filename.toLowerCase()) || [];
+}
+const regExpPathSep = /[\\/]/g;
+function basename(filename) {
+    return regExpPathSep.test(filename) ? filename.split(regExpPathSep).slice(-1).join('') : filename;
+}
+export function autoResolve(map, key, resolve) {
+    const found = map.get(key);
+    if (found !== undefined || map.has(key))
+        return found;
+    const value = resolve(key);
+    map.set(key, value);
+    return value;
+}
+function escapeRegEx(s) {
+    return s.replaceAll(/[|\\{}()[\]^$+*?.]/g, '\\$&').replaceAll('-', '\\x2d');
+}
+function stringOrGlob(s) {
+    return s.includes('*') ? simpleGlob(s) : s;
+}
+function simpleGlob(s) {
+    s = s.replaceAll('**', '*');
+    let pattern = '';
+    for (const char of s) {
+        switch (char) {
+            case '?': {
+                pattern += '.';
+                break;
+            }
+            case '*': {
+                pattern += '.*';
+                break;
+            }
+            default: {
+                pattern += escapeRegEx(char);
+            }
+        }
+    }
+    return new RegExp(pattern);
+}
+function defToRegExp(def) {
+    if (!def.filenames)
+        return undefined;
+    const regExps = def.filenames
+        .map(stringOrGlob)
+        .map((f) => (f instanceof RegExp ? f : undefined))
+        .filter((f) => !!f);
+    if (!regExps.length)
+        return undefined;
+    const regexp = new RegExp(regExps.map((r) => r.source).join('|'));
+    return { regexp, id: def.id };
+}
+//# sourceMappingURL=filetypes.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { findMatchingFileTypes as findMatchingFileTypes, getFileTypesForExt, isBinaryExt, isBinaryFile, isBinaryFileType, isFileTypeGenerated, isGeneratedExt, isGeneratedFile, } from './filetypes.js';
+export type { FileTypeId } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,2 @@
+export { findMatchingFileTypes as findMatchingFileTypes, getFileTypesForExt, isBinaryExt, isBinaryFile, isBinaryFileType, isFileTypeGenerated, isGeneratedExt, isGeneratedFile, } from './filetypes.js';
+//# sourceMappingURL=index.js.map

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+export type FileTypeId = string;
+export interface FileTypeExtensionDefinition {
+    id: FileTypeId;
+    /** List of extensions starting with '.' */
+    extensions: string[];
+    /** Filenames that do not have an extension or have a different type than their implied extension */
+    filenames?: string[];
+    /** Indicates that it is a Text or Binary file type. */
+    format?: 'Text' | 'Binary';
+    /** Optional Description */
+    description?: string;
+    /** Optional Comment */
+    comment?: string;
+}
+export type FileTypeDefinition = FileTypeExtensionDefinition;
+export type FileTypeDefinitions = FileTypeDefinition[];
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@cspell/filetypes",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "8.14.1",
+  "description": "Library to determine file types based upon the file name.",
+  "keywords": [
+    "cspell",
+    "filetypes"
+  ],
+  "author": "Jason Dent <jason@streetsidesoftware.nl>",
+  "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-filetypes#readme",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "directories": {
+    "dist": "dist"
+  },
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "!**/*.tsbuildInfo",
+    "!**/__mocks__",
+    "!**/*.test.*",
+    "!**/*.spec.*",
+    "!**/*.map"
+  ],
+  "scripts": {
+    "build": "tsc -p .",
+    "watch": "tsc -p . -w",
+    "clean": "shx rm -rf dist temp coverage \"*.tsbuildInfo\"",
+    "clean-build": "pnpm run clean && pnpm run build",
+    "sort-filetypes": "pnpm build && node scripts/sortFileTypes.js && prettier --write src/definitions.ts",
+    "coverage": "vitest run --coverage",
+    "test-watch": "vitest",
+    "test": "vitest run"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/streetsidesoftware/cspell.git",
+    "directory": "packages/cspell-filetypes"
+  },
+  "bugs": {
+    "url": "https://github.com/streetsidesoftware/cspell/labels/filetype"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "gitHead": "5552bdba15adc8c073dd33791f30329147c5c64b"
+}