@codemap-ai/code-index 1.0.0

package/LICENSE

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

package/dist/file-discovery.d.ts

@@ -0,0 +1,36 @@
+export type RepoFileParseStatus = "parsed" | "skipped" | "too_large" | "binary" | "unsupported" | "error";
+export declare const IGNORED_NAMES: Set<string>;
+export declare const MAX_PARSE_BYTES: number;
+export declare const MAX_PARSE_BYTES_BY_LANGUAGE: Partial<Record<string, number>>;
+export declare const PARSE_TOOL_NAME = "codemap-regex-parser";
+export declare const PARSE_TOOL_VERSION = "0.1.0";
+export interface WorkspaceFileCandidate {
+    path: string;
+    absolutePath: string;
+    dirPath: string;
+    baseName: string;
+    extension: string | null;
+    language: string | null;
+    mimeType: string | null;
+    sizeBytes: number;
+    contentSha256: string | null;
+    isText: boolean;
+    isBinary: boolean;
+    isGenerated: boolean;
+    isIgnored: boolean;
+    ignoreReason: string | null;
+    isParseable: boolean;
+    parseStatus: RepoFileParseStatus;
+    parserName: string | null;
+    parserVersion: string | null;
+    lineCount: number | null;
+    content: string | null;
+}
+export declare function normalizeRepositoryFilePath(input: string): string;
+/**
+ * Collect a single file as a WorkspaceFileCandidate.
+ * Returns null if the file doesn't exist, is a symlink, or is in an ignored directory.
+ */
+export declare function collectSingleFile(relativePath: string, workspacePath: string): Promise<WorkspaceFileCandidate | null>;
+export declare function collectWorkspaceFiles(workspacePath: string): Promise<WorkspaceFileCandidate[]>;
+//# sourceMappingURL=file-discovery.d.ts.map

package/dist/file-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-discovery.d.ts","sourceRoot":"","sources":["../src/file-discovery.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,mBAAmB,GAC3B,QAAQ,GACR,SAAS,GACT,WAAW,GACX,QAAQ,GACR,aAAa,GACb,OAAO,CAAC;AAEZ,eAAO,MAAM,aAAa,aAUxB,CAAC;AAEH,eAAO,MAAM,eAAe,QAAkB,CAAC;AAC/C,eAAO,MAAM,2BAA2B,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEvE,CAAC;AAEF,eAAO,MAAM,eAAe,yBAAyB,CAAC;AACtD,eAAO,MAAM,kBAAkB,UAAU,CAAC;AAE1C,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,mBAAmB,CAAC;IACjC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,UASxD;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CA+ExC;AAED,wBAAsB,qBAAqB,CACzC,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAgGnC"}

package/dist/file-discovery.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARSE_TOOL_VERSION = exports.PARSE_TOOL_NAME = exports.MAX_PARSE_BYTES_BY_LANGUAGE = exports.MAX_PARSE_BYTES = exports.IGNORED_NAMES = void 0;
+exports.normalizeRepositoryFilePath = normalizeRepositoryFilePath;
+exports.collectSingleFile = collectSingleFile;
+exports.collectWorkspaceFiles = collectWorkspaceFiles;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const language_utils_js_1 = require("./language-utils.js");
+exports.IGNORED_NAMES = new Set([
+    ".git",
+    ".codemap",
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    "coverage",
+    ".turbo",
+    ".cache",
+]);
+exports.MAX_PARSE_BYTES = 2 * 1024 * 1024;
+exports.MAX_PARSE_BYTES_BY_LANGUAGE = {
+    Gettext: 10 * 1024 * 1024,
+};
+exports.PARSE_TOOL_NAME = "codemap-regex-parser";
+exports.PARSE_TOOL_VERSION = "0.1.0";
+function normalizeRepositoryFilePath(input) {
+    const normalizedPath = input.trim().replace(/\\/g, "/").replace(/^\/+/, "");
+    const resolvedPath = node_path_1.default.posix.normalize(normalizedPath);
+    if (!resolvedPath || resolvedPath === "." || resolvedPath.startsWith("../")) {
+        throw new Error("File path must stay within the repository root");
+    }
+    return resolvedPath;
+}
+/**
+ * Collect a single file as a WorkspaceFileCandidate.
+ * Returns null if the file doesn't exist, is a symlink, or is in an ignored directory.
+ */
+async function collectSingleFile(relativePath, workspacePath) {
+    const absolutePath = node_path_1.default.join(workspacePath, relativePath);
+    try {
+        const entryStats = await (0, promises_1.lstat)(absolutePath);
+        if (entryStats.isSymbolicLink() || !entryStats.isFile())
+            return null;
+        // Check if any parent directory is in IGNORED_NAMES
+        const parts = relativePath.split("/");
+        for (let i = 0; i < parts.length - 1; i++) {
+            if (exports.IGNORED_NAMES.has(parts[i]))
+                return null;
+        }
+        const name = node_path_1.default.basename(absolutePath);
+        const extension = (0, language_utils_js_1.normalizeExtension)(name);
+        const language = (0, language_utils_js_1.inferLanguage)(extension);
+        const mimeType = (0, language_utils_js_1.inferMimeType)(extension);
+        const sample = await (0, language_utils_js_1.readSampleBuffer)(absolutePath, entryStats.size);
+        const isBinary = (0, language_utils_js_1.isBinaryBuffer)(sample);
+        const isText = !isBinary;
+        const maxParseBytes = (language ? exports.MAX_PARSE_BYTES_BY_LANGUAGE[language] : undefined) ?? exports.MAX_PARSE_BYTES;
+        const isParseable = Boolean(language) && isText && entryStats.size <= maxParseBytes;
+        const normalizedPath = normalizeRepositoryFilePath(relativePath);
+        const dirPath = node_path_1.default.posix.dirname(normalizedPath) === "."
+            ? ""
+            : node_path_1.default.posix.dirname(normalizedPath);
+        if (!isParseable) {
+            return {
+                path: normalizedPath,
+                absolutePath,
+                dirPath,
+                baseName: name,
+                extension,
+                language,
+                mimeType,
+                sizeBytes: entryStats.size,
+                contentSha256: null,
+                isText,
+                isBinary,
+                isGenerated: false,
+                isIgnored: false,
+                ignoreReason: null,
+                isParseable: false,
+                parseStatus: isBinary ? "binary" : entryStats.size > exports.MAX_PARSE_BYTES ? "too_large" : "unsupported",
+                parserName: null,
+                parserVersion: null,
+                lineCount: null,
+                content: null,
+            };
+        }
+        const content = await (0, promises_1.readFile)(absolutePath, "utf8");
+        return {
+            path: normalizedPath,
+            absolutePath,
+            dirPath,
+            baseName: name,
+            extension,
+            language,
+            mimeType,
+            sizeBytes: entryStats.size,
+            contentSha256: (0, language_utils_js_1.buildFileSha256)(content),
+            isText: true,
+            isBinary: false,
+            isGenerated: false,
+            isIgnored: false,
+            ignoreReason: null,
+            isParseable: true,
+            parseStatus: "parsed",
+            parserName: exports.PARSE_TOOL_NAME,
+            parserVersion: exports.PARSE_TOOL_VERSION,
+            lineCount: content.split(/\r?\n/).length,
+            content,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function collectWorkspaceFiles(workspacePath) {
+    const candidates = [];
+    async function visit(absolutePath) {
+        const entryStats = await (0, promises_1.lstat)(absolutePath);
+        if (entryStats.isSymbolicLink())
+            return;
+        const name = node_path_1.default.basename(absolutePath);
+        if (entryStats.isDirectory()) {
+            if (exports.IGNORED_NAMES.has(name))
+                return;
+            const entries = await (0, promises_1.readdir)(absolutePath, { withFileTypes: true });
+            for (const entry of entries) {
+                await visit(node_path_1.default.join(absolutePath, entry.name));
+            }
+            return;
+        }
+        if (!entryStats.isFile())
+            return;
+        const relativePath = normalizeRepositoryFilePath(node_path_1.default.relative(workspacePath, absolutePath).split(node_path_1.default.sep).join("/"));
+        const extension = (0, language_utils_js_1.normalizeExtension)(name);
+        const language = (0, language_utils_js_1.inferLanguage)(extension);
+        const mimeType = (0, language_utils_js_1.inferMimeType)(extension);
+        const sample = await (0, language_utils_js_1.readSampleBuffer)(absolutePath, entryStats.size);
+        const isBinary = (0, language_utils_js_1.isBinaryBuffer)(sample);
+        const isText = !isBinary;
+        const maxParseBytes = (language ? exports.MAX_PARSE_BYTES_BY_LANGUAGE[language] : undefined) ?? exports.MAX_PARSE_BYTES;
+        const isParseable = Boolean(language) && isText && entryStats.size <= maxParseBytes;
+        const dirPath = node_path_1.default.posix.dirname(relativePath) === "."
+            ? ""
+            : node_path_1.default.posix.dirname(relativePath);
+        if (!isParseable) {
+            candidates.push({
+                path: relativePath,
+                absolutePath,
+                dirPath,
+                baseName: name,
+                extension,
+                language,
+                mimeType,
+                sizeBytes: entryStats.size,
+                contentSha256: null,
+                isText,
+                isBinary,
+                isGenerated: false,
+                isIgnored: false,
+                ignoreReason: null,
+                isParseable: false,
+                parseStatus: isBinary
+                    ? "binary"
+                    : entryStats.size > exports.MAX_PARSE_BYTES
+                        ? "too_large"
+                        : "unsupported",
+                parserName: null,
+                parserVersion: null,
+                lineCount: null,
+                content: null,
+            });
+            return;
+        }
+        const content = await (0, promises_1.readFile)(absolutePath, "utf8");
+        candidates.push({
+            path: relativePath,
+            absolutePath,
+            dirPath,
+            baseName: name,
+            extension,
+            language,
+            mimeType,
+            sizeBytes: entryStats.size,
+            contentSha256: (0, language_utils_js_1.buildFileSha256)(content),
+            isText: true,
+            isBinary: false,
+            isGenerated: false,
+            isIgnored: false,
+            ignoreReason: null,
+            isParseable: true,
+            parseStatus: "parsed",
+            parserName: exports.PARSE_TOOL_NAME,
+            parserVersion: exports.PARSE_TOOL_VERSION,
+            lineCount: content.split(/\r?\n/).length,
+            content,
+        });
+    }
+    await visit(workspacePath);
+    return candidates.sort((left, right) => left.path.localeCompare(right.path));
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { collectSingleFile, collectWorkspaceFiles, IGNORED_NAMES, MAX_PARSE_BYTES, MAX_PARSE_BYTES_BY_LANGUAGE, PARSE_TOOL_NAME, PARSE_TOOL_VERSION, type WorkspaceFileCandidate, } from "./file-discovery.js";
+export { BINARY_SAMPLE_BYTES, SOURCE_LANGUAGE_BY_EXTENSION, MIME_TYPE_BY_EXTENSION, buildFileSha256, inferLanguage, inferMimeType, isBinaryBuffer, normalizeExtension, readSampleBuffer, } from "./language-utils.js";
+export { loadTypeScriptResolverConfigs, normalizeWorkspaceRelativePath, type TypeScriptPathAliasPattern, type TypeScriptResolverConfig, } from "./ts-resolver.js";
+export { parseWorkspaceFileSemantics, type ParsedWorkspaceSemantics, } from "./parsers/index.js";
+export type { ParsedCallDraft, ParsedExportDraft, ParsedExternalSymbolDraft, ParsedImportDraft, ParsedParseIssueDraft, ParsedRelationshipDraft, ParsedSymbolDraft, RepoExportKind, RepoFileParseStatus, RepoImportKind, RepoImportResolutionKind, RepoParseIssueSeverity, RepoSymbolKind, RepoSymbolRelationshipKind, } from "./parsers/types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,aAAa,EACb,eAAe,EACf,2BAA2B,EAC3B,eAAe,EACf,kBAAkB,EAClB,KAAK,sBAAsB,GAC5B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,mBAAmB,EACnB,4BAA4B,EAC5B,sBAAsB,EACtB,eAAe,EACf,aAAa,EACb,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,6BAA6B,EAC7B,8BAA8B,EAC9B,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,GAC9B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,2BAA2B,EAC3B,KAAK,wBAAwB,GAC9B,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,eAAe,EACf,iBAAiB,EACjB,yBAAyB,EACzB,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,wBAAwB,EACxB,sBAAsB,EACtB,cAAc,EACd,0BAA0B,GAC3B,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWorkspaceFileSemantics = exports.normalizeWorkspaceRelativePath = exports.loadTypeScriptResolverConfigs = exports.readSampleBuffer = exports.normalizeExtension = exports.isBinaryBuffer = exports.inferMimeType = exports.inferLanguage = exports.buildFileSha256 = exports.MIME_TYPE_BY_EXTENSION = exports.SOURCE_LANGUAGE_BY_EXTENSION = exports.BINARY_SAMPLE_BYTES = exports.PARSE_TOOL_VERSION = exports.PARSE_TOOL_NAME = exports.MAX_PARSE_BYTES_BY_LANGUAGE = exports.MAX_PARSE_BYTES = exports.IGNORED_NAMES = exports.collectWorkspaceFiles = exports.collectSingleFile = void 0;
+var file_discovery_js_1 = require("./file-discovery.js");
+Object.defineProperty(exports, "collectSingleFile", { enumerable: true, get: function () { return file_discovery_js_1.collectSingleFile; } });
+Object.defineProperty(exports, "collectWorkspaceFiles", { enumerable: true, get: function () { return file_discovery_js_1.collectWorkspaceFiles; } });
+Object.defineProperty(exports, "IGNORED_NAMES", { enumerable: true, get: function () { return file_discovery_js_1.IGNORED_NAMES; } });
+Object.defineProperty(exports, "MAX_PARSE_BYTES", { enumerable: true, get: function () { return file_discovery_js_1.MAX_PARSE_BYTES; } });
+Object.defineProperty(exports, "MAX_PARSE_BYTES_BY_LANGUAGE", { enumerable: true, get: function () { return file_discovery_js_1.MAX_PARSE_BYTES_BY_LANGUAGE; } });
+Object.defineProperty(exports, "PARSE_TOOL_NAME", { enumerable: true, get: function () { return file_discovery_js_1.PARSE_TOOL_NAME; } });
+Object.defineProperty(exports, "PARSE_TOOL_VERSION", { enumerable: true, get: function () { return file_discovery_js_1.PARSE_TOOL_VERSION; } });
+var language_utils_js_1 = require("./language-utils.js");
+Object.defineProperty(exports, "BINARY_SAMPLE_BYTES", { enumerable: true, get: function () { return language_utils_js_1.BINARY_SAMPLE_BYTES; } });
+Object.defineProperty(exports, "SOURCE_LANGUAGE_BY_EXTENSION", { enumerable: true, get: function () { return language_utils_js_1.SOURCE_LANGUAGE_BY_EXTENSION; } });
+Object.defineProperty(exports, "MIME_TYPE_BY_EXTENSION", { enumerable: true, get: function () { return language_utils_js_1.MIME_TYPE_BY_EXTENSION; } });
+Object.defineProperty(exports, "buildFileSha256", { enumerable: true, get: function () { return language_utils_js_1.buildFileSha256; } });
+Object.defineProperty(exports, "inferLanguage", { enumerable: true, get: function () { return language_utils_js_1.inferLanguage; } });
+Object.defineProperty(exports, "inferMimeType", { enumerable: true, get: function () { return language_utils_js_1.inferMimeType; } });
+Object.defineProperty(exports, "isBinaryBuffer", { enumerable: true, get: function () { return language_utils_js_1.isBinaryBuffer; } });
+Object.defineProperty(exports, "normalizeExtension", { enumerable: true, get: function () { return language_utils_js_1.normalizeExtension; } });
+Object.defineProperty(exports, "readSampleBuffer", { enumerable: true, get: function () { return language_utils_js_1.readSampleBuffer; } });
+var ts_resolver_js_1 = require("./ts-resolver.js");
+Object.defineProperty(exports, "loadTypeScriptResolverConfigs", { enumerable: true, get: function () { return ts_resolver_js_1.loadTypeScriptResolverConfigs; } });
+Object.defineProperty(exports, "normalizeWorkspaceRelativePath", { enumerable: true, get: function () { return ts_resolver_js_1.normalizeWorkspaceRelativePath; } });
+var index_js_1 = require("./parsers/index.js");
+Object.defineProperty(exports, "parseWorkspaceFileSemantics", { enumerable: true, get: function () { return index_js_1.parseWorkspaceFileSemantics; } });

package/dist/language-utils.d.ts

@@ -0,0 +1,10 @@
+export declare const SOURCE_LANGUAGE_BY_EXTENSION: Record<string, string>;
+export declare const MIME_TYPE_BY_EXTENSION: Record<string, string>;
+export declare const BINARY_SAMPLE_BYTES = 8192;
+export declare function normalizeExtension(fileName: string): string | null;
+export declare function inferLanguage(extension: string | null): string | null;
+export declare function inferMimeType(extension: string | null): string | null;
+export declare function isBinaryBuffer(buffer: Buffer): boolean;
+export declare function readSampleBuffer(filePath: string, sizeBytes: number): Promise<Buffer<ArrayBuffer>>;
+export declare function buildFileSha256(content: Buffer | string): string;
+//# sourceMappingURL=language-utils.d.ts.map

package/dist/language-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-utils.d.ts","sourceRoot":"","sources":["../src/language-utils.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,4BAA4B,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAY/D,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAUzD,CAAC;AAEF,eAAO,MAAM,mBAAmB,OAAO,CAAC;AAExC,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,iBAGlD;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,iBAGrD;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,iBAGrD;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,WAK5C;AAED,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,gCASzE;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,UAEvD"}

package/dist/language-utils.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BINARY_SAMPLE_BYTES = exports.MIME_TYPE_BY_EXTENSION = exports.SOURCE_LANGUAGE_BY_EXTENSION = void 0;
+exports.normalizeExtension = normalizeExtension;
+exports.inferLanguage = inferLanguage;
+exports.inferMimeType = inferMimeType;
+exports.isBinaryBuffer = isBinaryBuffer;
+exports.readSampleBuffer = readSampleBuffer;
+exports.buildFileSha256 = buildFileSha256;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+exports.SOURCE_LANGUAGE_BY_EXTENSION = {
+    ts: "TypeScript",
+    tsx: "TypeScript",
+    js: "JavaScript",
+    jsx: "JavaScript",
+    dart: "Dart",
+    php: "PHP",
+    py: "Python",
+    java: "Java",
+    kt: "Kotlin",
+    kts: "Kotlin",
+    po: "Gettext",
+};
+exports.MIME_TYPE_BY_EXTENSION = {
+    ts: "text/plain",
+    tsx: "text/plain",
+    js: "text/javascript",
+    jsx: "text/javascript",
+    dart: "text/plain",
+    php: "text/x-php",
+    java: "text/x-java-source",
+    kt: "text/x-kotlin",
+    kts: "text/x-kotlin",
+};
+exports.BINARY_SAMPLE_BYTES = 8192;
+function normalizeExtension(fileName) {
+    const extension = node_path_1.default.extname(fileName).slice(1).trim().toLowerCase();
+    return extension || null;
+}
+function inferLanguage(extension) {
+    if (!extension)
+        return null;
+    return exports.SOURCE_LANGUAGE_BY_EXTENSION[extension] ?? null;
+}
+function inferMimeType(extension) {
+    if (!extension)
+        return null;
+    return exports.MIME_TYPE_BY_EXTENSION[extension] ?? null;
+}
+function isBinaryBuffer(buffer) {
+    for (const byte of buffer) {
+        if (byte === 0)
+            return true;
+    }
+    return false;
+}
+async function readSampleBuffer(filePath, sizeBytes) {
+    const handle = await (0, promises_1.open)(filePath, "r");
+    try {
+        const buffer = Buffer.alloc(Math.min(sizeBytes, exports.BINARY_SAMPLE_BYTES));
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        return buffer.subarray(0, bytesRead);
+    }
+    finally {
+        await handle.close();
+    }
+}
+function buildFileSha256(content) {
+    return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+}

package/dist/parsers/dart.d.ts

@@ -0,0 +1,4 @@
+import type { WorkspaceFileCandidate } from "../file-discovery.js";
+import { type ParsedWorkspaceSemantics } from "./types.js";
+export declare function parseDartFile(file: WorkspaceFileCandidate, filePathSet: Set<string>, projectImportId: string): Promise<ParsedWorkspaceSemantics>;
+//# sourceMappingURL=dart.d.ts.map

package/dist/parsers/dart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dart.d.ts","sourceRoot":"","sources":["../../src/parsers/dart.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEnE,OAAO,EAAmE,KAAK,wBAAwB,EAA2E,MAAM,YAAY,CAAC;AAsBrM,wBAAsB,aAAa,CACjC,IAAI,EAAE,sBAAsB,EAC5B,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,wBAAwB,CAAC,CA0EnC"}