metascope 0.1.0 → 0.2.0

package/dist/lib/utilities/license-identification.js

@@ -0,0 +1,141 @@
+import spdxLicenseList from "spdx-license-list/full.js";
+//#region src/lib/utilities/license-identification.ts
+/**
+* License identification using Dice coefficient on bigrams.
+*
+* Compares plain-text license file content against the full SPDX license list
+* to identify the best-matching SPDX license identifier. Returns a standard
+* SPDX license URL (e.g. "https://spdx.org/licenses/MIT").
+*
+* Handles:
+*   - Standard license texts (MIT, BSD, Apache, etc.)
+*   - GNU family licenses via header pattern matching (LGPL, AGPL)
+*   - Markdown-formatted license files (strips headings, tables, links)
+*   - YAML front matter stripping
+*/
+/** Minimum similarity score to consider a match. */
+const CONFIDENCE_THRESHOLD = .75;
+/**
+* Identify the SPDX license that best matches the given text.
+* Returns the best match with confidence score, or undefined if no match
+* exceeds the confidence threshold.
+*/
+function identifyLicense(text) {
+	const headerMatch = identifyByHeader(text);
+	if (headerMatch) return headerMatch;
+	const normalizedInput = normalizeInput(text);
+	if (normalizedInput.length < 2) return void 0;
+	const inputBigramsMap = computeBigrams(normalizedInput);
+	const inputTotal = normalizedInput.length - 1;
+	let bestMatch;
+	let bestScore = 0;
+	for (const { bigramsMap, normalized, spdxId, totalBigrams } of getNormalizedLicenses()) {
+		if (normalizedInput === normalized) return {
+			confidence: 1,
+			spdxId
+		};
+		const score = diceCoefficientCached(inputBigramsMap, inputTotal, bigramsMap, totalBigrams);
+		if (score > bestScore) {
+			bestScore = score;
+			bestMatch = {
+				confidence: score,
+				spdxId
+			};
+		}
+	}
+	if (bestMatch && bestMatch.confidence >= CONFIDENCE_THRESHOLD) return bestMatch;
+}
+/**
+* Strip YAML front matter (--- delimited blocks at the start of a file).
+*/
+function stripFrontMatter(text) {
+	if (text.startsWith("---")) {
+		const end = text.indexOf("---", 3);
+		if (end !== -1) return text.slice(end + 3);
+	}
+	return text;
+}
+/**
+* Normalize license text for comparison.
+* Follows SPDX matching guidelines: collapse whitespace, strip copyright lines,
+* remove URLs, lowercase.
+*/
+function normalizeText(text) {
+	return text.replaceAll(/^#+\s+/gm, "").replaceAll(/^copyright.*$/gim, "").replaceAll(/^\|.*\|$/gm, "").replaceAll(/^[-|:\s]+$/gm, "").replaceAll(/https?:\/\/\S+/g, "").replaceAll(/\S+@\S+/g, "").replaceAll(/[[\]()]/g, " ").replaceAll(/\s+/g, " ").trim().toLowerCase();
+}
+/**
+* Normalize input text (user-provided license file).
+* Applies additional cleanup beyond what reference texts need.
+*/
+function normalizeInput(text) {
+	return normalizeText(stripFrontMatter(text));
+}
+/**
+* Compute bigrams (2-character substrings) of a string.
+*/
+function computeBigrams(text) {
+	const map = /* @__PURE__ */ new Map();
+	for (let index = 0; index < text.length - 1; index++) {
+		const pair = text.slice(index, index + 2);
+		map.set(pair, (map.get(pair) ?? 0) + 1);
+	}
+	return map;
+}
+let normalizedLicenses;
+function getNormalizedLicenses() {
+	normalizedLicenses ??= Object.entries(spdxLicenseList).map(([spdxId, entry]) => {
+		const normalized = normalizeText(entry.licenseText);
+		return {
+			bigramsMap: computeBigrams(normalized),
+			normalized,
+			spdxId,
+			totalBigrams: normalized.length - 1
+		};
+	});
+	return normalizedLicenses;
+}
+/**
+* Compute the Dice coefficient using pre-computed bigrams for one side.
+*/
+function diceCoefficientCached(inputBigrams, inputTotal, referenceBigrams, referenceTotal) {
+	let intersection = 0;
+	for (const [pair, countA] of inputBigrams) {
+		const countB = referenceBigrams.get(pair);
+		if (countB !== void 0) intersection += Math.min(countA, countB);
+	}
+	return 2 * intersection / (inputTotal + referenceTotal);
+}
+/**
+* Title-based identification for GNU licenses whose SPDX templates embed
+* combined texts (e.g. LGPL-3.0-only = LGPL supplement + full GPL), making
+* Dice coefficient unreliable against real-world standalone files.
+* Only checks the first 500 characters to avoid matching references in
+* unrelated license texts (e.g. CeCILL-2.1 mentions AGPL in its body).
+*/
+const HEADER_PATTERNS = [
+	{
+		pattern: /gnu lesser general public license\s+version 3/i,
+		spdxId: "LGPL-3.0-only"
+	},
+	{
+		pattern: /gnu lesser general public license\s+version 2\.1/i,
+		spdxId: "LGPL-2.1-only"
+	},
+	{
+		pattern: /gnu lesser general public license\s+version 2(?:\.0)?(?!\.\d)/i,
+		spdxId: "LGPL-2.0-only"
+	},
+	{
+		pattern: /gnu affero general public license\s+version 3/i,
+		spdxId: "AGPL-3.0-only"
+	}
+];
+function identifyByHeader(text) {
+	const header = text.slice(0, 500);
+	for (const { pattern, spdxId } of HEADER_PATTERNS) if (pattern.test(header)) return {
+		confidence: 1,
+		spdxId
+	};
+}
+//#endregion
+export { identifyLicense };

package/dist/lib/utilities/schema-primitives.js

@@ -0,0 +1,47 @@
+import is from "@sindresorhus/is";
+import { z } from "zod";
+//#region src/lib/utilities/schema-primitives.ts
+/**
+* Shared Zod schema primitives for parser schemas.
+*
+* These handle common coercions:
+*   - Empty/whitespace-only strings → undefined
+*   - URL validation with empty → undefined fallback
+*   - String arrays with empty-element filtering
+*/
+/**
+* A string that treats empty or whitespace-only values as undefined.
+* Use `.optional()` on the result for optional fields.
+*/
+const nonEmptyString = z.preprocess((value) => {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}, z.string().optional());
+/**
+* A URL string that treats empty/whitespace as undefined.
+* Does not reject invalid URLs — just ensures non-empty.
+* Use z.url() in place of this if strict URL validation is desired.
+*/
+const optionalUrl = nonEmptyString.describe("A URL string");
+/**
+* An array of strings, filtering out empty/whitespace-only elements.
+*/
+const stringArray = z.preprocess((value) => {
+	if (!Array.isArray(value)) return [];
+	return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}, z.array(z.string()));
+/**
+* Parse a JSON string into a plain object.
+* Returns `undefined` for malformed JSON or non-object values (arrays, primitives).
+*/
+function parseJsonRecord(content) {
+	try {
+		const parsed = JSON.parse(content);
+		return is.plainObject(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { nonEmptyString, optionalUrl, parseJsonRecord, stringArray };

package/dist/lib/utilities/template-helpers.d.ts

@@ -0,0 +1,135 @@
+import { CodeMetaJson } from "../sources/codemeta-json.js";
+import { NodePackageJsonData } from "../sources/node-package-json.js";
+
+//#region src/lib/utilities/template-helpers.d.ts
+declare namespace template_helpers_d_exports {
+  export { REPLACEMENTS, collectArrayField, collectField, dependencyNames, ensureArray, firstOf, hasDependencyWithId, isAuthoredBy, isOnGithubAccountOf, isValidUrl, mixedStringsToArray, nonEmpty, splitCommaSeparated, stripNamespace, stripUndefined, toAlias, toBasicLicense, toBasicLicenses, toBasicNames, toDelimitedString, toLocalUrl, toMarkdownLink, toMb, toStatus, toStatusLegacy, usesPnpm };
+}
+/**
+ * Extract the first element from a `OneOrMany` value.
+ *
+ * Metadata sources may return a single record or an array of records. This
+ * helper normalizes access so you can safely retrieve the first record
+ * regardless of cardinality.
+ */
+declare function firstOf<T>(value: T | T[] | undefined): T | undefined;
+/**
+ * Wrap a value in an array if it isn't one already.
+ * Returns an empty array for `undefined` or `null`.
+ */
+declare function ensureArray<T>(value: null | T | T[] | undefined): T[];
+/**
+ * Collect values from all records in a `OneOrMany<SourceRecord<D>>` source.
+ * Runs the accessor on each record's `.data` and returns all non-undefined results.
+ *
+ * Useful for extracting a specific field from sources that may contain multiple records
+ * (e.g. multiple Cargo.toml files in a workspace).
+ */
+declare function collectField<T extends {
+  data: unknown;
+}, R>(source: T | T[] | undefined, accessor: (data: T['data']) => R | undefined): R[];
+/**
+ * Collect and flatten array values from all records in a `OneOrMany<SourceRecord<D>>` source.
+ * Runs the accessor on each record's `.data` and flattens the resulting arrays.
+ */
+declare function collectArrayField<T extends {
+  data: unknown;
+}, R>(source: T | T[] | undefined, accessor: (data: T['data']) => R[] | undefined): R[];
+/**
+ * Return the array if non-empty, otherwise undefined.
+ * Useful for converting empty collection results to undefined before `stripUndefined`.
+ */
+declare function nonEmpty<T>(array: T[]): T[] | undefined;
+/**
+ * Split a string on commas, trimming each part and filtering out empty strings.
+ * Returns an empty array for `undefined` or empty input.
+ */
+declare function splitCommaSeparated(value: string | undefined): string[];
+/**
+ * Join an array of strings with a delimiter, filtering out undefined values.
+ */
+declare function toDelimitedString(source: Array<string | undefined> | string | string[] | undefined, delimiter?: string): string | undefined;
+/**
+ * Convert a URL or path to a markdown link using its basename as the label.
+ */
+declare function toMarkdownLink(value: string | undefined): string | undefined;
+/**
+ * Convert bytes to megabytes (rounded).
+ * (MB, not MiB.)
+ */
+declare function toMb(bytes: unknown): number | undefined;
+/**
+ * Strip the namespace or directory prefix from a package name or path.
+ */
+declare function stripNamespace(value: string): string;
+/**
+ * Convert a package name to a human-friendly alias using title case
+ * and brand-name corrections.
+ */
+declare function toAlias(value: string | undefined): string | undefined;
+declare const REPLACEMENTS: Map<string, string>;
+/**
+ * Takes any value and extracts all strings from it.
+ * Returns string[] if any strings were found, or undefined otherwise.
+ * Optionally performs case-insensitive string replacement with `replacements`.
+ */
+declare function mixedStringsToArray(value: unknown, replacements?: Map<string, string>): string[] | undefined;
+/**
+ * Convert a filename or relative path to a local `file://` URL rooted at `repoPath`.
+ */
+declare function toLocalUrl(value: string | undefined, repoPath: string | undefined): string | undefined;
+/**
+ * Recursively removes `undefined` values and empty objects from an object.
+ * Only recurses into plain objects and arrays. Non-plain objects (like Date)
+ * are preserved as-is.
+ * Array elements that are `undefined` are also removed.
+ * Returns `undefined` if the entire input becomes empty after stripping.
+ */
+declare function stripUndefined<T>(value: T): T;
+/**
+ * Strip the SPDX license URL prefix, returning just the license identifier.
+ */
+declare function toBasicLicense(source: string | undefined): string | undefined;
+/**
+ * Normalize one or more license values to plain SPDX identifiers, stripping URL prefixes.
+ */
+declare function toBasicLicenses(...sources: Array<string | string[] | undefined>): string[] | undefined;
+type CodeMetaPersonOrOrg = NonNullable<CodeMetaJson['author']>[number];
+/**
+ * Extract display names from an array of `CodeMetaPersonOrOrg`.
+ */
+declare function toBasicNames(source: CodeMetaPersonOrOrg[] | undefined): string[] | undefined;
+/**
+ * Check id a project uses a specific dependency
+ */
+declare function hasDependencyWithId(id: string, codemeta: CodeMetaJson): boolean;
+/**
+ * Simple list of all dependencies
+ */
+declare function dependencyNames(codemeta: CodeMetaJson, filter?: 'all' | 'dev' | 'prod'): string[] | undefined;
+/**
+ * Check if the project uses pnpm as its package manager.
+ */
+declare function usesPnpm(packageJson: NodePackageJsonData): boolean;
+/**
+ * True if project was authored by specific person(s).
+ */
+declare function isAuthoredBy(codemetaAuthorName?: CodeMetaPersonOrOrg | CodeMetaPersonOrOrg[], expectedAuthorName?: string | string[]): boolean | undefined;
+/**
+ * True if project is on a specific GitHub account(s).
+ */
+declare function isOnGithubAccountOf(codeRepository?: string, githubUserName?: string | string[]): boolean | undefined;
+/**
+ * Legacy heuristic project status based on authorship and GitHub account.
+ */
+declare function toStatusLegacy(codeRepository?: string, codemetaAuthorName?: CodeMetaPersonOrOrg | CodeMetaPersonOrOrg[], authorName?: string | string[], githubUserName?: string | string[]): /** It's a fork on GitHub */('fork' /** I am original author, local or on github */ | 'source' /** Someone else's local code */ | 'unmaintained') | undefined;
+/**
+ * Heuristic project status based on authorship and GitHub account.
+ */
+declare function toStatus(codeRepository?: string, codemetaAuthorName?: CodeMetaPersonOrOrg | CodeMetaPersonOrOrg[], codemetaContributorOrMaintainerName?: CodeMetaPersonOrOrg | CodeMetaPersonOrOrg[], isGitHubFork?: boolean, myAuthorName?: string | string[], myGithubUserName?: string | string[]): 'author' /** I wrote the repo */ | 'maintainer' /** I contribute or help maintain it */ | 'observer' /** I look at this repo */ | 'unknown' /** It's unclear */;
+/**
+ * True if valid url
+ */
+declare function isValidUrl(value: string): boolean;
+//#endregion
+export { template_helpers_d_exports };

package/dist/lib/utilities/template-helpers.js

@@ -0,0 +1,310 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import path from "node:path";
+import is from "@sindresorhus/is";
+import { replaceCore } from "case-police";
+import abbreviates from "case-police/dict/abbreviates.json";
+import brands from "case-police/dict/brands.json";
+import general from "case-police/dict/general.json";
+import products from "case-police/dict/products.json";
+import softwares from "case-police/dict/softwares.json";
+import { titleCase } from "scule";
+//#region src/lib/utilities/template-helpers.ts
+var template_helpers_exports = /* @__PURE__ */ __exportAll({
+	REPLACEMENTS: () => REPLACEMENTS,
+	collectArrayField: () => collectArrayField,
+	collectField: () => collectField,
+	dependencyNames: () => dependencyNames,
+	ensureArray: () => ensureArray,
+	firstOf: () => firstOf,
+	hasDependencyWithId: () => hasDependencyWithId,
+	isAuthoredBy: () => isAuthoredBy,
+	isOnGithubAccountOf: () => isOnGithubAccountOf,
+	isValidUrl: () => isValidUrl,
+	mixedStringsToArray: () => mixedStringsToArray,
+	nonEmpty: () => nonEmpty,
+	splitCommaSeparated: () => splitCommaSeparated,
+	stripNamespace: () => stripNamespace,
+	stripUndefined: () => stripUndefined,
+	toAlias: () => toAlias,
+	toBasicLicense: () => toBasicLicense,
+	toBasicLicenses: () => toBasicLicenses,
+	toBasicNames: () => toBasicNames,
+	toDelimitedString: () => toDelimitedString,
+	toLocalUrl: () => toLocalUrl,
+	toMarkdownLink: () => toMarkdownLink,
+	toMb: () => toMb,
+	toStatus: () => toStatus,
+	toStatusLegacy: () => toStatusLegacy,
+	usesPnpm: () => usesPnpm
+});
+const casePoliceDict = {
+	...abbreviates,
+	...brands,
+	...general,
+	...products,
+	...softwares
+};
+/**
+* Extract the first element from a `OneOrMany` value.
+*
+* Metadata sources may return a single record or an array of records. This
+* helper normalizes access so you can safely retrieve the first record
+* regardless of cardinality.
+*/
+function firstOf(value) {
+	if (value === void 0) return void 0;
+	return Array.isArray(value) ? value[0] : value;
+}
+/**
+* Wrap a value in an array if it isn't one already.
+* Returns an empty array for `undefined` or `null`.
+*/
+function ensureArray(value) {
+	if (value === void 0 || value === null) return [];
+	return Array.isArray(value) ? value : [value];
+}
+/**
+* Collect values from all records in a `OneOrMany<SourceRecord<D>>` source.
+* Runs the accessor on each record's `.data` and returns all non-undefined results.
+*
+* Useful for extracting a specific field from sources that may contain multiple records
+* (e.g. multiple Cargo.toml files in a workspace).
+*/
+function collectField(source, accessor) {
+	if (source === void 0) return [];
+	return (Array.isArray(source) ? source : [source]).map((record) => accessor(record.data)).filter((value) => value !== void 0);
+}
+/**
+* Collect and flatten array values from all records in a `OneOrMany<SourceRecord<D>>` source.
+* Runs the accessor on each record's `.data` and flattens the resulting arrays.
+*/
+function collectArrayField(source, accessor) {
+	if (source === void 0) return [];
+	return (Array.isArray(source) ? source : [source]).flatMap((record) => accessor(record.data) ?? []);
+}
+/**
+* Return the array if non-empty, otherwise undefined.
+* Useful for converting empty collection results to undefined before `stripUndefined`.
+*/
+function nonEmpty(array) {
+	return array.length > 0 ? array : void 0;
+}
+/**
+* Split a string on commas, trimming each part and filtering out empty strings.
+* Returns an empty array for `undefined` or empty input.
+*/
+function splitCommaSeparated(value) {
+	if (value === void 0) return [];
+	return value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+/**
+* Join an array of strings with a delimiter, filtering out undefined values.
+*/
+function toDelimitedString(source, delimiter = ", ") {
+	if (source === void 0) return void 0;
+	if (Array.isArray(source)) {
+		const filtered = source.filter((s) => s !== void 0);
+		return filtered.length > 0 ? filtered.join(delimiter) : void 0;
+	}
+	return source;
+}
+/**
+* Convert a URL or path to a markdown link using its basename as the label.
+*/
+function toMarkdownLink(value) {
+	if (is.nonEmptyStringAndNotWhitespace(value)) return `[${path.basename(value)}](${value})`;
+}
+/**
+* Convert bytes to megabytes (rounded).
+* (MB, not MiB.)
+*/
+function toMb(bytes) {
+	if (is.positiveNumber(bytes)) return Math.round(bytes / 1e3 / 1e3 * 100) / 100;
+}
+/**
+* Strip the namespace or directory prefix from a package name or path.
+*/
+function stripNamespace(value) {
+	return path.basename(value);
+}
+/**
+* Convert a package name to a human-friendly alias using title case
+* and brand-name corrections.
+*/
+function toAlias(value) {
+	if (is.nonEmptyString(value)) {
+		const result = titleCase(stripNamespace(value)).replaceAll(/ {2,}/g, " ").trim();
+		return replaceCore(result, casePoliceDict) ?? result;
+	}
+}
+/**
+* Escape a string for use in a regular expression.
+*/
+function escapeRegExp(string_) {
+	return string_.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+}
+const REPLACEMENTS = new Map([["javascript", "JavaScript"], ["typescript", "TypeScript"]]);
+/**
+* Takes any value and extracts all strings from it.
+* Returns string[] if any strings were found, or undefined otherwise.
+* Optionally performs case-insensitive string replacement with `replacements`.
+*/
+function mixedStringsToArray(value, replacements) {
+	if (value === void 0) return;
+	const filtered = ensureArray(value).filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => {
+		if (!replacements) return item;
+		let result = item;
+		for (const [search, replace] of replacements) {
+			const pattern = new RegExp(escapeRegExp(search), "gi");
+			result = result.replace(pattern, replace);
+		}
+		return result;
+	});
+	return filtered.length > 0 ? filtered : void 0;
+}
+/**
+* Convert a filename or relative path to a local `file://` URL rooted at `repoPath`.
+*/
+function toLocalUrl(value, repoPath) {
+	if (value === void 0 || repoPath === void 0) return;
+	const relativePath = path.join(repoPath, path.basename(value)).replaceAll("\\", "/");
+	return `file://${relativePath.startsWith("/") ? "" : "/"}${relativePath}`;
+}
+/**
+* Recursively removes `undefined` values and empty objects from an object.
+* Only recurses into plain objects and arrays. Non-plain objects (like Date)
+* are preserved as-is.
+* Array elements that are `undefined` are also removed.
+* Returns `undefined` if the entire input becomes empty after stripping.
+*/
+function stripUndefined(value) {
+	if (Array.isArray(value)) {
+		const filtered = value.filter((item) => item !== void 0).map((item) => stripUndefined(item)).filter((item) => item !== void 0);
+		return filtered.length > 0 ? filtered : void 0;
+	}
+	if (is.plainObject(value)) {
+		const result = {};
+		let hasKeys = false;
+		for (const [key, theValue] of Object.entries(value)) if (theValue !== void 0) {
+			const stripped = stripUndefined(theValue);
+			if (stripped !== void 0) {
+				result[key] = stripped;
+				hasKeys = true;
+			}
+		}
+		if (!hasKeys) return void 0;
+		return result;
+	}
+	return value;
+}
+/**
+* Strip the SPDX license URL prefix, returning just the license identifier.
+*/
+function toBasicLicense(source) {
+	if (source === void 0) return;
+	return source.replace("http://spdx.org/licenses/", "").replace("https://spdx.org/licenses/", "");
+}
+/**
+* Normalize one or more license values to plain SPDX identifiers, stripping URL prefixes.
+*/
+function toBasicLicenses(...sources) {
+	const result = sources.flat().filter((value) => value !== void 0).map((value) => toBasicLicense(value)).filter((value) => value !== void 0);
+	return result.length === 0 ? void 0 : result;
+}
+/**
+* Extract a display name from a `CodeMetaPersonOrOrg`.
+*/
+function toBasicName(basicPersonOrOrg) {
+	if (basicPersonOrOrg === void 0) return;
+	if (basicPersonOrOrg.name !== void 0) return basicPersonOrOrg.name;
+	return toDelimitedString([basicPersonOrOrg.givenName, basicPersonOrOrg.familyName], " ");
+}
+/**
+* Extract display names from an array of `CodeMetaPersonOrOrg`.
+*/
+function toBasicNames(source) {
+	if (source === void 0) return;
+	const result = source.map((basicPersonOrOrg) => toBasicName(basicPersonOrOrg)).filter((value) => value !== void 0);
+	return result.length > 0 ? result : void 0;
+}
+/**
+* Check id a project uses a specific dependency
+*/
+function hasDependencyWithId(id, codemeta) {
+	return [...codemeta.softwareSuggestions ?? [], ...codemeta.softwareRequirements ?? []].some(({ identifier, name }) => identifier === id || name === id);
+}
+/**
+* Simple list of all dependencies
+*/
+function dependencyNames(codemeta, filter = "all") {
+	return nonEmpty([...new Set([...filter === "prod" ? [] : codemeta.softwareSuggestions ?? [], ...filter === "dev" ? [] : codemeta.softwareRequirements ?? []].map((value) => value.name ?? value.identifier ?? void 0).filter((value) => value !== void 0))].toSorted());
+}
+/**
+* Check if the project uses pnpm as its package manager.
+*/
+function usesPnpm(packageJson) {
+	const first = firstOf(packageJson);
+	if (!first) return false;
+	return first.data.packageManager?.toLowerCase().startsWith("pnpm") ?? Object.hasOwn(first.data.engines ?? {}, "pnpm");
+}
+/**
+* True if project was authored by specific person(s).
+*/
+function isAuthoredBy(codemetaAuthorName, expectedAuthorName) {
+	if (codemetaAuthorName === void 0 || expectedAuthorName === void 0 || is.emptyArray(codemetaAuthorName) || is.emptyArray(expectedAuthorName)) return;
+	const authors = new Set(ensureArray(expectedAuthorName).map((name) => name.toLocaleLowerCase().trim()));
+	return (toBasicNames(ensureArray(codemetaAuthorName))?.map((name) => name.toLocaleLowerCase().trim()))?.some((name) => authors.has(name));
+}
+/**
+* True if project is on a specific GitHub account(s).
+*/
+function isOnGithubAccountOf(codeRepository, githubUserName) {
+	if (codeRepository === void 0 || githubUserName === void 0) return;
+	const cleanRepo = codeRepository.toLocaleLowerCase().trim();
+	if (!cleanRepo.includes("github.com/")) return false;
+	return ensureArray(githubUserName).some((userName) => cleanRepo.includes(`/${userName.toLocaleLowerCase().trim()}/`));
+}
+/**
+* Legacy heuristic project status based on authorship and GitHub account.
+*/
+function toStatusLegacy(codeRepository, codemetaAuthorName, authorName, githubUserName) {
+	if (codeRepository === void 0 || authorName === void 0 || githubUserName === void 0) return;
+	const isAuthoredByAuthorName = isAuthoredBy(codemetaAuthorName, authorName);
+	const isOnGithub = isOnGithubAccountOf(codeRepository, githubUserName);
+	if (isAuthoredByAuthorName === void 0 || isOnGithub === void 0) return;
+	return !isAuthoredByAuthorName && isOnGithub ? "fork" : isAuthoredByAuthorName ? "source" : "unmaintained";
+}
+/**
+* Heuristic project status based on authorship and GitHub account.
+*/
+function toStatus(codeRepository, codemetaAuthorName, codemetaContributorOrMaintainerName, isGitHubFork, myAuthorName, myGithubUserName) {
+	const author = isAuthoredBy(codemetaAuthorName, myAuthorName);
+	const maintainer = isAuthoredBy(codemetaContributorOrMaintainerName, myAuthorName);
+	const githubStatus = isOnGithubAccountOf(codeRepository, myGithubUserName);
+	const github = githubStatus === void 0 ? "missing" : githubStatus ? isGitHubFork ? "my-fork" : "my-source" : isGitHubFork ? "their-fork" : "their-source";
+	const me = author === true ? "author" : maintainer === true ? "maintainer" : "missing";
+	if (github === "missing" && me === "author") return "author";
+	if (github === "missing" && me === "maintainer") return "maintainer";
+	if (github === "missing" && me === "missing") return "unknown";
+	if (github === "my-fork" && me === "author") return "maintainer";
+	if (github === "my-fork" && me === "maintainer") return "maintainer";
+	if (github === "my-fork" && me === "missing") return "observer";
+	if (github === "my-source" && me === "author") return "author";
+	if (github === "my-source" && me === "maintainer") return "maintainer";
+	if (github === "my-source" && me === "missing") return "author";
+	if (github === "their-fork" && me === "author") return "maintainer";
+	if (github === "their-fork" && me === "maintainer") return "maintainer";
+	if (github === "their-fork" && me === "missing") return "observer";
+	if (github === "their-source" && me === "author") return "author";
+	if (github === "their-source" && me === "maintainer") return "maintainer";
+	if (github === "their-source" && me === "missing") return "observer";
+	return "unknown";
+}
+/**
+* True if valid url
+*/
+function isValidUrl(value) {
+	return is.urlString(value);
+}
+//#endregion
+export { REPLACEMENTS, collectArrayField, collectField, dependencyNames, ensureArray, firstOf, hasDependencyWithId, isAuthoredBy, isOnGithubAccountOf, isValidUrl, mixedStringsToArray, nonEmpty, splitCommaSeparated, stripUndefined, template_helpers_exports, toAlias, toBasicLicenses, toBasicNames, toLocalUrl, toMb, toStatus, toStatusLegacy, usesPnpm };

package/dist/lib/utilities/tree-sitter-wasm.js

@@ -0,0 +1,30 @@
+import { fileURLToPath } from "node:url";
+import { Language, Parser } from "web-tree-sitter";
+//#region src/lib/utilities/tree-sitter-wasm.ts
+/**
+* Shared WASM loader for web-tree-sitter.
+* Provides singleton initialization and cached language loading.
+*/
+let initialized = false;
+/** Initialize web-tree-sitter (idempotent) and return a new Parser instance. */
+async function initParser() {
+	if (!initialized) {
+		await Parser.init();
+		initialized = true;
+	}
+	return new Parser();
+}
+let pythonLanguage;
+/** Get the Python language (cached after first load). */
+async function getPythonLanguage() {
+	pythonLanguage ??= await Language.load(fileURLToPath(new URL("../../grammars/tree-sitter-python.wasm", import.meta.url)));
+	return pythonLanguage;
+}
+let rubyLanguage;
+/** Get the Ruby language (cached after first load). */
+async function getRubyLanguage() {
+	rubyLanguage ??= await Language.load(fileURLToPath(new URL("../../grammars/tree-sitter-ruby.wasm", import.meta.url)));
+	return rubyLanguage;
+}
+//#endregion
+export { getPythonLanguage, getRubyLanguage, initParser };