@aklinker1/zero-changelog 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aaron
+
+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/README.md

@@ -0,0 +1,158 @@
+<div align="center">
+
+# `@aklinker1/zero-changelog`
+
+[![JSR](https://jsr.io/badges/@aklinker1/zero-changelog)](https://jsr.io/@aklinker1/zero-changelog)
+[![NPM Version](https://img.shields.io/npm/v/%40aklinker1%2Fzero-changelog?logo=npm&labelColor=red&color=white)](https://www.npmjs.com/package/@aklinker1/zero-changelog)
+[![Docs](https://img.shields.io/badge/API%20Reference-blue?logo=readme&logoColor=white)](https://jsr.io/@aklinker1/zero-changelog/doc)
+[![Install Size](https://pkg-size.dev/badge/install/61804)](https://pkg-size.dev/@aklinker1%2Fzero-changelog)
+
+Zero-dependency, conventional commit release and changelog generator with monorepo support
+
+</div>
+
+```sh
+bun add @aklinker1/zero-changelog
+```
+
+## Features
+
+- 📦 Zero dependencies, [e18e](https://e18e.dev) first
+- 🏗️ Monorepo & sub-directory support
+- 🛠️ Github Action, JS API, CLI
+- 🚀 Runs custom publish scripts
+- 📊 Summarize unreleased changes
+
+## Options
+
+Refer to the API reference:
+
+- [Release](https://jsr.io/@aklinker1/zero-ioc/doc/release/~/ReleaseOptions)
+- [Sync Releases](https://jsr.io/@aklinker1/zero-ioc/doc/sync-releases/~/SyncReleasesOptions)
+- [Summarize Unreleased Commits](https://jsr.io/@aklinker1/zero-ioc/doc/summarize-unreleased-commits/~/SummarizeUnreleasedCommitsOptions)
+
+## Usage
+
+### GitHub Action
+
+```yml
+- uses: aklinker1/zero-changelog/actions/release@1.0.0
+  with:
+    # options...
+```
+
+### JS API
+
+```ts
+import { release } from "@aklinker1/zero-changelog/release";
+
+await release({
+  // options...
+});
+```
+
+### CLI
+
+> TODO: CLI not implemented yet.
+
+Run any command with `--help` to see available options.
+
+```sh
+bun zero-changelog --help
+bun zero-changelog release --help
+bun zero-changelog sync-releases --help
+bun zero-changelog summarize-unreleased-changes --help
+```
+
+## Semver
+
+`@aklinker1/zero-changelog` does not implement the entire Semver spec. It only supports the
+following types of versions:
+
+- ✅ **Unstable**: `0.[0-9]+.[0-9]+`
+  - Examples: `0.0.0`, `0.12.1`, `0.1.9`, `0.20.17`
+
+- ✅ **Prerelease**: `[1-9][0-9]*.0.0-\w+.[0-9]+`
+  - Examples: `1.0.0-alpha.1`, `2.0.0-beta.3`, `3.0.0-rc.10`
+
+- ✅ **Stable**: `[1-9][0-9]*.[0-9]+.[0-9]+`
+  - Examples: `1.1.0`, `2.0.1`, `3.0.0`
+
+It does NOT support:
+
+- ❌ **Truncated versions** with one or two digits:
+  - Examples: `1.0`, `2`
+- ❌ **Unstable prereleases**:
+  - Examples: `0.2.0-alpha.1`
+- ❌ **Non X.0.0 prereleases**:
+  - Examples: `1.1.0-rc.1`, `1.0.5-alpha.1`
+- ❌ **Other prerelease formats**:
+  - Examples: `0.2.0-0.3.2`, `0.2.0-1`
+
+This allows the package to have 0 dependencies.
+
+### Relative Version Bumping
+
+When bumping the version by `major`, `minor`, or `patch`, either by setting the `bump` option or
+auto-detecting the type based on commits, there are some special cases where the version may not be
+bumped as expected:
+
+1. **Unstable**: The type of semver change will be lowered by 1, so `major` &rarr; `minor`, `minor`
+   &rarr; `patch`, `patch` &rarr; `patch`.
+   - Examples:
+     - `0.1.0` &rarr; `major` &rarr; `0.2.0`
+     - `0.1.0` &rarr; `minor` &rarr; `0.1.1`
+     - `0.1.0` &rarr; `patch` &rarr; `0.1.1`
+
+2. **Prereleases**: The final integer will always be updated.
+   - Examples:
+     - `1.0.0-alpha.1` &rarr; `major` &rarr; `1.0.0-alpha.2`
+     - `1.0.0-alpha.1` &rarr; `minor` &rarr; `1.0.0-alpha.2`
+     - `1.0.0-alpha.1` &rarr; `patch` &rarr; `1.0.0-alpha.2`
+
+So if you want to switch between versions types (stable ↔ unstable ↔ pre-release), like `0.7.5`
+&rarr; `1.0.0` or `2.0.0-rc.4` &rarr; `2.0.0`, you need to provide the next version number for the
+`bump` option instead of using `major`/`minor`/`patch`:
+
+```ts
+await release({
+  bump: "2.0.0",
+});
+```
+
+Otherwise stable versions will remain stable, unstable will remain unstable, and prereleases will
+remain prereleases.
+
+## Plan
+
+Release:
+
+1. List git commits
+2. Detect type of version bump
+3. Generate changelog
+4. Bump version in version files
+5. Update changelog
+6. Git commit & tag
+7. Git push
+8. Create release
+
+Sync Releases:
+
+1. Parse changelog
+2. Update each release to match changelog
+
+Summarize Unreleased Changes:
+
+1. List commits in each directory since the last commit
+2. Print and return the summary
+
+## TODO
+
+- [x] Structure for package + action
+- [x] Implement tests
+- [x] Implement git logic
+- [ ] Implement sync releases
+- [x] Glob patterns for github action
+- [x] Implement unreleased commit summary
+- [ ] CLI?
+- [x] Implement alpha/beta version bumping

package/dist/changelog-section.d.mts

@@ -0,0 +1,7 @@
+//#region src/changelog-section.d.ts
+type ChangelogSection = {
+  header: string;
+  body: string;
+};
+//#endregion
+export { ChangelogSection };

package/dist/changelog-section.mjs

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

package/dist/conventional-commit.d.mts

@@ -0,0 +1,28 @@
+//#region src/conventional-commit.d.ts
+type ConventionalCommit = {
+  type: string;
+  scope?: string;
+  description: string;
+  body?: string;
+  isBreaking: boolean;
+  footers: Array<{
+    /**
+     * Lowercase footer key.
+     *
+     * @example
+     *   "Co-authored-by: Aaron <aaron@example.com>"; // key: "co-authored-by"
+     */
+    key: string;
+    /**
+     * @example
+     *   "Co-authored-by: Aaron <aaron@example.com>"; // value: "Aaron <aaron@example.com>"
+     */
+    value: string;
+  }>;
+  authors: Array<{
+    name: string;
+    email: string;
+  }>;
+};
+//#endregion
+export { ConventionalCommit };

package/dist/conventional-commit.mjs

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

package/dist/create-github-release.d.mts

@@ -0,0 +1,15 @@
+//#region src/create-github-release.d.ts
+type CreateGithubReleaseOptions = {
+  repo: `${string}/${string}`;
+  token: string;
+  dryRun: boolean;
+  tag: string;
+  name: string;
+  body: string;
+  artifacts?: string[];
+  latest: boolean;
+  prerelease: boolean;
+};
+declare function createGithubRelease(options: CreateGithubReleaseOptions): Promise<void>;
+//#endregion
+export { createGithubRelease };

package/dist/create-github-release.mjs

@@ -0,0 +1,61 @@
+import { createReadStream } from "node:fs";
+import { styleText } from "node:util";
+//#region src/create-github-release.ts
+async function createGithubRelease(options) {
+	console.log("Creating GitHub release...");
+	if (options.dryRun) console.log("  -> Skipping, dry run");
+	else throw Error("TODO");
+	for (const artifact of options.artifacts ?? []) {
+		console.log(`Uploading ${styleText("cyan", artifact)}...`);
+		if (options.dryRun) console.log("  -> Skipping, dry run");
+		else {
+			const artifactStreams = options.artifacts?.length ? await getArtifactStreams(options.artifacts) : void 0;
+			await createRelease(options);
+			if (artifactStreams) await uploadArtifacts(options, artifactStreams);
+		}
+	}
+}
+async function getArtifactStreams(artifacts) {
+	return Promise.all(artifacts.map((artifact) => createReadStream(artifact)));
+}
+async function createRelease(options) {
+	const res = await fetch(`https://api.github.com/repos/${options.repo}/releases`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${options.token}`
+		},
+		body: JSON.stringify({
+			tag_name: options.tag,
+			name: options.name,
+			body: options.body,
+			make_latest: options.latest,
+			prerelease: options.prerelease
+		})
+	});
+	if (res.ok) return;
+	console.log("Response status: " + res.status);
+	console.log("Response body: " + await res.text());
+	throw Error(`Failed to create GitHub release`);
+}
+async function uploadArtifacts(options, artifactStreams) {
+	for (const [i, stream] of artifactStreams.entries()) {
+		const artifact = options.artifacts[i];
+		console.log("  -> Uploading ", artifact);
+		const res = await fetch(`https://uploads.github.com/repos/${options.repo}/releases/tags/${options.tag}/assets`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/octet-stream",
+				Authorization: `Bearer ${options.token}`,
+				"Content-Disposition": `attachment; filename="${artifact}"`
+			},
+			body: stream
+		});
+		if (!res.ok) {
+			console.error(`Failed to upload`, artifact, res);
+			console.log(await res.text());
+		}
+	}
+}
+//#endregion
+export { createGithubRelease };

package/dist/detect-version-bump.d.mts

@@ -0,0 +1,13 @@
+import { ConventionalCommit } from "./conventional-commit.mjs";
+import { RelativeBump } from "./semver.mjs";
+
+//#region src/detect-version-bump.d.ts
+/**
+ * Given the current version and a list of commits, detect the type of relative version bump to use.
+ *
+ * @param currentVersion Used to determine the if prerelease logic should be applied.
+ * @param conventionalCommits List of commits to generate the version bump from.
+ */
+declare function detectVersionBump(conventionalCommits: ConventionalCommit[], throwOnNoChanges: boolean): RelativeBump;
+//#endregion
+export { detectVersionBump };

package/dist/detect-version-bump.mjs

@@ -0,0 +1,43 @@
+import types from "./semver-types/aklinker1.mjs";
+//#region src/detect-version-bump.ts
+const NONE = 0;
+const PATCH = 1;
+const MINOR = 2;
+const PRIORITY_MAP = {
+	none: NONE,
+	patch: PATCH,
+	minor: MINOR
+};
+/**
+* Given the current version and a list of commits, detect the type of relative version bump to use.
+*
+* @param currentVersion Used to determine the if prerelease logic should be applied.
+* @param conventionalCommits List of commits to generate the version bump from.
+*/
+function detectVersionBump(conventionalCommits, throwOnNoChanges) {
+	console.log("Detecting version bump based on changes...");
+	let priority = NONE;
+	for (const commit of conventionalCommits) {
+		if (commit.isBreaking) {
+			console.log("  -> major");
+			return "major";
+		}
+		const bumpBy = types[commit.type]?.bump ?? "none";
+		priority = Math.max(priority, PRIORITY_MAP[bumpBy]);
+	}
+	switch (priority) {
+		case MINOR:
+			console.log("  -> minor");
+			return "minor";
+		case PATCH:
+			console.log("  -> patch");
+			return "patch";
+		case NONE:
+			if (throwOnNoChanges) throw Error("No semver changes detected");
+			console.log("  -> patch");
+			return "patch";
+		default: throw Error("Unknown semver bump value: " + priority);
+	}
+}
+//#endregion
+export { detectVersionBump };

package/dist/find-previous-tag-Cj2oZAty.mjs

@@ -0,0 +1,27 @@
+import { t as waitForChildProcess } from "./wait-for-child-process-lyAoE4WE.mjs";
+import { spawn } from "node:child_process";
+//#region src/internal/run-git-tag.ts
+async function runGitTag(prefix, cwd = process.cwd()) {
+	const { stdout } = await waitForChildProcess(spawn("git", [
+		"--no-pager",
+		"tag",
+		"-l",
+		`${prefix}*`,
+		"--sort=-version:refname"
+	], { cwd }));
+	return stdout;
+}
+//#endregion
+//#region src/find-previous-tag.ts
+/**
+* Finds the previous tag that starts with a prefix. If there are no previous tags starting with the
+* prefix, this returns `undefined`.
+*
+* @param tagPrefix The prefix to look for.
+*/
+async function findPreviousTag(tagPrefix) {
+	console.log(`Finding previous tag matching: "${tagPrefix}*"`);
+	return (await runGitTag(tagPrefix)).trim().split("\n")[0] || void 0;
+}
+//#endregion
+export { findPreviousTag as t };

package/dist/find-previous-tag.d.mts

@@ -0,0 +1,10 @@
+//#region src/find-previous-tag.d.ts
+/**
+ * Finds the previous tag that starts with a prefix. If there are no previous tags starting with the
+ * prefix, this returns `undefined`.
+ *
+ * @param tagPrefix The prefix to look for.
+ */
+declare function findPreviousTag(tagPrefix: string): Promise<string | undefined>;
+//#endregion
+export { findPreviousTag };

package/dist/find-previous-tag.mjs

@@ -0,0 +1,2 @@
+import { t as findPreviousTag } from "./find-previous-tag-Cj2oZAty.mjs";
+export { findPreviousTag };

package/dist/get-current-version.d.mts

@@ -0,0 +1,4 @@
+//#region src/get-current-version.d.ts
+declare function getCurrentVersion(path: string, versionFiles: string[]): Promise<string>;
+//#endregion
+export { getCurrentVersion };

package/dist/get-current-version.mjs

@@ -0,0 +1,24 @@
+import { t as getVersionRegexFor } from "./version-regex-C82OGsTC.mjs";
+import { styleText } from "node:util";
+import { readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+//#region src/get-current-version.ts
+async function getCurrentVersion(path, versionFiles) {
+	console.log("Getting current version...");
+	for (const versionFile of versionFiles) try {
+		const file = join(path, versionFile);
+		const text = await readFile(file, "utf8");
+		const regex = getVersionRegexFor(file);
+		const version = text.match(regex)?.groups?.version;
+		if (version) {
+			console.log(`Found current version (${version})) in ${styleText("cyan", relative(process.cwd(), file))}`);
+			return version;
+		}
+		console.log(`  -> Not found in ${styleText("cyan", relative(process.cwd(), file))}`);
+	} catch (err) {
+		if (err.code !== "ENOENT") throw err;
+	}
+	throw Error("Version not found");
+}
+//#endregion
+export { getCurrentVersion };

package/dist/get-github-release.d.mts

@@ -0,0 +1,15 @@
+//#region src/get-github-release.d.ts
+type GithubRelease = {
+  tag: string;
+  title: string;
+  body: string;
+  draft: boolean;
+  prerelease: boolean;
+};
+declare function getGithubRelease(options: {
+  repo: string;
+  tag: string;
+  token: string;
+}): Promise<GithubRelease>;
+//#endregion
+export { GithubRelease, getGithubRelease };

package/dist/get-github-release.mjs

@@ -0,0 +1,11 @@
+//#region src/get-github-release.ts
+async function getGithubRelease(options) {
+	const res = await fetch(`https://api.github.com/repos/${options.repo}/releases/tags/${options.tag}`, { headers: { Authorization: `Bearer ${options.token}` } });
+	if (res.ok) return await res.json();
+	console.log("Response status:", res.status);
+	console.log("Response body:");
+	console.log(await res.text());
+	throw Error("Failed to fetch github release");
+}
+//#endregion
+export { getGithubRelease };

package/dist/get-github-repo.d.mts

@@ -0,0 +1,4 @@
+//#region src/get-github-repo.d.ts
+declare function getGithubRepo(): Promise<`${string}/${string}`>;
+//#endregion
+export { getGithubRepo };

package/dist/get-github-repo.mjs

@@ -0,0 +1,20 @@
+import { t as waitForChildProcess } from "./wait-for-child-process-lyAoE4WE.mjs";
+import { spawn } from "node:child_process";
+//#region src/get-github-repo.ts
+const REMOTE_REGEX = [/^git@github\.com:(?<owner>\S+)\/(?<repo>\S+)\.git$/, /^https:\/\/github\.com\/(?<owner>\S+)\/(?<repo>\S+)\.git$/];
+async function getGithubRepo() {
+	console.log("Getting current github repo...");
+	const { stdout } = await waitForChildProcess(spawn("git", [
+		"config",
+		"--get",
+		"remote.origin.url"
+	]));
+	const url = stdout.trim();
+	for (const regex of REMOTE_REGEX) {
+		const groups = url.match(regex)?.groups;
+		if (groups) return `${groups.owner}/${groups.repo}`;
+	}
+	throw Error(`Could not find github repo from the origin remote's URL: ${url}`);
+}
+//#endregion
+export { getGithubRepo };

package/dist/get-release-notes.d.mts

@@ -0,0 +1,6 @@
+import { ConventionalCommit } from "./conventional-commit.mjs";
+
+//#region src/get-release-notes.d.ts
+declare function getReleaseNotes(conventionalCommits: ConventionalCommit[], since: string | undefined, tag: string, repo: string): string;
+//#endregion
+export { getReleaseNotes };

package/dist/get-release-notes.mjs

@@ -0,0 +1,37 @@
+import types from "./semver-types/aklinker1.mjs";
+//#region src/get-release-notes.ts
+function getReleaseNotes(conventionalCommits, since, tag, repo) {
+	const commitsByType = conventionalCommits.reduce((acc, commit) => {
+		acc[commit.type] ??= [];
+		acc[commit.type].push(commit);
+		return acc;
+	}, {});
+	const lines = [];
+	if (since) lines.push(`[compare changes](https://github.com/${repo}/compare/${since}...${tag})`, "");
+	for (const [type, details] of Object.entries(types)) {
+		const commits = commitsByType[type];
+		if (!commits?.length) continue;
+		lines.push(`### ${details.title}`, "");
+		for (const commit of commits) {
+			const scope = commit.scope ? `**${commit.scope}**: ` : "";
+			const breaking = commit.isBreaking ? "⚠️ " : "";
+			lines.push(`- ${breaking}${scope}${commit.description}`);
+		}
+		lines.push("");
+	}
+	const authors = conventionalCommits.flatMap((commit) => commit.authors);
+	if (authors.length) {
+		const emailNameMap = authors.reduce((acc, author) => {
+			acc[author.name] ??= author.email;
+			return acc;
+		}, {});
+		const emails = new Set(conventionalCommits.flatMap((commit) => commit.authors).map((author) => author.email));
+		const sortedEmails = Array.from(emails).toSorted((a, b) => b.localeCompare(a));
+		lines.push("### ❤️ Contributors", "");
+		for (const email of sortedEmails) lines.push(`- ${emailNameMap[email]} <${email}>`);
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+//#endregion
+export { getReleaseNotes };

package/dist/git-commit.d.mts

@@ -0,0 +1,13 @@
+//#region src/git-commit.d.ts
+type GitCommit = {
+  hash: string;
+  author: {
+    name: string;
+    email: string;
+  };
+  subject: string;
+  body: string | undefined;
+  date: Date;
+};
+//#endregion
+export { GitCommit };

package/dist/git-commit.mjs

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

package/dist/list-commits-since-DycWgHTi.mjs

@@ -0,0 +1,44 @@
+import { t as waitForChildProcess } from "./wait-for-child-process-lyAoE4WE.mjs";
+import { spawn } from "node:child_process";
+//#region src/internal/run-git-log.ts
+async function runGitLog(paths, fromRef, toRef = "HEAD", cwd = process.cwd()) {
+	const args = [
+		"--no-pager",
+		"log",
+		...fromRef ? [`${fromRef}..${toRef}`] : [],
+		"--date=iso-strict",
+		"--no-color",
+		"--no-decorate",
+		"--no-merges",
+		`--format=%H%x1f%an%x1f%ae%x1f%ad%x1f%s%x1f%b%x1e`,
+		"--",
+		...paths
+	];
+	console.log(args);
+	const { stdout } = await waitForChildProcess(spawn("git", args, { cwd }));
+	return stdout;
+}
+//#endregion
+//#region src/list-commits-since.ts
+/** List the commits since a ref in specific dirs. */
+async function listCommitsSince(options) {
+	console.log(`Listing commits ${options.since ? "since " + options.since : "for all time"} in:`, options.dirs);
+	return parseGitLog(await runGitLog(options.dirs, options.since));
+}
+function parseGitLog(log) {
+	return log.split("").map((r) => r.trim()).filter(Boolean).map((record) => {
+		const [hash, authorName, authorEmail, date, subject, body] = record.split("");
+		return {
+			hash,
+			author: {
+				name: authorName,
+				email: authorEmail
+			},
+			date: new Date(date),
+			subject,
+			body: body?.trim() || void 0
+		};
+	});
+}
+//#endregion
+export { parseGitLog as n, listCommitsSince as t };

package/dist/list-commits-since.d.mts

@@ -0,0 +1,11 @@
+import { GitCommit } from "./git-commit.mjs";
+
+//#region src/list-commits-since.d.ts
+/** List the commits since a ref in specific dirs. */
+declare function listCommitsSince(options: {
+  dirs: string[];
+  since: string | undefined;
+}): Promise<GitCommit[]>;
+declare function parseGitLog(log: string): GitCommit[];
+//#endregion
+export { listCommitsSince, parseGitLog };

package/dist/list-commits-since.mjs

@@ -0,0 +1,2 @@
+import { n as parseGitLog, t as listCommitsSince } from "./list-commits-since-DycWgHTi.mjs";
+export { listCommitsSince, parseGitLog };

package/dist/parse-changelog.d.mts

@@ -0,0 +1,6 @@
+import { ChangelogSection } from "./changelog-section.mjs";
+
+//#region src/parse-changelog.d.ts
+declare function parseChangelog(changelog: string): ChangelogSection[];
+//#endregion
+export { parseChangelog };

package/dist/parse-changelog.mjs

@@ -0,0 +1,23 @@
+//#region src/parse-changelog.ts
+function parseChangelog(changelog) {
+	const lines = changelog.split(/\n\r?/);
+	let results = [];
+	let current;
+	for (const line of lines) if (line.startsWith("## ")) {
+		if (current) results.push({
+			header: current.header,
+			body: current.lines.join("\n").trim()
+		});
+		current = {
+			header: line.slice(3),
+			lines: []
+		};
+	} else if (current) current.lines.push(line);
+	if (current) results.push({
+		header: current.header,
+		body: current.lines.join("\n").trim()
+	});
+	return results;
+}
+//#endregion
+export { parseChangelog };

package/dist/parse-commit.d.mts

@@ -0,0 +1,8 @@
+import { ConventionalCommit } from "./conventional-commit.mjs";
+import { GitCommit } from "./git-commit.mjs";
+
+//#region src/parse-commit.d.ts
+/** Convert a commit to a {@link ConventionalCommit}, returning `undefined` for unknown formats */
+declare function parseCommit(commit: GitCommit): ConventionalCommit | undefined;
+//#endregion
+export { parseCommit };