@williamthorsen/release-kit 6.0.0 → 7.0.0

package/dist/esm/loadConfig.js

@@ -1,256 +1,237 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import {
-  DEFAULT_CHANGELOG_JSON_CONFIG,
-  DEFAULT_PROJECT_TAG_PREFIX,
-  DEFAULT_RELEASE_NOTES_CONFIG,
-  DEFAULT_VERSION_PATTERNS,
-  DEFAULT_WORK_TYPES
-} from "./defaults.js";
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { DEFAULT_CHANGELOG_JSON_CONFIG, DEFAULT_PROJECT_TAG_PREFIX, DEFAULT_RELEASE_NOTES_CONFIG, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES, } from "./defaults.js";
 import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
 import { isRecord } from "./typeGuards.js";
-const ROOT_PACKAGE_JSON_PATH = "package.json";
-function readRootPackageVersion() {
-  const absolutePath = path.resolve(process.cwd(), ROOT_PACKAGE_JSON_PATH);
-  if (!existsSync(absolutePath)) {
-    return { exists: false, version: void 0 };
-  }
-  let contents;
-  try {
-    contents = readFileSync(absolutePath, "utf8");
-  } catch (error) {
-    throw new Error(
-      `Failed to read root ${ROOT_PACKAGE_JSON_PATH}: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(contents);
-  } catch (error) {
-    throw new Error(
-      `Failed to parse root ${ROOT_PACKAGE_JSON_PATH}: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  if (!isRecord(parsed)) {
-    return { exists: true, version: void 0 };
-  }
-  return { exists: true, version: typeof parsed.version === "string" ? parsed.version : void 0 };
+export const ROOT_PACKAGE_JSON_PATH = 'package.json';
+export function readRootPackageVersion() {
+    const absolutePath = path.resolve(process.cwd(), ROOT_PACKAGE_JSON_PATH);
+    if (!existsSync(absolutePath)) {
+        return { exists: false, version: undefined };
+    }
+    let contents;
+    try {
+        contents = readFileSync(absolutePath, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`Failed to read root ${ROOT_PACKAGE_JSON_PATH}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse root ${ROOT_PACKAGE_JSON_PATH}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isRecord(parsed)) {
+        return { exists: true, version: undefined };
+    }
+    return { exists: true, version: typeof parsed.version === 'string' ? parsed.version : undefined };
 }
-const CONFIG_FILE_PATH = ".config/release-kit.config.ts";
-async function loadConfig() {
-  const absoluteConfigPath = path.resolve(process.cwd(), CONFIG_FILE_PATH);
-  if (!existsSync(absoluteConfigPath)) {
-    return void 0;
-  }
-  const { createJiti } = await import("jiti");
-  const jiti = createJiti(import.meta.url);
-  const imported = await jiti.import(absoluteConfigPath);
-  if (!isRecord(imported)) {
-    throw new Error(`Config file must export an object, got ${Array.isArray(imported) ? "array" : typeof imported}`);
-  }
-  const resolved = imported.default ?? imported.config;
-  if (resolved === void 0) {
-    throw new Error(
-      "Config file must have a default export or a named `config` export (e.g., `export default { ... }` or `export const config = { ... }`)"
-    );
-  }
-  return resolved;
+export const CONFIG_FILE_PATH = '.config/release-kit.config.ts';
+export async function loadConfig() {
+    const absoluteConfigPath = path.resolve(process.cwd(), CONFIG_FILE_PATH);
+    if (!existsSync(absoluteConfigPath)) {
+        return undefined;
+    }
+    const { createJiti } = await import('jiti');
+    const jiti = createJiti(import.meta.url);
+    const imported = await jiti.import(absoluteConfigPath);
+    if (!isRecord(imported)) {
+        throw new Error(`Config file must export an object, got ${Array.isArray(imported) ? 'array' : typeof imported}`);
+    }
+    const resolved = imported.default ?? imported.config;
+    if (resolved === undefined) {
+        throw new Error('Config file must have a default export or a named `config` export (e.g., `export default { ... }` or `export const config = { ... }`)');
+    }
+    return resolved;
 }
-function mergeMonorepoConfig(discoveredPaths, userConfig, rootPackage) {
-  let workspaces = discoveredPaths.map((workspacePath) => deriveWorkspaceConfig(workspacePath));
-  assertUniqueTagPrefixes(workspaces);
-  if (userConfig?.workspaces !== void 0) {
-    const overrides = new Map(userConfig.workspaces.map((w) => [w.dir, w]));
-    workspaces = workspaces.filter((w) => {
-      const override = overrides.get(w.dir);
-      return override?.shouldExclude !== true;
-    }).map((w) => {
-      const override = overrides.get(w.dir);
-      if (override?.legacyIdentities === void 0) {
-        return w;
-      }
-      assertLegacyIdentityDoesNotMatchCurrent(w.dir, w.name, w.tagPrefix, override.legacyIdentities);
-      return { ...w, legacyIdentities: override.legacyIdentities.map((identity) => ({ ...identity })) };
-    });
-  }
-  if (userConfig?.retiredPackages !== void 0) {
-    assertRetiredPackagesDoNotCollideWithActive(workspaces, userConfig.retiredPackages);
-  }
-  const project = resolveProjectConfig(userConfig?.project, rootPackage);
-  const workTypes = resolveWorkTypes(userConfig?.workTypes);
-  const versionPatterns = userConfig?.versionPatterns === void 0 ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
-  const changelogJson = mergeChangelogJsonConfig(userConfig?.changelogJson);
-  const releaseNotes = mergeReleaseNotesConfig(userConfig?.releaseNotes);
-  assertNoTagPrefixCollisions(workspaces, userConfig?.retiredPackages, project);
-  const result = {
-    workspaces,
-    workTypes,
-    versionPatterns,
-    changelogJson,
-    releaseNotes
-  };
-  if (project !== void 0) {
-    result.project = project;
-  }
-  applyOptionalPassthroughFields(result, userConfig);
-  return result;
+export function mergeMonorepoConfig(discoveredPaths, userConfig, rootPackage) {
+    let workspaces = discoveredPaths.map((workspacePath) => deriveWorkspaceConfig(workspacePath));
+    assertUniqueTagPrefixes(workspaces);
+    if (userConfig?.workspaces !== undefined) {
+        const overrides = new Map(userConfig.workspaces.map((w) => [w.dir, w]));
+        workspaces = workspaces
+            .filter((w) => {
+            const override = overrides.get(w.dir);
+            return override?.shouldExclude !== true;
+        })
+            .map((w) => {
+            const override = overrides.get(w.dir);
+            if (override?.legacyIdentities === undefined) {
+                return w;
+            }
+            assertLegacyIdentityDoesNotMatchCurrent(w.dir, w.name, w.tagPrefix, override.legacyIdentities);
+            return { ...w, legacyIdentities: override.legacyIdentities.map((identity) => ({ ...identity })) };
+        });
+    }
+    if (userConfig?.retiredPackages !== undefined) {
+        assertRetiredPackagesDoNotCollideWithActive(workspaces, userConfig.retiredPackages);
+    }
+    const project = resolveProjectConfig(userConfig?.project, rootPackage);
+    const workTypes = resolveWorkTypes(userConfig?.workTypes);
+    const versionPatterns = userConfig?.versionPatterns === undefined ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
+    const changelogJson = mergeChangelogJsonConfig(userConfig?.changelogJson);
+    const releaseNotes = mergeReleaseNotesConfig(userConfig?.releaseNotes);
+    assertNoTagPrefixCollisions(workspaces, userConfig?.retiredPackages, project);
+    const result = {
+        workspaces,
+        workTypes,
+        versionPatterns,
+        changelogJson,
+        releaseNotes,
+    };
+    if (project !== undefined) {
+        result.project = project;
+    }
+    applyOptionalPassthroughFields(result, userConfig);
+    return result;
 }
 function applyOptionalPassthroughFields(result, userConfig) {
-  if (userConfig?.formatCommand !== void 0) {
-    result.formatCommand = userConfig.formatCommand;
-  }
-  if (userConfig?.cliffConfigPath !== void 0) {
-    result.cliffConfigPath = userConfig.cliffConfigPath;
-  }
-  if (userConfig?.scopeAliases !== void 0) {
-    result.scopeAliases = userConfig.scopeAliases;
-  }
-  if (userConfig?.breakingPolicies !== void 0) {
-    result.breakingPolicies = userConfig.breakingPolicies;
-  }
+    if (userConfig?.formatCommand !== undefined) {
+        result.formatCommand = userConfig.formatCommand;
+    }
+    if (userConfig?.cliffConfigPath !== undefined) {
+        result.cliffConfigPath = userConfig.cliffConfigPath;
+    }
+    if (userConfig?.scopeAliases !== undefined) {
+        result.scopeAliases = userConfig.scopeAliases;
+    }
+    if (userConfig?.breakingPolicies !== undefined) {
+        result.breakingPolicies = userConfig.breakingPolicies;
+    }
 }
-function mergeSinglePackageConfig(userConfig) {
-  if (userConfig?.project !== void 0) {
-    throw new Error("project block is not supported in single-package mode");
-  }
-  const workTypes = resolveWorkTypes(userConfig?.workTypes);
-  const versionPatterns = userConfig?.versionPatterns === void 0 ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
-  const changelogJson = mergeChangelogJsonConfig(userConfig?.changelogJson);
-  const releaseNotes = mergeReleaseNotesConfig(userConfig?.releaseNotes);
-  const result = {
-    tagPrefix: "v",
-    packageFiles: ["package.json"],
-    changelogPaths: ["."],
-    workTypes,
-    versionPatterns,
-    changelogJson,
-    releaseNotes
-  };
-  applyOptionalPassthroughFields(result, userConfig);
-  return result;
+export function mergeSinglePackageConfig(userConfig) {
+    if (userConfig?.project !== undefined) {
+        throw new Error('project block is not supported in single-package mode');
+    }
+    const workTypes = resolveWorkTypes(userConfig?.workTypes);
+    const versionPatterns = userConfig?.versionPatterns === undefined ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
+    const changelogJson = mergeChangelogJsonConfig(userConfig?.changelogJson);
+    const releaseNotes = mergeReleaseNotesConfig(userConfig?.releaseNotes);
+    const result = {
+        tagPrefix: 'v',
+        packageFiles: ['package.json'],
+        changelogPaths: ['.'],
+        workTypes,
+        versionPatterns,
+        changelogJson,
+        releaseNotes,
+    };
+    applyOptionalPassthroughFields(result, userConfig);
+    return result;
 }
-function resolveWorkTypes(userWorkTypes) {
-  return userWorkTypes === void 0 ? { ...DEFAULT_WORK_TYPES } : { ...DEFAULT_WORK_TYPES, ...userWorkTypes };
+export function resolveWorkTypes(userWorkTypes) {
+    return userWorkTypes === undefined ? { ...DEFAULT_WORK_TYPES } : { ...DEFAULT_WORK_TYPES, ...userWorkTypes };
 }
 function mergeChangelogJsonConfig(partial) {
-  if (partial === void 0) {
-    return { ...DEFAULT_CHANGELOG_JSON_CONFIG };
-  }
-  return {
-    enabled: partial.enabled ?? DEFAULT_CHANGELOG_JSON_CONFIG.enabled,
-    outputPath: partial.outputPath ?? DEFAULT_CHANGELOG_JSON_CONFIG.outputPath,
-    devOnlySections: partial.devOnlySections ?? [...DEFAULT_CHANGELOG_JSON_CONFIG.devOnlySections]
-  };
+    if (partial === undefined) {
+        return { ...DEFAULT_CHANGELOG_JSON_CONFIG };
+    }
+    return {
+        enabled: partial.enabled ?? DEFAULT_CHANGELOG_JSON_CONFIG.enabled,
+        outputPath: partial.outputPath ?? DEFAULT_CHANGELOG_JSON_CONFIG.outputPath,
+        devOnlySections: partial.devOnlySections ?? [...DEFAULT_CHANGELOG_JSON_CONFIG.devOnlySections],
+    };
 }
 function assertLegacyIdentityDoesNotMatchCurrent(dir, currentName, currentTagPrefix, legacyIdentities) {
-  for (const identity of legacyIdentities) {
-    if (identity.name === currentName && identity.tagPrefix === currentTagPrefix) {
-      throw new Error(
-        `Workspace '${dir}': legacyIdentities must not match the current identity (name='${currentName}', tagPrefix='${currentTagPrefix}'). The current identity is always searched; listing it again is a no-op.`
-      );
+    for (const identity of legacyIdentities) {
+        if (identity.name === currentName && identity.tagPrefix === currentTagPrefix) {
+            throw new Error(`Workspace '${dir}': legacyIdentities must not match the current identity ` +
+                `(name='${currentName}', tagPrefix='${currentTagPrefix}'). ` +
+                'The current identity is always searched; listing it again is a no-op.');
+        }
     }
-  }
 }
 function assertRetiredPackagesDoNotCollideWithActive(workspaces, retiredPackages) {
-  const workspaceByDerivedPrefix = /* @__PURE__ */ new Map();
-  for (const workspace of workspaces) {
-    workspaceByDerivedPrefix.set(workspace.tagPrefix, workspace);
-  }
-  for (const retired of retiredPackages) {
-    const active = workspaceByDerivedPrefix.get(retired.tagPrefix);
-    if (active !== void 0) {
-      throw new Error(
-        `retiredPackages: tagPrefix '${retired.tagPrefix}' collides with active workspace '${active.dir}' (derived prefix '${active.tagPrefix}'). A retired package's tagPrefix cannot belong to an active workspace.`
-      );
+    const workspaceByDerivedPrefix = new Map();
+    for (const workspace of workspaces) {
+        workspaceByDerivedPrefix.set(workspace.tagPrefix, workspace);
+    }
+    for (const retired of retiredPackages) {
+        const active = workspaceByDerivedPrefix.get(retired.tagPrefix);
+        if (active !== undefined) {
+            throw new Error(`retiredPackages: tagPrefix '${retired.tagPrefix}' collides with active workspace '${active.dir}' ` +
+                `(derived prefix '${active.tagPrefix}'). A retired package's tagPrefix cannot belong to an active workspace.`);
+        }
     }
-  }
 }
 function resolveProjectConfig(userProject, rootPackage) {
-  if (userProject === void 0) {
-    return void 0;
-  }
-  if (rootPackage === void 0 || !rootPackage.exists) {
-    throw new Error(
-      `project block requires a root ${ROOT_PACKAGE_JSON_PATH}; create one with a 'version' field at the repo root`
-    );
-  }
-  if (rootPackage.version === void 0) {
-    throw new Error(
-      `project block requires root ${ROOT_PACKAGE_JSON_PATH} to have a 'version' field; add a 'version' field to your root package.json`
-    );
-  }
-  return { tagPrefix: userProject.tagPrefix ?? DEFAULT_PROJECT_TAG_PREFIX };
+    if (userProject === undefined) {
+        return undefined;
+    }
+    if (rootPackage === undefined || !rootPackage.exists) {
+        throw new Error(`project block requires a root ${ROOT_PACKAGE_JSON_PATH}; create one with a 'version' field at the repo root`);
+    }
+    if (rootPackage.version === undefined) {
+        throw new Error(`project block requires root ${ROOT_PACKAGE_JSON_PATH} to have a 'version' field; add a 'version' field to your root package.json`);
+    }
+    return { tagPrefix: userProject.tagPrefix ?? DEFAULT_PROJECT_TAG_PREFIX };
 }
 function assertNoTagPrefixCollisions(workspaces, retiredPackages, project) {
-  const sources = [];
-  for (const workspace of workspaces) {
-    const owner = `ws:${workspace.dir}`;
-    sources.push({ prefix: workspace.tagPrefix, label: `workspace '${workspace.dir}'`, owner });
-    for (const identity of workspace.legacyIdentities ?? []) {
-      sources.push({
-        prefix: identity.tagPrefix,
-        label: `workspace '${workspace.dir}' legacyIdentities entry (name='${identity.name}')`,
-        owner
-      });
+    const sources = [];
+    for (const workspace of workspaces) {
+        const owner = `ws:${workspace.dir}`;
+        sources.push({ prefix: workspace.tagPrefix, label: `workspace '${workspace.dir}'`, owner });
+        for (const identity of workspace.legacyIdentities ?? []) {
+            sources.push({
+                prefix: identity.tagPrefix,
+                label: `workspace '${workspace.dir}' legacyIdentities entry (name='${identity.name}')`,
+                owner,
+            });
+        }
     }
-  }
-  for (const [index, retired] of (retiredPackages ?? []).entries()) {
-    sources.push({
-      prefix: retired.tagPrefix,
-      label: `retiredPackages entry (name='${retired.name}')`,
-      owner: `retired:${index}`
-    });
-  }
-  if (project !== void 0) {
-    sources.push({ prefix: project.tagPrefix, label: "project", owner: "project" });
-  }
-  for (let i = 0; i < sources.length; i++) {
-    for (let j = i + 1; j < sources.length; j++) {
-      const a = sources[i];
-      const b = sources[j];
-      if (a === void 0 || b === void 0) continue;
-      if (a.owner === b.owner) continue;
-      if (isPrefixCollision(a.prefix, b.prefix)) {
-        throw new Error(
-          `Tag prefix collision: '${a.prefix}' (${a.label}) and '${b.prefix}' (${b.label}). One prefix is identical to or a strict prefix of the other; this would cause \`git describe --match=<prefix>*\` to return cross-matches.`
-        );
-      }
+    for (const [index, retired] of (retiredPackages ?? []).entries()) {
+        sources.push({
+            prefix: retired.tagPrefix,
+            label: `retiredPackages entry (name='${retired.name}')`,
+            owner: `retired:${index}`,
+        });
+    }
+    if (project !== undefined) {
+        sources.push({ prefix: project.tagPrefix, label: 'project', owner: 'project' });
+    }
+    for (let i = 0; i < sources.length; i++) {
+        for (let j = i + 1; j < sources.length; j++) {
+            const a = sources[i];
+            const b = sources[j];
+            if (a === undefined || b === undefined)
+                continue;
+            if (a.owner === b.owner)
+                continue;
+            if (isPrefixCollision(a.prefix, b.prefix)) {
+                throw new Error(`Tag prefix collision: '${a.prefix}' (${a.label}) and '${b.prefix}' (${b.label}). ` +
+                    'One prefix is identical to or a strict prefix of the other; ' +
+                    'this would cause `git describe --match=<prefix>*` to return cross-matches.');
+            }
+        }
     }
-  }
 }
 function isPrefixCollision(a, b) {
-  return a === b || a.startsWith(b) || b.startsWith(a);
+    return a === b || a.startsWith(b) || b.startsWith(a);
 }
 function assertUniqueTagPrefixes(workspaces) {
-  const pathsByPrefix = /* @__PURE__ */ new Map();
-  for (const workspace of workspaces) {
-    const existing = pathsByPrefix.get(workspace.tagPrefix);
-    if (existing === void 0) {
-      pathsByPrefix.set(workspace.tagPrefix, [workspace.workspacePath]);
-    } else {
-      existing.push(workspace.workspacePath);
+    const pathsByPrefix = new Map();
+    for (const workspace of workspaces) {
+        const existing = pathsByPrefix.get(workspace.tagPrefix);
+        if (existing === undefined) {
+            pathsByPrefix.set(workspace.tagPrefix, [workspace.workspacePath]);
+        }
+        else {
+            existing.push(workspace.workspacePath);
+        }
     }
-  }
-  for (const [prefix, paths] of pathsByPrefix) {
-    if (paths.length > 1) {
-      throw new Error(`Duplicate tag prefix '${prefix}' for workspaces: ${paths.join(", ")}`);
+    for (const [prefix, paths] of pathsByPrefix) {
+        if (paths.length > 1) {
+            throw new Error(`Duplicate tag prefix '${prefix}' for workspaces: ${paths.join(', ')}`);
+        }
     }
-  }
 }
 function mergeReleaseNotesConfig(partial) {
-  if (partial === void 0) {
-    return { ...DEFAULT_RELEASE_NOTES_CONFIG };
-  }
-  return {
-    shouldInjectIntoReadme: partial.shouldInjectIntoReadme ?? DEFAULT_RELEASE_NOTES_CONFIG.shouldInjectIntoReadme
-  };
+    if (partial === undefined) {
+        return { ...DEFAULT_RELEASE_NOTES_CONFIG };
+    }
+    return {
+        shouldInjectIntoReadme: partial.shouldInjectIntoReadme ?? DEFAULT_RELEASE_NOTES_CONFIG.shouldInjectIntoReadme,
+    };
 }
-export {
-  CONFIG_FILE_PATH,
-  ROOT_PACKAGE_JSON_PATH,
-  loadConfig,
-  mergeMonorepoConfig,
-  mergeSinglePackageConfig,
-  readRootPackageVersion,
-  resolveWorkTypes
-};

package/dist/esm/parseCommitMessage.d.ts

@@ -1,4 +1,4 @@
-import type { Commit, ParsedCommit, WorkTypeConfig } from './types.ts';
+import type { Commit, ParsedCommit, WorkTypeConfig } from './types.js';
 export declare const COMMIT_PREPROCESSOR_PATTERNS: readonly RegExp[];
 export type PolicyViolationSurface = 'prefix' | 'body';
 export type PolicyViolationHandler = (commit: Commit, type: string, surface: PolicyViolationSurface) => void;

package/dist/esm/parseCommitMessage.js

@@ -1,87 +1,83 @@
-const COMMIT_PREPROCESSOR_PATTERNS = [/^##\s+/, /^#\d+([.-]\d+)?\s+/, /^[A-Z]+-\d+\s+/];
-function parseCommitMessage(message, hash, workTypes, scopeAliases, options) {
-  const firstLine = message.split("\n", 1)[0] ?? "";
-  const stripped = stripTicketPrefix(firstLine);
-  const match = stripped.match(/^(?:([^|]+)\|)?(\w+)(?:\(([^)]+)\))?(!)?:\s*(.*)$/);
-  if (!match) {
-    return void 0;
-  }
-  const pipeScope = match[1];
-  const rawType = match[2];
-  const parenthesizedScope = match[3];
-  const breakingMarker = match[4];
-  const description = match[5];
-  if (rawType === void 0 || description === void 0) {
-    return void 0;
-  }
-  const resolvedType = resolveType(rawType, workTypes);
-  if (resolvedType === void 0) {
-    return void 0;
-  }
-  const commit = { message, hash };
-  const breaking = evaluateBreakingPolicy({
-    commit,
-    resolvedType,
-    hasPrefixBreaking: breakingMarker === "!",
-    hasFooterBreaking: message.includes("BREAKING CHANGE:"),
-    policy: options?.breakingPolicies?.[resolvedType] ?? "optional",
-    onPolicyViolation: options?.onPolicyViolation
-  });
-  const rawScope = pipeScope ?? parenthesizedScope;
-  const resolvedScope = rawScope !== void 0 && scopeAliases !== void 0 ? scopeAliases[rawScope] ?? rawScope : rawScope;
-  return {
-    message,
-    hash,
-    type: resolvedType,
-    description,
-    breaking,
-    ...resolvedScope !== void 0 && { scope: resolvedScope }
-  };
+export const COMMIT_PREPROCESSOR_PATTERNS = [/^##\s+/, /^#\d+([.-]\d+)?\s+/, /^[A-Z]+-\d+\s+/];
+export function parseCommitMessage(message, hash, workTypes, scopeAliases, options) {
+    const firstLine = message.split('\n', 1)[0] ?? '';
+    const stripped = stripTicketPrefix(firstLine);
+    const match = stripped.match(/^(?:([^|]+)\|)?(\w+)(?:\(([^)]+)\))?(!)?:\s*(.*)$/);
+    if (!match) {
+        return undefined;
+    }
+    const pipeScope = match[1];
+    const rawType = match[2];
+    const parenthesizedScope = match[3];
+    const breakingMarker = match[4];
+    const description = match[5];
+    if (rawType === undefined || description === undefined) {
+        return undefined;
+    }
+    const resolvedType = resolveType(rawType, workTypes);
+    if (resolvedType === undefined) {
+        return undefined;
+    }
+    const commit = { message, hash };
+    const breaking = evaluateBreakingPolicy({
+        commit,
+        resolvedType,
+        hasPrefixBreaking: breakingMarker === '!',
+        hasFooterBreaking: message.includes('BREAKING CHANGE:'),
+        policy: options?.breakingPolicies?.[resolvedType] ?? 'optional',
+        onPolicyViolation: options?.onPolicyViolation,
+    });
+    const rawScope = pipeScope ?? parenthesizedScope;
+    const resolvedScope = rawScope !== undefined && scopeAliases !== undefined ? (scopeAliases[rawScope] ?? rawScope) : rawScope;
+    return {
+        message,
+        hash,
+        type: resolvedType,
+        description,
+        breaking,
+        ...(resolvedScope !== undefined && { scope: resolvedScope }),
+    };
 }
 function evaluateBreakingPolicy(inputs) {
-  const { commit, resolvedType, hasPrefixBreaking, hasFooterBreaking, policy, onPolicyViolation } = inputs;
-  if (policy === "forbidden") {
-    if (hasPrefixBreaking) {
-      onPolicyViolation?.(commit, resolvedType, "prefix");
-    }
-    if (hasFooterBreaking) {
-      onPolicyViolation?.(commit, resolvedType, "body");
+    const { commit, resolvedType, hasPrefixBreaking, hasFooterBreaking, policy, onPolicyViolation } = inputs;
+    if (policy === 'forbidden') {
+        if (hasPrefixBreaking) {
+            onPolicyViolation?.(commit, resolvedType, 'prefix');
+        }
+        if (hasFooterBreaking) {
+            onPolicyViolation?.(commit, resolvedType, 'body');
+        }
+        return false;
     }
-    return false;
-  }
-  if (policy === "required") {
-    if (!hasPrefixBreaking) {
-      onPolicyViolation?.(commit, resolvedType, "prefix");
-      return false;
+    if (policy === 'required') {
+        if (!hasPrefixBreaking) {
+            onPolicyViolation?.(commit, resolvedType, 'prefix');
+            return false;
+        }
+        return true;
     }
-    return true;
-  }
-  return hasPrefixBreaking || hasFooterBreaking;
+    return hasPrefixBreaking || hasFooterBreaking;
 }
 function resolveType(rawType, workTypes) {
-  const lowered = rawType.toLowerCase();
-  for (const [key, config] of Object.entries(workTypes)) {
-    if (key === lowered) {
-      return key;
-    }
-    if (config.aliases !== void 0) {
-      for (const alias of config.aliases) {
-        if (alias === lowered) {
-          return key;
+    const lowered = rawType.toLowerCase();
+    for (const [key, config] of Object.entries(workTypes)) {
+        if (key === lowered) {
+            return key;
+        }
+        if (config.aliases !== undefined) {
+            for (const alias of config.aliases) {
+                if (alias === lowered) {
+                    return key;
+                }
+            }
         }
-      }
     }
-  }
-  return void 0;
+    return undefined;
 }
 function stripTicketPrefix(message) {
-  let result = message;
-  for (const pattern of COMMIT_PREPROCESSOR_PATTERNS) {
-    result = result.replace(pattern, "");
-  }
-  return result;
+    let result = message;
+    for (const pattern of COMMIT_PREPROCESSOR_PATTERNS) {
+        result = result.replace(pattern, '');
+    }
+    return result;
 }
-export {
-  COMMIT_PREPROCESSOR_PATTERNS,
-  parseCommitMessage
-};