linguist-js 3.0.0-pre → 3.0.1

package/dist/analyser/pipeline/aggregate.d.ts

@@ -1,2 +1,4 @@
 import * as T from '../../types/types.js';
-export declare function aggregateResults(files: T.VirtualFile[], classifications: Record<string, string[]>, heuristicResolutions: Record<string, string | undefined>, langData: Record<string, unknown>, opts: T.Options): T.Results;
+export declare function aggregateResults(files: T.VirtualFile[], classifications: Record<string, string[]>, heuristicResolutions: Record<string, string | undefined>, langData: {
+    [language: string]: T.LanguageMetadata;
+}, opts: T.Options): T.Results;

package/dist/analyser/pipeline/aggregate.js

@@ -1,6 +1,7 @@
 import Path from 'node:path';
 const categoryKeys = ['data', 'markup', 'programming', 'prose'];
 function pickBestLanguage(classifications) {
+    // Assign first language as a default option
     return classifications[0] ?? null;
 }
 function makeRelPath(path) {
@@ -15,7 +16,7 @@ function normPath(filePath) {
 }
 export function aggregateResults(files, classifications, heuristicResolutions, langData, opts) {
     const results = {
-        files: { count: 0, bytes: 0, lines: { total: 0, content: 0 }, results: {}, alternatives: {} },
+        files: { count: 0, bytes: 0, lines: { total: 0, content: 0 }, results: {} },
         languages: { count: 0, bytes: 0, lines: { total: 0, content: 0 }, results: {} },
         unknown: { count: 0, bytes: 0, lines: { total: 0, content: 0 }, extensions: {}, filenames: {} },
         repository: {},
@@ -27,10 +28,12 @@ export function aggregateResults(files, classifications, heuristicResolutions, l
         // Narrow down file associations to the best fit
         const candidates = classifications[file.path] ?? [];
         // If no heuristics, assign a language
-        const selectedLanguage = heuristicResolutions[file.path] ?? pickBestLanguage(candidates);
-        const alternativeLanguages = [...new Set(candidates.filter((lang) => lang !== selectedLanguage))];
-        // Assign first language as a default option
-        // List alternative languages if there are any
+        const bestLanguage = heuristicResolutions[file.path] ?? pickBestLanguage(candidates);
+        const selectedLanguage = bestLanguage
+            ? opts.childLanguages
+                ? bestLanguage // use the child language
+                : (langData[bestLanguage]?.group ?? bestLanguage) // use the parent language, if it exists
+            : null;
         // Load language bytes size
         const size = file.size ?? file.content?.length ?? 0;
         // Calculate lines of code
@@ -72,9 +75,6 @@ export function aggregateResults(files, classifications, heuristicResolutions, l
             }
         }
         results.files.results[outputPath] = selectedLanguage;
-        if (alternativeLanguages.length) {
-            results.files.alternatives[outputPath] = alternativeLanguages;
-        }
         // Apply to files totals
         results.files.bytes += size;
         results.files.lines.total += Number.isNaN(loc.total) ? 0 : loc.total;

package/dist/analyser/pipeline/classify.js

@@ -18,11 +18,12 @@ export function classifyFiles(files, langData, opts) {
     const classifications = {};
     for (const file of files) {
         // Search each language
+        // Note: order here is important; the first match will be the one chosen
         const candidates = [
             ...byAttributes(file, langData),
+            ...byModeline(file, langData, opts),
             ...byFilename(file, langData),
             ...byShebang(file, langData, opts),
-            ...byModeline(file, langData, opts),
             ...byExtension(file, langData),
         ];
         classifications[file.path] = dedupeClassifications(candidates);

package/dist/program/data/loadDataFiles.js

@@ -1,3 +1,4 @@
+import YAML from 'js-yaml';
 import Cache from 'node-cache';
 import FS from 'node:fs';
 import Path from 'node:path';
@@ -14,8 +15,15 @@ async function loadWebFile(file) {
     // Load file content, falling back to the local file if the request fails
     const fileContent = await fetch(dataUrl(file))
         .then((data) => data.text())
-        .catch(async () => await loadLocalFile(file));
+        .catch(async (x) => void x);
+    if (!fileContent) {
+        return await loadLocalFile(file);
+    }
     cache.set(file, fileContent);
+    // Clean up lengthy files
+    if (file === 'generated.rb') {
+        return YAML.dump(parseGeneratedDataFile(fileContent));
+    }
     return fileContent;
 }
 async function loadLocalFile(file) {

package/dist/program/data/retrieveData.d.ts

@@ -1,10 +1,7 @@
-import { HeuristicsSchema, LanguagesScema, VendorSchema } from '../../types/schema.js';
+import { HeuristicsSchema, LanguagesScema } from '../../types/schema.js';
 type LoadedData = {
     langData: LanguagesScema;
-    vendorData: VendorSchema;
-    docData: VendorSchema;
     heuristicsData: HeuristicsSchema;
-    generatedData: string[];
     vendorPaths: string[];
 };
 /** Load data from github-linguist web repo or cached local file. */

package/dist/program/data/retrieveData.js

@@ -1,22 +1,19 @@
 import YAML from 'js-yaml';
-import { loadFile, parseGeneratedDataFile } from './loadDataFiles.js';
+import { loadFile } from './loadDataFiles.js';
 let data = null;
 async function initRetrieveData(offline) {
-    // Only load the data on mont
+    // Only load the data on mount
     if (data)
         return;
     const langData = (await loadFile('languages.yml', offline).then(YAML.load));
     const vendorData = (await loadFile('vendor.yml', offline).then(YAML.load));
     const docData = (await loadFile('documentation.yml', offline).then(YAML.load));
     const heuristicsData = (await loadFile('heuristics.yml', offline).then(YAML.load));
-    const generatedData = (await loadFile('generated.rb', offline).then(parseGeneratedDataFile));
+    const generatedData = (await loadFile('generated.rb', offline).then(YAML.load));
     const vendorPaths = [...vendorData, ...docData, ...generatedData];
     data = {
         langData,
-        vendorData,
-        docData,
         heuristicsData,
-        generatedData,
         vendorPaths,
     };
 }

package/dist/program/utils/pcre.js

@@ -14,6 +14,7 @@ export default function pcre(regex) {
     // Remove PCRE-only syntax
     replace(/([*+]){2}/g, '$1');
     replace(/\(\?>/g, '(?:');
+    replace(/\\g\<[^>]+\>/g, '.*?'); // referenced named groups not supported
     // Remove start/end-of-file markers
     if (/\\[AZ]/.test(finalRegex)) {
         replace(/\\A/g, '^');

package/dist/src/cli/output/default.d.ts

@@ -0,0 +1,3 @@
+import { OptionValues } from 'commander';
+import { Results } from '../../types/types.js';
+export default function defaultOutput(args: OptionValues, data: Results): Promise<void>;

package/dist/src/cli/output/default.js

@@ -0,0 +1,106 @@
+import FS from 'node:fs';
+import Path from 'node:path';
+import { normPath } from '../../program/fs/normalisedPath.js';
+import { colouredMsg, hexToRgb } from '../utils.js';
+export default async function defaultOutput(args, data) {
+    const { files, languages, unknown, repository } = data;
+    if (args.minSize) {
+        // Ignore languages with a bytes/% size less than the declared min size
+        const totalSize = languages.bytes;
+        const minSizeAmt = parseFloat(args.minSize.replace(/[a-z]+$/i, '')); // '2KB' -> 2
+        const minSizeUnit = args.minSize.replace(/^\d+/, '').toLowerCase(); // '2KB' -> 'kb'
+        const checkBytes = minSizeUnit !== 'loc'; // whether to check bytes or loc
+        const conversionFactors = {
+            ['b']: (n) => n,
+            ['kb']: (n) => n * 1e3,
+            ['mb']: (n) => n * 1e6,
+            ['%']: (n) => (n * totalSize) / 100,
+            ['loc']: (n) => n,
+        };
+        const minBytesSize = conversionFactors[minSizeUnit](+minSizeAmt);
+        const other = { count: 0, bytes: 0, lines: { total: 0, content: 0, code: 0 } };
+        // Apply specified minimums: delete language results that do not reach the threshold
+        for (const [lang, data] of Object.entries(languages.results)) {
+            const checkUnit = checkBytes ? data.bytes : data.lines.content;
+            if (checkUnit < minBytesSize) {
+                // Add to 'other' count
+                other.count++;
+                other.bytes += data.bytes;
+                other.lines.total += data.lines.total;
+                other.lines.content += data.lines.content;
+                // Remove language result
+                delete languages.results[lang];
+            }
+        }
+        if (other.bytes) {
+            languages.results['Other'] = other;
+        }
+    }
+    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 ${files.count} files with linguist-js`);
+    console.log(`\n Language analysis results: \n`);
+    let count = 0;
+    if (sortedEntries.length === 0)
+        console.log(`  None`);
+    // Collate files per language
+    const filesPerLanguage = {};
+    if (args.listFiles) {
+        for (const language of Object.keys(languages.results)) {
+            filesPerLanguage[language] = [];
+        }
+        for (const [file, lang] of Object.entries(files.results)) {
+            if (lang) {
+                filesPerLanguage[lang].push(file);
+            }
+        }
+    }
+    // List parsed results
+    for (const [lang, { bytes, lines }] of sortedEntries) {
+        const colour = hexToRgb(repository[lang].color ?? '#ededed');
+        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.content.toLocaleString().padStart(10, ' '),
+            icon: colouredMsg(colour, '\u2588'),
+        };
+        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 = normPath(Path.relative(Path.resolve('.'), file));
+                if (!relFile.startsWith('../')) {
+                    relFile = './' + relFile;
+                }
+                const fileStat = await FS.promises.stat(file);
+                const bytes = fileStat.size;
+                const fmtd2 = {
+                    file: relFile.padEnd(42, ' '),
+                    percent: percent(bytes).toFixed(2).padStart(5, ' '),
+                    bytes: bytes.toLocaleString().padStart(10, ' '),
+                };
+                console.log(`        ${fmtd.icon} ${fmtd2.file}  ${fmtd2.percent}% ${fmtd2.bytes} B`);
+            }
+            console.log(); // padding
+        }
+    }
+    if (!args.listFiles) {
+        console.log(); // padding
+    }
+    console.log(` Total: ${totalBytes.toLocaleString()} B`);
+    // List unknown files/extensions
+    if (unknown.bytes > 0) {
+        console.log(`\n Unknown files and extensions:`);
+        for (const [name, bytes] of Object.entries(unknown.filenames)) {
+            console.log(`  '${name}': ${bytes.toLocaleString()} B`);
+        }
+        for (const [ext, bytes] of Object.entries(unknown.extensions)) {
+            console.log(`  '*${ext}': ${bytes.toLocaleString()} B`);
+        }
+        console.log(` Total: ${unknown.bytes.toLocaleString()} B`);
+    }
+}

package/dist/src/cli/output/tree.d.ts

@@ -0,0 +1,3 @@
+import { OptionValues } from 'commander';
+import { Results } from '../../types/types.js';
+export default function treeOutput(args: OptionValues, data: Results): void;

package/dist/src/cli/output/tree.js

@@ -0,0 +1,11 @@
+export default function treeOutput(args, data) {
+    const treeParts = args.tree.split('.');
+    let nestedData = data;
+    for (const part of treeParts) {
+        if (!nestedData[part]) {
+            throw Error(`TraversalError: Key '${part}' cannot be found on output object.`);
+        }
+        nestedData = nestedData[part];
+    }
+    console.log(nestedData);
+}

package/dist/src/cli/runCliAnalysis.d.ts

@@ -0,0 +1,2 @@
+import { OptionValues } from 'commander';
+export default function runCliAnalysis(args: OptionValues): Promise<void>;

package/dist/src/cli/runCliAnalysis.js

@@ -0,0 +1,25 @@
+import linguist from '../index.js';
+import defaultOutput from './output/default.js';
+import treeOutput from './output/tree.js';
+const validCategories = ['data', 'programming', 'prose', 'markup'];
+export default async function runCliAnalysis(args) {
+    // Check arguments
+    if (args.categories?.some((category) => !validCategories.includes(category))) {
+        console.log(`Error: '${args.categories.join(', ')}' contains an invalid category.`);
+        console.log(`\tValid options: ${validCategories.join(', ')}.`);
+        return;
+    }
+    // Fetch language data
+    const root = args.analyze === true ? '.' : args.analyze;
+    const data = await linguist(root, args);
+    // Print output
+    if (!args.json) {
+        defaultOutput(args, data);
+    }
+    else if (args.tree) {
+        treeOutput(args, data);
+    }
+    else {
+        console.dir(data, { depth: null });
+    }
+}

package/dist/src/cli/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function colouredMsg([r, g, b]: [number, number, number], msg: string): string;
+export declare function hexToRgb(hex: string): [number, number, number];

package/dist/src/cli/utils.js

@@ -0,0 +1,9 @@
+export function colouredMsg([r, g, b], msg) {
+    return `\u001B[${38};2;${r};${g};${b}m${msg}\u001b[0m`;
+}
+export function hexToRgb(hex) {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return [r, g, b];
+}

package/dist/src/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/cli.js

@@ -0,0 +1,56 @@
+import { program } from 'commander';
+import FS from 'node:fs';
+import runCliAnalysis from './cli/runCliAnalysis.js';
+const packageJson = JSON.parse(FS.readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
+const VERSION = packageJson.version;
+program
+    .name('linguist')
+    .usage('--analyze [<folders...>] [<options...>]')
+    .option('-a|--analyze [folders...]', 'Analyse the languages of all files in a folder')
+    .option('-i|--ignoredFiles <files...>', `A list of file path globs to ignore`)
+    .option('-l|--ignoredLanguages <languages...>', `A list of languages to ignore`)
+    .option('-c|--categories <categories...>', 'Language categories to include in output')
+    .option('-C|--childLanguages [bool]', 'Display child languages instead of their parents', false)
+    .option('-j|--json [bool]', 'Display the output as JSON', false)
+    .option('-t|--tree <traversal>', 'Which part of the output JSON to display (dot-delimited)')
+    .option('-F|--listFiles [bool]', 'Whether to list every matching file under the language results', false)
+    .option('-m|--minSize <size>', 'Minimum size of file to show language results for (must have a unit: b, kb, mb, %, or loc)')
+    .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)
+    .helpOption(`-h|--help`, 'Display this help message')
+    .version(VERSION, '-v|--version', 'Display the installed version of linguist-js');
+program.parse(process.argv);
+const args = program.opts();
+// Normalise arguments
+for (const arg in args) {
+    const normalise = (val) => {
+        if (typeof val !== 'string')
+            return val;
+        val = val.replace(/^=/, '');
+        if (val.match(/true$|false$/))
+            val = val === 'true';
+        return val;
+    };
+    if (Array.isArray(args[arg]))
+        args[arg] = args[arg].map(normalise);
+    else
+        args[arg] = normalise(args[arg]);
+}
+// Run Linguist
+if (args.analyze) {
+    void runCliAnalysis(args);
+}
+else {
+    console.log(`Welcome to linguist-js, a JavaScript port of GitHub's language analyzer.`);
+    console.log(`Type 'linguist --help' for a list of commands.`);
+}

package/dist/src/helpers/convert-pcre.d.ts

@@ -0,0 +1,2 @@
+/** Convert a PCRE regex into JS. */
+export default function pcre(regex: string): RegExp;

package/dist/src/helpers/convert-pcre.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = pcre;
+/** Convert a PCRE regex into JS. */
+function pcre(regex) {
+    let finalRegex = regex;
+    const replace = (search, replace) => finalRegex = finalRegex.replace(search, replace);
+    const finalFlags = new Set();
+    // Convert inline flag declarations
+    const inlineMatches = regex.matchAll(/\?(-)?([a-z]):/g);
+    const startMatches = regex.matchAll(/\(\?(-)?([a-z]+)\)/g);
+    for (const [match, isNegative, flags] of [...inlineMatches, ...startMatches]) {
+        replace(match, '');
+        const func = (flag) => isNegative ? finalFlags.delete(flag) : finalFlags.add(flag);
+        [...flags].forEach(func);
+    }
+    // Remove PCRE-only syntax
+    replace(/([*+]){2}/g, '$1');
+    replace(/\(\?>/g, '(?:');
+    // Remove start/end-of-file markers
+    if (/\\[AZ]/.test(finalRegex)) {
+        replace(/\\A/g, '^');
+        replace(/\\Z/g, '$');
+        finalFlags.delete('m');
+    }
+    else {
+        finalFlags.add('m');
+    }
+    // Reformat free-spacing mode
+    if (finalFlags.has('x')) {
+        finalFlags.delete('x');
+        replace(/#.+/g, '');
+        replace(/^\s+|\s+$|\n/gm, '');
+        replace(/\s+/g, ' ');
+    }
+    // Return final regex
+    return RegExp(finalRegex, [...finalFlags].join(''));
+}

package/dist/src/helpers/load-data.d.ts

@@ -0,0 +1,4 @@
+/** Nukes unused `generated.rb` file content. */
+export declare function parseGeneratedDataFile(fileContent: string): string[];
+/** Load a data file from github-linguist. */
+export default function loadFile(file: string, offline?: boolean): Promise<string>;

package/dist/src/helpers/load-data.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGeneratedDataFile = parseGeneratedDataFile;
+exports.default = loadFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const cross_fetch_1 = __importDefault(require("cross-fetch"));
+const node_cache_1 = __importDefault(require("node-cache"));
+const cache = new node_cache_1.default({});
+async function loadWebFile(file) {
+    // Return cache if it exists
+    const cachedContent = cache.get(file);
+    if (cachedContent)
+        return cachedContent;
+    // Otherwise cache the request
+    const dataUrl = (file) => `https://raw.githubusercontent.com/github/linguist/HEAD/lib/linguist/${file}`;
+    // Load file content, falling back to the local file if the request fails
+    const fileContent = await (0, cross_fetch_1.default)(dataUrl(file)).then(data => data.text()).catch(async () => await loadLocalFile(file));
+    cache.set(file, fileContent);
+    return fileContent;
+}
+async function loadLocalFile(file) {
+    const filePath = path_1.default.resolve(__dirname, '../../ext', file);
+    return fs_1.default.promises.readFile(filePath).then(buffer => buffer.toString());
+}
+/** Nukes unused `generated.rb` file content. */
+function parseGeneratedDataFile(fileContent) {
+    var _a;
+    return [...(_a = fileContent.match(/(?<=name\.match\(\/).+?(?=(?<!\\)\/)/gm)) !== null && _a !== void 0 ? _a : []];
+}
+/** Load a data file from github-linguist. */
+function loadFile(file, offline = false) {
+    return offline ? loadLocalFile(file) : loadWebFile(file);
+}

package/dist/src/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/src/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/src/helpers/parse-gitattributes.d.ts

@@ -0,0 +1,17 @@
+import * as T from '../types';
+export type FlagAttributes = {
+    'vendored': boolean | null;
+    'generated': boolean | null;
+    'documentation': boolean | null;
+    'detectable': boolean | null;
+    'binary': boolean | null;
+    'language': T.LanguageResult;
+};
+export type ParsedGitattributes = Array<{
+    glob: T.FileGlob;
+    attrs: FlagAttributes;
+}>;
+/**
+ * Parses a gitattributes file.
+ */
+export default function parseAttributes(content: string, folderRoot?: string): ParsedGitattributes;

package/dist/src/helpers/parse-gitattributes.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = parseAttributes;
+const norm_path_1 = require("./norm-path");
+/**
+ * Parses a gitattributes file.
+ */
+function parseAttributes(content, folderRoot = '.') {
+    var _a, _b;
+    const output = [];
+    for (const rawLine of content.split('\n')) {
+        const line = rawLine.replace(/#.*/, '').trim();
+        if (!line)
+            continue;
+        const parts = line.split(/\s+/g);
+        const fileGlob = parts[0];
+        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');
+        const trueParts = (str) => attrParts.filter(part => part.includes(str) && isTrue(part));
+        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': 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,
+        };
+        output.push({ glob: relFileGlob, attrs });
+    }
+    return output;
+}

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

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

package/dist/src/helpers/parse-gitignore.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = parseGitignore;
+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;
+}

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

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

package/dist/src/helpers/read-file.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = readFileChunk;
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Read part of a file on disc.
+ * @throws 'EPERM' if the file is not readable.
+ */
+async function readFileChunk(filename, onlyFirstLine = false) {
+    const chunkSize = 100;
+    const stream = fs_1.default.createReadStream(filename, { highWaterMark: chunkSize });
+    let content = '';
+    for await (const data of stream) { // may throw
+        content += data.toString();
+        if (onlyFirstLine && content.includes('\n')) {
+            return content.split(/\r?\n/)[0];
+        }
+    }
+    return content;
+}

package/dist/src/helpers/walk-tree.d.ts

@@ -0,0 +1,20 @@
+import { Ignore } from 'ignore';
+interface WalkInput {
+    /** Whether this is walking the tree from the root */
+    init: boolean;
+    /** The common root absolute path of all folders being checked */
+    commonRoot: string;
+    /** The absolute path that each folder is relative to */
+    folderRoots: string[];
+    /** The absolute path of folders being checked */
+    folders: string[];
+    /** An instantiated Ignore object listing ignored files */
+    ignored: Ignore;
+}
+interface WalkOutput {
+    files: string[];
+    folders: string[];
+}
+/** Generate list of files in a directory. */
+export default function walk(data: WalkInput): WalkOutput;
+export {};