versionary 0.28.0 → 0.28.2

package/dist/strategy/rust.js

@@ -1,16 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rustVersionStrategy = void 0;
-exports.applyRustWorkspaceDependencyUpdates = applyRustWorkspaceDependencyUpdates;
-exports.detectRustDependencyImpact = detectRustDependencyImpact;
-exports.toCargoManifestPath = toCargoManifestPath;
-const node_child_process_1 = require("node:child_process");
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const toml_1 = __importDefault(require("@iarna/toml"));
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseToml } from "smol-toml";
 const ROOT_DEPENDENCY_SECTIONS = new Set([
     "dependencies",
     "dev-dependencies",
@@ -57,12 +48,12 @@ function findCargoManifestDirectories(rootDir) {
         if (!currentDir) {
             continue;
         }
-        const entries = node_fs_1.default.readdirSync(currentDir, {
+        const entries = fs.readdirSync(currentDir, {
             withFileTypes: true,
         });
         let hasCargoManifest = false;
         for (const entry of entries) {
-            const fullPath = node_path_1.default.join(currentDir, entry.name);
+            const fullPath = path.join(currentDir, entry.name);
             if (entry.isFile() && entry.name === "Cargo.toml") {
                 hasCargoManifest = true;
                 continue;
@@ -72,7 +63,7 @@ function findCargoManifestDirectories(rootDir) {
             }
         }
         if (hasCargoManifest) {
-            const rel = normalizeSlashPath(node_path_1.default.relative(rootDir, currentDir));
+            const rel = normalizeSlashPath(path.relative(rootDir, currentDir));
             results.add(rel === "" ? "." : rel);
         }
     }
@@ -84,12 +75,12 @@ function collectAllCrateManifests(cwd) {
     for (const dir of cargoDirs) {
         const manifest = dir === "."
             ? "Cargo.toml"
-            : normalizeSlashPath(node_path_1.default.posix.join(dir, "Cargo.toml"));
-        const manifestPath = node_path_1.default.join(cwd, manifest);
-        if (!node_fs_1.default.existsSync(manifestPath)) {
+            : normalizeSlashPath(path.posix.join(dir, "Cargo.toml"));
+        const manifestPath = path.join(cwd, manifest);
+        if (!fs.existsSync(manifestPath)) {
             continue;
         }
-        const cargoTomlRaw = node_fs_1.default.readFileSync(manifestPath, "utf8");
+        const cargoTomlRaw = fs.readFileSync(manifestPath, "utf8");
         if (!isCrateManifest(manifest, cargoTomlRaw)) {
             continue;
         }
@@ -105,12 +96,12 @@ function listCargoLockFiles(cwd) {
         if (!currentDir) {
             continue;
         }
-        const entries = node_fs_1.default.readdirSync(currentDir, { withFileTypes: true });
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
         for (const entry of entries) {
             if (entry.name === ".git") {
                 continue;
             }
-            const fullPath = node_path_1.default.join(currentDir, entry.name);
+            const fullPath = path.join(currentDir, entry.name);
             if (entry.isDirectory()) {
                 queue.push(fullPath);
                 continue;
@@ -118,7 +109,7 @@ function listCargoLockFiles(cwd) {
             if (!entry.isFile() || entry.name !== "Cargo.lock") {
                 continue;
             }
-            lockfiles.push(normalizeSlashPath(node_path_1.default.relative(cwd, fullPath)));
+            lockfiles.push(normalizeSlashPath(path.relative(cwd, fullPath)));
         }
     }
     return lockfiles.sort((a, b) => a.localeCompare(b));
@@ -130,11 +121,11 @@ function ensureCargoLockUpToDate(cwd) {
     }
     const updatedLockfiles = [];
     for (const lockfile of lockfiles) {
-        const lockfilePath = node_path_1.default.join(cwd, lockfile);
-        const before = node_fs_1.default.readFileSync(lockfilePath, "utf8");
+        const lockfilePath = path.join(cwd, lockfile);
+        const before = fs.readFileSync(lockfilePath, "utf8");
         try {
-            (0, node_child_process_1.execFileSync)("cargo", ["generate-lockfile"], {
-                cwd: node_path_1.default.dirname(lockfilePath),
+            execFileSync("cargo", ["generate-lockfile"], {
+                cwd: path.dirname(lockfilePath),
                 stdio: ["ignore", "pipe", "pipe"],
             });
         }
@@ -142,7 +133,7 @@ function ensureCargoLockUpToDate(cwd) {
             const message = error instanceof Error ? error.message : String(error);
             throw new Error(`Failed to refresh ${lockfile} via "cargo generate-lockfile". Ensure cargo is installed and available in PATH. Details: ${message}`);
         }
-        const after = node_fs_1.default.readFileSync(lockfilePath, "utf8");
+        const after = fs.readFileSync(lockfilePath, "utf8");
         if (after !== before) {
             updatedLockfiles.push(lockfile);
         }
@@ -152,7 +143,7 @@ function ensureCargoLockUpToDate(cwd) {
 function parseCargoManifest(versionFile, cargoTomlRaw) {
     let parsed;
     try {
-        parsed = toml_1.default.parse(cargoTomlRaw);
+        parsed = parseToml(cargoTomlRaw);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -211,7 +202,7 @@ function resolveWorkspaceMemberManifests(rootDir, workspaceTable) {
             const regex = globToRegex(pattern);
             for (const dir of cargoDirs) {
                 if (regex.test(dir)) {
-                    manifests.add(normalizeSlashPath(node_path_1.default.posix.join(dir, "Cargo.toml")));
+                    manifests.add(normalizeSlashPath(path.posix.join(dir, "Cargo.toml")));
                 }
             }
             continue;
@@ -220,34 +211,34 @@ function resolveWorkspaceMemberManifests(rootDir, workspaceTable) {
         if (excludeRegexes.some((regex) => regex.test(candidateDir))) {
             continue;
         }
-        const cargoPath = node_path_1.default.join(rootDir, candidateDir, "Cargo.toml");
-        if (node_fs_1.default.existsSync(cargoPath)) {
-            manifests.add(normalizeSlashPath(node_path_1.default.posix.join(candidateDir, "Cargo.toml")));
+        const cargoPath = path.join(rootDir, candidateDir, "Cargo.toml");
+        if (fs.existsSync(cargoPath)) {
+            manifests.add(normalizeSlashPath(path.posix.join(candidateDir, "Cargo.toml")));
         }
     }
     const filtered = [...manifests].filter((manifestPath) => {
-        const dir = normalizeSlashPath(node_path_1.default.posix.dirname(manifestPath));
+        const dir = normalizeSlashPath(path.posix.dirname(manifestPath));
         return !excludeRegexes.some((regex) => regex.test(dir));
     });
     return filtered.sort((a, b) => a.localeCompare(b));
 }
 function collectRustTargetManifests(cwd, versionFile, includeWorkspaceMembers) {
-    if (node_path_1.default.basename(versionFile) !== "Cargo.toml") {
+    if (path.basename(versionFile) !== "Cargo.toml") {
         throw new Error(`Rust strategy requires "version-file" to point to a Cargo.toml manifest (received "${versionFile}").`);
     }
-    const rootManifestPath = node_path_1.default.join(cwd, versionFile);
-    if (!node_fs_1.default.existsSync(rootManifestPath)) {
+    const rootManifestPath = path.join(cwd, versionFile);
+    if (!fs.existsSync(rootManifestPath)) {
         throw new Error(`Versionary requires ${versionFile} to exist.`);
     }
-    const rootRaw = node_fs_1.default.readFileSync(rootManifestPath, "utf8");
+    const rootRaw = fs.readFileSync(rootManifestPath, "utf8");
     const parsedRoot = parseCargoManifest(versionFile, rootRaw);
     const rootIsCrate = parsedRoot.packageTable !== null;
-    const rootDir = node_path_1.default.dirname(rootManifestPath);
+    const rootDir = path.dirname(rootManifestPath);
     const augmentingMembers = includeWorkspaceMembers
         ? resolveWorkspaceMemberManifests(rootDir, parsedRoot.workspaceTable)
         : [];
     if (rootIsCrate) {
-        const relRoot = normalizeSlashPath(node_path_1.default.relative(cwd, rootManifestPath));
+        const relRoot = normalizeSlashPath(path.relative(cwd, rootManifestPath));
         return [...new Set([relRoot, ...augmentingMembers])].sort((a, b) => a.localeCompare(b));
     }
     const fallbackMembers = includeWorkspaceMembers
@@ -284,17 +275,17 @@ function readWorkspacePackageVersion(cargoTomlRaw, versionFile) {
     return rawVersion.trim();
 }
 function findWorkspaceManifestForMember(cwd, memberManifest) {
-    const cwdAbs = node_path_1.default.resolve(cwd);
-    let currentDir = node_path_1.default.resolve(cwd, node_path_1.default.dirname(memberManifest));
+    const cwdAbs = path.resolve(cwd);
+    let currentDir = path.resolve(cwd, path.dirname(memberManifest));
     while (true) {
-        const relativeDir = node_path_1.default.relative(cwdAbs, currentDir);
+        const relativeDir = path.relative(cwdAbs, currentDir);
         if (relativeDir.startsWith("..")) {
             break;
         }
-        const candidatePath = node_path_1.default.join(currentDir, "Cargo.toml");
-        if (node_fs_1.default.existsSync(candidatePath)) {
-            const relativeManifest = normalizeSlashPath(node_path_1.default.relative(cwdAbs, candidatePath));
-            const cargoTomlRaw = node_fs_1.default.readFileSync(candidatePath, "utf8");
+        const candidatePath = path.join(currentDir, "Cargo.toml");
+        if (fs.existsSync(candidatePath)) {
+            const relativeManifest = normalizeSlashPath(path.relative(cwdAbs, candidatePath));
+            const cargoTomlRaw = fs.readFileSync(candidatePath, "utf8");
             const parsed = parseCargoManifest(relativeManifest, cargoTomlRaw);
             if (parsed.workspaceTable) {
                 return relativeManifest;
@@ -303,7 +294,7 @@ function findWorkspaceManifestForMember(cwd, memberManifest) {
         if (currentDir === cwdAbs) {
             break;
         }
-        const parentDir = node_path_1.default.dirname(currentDir);
+        const parentDir = path.dirname(currentDir);
         if (parentDir === currentDir) {
             break;
         }
@@ -327,7 +318,7 @@ function readResolvedCargoVersion(cwd, manifest, cargoTomlRaw) {
         throw new Error(`${manifest} has invalid [package].version. Expected a non-empty SemVer string or version.workspace = true.`);
     }
     const workspaceManifest = findWorkspaceManifestForMember(cwd, manifest);
-    const workspaceRaw = node_fs_1.default.readFileSync(node_path_1.default.join(cwd, workspaceManifest), "utf8");
+    const workspaceRaw = fs.readFileSync(path.join(cwd, workspaceManifest), "utf8");
     return readWorkspacePackageVersion(workspaceRaw, workspaceManifest);
 }
 function readCargoPackageName(cargoTomlRaw, versionFile) {
@@ -529,8 +520,8 @@ function writeMappedDependencyVersions(cargoTomlRaw, versionByDependency) {
     return updated;
 }
 function readPackageNameForManifest(cwd, manifest) {
-    const manifestPath = node_path_1.default.join(cwd, manifest);
-    const cargoTomlRaw = node_fs_1.default.readFileSync(manifestPath, "utf8");
+    const manifestPath = path.join(cwd, manifest);
+    const cargoTomlRaw = fs.readFileSync(manifestPath, "utf8");
     if (!isCrateManifest(manifest, cargoTomlRaw)) {
         throw new Error(`Configured rust target "${manifest}" is not a Rust crate manifest to update.`);
     }
@@ -539,34 +530,34 @@ function readPackageNameForManifest(cwd, manifest) {
 function expandWorkspaceOnlyManifests(cwd, manifestToVersion) {
     const expanded = {};
     for (const [manifest, version] of Object.entries(manifestToVersion)) {
-        const manifestPath = node_path_1.default.join(cwd, manifest);
-        if (!node_fs_1.default.existsSync(manifestPath)) {
+        const manifestPath = path.join(cwd, manifest);
+        if (!fs.existsSync(manifestPath)) {
             expanded[manifest] = version;
             continue;
         }
-        const cargoTomlRaw = node_fs_1.default.readFileSync(manifestPath, "utf8");
+        const cargoTomlRaw = fs.readFileSync(manifestPath, "utf8");
         const parsed = parseCargoManifest(manifest, cargoTomlRaw);
         if (parsed.packageTable !== null || parsed.workspaceTable === null) {
             expanded[manifest] = version;
             continue;
         }
-        const rootDir = node_path_1.default.dirname(manifestPath);
+        const rootDir = path.dirname(manifestPath);
         const memberManifests = resolveWorkspaceMemberManifests(rootDir, parsed.workspaceTable);
         if (memberManifests.length === 0) {
             expanded[manifest] = version;
             continue;
         }
-        const manifestDir = normalizeSlashPath(node_path_1.default.posix.dirname(manifest));
+        const manifestDir = normalizeSlashPath(path.posix.dirname(manifest));
         for (const memberManifest of memberManifests) {
             const joined = manifestDir === "." || manifestDir === ""
                 ? memberManifest
-                : normalizeSlashPath(node_path_1.default.posix.join(manifestDir, memberManifest));
+                : normalizeSlashPath(path.posix.join(manifestDir, memberManifest));
             expanded[joined] = version;
         }
     }
     return expanded;
 }
-function applyRustWorkspaceDependencyUpdates(cwd, manifestToVersion) {
+export function applyRustWorkspaceDependencyUpdates(cwd, manifestToVersion) {
     const expandedManifestToVersion = expandWorkspaceOnlyManifests(cwd, manifestToVersion);
     const versionByDependency = new Map();
     for (const [manifest, version] of Object.entries(expandedManifestToVersion)) {
@@ -582,23 +573,23 @@ function applyRustWorkspaceDependencyUpdates(cwd, manifestToVersion) {
     const updatedFiles = [];
     const manifests = collectAllCrateManifests(cwd);
     for (const manifest of manifests) {
-        const manifestPath = node_path_1.default.join(cwd, manifest);
-        if (!node_fs_1.default.existsSync(manifestPath)) {
+        const manifestPath = path.join(cwd, manifest);
+        if (!fs.existsSync(manifestPath)) {
             continue;
         }
-        const cargoTomlRaw = node_fs_1.default.readFileSync(manifestPath, "utf8");
+        const cargoTomlRaw = fs.readFileSync(manifestPath, "utf8");
         if (!isCrateManifest(manifest, cargoTomlRaw)) {
             continue;
         }
         const next = writeMappedDependencyVersions(cargoTomlRaw, versionByDependency);
         if (next !== cargoTomlRaw) {
-            node_fs_1.default.writeFileSync(manifestPath, next, "utf8");
+            fs.writeFileSync(manifestPath, next, "utf8");
             updatedFiles.push(manifest);
         }
     }
     return updatedFiles;
 }
-function detectRustDependencyImpact(cwd, manifestToVersion, candidateManifests) {
+export function detectRustDependencyImpact(cwd, manifestToVersion, candidateManifests) {
     const expandedManifestToVersion = expandWorkspaceOnlyManifests(cwd, manifestToVersion);
     const versionByDependency = new Map();
     for (const [manifest, version] of Object.entries(expandedManifestToVersion)) {
@@ -613,11 +604,11 @@ function detectRustDependencyImpact(cwd, manifestToVersion, candidateManifests)
     }
     const impacted = [];
     for (const manifest of [...new Set(candidateManifests)].sort((a, b) => a.localeCompare(b))) {
-        const manifestPath = node_path_1.default.join(cwd, manifest);
-        if (!node_fs_1.default.existsSync(manifestPath)) {
+        const manifestPath = path.join(cwd, manifest);
+        if (!fs.existsSync(manifestPath)) {
             continue;
         }
-        const cargoTomlRaw = node_fs_1.default.readFileSync(manifestPath, "utf8");
+        const cargoTomlRaw = fs.readFileSync(manifestPath, "utf8");
         if (!isCrateManifest(manifest, cargoTomlRaw)) {
             continue;
         }
@@ -628,12 +619,12 @@ function detectRustDependencyImpact(cwd, manifestToVersion, candidateManifests)
     }
     return impacted;
 }
-function toCargoManifestPath(packagePath) {
+export function toCargoManifestPath(packagePath) {
     return packagePath === "."
         ? "Cargo.toml"
-        : normalizeSlashPath(node_path_1.default.posix.join(packagePath, "Cargo.toml"));
+        : normalizeSlashPath(path.posix.join(packagePath, "Cargo.toml"));
 }
-exports.rustVersionStrategy = {
+export const rustVersionStrategy = {
     name: "rust",
     getVersionFile(config) {
         return config["version-file"] ?? "Cargo.toml";
@@ -645,7 +636,7 @@ exports.rustVersionStrategy = {
         if (!selectedManifest) {
             throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest.`);
         }
-        const cargoTomlRaw = node_fs_1.default.readFileSync(node_path_1.default.join(cwd, selectedManifest), "utf8");
+        const cargoTomlRaw = fs.readFileSync(path.join(cwd, selectedManifest), "utf8");
         return readResolvedCargoVersion(cwd, selectedManifest, cargoTomlRaw);
     },
     validateProject(cwd, config) {
@@ -656,11 +647,11 @@ exports.rustVersionStrategy = {
             if (!selectedManifest) {
                 return null;
             }
-            const versionPath = node_path_1.default.join(cwd, selectedManifest);
-            if (!node_fs_1.default.existsSync(versionPath)) {
+            const versionPath = path.join(cwd, selectedManifest);
+            if (!fs.existsSync(versionPath)) {
                 return null;
             }
-            const cargoTomlRaw = node_fs_1.default.readFileSync(versionPath, "utf8");
+            const cargoTomlRaw = fs.readFileSync(versionPath, "utf8");
             readResolvedCargoVersion(cwd, selectedManifest, cargoTomlRaw);
             return null;
         }
@@ -675,11 +666,11 @@ exports.rustVersionStrategy = {
         const internalCrates = new Set();
         const workspaceManifestsToUpdate = new Set();
         for (const manifest of manifests) {
-            const versionPath = node_path_1.default.join(cwd, manifest);
-            if (!node_fs_1.default.existsSync(versionPath)) {
+            const versionPath = path.join(cwd, manifest);
+            if (!fs.existsSync(versionPath)) {
                 continue;
             }
-            const cargoTomlRaw = node_fs_1.default.readFileSync(versionPath, "utf8");
+            const cargoTomlRaw = fs.readFileSync(versionPath, "utf8");
             if (!isCrateManifest(manifest, cargoTomlRaw)) {
                 continue;
             }
@@ -687,11 +678,11 @@ exports.rustVersionStrategy = {
             readResolvedCargoVersion(cwd, manifest, cargoTomlRaw);
         }
         for (const manifest of manifests) {
-            const versionPath = node_path_1.default.join(cwd, manifest);
-            if (!node_fs_1.default.existsSync(versionPath)) {
+            const versionPath = path.join(cwd, manifest);
+            if (!fs.existsSync(versionPath)) {
                 continue;
             }
-            const cargoTomlRaw = node_fs_1.default.readFileSync(versionPath, "utf8");
+            const cargoTomlRaw = fs.readFileSync(versionPath, "utf8");
             if (!isCrateManifest(manifest, cargoTomlRaw)) {
                 continue;
             }
@@ -704,19 +695,19 @@ exports.rustVersionStrategy = {
             }
             updatedCargoToml = writeInternalDependencyVersions(updatedCargoToml, internalCrates, version);
             if (updatedCargoToml !== cargoTomlRaw) {
-                node_fs_1.default.writeFileSync(versionPath, updatedCargoToml, "utf8");
+                fs.writeFileSync(versionPath, updatedCargoToml, "utf8");
                 updatedFiles.push(manifest);
             }
         }
         for (const workspaceManifest of workspaceManifestsToUpdate) {
-            const workspacePath = node_path_1.default.join(cwd, workspaceManifest);
-            if (!node_fs_1.default.existsSync(workspacePath)) {
+            const workspacePath = path.join(cwd, workspaceManifest);
+            if (!fs.existsSync(workspacePath)) {
                 continue;
             }
-            const workspaceRaw = node_fs_1.default.readFileSync(workspacePath, "utf8");
+            const workspaceRaw = fs.readFileSync(workspacePath, "utf8");
             const updatedWorkspaceToml = writeInternalDependencyVersions(writeWorkspacePackageVersion(workspaceRaw, workspaceManifest, version), internalCrates, version);
             if (updatedWorkspaceToml !== workspaceRaw) {
-                node_fs_1.default.writeFileSync(workspacePath, updatedWorkspaceToml, "utf8");
+                fs.writeFileSync(workspacePath, updatedWorkspaceToml, "utf8");
                 updatedFiles.push(workspaceManifest);
             }
         }
@@ -732,11 +723,11 @@ exports.rustVersionStrategy = {
         if (!selectedManifest) {
             throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest.`);
         }
-        const versionPath = node_path_1.default.join(cwd, selectedManifest);
-        if (!node_fs_1.default.existsSync(versionPath)) {
+        const versionPath = path.join(cwd, selectedManifest);
+        if (!fs.existsSync(versionPath)) {
             throw new Error(`Versionary requires ${selectedManifest} to exist.`);
         }
-        const cargoTomlRaw = node_fs_1.default.readFileSync(versionPath, "utf8");
+        const cargoTomlRaw = fs.readFileSync(versionPath, "utf8");
         if (!isCrateManifest(selectedManifest, cargoTomlRaw)) {
             return null;
         }
@@ -748,7 +739,7 @@ exports.rustVersionStrategy = {
         const manifestToPath = new Map();
         for (const pkg of packages) {
             const manifest = pkg.versionFile;
-            if (node_path_1.default.posix.basename(normalizeSlashPath(manifest)) !== "Cargo.toml") {
+            if (path.posix.basename(normalizeSlashPath(manifest)) !== "Cargo.toml") {
                 continue;
             }
             candidateManifests.push(manifest);
@@ -766,7 +757,7 @@ exports.rustVersionStrategy = {
     finalizeVersionWrites(cwd, writes, _context) {
         const manifestToVersion = {};
         for (const write of writes) {
-            if (node_path_1.default.posix.basename(normalizeSlashPath(write.versionFile)) !==
+            if (path.posix.basename(normalizeSlashPath(write.versionFile)) !==
                 "Cargo.toml") {
                 continue;
             }

package/dist/strategy/simple.js

@@ -1,28 +1,22 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.simpleVersionStrategy = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-exports.simpleVersionStrategy = {
+import fs from "node:fs";
+import path from "node:path";
+export const simpleVersionStrategy = {
     name: "simple",
     getVersionFile(config) {
         return config["version-file"] ?? "version.txt";
     },
     readVersion(cwd, config) {
         const versionFile = this.getVersionFile(config);
-        const versionPath = node_path_1.default.join(cwd, versionFile);
-        if (!node_fs_1.default.existsSync(versionPath)) {
+        const versionPath = path.join(cwd, versionFile);
+        if (!fs.existsSync(versionPath)) {
             throw new Error(`Versionary requires ${versionFile} to exist.`);
         }
-        return node_fs_1.default.readFileSync(versionPath, "utf8").trim();
+        return fs.readFileSync(versionPath, "utf8").trim();
     },
     writeVersion(cwd, config, version) {
         const versionFile = this.getVersionFile(config);
-        const versionPath = node_path_1.default.join(cwd, versionFile);
-        node_fs_1.default.writeFileSync(versionPath, `${version}\n`, "utf8");
+        const versionPath = path.join(cwd, versionFile);
+        fs.writeFileSync(versionPath, `${version}\n`, "utf8");
         return [versionFile];
     },
 };

package/dist/strategy/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/types/config.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/types/plugins.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.28.0",
+  "version": "0.28.2",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",
@@ -17,7 +17,7 @@
   },
   "license": "MIT",
   "author": "Johan Larsson",
-  "type": "commonjs",
+  "type": "module",
   "bin": {
     "versionary": "dist/cli/index.js"
   },
@@ -27,7 +27,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "@iarna/toml": "^2.2.5",
+    "smol-toml": "^1.4.2",
     "@octokit/rest": "^22.0.0",
     "jsonc-parser": "^3.3.1",
     "yaml": "^2.8.3",