metascope 0.1.0 → 0.2.0

package/dist/lib/sources/python-setup-cfg.js

@@ -0,0 +1,106 @@
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { nonEmptyString, optionalUrl, stringArray } from "../utilities/schema-primitives.js";
+import { splitCommaSeparated } from "../utilities/template-helpers.js";
+import { parseConfigparser, splitMultiline } from "../parsers/configparser-parser.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { z } from "zod";
+//#region src/lib/sources/python-setup-cfg.ts
+const setupCfgDataSchema = z.object({
+	author: nonEmptyString,
+	author_email: nonEmptyString,
+	classifiers: stringArray,
+	description: nonEmptyString,
+	download_url: optionalUrl,
+	extras_require: z.record(z.string(), z.array(z.string())),
+	install_requires: stringArray,
+	keywords: z.array(z.string()).optional(),
+	license: nonEmptyString,
+	long_description: nonEmptyString,
+	maintainer: nonEmptyString,
+	maintainer_email: nonEmptyString,
+	name: nonEmptyString,
+	project_urls: z.record(z.string(), z.string()),
+	python_requires: nonEmptyString,
+	url: optionalUrl,
+	version: nonEmptyString
+});
+/** Simple string attributes to extract from [metadata]. */
+const STRING_ATTRS = new Set([
+	"author",
+	"author_email",
+	"description",
+	"download_url",
+	"license",
+	"long_description",
+	"maintainer",
+	"maintainer_email",
+	"name",
+	"url",
+	"version"
+]);
+/**
+* Parse a setup.cfg file and return structured metadata.
+*
+* Extracts fields from the `[metadata]` and `[options]` sections,
+* including multi-line values like classifiers and install_requires.
+*/
+function parse(source) {
+	const sections = parseConfigparser(source);
+	const metadata = sections.metadata ?? {};
+	const options = sections.options ?? {};
+	const data = {
+		author: void 0,
+		author_email: void 0,
+		classifiers: [],
+		description: void 0,
+		download_url: void 0,
+		extras_require: {},
+		install_requires: [],
+		keywords: void 0,
+		license: void 0,
+		long_description: void 0,
+		maintainer: void 0,
+		maintainer_email: void 0,
+		name: void 0,
+		project_urls: {},
+		python_requires: void 0,
+		url: void 0,
+		version: void 0
+	};
+	for (const key of STRING_ATTRS) {
+		const value = metadata[key];
+		if (value) Object.assign(data, { [key]: value });
+	}
+	if (metadata.classifiers) data.classifiers = splitMultiline(metadata.classifiers);
+	if (metadata.keywords) data.keywords = splitCommaSeparated(metadata.keywords);
+	if (metadata.project_urls) for (const line of splitMultiline(metadata.project_urls)) {
+		const eqIndex = line.indexOf("=");
+		if (eqIndex > 0) {
+			const label = line.slice(0, eqIndex).trim();
+			const url = line.slice(eqIndex + 1).trim();
+			if (url) data.project_urls[label] = url;
+		}
+	}
+	if (options.install_requires) data.install_requires = splitMultiline(options.install_requires);
+	if (options.python_requires) data.python_requires = options.python_requires;
+	const extrasSection = sections["options.extras_require"];
+	if (extrasSection) for (const [key, value] of Object.entries(extrasSection)) data.extras_require[key] = splitMultiline(value);
+	return setupCfgDataSchema.parse(data);
+}
+const pythonSetupCfgSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, ["setup.cfg"]);
+	},
+	key: "pythonSetupCfg",
+	async parse(input, context) {
+		return {
+			data: parse(await readFile(resolve(context.options.path, input), "utf8")),
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { pythonSetupCfgSource };

package/dist/lib/sources/python-setup-py.d.ts

@@ -0,0 +1,28 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { z } from "zod";
+
+//#region src/lib/sources/python-setup-py.d.ts
+/** Parsed setup.py metadata */
+declare const setupPyDataSchema: z.ZodObject<{
+  author: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  author_email: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  classifiers: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  description: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  download_url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  extras_require: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+  install_requires: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  license: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  long_description: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  maintainer: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  maintainer_email: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  project_urls: z.ZodRecord<z.ZodString, z.ZodString>;
+  python_requires: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  version: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+type SetupPyData = z.infer<typeof setupPyDataSchema>;
+type PythonSetupPyData = OneOrMany<SourceRecord<SetupPyData>> | undefined;
+//#endregion
+export { PythonSetupPyData };

package/dist/lib/sources/python-setup-py.js

@@ -0,0 +1,48 @@
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { nonEmptyString, optionalUrl, stringArray } from "../utilities/schema-primitives.js";
+import { parseSetupPy } from "../parsers/setup-py-parser.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { z } from "zod";
+//#region src/lib/sources/python-setup-py.ts
+/** Parsed setup.py metadata */
+const setupPyDataSchema = z.object({
+	author: nonEmptyString,
+	author_email: nonEmptyString,
+	classifiers: stringArray,
+	description: nonEmptyString,
+	download_url: optionalUrl,
+	extras_require: z.record(z.string(), z.array(z.string())),
+	install_requires: stringArray,
+	keywords: z.array(z.string()).optional(),
+	license: nonEmptyString,
+	long_description: nonEmptyString,
+	maintainer: nonEmptyString,
+	maintainer_email: nonEmptyString,
+	name: nonEmptyString,
+	project_urls: z.record(z.string(), z.string()),
+	python_requires: nonEmptyString,
+	url: optionalUrl,
+	version: nonEmptyString
+});
+/** Parse setup.py content and validate through the Zod schema. */
+async function parse(content) {
+	const data = await parseSetupPy(content);
+	return setupPyDataSchema.parse(data);
+}
+const pythonSetupPySource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, ["setup.py"]);
+	},
+	key: "pythonSetupPy",
+	async parse(input, context) {
+		return {
+			data: await parse(await readFile(resolve(context.options.path, input), "utf8")),
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { pythonSetupPySource };

package/dist/lib/sources/readme-file.d.ts

@@ -0,0 +1,11 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { z } from "zod";
+
+//#region src/lib/sources/readme-file.d.ts
+declare const readmeSchema: z.ZodObject<{
+  name: z.ZodString;
+}, z.core.$strip>;
+type Readme = z.infer<typeof readmeSchema>;
+type ReadmeFileData = OneOrMany<SourceRecord<Readme>> | undefined;
+//#endregion
+export { ReadmeFileData };

package/dist/lib/sources/readme-file.js

@@ -0,0 +1,55 @@
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { z } from "zod";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+//#region src/lib/sources/readme-file.ts
+const readmeSchema = z.object({ name: z.string() });
+/**
+* Recursively extract plain text from mdast phrasing content.
+*/
+function extractText(nodes) {
+	return nodes.map((node) => {
+		if ("value" in node) return node.value;
+		if ("children" in node) return extractText(node.children);
+		return "";
+	}).join("").trim();
+}
+/**
+* Extract the text content of the first H1 heading from markdown.
+*/
+function extractFirstH1(markdown) {
+	const tree = unified().use(remarkParse).parse(markdown);
+	for (const node of tree.children) if (node.type === "heading" && node.depth === 1) {
+		const text = extractText(node.children);
+		if (text.length > 0) return text;
+	}
+}
+/**
+* Parse a README file's content.
+* @param content - Raw file content (markdown).
+* @returns Parsed metadata, or `undefined` if no H1 heading is found.
+*/
+function parse(content) {
+	const name = extractFirstH1(content);
+	if (!name) return void 0;
+	return readmeSchema.parse({ name });
+}
+const readmeFileSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, ["README", "README.*"]);
+	},
+	key: "readmeFile",
+	async parse(input, context) {
+		const data = parse(await readFile(resolve(context.options.path, input), "utf8"));
+		if (data !== void 0) return {
+			data,
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { readmeFileSource };

package/dist/lib/sources/ruby-gemspec.d.ts

@@ -0,0 +1,44 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { z } from "zod";
+
+//#region src/lib/sources/ruby-gemspec.d.ts
+/** @public */
+declare const gemSpecSchema: z.ZodObject<{
+  authors: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  bindir: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  cert_chain: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  dependencies: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    requirements: z.ZodArray<z.ZodString>;
+    type: z.ZodEnum<{
+      development: "development";
+      runtime: "runtime";
+    }>;
+  }, z.core.$strip>>;
+  description: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  email: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+  executables: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  extensions: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  extra: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  extra_rdoc_files: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  files: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  homepage: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  license: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  licenses: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+  name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  platform: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  post_install_message: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  rdoc_options: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  require_paths: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  required_ruby_version: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  required_rubygems_version: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  signing_key: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  summary: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  test_files: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  version: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+type GemSpec = z.infer<typeof gemSpecSchema>;
+type RubyGemspecData = OneOrMany<SourceRecord<GemSpec>> | undefined;
+//#endregion
+export { RubyGemspecData };

package/dist/lib/sources/ruby-gemspec.js

@@ -0,0 +1,62 @@
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { nonEmptyString, optionalUrl, stringArray } from "../utilities/schema-primitives.js";
+import { parseGemspec } from "../parsers/gemspec-parser.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { z } from "zod";
+//#region src/lib/sources/ruby-gemspec.ts
+const gemSpecDependencySchema = z.object({
+	name: z.string(),
+	requirements: z.array(z.string()),
+	type: z.enum(["development", "runtime"])
+});
+/** @public */
+const gemSpecSchema = z.object({
+	authors: stringArray,
+	bindir: nonEmptyString,
+	cert_chain: stringArray,
+	dependencies: z.array(gemSpecDependencySchema),
+	description: nonEmptyString,
+	email: z.union([z.string(), z.array(z.string())]).optional(),
+	executables: stringArray,
+	extensions: stringArray,
+	extra: z.record(z.string(), z.unknown()),
+	extra_rdoc_files: stringArray,
+	files: stringArray,
+	homepage: optionalUrl,
+	license: nonEmptyString,
+	licenses: stringArray,
+	metadata: z.record(z.string(), z.string()),
+	name: nonEmptyString,
+	platform: nonEmptyString,
+	post_install_message: nonEmptyString,
+	rdoc_options: stringArray,
+	require_paths: stringArray,
+	required_ruby_version: nonEmptyString,
+	required_rubygems_version: nonEmptyString,
+	signing_key: nonEmptyString,
+	summary: nonEmptyString,
+	test_files: stringArray,
+	version: nonEmptyString
+});
+/** Parse gemspec content and validate through the Zod schema. */
+async function parse(content) {
+	const raw = await parseGemspec(content);
+	return gemSpecSchema.parse(raw);
+}
+const rubyGemspecSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, ["*.gemspec"]);
+	},
+	key: "rubyGemspec",
+	async parse(input, context) {
+		return {
+			data: await parse(await readFile(resolve(context.options.path, input), "utf8")),
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { rubyGemspecSource };

package/dist/lib/sources/rust-cargo-toml.d.ts

@@ -0,0 +1,40 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { z } from "zod";
+
+//#region src/lib/sources/rust-cargo-toml.d.ts
+declare const cargoTomlSchema: z.ZodObject<{
+  authors: z.ZodArray<z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+  }, z.core.$strip>>;
+  buildDependencies: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  categories: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  dependencies: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  description: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  devDependencies: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  documentation: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  edition: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  homepage: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  keywords: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  license: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  licenseFile: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  readme: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  repository: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  rustVersion: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  version: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  workspaceMembers: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type CargoToml = z.infer<typeof cargoTomlSchema>;
+type RustCargoTomlData = OneOrMany<SourceRecord<CargoToml>> | undefined;
+//#endregion
+export { RustCargoTomlData };

package/dist/lib/sources/rust-cargo-toml.js

@@ -0,0 +1,159 @@
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { nonEmptyString, optionalUrl, stringArray } from "../utilities/schema-primitives.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import is from "@sindresorhus/is";
+import { z } from "zod";
+import { parse } from "smol-toml";
+//#region src/lib/sources/rust-cargo-toml.ts
+/**
+* Source for Rust `Cargo.toml` manifest files.
+* These are TOML files used by the Cargo package manager. Metadata lives
+* primarily in the `[package]` table, with dependencies in `[dependencies]`,
+* `[dev-dependencies]`, and `[build-dependencies]`.
+*
+* Uses `smol-toml` for TOML parsing.
+* @see https://doc.rust-lang.org/cargo/reference/manifest.html
+*/
+const cargoTomlAuthorEntrySchema = z.object({
+	email: z.string().optional(),
+	name: z.string()
+});
+const cargoTomlDependencyEntrySchema = z.object({
+	name: z.string(),
+	version: z.string().optional()
+});
+const cargoTomlSchema = z.object({
+	authors: z.array(cargoTomlAuthorEntrySchema),
+	buildDependencies: z.array(cargoTomlDependencyEntrySchema),
+	categories: stringArray,
+	dependencies: z.array(cargoTomlDependencyEntrySchema),
+	description: nonEmptyString,
+	devDependencies: z.array(cargoTomlDependencyEntrySchema),
+	documentation: optionalUrl,
+	edition: nonEmptyString,
+	homepage: optionalUrl,
+	keywords: stringArray,
+	license: nonEmptyString,
+	licenseFile: nonEmptyString,
+	name: nonEmptyString,
+	readme: nonEmptyString,
+	repository: optionalUrl,
+	rustVersion: nonEmptyString,
+	version: nonEmptyString,
+	workspaceMembers: stringArray
+});
+/**
+* Parse a `Cargo.toml` content string into a structured object.
+* Returns undefined if the TOML is malformed.
+*/
+function parse$1(content) {
+	let data;
+	try {
+		const parsed = parse(content);
+		if (!is.plainObject(parsed)) return void 0;
+		data = parsed;
+	} catch {
+		return;
+	}
+	const packageData = is.plainObject(data.package) ? data.package : {};
+	const workspace = is.plainObject(data.workspace) ? data.workspace : void 0;
+	return cargoTomlSchema.parse({
+		authors: parseAuthors(packageData.authors),
+		buildDependencies: parseDependencies(is.plainObject(data["build-dependencies"]) ? data["build-dependencies"] : {}),
+		categories: toStringArray(packageData.categories),
+		dependencies: parseDependencies(is.plainObject(data.dependencies) ? data.dependencies : {}),
+		description: nonEmpty(packageData.description),
+		devDependencies: parseDependencies(is.plainObject(data["dev-dependencies"]) ? data["dev-dependencies"] : {}),
+		documentation: nonEmpty(packageData.documentation),
+		edition: nonEmpty(packageData.edition),
+		homepage: nonEmpty(packageData.homepage),
+		keywords: toStringArray(packageData.keywords),
+		license: nonEmpty(packageData.license),
+		licenseFile: nonEmpty(packageData["license-file"]),
+		name: nonEmpty(packageData.name),
+		readme: nonEmpty(packageData.readme),
+		repository: nonEmpty(packageData.repository),
+		rustVersion: nonEmpty(packageData["rust-version"]),
+		version: nonEmpty(packageData.version),
+		workspaceMembers: toStringArray(workspace?.members)
+	});
+}
+/** Return a trimmed string, or undefined if not a non-empty string. */
+function nonEmpty(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+/** Convert an unknown value to a string array, filtering non-strings. */
+function toStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((v) => typeof v === "string" && v.trim().length > 0);
+}
+/**
+* Parse `authors` field entries. Each entry is `"Name <email>"` or `"Name"`.
+*/
+function parseAuthors(value) {
+	if (!Array.isArray(value)) return [];
+	const results = [];
+	for (const entry of value) {
+		if (typeof entry !== "string") continue;
+		const trimmed = entry.trim();
+		if (trimmed.length === 0) continue;
+		const bracketIndex = trimmed.indexOf("<");
+		if (bracketIndex !== -1) {
+			const closeBracket = trimmed.indexOf(">", bracketIndex);
+			if (closeBracket !== -1) {
+				const name = trimmed.slice(0, bracketIndex).trim();
+				const email = trimmed.slice(bracketIndex + 1, closeBracket).trim();
+				results.push({
+					email: email.length > 0 ? email : void 0,
+					name
+				});
+				continue;
+			}
+		}
+		results.push({
+			email: void 0,
+			name: trimmed
+		});
+	}
+	return results;
+}
+/**
+* Parse a dependencies table into name/version entries.
+* Handles both `dep = "version"` and `dep = { version = "..." }` forms.
+*/
+function parseDependencies(table) {
+	const results = [];
+	for (const [name, value] of Object.entries(table)) if (typeof value === "string") results.push({
+		name,
+		version: value
+	});
+	else if (is.plainObject(value)) results.push({
+		name,
+		version: nonEmpty(value.version)
+	});
+	else results.push({
+		name,
+		version: void 0
+	});
+	return results;
+}
+const rustCargoTomlSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, ["Cargo.toml"]);
+	},
+	key: "rustCargoToml",
+	async parse(input, context) {
+		const data = parse$1(await readFile(resolve(context.options.path, input), "utf8"));
+		if (data !== void 0) return {
+			data,
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { rustCargoTomlSource };

package/dist/lib/sources/xcode-info-plist.d.ts

@@ -0,0 +1,22 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { z } from "zod";
+
+//#region src/lib/sources/xcode-info-plist.d.ts
+declare const infoPlistSchema: z.ZodObject<{
+  applicationCategory: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  author: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  authorEmail: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  copyrightHolder: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  copyrightYear: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  description: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  identifier: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  operatingSystems: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  processorRequirements: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  version: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+type InfoPlist = z.infer<typeof infoPlistSchema>;
+type XcodeInfoPlistData = OneOrMany<SourceRecord<InfoPlist>> | undefined;
+//#endregion
+export { XcodeInfoPlistData };