linguist-js 2.9.2 → 3.0.0-pre

package/dist/program/classes/attributes.d.ts

@@ -0,0 +1,11 @@
+import { FileGlob, RelFile } from '../../types/types.js';
+import { FlagAttributes } from '../parsing/parseGitattributes.js';
+/** Stores parsed attribute information per file glob */
+export default class Attributes {
+    #private;
+    constructor();
+    get attributes(): Record<FileGlob, FlagAttributes>;
+    add(glob: FileGlob, attributes: FlagAttributes): void;
+    getFlaggedGlobs(attr: keyof FlagAttributes, val: boolean): string[];
+    findAttrsForPath(relFilePath: RelFile): FlagAttributes | null;
+}

package/dist/program/classes/attributes.js

@@ -0,0 +1,37 @@
+import ignore from 'ignore';
+/** Stores parsed attribute information per file glob */
+export default class Attributes {
+    #attributes;
+    constructor() {
+        this.#attributes = {};
+    }
+    get attributes() {
+        return this.#attributes;
+    }
+    add(glob, attributes) {
+        this.#attributes[glob] = attributes;
+    }
+    getFlaggedGlobs(attr, val) {
+        return Object.entries(this.#attributes)
+            .filter(([, attrs]) => attrs[attr] === val)
+            .map(([glob]) => glob);
+    }
+    findAttrsForPath(relFilePath) {
+        const resultAttrs = {};
+        for (const glob in this.#attributes) {
+            const matchingAttrs = this.#attributes[glob];
+            // Check if glob matches rel path
+            if (ignore().add(glob).ignores(relFilePath)) {
+                for (const [attr, val] of Object.entries(matchingAttrs)) {
+                    if (val != null) {
+                        resultAttrs[attr] = val;
+                    }
+                }
+            }
+        }
+        if (!JSON.stringify(resultAttrs).length) {
+            return null;
+        }
+        return resultAttrs;
+    }
+}

package/dist/{helpers/load-data.d.ts → program/data/loadDataFiles.d.ts}

@@ -1,4 +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>;
+export declare function loadFile(file: string, offline?: boolean): Promise<string>;

package/dist/program/data/loadDataFiles.js

@@ -0,0 +1,32 @@
+import Cache from 'node-cache';
+import FS from 'node:fs';
+import Path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const cache = new Cache({});
+const dirname = Path.dirname(fileURLToPath(import.meta.url));
+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 fetch(dataUrl(file))
+        .then((data) => data.text())
+        .catch(async () => await loadLocalFile(file));
+    cache.set(file, fileContent);
+    return fileContent;
+}
+async function loadLocalFile(file) {
+    const filePath = Path.resolve(dirname, '../../../ext', file);
+    return FS.promises.readFile(filePath).then((buffer) => buffer.toString());
+}
+/** Nukes unused `generated.rb` file content. */
+export function parseGeneratedDataFile(fileContent) {
+    return [...(fileContent.match(/(?<=name\.match\(\/).+?(?=(?<!\\)\/)/gm) ?? [])];
+}
+/** Load a data file from github-linguist. */
+export function loadFile(file, offline = false) {
+    return offline ? loadLocalFile(file) : loadWebFile(file);
+}

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

@@ -0,0 +1,12 @@
+import { HeuristicsSchema, LanguagesScema, VendorSchema } 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. */
+export default function retrieveData(offline: boolean): Promise<LoadedData>;
+export {};

package/dist/program/data/retrieveData.js

@@ -0,0 +1,27 @@
+import YAML from 'js-yaml';
+import { loadFile, parseGeneratedDataFile } from './loadDataFiles.js';
+let data = null;
+async function initRetrieveData(offline) {
+    // Only load the data on mont
+    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 vendorPaths = [...vendorData, ...docData, ...generatedData];
+    data = {
+        langData,
+        vendorData,
+        docData,
+        heuristicsData,
+        generatedData,
+        vendorPaths,
+    };
+}
+/** Load data from github-linguist web repo or cached local file. */
+export default async function retrieveData(offline) {
+    await initRetrieveData(offline);
+    return data;
+}

package/dist/{helpers/norm-path.d.ts → program/fs/normalisedPath.d.ts}

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

package/dist/program/fs/normalisedPath.js

@@ -0,0 +1,17 @@
+import Path from 'node:path';
+export const normPath = function normalisedPath(...inputPaths) {
+    return Path.join(...inputPaths).replace(/\\/g, '/');
+};
+export const normAbsPath = function normalisedAbsolutePath(...inputPaths) {
+    return Path.resolve(...inputPaths).replace(/\\/g, '/');
+};
+export const getFileExtension = function getFileExtension(filePath) {
+    const extension = Path.extname(filePath).toLowerCase();
+    if (extension)
+        return extension;
+    const basename = Path.basename(filePath);
+    if (basename.startsWith('.') && basename.length > 1 && basename.indexOf('.', 1) === -1) {
+        return basename.toLowerCase();
+    }
+    return '';
+};

package/dist/program/fs/readFile.js

@@ -0,0 +1,17 @@
+import FS from 'node:fs';
+/**
+ * Read part of a file on disc.
+ * @throws 'EPERM' if the file is not readable.
+ */
+export default async function readFileChunk(filename, onlyFirstLine = false) {
+    const chunkSize = 100;
+    const stream = FS.createReadStream(filename, { highWaterMark: chunkSize });
+    let content = '';
+    for await (const data of stream) { // may throw
+        content += data.toString();
+        if (onlyFirstLine) {
+            return content.split(/\r?\n/)[0];
+        }
+    }
+    return content;
+}

package/dist/{helpers/walk-tree.d.ts → program/fs/walkTree.d.ts}

@@ -16,5 +16,5 @@ interface WalkOutput {
     folders: string[];
 }
 /** Generate list of files in a directory. */
-export default function walk(data: WalkInput): WalkOutput;
+export default function walkTree(data: WalkInput): WalkOutput;
 export {};

package/dist/{helpers/walk-tree.js → program/fs/walkTree.js}

@@ -1,19 +1,11 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = walk;
-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");
+import FS from 'node:fs';
+import Path from 'node:path';
+import parseGitignore from '../parsing/parseGitignore.js';
+import { normAbsPath, normPath } from './normalisedPath.js';
 let allFiles;
 let allFolders;
-;
-;
 /** Generate list of files in a directory. */
-function walk(data) {
+export default function walkTree(data) {
     const { init, commonRoot, folderRoots, folders, ignored } = data;
     // Initialise files and folders lists
     if (init) {
@@ -25,37 +17,37 @@ function walk(data) {
         const folder = folders[0];
         const localRoot = folderRoots[0].replace(commonRoot, '').replace(/^\//, '');
         // Get list of files and folders inside this folder
-        const files = fs_1.default.readdirSync(folder).map(file => {
+        const files = FS.readdirSync(folder).map((file) => {
             // Create path relative to root
-            const base = (0, norm_path_1.normAbsPath)(folder, file).replace(commonRoot, '.');
+            const base = normAbsPath(folder, file).replace(commonRoot, '.');
             // Add trailing slash to mark directories
-            const isDir = fs_1.default.lstatSync(path_1.default.resolve(commonRoot, base)).isDirectory();
+            const isDir = FS.lstatSync(Path.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);
-            const rootRelIgnoredPaths = ignoredPaths.map(ignorePath => 
+        const gitignoreFilename = normPath(folder, '.gitignore');
+        if (FS.existsSync(gitignoreFilename)) {
+            const gitignoreContents = FS.readFileSync(gitignoreFilename, 'utf-8');
+            const ignoredPaths = parseGitignore(gitignoreContents);
+            const rootRelIgnoredPaths = ignoredPaths.map((ignorePath) => 
             // get absolute path of the ignore glob
-            (0, norm_path_1.normPath)(folder, ignorePath)
+            normPath(folder, ignorePath)
                 // convert abs ignore glob to be relative to the root folder
                 .replace(commonRoot + '/', ''));
             ignored.add(rootRelIgnoredPaths);
         }
         // Add gitattributes if present
-        const gitattributesPath = (0, norm_path_1.normPath)(folder, '.gitattributes');
-        if (fs_1.default.existsSync(gitattributesPath)) {
+        const gitattributesPath = normPath(folder, '.gitattributes');
+        if (FS.existsSync(gitattributesPath)) {
             allFiles.add(gitattributesPath);
         }
         // Loop through files and folders
         for (const file of files) {
             // Create absolute path for disc operations
-            const path = (0, norm_path_1.normAbsPath)(commonRoot, file);
+            const path = normAbsPath(commonRoot, file);
             const localPath = localRoot ? file.replace(`./${localRoot}/`, '') : file.replace('./', '');
             // Skip if nonexistant
-            const nonExistant = !fs_1.default.existsSync(path);
+            const nonExistant = !FS.existsSync(path);
             if (nonExistant)
                 continue;
             // Skip if marked in gitignore
@@ -63,12 +55,12 @@ function walk(data) {
             if (isIgnored)
                 continue;
             // Add absolute folder path to list
-            allFolders.add((0, norm_path_1.normAbsPath)(folder));
+            allFolders.add(normAbsPath(folder));
             // Check if this is a folder or file
             if (file.endsWith('/')) {
                 // Recurse into subfolders
                 allFolders.add(path);
-                walk({ init: false, commonRoot, folderRoots, folders: [path], ignored });
+                walkTree({ init: false, commonRoot, folderRoots, folders: [path], ignored });
             }
             else {
                 // Add file path to list
@@ -79,12 +71,12 @@ function walk(data) {
     // Recurse into all folders
     else {
         for (const i in folders) {
-            walk({ init: false, commonRoot, folderRoots: [folderRoots[i]], folders: [folders[i]], ignored });
+            walkTree({ init: false, commonRoot, folderRoots: [folderRoots[i]], folders: [folders[i]], ignored });
         }
     }
     // Return absolute files and folders lists
     return {
-        files: [...allFiles].map(file => file.replace(/^\./, commonRoot)),
+        files: [...allFiles].map((file) => file.replace(/^\./, commonRoot)),
         folders: [...allFolders],
     };
 }

package/dist/{helpers/parse-gitattributes.d.ts → program/parsing/parseGitattributes.d.ts}

@@ -1,4 +1,4 @@
-import * as T from '../types';
+import * as T from '../../types/types.js';
 export type FlagAttributes = {
     'vendored': boolean | null;
     'generated': boolean | null;
@@ -14,4 +14,4 @@ export type ParsedGitattributes = Array<{
 /**
  * Parses a gitattributes file.
  */
-export default function parseAttributes(content: string, folderRoot?: string): ParsedGitattributes;
+export default function parseGitattributes(content: string, folderRoot?: string): ParsedGitattributes;

package/dist/{helpers/parse-gitattributes.js → program/parsing/parseGitattributes.js}

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = parseAttributes;
-const norm_path_1 = require("./norm-path");
+import { normPath } from '../fs/normalisedPath.js';
 /**
  * Parses a gitattributes file.
  */
-function parseAttributes(content, folderRoot = '.') {
-    var _a, _b;
+export default function parseGitattributes(content, folderRoot = '.') {
     const output = [];
     for (const rawLine of content.split('\n')) {
         const line = rawLine.replace(/#.*/, '').trim();
@@ -14,7 +10,7 @@ function parseAttributes(content, folderRoot = '.') {
             continue;
         const parts = line.split(/\s+/g);
         const fileGlob = parts[0];
-        const relFileGlob = (0, norm_path_1.normPath)(folderRoot, fileGlob);
+        const relFileGlob = normPath(folderRoot, fileGlob);
         const attrParts = parts.slice(1);
         const isTrue = (str) => !str.startsWith('-') && !str.endsWith('=false');
         const isFalse = (str) => str.startsWith('-') || str.endsWith('=false');
@@ -29,7 +25,7 @@ function parseAttributes(content, folderRoot = '.') {
             '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,
+            'language': trueParts('linguist-language').at(-1)?.split('=')[1] ?? null,
         };
         output.push({ glob: relFileGlob, attrs });
     }

package/dist/{helpers/parse-gitignore.js → program/parsing/parseGitignore.js}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = parseGitignore;
-function parseGitignore(content) {
+export default function parseGitignore(content) {
     const readableData = content
         // Remove comments unless escaped
         .replace(/(?<!\\)#.+/g, '')

package/dist/program/processFiles.d.ts

@@ -0,0 +1,9 @@
+import * as T from '../types/types.js';
+import Attributes from './classes/attributes.js';
+type ProcessFilesResult = {
+    files: T.AbsFile[];
+    manualAttributes: Attributes;
+    relPath(file: T.AbsFile): T.RelFile;
+};
+export default function processFiles(input: string[], opts: T.Options, useRawContent: boolean, vendorPaths: string[]): Promise<ProcessFilesResult>;
+export {};

package/dist/program/processFiles.js

@@ -0,0 +1,111 @@
+import commonPrefix from 'common-path-prefix';
+import ignore from 'ignore';
+import FS from 'node:fs';
+import Path from 'node:path';
+import Attributes from './classes/attributes.js';
+import { normPath } from './fs/normalisedPath.js';
+import readFileChunk from './fs/readFile.js';
+import walkTree from './fs/walkTree.js';
+import parseGitattributes from './parsing/parseGitattributes.js';
+const binaryData = JSON.parse(FS.readFileSync(new URL('../../node_modules/binary-extensions/binary-extensions.json', import.meta.url), 'utf-8'));
+export default async function processFiles(input, opts, useRawContent, vendorPaths) {
+    // Set a common root path so that vendor paths do not incorrectly match parent folders
+    const resolvedInput = input.map((path) => normPath(Path.resolve(path)));
+    const commonRoot = (input.length > 1 ? commonPrefix(resolvedInput) : resolvedInput[0]).replace(/\/?$/, '');
+    const relPath = (file) => (useRawContent ? file : normPath(Path.relative(commonRoot, file)));
+    const unRelPath = (file) => (useRawContent ? file : normPath(Path.resolve(commonRoot, file)));
+    // Other helper functions
+    const filterOutIgnored = (files, ignored) => ignored.filter(files.map((file) => relPath(file))).map((file) => unRelPath(file));
+    //*PREPARE FILES AND DATA*//
+    // Prepare list of ignored files
+    const ignored = ignore();
+    ignored.add('.git/');
+    ignored.add(opts.ignoredFiles ?? []);
+    const regexIgnores = opts.keepVendored ? [] : vendorPaths.map((path) => RegExp(path, 'i'));
+    // Load file paths and folders
+    let files;
+    if (useRawContent) {
+        // Uses raw file content
+        files = input;
+    }
+    else {
+        // Uses directory on disc
+        const data = walkTree({ init: true, commonRoot, folderRoots: resolvedInput, folders: resolvedInput, ignored });
+        files = data.files;
+    }
+    // Fetch and normalise gitattributes data of all subfolders and save to metadata
+    const manualAttributes = new Attributes();
+    if (!useRawContent && opts.checkAttributes) {
+        const nestedAttrFiles = files.filter((file) => file.endsWith('.gitattributes'));
+        for (const attrFile of nestedAttrFiles) {
+            const relAttrFile = relPath(attrFile);
+            const relAttrFolder = Path.dirname(relAttrFile);
+            const contents = await readFileChunk(attrFile);
+            const parsed = parseGitattributes(contents, relAttrFolder);
+            for (const { glob, attrs } of parsed) {
+                manualAttributes.add(glob, attrs);
+            }
+        }
+    }
+    // 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 = manualAttributes.findAttrsForPath(relPath(file));
+        if (fileAttrs?.generated === false || 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
+        const vendorTrueGlobs = [
+            ...manualAttributes.getFlaggedGlobs('vendored', true),
+            ...manualAttributes.getFlaggedGlobs('generated', true),
+            ...manualAttributes.getFlaggedGlobs('documentation', true),
+        ];
+        const vendorFalseGlobs = [
+            ...manualAttributes.getFlaggedGlobs('vendored', false),
+            ...manualAttributes.getFlaggedGlobs('generated', false),
+            ...manualAttributes.getFlaggedGlobs('documentation', false),
+        ];
+        // Set up glob ignore object to use for expanding globs to match files
+        const vendorTrueIgnore = ignore().add(vendorTrueGlobs);
+        const vendorFalseIgnore = ignore().add(vendorFalseGlobs);
+        // Remove all files marked as vendored by default
+        const excludedFiles = files.filter((file) => vendorPaths.some((pathPtn) => RegExp(pathPtn, 'i').test(relPath(file))));
+        files = files.filter((file) => !excludedFiles.includes(file));
+        // Re-add removed files that are overridden manually in gitattributes
+        const overriddenExcludedFiles = excludedFiles.filter((file) => vendorFalseIgnore.ignores(relPath(file)));
+        files.push(...overriddenExcludedFiles);
+        // Remove files explicitly marked as vendored in gitattributes
+        files = files.filter((file) => !vendorTrueIgnore.ignores(relPath(file)));
+    }
+    // Filter out binary files
+    if (!opts.keepBinary) {
+        // Filter out files that are binary by default
+        files = files.filter((file) => !binaryData.some((ext) => file.endsWith('.' + ext)));
+        // Filter out manually specified binary files
+        const binaryIgnored = ignore().add(manualAttributes.getFlaggedGlobs('binary', true));
+        files = filterOutIgnored(files, binaryIgnored);
+        // Re-add files manually marked not as binary
+        const binaryUnignored = ignore().add(manualAttributes.getFlaggedGlobs('binary', false));
+        const unignoredList = filterOutIgnored(files, binaryUnignored);
+        files.push(...unignoredList);
+    }
+    return {
+        files,
+        manualAttributes,
+        relPath,
+    };
+}

package/dist/{helpers/convert-pcre.js → program/utils/pcre.js}

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = pcre;
 /** Convert a PCRE regex into JS. */
-function pcre(regex) {
+export default function pcre(regex) {
     let finalRegex = regex;
     const replace = (search, replace) => finalRegex = finalRegex.replace(search, replace);
     const finalFlags = new Set();

package/dist/{schema.d.ts → types/schema.d.ts}

@@ -1,4 +1,4 @@
-import { Category, Language } from './types';
+import { Category, Language } from './types.js';
 export interface LanguagesScema {
     [name: string]: {
         language_id: number;

package/dist/types/schema.js

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

package/dist/{types.d.ts → types/types.d.ts}

@@ -1,15 +1,16 @@
+import type { LanguagesScema } from './schema.js';
 export type LanguageResult = string | null;
 export type Language = string;
 export type Category = 'data' | 'markup' | 'programming' | 'prose';
 export type FilePath = string;
 export type Bytes = Integer;
 export type Integer = number;
+export type LanguageMetadata = LanguagesScema[string];
 export type RelFile = string & {};
 export type AbsFile = string & {};
 export type AbsFolder = string & {};
 export type FileGlob = string & {};
 export interface Options {
-    fileContent?: string | string[];
     ignoredFiles?: string[];
     ignoredLanguages?: Language[];
     categories?: Category[];
@@ -27,15 +28,33 @@ export interface Options {
     checkShebang?: boolean;
     checkModeline?: boolean;
 }
+export interface VirtualFile {
+    path: string;
+    content?: string;
+    firstLine?: string;
+    size?: number;
+    extension?: string;
+    isBinary?: boolean;
+    metadata?: {
+        vendored?: boolean;
+        generated?: boolean;
+        documentation?: boolean;
+    };
+    attributes?: {
+        language?: LanguageResult;
+        binary?: boolean;
+        detectable?: boolean;
+    };
+}
+type LinesOfCode = {
+    total: Integer;
+    content: Integer;
+};
 export interface Results {
     files: {
         count: Integer;
         bytes: Bytes;
-        lines: {
-            total: Integer;
-            content: Integer;
-            code: Integer;
-        };
+        lines: LinesOfCode;
         /** Note: Results use slashes as delimiters even on Windows. */
         results: Record<FilePath, LanguageResult>;
         alternatives: Record<FilePath, LanguageResult[]>;
@@ -43,32 +62,24 @@ export interface Results {
     languages: {
         count: Integer;
         bytes: Bytes;
-        lines: {
-            total: Integer;
-            content: Integer;
-            code: Integer;
-        };
+        lines: LinesOfCode;
         results: Record<Language, {
+            count: Integer;
             bytes: Bytes;
-            lines: {
-                total: Integer;
-                content: Integer;
-                code: Integer;
-            };
-            type: Category;
-            parent?: Language;
-            color?: `#${string}`;
+            lines: LinesOfCode;
         }>;
     };
     unknown: {
         count: Integer;
         bytes: Bytes;
-        lines: {
-            total: Integer;
-            content: Integer;
-            code: Integer;
-        };
+        lines: LinesOfCode;
         extensions: Record<string, Bytes>;
         filenames: Record<string, Bytes>;
     };
+    repository: Record<Language, {
+        type: Category;
+        parent?: Language;
+        color?: `#${string}`;
+    }>;
 }
+export {};

package/dist/types/types.js

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

package/ext/generated.rb

@@ -6,6 +6,7 @@
 - node_modules\/
 - vendor\/((?!-)[-0-9A-Za-z]+(?<!-)\.)+(com|edu|gov|in|me|net|org|fm|io)
 - (Gopkg|glide)\.lock
+- Package\.resolved
 - poetry\.lock
 - pdm\.lock
 - uv\.lock
@@ -15,6 +16,7 @@
 - npm-shrinkwrap\.json
 - package-lock\.json
 - pnpm-lock\.yaml
+- (?:^|\/)bun\.lockb?$
 - (^|\/)\.pnp\..*$
 - Godeps\/
 - composer\.lock
@@ -23,6 +25,10 @@
 - Cargo\.toml\.orig
 - (^|\/)flake\.lock$
 - (^|\/)MODULE\.bazel\.lock$
+- (?:^|\/)gradlew(?:\.bat)?$
+- (?:^|\/)mvnw(?:\.cmd)?$
+- (?:^|\/)mise(?:\.[^\/]+)?\.lock$
+- (?:^|\/)(Julia)?Manifest(-v\d+\.\d+)?\.toml$
 - Pipfile\.lock
 - (?:^|\/)\.terraform\.lock\.hcl$
 - ppport\.h$