linguist-js 2.3.1 → 2.4.1

package/dist/cli.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const VERSION = require('../package.json').version;
 const commander_1 = require("commander");
 const index_1 = __importDefault(require("./index"));
-const walk_tree_1 = __importDefault(require("./helpers/walk-tree"));
 const colouredMsg = ([r, g, b], msg) => `\u001B[${38};2;${r};${g};${b}m${msg}${'\u001b[0m'}`;
 const hexToRgb = (hex) => [parseInt(hex.slice(1, 3), 16), parseInt(hex.slice(3, 5), 16), parseInt(hex.slice(5, 7), 16)];
 commander_1.program
@@ -27,6 +26,7 @@ commander_1.program
     .option('-I|--checkIgnored [bool]', 'Force the checking of gitignore files', true)
     .option('-H|--checkHeuristics [bool]', 'Apply heuristics to ambiguous languages', true)
     .option('-S|--checkShebang [bool]', 'Check shebang lines for explicit classification', true)
+    .option('-M|--checkModeline [bool]', 'Check modelines for explicit classification', true)
     .helpOption(`-h|--help`, 'Display this help message')
     .version(VERSION, '-v|--version', 'Display the installed version of linguist-js');
 commander_1.program.parse(process.argv);
@@ -53,13 +53,11 @@ if (args.analyze)
         const root = args.analyze === true ? '.' : args.analyze;
         const data = await (0, index_1.default)(root, args);
         const { files, languages, unknown } = data;
-        // Get file count
-        const totalFiles = (0, walk_tree_1.default)(root).files.length;
         // Print output
         if (!args.json) {
             const sortedEntries = Object.entries(languages.results).sort((a, b) => a[1].bytes < b[1].bytes ? +1 : -1);
             const totalBytes = languages.bytes;
-            console.log(`\n Analysed ${files.bytes.toLocaleString()} B from ${totalFiles} files (${totalFiles - files.count} ignored) with linguist-js`);
+            console.log(`\n Analysed ${files.bytes.toLocaleString()} B from ${files.count} files with linguist-js`);
             console.log(`\n Language analysis results:`);
             let count = 0;
             if (sortedEntries.length === 0)

package/dist/helpers/walk-tree.js

@@ -8,28 +8,51 @@ const path_1 = __importDefault(require("path"));
 const allFiles = new Set();
 const allFolders = new Set();
 /** Generate list of files in a directory. */
-function walk(folder, ignored = []) {
-    if (Array.isArray(folder)) {
-        for (const path of folder)
-            walk(path, ignored);
-    }
-    else {
-        const files = fs_1.default.readdirSync(folder);
+function walk(root, folders, gitignores, regexIgnores) {
+    // Walk tree of a folder
+    if (folders.length === 1) {
+        const folder = folders[0];
+        // Get list of files and folders inside this folder
+        const files = fs_1.default.readdirSync(folder).map(file => {
+            // Create path relative to root
+            const base = path_1.default.resolve(folder, file).replace(/\\/g, '/').replace(root, '.');
+            // Add trailing slash to mark directories
+            const isDir = fs_1.default.lstatSync(path_1.default.resolve(root, base)).isDirectory();
+            return isDir ? `${base}/` : base;
+        });
+        // Loop through files and folders
         for (const file of files) {
-            const path = path_1.default.resolve(folder, file).replace(/\\/g, '/');
-            if (!fs_1.default.existsSync(path) || ignored.some(pattern => pattern.test(path)))
+            // Create absolute path for disc operations
+            const path = path_1.default.resolve(root, file).replace(/\\/g, '/');
+            // Skip if nonexistant or ignored
+            const nonExistant = !fs_1.default.existsSync(path);
+            const isGitIgnored = gitignores.test(file.replace('./', '')).ignored;
+            const isRegexIgnored = regexIgnores.find(match => file.replace('./', '').match(match));
+            if (nonExistant || isGitIgnored || isRegexIgnored)
                 continue;
-            allFolders.add(folder.replace(/\\/g, '/'));
-            if (fs_1.default.lstatSync(path).isDirectory()) {
+            // Add absolute folder path to list
+            allFolders.add(path_1.default.resolve(folder).replace(/\\/g, '/'));
+            // Check if this is a folder or file
+            if (file.endsWith('/')) {
+                // Recurse into subfolders
                 allFolders.add(path);
-                walk(path, ignored);
-                continue;
+                walk(root, [path], gitignores, regexIgnores);
+            }
+            else {
+                // Add relative file path to list
+                allFiles.add(path);
             }
-            allFiles.add(path);
         }
     }
+    // Recurse into all folders
+    else {
+        for (const path of folders) {
+            walk(root, [path], gitignores, regexIgnores);
+        }
+    }
+    // Return absolute files and folders lists
     return {
-        files: [...allFiles],
+        files: [...allFiles].map(file => file.replace(/^\./, root)),
         folders: [...allFolders],
     };
 }

package/dist/index.js

@@ -5,24 +5,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
-const glob_to_regexp_1 = __importDefault(require("glob-to-regexp"));
+const ignore_1 = __importDefault(require("ignore"));
+const common_path_prefix_1 = __importDefault(require("common-path-prefix"));
 const binary_extensions_1 = __importDefault(require("binary-extensions"));
 const isbinaryfile_1 = require("isbinaryfile");
 const walk_tree_1 = __importDefault(require("./helpers/walk-tree"));
 const load_data_1 = __importDefault(require("./helpers/load-data"));
 const read_file_1 = __importDefault(require("./helpers/read-file"));
 const convert_pcre_1 = __importDefault(require("./helpers/convert-pcre"));
-const convert_glob_1 = __importDefault(require("./helpers/convert-glob"));
 async function analyse(input, opts = {}) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
-    var _s, _t, _u;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+    var _t, _u, _v;
     const useRawContent = opts.fileContent !== undefined;
+    input = [input !== null && input !== void 0 ? input : []].flat();
+    opts.fileContent = [(_a = opts.fileContent) !== null && _a !== void 0 ? _a : []].flat();
+    // Load data from github-linguist web repo
     const langData = await (0, load_data_1.default)('languages.yml').then(js_yaml_1.default.load);
     const vendorData = await (0, load_data_1.default)('vendor.yml').then(js_yaml_1.default.load);
+    const docData = await (0, load_data_1.default)('documentation.yml').then(js_yaml_1.default.load);
     const heuristicsData = await (0, load_data_1.default)('heuristics.yml').then(js_yaml_1.default.load);
-    const generatedData = await (0, load_data_1.default)('generated.rb').then(text => { var _a; return (_a = text.match(/(?<=name\.match\(\/).+?(?=(?<!\\)\/\))/gm)) !== null && _a !== void 0 ? _a : []; });
-    vendorData.push(...generatedData);
+    const generatedData = await (0, load_data_1.default)('generated.rb').then(text => { var _a; return (_a = text.match(/(?<=name\.match\(\/).+?(?=(?<!\\)\/)/gm)) !== null && _a !== void 0 ? _a : []; });
+    const vendorPaths = [...vendorData, ...docData, ...generatedData];
+    // Setup main variables
     const fileAssociations = {};
+    const definiteness = {};
     const extensions = {};
     const overrides = {};
     const results = {
@@ -30,25 +36,43 @@ async function analyse(input, opts = {}) {
         languages: { count: 0, bytes: 0, results: {} },
         unknown: { count: 0, bytes: 0, extensions: {}, filenames: {} },
     };
-    const ignoredFiles = [
-        /\/\.git\//,
-        opts.keepVendored ? [] : vendorData.map(path => RegExp(path)),
-        (_b = (_a = opts.ignoredFiles) === null || _a === void 0 ? void 0 : _a.map(path => (0, glob_to_regexp_1.default)('*' + path + '*', { extended: true }))) !== null && _b !== void 0 ? _b : [],
-    ].flat();
+    // Prepare list of ignored files
+    const gitignores = (0, ignore_1.default)();
+    const regexIgnores = [];
+    gitignores.add('/.git');
+    if (!opts.keepVendored)
+        regexIgnores.push(...vendorPaths.map(path => RegExp(path, 'i')));
+    if (opts.ignoredFiles)
+        gitignores.add(opts.ignoredFiles);
+    // Set a common root path so that vendor paths do not incorrectly match parent folders
+    const resolvedInput = input.map(path => path_1.default.resolve(path).replace(/\\/g, '/'));
+    const commonRoot = (input.length > 1 ? (0, common_path_prefix_1.default)(resolvedInput) : resolvedInput[0]).replace(/\/?$/, '');
+    const relPath = (file) => path_1.default.relative(commonRoot, file).replace(/\\/g, '/');
+    const unRelPath = (file) => path_1.default.resolve(commonRoot, file).replace(/\\/g, '/');
+    // Load file paths and folders
     let files, folders;
-    if (opts.fileContent) {
-        opts.fileContent = Array.isArray(opts.fileContent) ? opts.fileContent : [opts.fileContent];
-        files = [`${input}`];
+    if (useRawContent) {
+        // Uses raw file content
+        files = input;
         folders = [''];
     }
     else {
-        const data = (0, walk_tree_1.default)(input !== null && input !== void 0 ? input : '.', ignoredFiles);
-        ({ files, folders } = data);
+        // Uses directory on disc
+        const data = (0, walk_tree_1.default)(commonRoot, input, gitignores, regexIgnores);
+        files = data.files;
+        folders = data.folders;
     }
     // Apply aliases
-    opts = { checkIgnored: !opts.quick, checkAttributes: !opts.quick, checkHeuristics: !opts.quick, checkShebang: !opts.quick, ...opts };
+    opts = {
+        checkIgnored: !opts.quick,
+        checkAttributes: !opts.quick,
+        checkHeuristics: !opts.quick,
+        checkShebang: !opts.quick,
+        checkModeline: !opts.quick,
+        ...opts
+    };
     // Ignore specific languages
-    for (const lang of (_c = opts.ignoredLanguages) !== null && _c !== void 0 ? _c : []) {
+    for (const lang of (_b = opts.ignoredLanguages) !== null && _b !== void 0 ? _b : []) {
         for (const key in langData) {
             if (lang.toLowerCase() === key.toLowerCase()) {
                 delete langData[key];
@@ -56,40 +80,36 @@ async function analyse(input, opts = {}) {
             }
         }
     }
-    // Load gitattributes
-    const customIgnored = [];
-    const customBinary = [];
-    const customText = [];
-    if (!useRawContent && !opts.quick) {
+    // Load gitignores and gitattributes
+    const customBinary = (0, ignore_1.default)();
+    const customText = (0, ignore_1.default)();
+    if (!useRawContent && opts.checkAttributes) {
         for (const folder of folders) {
             // Skip if folder is marked in gitattributes
-            if (customIgnored.some(path => (0, convert_glob_1.default)(path).test(folder)))
+            if (relPath(folder) && gitignores.test(relPath(folder)).ignored)
                 continue;
             // Parse gitignores
             const ignoresFile = path_1.default.join(folder, '.gitignore');
             if (opts.checkIgnored && fs_1.default.existsSync(ignoresFile)) {
                 const ignoresData = await (0, read_file_1.default)(ignoresFile);
-                const ignoresList = ignoresData.split(/\r?\n/).filter(line => line.trim() && !line.startsWith('#'));
-                const ignoredPaths = ignoresList.map(path => (0, convert_glob_1.default)(path).source);
-                customIgnored.push(...ignoredPaths);
+                gitignores.add(ignoresData);
             }
             // Parse gitattributes
             const attributesFile = path_1.default.join(folder, '.gitattributes');
             if (opts.checkAttributes && fs_1.default.existsSync(attributesFile)) {
                 const attributesData = await (0, read_file_1.default)(attributesFile);
-                const relPathToRegex = (path) => (0, convert_glob_1.default)(path).source.substr(1).replace(folder, '');
                 // Explicit text/binary associations
                 const contentTypeMatches = attributesData.matchAll(/^(\S+).*?(-?binary|-?text)(?!=auto)/gm);
                 for (const [_line, path, type] of contentTypeMatches) {
                     if (['text', '-binary'].includes(type))
-                        customText.push(relPathToRegex(path));
+                        customText.add(path);
                     if (['-text', 'binary'].includes(type))
-                        customBinary.push(relPathToRegex(path));
+                        customBinary.add(path);
                 }
                 // Custom vendor options
                 const vendorMatches = attributesData.matchAll(/^(\S+).*[^-]linguist-(vendored|generated|documentation)(?!=false)/gm);
                 for (const [_line, path] of vendorMatches) {
-                    customIgnored.push(relPathToRegex(path));
+                    gitignores.add(path);
                 }
                 // Custom file associations
                 const customLangMatches = attributesData.matchAll(/^(\S+).*[^-]linguist-language=(\S+)/gm);
@@ -100,17 +120,22 @@ async function analyse(input, opts = {}) {
                         if (overrideLang)
                             forcedLang = overrideLang[0];
                     }
-                    const fullPath = folder + (0, convert_glob_1.default)(path).source.substr(1);
+                    const fullPath = relPath(folder) + '/' + path;
                     overrides[fullPath] = forcedLang;
                 }
             }
         }
     }
     // Check vendored files
-    if (!useRawContent && !opts.keepVendored) {
+    if (!opts.keepVendored) {
         // Filter out any files that match a vendor file path
-        const matcher = (match) => RegExp(match.replace(/\/$/, '/.+$').replace(/^\.\//, ''));
-        files = files.filter(file => !customIgnored.some(pattern => matcher(pattern).test(file)));
+        if (useRawContent) {
+            files = gitignores.filter(files);
+            files = files.filter(file => !regexIgnores.find(match => match.test(file)));
+        }
+        else {
+            files = gitignores.filter(files.map(relPath)).map(unRelPath);
+        }
     }
     // Load all files and parse languages
     const addResult = (file, result) => {
@@ -126,8 +151,8 @@ async function analyse(input, opts = {}) {
     // List all languages that could be associated with a given file
     for (const file of files) {
         let firstLine;
-        if (opts.fileContent) {
-            firstLine = (_f = (_e = (_d = opts.fileContent) === null || _d === void 0 ? void 0 : _d[files.indexOf(file)]) === null || _e === void 0 ? void 0 : _e.split('\n')[0]) !== null && _f !== void 0 ? _f : null;
+        if (useRawContent) {
+            firstLine = (_e = (_d = (_c = opts.fileContent) === null || _c === void 0 ? void 0 : _c[files.indexOf(file)]) === null || _d === void 0 ? void 0 : _d.split('\n')[0]) !== null && _e !== void 0 ? _e : null;
         }
         else {
             if (!fs_1.default.existsSync(file) || fs_1.default.lstatSync(file).isDirectory())
@@ -137,22 +162,40 @@ async function analyse(input, opts = {}) {
         // Skip if file is unreadable
         if (firstLine === null)
             continue;
-        // Check shebang line for explicit classification
-        if (!opts.quick && opts.checkShebang && firstLine.startsWith('#!')) {
-            // Find matching interpreters
-            const matches = Object.entries(langData).filter(([, data]) => { var _a; return (_a = data.interpreters) === null || _a === void 0 ? void 0 : _a.some(interpreter => firstLine.match('\\b' + interpreter + '\\b')); });
+        // Check first line for explicit classification
+        const hasShebang = opts.checkShebang && /^#!/.test(firstLine);
+        const hasModeline = opts.checkModeline && /-\*-|(syntax|filetype|ft)\s*=/.test(firstLine);
+        if (!opts.quick && (hasShebang || hasModeline)) {
+            const matches = [];
+            for (const [lang, data] of Object.entries(langData)) {
+                const langMatcher = (lang) => `\\b${lang.toLowerCase().replace(/\W/g, '\\$&')}(?![\\w#+*]|-\*-)`;
+                // Check for interpreter match
+                const matchesInterpretor = (_f = data.interpreters) === null || _f === void 0 ? void 0 : _f.some(interpreter => firstLine.match(`\\b${interpreter}\\b`));
+                // Check modeline declaration
+                const matchesLang = firstLine.toLowerCase().match(langMatcher(lang));
+                const matchesAlias = (_g = data.aliases) === null || _g === void 0 ? void 0 : _g.some(lang => firstLine.toLowerCase().match(langMatcher(lang)));
+                // Add language
+                if (opts.checkShebang && matchesInterpretor)
+                    matches.push(lang);
+                if (opts.checkModeline && (matchesLang || matchesAlias))
+                    matches.push(lang);
+            }
             if (matches.length) {
                 // Add explicitly-identified language
-                const forcedLang = matches[0][0];
+                const forcedLang = matches[0];
                 addResult(file, forcedLang);
+                definiteness[file] = true;
+                continue;
             }
         }
         // Check override for manual language classification
         if (!useRawContent && !opts.quick && opts.checkAttributes) {
-            const match = overridesArray.find(item => RegExp(item[0]).test(file));
+            const isOverridden = (path) => (0, ignore_1.default)().add(path).test(relPath(file)).ignored;
+            const match = overridesArray.find(item => isOverridden(item[0]));
             if (match) {
                 const forcedLang = match[1];
                 addResult(file, forcedLang);
+                definiteness[file] = true;
                 continue;
             }
         }
@@ -160,7 +203,7 @@ async function analyse(input, opts = {}) {
         let skipExts = false;
         for (const lang in langData) {
             // Check if filename is a match
-            const matchesName = (_g = langData[lang].filenames) === null || _g === void 0 ? void 0 : _g.some(name => path_1.default.basename(file.toLowerCase()) === name.toLowerCase());
+            const matchesName = (_h = langData[lang].filenames) === null || _h === void 0 ? void 0 : _h.some(name => path_1.default.basename(file.toLowerCase()) === name.toLowerCase());
             if (matchesName) {
                 addResult(file, lang);
                 skipExts = true;
@@ -169,7 +212,7 @@ async function analyse(input, opts = {}) {
         if (!skipExts)
             for (const lang in langData) {
                 // Check if extension is a match
-                const matchesExt = (_h = langData[lang].extensions) === null || _h === void 0 ? void 0 : _h.some(ext => file.toLowerCase().endsWith(ext.toLowerCase()));
+                const matchesExt = (_j = langData[lang].extensions) === null || _j === void 0 ? void 0 : _j.some(ext => file.toLowerCase().endsWith(ext.toLowerCase()));
                 if (matchesExt)
                     addResult(file, lang);
             }
@@ -179,10 +222,15 @@ async function analyse(input, opts = {}) {
     }
     // Narrow down file associations to the best fit
     for (const file in fileAssociations) {
+        // Skip if file has explicit association
+        if (definiteness[file]) {
+            results.files.results[file] = fileAssociations[file][0];
+            continue;
+        }
         // Skip binary files
         if (!useRawContent && !opts.keepBinary) {
-            const isCustomText = customText.some(path => RegExp(path).test(file));
-            const isCustomBinary = customBinary.some(path => RegExp(path).test(file));
+            const isCustomText = customText.test(relPath(file)).ignored;
+            const isCustomBinary = customBinary.test(relPath(file)).ignored;
             const isBinaryExt = binary_extensions_1.default.some(ext => file.endsWith('.' + ext));
             if (!isCustomText && (isCustomBinary || isBinaryExt || await (0, isbinaryfile_1.isBinaryFile)(file))) {
                 continue;
@@ -202,14 +250,14 @@ async function analyse(input, opts = {}) {
                         heuristic.language = heuristic.language[0];
                     }
                     // Make sure the results includes this language
-                    const languageGroup = (_j = langData[heuristic.language]) === null || _j === void 0 ? void 0 : _j.group;
+                    const languageGroup = (_k = langData[heuristic.language]) === null || _k === void 0 ? void 0 : _k.group;
                     const matchesLang = fileAssociations[file].includes(heuristic.language);
                     const matchesParent = languageGroup && fileAssociations[file].includes(languageGroup);
                     if (!matchesLang && !matchesParent)
                         continue;
                     // Normalise heuristic data
                     const patterns = [];
-                    const normalise = (contents) => patterns.push(...(Array.isArray(contents) ? contents : [contents]));
+                    const normalise = (contents) => patterns.push(...[contents].flat());
                     if (heuristic.pattern)
                         normalise(heuristic.pattern);
                     if (heuristic.named_pattern)
@@ -225,10 +273,10 @@ async function analyse(input, opts = {}) {
                 }
             }
         // If no heuristics, assign a language
-        (_k = (_s = results.files.results)[file]) !== null && _k !== void 0 ? _k : (_s[file] = fileAssociations[file][0]);
+        (_l = (_t = results.files.results)[file]) !== null && _l !== void 0 ? _l : (_t[file] = fileAssociations[file][0]);
     }
     // Skip specified categories
-    if ((_l = opts.categories) === null || _l === void 0 ? void 0 : _l.length) {
+    if ((_m = opts.categories) === null || _m === void 0 ? void 0 : _m.length) {
         const categories = ['data', 'markup', 'programming', 'prose'];
         const hiddenCategories = categories.filter(cat => !opts.categories.includes(cat));
         for (const [file, lang] of Object.entries(results.files.results)) {
@@ -260,21 +308,21 @@ async function analyse(input, opts = {}) {
     for (const [file, lang] of Object.entries(results.files.results)) {
         if (lang && !langData[lang])
             continue;
-        const fileSize = (_p = (_o = (_m = opts.fileContent) === null || _m === void 0 ? void 0 : _m[files.indexOf(file)]) === null || _o === void 0 ? void 0 : _o.length) !== null && _p !== void 0 ? _p : fs_1.default.statSync(file).size;
+        const fileSize = (_q = (_p = (_o = opts.fileContent) === null || _o === void 0 ? void 0 : _o[files.indexOf(file)]) === null || _p === void 0 ? void 0 : _p.length) !== null && _q !== void 0 ? _q : fs_1.default.statSync(file).size;
         results.files.bytes += fileSize;
         // If no language found, add extension in other section
         if (!lang) {
             const ext = path_1.default.extname(file);
             const unknownType = ext === '' ? 'filenames' : 'extensions';
             const name = ext === '' ? path_1.default.basename(file) : ext;
-            (_q = (_t = results.unknown[unknownType])[name]) !== null && _q !== void 0 ? _q : (_t[name] = 0);
+            (_r = (_u = results.unknown[unknownType])[name]) !== null && _r !== void 0 ? _r : (_u[name] = 0);
             results.unknown[unknownType][name] += fileSize;
             results.unknown.bytes += fileSize;
             continue;
         }
         // Add language and bytes data to corresponding section
         const { type } = langData[lang];
-        (_r = (_u = results.languages.results)[lang]) !== null && _r !== void 0 ? _r : (_u[lang] = { type, bytes: 0, color: langData[lang].color });
+        (_s = (_v = results.languages.results)[lang]) !== null && _s !== void 0 ? _s : (_v[lang] = { type, bytes: 0, color: langData[lang].color });
         if (opts.childLanguages)
             results.languages.results[lang].parent = langData[lang].group;
         results.languages.results[lang].bytes += fileSize;

package/dist/types.d.ts

@@ -18,6 +18,7 @@ export interface Options {
     checkAttributes?: boolean;
     checkHeuristics?: boolean;
     checkShebang?: boolean;
+    checkModeline?: boolean;
 }
 export interface Results {
     files: {

package/license.md

@@ -1,6 +1,6 @@
 # ISC License
 
-Copyright © 2021 Nixinova
+Copyright © Nixinova 2021–2022
 
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "linguist-js",
-	"version": "2.3.1",
+	"version": "2.4.1",
 	"description": "Analyse languages used in a folder. Powered by GitHub Linguist, although it doesn't need to be installed.",
 	"main": "dist/index.js",
 	"bin": {
@@ -38,8 +38,9 @@
 	"dependencies": {
 		"binary-extensions": "^2.2.0",
 		"commander": "^9.0.0",
+		"common-path-prefix": "^3.0.0",
 		"cross-fetch": "^3.1.5",
-		"glob-to-regexp": "~0.4.1",
+		"ignore": "^5.2.0",
 		"isbinaryfile": "^4.0.8",
 		"js-yaml": "^4.1.0",
 		"node-cache": "^5.1.2"

package/readme.md

@@ -97,7 +97,6 @@ const { files, languages, unknown } = linguist(folder, options);
   Analyse the language of all files found in a folder.
   - `entry` (optional; string or string array):
     The folder(s) to analyse (defaults to `./`).
-    Analyse multiple folders using the syntax `"{folder1,folder2,...}"`.
   - `opts` (optional; object):
     An object containing analyser options.
     - `fileContent` (string or string array):
@@ -113,21 +112,26 @@ const { files, languages, unknown } = linguist(folder, options);
       Whether to display sub-languages instead of their parents when possible (defaults to `false`).
     - `quick` (boolean):
       Whether to skip complex language analysis such as the checking of heuristics and gitattributes statements (defaults to `false`).
-      Alias for `checkAttributes:false, checkIgnored:false, checkHeuristics:false, checkShebang:false`.
+      Alias for `checkAttributes:false, checkIgnored:false, checkHeuristics:false, checkShebang:false, checkModeline:false`.
     - `keepVendored` (boolean):
       Whether to keep vendored files (dependencies, etc) (defaults to `false`).
+      Does nothing when `fileContent` is set.
     - `keepBinary` (boolean):
       Whether binary files should be included in the output (defaults to `false`).
     - `relativePaths` (boolean):
       Change the absolute file paths in the output to be relative to the current working directory (defaults to `false`).
     - `checkAttributes` (boolean):
       Force the checking of `.gitattributes` files (defaults to `true` unless `quick` is set).
+      Does nothing when `fileContent` is set.
     - `checkIgnored` (boolean):
       Force the checking of `.gitignore` files (defaults to `true` unless `quick` is set).
+      Does nothing when `fileContent` is set.
     - `checkHeuristics` (boolean):
       Apply heuristics to ambiguous languages (defaults to `true` unless `quick` is set).
     - `checkShebang` (boolean):
       Check shebang (`#!`) lines for explicit language classification (defaults to `true` unless `quick` is set).
+    - `checkModeline` (boolean):
+      Check modelines for explicit language classification (defaults to `true` unless `quick` is set).
 
 ### Command-line
 
@@ -155,7 +159,7 @@ linguist --help
     Requires `--json` to be specified.
   - `--quick`:
     Whether to skip the checking of `.gitattributes` and `.gitignore` files for manual language classifications.
-    Alias for `--checkAttributes=false --checkIgnored=false --checkHeuristics=false --checkShebang=false`.
+    Alias for `--checkAttributes=false --checkIgnored=false --checkHeuristics=false --checkShebang=false --checkModeline=false`.
   - `--keepVendored`:
     Whether to include vendored files (auto-generated files, dependencies folder, etc).
   - `--keepBinary`:
@@ -170,6 +174,8 @@ linguist --help
     Apply heuristics to ambiguous languages (use alongside `--quick` to overwrite).
   - `--checkShebang`:
     Check shebang (`#!`) lines for explicit classification (use alongside `--quick` to overwrite).
+  - `--checkModeline`:
+    Check modelines for explicit classification (use alongside `--quick` to overwrite).
 - `--help`:
   Display a help message.
 - `--version`:

package/dist/helpers/convert-glob.js

@@ -1,11 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const glob_to_regexp_1 = __importDefault(require("glob-to-regexp"));
-function parseGitGlob(path) {
-    const globPath = `**/${path}`.replace(/\\/g, '/').replace(/\[:(space|digit):\]/g, (_, val) => `\\${val[0]}`);
-    return (0, glob_to_regexp_1.default)(globPath, { globstar: true, extended: true });
-}
-exports.default = parseGitGlob;