linguist-js 2.7.0 → 2.8.0

package/dist/cli.js

@@ -8,6 +8,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const commander_1 = require("commander");
 const index_1 = __importDefault(require("./index"));
+const norm_path_1 = require("./helpers/norm-path");
 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
@@ -23,11 +24,13 @@ commander_1.program
     .option('-F|--listFiles [bool]', 'Whether to list every matching file under the language results', false)
     .option('-q|--quick [bool]', 'Skip complex language analysis (alias for -{A|I|H|S}=false)', false)
     .option('-o|--offline [bool]', 'Use packaged data files instead of fetching latest from GitHub', false)
+    .option('-L|--calculateLines [bool]', 'Calculate lines of code totals', true)
     .option('-V|--keepVendored [bool]', 'Prevent skipping over vendored/generated files', false)
     .option('-B|--keepBinary [bool]', 'Prevent skipping over binary files', false)
     .option('-r|--relativePaths [bool]', 'Convert absolute file paths to relative', false)
     .option('-A|--checkAttributes [bool]', 'Force the checking of gitattributes files', true)
     .option('-I|--checkIgnored [bool]', 'Force the checking of gitignore files', true)
+    .option('-D|--checkDetected [bool]', 'Force files marked with linguist-detectable to always appear in output', 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)
@@ -78,21 +81,22 @@ if (args.analyze)
                 }
             }
             // List parsed results
-            for (const [lang, { bytes, color }] of sortedEntries) {
+            for (const [lang, { bytes, lines, color }] of sortedEntries) {
                 const percent = (bytes) => bytes / (totalBytes || 1) * 100;
                 const fmtd = {
                     index: (++count).toString().padStart(2, ' '),
                     lang: lang.padEnd(24, ' '),
                     percent: percent(bytes).toFixed(2).padStart(5, ' '),
                     bytes: bytes.toLocaleString().padStart(10, ' '),
+                    loc: lines.code.toLocaleString().padStart(10, ' '),
                     icon: colouredMsg(hexToRgb(color !== null && color !== void 0 ? color : '#ededed'), '\u2588'),
                 };
-                console.log(`  ${fmtd.index}. ${fmtd.icon} ${fmtd.lang} ${fmtd.percent}% ${fmtd.bytes} B`);
+                console.log(`  ${fmtd.index}. ${fmtd.icon} ${fmtd.lang} ${fmtd.percent}% ${fmtd.bytes} B ${fmtd.loc} LOC`);
                 // If using `listFiles` option, list all files tagged as this language
                 if (args.listFiles) {
                     console.log(); // padding
                     for (const file of filesPerLanguage[lang]) {
-                        let relFile = path_1.default.relative(path_1.default.resolve('.'), file).replace(/\\/g, '/');
+                        let relFile = (0, norm_path_1.normPath)(path_1.default.relative(path_1.default.resolve('.'), file));
                         if (!relFile.startsWith('../'))
                             relFile = './' + relFile;
                         const bytes = (await fs_1.default.promises.stat(file)).size;

package/dist/helpers/norm-path.d.ts

@@ -0,0 +1,2 @@
+export declare const normPath: (...inputPaths: string[]) => string;
+export declare const normAbsPath: (...inputPaths: string[]) => string;

package/dist/helpers/norm-path.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normAbsPath = exports.normPath = void 0;
+const path_1 = __importDefault(require("path"));
+const normPath = function normalisedPath(...inputPaths) {
+    return path_1.default.join(...inputPaths).replace(/\\/g, '/');
+};
+exports.normPath = normPath;
+const normAbsPath = function normalisedAbsolutePath(...inputPaths) {
+    return path_1.default.resolve(...inputPaths).replace(/\\/g, '/');
+};
+exports.normAbsPath = normAbsPath;

package/dist/helpers/parse-gitattributes.d.ts

@@ -3,6 +3,7 @@ export type FlagAttributes = {
     'vendored': boolean | null;
     'generated': boolean | null;
     'documentation': boolean | null;
+    'detectable': boolean | null;
     'binary': boolean | null;
     'language': T.LanguageResult;
 };

package/dist/helpers/parse-gitattributes.js

@@ -1,9 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
+const norm_path_1 = require("./norm-path");
 /**
  * Parses a gitattributes file.
  */
@@ -16,7 +13,7 @@ function parseAttributes(content, folderRoot = '.') {
             continue;
         const parts = line.split(/\s+/g);
         const fileGlob = parts[0];
-        const relFileGlob = path_1.default.join(folderRoot, fileGlob).replace(/\\/g, '/');
+        const relFileGlob = (0, norm_path_1.normPath)(folderRoot, fileGlob);
         const attrParts = parts.slice(1);
         const isTrue = (str) => !str.startsWith('-') && !str.endsWith('=false');
         const isFalse = (str) => str.startsWith('-') || str.endsWith('=false');
@@ -24,10 +21,12 @@ function parseAttributes(content, folderRoot = '.') {
         const falseParts = (str) => attrParts.filter(part => part.includes(str) && isFalse(part));
         const hasTrueParts = (str) => trueParts(str).length > 0;
         const hasFalseParts = (str) => falseParts(str).length > 0;
+        const boolOrNullVal = (str) => hasTrueParts(str) ? true : hasFalseParts(str) ? false : null;
         const attrs = {
-            'generated': hasTrueParts('linguist-generated') ? true : hasFalseParts('linguist-generated') ? false : null,
-            'vendored': hasTrueParts('linguist-vendored') ? true : hasFalseParts('linguist-vendored') ? false : null,
-            'documentation': hasTrueParts('linguist-documentation') ? true : hasFalseParts('linguist-documentation') ? false : null,
+            'generated': boolOrNullVal('linguist-generated'),
+            'vendored': boolOrNullVal('linguist-vendored'),
+            'documentation': boolOrNullVal('linguist-documentation'),
+            'detectable': boolOrNullVal('linguist-detectable'),
             'binary': hasTrueParts('binary') || hasFalseParts('text') ? true : hasFalseParts('binary') || hasTrueParts('text') ? false : null,
             'language': (_b = (_a = trueParts('linguist-language').at(-1)) === null || _a === void 0 ? void 0 : _a.split('=')[1]) !== null && _b !== void 0 ? _b : null,
         };

package/dist/helpers/parse-gitignore.d.ts

@@ -0,0 +1 @@
+export default function parseGitignore(content: string): string[];

package/dist/helpers/parse-gitignore.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function parseGitignore(content) {
+    const readableData = content
+        // Remove comments unless escaped
+        .replace(/(?<!\\)#.+/g, '')
+        // Remove whitespace unless escaped
+        .replace(/(?:(?<!\\)\s)+$/g, '');
+    const arrayData = readableData.split(/\r?\n/).filter(data => data);
+    return arrayData;
+}
+exports.default = parseGitignore;

package/dist/helpers/read-file.d.ts

@@ -2,4 +2,4 @@
  * Read part of a file on disc.
  * @throws 'EPERM' if the file is not readable.
  */
-export default function readFile(filename: string, onlyFirstLine?: boolean): Promise<string>;
+export default function readFileChunk(filename: string, onlyFirstLine?: boolean): Promise<string>;

package/dist/helpers/read-file.js

@@ -8,7 +8,7 @@ const fs_1 = __importDefault(require("fs"));
  * Read part of a file on disc.
  * @throws 'EPERM' if the file is not readable.
  */
-async function readFile(filename, onlyFirstLine = false) {
+async function readFileChunk(filename, onlyFirstLine = false) {
     const chunkSize = 100;
     const stream = fs_1.default.createReadStream(filename, { highWaterMark: chunkSize });
     let content = '';
@@ -20,4 +20,4 @@ async function readFile(filename, onlyFirstLine = false) {
     }
     return content;
 }
-exports.default = readFile;
+exports.default = readFileChunk;

package/dist/helpers/walk-tree.js

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const parse_gitignore_1 = __importDefault(require("./parse-gitignore"));
+const norm_path_1 = require("./norm-path");
 let allFiles;
 let allFolders;
 ;
@@ -24,26 +26,38 @@ function walk(data) {
         // 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(commonRoot, '.');
+            const base = (0, norm_path_1.normAbsPath)(folder, file).replace(commonRoot, '.');
             // Add trailing slash to mark directories
             const isDir = fs_1.default.lstatSync(path_1.default.resolve(commonRoot, base)).isDirectory();
             return isDir ? `${base}/` : base;
         });
+        // Read and apply gitignores
+        const gitignoreFilename = (0, norm_path_1.normPath)(folder, '.gitignore');
+        if (fs_1.default.existsSync(gitignoreFilename)) {
+            const gitignoreContents = fs_1.default.readFileSync(gitignoreFilename, 'utf-8');
+            const ignoredPaths = (0, parse_gitignore_1.default)(gitignoreContents);
+            ignored.add(ignoredPaths);
+        }
+        // Add gitattributes if present
+        const gitattributesPath = (0, norm_path_1.normPath)(folder, '.gitattributes');
+        if (fs_1.default.existsSync(gitattributesPath)) {
+            allFiles.add(gitattributesPath);
+        }
         // Loop through files and folders
         for (const file of files) {
             // Create absolute path for disc operations
-            const path = path_1.default.resolve(commonRoot, file).replace(/\\/g, '/');
+            const path = (0, norm_path_1.normAbsPath)(commonRoot, file);
             const localPath = localRoot ? file.replace(`./${localRoot}/`, '') : file.replace('./', '');
             // Skip if nonexistant
             const nonExistant = !fs_1.default.existsSync(path);
             if (nonExistant)
                 continue;
-            // Skip if marked as ignored
+            // Skip if marked in gitignore
             const isIgnored = ignored.test(localPath).ignored;
             if (isIgnored)
                 continue;
             // Add absolute folder path to list
-            allFolders.add(path_1.default.resolve(folder).replace(/\\/g, '/'));
+            allFolders.add((0, norm_path_1.normAbsPath)(folder));
             // Check if this is a folder or file
             if (file.endsWith('/')) {
                 // Recurse into subfolders

package/dist/index.js

@@ -37,15 +37,18 @@ const load_data_1 = __importStar(require("./helpers/load-data"));
 const read_file_1 = __importDefault(require("./helpers/read-file"));
 const parse_gitattributes_1 = __importDefault(require("./helpers/parse-gitattributes"));
 const convert_pcre_1 = __importDefault(require("./helpers/convert-pcre"));
+const norm_path_1 = require("./helpers/norm-path");
 async function analyse(rawPaths, opts = {}) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
-    var _r, _s;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+    var _u, _v;
     const useRawContent = opts.fileContent !== undefined;
     const input = [rawPaths !== null && rawPaths !== void 0 ? rawPaths : []].flat();
     const manualFileContent = [(_a = opts.fileContent) !== null && _a !== void 0 ? _a : []].flat();
     // Normalise input option arguments
     opts = {
+        calculateLines: (_b = opts.calculateLines) !== null && _b !== void 0 ? _b : true,
         checkIgnored: !opts.quick,
+        checkDetected: !opts.quick,
         checkAttributes: !opts.quick,
         checkHeuristics: !opts.quick,
         checkShebang: !opts.quick,
@@ -64,17 +67,15 @@ async function analyse(rawPaths, opts = {}) {
     const extensions = {};
     const globOverrides = {};
     const results = {
-        files: { count: 0, bytes: 0, results: {}, alternatives: {} },
-        languages: { count: 0, bytes: 0, results: {} },
-        unknown: { count: 0, bytes: 0, extensions: {}, filenames: {} },
+        files: { count: 0, bytes: 0, lines: { total: 0, content: 0, code: 0 }, results: {}, alternatives: {} },
+        languages: { count: 0, bytes: 0, lines: { total: 0, content: 0, code: 0 }, results: {} },
+        unknown: { count: 0, bytes: 0, lines: { total: 0, content: 0, code: 0 }, extensions: {}, filenames: {} },
     };
     // Set a common root path so that vendor paths do not incorrectly match parent folders
-    const normPath = (file) => file.replace(/\\/g, '/');
-    const resolvedInput = input.map(path => normPath(path_1.default.resolve(path)));
+    const resolvedInput = input.map(path => (0, norm_path_1.normPath)(path_1.default.resolve(path)));
     const commonRoot = (input.length > 1 ? (0, common_path_prefix_1.default)(resolvedInput) : resolvedInput[0]).replace(/\/?$/, '');
-    const localRoot = (folder) => folder.replace(commonRoot, '').replace(/^\//, '');
-    const relPath = (file) => useRawContent ? file : normPath(path_1.default.relative(commonRoot, file));
-    const unRelPath = (file) => useRawContent ? file : normPath(path_1.default.resolve(commonRoot, file));
+    const relPath = (file) => useRawContent ? file : (0, norm_path_1.normPath)(path_1.default.relative(commonRoot, file));
+    const unRelPath = (file) => useRawContent ? file : (0, norm_path_1.normPath)(path_1.default.resolve(commonRoot, file));
     // Other helper functions
     const fileMatchesGlobs = (file, ...globs) => (0, ignore_1.default)().add(globs).ignores(relPath(file));
     const filterOutIgnored = (files, ignored) => ignored.filter(files.map(relPath)).map(unRelPath);
@@ -82,47 +83,40 @@ async function analyse(rawPaths, opts = {}) {
     // Prepare list of ignored files
     const ignored = (0, ignore_1.default)();
     ignored.add('.git/');
-    ignored.add((_b = opts.ignoredFiles) !== null && _b !== void 0 ? _b : []);
-    const regexIgnores = [];
-    if (!opts.keepVendored)
-        regexIgnores.push(...vendorPaths.map(path => RegExp(path, 'i')));
+    ignored.add((_c = opts.ignoredFiles) !== null && _c !== void 0 ? _c : []);
+    const regexIgnores = opts.keepVendored ? [] : vendorPaths.map(path => RegExp(path, 'i'));
     // Load file paths and folders
     let files;
-    let folders;
     if (useRawContent) {
         // Uses raw file content
         files = input;
-        folders = [''];
     }
     else {
         // Uses directory on disc
         const data = (0, walk_tree_1.default)({ init: true, commonRoot, folderRoots: resolvedInput, folders: resolvedInput, ignored });
         files = data.files;
-        folders = data.folders;
-    }
-    // Load gitignore data and apply ignores rules
-    if (!useRawContent && opts.checkIgnored) {
-        const nestedIgnoreFiles = files.filter(file => file.endsWith('.gitignore'));
-        for (const ignoresFile of nestedIgnoreFiles) {
-            const relIgnoresFile = relPath(ignoresFile);
-            const relIgnoresFolder = path_1.default.dirname(relIgnoresFile);
-            // Parse gitignores
-            const ignoresDataRaw = await (0, read_file_1.default)(ignoresFile);
-            const ignoresData = ignoresDataRaw.replace(/#.+|\s+$/gm, '');
-            const absoluteIgnoresData = ignoresData
-                // '.file' -> 'root/*/.file'
-                .replace(/^(?=[^\s\/\\])/gm, localRoot(relIgnoresFolder) + '/*/')
-                // '/folder' -> 'root/folder'
-                .replace(/^[\/\\]/gm, localRoot(relIgnoresFolder) + '/');
-            ignored.add(absoluteIgnoresData);
-            files = filterOutIgnored(files, ignored);
-        }
     }
     // Fetch and normalise gitattributes data of all subfolders and save to metadata
     const manualAttributes = {}; // Maps file globs to gitattribute boolean flags
     const getFlaggedGlobs = (attr, val) => {
         return Object.entries(manualAttributes).filter(([, attrs]) => attrs[attr] === val).map(([glob,]) => glob);
     };
+    const findAttrsForPath = (filePath) => {
+        const resultAttrs = {};
+        for (const glob in manualAttributes) {
+            if ((0, ignore_1.default)().add(glob).ignores(relPath(filePath))) {
+                const matchingAttrs = manualAttributes[glob];
+                for (const [attr, val] of Object.entries(matchingAttrs)) {
+                    if (val !== null)
+                        resultAttrs[attr] = val;
+                }
+            }
+        }
+        if (!JSON.stringify(resultAttrs)) {
+            return null;
+        }
+        return resultAttrs;
+    };
     if (!useRawContent && opts.checkAttributes) {
         const nestedAttrFiles = files.filter(file => file.endsWith('.gitattributes'));
         for (const attrFile of nestedAttrFiles) {
@@ -135,6 +129,25 @@ async function analyse(rawPaths, opts = {}) {
             }
         }
     }
+    // Remove files that are linguist-ignored via regex by default unless explicitly unignored in gitattributes
+    const filesToIgnore = [];
+    for (const file of files) {
+        const relFile = relPath(file);
+        const isRegexIgnored = regexIgnores.some(pattern => pattern.test(relFile));
+        if (!isRegexIgnored) {
+            // Checking overrides is moot if file is not even marked as ignored by default
+            continue;
+        }
+        const fileAttrs = findAttrsForPath(file);
+        if ((fileAttrs === null || fileAttrs === void 0 ? void 0 : fileAttrs.generated) === false || (fileAttrs === null || fileAttrs === void 0 ? void 0 : fileAttrs.vendored) === false) {
+            // File is explicitly marked as *not* to be ignored
+            // do nothing
+        }
+        else {
+            filesToIgnore.push(file);
+        }
+    }
+    files = files.filter(file => !filesToIgnore.includes(file));
     // Apply vendor file path matches and filter out vendored files
     if (!opts.keepVendored) {
         // Get data of files that have been manually marked with metadata
@@ -165,7 +178,7 @@ async function analyse(rawPaths, opts = {}) {
         files.push(...unignoredList);
     }
     // Ignore specific languages
-    for (const lang of (_c = opts.ignoredLanguages) !== null && _c !== void 0 ? _c : []) {
+    for (const lang of (_d = opts.ignoredLanguages) !== null && _d !== void 0 ? _d : []) {
         for (const key in langData) {
             if (lang.toLowerCase() === key.toLowerCase()) {
                 delete langData[key];
@@ -218,7 +231,7 @@ async function analyse(rawPaths, opts = {}) {
         // Check first line for readability
         let firstLine;
         if (useRawContent) {
-            firstLine = (_e = (_d = manualFileContent[files.indexOf(file)]) === null || _d === void 0 ? void 0 : _d.split('\n')[0]) !== null && _e !== void 0 ? _e : null;
+            firstLine = (_f = (_e = manualFileContent[files.indexOf(file)]) === null || _e === void 0 ? void 0 : _e.split('\n')[0]) !== null && _f !== void 0 ? _f : null;
         }
         else if (fs_1.default.existsSync(file) && !fs_1.default.lstatSync(file).isDirectory()) {
             firstLine = await (0, read_file_1.default)(file, true).catch(() => null);
@@ -237,7 +250,7 @@ async function analyse(rawPaths, opts = {}) {
                 const langMatcher = (lang) => `\\b${lang.toLowerCase().replace(/\W/g, '\\$&')}(?![\\w#+*]|-\*-)`;
                 // Check for interpreter match
                 if (opts.checkShebang && hasShebang) {
-                    const matchesInterpretor = (_f = data.interpreters) === null || _f === void 0 ? void 0 : _f.some(interpreter => firstLine.match(`\\b${interpreter}\\b`));
+                    const matchesInterpretor = (_g = data.interpreters) === null || _g === void 0 ? void 0 : _g.some(interpreter => firstLine.match(`\\b${interpreter}\\b`));
                     if (matchesInterpretor)
                         matches.push(lang);
                 }
@@ -245,7 +258,7 @@ async function analyse(rawPaths, opts = {}) {
                 if (opts.checkModeline && hasModeline) {
                     const modelineText = firstLine.toLowerCase().replace(/^.*-\*-(.+)-\*-.*$/, '$1');
                     const matchesLang = modelineText.match(langMatcher(lang));
-                    const matchesAlias = (_g = data.aliases) === null || _g === void 0 ? void 0 : _g.some(lang => modelineText.match(langMatcher(lang)));
+                    const matchesAlias = (_h = data.aliases) === null || _h === void 0 ? void 0 : _h.some(lang => modelineText.match(langMatcher(lang)));
                     if (matchesLang || matchesAlias)
                         matches.push(lang);
                 }
@@ -264,7 +277,7 @@ async function analyse(rawPaths, opts = {}) {
         let skipExts = false;
         // Check if filename is a match
         for (const lang in langData) {
-            const matchesName = (_h = langData[lang].filenames) === null || _h === void 0 ? void 0 : _h.some(name => path_1.default.basename(file.toLowerCase()) === name.toLowerCase());
+            const matchesName = (_j = langData[lang].filenames) === null || _j === void 0 ? void 0 : _j.some(name => path_1.default.basename(file.toLowerCase()) === name.toLowerCase());
             if (matchesName) {
                 addResult(file, lang);
                 skipExts = true;
@@ -274,7 +287,7 @@ async function analyse(rawPaths, opts = {}) {
         const possibleExts = [];
         if (!skipExts)
             for (const lang in langData) {
-                const extMatches = (_j = langData[lang].extensions) === null || _j === void 0 ? void 0 : _j.filter(ext => file.toLowerCase().endsWith(ext.toLowerCase()));
+                const extMatches = (_k = langData[lang].extensions) === null || _k === void 0 ? void 0 : _k.filter(ext => file.toLowerCase().endsWith(ext.toLowerCase()));
                 if (extMatches === null || extMatches === void 0 ? void 0 : extMatches.length) {
                     for (const ext of extMatches)
                         possibleExts.push({ ext, lang });
@@ -320,7 +333,7 @@ async function analyse(rawPaths, opts = {}) {
                         heuristic.language = heuristic.language[0];
                     }
                     // Make sure the results includes this language
-                    const languageGroup = (_k = langData[heuristic.language]) === null || _k === void 0 ? void 0 : _k.group;
+                    const languageGroup = (_l = langData[heuristic.language]) === null || _l === void 0 ? void 0 : _l.group;
                     const matchesLang = fileAssociations[file].includes(heuristic.language);
                     const matchesParent = languageGroup && fileAssociations[file].includes(languageGroup);
                     if (!matchesLang && !matchesParent)
@@ -365,17 +378,23 @@ async function analyse(rawPaths, opts = {}) {
         }
     }
     // 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)) {
-            if (!hiddenCategories.some(cat => { var _a; return lang && ((_a = langData[lang]) === null || _a === void 0 ? void 0 : _a.type) === cat; })) {
+            // Skip if language is not hidden
+            if (!hiddenCategories.some(cat => { var _a; return lang && ((_a = langData[lang]) === null || _a === void 0 ? void 0 : _a.type) === cat; }))
                 continue;
+            // Skip if language is forced as detectable
+            if (opts.checkDetected) {
+                const detectable = (0, ignore_1.default)().add(getFlaggedGlobs('detectable', true));
+                if (detectable.ignores(relPath(file)))
+                    continue;
             }
+            // Delete result otherwise
             delete results.files.results[file];
-            if (lang) {
+            if (lang)
                 delete results.languages.results[lang];
-            }
         }
         for (const category of hiddenCategories) {
             for (const [lang, { type }] of Object.entries(results.languages.results)) {
@@ -389,7 +408,7 @@ async function analyse(rawPaths, opts = {}) {
     if (!useRawContent && opts.relativePaths) {
         const newMap = {};
         for (const [file, lang] of Object.entries(results.files.results)) {
-            let relPath = path_1.default.relative(process.cwd(), file).replace(/\\/g, '/');
+            let relPath = (0, norm_path_1.normPath)(path_1.default.relative(process.cwd(), file));
             if (!relPath.startsWith('../')) {
                 relPath = './' + relPath;
             }
@@ -401,26 +420,59 @@ async function analyse(rawPaths, opts = {}) {
     for (const [file, lang] of Object.entries(results.files.results)) {
         if (lang && !langData[lang])
             continue;
-        const fileSize = (_o = (_m = manualFileContent[files.indexOf(file)]) === null || _m === void 0 ? void 0 : _m.length) !== null && _o !== void 0 ? _o : fs_1.default.statSync(file).size;
+        // Calculate file size
+        const fileSize = (_p = (_o = manualFileContent[files.indexOf(file)]) === null || _o === void 0 ? void 0 : _o.length) !== null && _p !== void 0 ? _p : fs_1.default.statSync(file).size;
+        // Calculate lines of code
+        const loc = { total: 0, content: 0, code: 0 };
+        if (opts.calculateLines) {
+            const fileContent = (_r = ((_q = manualFileContent[files.indexOf(file)]) !== null && _q !== void 0 ? _q : fs_1.default.readFileSync(file).toString())) !== null && _r !== void 0 ? _r : '';
+            const allLines = fileContent.split(/\r?\n/gm);
+            loc.total = allLines.length;
+            loc.content = allLines.filter(line => line.trim().length > 0).length;
+            const codeLines = fileContent
+                .replace(/^\s*(\/\/|# |;|--).+/gm, '')
+                .replace(/\/\*.+\*\/|<!--.+-->/sg, '');
+            loc.code = codeLines.split(/\r?\n/gm).filter(line => line.trim().length > 0).length;
+        }
+        // Apply to files totals
         results.files.bytes += fileSize;
-        // If no language found, add extension in other section
-        if (!lang) {
+        results.files.lines.total += loc.total;
+        results.files.lines.content += loc.content;
+        results.files.lines.code += loc.code;
+        // Add results to 'languages' section if language match found, or 'unknown' section otherwise
+        if (lang) {
+            const { type } = langData[lang];
+            // set default if unset
+            (_s = (_u = results.languages.results)[lang]) !== null && _s !== void 0 ? _s : (_u[lang] = { type, bytes: 0, lines: { total: 0, content: 0, code: 0 }, color: langData[lang].color });
+            // apply results to 'languages' section
+            if (opts.childLanguages) {
+                results.languages.results[lang].parent = langData[lang].group;
+            }
+            results.languages.results[lang].bytes += fileSize;
+            results.languages.bytes += fileSize;
+            results.languages.results[lang].lines.total += loc.total;
+            results.languages.results[lang].lines.content += loc.content;
+            results.languages.results[lang].lines.code += loc.code;
+            results.languages.lines.total += loc.total;
+            results.languages.lines.content += loc.content;
+            results.languages.lines.code += loc.code;
+        }
+        else {
             const ext = path_1.default.extname(file);
-            const unknownType = ext === '' ? 'filenames' : 'extensions';
-            const name = ext === '' ? path_1.default.basename(file) : ext;
-            (_p = (_r = results.unknown[unknownType])[name]) !== null && _p !== void 0 ? _p : (_r[name] = 0);
+            const unknownType = ext ? 'extensions' : 'filenames';
+            const name = ext || path_1.default.basename(file);
+            // apply results to 'unknown' section
+            (_t = (_v = results.unknown[unknownType])[name]) !== null && _t !== void 0 ? _t : (_v[name] = 0);
             results.unknown[unknownType][name] += fileSize;
             results.unknown.bytes += fileSize;
-            continue;
+            results.unknown.lines.total += loc.total;
+            results.unknown.lines.content += loc.content;
+            results.unknown.lines.code += loc.code;
         }
-        // Add language and bytes data to corresponding section
-        const { type } = langData[lang];
-        (_q = (_s = results.languages.results)[lang]) !== null && _q !== void 0 ? _q : (_s[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;
-        results.languages.bytes += fileSize;
+    }
+    // Set lines output to NaN when line calculation is disabled
+    if (opts.calculateLines === false) {
+        results.files.lines = { total: NaN, content: NaN, code: NaN };
     }
     // Set counts
     results.files.count = Object.keys(results.files.results).length;

package/dist/types.d.ts

@@ -19,7 +19,9 @@ export interface Options {
     childLanguages?: boolean;
     quick?: boolean;
     offline?: boolean;
+    calculateLines?: boolean;
     checkIgnored?: boolean;
+    checkDetected?: boolean;
     checkAttributes?: boolean;
     checkHeuristics?: boolean;
     checkShebang?: boolean;
@@ -29,6 +31,11 @@ export interface Results {
     files: {
         count: Integer;
         bytes: Bytes;
+        lines: {
+            total: Integer;
+            content: Integer;
+            code: Integer;
+        };
         /** Note: Results use slashes as delimiters even on Windows. */
         results: Record<FilePath, LanguageResult>;
         alternatives: Record<FilePath, LanguageResult[]>;
@@ -36,8 +43,18 @@ export interface Results {
     languages: {
         count: Integer;
         bytes: Bytes;
+        lines: {
+            total: Integer;
+            content: Integer;
+            code: Integer;
+        };
         results: Record<Language, {
             bytes: Bytes;
+            lines: {
+                total: Integer;
+                content: Integer;
+                code: Integer;
+            };
             type: Category;
             parent?: Language;
             color?: `#${string}`;
@@ -46,6 +63,11 @@ export interface Results {
     unknown: {
         count: Integer;
         bytes: Bytes;
+        lines: {
+            total: Integer;
+            content: Integer;
+            code: Integer;
+        };
         extensions: Record<string, Bytes>;
         filenames: Record<string, Bytes>;
     };

package/ext/generated.rb

@@ -8,18 +8,24 @@
 - (Gopkg|glide)\.lock
 - poetry\.lock
 - pdm\.lock
+- uv\.lock
 - (^|\/)(\w+\.)?esy.lock$
+- deno\.lock
 - npm-shrinkwrap\.json
 - package-lock\.json
+- pnpm-lock\.yaml
 - (^|\/)\.pnp\..*$
 - Godeps\/
 - composer\.lock
 - .\.zep\.(?:c|h|php)$
 - Cargo\.lock
+- Cargo\.toml\.orig
 - (^|\/)flake\.lock$
+- (^|\/)MODULE\.bazel\.lock$
 - Pipfile\.lock
 - (?:^|\/)\.terraform\.lock\.hcl$
 - ppport\.h$
 - __generated__\/
 - _tlb\.pas$
 - (?:^|\/)htmlcov\/
+- (?:^|.*\/)\.sqlx\/query-.+\.json$