@mnaoumov/typescript-dev-toolkit 6.0.2 → 6.1.0

package/dist/lib/esm/version.mjs

@@ -53,6 +53,7 @@ import {
   writeFile
 } from "node:fs/promises";
 import { tmpdir } from "node:os";
+import { basename } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 import {
@@ -254,9 +255,8 @@ function parseVersionArguments($arguments) {
   };
 }
 async function publishGitHubRelease(newVersion, options = {}) {
-  const { getReleaseAssetPaths = getNpmPackReleaseAssetPaths, shouldCloseReleasedIssues = true } = options;
-  let filePaths = await getReleaseAssetPaths();
-  filePaths = filePaths.filter((filePath) => existsSync(resolvePathFromRootSafe({ path: filePath })));
+  const { getReleaseAssetPaths = getNpmPackReleaseAssetPaths, shouldCloseReleasedIssues = true, shouldVerifyRelease = false } = options;
+  const filePaths = await resolveReleaseAssetPaths(getReleaseAssetPaths, shouldVerifyRelease);
   await execFromRoot([
     "gh",
     "release",
@@ -265,6 +265,7 @@ async function publishGitHubRelease(newVersion, options = {}) {
     ...filePaths,
     "--title",
     `v${newVersion}`,
+    ...shouldVerifyRelease ? ["--verify-tag"] : [],
     ...isPreRelease(newVersion) ? ["--prerelease"] : [],
     "--notes-file",
     "-"
@@ -272,14 +273,13 @@ async function publishGitHubRelease(newVersion, options = {}) {
     isQuiet: true,
     stdin: await getReleaseNotes(newVersion)
   });
+  if (shouldVerifyRelease) {
+    await verifyGitHubRelease(newVersion, filePaths);
+  }
   if (!shouldCloseReleasedIssues) {
     return;
   }
-  try {
-    await closeReleasedIssues({ newVersion });
-  } catch (error) {
-    console.warn(`The ${newVersion} release is published, but closing the issues it carries failed: ${errorToString(error)}`);
-  }
+  await closeReleasedIssuesSafely(newVersion, true);
 }
 function toUpdateVersionOptions(values) {
   return {
@@ -298,11 +298,12 @@ async function updateChangelog(newVersion, options = {}) {
 async function updateVersion(versionUpdateType, options = {}) {
   const {
     changelogFilePath,
-    getReleaseAssetPaths,
+    getReleaseAssetPaths = getNpmPackReleaseAssetPaths,
     prepareGitHubRelease,
     shouldBuild = true,
     shouldCloseReleasedIssues = true,
     shouldEditChangelog = true,
+    shouldPublishBeforePush = false,
     shouldRelease = true,
     shouldRunChecks = true,
     shouldVerifyCommit = true,
@@ -348,6 +349,25 @@ async function updateVersion(versionUpdateType, options = {}) {
     getLibDebugger("Version")("Skipping git push and GitHub release (--no-release). The version bump, changelog, commit, and tag have been created locally.");
     return;
   }
+  if (shouldPublishBeforePush) {
+    await prepareGitHubRelease?.(newVersion);
+    const filePaths = await resolveReleaseAssetPaths(getReleaseAssetPaths, true);
+    await assertReleaseCommitLanded(newVersion, startHead, "pushing");
+    const tagCommitSha = await execFromRoot(["git", "rev-parse", `refs/tags/${newVersion}^{}`], { isQuiet: true });
+    if (tagCommitSha !== releaseCommitSha) {
+      throw new Error(`Refusing to push ${newVersion}: its tag no longer names the verified release commit.`);
+    }
+    await execFromRoot(["git", "push", "origin", `refs/tags/${newVersion}:refs/tags/${newVersion}`], { isQuiet: true });
+    await publishGitHubRelease(newVersion, {
+      getReleaseAssetPaths: () => Promise.resolve(filePaths),
+      shouldCloseReleasedIssues: false,
+      shouldVerifyRelease: true
+    });
+    await assertReleaseCommitLanded(newVersion, startHead, "pushing");
+    await execFromRoot(["git", "push", "origin", `${releaseCommitSha}:refs/heads/${startHead.branch}`], { isQuiet: true });
+    await closeReleasedIssuesSafely(newVersion, shouldCloseReleasedIssues);
+    return;
+  }
   await assertReleaseCommitLanded(newVersion, startHead, "pushing");
   await gitPush();
   await prepareGitHubRelease?.(newVersion);
@@ -447,6 +467,16 @@ async function assertVersionUpdateTypeMeetsBumpFloor(versionUpdateType) {
     versionUpdateType
   });
 }
+async function closeReleasedIssuesSafely(newVersion, shouldClose) {
+  if (!shouldClose) {
+    return;
+  }
+  try {
+    await closeReleasedIssues({ newVersion });
+  } catch (error) {
+    console.warn(`The ${newVersion} release is published, but closing the issues it carries failed: ${errorToString(error)}`);
+  }
+}
 async function composeChangelog(newVersion, changelogFilePath) {
   const previousChangelogLines = await readPreviousChangelogLines();
   let newChangeLog = `# CHANGELOG
@@ -658,6 +688,16 @@ async function resolveLastReleasedTag(previousChangelogLines) {
   }
   return lastTag;
 }
+async function resolveReleaseAssetPaths(getPaths, shouldRequireAssets) {
+  const paths = await getPaths();
+  return paths.filter((path) => {
+    const isExists = existsSync(resolvePathFromRootSafe({ path }));
+    if (!isExists && shouldRequireAssets) {
+      throw new Error(`Release asset does not exist: ${path}`);
+    }
+    return isExists;
+  });
+}
 async function reviewChangelog(newChangeLog, findings) {
   const scratchFolder = await mkdtemp(join(tmpdir(), "changelog-"));
   const scratchChangelogPath = join(scratchFolder, RepoPaths.ChangelogMd);
@@ -789,6 +829,21 @@ function toHighestBumpLevel(forcingCommits) {
   }
   return forcingCommits.length > 0 ? "minor" /* Minor */ : "patch" /* Patch */;
 }
+async function verifyGitHubRelease(newVersion, filePaths) {
+  const release = JSON.parse(
+    await execFromRoot([
+      "gh",
+      "release",
+      "view",
+      newVersion,
+      "--json",
+      "isDraft,isPrerelease,tagName,assets"
+    ], { isQuiet: true })
+  );
+  if (release.isDraft || release.tagName !== newVersion || release.isPrerelease !== isPreRelease(newVersion) || filePaths.some((path) => release.assets.every((asset) => !(asset.name === basename(path) && asset.state === "uploaded")))) {
+    throw new Error(`Could not verify the public ${newVersion} release and its uploaded assets; the remote branch was not advanced.`);
+  }
+}
 async function writeChangelog(newChangeLog) {
   await writeFile(resolvePathFromRootSafe({ path: RepoPaths.ChangelogMd }), newChangeLog, "utf-8");
 }
@@ -816,4 +871,4 @@ export {
   updateVersionInFiles,
   validate
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/version.ts"],"sourcesContent":["/**\n * @file\n *\n * This module provides functions for managing version updates in a project.\n * It includes tasks such as validating version update types, checking the state\n * of Git and GitHub CLI, updating version numbers in files, and performing\n * Git operations such as tagging and pushing.\n */\n\nimport type { ParseArgsConfig } from 'node:util';\nimport type { ReleaseType } from 'semver';\n\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { errorToString } from '@mnaoumov/typescript-lib/error';\nimport { join } from '@mnaoumov/typescript-lib/path';\nimport {\n  escapeRegExp,\n  getOptionalNamedGroup\n} from '@mnaoumov/typescript-lib/reg-exp';\nimport { replaceAll } from '@mnaoumov/typescript-lib/string';\nimport { assertNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { existsSync } from 'node:fs';\nimport {\n  mkdtemp,\n  readFile,\n  rm,\n  writeFile\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { createInterface } from 'node:readline/promises';\nimport { parseArgs } from 'node:util';\nimport {\n  inc,\n  parse,\n  prerelease\n} from 'semver';\n\nimport type { PackageLockJson } from './npm.ts';\n\nimport {\n  findForbiddenPatternMatches,\n  FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE,\n  readForbiddenPatterns\n} from './forbidden-patterns.ts';\nimport { gate } from './gate.ts';\nimport { spellcheckContent } from './linters/cspell-content.ts';\nimport {\n  fixMarkdownContent,\n  lintMarkdownContent\n} from './linters/markdownlint-content.ts';\nimport {\n  editNpmShrinkWrapJson,\n  editPackageJson,\n  editPackageLockJson,\n  readPackageJson\n} from './npm.ts';\nimport { closeReleasedIssues } from './released-issues.ts';\nimport { RepoPaths } from './repo-paths.ts';\nimport {\n  execFromRoot,\n  resolvePathFromRootSafe\n} from './root.ts';\n\n/**\n * Options for {@link addUpdatedFilesToGit}.\n */\nexport interface AddUpdatedFilesToGitOptions {\n  /**\n   * Whether to run the pre-commit hook when creating the release commit. When `false`, `--no-verify`\n   * is passed to the release commit to skip the hook.\n   *\n   * @default `true`\n   */\n  readonly shouldVerifyCommit?: boolean;\n}\n\n/**\n * The result of parsing the command-line arguments for a version update.\n */\nexport interface ParsedVersionArguments {\n  /**\n   * The {@link UpdateVersionOptions} parsed from the flags.\n   */\n  readonly options: UpdateVersionOptions;\n\n  /**\n   * The positional version update type argument, or `undefined` if none was provided.\n   */\n  readonly versionUpdateType: string | undefined;\n}\n\n/**\n * Options for {@link publishGitHubRelease}.\n */\nexport interface PublishGitHubReleaseOptions {\n  /**\n   * Returns the files to attach to the GitHub release, as paths relative to the project root. A path that does\n   * not exist is skipped.\n   *\n   * @default the `npm pack` tarball of the project, written into `dist/`, and `dist/styles.css`\n   */\n  readonly getReleaseAssetPaths?: (() => Promise<string[]>) | undefined;\n\n  /**\n   * Whether to close the issues the release carries once it is published: every issue a commit since the previous\n   * tag names with a closing keyword (`fixes #12`) is closed with a `Fixed in` / `Implemented in` comment linking\n   * the release. See {@link closeReleasedIssues}.\n   *\n   * @default `true`\n   */\n  readonly shouldCloseReleasedIssues?: boolean;\n}\n\n/**\n * Options for {@link updateChangelog}.\n */\nexport interface UpdateChangelogOptions {\n  /**\n   * A path to a file whose contents become the body of the new version's changelog section, instead of\n   * the bullets derived from the commit messages. Use it to supply prepared release notes from a\n   * non-interactive caller (a background process, CI, an agent).\n   *\n   * Setting it implies no interactive review: the commit log is not read, and the changelog is never\n   * opened in the editor nor waited on at the console, regardless of {@link shouldEditChangelog}.\n   *\n   * @default the first-parent commit subjects since the previous version\n   */\n  readonly changelogFilePath?: string | undefined;\n\n  /**\n   * Whether to open the generated changelog in the editor for an interactive review. When `false`,\n   * the changelog is still generated from commit messages, but it is not opened in the editor for\n   * manual review.\n   *\n   * Ignored when {@link changelogFilePath} is set.\n   *\n   * @default `true`\n   */\n  readonly shouldEditChangelog?: boolean;\n}\n\n/**\n * Options for {@link updateVersion}.\n */\nexport interface UpdateVersionOptions {\n  /**\n   * A path to a file whose contents become the body of the new version's changelog section, instead of\n   * the bullets derived from the commit messages. Use it to supply prepared release notes from a\n   * non-interactive caller (a background process, CI, an agent).\n   *\n   * Setting it implies no interactive review: the commit log is not read, and the changelog is never\n   * opened in the editor nor waited on at the console, regardless of {@link shouldEditChangelog}.\n   *\n   * @default the first-parent commit subjects since the previous version\n   */\n  readonly changelogFilePath?: string | undefined;\n\n  /**\n   * Returns the files to attach to the GitHub release. See {@link PublishGitHubReleaseOptions.getReleaseAssetPaths}.\n   */\n  readonly getReleaseAssetPaths?: (() => Promise<string[]>) | undefined;\n\n  /**\n   * A callback function to prepare the GitHub release.\n   *\n   * @param newVersion - The new version number for the release.\n   * @returns A {@link Promise} that resolves when the GitHub release has been prepared.\n   */\n  readonly prepareGitHubRelease?: (newVersion: string) => Promise<void>;\n\n  /**\n   * Whether to run the build step. The build is a publishing prerequisite, not a verification check,\n   * so it is governed by this flag independently of {@link shouldRunChecks} — it runs even when the\n   * checks are skipped, so a fast release still ships fresh artifacts. Set to `false` only when the\n   * build output is known to already match the current code; otherwise the release would publish\n   * stale artifacts.\n   *\n   * @default `true`\n   */\n  readonly shouldBuild?: boolean;\n\n  /**\n   * Whether to close the issues the release carries once it is published. See\n   * {@link PublishGitHubReleaseOptions.shouldCloseReleasedIssues}.\n   *\n   * @default `true`\n   */\n  readonly shouldCloseReleasedIssues?: boolean;\n\n  /**\n   * Whether to open the generated changelog in the editor for an interactive review.\n   *\n   * Ignored when {@link changelogFilePath} is set. When it is neither set nor disabled, the release\n   * requires an interactive terminal, and {@link updateVersion} refuses up front without one rather\n   * than blocking on an editor nobody will close.\n   *\n   * @default `true`\n   */\n  readonly shouldEditChangelog?: boolean;\n\n  /**\n   * Whether to publish the release. When `false`, all local steps are executed (version bump,\n   * changelog, commit, tag), but the changes are not pushed and no GitHub release is published.\n   *\n   * @default `true`\n   */\n  readonly shouldRelease?: boolean;\n\n  /**\n   * Whether to run the preflight verification checks (clean-repo check, format, spellcheck, lint,\n   * over-exposure analysis, and tests). The build step is not one of these checks — it is governed\n   * separately by {@link shouldBuild}.\n   *\n   * @default `true`\n   */\n  readonly shouldRunChecks?: boolean;\n\n  /**\n   * Whether to run the pre-commit hook when creating the release commit. When `false`, `--no-verify`\n   * is passed to the release commit to skip the hook.\n   *\n   * @default `true`\n   */\n  readonly shouldVerifyCommit?: boolean;\n\n  /**\n   * Updates the version in any file beyond `package.json` and the lockfiles, once the new version is known and\n   * before the release commit is made. An Obsidian plugin's `manifest.json` and `versions.json` are the case this\n   * exists for.\n   *\n   * @param newVersion - The version being released.\n   * @returns A {@link Promise} that resolves when the files are updated.\n   */\n  readonly updateVersionInExtraFiles?: ((newVersion: string) => Promise<void>) | undefined;\n}\n\n/**\n * The lowest bump a range of commits may be published under, and the commits that force it.\n */\ninterface BumpFloor {\n  /**\n   * The commits whose Conventional-Commits markers force {@link level}, in the order `git log` reported them.\n   * Empty when nothing forces anything, which is the ordinary case for a range of `fix`es and `chore`s.\n   */\n  readonly forcingCommits: readonly ForcingCommit[];\n\n  /**\n   * The lowest {@link BumpLevel} the range may ship as.\n   */\n  readonly level: BumpLevel;\n}\n\n/**\n * What {@link toBumpFloorError} needs beyond the {@link BumpFloor} itself to say what was asked for and what\n * that would have shipped as.\n */\ninterface BumpFloorRefusalContext {\n  /**\n   * The previous release tag the range was measured from.\n   */\n  readonly lastTag: string;\n\n  /**\n   * The version the requested bump would have produced.\n   */\n  readonly newVersion: string;\n\n  /**\n   * The {@link BumpLevel} {@link newVersion} actually moves, relative to {@link lastTag}.\n   */\n  readonly takenLevel: BumpLevel;\n\n  /**\n   * The version update type the release was asked for, verbatim — which is a pre-release type or an explicit\n   * version as often as it is a plain `patch`, and is therefore worth quoting back rather than inferring.\n   */\n  readonly versionUpdateType: string;\n}\n\n/**\n * The three release lines a bump can move, ordered by {@link isBumpLevelAtLeast}.\n *\n * A pre-release type is not one of these: `premajor` moves the major line and `prerelease` moves whichever\n * line an earlier pre-release already chose, so what a pre-release did is read off the resulting version\n * rather than off its type. See {@link toEffectiveBumpLevel}.\n */\ntype BumpLevel = VersionUpdateType.Major | VersionUpdateType.Minor | VersionUpdateType.Patch;\n\n/**\n * One finding reported over the settled changelog section, tagged with the npm script whose check produced it.\n *\n * The tag is what lets one message name `lint:md`, `spellcheck` or both, truthfully. Both checks run over\n * every settle, so an author who has to fix a hard-wrapped line and a coined word fixes them in ONE round of\n * the review rather than being sent back twice.\n */\ninterface ChangelogFinding {\n  /**\n   * The npm script that would have reported this on the branch.\n   */\n  readonly scriptName: string;\n\n  /**\n   * The reported line, exactly as that script's own output would have carried it.\n   */\n  readonly text: string;\n}\n\n/**\n * One commit that forces a {@link BumpFloor}, rendered into the refusal so the author can go and look at it.\n */\ninterface ForcingCommit {\n  /**\n   * The {@link BumpLevel} this one commit forces on its own.\n   */\n  readonly level: BumpLevel;\n\n  /**\n   * What in the commit forced it — the `!` marker, the `BREAKING CHANGE:` footer, or the `feat` type — named\n   * so a reader can tell a deliberate breaking marker from a footer somebody wrote in passing.\n   */\n  readonly marker: string;\n\n  /**\n   * The full commit hash.\n   */\n  readonly sha: string;\n\n  /**\n   * The commit subject.\n   */\n  readonly subject: string;\n}\n\ninterface NpmPackResult {\n  readonly filename: string;\n}\n\n/**\n * A `BREAKING CHANGE:` footer, in both spellings Conventional Commits allows.\n *\n * Matched per line (`m`) rather than against the whole message, because a footer sits at the bottom of the\n * body. It is the half of the breaking-change signal that {@link MERGE_SUBJECT_REG_EXP}'s sibling rewrite\n * cannot carry: `toChangelogEntry` lifts only the merge body's first line onto the merge subject, so a footer\n * written on a branch commit never reaches the first-parent history at all. That is why\n * {@link getBumpFloor} reads every commit in the range rather than only the first-parent ones.\n */\nconst BREAKING_CHANGE_FOOTER_REG_EXP = /^BREAKING[ -]CHANGE:/m;\n\n/**\n * The marker names a {@link ForcingCommit} carries, and therefore what the refusal message says forced the\n * floor. They are spelled out rather than reduced to the level alone, because `feat!` and a `BREAKING CHANGE:`\n * footer buried in a body are very different things to be told about.\n */\nconst BREAKING_CHANGE_FOOTER_MARKER = 'a `BREAKING CHANGE:` footer';\n\n/**\n * See {@link BREAKING_CHANGE_FOOTER_MARKER}.\n */\nconst BREAKING_MARKER = 'the `!` breaking marker';\n\n/**\n * See {@link BREAKING_CHANGE_FOOTER_MARKER}.\n */\nconst FEAT_TYPE_MARKER = 'a `feat` type';\n\n/**\n * A Conventional-Commits subject: a type, an optional scope, an optional `!`, then the colon.\n *\n * Deliberately tolerant of a subject that is not one at all — an unparsable subject simply constrains\n * nothing, which is the same answer a `chore:` gives. This gate exists to catch a bump that is too LOW, so\n * failing to recognize a subject can only under-constrain, never refuse a release that should have shipped.\n */\nconst CONVENTIONAL_COMMIT_SUBJECT_REG_EXP = /^(?<type>[a-z]+)(?:\\([^()]*\\))?(?<breaking>!)?:\\s/i;\n\n/**\n * The default pre-release identifier used for pre-release versions.\n */\nconst DEFAULT_PREID = 'beta';\n\n/**\n * The Conventional-Commits type that forces a minor.\n */\nconst FEAT_TYPE = 'feat';\n\n/**\n * One issue reference inside an {@link ISSUE_REFERENCE_LINE_REG_EXP} line: an issue or pull request URL, an\n * `owner/repo#n`, or a bare `#n`.\n */\nconst ISSUE_REFERENCE_REG_EXP = /https:\\/\\/github\\.com\\/(?<urlSlug>[\\w.-]+\\/[\\w.-]+)\\/(?:issues|pull)\\/(?<urlNumber>\\d+)|(?<![\\w./-])(?<slug>[\\w.-]+\\/[\\w.-]+)#(?<slugNumber>\\d+)\\b|(?<![\\w/&#.-])#(?<bareNumber>\\d+)\\b/g;\n\n/**\n * A commit body line that names the issues the commit works on: `Refs owner/repo#12`, `Fixes #3`,\n * `Closes https://github.com/owner/repo/issues/4, #5`. The keyword is followed by references and nothing else\n * (see {@link parseIssueReferenceLine}), so a prose line that merely opens with `Fixes` names nothing.\n *\n * A fix made in one repository for an issue in another closes nothing here, and its commit subject cannot carry\n * the other repository's number, so this line is the only place the release can learn which issue it fixes.\n */\nconst ISSUE_REFERENCE_LINE_REG_EXP = /^(?:refs?|re|fix(?:e[sd])?|close[sd]?|resolve[sd]?|implements?):?\\s+(?<references>.+)$/i;\n\n/**\n * The npm scripts whose checks the settled changelog is held to, named in the messages so a reader knows which\n * gate they are looking at — and knows that fixing it here is the same fix as fixing it on the branch.\n */\nconst LINT_MD_SCRIPT_NAME = 'lint:md';\n\n/**\n * How much of a commit hash the bump-floor refusal prints. Long enough to paste into `git show`, short enough\n * that a list of them stays readable.\n */\nconst SHORT_SHA_LENGTH = 8;\n\n/**\n * See {@link LINT_MD_SCRIPT_NAME}.\n */\nconst SPELLCHECK_SCRIPT_NAME = 'spellcheck';\n\n/**\n * The shape of a merge subject git wrote itself, rather than one an author chose.\n *\n * Every default git produces opens with `Merge` and a word boundary — `Merge branch 'x'`,\n * `Merge branches 'x' and 'y'`, `Merge remote-tracking branch 'x'`, `Merge pull request #1 from y`,\n * `Merge tag 'x'`, `Merge commit 'abc'` — which is what the optional alternation and the trailing `\\b` cover\n * between them. Being that broad costs nothing here: every changelog entry in this workspace is a\n * Conventional-Commits subject, and those open with a type (`feat`, `fix`, `chore`, …), never with `Merge`.\n *\n * ONE pattern drives both halves of the guard, so they cannot drift apart: {@link toChangelogEntry} rewrites\n * a commit whose subject matches it, and {@link assertChangelogHasNoMergeSubjects} refuses a changelog line\n * that still does. The refusal is therefore reachable only for a merge the rewrite had nothing to work with.\n */\nconst MERGE_SUBJECT_REG_EXP = /^Merge(?: branch| remote-tracking| pull request)?\\b/;\n\n/**\n * Enum representing different types of version updates.\n *\n * Aligns with npm's `npm version` increment types plus `Manual` for explicit versions.\n */\nexport enum VersionUpdateType {\n  Invalid = 'invalid',\n  Major = 'major',\n  Manual = 'manual',\n  Minor = 'minor',\n  Patch = 'patch',\n  PreMajor = 'premajor',\n  PreMinor = 'preminor',\n  PrePatch = 'prepatch',\n  PreRelease = 'prerelease'\n}\n\n/**\n * The version update types a caller names directly, keyed by their name, as opposed to the two `getVersionUpdateType` derives.\n */\nconst NAMED_VERSION_UPDATE_TYPES = new Map<string, VersionUpdateType>([\n  VersionUpdateType.Major,\n  VersionUpdateType.Minor,\n  VersionUpdateType.Patch,\n  VersionUpdateType.PreMajor,\n  VersionUpdateType.PreMinor,\n  VersionUpdateType.PrePatch,\n  VersionUpdateType.PreRelease\n].map((type) => [type, type]));\n\n/**\n * Where `HEAD` stood when a release started: the branch it is on (empty for a detached `HEAD`) and its commit.\n */\nexport interface GitHeadState {\n  /**\n   * The checked-out branch, or an empty string for a detached `HEAD`.\n   */\n  readonly branch: string;\n\n  /**\n   * The commit `HEAD` points at.\n   */\n  readonly sha: string;\n}\n\n/**\n * Creates a Git tag for the new version.\n *\n * @param newVersion - The new version number to use for the tag.\n * @param commitSha - The commit to tag. When omitted, `HEAD` is tagged.\n * @returns A {@link Promise} that resolves when the tag has been created.\n */\nexport async function addGitTag(newVersion: string, commitSha?: string): Promise<void> {\n  await execFromRoot(`git tag -a ${newVersion} -m ${newVersion} --force${commitSha ? ` ${commitSha}` : ''}`, { isQuiet: true });\n}\n\n/**\n * Adds updated files to the Git staging area and commits them with the new version message.\n *\n * If the commit fails (for example, the pre-commit hook rejects a new word in the changelog) and the\n * process is attached to an interactive terminal, the user is prompted to fix the issue (for example,\n * add the missing word to `cspell.json`) and press Enter to retry. The retry re-stages all files, so the\n * fix is picked up without restarting the whole release lifecycle. In a non-interactive environment (no\n * TTY, such as CI), the error is re-thrown instead of prompting, so the script fails fast rather than\n * hanging. Pass `shouldVerifyCommit: false` to skip the pre-commit hook entirely in such cases.\n *\n * @param newVersion - The new version number used as the commit message.\n * @param options - The {@link AddUpdatedFilesToGitOptions} controlling the commit behavior.\n * @returns A {@link Promise} that resolves when the files have been added and committed.\n */\nexport async function addUpdatedFilesToGit(newVersion: string, options: AddUpdatedFilesToGitOptions = {}): Promise<void> {\n  const { shouldVerifyCommit = true } = options;\n  const versionDebugger = getLibDebugger('Version');\n\n  const commitArguments = ['git', 'commit', '-m', `chore: release ${newVersion}`, '--allow-empty', ...(shouldVerifyCommit ? [] : ['--no-verify'])];\n\n  for (;;) {\n    try {\n      await execFromRoot(['git', 'add', '--all'], { isQuiet: true });\n      await execFromRoot(commitArguments, { isQuiet: true });\n      return;\n    } catch (error) {\n      if (!process.stdin.isTTY) {\n        throw error;\n      }\n\n      versionDebugger(\n        `Failed to commit the release.\\n${errorToString(error)}\\n`\n          + 'Fix the issues (for example, add the missing word to cspell.json) and press Enter to retry the commit, or Ctrl+C to abort.'\n      );\n      await createInterface(process.stdin, process.stdout).question('Press Enter to retry the commit...');\n    }\n  }\n}\n\n/**\n * Checks if the GitHub CLI is installed on the system.\n *\n * Throws an error if the GitHub CLI is not installed.\n *\n * @throws Error if the GitHub CLI is not installed.\n */\nexport async function assertGitHubCliInstalled(): Promise<void> {\n  try {\n    await execFromRoot('gh --version', { isQuiet: true });\n  } catch {\n    throw new Error('GitHub CLI is not installed. Please install it from https://cli.github.com/');\n  }\n}\n\n/**\n * Checks if Git is installed on the system.\n *\n * Throws an error if Git is not installed.\n *\n * @throws Error if Git is not installed.\n */\nexport async function assertGitInstalled(): Promise<void> {\n  try {\n    await execFromRoot('git --version', { isQuiet: true });\n  } catch {\n    throw new Error('Git is not installed. Please install it from https://git-scm.com/');\n  }\n}\n\n/**\n * Checks if the Git repository is clean, meaning there are no uncommitted changes.\n *\n * Throws an error if the Git repository is not clean.\n *\n * @throws Error if the Git repository is not clean.\n */\nexport async function assertGitRepoClean(): Promise<void> {\n  try {\n    const stdout = await execFromRoot('git status --porcelain --untracked-files=all', { isQuiet: true });\n    if (stdout) {\n      throw new Error();\n    }\n  } catch {\n    throw new Error('Git repository is not clean. Please commit or stash your changes before releasing a new version.');\n  }\n}\n\n/**\n * Asserts that `HEAD` is the release commit: on the branch the release started on, a single commit on top of the\n * commit it started from, with the `chore: release <version>` subject.\n *\n * A successful `git commit` proves only that a commit was made somewhere. A checkout switched underneath a\n * release by another process takes the commit onto that other branch, and when it is switched back the tag and\n * the GitHub release go out on the commit before the bump, with the bump left staged in the working tree and nothing\n * reported. So the release checks where the commit landed before tagging, and again before pushing.\n *\n * @param newVersion - The version being released.\n * @param startHead - Where `HEAD` stood when the release started.\n * @param stage - The step about to run, for the error message (for example `tagging`).\n * @returns A {@link Promise} that resolves to the release commit's SHA.\n */\nexport async function assertReleaseCommitLanded(newVersion: string, startHead: GitHeadState, stage: string): Promise<string> {\n  const expectedSubject = `chore: release ${newVersion}`;\n  const branch = await execFromRoot(['git', 'branch', '--show-current'], { isQuiet: true });\n  const headLogFieldCount = 3;\n  const headLog = await execFromRoot(['git', 'log', '-1', '--format=%H%n%P%n%s'], { isQuiet: true });\n  const [sha = '', parents = '', subject = ''] = headLog.split('\\n', headLogFieldCount);\n\n  if (branch === startHead.branch && parents === startHead.sha && subject === expectedSubject) {\n    return sha;\n  }\n\n  throw new Error(\n    `Refusing to continue before ${stage}: the release commit for ${newVersion} is not where it should be. `\n      + `The release started on ${describeBranch(startHead.branch)} at ${startHead.sha} and expects a '${expectedSubject}' commit on top of it, `\n      + `but HEAD is ${sha} ('${subject}', parent ${parents || 'none'}) on ${describeBranch(branch)}. `\n      + 'Something else moved HEAD in this working tree while the release ran (a concurrent checkout, reset or commit). '\n      + 'Check `git reflog` to find the release commit, put it on the release branch, and tag and push it by hand.'\n  );\n}\n\n/**\n * Wraps any bare `http(s)://` URL in the given text in angle brackets (`<url>`) so that text emitted\n * into a Markdown document (such as a generated changelog bullet) passes markdownlint's\n * `MD034/no-bare-urls` rule while still rendering as a clickable autolink on GitHub.\n *\n * URLs that are already wrapped in angle brackets (`<url>`) or that form the target of a Markdown\n * link (`[text](url)`) are left untouched, so the function is safe to run repeatedly. Trailing\n * sentence punctuation (`.`, `,`, `;`, `:`, `!`, `?`) is kept outside the angle brackets so it does\n * not become part of the link.\n *\n * @param text - The text possibly containing bare URLs.\n * @returns The text with every bare URL wrapped in angle brackets.\n */\nexport function autolinkBareUrls(text: string): string {\n  return text.replaceAll(/(?<![<[(])https?:\\/\\/[^\\s<>)\\]]+/g, (url) => {\n    const trailingPunctuation = /[.,;:!?]+$/.exec(url)?.[0] ?? '';\n    const bareUrl = url.slice(0, url.length - trailingPunctuation.length);\n    return `<${bareUrl}>${trailingPunctuation}`;\n  });\n}\n\n/**\n * Generates a new version string based on the current version and the specified update type.\n *\n * Uses the `semver` package to compute the next version, supporting all npm increment types:\n * `major`, `minor`, `patch`, `premajor`, `preminor`, `prepatch`, and `prerelease`.\n * Pre-release versions use the `beta` identifier by default (e.g., `1.2.4-beta.0`).\n *\n * @param versionUpdateType - The type of version update or an explicit version string.\n * @returns A {@link Promise} that resolves to the new version string.\n * @throws Error if the current version is invalid or the increment fails.\n */\nexport async function getNewVersion(versionUpdateType: string): Promise<string> {\n  const versionType = getVersionUpdateType(versionUpdateType);\n  if (versionType === VersionUpdateType.Manual) {\n    return versionUpdateType;\n  }\n\n  const packageJson = await readPackageJson();\n  const currentVersion = packageJson.version ?? '';\n\n  const releaseType = versionType as ReleaseType;\n  const isPreReleaseType = releaseType.startsWith('pre');\n  const newVersion = isPreReleaseType\n    ? inc(currentVersion, releaseType, DEFAULT_PREID)\n    : inc(currentVersion, releaseType);\n  assertNonNullable(newVersion, `Failed to increment version from '${currentVersion}' with type '${versionType}'`);\n\n  return newVersion;\n}\n\n/**\n * Retrieves the release notes for a specific version from the changelog.\n *\n * @param newVersion - The new version number for which to get the release notes.\n * @returns A {@link Promise} that resolves to the release notes for the specified version.\n */\nexport async function getReleaseNotes(newVersion: string): Promise<string> {\n  const changelogPath = resolvePathFromRootSafe({ path: RepoPaths.ChangelogMd });\n  const content = await readFile(changelogPath, 'utf-8');\n  const section = extractChangelogSection(content, newVersion);\n  let releaseNotes = section ? `${section}\\n\\n` : '';\n\n  const tagOutput = await execFromRoot('git tag --sort=-creatordate', { isQuiet: true });\n  const tags = tagOutput.split(/\\r?\\n/);\n  const previousVersion = tags[1];\n\n  const repoUrl = await execFromRoot('gh repo view --json url -q .url', { isQuiet: true });\n\n  const changesUrl = previousVersion ? `${repoUrl}/compare/${previousVersion}...${newVersion}` : `${repoUrl}/commits/${newVersion}`;\n\n  releaseNotes += `**Full Changelog**: ${changesUrl}`;\n  return releaseNotes;\n}\n\n/**\n * Determines the type of version update based on the input string.\n *\n * @param versionUpdateType - The input string representing the version update type.\n * @returns The corresponding `VersionUpdateType`.\n */\nexport function getVersionUpdateType(versionUpdateType: string): VersionUpdateType {\n  const namedVersionUpdateType = NAMED_VERSION_UPDATE_TYPES.get(versionUpdateType);\n  if (namedVersionUpdateType) {\n    return namedVersionUpdateType;\n  }\n\n  return /^\\d+\\.\\d+\\.\\d+(?:-[\\w\\d.-]+)?$/.test(versionUpdateType) ? VersionUpdateType.Manual : VersionUpdateType.Invalid;\n}\n\n/**\n * Pushes commits and tags to the remote Git repository.\n *\n * @returns A {@link Promise} that resolves when the push operation is complete.\n */\nexport async function gitPush(): Promise<void> {\n  await execFromRoot('git push --follow-tags --force', { isQuiet: true });\n}\n\n/**\n * Reads where `HEAD` stands now.\n *\n * @returns A {@link Promise} that resolves to the current {@link GitHeadState}.\n */\nexport async function readGitHeadState(): Promise<GitHeadState> {\n  const branch = await execFromRoot(['git', 'branch', '--show-current'], { isQuiet: true });\n  const sha = await execFromRoot(['git', 'rev-parse', 'HEAD'], { isQuiet: true });\n  return { branch, sha };\n}\n\n/**\n * The flags {@link parseVersionArguments} recognizes, in the shape Node's `parseArgs` takes. Exported so a wrapper\n * that adds flags of its own can parse them all in one pass and still read these through\n * {@link toUpdateVersionOptions}.\n */\nexport const VERSION_ARGUMENT_OPTIONS = {\n  'changelog-file': { type: 'string' },\n  'no-build': { type: 'boolean' },\n  'no-changelog-editing': { type: 'boolean' },\n  'no-checks': { type: 'boolean' },\n  'no-commit-verification': { type: 'boolean' },\n  'no-issue-closing': { type: 'boolean' },\n  'no-release': { type: 'boolean' }\n} as const satisfies NonNullable<ParseArgsConfig['options']>;\n\n/**\n * The values `parseArgs` reports for {@link VERSION_ARGUMENT_OPTIONS}.\n */\nexport type VersionArgumentValues = ReturnType<typeof parseArgs<VersionArgumentParseConfig>>['values'];\n\n/**\n * One issue reference a commit body names, as {@link parseIssueReferenceLine} reads it.\n */\ninterface IssueReference {\n  /**\n   * How the changelog line shows it: `#n` for a bare number, the issue URL in angle brackets otherwise.\n   */\n  readonly rendered: string;\n  /**\n   * Every way a line that already shows it may spell it: `#n`, or `owner/repo#n` and the issue URL.\n   */\n  readonly spellings: readonly string[];\n}\n\n/**\n * The `parseArgs` configuration {@link VersionArgumentValues} is derived from.\n */\ninterface VersionArgumentParseConfig {\n  /**\n   * The recognized flags.\n   */\n  readonly options: typeof VERSION_ARGUMENT_OPTIONS;\n}\n\n/**\n * Whether a version is a pre-release, such as `1.2.4-beta.0`.\n *\n * @param version - The version.\n * @returns Whether it carries a pre-release part.\n */\nexport function isPreRelease(version: string): boolean {\n  return prerelease(version) !== null;\n}\n\n/**\n * Parses the command-line arguments for a version update into a version update type and\n * {@link UpdateVersionOptions}.\n *\n * Each behavior is enabled by default; the corresponding `--no-*` flag turns it off. `--changelog-file` takes a\n * value instead and has no default. Recognized flags:\n * - `--changelog-file=<path>` — use this file's contents as the new version's changelog section instead of\n *   the commit-derived bullets, and skip the interactive review entirely.\n * - `--no-build` — skip the build step (only safe when the build output already matches the current code).\n * - `--no-changelog-editing` — generate the changelog without opening it for manual review.\n * - `--no-checks` — skip the clean-repo check, format, spellcheck, lint, over-exposure analysis, and tests (the build still runs).\n * - `--no-commit-verification` — pass `--no-verify` to the release commit, skipping the pre-commit hook.\n * - `--no-issue-closing` — do not close the issues the release carries once it is published.\n * - `--no-release` — run all local steps but skip the push and the GitHub release.\n *\n * @param $arguments - The command-line arguments to parse (typically `process.argv.slice(2)`).\n * @returns The {@link ParsedVersionArguments} containing the version update type and the options.\n */\nexport function parseVersionArguments($arguments: string[]): ParsedVersionArguments {\n  const { positionals, values } = parseArgs({\n    allowPositionals: true,\n    // eslint-disable-next-line unicorn/name-replacements -- `args` is the option name Node's `parseArgs` reads.\n    args: $arguments,\n    options: VERSION_ARGUMENT_OPTIONS\n  });\n\n  return {\n    options: toUpdateVersionOptions(values),\n    versionUpdateType: positionals[0]\n  };\n}\n/**\n * Publishes a GitHub release for the new version.\n *\n * Creates the release and attaches the files {@link PublishGitHubReleaseOptions.getReleaseAssetPaths} names.\n *\n * Once the release exists, the issues it carries are closed with a link to it (see {@link closeReleasedIssues}),\n * unless {@link PublishGitHubReleaseOptions.shouldCloseReleasedIssues} is `false`. A failure there is reported and\n * does not fail the release, which is already published.\n *\n * @param newVersion - The new version number for the release.\n * @param options - The {@link PublishGitHubReleaseOptions}.\n * @returns A {@link Promise} that resolves when the release has been published.\n */\nexport async function publishGitHubRelease(newVersion: string, options: PublishGitHubReleaseOptions = {}): Promise<void> {\n  const { getReleaseAssetPaths = getNpmPackReleaseAssetPaths, shouldCloseReleasedIssues = true } = options;\n  let filePaths = await getReleaseAssetPaths();\n  filePaths = filePaths.filter((filePath) => existsSync(resolvePathFromRootSafe({ path: filePath })));\n\n  await execFromRoot([\n    'gh',\n    'release',\n    'create',\n    newVersion,\n    ...filePaths,\n    '--title',\n    `v${newVersion}`,\n    ...(isPreRelease(newVersion) ? ['--prerelease'] : []),\n    '--notes-file',\n    '-'\n  ], {\n    isQuiet: true,\n    stdin: await getReleaseNotes(newVersion)\n  });\n\n  if (!shouldCloseReleasedIssues) {\n    return;\n  }\n\n  try {\n    await closeReleasedIssues({ newVersion });\n  } catch (error) {\n    console.warn(`The ${newVersion} release is published, but closing the issues it carries failed: ${errorToString(error)}`);\n  }\n}\n\n/**\n * Maps the values `parseArgs` reports for {@link VERSION_ARGUMENT_OPTIONS} onto {@link UpdateVersionOptions}.\n *\n * @param values - The parsed values.\n * @returns The options.\n */\nexport function toUpdateVersionOptions(values: VersionArgumentValues): UpdateVersionOptions {\n  return {\n    changelogFilePath: values['changelog-file'],\n    shouldBuild: !(values['no-build'] ?? false),\n    shouldCloseReleasedIssues: !(values['no-issue-closing'] ?? false),\n    shouldEditChangelog: !(values['no-changelog-editing'] ?? false),\n    shouldRelease: !(values['no-release'] ?? false),\n    shouldRunChecks: !(values['no-checks'] ?? false),\n    shouldVerifyCommit: !(values['no-commit-verification'] ?? false)\n  };\n}\n/**\n * Updates the changelog file with new version information and commit messages.\n *\n * This function reads the current changelog, appends new entries for the latest version,\n * and prompts the user to review the changes.\n *\n * The review happens on a scratch copy in the OS temporary folder, and the repository's own\n * `CHANGELOG.md` is written only once the review is over — so interrupting the review leaves the\n * repository untouched.\n *\n * @param newVersion - The new version number to be added to the changelog.\n * @param options - The {@link UpdateChangelogOptions} controlling the changelog review behavior.\n * @returns A {@link Promise} that resolves when the changelog update is complete.\n */\nexport async function updateChangelog(newVersion: string, options: UpdateChangelogOptions = {}): Promise<void> {\n  await writeChangelog(await prepareChangelog(newVersion, options));\n}\n\n/**\n * Updates the version of the project based on the specified update type.\n *\n * This function performs a series of tasks to handle version updates:\n * 1. Validates the version update type.\n * 2. Checks if Git and GitHub CLI are installed.\n * 3. Verifies that the interactive changelog review, if one is due, can actually be answered.\n * 4. Verifies that the bump is not lower than the commits since the last tag force it to be.\n * 5. Verifies that the Git repository is clean.\n * 6. Runs spellcheck and linting.\n * 7. Builds the project.\n * 8. Settles the changelog — the only step that can block on a human, and deliberately the last one before\n *    anything is written, so an interrupt here leaves the working tree clean and the release re-runnable.\n *    The settled text is linted here too: `lint:md` ran in step 6, before a character of it existed.\n * 9. Updates version in files (and in whatever {@link UpdateVersionOptions.updateVersionInExtraFiles} adds), then\n *    writes the settled changelog.\n * 10. Adds updated files to Git, tags the commit, and pushes to the repository.\n * 11. Prepares and publishes a GitHub release.\n * 12. Closes the issues the release carries, with a link to it.\n *\n * @param versionUpdateType - The type of version update to perform (major, minor, patch, premajor, preminor, prepatch, prerelease, or x.y.z[-suffix]).\n * @param options - The {@link UpdateVersionOptions} controlling the release behavior.\n * @returns A {@link Promise} that resolves when the version update is complete.\n */\nexport async function updateVersion(versionUpdateType?: string, options: UpdateVersionOptions = {}): Promise<void> {\n  const {\n    changelogFilePath,\n    getReleaseAssetPaths,\n    prepareGitHubRelease,\n    shouldBuild = true,\n    shouldCloseReleasedIssues = true,\n    shouldEditChangelog = true,\n    shouldRelease = true,\n    shouldRunChecks = true,\n    shouldVerifyCommit = true,\n    updateVersionInExtraFiles\n  } = options;\n\n  if (!versionUpdateType) {\n    const npmOldVersion = process.env['npm_old_version'];\n    const npmNewVersion = process.env['npm_new_version'];\n\n    if (npmOldVersion && npmNewVersion) {\n      await updateVersionInFiles(npmOldVersion);\n      await updateVersion(npmNewVersion, options);\n      return;\n    }\n\n    throw new Error('No version update type provided');\n  }\n\n  validate(versionUpdateType);\n  await assertGitInstalled();\n  await assertGitHubCliInstalled();\n  // Checked here, before the checks and the build, rather than at the changelog step itself: a non-interactive\n  // caller learns in seconds instead of paying for the whole preflight and only then blocking on an editor\n  // window nobody will ever close.\n  assertChangelogStepIsNonBlocking(changelogFilePath, shouldEditChangelog);\n  // Same placement, same reason. Deliberately NOT under `shouldRunChecks`: that flag buys a fast release by\n  // skipping the VERIFICATION of the code, and this is a correctness gate on the release itself — the bump\n  // a `--no-checks` release ships is as public, and as unfixable afterwards, as any other.\n  await assertVersionUpdateTypeMeetsBumpFloor(versionUpdateType);\n  // Same placement, same reason: a changelog section nobody will review is fully known before the gate, and a subject it\n  // fails on is already pushed, so learning that after the preflight only costs the preflight.\n  await assertNonInteractiveChangelogIsPublishable(versionUpdateType, changelogFilePath, shouldEditChangelog);\n\n  if (shouldRunChecks) {\n    await assertGitRepoClean();\n  }\n\n  // Read before the gate, so a checkout switched at any point of the release is caught after the commit.\n  const startHead = await readGitHeadState();\n\n  // The rest of the preflight IS `npm run gate`, not a copy of it: a check added to the gate is reachable\n  // from the branch and from the release by construction, instead of by two lists happening to agree.\n  // The clean-repo assertion above stays here, because the gate is run on a dirty tree on purpose.\n  // The build is a prerequisite for publishing, not a verification check, so it runs unless `shouldBuild` is `false` — this keeps the released artifacts in sync with the current code even on a fast release.\n  await gate({\n    shouldBuild,\n    shouldRunChecks,\n    shouldRunIntegrationTests: true\n  });\n\n  const newVersion = await getNewVersion(versionUpdateType);\n\n  // The changelog is settled BEFORE anything is written, because this is the only step that can block on a\n  // human. Interrupting it therefore leaves the working tree pristine and the whole release re-runnable,\n  // instead of stranding a bumped-but-uncommitted tree that `assertGitRepoClean` then refuses to re-release.\n  const newChangeLog = await prepareChangelog(newVersion, {\n    changelogFilePath,\n    shouldEditChangelog\n  });\n\n  await updateVersionInFiles(newVersion);\n  await updateVersionInExtraFiles?.(newVersion);\n\n  await writeChangelog(newChangeLog);\n  await addUpdatedFilesToGit(newVersion, { shouldVerifyCommit });\n  // The tag names the verified commit rather than whatever `HEAD` is by the time `git tag` runs.\n  const releaseCommitSha = await assertReleaseCommitLanded(newVersion, startHead, 'tagging');\n  await addGitTag(newVersion, releaseCommitSha);\n\n  if (!shouldRelease) {\n    getLibDebugger('Version')('Skipping git push and GitHub release (--no-release). The version bump, changelog, commit, and tag have been created locally.');\n    return;\n  }\n\n  await assertReleaseCommitLanded(newVersion, startHead, 'pushing');\n  await gitPush();\n  await prepareGitHubRelease?.(newVersion);\n  await publishGitHubRelease(newVersion, { getReleaseAssetPaths, shouldCloseReleasedIssues });\n}\n\n/**\n * Updates the version in `package.json` and, where they exist, `package-lock.json` and `npm-shrinkwrap.json`.\n *\n * @param newVersion - The new version string to update in the files.\n * @returns A {@link Promise} that resolves when the update is complete.\n */\nexport async function updateVersionInFiles(newVersion: string): Promise<void> {\n  await editPackageJson((packageJson) => {\n    packageJson.version = newVersion;\n  });\n\n  await editPackageLockJson(update, { shouldSkipIfMissing: true });\n  await editNpmShrinkWrapJson(update, { shouldSkipIfMissing: true });\n\n  function update(packageLockJson: PackageLockJson): void {\n    packageLockJson.version = newVersion;\n    const defaultPackage = packageLockJson.packages?.[''];\n    if (defaultPackage) {\n      defaultPackage.version = newVersion;\n    }\n  }\n}\n\n/**\n * Validates the version update type to ensure it is either a recognized type\n * or a valid manual version string.\n *\n * @param versionUpdateType - The version update type to validate.\n * @throws Error if the version update type is invalid.\n */\nexport function validate(versionUpdateType: string): void {\n  if (getVersionUpdateType(versionUpdateType) === VersionUpdateType.Invalid) {\n    throw new Error(\n      'Invalid version update type. Please use \\'major\\', \\'minor\\', \\'patch\\', \\'premajor\\', \\'preminor\\', \\'prepatch\\', \\'prerelease\\', or \\'x.y.z[-suffix]\\' format.'\n    );\n  }\n}\n\n/**\n * Refuses a changelog whose NEW section matches one of the maintainer's own unpublished forbidden patterns.\n *\n * Every commit subject since the last tag ships verbatim into the new section, so a subject that carries\n * vocabulary private to the maintainer — an internal tracker id, a private project short name — lands in a\n * checked-in, published file inside the release commit, where nothing ever looks at it again. The list of what\n * counts as private cannot live in this library or in the repository without publishing the very thing it\n * protects, so it comes from the file {@link FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE} names, and this is a no-op\n * wherever that is not configured.\n *\n * Like {@link assertChangelogHasNoMergeSubjects}, only the section being published is scanned, and the throw\n * comes before anything is written.\n *\n * @param changelogContent - The full composed `CHANGELOG.md` content.\n * @param version - The version whose section is about to be published.\n * @returns A {@link Promise} that resolves when the section is clean.\n */\nasync function assertChangelogHasNoForbiddenPatterns(changelogContent: string, version: string): Promise<void> {\n  const patterns = await readForbiddenPatterns();\n  const matches = findForbiddenPatternMatches(extractChangelogSection(changelogContent, version), patterns);\n\n  if (matches.length === 0) {\n    return;\n  }\n\n  throw new Error(\n    `The ${version} section of ${RepoPaths.ChangelogMd} matches a pattern from the file`\n      + ` ${FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE} names:\\n`\n      + `${matches.map(({ line, match }) => `${line}    <- ${match}`).join('\\n')}\\n`\n      + 'Nothing has been written yet. Supply release notes that say the same thing without it, with'\n      + ' `--changelog-file <path>`, or remove it at the interactive review, and re-run the release.'\n  );\n}\n\n/**\n * Refuses a changelog whose NEW section still carries an entry that reads as a merge subject git wrote itself.\n *\n * The convention this enforces is that a non-ff merge takes the same Conventional-Commits subject as the branch\n * commit it lands. Nothing used to hold it: for a non-ff merge the first-parent commit is the merge commit, so a\n * default subject ships verbatim, publishing a bare branch name (`Merge branch 'fix-the-thing'`) as a changelog\n * entry — which says nothing about what changed, and on a branch named after a private tracker item decodes to\n * nothing at all for a reader. The interactive review was the de facto catch, and `--no-changelog-editing`, the\n * flag an unattended release actually uses, skips it; one sweep across this workspace found twelve such\n * published entries in a single repository.\n *\n * Only the section being published is scanned, so an entry already shipped under an older version cannot block\n * every future release. {@link toChangelogEntry} has already rewritten every merge that had a body to rewrite\n * from, so what reaches here is a merge whose author wrote nothing at all — which no rewrite can invent, and\n * which is therefore worth stopping the release for.\n *\n * @param changelogContent - The full composed `CHANGELOG.md` content.\n * @param version - The version whose section is about to be published.\n */\nfunction assertChangelogHasNoMergeSubjects(changelogContent: string, version: string): void {\n  const BULLET_REG_EXP = /^- /;\n  const offendingEntries = extractChangelogSection(changelogContent, version)\n    .split('\\n')\n    .filter((line) => MERGE_SUBJECT_REG_EXP.test(line.replace(BULLET_REG_EXP, '')));\n\n  if (offendingEntries.length === 0) {\n    return;\n  }\n\n  throw new Error(\n    `The ${version} section of ${RepoPaths.ChangelogMd} carries a merge subject git wrote itself:\\n`\n      + `${offendingEntries.join('\\n')}\\n`\n      + 'Such an entry publishes a branch name instead of saying what shipped. Give the merge commit the same'\n      + ' subject as the branch commit it lands (`git commit --amend` on the merge, then re-run the release), or'\n      + ' supply the release notes yourself with `--changelog-file <path>`.'\n  );\n}\n\n/**\n * Refuses a release that would have to stop at the interactive changelog review with nobody there to\n * finish it. Called from the preflight so the refusal costs seconds, not the whole check-and-build gate.\n *\n * @param changelogFilePath - The path to the prepared release notes, or `undefined` when there is none.\n * @param shouldEditChangelog - Whether the generated changelog is meant to be reviewed interactively.\n */\nfunction assertChangelogStepIsNonBlocking(changelogFilePath: string | undefined, shouldEditChangelog: boolean): void {\n  if (changelogFilePath !== undefined || !shouldEditChangelog || process.stdin.isTTY) {\n    return;\n  }\n\n  throw new Error(\n    'The interactive changelog review needs a terminal, and this process has none, so the release would block forever.'\n      + ' Pass `--changelog-file <path>` to supply prepared release notes, or `--no-changelog-editing` to accept the'\n      + ' changelog generated from the commit messages as is.'\n  );\n}\n\n/**\n * Runs the checks {@link prepareChangelog} runs on a changelog nobody will review, before the gate rather than\n * after it.\n *\n * Without an interactive review (`--no-changelog-editing`, or `--changelog-file`), the new section is fully decided\n * by what is already committed, so every check `prepareChangelog` would throw on can be answered in seconds. A\n * release once passed its whole 25-minute preflight and was then refused by `lint:md` over a pushed commit subject\n * it could have named at the start. With a review due, nothing is checked here, because the author can still fix\n * a finding in the editor.\n *\n * @param versionUpdateType - The requested version update type.\n * @param changelogFilePath - The prepared notes, when the release was given them.\n * @param shouldEditChangelog - Whether the interactive review was asked for.\n * @returns A {@link Promise} that resolves when the section would pass, and rejects naming what it fails on.\n */\nasync function assertNonInteractiveChangelogIsPublishable(\n  versionUpdateType: string,\n  changelogFilePath: string | undefined,\n  shouldEditChangelog: boolean\n): Promise<void> {\n  if (isChangelogReviewDue(changelogFilePath, shouldEditChangelog)) {\n    return;\n  }\n\n  const newVersion = await getNewVersion(versionUpdateType);\n  const changelog = await composeChangelogNobodyReviews(newVersion, changelogFilePath);\n  const findings = await getChangelogSectionFindings(changelog, newVersion);\n  if (findings.length > 0) {\n    throw toChangelogFindingsError(findings, newVersion);\n  }\n\n  assertChangelogHasNoMergeSubjects(changelog, newVersion);\n  await assertChangelogHasNoForbiddenPatterns(changelog, newVersion);\n}\n\n/**\n * Refuses a release whose bump is LOWER than the commits it is about to publish force it to be.\n *\n * The rule this enforces is old and was written down after `96.5.1` shipped six unreleased `feat:` commits as\n * a patch: choose the bump from the whole range since the last tag, never from the change you happen to be\n * working on. It did not hold — `105.1.0` of this library is a MINOR carrying `feat(vitest-config)!`, so every\n * consumer on a caret range took a breaking change with no version signal — and it could not hold, because it\n * asked a human to scan a range and then type a bump that nothing compared against what the scan would have\n * found. This is that comparison, at the one moment the rule is being broken.\n *\n * It refuses only a bump that is too LOW. A deliberately higher one — a major cut to signal a break late, a\n * minor for a range of pure `fix`es — passes untouched, and there is no flag to switch the gate off: an\n * opt-out is what gets reached for reflexively, and the legitimate escape (bump higher) already exists.\n *\n * Called from the preflight rather than at the bump itself, so a refusal costs seconds instead of the whole\n * check-and-build gate, and nothing has been written when it throws.\n *\n * @param versionUpdateType - The version update type the release was asked for.\n */\nasync function assertVersionUpdateTypeMeetsBumpFloor(versionUpdateType: string): Promise<void> {\n  const versionDebugger = getLibDebugger('Version');\n  const lastTag = await resolveLastReleasedTag(await readPreviousChangelogLines());\n\n  // No baseline, no range, no floor. This is a first release, or one whose previous tag was deleted — the\n  // changelog step falls back to the full history there, and deriving a floor from the full history of a repo\n  // about to cut `1.0.0` would refuse it over commits that predate the concept of a published surface.\n  if (!lastTag) {\n    versionDebugger('No previous release tag resolved, so the bump floor is not derived. The bump is taken as given.');\n    return;\n  }\n\n  const bumpFloor = await getBumpFloor(`${lastTag}..HEAD`);\n  const floorLevel = bumpFloor.level;\n  if (floorLevel === VersionUpdateType.Patch) {\n    return;\n  }\n\n  const newVersion = await getNewVersion(versionUpdateType);\n  const takenLevel = toEffectiveBumpLevel(lastTag, newVersion);\n\n  // An unparsable baseline or target is not this gate's business to fail a release over. It can only happen\n  // for a tag that is not a version at all, which every other step here would have its own trouble with.\n  if (!takenLevel) {\n    versionDebugger(`Could not compare '${newVersion}' against the previous tag '${lastTag}', so the bump floor is not enforced.`);\n    return;\n  }\n\n  if (isBumpLevelAtLeast(takenLevel, floorLevel)) {\n    return;\n  }\n\n  throw toBumpFloorError(bumpFloor, {\n    lastTag,\n    newVersion,\n    takenLevel,\n    versionUpdateType\n  });\n}\n\n/**\n * Composes the new `CHANGELOG.md` content — the new section from the commits since the last tag, or from the\n * prepared notes, above the previous sections — without reviewing, checking or writing it.\n *\n * @param newVersion - The new version number the changelog section is written for.\n * @param changelogFilePath - The prepared notes, when the release was given them.\n * @returns A {@link Promise} that resolves to the composed content.\n */\nasync function composeChangelog(newVersion: string, changelogFilePath: string | undefined): Promise<string> {\n  const previousChangelogLines = await readPreviousChangelogLines();\n\n  let newChangeLog = `# CHANGELOG\\n\\n## ${newVersion}\\n\\n`;\n\n  if (changelogFilePath === undefined) {\n    const lastTag = await resolveLastReleasedTag(previousChangelogLines);\n    const commitRange = lastTag ? `${lastTag}..HEAD` : 'HEAD';\n    const commitMessagesString = await execFromRoot(`git log ${commitRange} --format=%B --first-parent -z`, { isQuiet: true });\n    const commitMessages = commitMessagesString.split('\\0').filter(Boolean).map((commitMessage) => toChangelogEntry(commitMessage));\n\n    for (const message of commitMessages) {\n      newChangeLog += `- ${autolinkBareUrls(message)}\\n`;\n    }\n  } else {\n    const preparedNotes = await readFile(changelogFilePath, 'utf-8');\n    newChangeLog += `${replaceAll({ $string: preparedNotes, replacer: '\\n', searchValue: '\\r\\n' }).trim()}\\n`;\n  }\n\n  if (previousChangelogLines.length > 0) {\n    newChangeLog += '\\n';\n    for (const line of previousChangelogLines) {\n      newChangeLog += `${line}\\n`;\n    }\n  }\n\n  return newChangeLog;\n}\n\n/**\n * Composes the new `CHANGELOG.md` content for a release nobody reviews, applying `lint:md:fix`'s fixes to a section\n * generated from commit subjects.\n *\n * A subject can fail `lint:md` without anyone having had the chance to fix it: a `--no-ff` merge is made with\n * `HUSKY=0`, so commitlint never sees it, and an issue-closing merge takes the issue title verbatim. An Obsidian\n * plugin's subject naming the plugin without backticks stopped a release that way three times, after the whole\n * preflight. Whatever the repository's configuration can fix is fixed here, and what it cannot is still refused by\n * the findings check that follows. Prepared notes are the author's reviewed text, so they are never rewritten, and\n * only the new section is touched, never a published one.\n *\n * @param newVersion - The new version number the changelog section is written for.\n * @param changelogFilePath - The prepared notes, when the release was given them.\n * @returns A {@link Promise} that resolves to the composed content.\n */\nasync function composeChangelogNobodyReviews(newVersion: string, changelogFilePath: string | undefined): Promise<string> {\n  const changelog = await composeChangelog(newVersion, changelogFilePath);\n  if (changelogFilePath !== undefined) {\n    return changelog;\n  }\n\n  const packageJson = await readPackageJson();\n  if (!Object.keys(packageJson.scripts ?? {}).includes(LINT_MD_SCRIPT_NAME)) {\n    return changelog;\n  }\n\n  const section = extractChangelogSection(changelog, newVersion);\n  const { content, fixCount } = await fixMarkdownContent({\n    content: toChangelogSectionDocument(changelog, newVersion),\n    filePath: resolvePathFromRootSafe({ path: RepoPaths.ChangelogMd })\n  });\n  if (fixCount === 0) {\n    return changelog;\n  }\n\n  console.warn(`Fixed ${String(fixCount)} markdownlint finding(s) in the generated ${newVersion} changelog section, so it differs from the commit subjects.`);\n  const heading = `## ${newVersion}\\n\\n`;\n  return changelog.replace(`${heading}${section}`, () => `${heading}${extractChangelogSection(content, newVersion)}`);\n}\n\nfunction describeBranch(branch: string): string {\n  return branch ? `branch '${branch}'` : 'a detached HEAD';\n}\n\n/**\n * Extracts the body of one version's `CHANGELOG.md` section — everything between its `## <version>` heading\n * and whichever comes first, the next `## ` heading or the end of the file.\n *\n * Ending at the end of the file is not an edge case but the normal shape of a FIRST release: sections are\n * prepended, so the newest one is bounded by the previous release only once a previous release exists. The\n * regex this replaced required a trailing `\\n\\n##`, so every `1.0.0` silently published empty release notes.\n * Terminating on `'## '` WITH its trailing space is what keeps an `###` sub-heading inside the section\n * instead of truncating it there.\n *\n * @param changelogContent - The full contents of `CHANGELOG.md`.\n * @param version - The version whose section to extract.\n * @returns The section body, trimmed, or an empty string when the changelog has no section for that version.\n */\nfunction extractChangelogSection(changelogContent: string, version: string): string {\n  const lines = changelogContent.split(/\\r?\\n/);\n  const headingIndex = lines.indexOf(`## ${version}`);\n  if (headingIndex === -1) {\n    return '';\n  }\n\n  const bodyStartIndex = headingIndex + 1;\n  const nextHeadingOffset = lines.slice(bodyStartIndex).findIndex((line) => line.startsWith('## '));\n  const bodyEndIndex = nextHeadingOffset === -1 ? lines.length : bodyStartIndex + nextHeadingOffset;\n  return lines.slice(bodyStartIndex, bodyEndIndex).join('\\n').trim();\n}\n/**\n * Derives the lowest bump a commit range may be published under, from the Conventional-Commits markers the\n * commits in it carry.\n *\n * A `!` before the subject's colon, or a `BREAKING CHANGE:` / `BREAKING-CHANGE:` footer, forces a major; a\n * `feat` type forces a minor; everything else — `fix`, `chore`, `docs`, `refactor`, an unparsable subject —\n * constrains nothing and yields a patch floor, which is no constraint at all.\n *\n * **Every commit in the range is read, deliberately NOT only the first-parent ones**, which is where this\n * differs from the changelog generated over the same range. The changelog is first-parent because it publishes\n * one line per landed change; a breaking change is breaking whichever parent it arrived on. Concretely,\n * {@link toChangelogEntry} lifts only the FIRST line of a merge body onto a default merge subject, so a\n * `BREAKING CHANGE:` footer written on a branch commit is invisible to the first-parent history — and a footer\n * is the one breaking signal Conventional Commits puts in the body rather than the subject. The cost of\n * reading everything is over-detection: a branch whose breaking commit was reworked into a non-breaking merge\n * still forces a major. That direction is safe — an over-bump costs a consumer nothing and the message names\n * the commit so the author can see exactly which one — and the other direction is the defect this exists for.\n *\n * @param commitRange - The git revision range to scan, e.g. `105.2.0..HEAD`.\n * @returns A {@link Promise} that resolves to the {@link BumpFloor} the range forces.\n */\nasync function getBumpFloor(commitRange: string): Promise<BumpFloor> {\n  // `%H%n%B` puts the hash on its own first line and the full message under it, and `-z` separates the\n  // commits with NUL — so nothing in a commit message can be mistaken for a record boundary.\n  const output = await execFromRoot(['git', 'log', commitRange, '--format=%H%n%B', '-z'], { isQuiet: true });\n\n  const forcingCommits = output\n    .split('\\0')\n    .map((record) => toForcingCommit(record))\n    .filter((forcingCommit) => forcingCommit !== null);\n\n  return {\n    forcingCommits,\n    level: toHighestBumpLevel(forcingCommits)\n  };\n}\n\n/**\n * Runs `lint:md`'s and `spellcheck`'s checks over the NEW section of a composed changelog, before any of it\n * reaches the repository.\n *\n * Only the new section is checked, and deliberately so. The honest check is the whole file, but it fails a\n * release on a defect in a section somebody shipped years ago — which is a release nobody can cut without\n * first fixing history, and is exactly how a changelog defect becomes a permanent blocker instead of a\n * two-minute fix. That is not hypothetical for the spelling half in particular: it is the state five\n * repositories in this workspace are in, each with a coined word already published in an old section. The new\n * section is the only part this release is responsible for.\n *\n * BOTH checks run over every settle, and neither short-circuits the other. An author who has a hard-wrapped\n * line and a coined word is told about both at once, in one round of the review, rather than fixing one and\n * being sent back for the other.\n *\n * Each half runs only where the project defines the script it stands for, just as {@link gate} runs that script\n * only where it is defined. A project with no `spellcheck` has no spelling configuration either, so `cspell` would\n * judge its release notes against the stock dictionaries alone and refuse the release over the plugin's own name:\n * a check the project never adopted, enforced only at release time.\n *\n * @param changelogContent - The full composed `CHANGELOG.md` content.\n * @param version - The version whose section is about to be published.\n * @returns A {@link Promise} that resolves to the findings, or an empty array when the section is clean.\n */\nasync function getChangelogSectionFindings(changelogContent: string, version: string): Promise<ChangelogFinding[]> {\n  const content = toChangelogSectionDocument(changelogContent, version);\n  const filePath = resolvePathFromRootSafe({ path: RepoPaths.ChangelogMd });\n  const packageJson = await readPackageJson();\n  const scriptNames = Object.keys(packageJson.scripts ?? {});\n\n  const markdownlintFindings = scriptNames.includes(LINT_MD_SCRIPT_NAME)\n    ? await lintMarkdownContent({\n      content,\n      filePath\n    })\n    : [];\n  const spellingFindings = scriptNames.includes(SPELLCHECK_SCRIPT_NAME)\n    ? await spellcheckContent({\n      content,\n      filePath\n    })\n    : [];\n\n  return [\n    ...markdownlintFindings.map((text) => ({\n      scriptName: LINT_MD_SCRIPT_NAME,\n      text\n    })),\n    ...spellingFindings.map((text) => ({\n      scriptName: SPELLCHECK_SCRIPT_NAME,\n      text\n    }))\n  ];\n}\n\n/**\n * The default release assets: the project's `npm pack` tarball, written into `dist/`, and `dist/styles.css`.\n *\n * @returns The asset paths, relative to the project root.\n */\nasync function getNpmPackReleaseAssetPaths(): Promise<string[]> {\n  const resultOutput = await execFromRoot(['npm', 'pack', '--pack-destination', RepoPaths.Dist, '--json'], { isQuiet: true });\n  const result = parseNpmPackOutput(resultOutput);\n  return [\n    join(RepoPaths.Dist, result.filename),\n    join(RepoPaths.Dist, RepoPaths.StylesCss)\n  ];\n}\n\n/**\n * Whether a bump reaches a floor.\n *\n * Spelled out rather than given numeric ranks, because three levels do not need an ordering scheme and a\n * `2 >= 3` in a release gate is one transposition away from silently passing everything. `floorLevel` excludes\n * {@link VersionUpdateType.Patch} for the same reason it is not tested for: a patch floor is no floor, and its\n * only caller has already returned by then — a branch that can only ever answer `true` is one nobody reads and\n * nothing covers.\n *\n * @param level - The {@link BumpLevel} actually taken.\n * @param floorLevel - The {@link BumpLevel} required.\n * @returns Whether `level` is at least `floorLevel`.\n */\nfunction isBumpLevelAtLeast(level: BumpLevel, floorLevel: VersionUpdateType.Major | VersionUpdateType.Minor): boolean {\n  return floorLevel === VersionUpdateType.Major\n    ? level === VersionUpdateType.Major\n    : level !== VersionUpdateType.Patch;\n}\n\n/**\n * Whether the release opens the interactive changelog review. Prepared notes are already the reviewed text, so\n * they never open an editor, whatever `shouldEditChangelog` says.\n *\n * @param changelogFilePath - The prepared notes, when the release was given them.\n * @param shouldEditChangelog - Whether the interactive review was asked for.\n * @returns Whether the review is due.\n */\nfunction isChangelogReviewDue(changelogFilePath: string | undefined, shouldEditChangelog: boolean): boolean {\n  return changelogFilePath === undefined && shouldEditChangelog;\n}\n\n/**\n * Reads the issue references off one {@link ISSUE_REFERENCE_LINE_REG_EXP} line.\n *\n * A cross-repository reference is rendered as its URL rather than as `owner/repo#n`: GitHub shows the URL as the\n * same short link, and the spellchecker the changelog section is held to skips a URL but not a repository name.\n *\n * @param line - One line of a commit body.\n * @returns The references, or `null` when the line is not a reference line or holds anything but references.\n */\nfunction parseIssueReferenceLine(line: string): IssueReference[] | null {\n  const referencesText = ISSUE_REFERENCE_LINE_REG_EXP.exec(line.trim())?.groups?.['references'];\n  if (referencesText?.replaceAll(ISSUE_REFERENCE_REG_EXP, '').replaceAll(/\\band\\b|[\\s,]/g, '') !== '') {\n    return null;\n  }\n\n  return Array.from(referencesText.matchAll(ISSUE_REFERENCE_REG_EXP), (match): IssueReference => {\n    const bareNumber = getOptionalNamedGroup(match, 'bareNumber');\n    if (bareNumber !== null) {\n      return { rendered: `#${bareNumber}`, spellings: [`#${bareNumber}`] };\n    }\n    const repoSlug = getOptionalNamedGroup(match, 'urlSlug') ?? getOptionalNamedGroup(match, 'slug');\n    const issueNumber = getOptionalNamedGroup(match, 'urlNumber') ?? getOptionalNamedGroup(match, 'slugNumber');\n    assertNonNullable(repoSlug);\n    assertNonNullable(issueNumber);\n    const url = `https://github.com/${repoSlug}/issues/${issueNumber}`;\n    return { rendered: `<${url}>`, spellings: [`${repoSlug}#${issueNumber}`, url, `https://github.com/${repoSlug}/pull/${issueNumber}`] };\n  });\n}\n\n/**\n * Extracts the single pack result from the output of `npm pack --json`.\n *\n * Two things make this more than a `JSON.parse()`. The payload is PRECEDED on stdout by whatever the\n * `prepare` script printed (the `npm notice` lines go to stderr, not here), so its start has to be found —\n * and it is found by parsing from each candidate start rather than by matching a literal, because the\n * prefix may itself contain a brace. And the payload's SHAPE depends on the npm major: npm 11 and earlier\n * emit an array of pack results, npm 12 emits an object keyed by package name. Both are accepted; scanning\n * for the array's literal opening is what broke every release on npm 12.\n *\n * @param output - The stdout of `npm pack --json`.\n * @returns The {@link NpmPackResult} describing the packed tarball.\n * @throws If the output holds no parsable JSON payload, or the payload holds no pack result.\n */\nfunction parseNpmPackOutput(output: string): NpmPackResult {\n  for (const match of output.matchAll(/[[{]/g)) {\n    let payload: unknown;\n\n    try {\n      payload = JSON.parse(output.slice(match.index));\n    } catch {\n      continue;\n    }\n\n    const results = Array.isArray(payload) ? payload as NpmPackResult[] : Object.values(payload as Record<string, NpmPackResult>);\n    const result = results[0];\n\n    if (!result) {\n      throw new Error('Found no pack result in the `npm pack --json` output');\n    }\n\n    return result;\n  }\n\n  throw new Error('Failed to find the JSON payload in the `npm pack --json` output');\n}\n\n/**\n * Composes the full new `CHANGELOG.md` content — including the interactive review, when one is due —\n * WITHOUT touching the repository. Nothing here writes into the repo, so an interrupt anywhere in the\n * review window (the whole point of the split) leaves the working tree exactly as it was.\n *\n * The settled content is handed to {@link assertChangelogHasNoMergeSubjects} before it is returned, which is\n * how that guard reaches every caller and every path — reviewed or not, commit-derived or prepared — from a\n * single site.\n *\n * It is also where the new section is LINTED and SPELLCHECKED, for the same reason and one the release's\n * ordering forces: the release's only `lint:md` and `spellcheck` run in the gate, which is over before this\n * text exists, so every character of a new changelog section used to enter the repository after the only\n * checks that could have looked at it. The generator's own bullets cannot fail them — they are one\n * `toFirstLine` per commit — but the two paths a human or an agent writes, the interactive review and\n * `--changelog-file`, are exactly the paths that carry prose. A defect there does not fail the release: it\n * lands on the default branch inside the `chore: release` commit, and turns the NEXT gate red, on a branch\n * belonging to somebody who did not write it.\n *\n * @param newVersion - The new version number the changelog section is written for.\n * @param options - The {@link UpdateChangelogOptions} controlling where the section body comes from.\n * @returns A {@link Promise} that resolves to the settled `CHANGELOG.md` content.\n */\nasync function prepareChangelog(newVersion: string, options: UpdateChangelogOptions): Promise<string> {\n  const {\n    changelogFilePath,\n    shouldEditChangelog = true\n  } = options;\n  const isReviewDue = isChangelogReviewDue(changelogFilePath, shouldEditChangelog);\n  const newChangeLog = isReviewDue\n    ? await composeChangelog(newVersion, changelogFilePath)\n    : await composeChangelogNobodyReviews(newVersion, changelogFilePath);\n  let settledChangeLog = newChangeLog;\n  let findings: ChangelogFinding[] = [];\n\n  // The checks run on the SETTLED text, so the review sits inside the loop rather than before it: the author is\n  // still sitting at the editor, so they are handed the findings and the same scratch copy back. A review that\n  // returns byte-identical text is the author declining to fix them, which ends the loop instead of reopening\n  // for ever. There is nobody to hand a finding to on the other paths, so those throw on the first one.\n  for (;;) {\n    if (isReviewDue) {\n      const reviewedChangeLog = await reviewChangelog(settledChangeLog, findings);\n      if (findings.length > 0 && reviewedChangeLog === settledChangeLog) {\n        throw toChangelogFindingsError(findings, newVersion);\n      }\n\n      settledChangeLog = reviewedChangeLog;\n    }\n\n    findings = await getChangelogSectionFindings(settledChangeLog, newVersion);\n    if (findings.length === 0) {\n      break;\n    }\n\n    if (!isReviewDue) {\n      throw toChangelogFindingsError(findings, newVersion);\n    }\n  }\n\n  // The last thing the composition does, and that placement is the whole point: this ONE site sees the\n  // commit-derived bullets, the prepared notes and whatever a review left behind, so the guard runs whether or not\n  // the interactive review does — and the review is precisely what `--no-changelog-editing` skips. Nothing has been\n  // written to the repository yet either, so the throw leaves the working tree pristine and the release re-runnable.\n  assertChangelogHasNoMergeSubjects(settledChangeLog, newVersion);\n  await assertChangelogHasNoForbiddenPatterns(settledChangeLog, newVersion);\n  return settledChangeLog;\n}\n\n/**\n * Reads `CHANGELOG.md` and returns everything below its `# CHANGELOG` header — so the first line is the\n * newest `## <version>` heading, which is what names the last released version.\n *\n * @returns A {@link Promise} that resolves to the lines, or an empty array when the repository has no changelog\n * yet.\n */\nasync function readPreviousChangelogLines(): Promise<string[]> {\n  const HEADER_LINES_COUNT = 2;\n  const changelogPath = resolvePathFromRootSafe({ path: RepoPaths.ChangelogMd });\n  if (!existsSync(changelogPath)) {\n    return [];\n  }\n\n  const content = await readFile(changelogPath, 'utf-8');\n  const previousChangelogLines = content.split('\\n').slice(HEADER_LINES_COUNT);\n  if (previousChangelogLines.at(-1) === '') {\n    previousChangelogLines.pop();\n  }\n\n  return previousChangelogLines;\n}\n\n/**\n * Resolves the tag of the last released version — the baseline both the changelog range and the bump floor are\n * measured from, derived once here so those two can never disagree about which commits are being published.\n *\n * A heading is not a tag. A hand-written `## 0.0.0` placeholder in a never-tagged repo, or a tag deleted after\n * the fact, would otherwise reach `git log` as a revision it cannot resolve — and it used to reach it at the\n * very END of the release, after the whole preflight had been paid for. Falling back to no baseline\n * over-includes when a tag was deleted, but that is safe and visible: the changelog review is exactly where an\n * over-included range gets trimmed, and the bump floor declines to derive anything at all without a baseline.\n *\n * @param previousChangelogLines - The lines {@link readPreviousChangelogLines} returned.\n * @returns A {@link Promise} that resolves to the tag name, or an empty string when there is none to resolve.\n */\nasync function resolveLastReleasedTag(previousChangelogLines: string[]): Promise<string> {\n  const lastTag = replaceAll({\n    $string: previousChangelogLines[0] ?? '',\n    replacer: '',\n    searchValue: '## '\n  });\n\n  if (!lastTag) {\n    return '';\n  }\n\n  const resolvedLastTag = await execFromRoot(['git', 'rev-parse', '--verify', '--quiet', `refs/tags/${lastTag}`], {\n    isQuiet: true,\n    shouldIgnoreExitCode: true\n  });\n\n  if (!resolvedLastTag) {\n    getLibDebugger('Version')(\n      `${RepoPaths.ChangelogMd} starts at '## ${lastTag}', but no such tag exists. Generating the changelog from the full history instead.`\n    );\n    return '';\n  }\n\n  return lastTag;\n}\n\n/**\n * Hands the composed changelog to the user for review on a scratch copy outside the repository, and\n * returns whatever they left behind. The scratch folder is removed even when the review fails.\n *\n * @param newChangeLog - The composed `CHANGELOG.md` content to hand over for review.\n * @param findings - The findings the previous round of this review left unfixed, printed above the prompt so\n * the author sees what has to change. Empty on the first round.\n * @returns A {@link Promise} that resolves to the reviewed content.\n */\nasync function reviewChangelog(newChangeLog: string, findings: ChangelogFinding[]): Promise<string> {\n  const scratchFolder = await mkdtemp(join(tmpdir(), 'changelog-'));\n  const scratchChangelogPath = join(scratchFolder, RepoPaths.ChangelogMd);\n\n  try {\n    await writeFile(scratchChangelogPath, newChangeLog, 'utf-8');\n\n    const codeVersion = await execFromRoot('code --version', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true\n    });\n    const versionDebugger = getLibDebugger('Version');\n    if (findings.length > 0) {\n      versionDebugger(\n        `${RepoPaths.ChangelogMd} does not pass ${toFailedScriptNames(findings)} yet:\\n${toFindingLines(findings)}`\n      );\n    }\n\n    if (codeVersion) {\n      versionDebugger(`Please update the ${RepoPaths.ChangelogMd} file. Close Visual Studio Code when you are done...`);\n      await execFromRoot(['code', '-w', scratchChangelogPath], {\n        isQuiet: true,\n        shouldIgnoreExitCode: true\n      });\n    } else {\n      versionDebugger('Could not find Visual Studio Code in your PATH. Using console mode instead.');\n      await createInterface(process.stdin, process.stdout).question(\n        `Please update the ${scratchChangelogPath} file. Press Enter when you are done...`\n      );\n    }\n\n    return await readFile(scratchChangelogPath, 'utf-8');\n  } finally {\n    await rm(scratchFolder, {\n      force: true,\n      recursive: true\n    });\n  }\n}\n\n/**\n * Builds the error that refuses a bump lower than the range forces.\n *\n * It names every forcing commit with its short hash, its subject and WHICH marker forced it, because the\n * remedy depends on that: a `feat!` is a deliberate break somebody typed, while a `BREAKING CHANGE:` footer\n * sits in a body nobody re-reads and is exactly the thing this gate exists to surface. The instruction is to\n * take the higher bump, not to edit the commits — history that already reached the default branch is what a\n * release publishes, and rewriting it to dodge a version signal is the defect one level up.\n *\n * @param bumpFloor - The derived {@link BumpFloor}.\n * @param context - The {@link BumpFloorRefusalContext} describing what was asked for.\n * @returns The error to throw.\n */\nfunction toBumpFloorError(bumpFloor: BumpFloor, context: BumpFloorRefusalContext): Error {\n  const forcingLines = bumpFloor.forcingCommits\n    .map((forcingCommit) => `  ${forcingCommit.sha.slice(0, SHORT_SHA_LENGTH)}  ${forcingCommit.subject}  (${forcingCommit.marker})`)\n    .join('\\n');\n\n  return new Error(\n    `The commits since ${context.lastTag} force at least a ${bumpFloor.level} release, but '${context.versionUpdateType}' would publish`\n      + ` ${context.newVersion}, which is a ${context.takenLevel}.\\n`\n      + `${forcingLines}\\n`\n      + 'A release publishes every commit since the last tag, not the change you happen to be working on, so the'\n      + ' bump has to answer for all of them. Re-run the release with a'\n      + ` ${bumpFloor.level} bump — a higher one is always accepted, and nothing has been written yet.`\n  );\n}\n\n/**\n * Turns one full commit message (`git log --format=%B`) into the changelog line it should contribute.\n *\n * Normally that is the subject. The exception is a merge whose subject git wrote itself: for a non-ff merge\n * the first-parent commit IS the merge commit, so its subject is what ships, and a default one publishes a\n * private branch name as a changelog entry. The message the author actually wrote is usually still there —\n * one line below, as the merge body — so it is lifted out rather than discarded, which is exactly the edit a\n * human makes by hand at the review step. A merge with no body has nothing to lift and keeps its subject;\n * {@link assertChangelogHasNoMergeSubjects} is what stops that one from being published.\n *\n * The issues the body names on {@link ISSUE_REFERENCE_LINE_REG_EXP} lines are appended to the line, so the\n * release links them. Only the first-parent commit's body is read, so for a merge it is the merge message that\n * has to carry them. A reference the line already shows is not repeated.\n *\n * @param commitMessage - The full commit message.\n * @returns The changelog line for that commit.\n */\nfunction toChangelogEntry(commitMessage: string): string {\n  const lines = commitMessage.split(/\\r?\\n/).filter(Boolean);\n  const subject = lines[0] ?? '';\n  const bodyLines = lines.slice(1);\n  const entry = MERGE_SUBJECT_REG_EXP.test(subject) ? bodyLines.find((line) => !parseIssueReferenceLine(line)) ?? subject : subject;\n  const references = new Set<string>();\n  for (const reference of bodyLines.flatMap((line) => parseIssueReferenceLine(line) ?? [])) {\n    if (reference.spellings.every((spelling) => !new RegExp(String.raw`(?<![\\w/])${escapeRegExp(spelling)}(?!\\d)`).test(entry))) {\n      references.add(reference.rendered);\n    }\n  }\n  return references.size === 0 ? entry : `${entry} (${[...references].join(', ')})`;\n}\n\n/**\n * Builds the error that stops a release whose new changelog section does not pass `lint:md` or `spellcheck`.\n *\n * It is thrown from the composition step, which is BEFORE anything is written, so the recovery it describes is\n * the whole recovery: there is nothing to revert, and the release re-runs from the top.\n *\n * @param findings - The findings, as {@link getChangelogSectionFindings} collected them.\n * @param version - The version whose section was being published.\n * @returns The error to throw.\n */\nfunction toChangelogFindingsError(findings: ChangelogFinding[], version: string): Error {\n  const scriptNames = toFailedScriptNames(findings);\n  return new Error(\n    `The ${version} section of ${RepoPaths.ChangelogMd} does not pass ${scriptNames}:\\n`\n      + `${toFindingLines(findings)}\\n`\n      + 'The changelog is settled before it is written, so this stops the release with the repository untouched'\n      + ' and nothing to revert. The line numbers are the ones the written file would have had. Fix the release'\n      + ' notes — in the prepared notes file, or in the commit messages they were generated from — or, for a word'\n      + ' this project really does use, add it to the project\\'s `cspell` configuration, and re-run the release.'\n      + ' Releasing anyway would land the defect on the default branch inside the release commit, where the next'\n      + ` ${scriptNames} on anyone's branch reports it.`\n  );\n}\n\n/**\n * Wraps one version's changelog section in the minimal document the checks are handed.\n *\n * The section goes inside a document rather than on its own, so the heading and list rules see the\n * context they need (a document whose first line is a list item is a different document). The line numbers a\n * finding reports are then the composed `CHANGELOG.md`'s own, which is not a coincidence and is worth keeping:\n * a section is PREPENDED, so this document is character-for-character the head of the file about to be written.\n *\n * @param changelogContent - The full composed `CHANGELOG.md` content.\n * @param version - The version whose section is about to be published.\n * @returns The minimal document to check.\n */\nfunction toChangelogSectionDocument(changelogContent: string, version: string): string {\n  const heading = `# CHANGELOG\\n\\n## ${version}`;\n  const section = extractChangelogSection(changelogContent, version);\n  // An empty section is a real shape — a release with no commits to describe, or prepared notes that are an\n  // empty file — and appending a blank body to the heading would report a defect this release did not commit.\n  return section === '' ? `${heading}\\n` : `${heading}\\n\\n${section}\\n`;\n}\n\n/**\n * Reads off which release line a version actually moves, relative to the baseline it is being cut from.\n *\n * This is measured rather than read off the requested type on purpose, because the type does not always say.\n * `prerelease` advances whichever line an earlier `premajor` or `preminor` already chose, and an explicit\n * `x.y.z` says nothing at all until it is compared. Taking the coordinates of the resulting version answers all\n * of them with one rule — and it answers them the way a consumer's caret range sees it, which is the only\n * reading that matters for a published surface.\n *\n * @param baseVersion - The previous released version.\n * @param newVersion - The version about to be published.\n * @returns The {@link BumpLevel}, or `null` when either version is not parsable as semver.\n */\nfunction toEffectiveBumpLevel(baseVersion: string, newVersion: string): BumpLevel | null {\n  const base = parse(baseVersion);\n  const next = parse(newVersion);\n  if (!base || !next) {\n    return null;\n  }\n\n  if (next.major > base.major) {\n    return VersionUpdateType.Major;\n  }\n\n  return next.minor > base.minor ? VersionUpdateType.Minor : VersionUpdateType.Patch;\n}\n\n/**\n * Names the npm scripts that actually reported something, in the order they ran.\n *\n * Naming both unconditionally would be the easy version and would be a lie half the time: a release stopped by\n * a coined word would tell its author to go and look at `lint:md`, which passed.\n *\n * @param findings - The findings to name the scripts of.\n * @returns The script names, joined for prose — `lint:md`, `spellcheck`, or `lint:md and spellcheck`.\n */\nfunction toFailedScriptNames(findings: ChangelogFinding[]): string {\n  const scriptNames = [LINT_MD_SCRIPT_NAME, SPELLCHECK_SCRIPT_NAME].filter((scriptName) => findings.some((finding) => finding.scriptName === scriptName));\n  return scriptNames.join(' and ');\n}\n\n/**\n * Renders the findings for a message, each line tagged with the script that reported it.\n *\n * The tag is not decoration: the two tools' output shapes are similar enough to be mistaken for each other,\n * and the fix for one is not the fix for the other.\n *\n * @param findings - The findings to render.\n * @returns The rendered lines, one finding per line.\n */\nfunction toFindingLines(findings: ChangelogFinding[]): string {\n  return findings.map((finding) => `[${finding.scriptName}] ${finding.text}`).join('\\n');\n}\n\n/**\n * Classifies one `git log --format=%H%n%B -z` record into the {@link ForcingCommit} it is, or `null` when it\n * forces nothing.\n *\n * @param record - One NUL-delimited record: the full hash on the first line, the full commit message below it.\n * @returns The {@link ForcingCommit}, or `null` for a record that constrains nothing or is not a record at all\n * (the trailing empty string `-z` output ends with, among others).\n */\nfunction toForcingCommit(record: string): ForcingCommit | null {\n  // The trailing empty record `-z` leaves has no hash, and a record with no line under the hash is not one\n  // this can classify. Both are the same non-answer.\n  const [sha, subjectLine, ...bodyLines] = record.split('\\n');\n  if (!sha || subjectLine === undefined) {\n    return null;\n  }\n\n  const subject = subjectLine.trim();\n  const body = bodyLines.join('\\n');\n  const subjectMatch = CONVENTIONAL_COMMIT_SUBJECT_REG_EXP.exec(subject);\n\n  if (subjectMatch?.groups?.['breaking']) {\n    return {\n      level: VersionUpdateType.Major,\n      marker: BREAKING_MARKER,\n      sha,\n      subject\n    };\n  }\n\n  if (BREAKING_CHANGE_FOOTER_REG_EXP.test(body)) {\n    return {\n      level: VersionUpdateType.Major,\n      marker: BREAKING_CHANGE_FOOTER_MARKER,\n      sha,\n      subject\n    };\n  }\n\n  return subjectMatch?.groups?.['type']?.toLowerCase() === FEAT_TYPE\n    ? {\n      level: VersionUpdateType.Minor,\n      marker: FEAT_TYPE_MARKER,\n      sha,\n      subject\n    }\n    : null;\n}\n\n/**\n * Reduces the commits that force something to the one floor the range as a whole has to clear.\n *\n * @param forcingCommits - The {@link ForcingCommit}s found in the range.\n * @returns The highest {@link BumpLevel} any of them forces, or {@link VersionUpdateType.Patch} — no\n * constraint — when there are none.\n */\nfunction toHighestBumpLevel(forcingCommits: readonly ForcingCommit[]): BumpLevel {\n  if (forcingCommits.some((forcingCommit) => forcingCommit.level === VersionUpdateType.Major)) {\n    return VersionUpdateType.Major;\n  }\n\n  return forcingCommits.length > 0 ? VersionUpdateType.Minor : VersionUpdateType.Patch;\n}\n\n/**\n * Writes the composed changelog into the repository. Deliberately the last thing the changelog step does,\n * so nothing lands on disk until the content is settled.\n *\n * @param newChangeLog - The settled `CHANGELOG.md` content to write.\n * @returns A {@link Promise} that resolves once the changelog has been written.\n */\nasync function writeChangelog(newChangeLog: string): Promise<void> {\n  await writeFile(resolvePathFromRootSafe({ path: RepoPaths.ChangelogMd }), newChangeLog, 'utf-8');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,SAAS,sBAAsB;AAC/B,SAAS,qBAAqB;AAC9B,SAAS,YAAY;AACrB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,kBAAkB;AAC3B,SAAS,yBAAyB;AAClC,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,cAAc;AACvB,SAAS,uBAAuB;AAChC,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAIP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,YAAY;AACrB,SAAS,yBAAyB;AAClC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,2BAA2B;AACpC,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AA6RP,MAAM,iCAAiC;AAOvC,MAAM,gCAAgC;AAKtC,MAAM,kBAAkB;AAKxB,MAAM,mBAAmB;AASzB,MAAM,sCAAsC;AAK5C,MAAM,gBAAgB;AAKtB,MAAM,YAAY;AAMlB,MAAM,0BAA0B;AAUhC,MAAM,+BAA+B;AAMrC,MAAM,sBAAsB;AAM5B,MAAM,mBAAmB;AAKzB,MAAM,yBAAyB;AAe/B,MAAM,wBAAwB;AAOvB,IAAK,oBAAL,kBAAKA,uBAAL;AACL,EAAAA,mBAAA,aAAU;AACV,EAAAA,mBAAA,WAAQ;AACR,EAAAA,mBAAA,YAAS;AACT,EAAAA,mBAAA,WAAQ;AACR,EAAAA,mBAAA,WAAQ;AACR,EAAAA,mBAAA,cAAW;AACX,EAAAA,mBAAA,cAAW;AACX,EAAAA,mBAAA,cAAW;AACX,EAAAA,mBAAA,gBAAa;AATH,SAAAA;AAAA,GAAA;AAeZ,MAAM,6BAA6B,IAAI,IAA+B;AAAA,EACpE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC,CAAC;AAwB7B,eAAsB,UAAU,YAAoB,WAAmC;AACrF,QAAM,aAAa,cAAc,UAAU,OAAO,UAAU,WAAW,YAAY,IAAI,SAAS,KAAK,EAAE,IAAI,EAAE,SAAS,KAAK,CAAC;AAC9H;AAgBA,eAAsB,qBAAqB,YAAoB,UAAuC,CAAC,GAAkB;AACvH,QAAM,EAAE,qBAAqB,KAAK,IAAI;AACtC,QAAM,kBAAkB,eAAe,SAAS;AAEhD,QAAM,kBAAkB,CAAC,OAAO,UAAU,MAAM,kBAAkB,UAAU,IAAI,iBAAiB,GAAI,qBAAqB,CAAC,IAAI,CAAC,aAAa,CAAE;AAE/I,aAAS;AACP,QAAI;AACF,YAAM,aAAa,CAAC,OAAO,OAAO,OAAO,GAAG,EAAE,SAAS,KAAK,CAAC;AAC7D,YAAM,aAAa,iBAAiB,EAAE,SAAS,KAAK,CAAC;AACrD;AAAA,IACF,SAAS,OAAO;AACd,UAAI,CAAC,QAAQ,MAAM,OAAO;AACxB,cAAM;AAAA,MACR;AAEA;AAAA,QACE;AAAA,EAAkC,cAAc,KAAK,CAAC;AAAA;AAAA,MAExD;AACA,YAAM,gBAAgB,QAAQ,OAAO,QAAQ,MAAM,EAAE,SAAS,oCAAoC;AAAA,IACpG;AAAA,EACF;AACF;AASA,eAAsB,2BAA0C;AAC9D,MAAI;AACF,UAAM,aAAa,gBAAgB,EAAE,SAAS,KAAK,CAAC;AAAA,EACtD,QAAQ;AACN,UAAM,IAAI,MAAM,6EAA6E;AAAA,EAC/F;AACF;AASA,eAAsB,qBAAoC;AACxD,MAAI;AACF,UAAM,aAAa,iBAAiB,EAAE,SAAS,KAAK,CAAC;AAAA,EACvD,QAAQ;AACN,UAAM,IAAI,MAAM,mEAAmE;AAAA,EACrF;AACF;AASA,eAAsB,qBAAoC;AACxD,MAAI;AACF,UAAM,SAAS,MAAM,aAAa,gDAAgD,EAAE,SAAS,KAAK,CAAC;AACnG,QAAI,QAAQ;AACV,YAAM,IAAI,MAAM;AAAA,IAClB;AAAA,EACF,QAAQ;AACN,UAAM,IAAI,MAAM,kGAAkG;AAAA,EACpH;AACF;AAgBA,eAAsB,0BAA0B,YAAoB,WAAyB,OAAgC;AAC3H,QAAM,kBAAkB,kBAAkB,UAAU;AACpD,QAAM,SAAS,MAAM,aAAa,CAAC,OAAO,UAAU,gBAAgB,GAAG,EAAE,SAAS,KAAK,CAAC;AACxF,QAAM,oBAAoB;AAC1B,QAAM,UAAU,MAAM,aAAa,CAAC,OAAO,OAAO,MAAM,qBAAqB,GAAG,EAAE,SAAS,KAAK,CAAC;AACjG,QAAM,CAAC,MAAM,IAAI,UAAU,IAAI,UAAU,EAAE,IAAI,QAAQ,MAAM,MAAM,iBAAiB;AAEpF,MAAI,WAAW,UAAU,UAAU,YAAY,UAAU,OAAO,YAAY,iBAAiB;AAC3F,WAAO;AAAA,EACT;AAEA,QAAM,IAAI;AAAA,IACR,+BAA+B,KAAK,4BAA4B,UAAU,sDAC5C,eAAe,UAAU,MAAM,CAAC,OAAO,UAAU,GAAG,mBAAmB,eAAe,sCACjG,GAAG,MAAM,OAAO,aAAa,WAAW,MAAM,QAAQ,eAAe,MAAM,CAAC;AAAA,EAGjG;AACF;AAeO,SAAS,iBAAiB,MAAsB;AACrD,SAAO,KAAK,WAAW,qCAAqC,CAAC,QAAQ;AACnE,UAAM,sBAAsB,aAAa,KAAK,GAAG,IAAI,CAAC,KAAK;AAC3D,UAAM,UAAU,IAAI,MAAM,GAAG,IAAI,SAAS,oBAAoB,MAAM;AACpE,WAAO,IAAI,OAAO,IAAI,mBAAmB;AAAA,EAC3C,CAAC;AACH;AAaA,eAAsB,cAAc,mBAA4C;AAC9E,QAAM,cAAc,qBAAqB,iBAAiB;AAC1D,MAAI,gBAAgB,uBAA0B;AAC5C,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,MAAM,gBAAgB;AAC1C,QAAM,iBAAiB,YAAY,WAAW;AAE9C,QAAM,cAAc;AACpB,QAAM,mBAAmB,YAAY,WAAW,KAAK;AACrD,QAAM,aAAa,mBACf,IAAI,gBAAgB,aAAa,aAAa,IAC9C,IAAI,gBAAgB,WAAW;AACnC,oBAAkB,YAAY,qCAAqC,cAAc,gBAAgB,WAAW,GAAG;AAE/G,SAAO;AACT;AAQA,eAAsB,gBAAgB,YAAqC;AACzE,QAAM,gBAAgB,wBAAwB,EAAE,MAAM,UAAU,YAAY,CAAC;AAC7E,QAAM,UAAU,MAAM,SAAS,eAAe,OAAO;AACrD,QAAM,UAAU,wBAAwB,SAAS,UAAU;AAC3D,MAAI,eAAe,UAAU,GAAG,OAAO;AAAA;AAAA,IAAS;AAEhD,QAAM,YAAY,MAAM,aAAa,+BAA+B,EAAE,SAAS,KAAK,CAAC;AACrF,QAAM,OAAO,UAAU,MAAM,OAAO;AACpC,QAAM,kBAAkB,KAAK,CAAC;AAE9B,QAAM,UAAU,MAAM,aAAa,mCAAmC,EAAE,SAAS,KAAK,CAAC;AAEvF,QAAM,aAAa,kBAAkB,GAAG,OAAO,YAAY,eAAe,MAAM,UAAU,KAAK,GAAG,OAAO,YAAY,UAAU;AAE/H,kBAAgB,uBAAuB,UAAU;AACjD,SAAO;AACT;AAQO,SAAS,qBAAqB,mBAA8C;AACjF,QAAM,yBAAyB,2BAA2B,IAAI,iBAAiB;AAC/E,MAAI,wBAAwB;AAC1B,WAAO;AAAA,EACT;AAEA,SAAO,iCAAiC,KAAK,iBAAiB,IAAI,wBAA2B;AAC/F;AAOA,eAAsB,UAAyB;AAC7C,QAAM,aAAa,kCAAkC,EAAE,SAAS,KAAK,CAAC;AACxE;AAOA,eAAsB,mBAA0C;AAC9D,QAAM,SAAS,MAAM,aAAa,CAAC,OAAO,UAAU,gBAAgB,GAAG,EAAE,SAAS,KAAK,CAAC;AACxF,QAAM,MAAM,MAAM,aAAa,CAAC,OAAO,aAAa,MAAM,GAAG,EAAE,SAAS,KAAK,CAAC;AAC9E,SAAO,EAAE,QAAQ,IAAI;AACvB;AAOO,MAAM,2BAA2B;AAAA,EACtC,kBAAkB,EAAE,MAAM,SAAS;AAAA,EACnC,YAAY,EAAE,MAAM,UAAU;AAAA,EAC9B,wBAAwB,EAAE,MAAM,UAAU;AAAA,EAC1C,aAAa,EAAE,MAAM,UAAU;AAAA,EAC/B,0BAA0B,EAAE,MAAM,UAAU;AAAA,EAC5C,oBAAoB,EAAE,MAAM,UAAU;AAAA,EACtC,cAAc,EAAE,MAAM,UAAU;AAClC;AAqCO,SAAS,aAAa,SAA0B;AACrD,SAAO,WAAW,OAAO,MAAM;AACjC;AAoBO,SAAS,sBAAsB,YAA8C;AAClF,QAAM,EAAE,aAAa,OAAO,IAAI,UAAU;AAAA,IACxC,kBAAkB;AAAA;AAAA,IAElB,MAAM;AAAA,IACN,SAAS;AAAA,EACX,CAAC;AAED,SAAO;AAAA,IACL,SAAS,uBAAuB,MAAM;AAAA,IACtC,mBAAmB,YAAY,CAAC;AAAA,EAClC;AACF;AAcA,eAAsB,qBAAqB,YAAoB,UAAuC,CAAC,GAAkB;AACvH,QAAM,EAAE,uBAAuB,6BAA6B,4BAA4B,KAAK,IAAI;AACjG,MAAI,YAAY,MAAM,qBAAqB;AAC3C,cAAY,UAAU,OAAO,CAAC,aAAa,WAAW,wBAAwB,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC;AAElG,QAAM,aAAa;AAAA,IACjB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAG;AAAA,IACH;AAAA,IACA,IAAI,UAAU;AAAA,IACd,GAAI,aAAa,UAAU,IAAI,CAAC,cAAc,IAAI,CAAC;AAAA,IACnD;AAAA,IACA;AAAA,EACF,GAAG;AAAA,IACD,SAAS;AAAA,IACT,OAAO,MAAM,gBAAgB,UAAU;AAAA,EACzC,CAAC;AAED,MAAI,CAAC,2BAA2B;AAC9B;AAAA,EACF;AAEA,MAAI;AACF,UAAM,oBAAoB,EAAE,WAAW,CAAC;AAAA,EAC1C,SAAS,OAAO;AACd,YAAQ,KAAK,OAAO,UAAU,oEAAoE,cAAc,KAAK,CAAC,EAAE;AAAA,EAC1H;AACF;AAQO,SAAS,uBAAuB,QAAqD;AAC1F,SAAO;AAAA,IACL,mBAAmB,OAAO,gBAAgB;AAAA,IAC1C,aAAa,EAAE,OAAO,UAAU,KAAK;AAAA,IACrC,2BAA2B,EAAE,OAAO,kBAAkB,KAAK;AAAA,IAC3D,qBAAqB,EAAE,OAAO,sBAAsB,KAAK;AAAA,IACzD,eAAe,EAAE,OAAO,YAAY,KAAK;AAAA,IACzC,iBAAiB,EAAE,OAAO,WAAW,KAAK;AAAA,IAC1C,oBAAoB,EAAE,OAAO,wBAAwB,KAAK;AAAA,EAC5D;AACF;AAeA,eAAsB,gBAAgB,YAAoB,UAAkC,CAAC,GAAkB;AAC7G,QAAM,eAAe,MAAM,iBAAiB,YAAY,OAAO,CAAC;AAClE;AA0BA,eAAsB,cAAc,mBAA4B,UAAgC,CAAC,GAAkB;AACjH,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA,cAAc;AAAA,IACd,4BAA4B;AAAA,IAC5B,sBAAsB;AAAA,IACtB,gBAAgB;AAAA,IAChB,kBAAkB;AAAA,IAClB,qBAAqB;AAAA,IACrB;AAAA,EACF,IAAI;AAEJ,MAAI,CAAC,mBAAmB;AACtB,UAAM,gBAAgB,QAAQ,IAAI,iBAAiB;AACnD,UAAM,gBAAgB,QAAQ,IAAI,iBAAiB;AAEnD,QAAI,iBAAiB,eAAe;AAClC,YAAM,qBAAqB,aAAa;AACxC,YAAM,cAAc,eAAe,OAAO;AAC1C;AAAA,IACF;AAEA,UAAM,IAAI,MAAM,iCAAiC;AAAA,EACnD;AAEA,WAAS,iBAAiB;AAC1B,QAAM,mBAAmB;AACzB,QAAM,yBAAyB;AAI/B,mCAAiC,mBAAmB,mBAAmB;AAIvE,QAAM,sCAAsC,iBAAiB;AAG7D,QAAM,2CAA2C,mBAAmB,mBAAmB,mBAAmB;AAE1G,MAAI,iBAAiB;AACnB,UAAM,mBAAmB;AAAA,EAC3B;AAGA,QAAM,YAAY,MAAM,iBAAiB;AAMzC,QAAM,KAAK;AAAA,IACT;AAAA,IACA;AAAA,IACA,2BAA2B;AAAA,EAC7B,CAAC;AAED,QAAM,aAAa,MAAM,cAAc,iBAAiB;AAKxD,QAAM,eAAe,MAAM,iBAAiB,YAAY;AAAA,IACtD;AAAA,IACA;AAAA,EACF,CAAC;AAED,QAAM,qBAAqB,UAAU;AACrC,QAAM,4BAA4B,UAAU;AAE5C,QAAM,eAAe,YAAY;AACjC,QAAM,qBAAqB,YAAY,EAAE,mBAAmB,CAAC;AAE7D,QAAM,mBAAmB,MAAM,0BAA0B,YAAY,WAAW,SAAS;AACzF,QAAM,UAAU,YAAY,gBAAgB;AAE5C,MAAI,CAAC,eAAe;AAClB,mBAAe,SAAS,EAAE,8HAA8H;AACxJ;AAAA,EACF;AAEA,QAAM,0BAA0B,YAAY,WAAW,SAAS;AAChE,QAAM,QAAQ;AACd,QAAM,uBAAuB,UAAU;AACvC,QAAM,qBAAqB,YAAY,EAAE,sBAAsB,0BAA0B,CAAC;AAC5F;AAQA,eAAsB,qBAAqB,YAAmC;AAC5E,QAAM,gBAAgB,CAAC,gBAAgB;AACrC,gBAAY,UAAU;AAAA,EACxB,CAAC;AAED,QAAM,oBAAoB,QAAQ,EAAE,qBAAqB,KAAK,CAAC;AAC/D,QAAM,sBAAsB,QAAQ,EAAE,qBAAqB,KAAK,CAAC;AAEjE,WAAS,OAAO,iBAAwC;AACtD,oBAAgB,UAAU;AAC1B,UAAM,iBAAiB,gBAAgB,WAAW,EAAE;AACpD,QAAI,gBAAgB;AAClB,qBAAe,UAAU;AAAA,IAC3B;AAAA,EACF;AACF;AASO,SAAS,SAAS,mBAAiC;AACxD,MAAI,qBAAqB,iBAAiB,MAAM,yBAA2B;AACzE,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACF;AAmBA,eAAe,sCAAsC,kBAA0B,SAAgC;AAC7G,QAAM,WAAW,MAAM,sBAAsB;AAC7C,QAAM,UAAU,4BAA4B,wBAAwB,kBAAkB,OAAO,GAAG,QAAQ;AAExG,MAAI,QAAQ,WAAW,GAAG;AACxB;AAAA,EACF;AAEA,QAAM,IAAI;AAAA,IACR,OAAO,OAAO,eAAe,UAAU,WAAW,oCAC1C,oCAAoC;AAAA,EACrC,QAAQ,IAAI,CAAC,EAAE,MAAM,MAAM,MAAM,GAAG,IAAI,UAAU,KAAK,EAAE,EAAE,KAAK,IAAI,CAAC;AAAA;AAAA,EAG9E;AACF;AAqBA,SAAS,kCAAkC,kBAA0B,SAAuB;AAC1F,QAAM,iBAAiB;AACvB,QAAM,mBAAmB,wBAAwB,kBAAkB,OAAO,EACvE,MAAM,IAAI,EACV,OAAO,CAAC,SAAS,sBAAsB,KAAK,KAAK,QAAQ,gBAAgB,EAAE,CAAC,CAAC;AAEhF,MAAI,iBAAiB,WAAW,GAAG;AACjC;AAAA,EACF;AAEA,QAAM,IAAI;AAAA,IACR,OAAO,OAAO,eAAe,UAAU,WAAW;AAAA,EAC3C,iBAAiB,KAAK,IAAI,CAAC;AAAA;AAAA,EAIpC;AACF;AASA,SAAS,iCAAiC,mBAAuC,qBAAoC;AACnH,MAAI,sBAAsB,UAAa,CAAC,uBAAuB,QAAQ,MAAM,OAAO;AAClF;AAAA,EACF;AAEA,QAAM,IAAI;AAAA,IACR;AAAA,EAGF;AACF;AAiBA,eAAe,2CACb,mBACA,mBACA,qBACe;AACf,MAAI,qBAAqB,mBAAmB,mBAAmB,GAAG;AAChE;AAAA,EACF;AAEA,QAAM,aAAa,MAAM,cAAc,iBAAiB;AACxD,QAAM,YAAY,MAAM,8BAA8B,YAAY,iBAAiB;AACnF,QAAM,WAAW,MAAM,4BAA4B,WAAW,UAAU;AACxE,MAAI,SAAS,SAAS,GAAG;AACvB,UAAM,yBAAyB,UAAU,UAAU;AAAA,EACrD;AAEA,oCAAkC,WAAW,UAAU;AACvD,QAAM,sCAAsC,WAAW,UAAU;AACnE;AAqBA,eAAe,sCAAsC,mBAA0C;AAC7F,QAAM,kBAAkB,eAAe,SAAS;AAChD,QAAM,UAAU,MAAM,uBAAuB,MAAM,2BAA2B,CAAC;AAK/E,MAAI,CAAC,SAAS;AACZ,oBAAgB,iGAAiG;AACjH;AAAA,EACF;AAEA,QAAM,YAAY,MAAM,aAAa,GAAG,OAAO,QAAQ;AACvD,QAAM,aAAa,UAAU;AAC7B,MAAI,eAAe,qBAAyB;AAC1C;AAAA,EACF;AAEA,QAAM,aAAa,MAAM,cAAc,iBAAiB;AACxD,QAAM,aAAa,qBAAqB,SAAS,UAAU;AAI3D,MAAI,CAAC,YAAY;AACf,oBAAgB,sBAAsB,UAAU,+BAA+B,OAAO,uCAAuC;AAC7H;AAAA,EACF;AAEA,MAAI,mBAAmB,YAAY,UAAU,GAAG;AAC9C;AAAA,EACF;AAEA,QAAM,iBAAiB,WAAW;AAAA,IAChC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACH;AAUA,eAAe,iBAAiB,YAAoB,mBAAwD;AAC1G,QAAM,yBAAyB,MAAM,2BAA2B;AAEhE,MAAI,eAAe;AAAA;AAAA,KAAqB,UAAU;AAAA;AAAA;AAElD,MAAI,sBAAsB,QAAW;AACnC,UAAM,UAAU,MAAM,uBAAuB,sBAAsB;AACnE,UAAM,cAAc,UAAU,GAAG,OAAO,WAAW;AACnD,UAAM,uBAAuB,MAAM,aAAa,WAAW,WAAW,kCAAkC,EAAE,SAAS,KAAK,CAAC;AACzH,UAAM,iBAAiB,qBAAqB,MAAM,IAAI,EAAE,OAAO,OAAO,EAAE,IAAI,CAAC,kBAAkB,iBAAiB,aAAa,CAAC;AAE9H,eAAW,WAAW,gBAAgB;AACpC,sBAAgB,KAAK,iBAAiB,OAAO,CAAC;AAAA;AAAA,IAChD;AAAA,EACF,OAAO;AACL,UAAM,gBAAgB,MAAM,SAAS,mBAAmB,OAAO;AAC/D,oBAAgB,GAAG,WAAW,EAAE,SAAS,eAAe,UAAU,MAAM,aAAa,OAAO,CAAC,EAAE,KAAK,CAAC;AAAA;AAAA,EACvG;AAEA,MAAI,uBAAuB,SAAS,GAAG;AACrC,oBAAgB;AAChB,eAAW,QAAQ,wBAAwB;AACzC,sBAAgB,GAAG,IAAI;AAAA;AAAA,IACzB;AAAA,EACF;AAEA,SAAO;AACT;AAiBA,eAAe,8BAA8B,YAAoB,mBAAwD;AACvH,QAAM,YAAY,MAAM,iBAAiB,YAAY,iBAAiB;AACtE,MAAI,sBAAsB,QAAW;AACnC,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,MAAM,gBAAgB;AAC1C,MAAI,CAAC,OAAO,KAAK,YAAY,WAAW,CAAC,CAAC,EAAE,SAAS,mBAAmB,GAAG;AACzE,WAAO;AAAA,EACT;AAEA,QAAM,UAAU,wBAAwB,WAAW,UAAU;AAC7D,QAAM,EAAE,SAAS,SAAS,IAAI,MAAM,mBAAmB;AAAA,IACrD,SAAS,2BAA2B,WAAW,UAAU;AAAA,IACzD,UAAU,wBAAwB,EAAE,MAAM,UAAU,YAAY,CAAC;AAAA,EACnE,CAAC;AACD,MAAI,aAAa,GAAG;AAClB,WAAO;AAAA,EACT;AAEA,UAAQ,KAAK,SAAS,OAAO,QAAQ,CAAC,6CAA6C,UAAU,6DAA6D;AAC1J,QAAM,UAAU,MAAM,UAAU;AAAA;AAAA;AAChC,SAAO,UAAU,QAAQ,GAAG,OAAO,GAAG,OAAO,IAAI,MAAM,GAAG,OAAO,GAAG,wBAAwB,SAAS,UAAU,CAAC,EAAE;AACpH;AAEA,SAAS,eAAe,QAAwB;AAC9C,SAAO,SAAS,WAAW,MAAM,MAAM;AACzC;AAgBA,SAAS,wBAAwB,kBAA0B,SAAyB;AAClF,QAAM,QAAQ,iBAAiB,MAAM,OAAO;AAC5C,QAAM,eAAe,MAAM,QAAQ,MAAM,OAAO,EAAE;AAClD,MAAI,iBAAiB,IAAI;AACvB,WAAO;AAAA,EACT;AAEA,QAAM,iBAAiB,eAAe;AACtC,QAAM,oBAAoB,MAAM,MAAM,cAAc,EAAE,UAAU,CAAC,SAAS,KAAK,WAAW,KAAK,CAAC;AAChG,QAAM,eAAe,sBAAsB,KAAK,MAAM,SAAS,iBAAiB;AAChF,SAAO,MAAM,MAAM,gBAAgB,YAAY,EAAE,KAAK,IAAI,EAAE,KAAK;AACnE;AAsBA,eAAe,aAAa,aAAyC;AAGnE,QAAM,SAAS,MAAM,aAAa,CAAC,OAAO,OAAO,aAAa,mBAAmB,IAAI,GAAG,EAAE,SAAS,KAAK,CAAC;AAEzG,QAAM,iBAAiB,OACpB,MAAM,IAAI,EACV,IAAI,CAAC,WAAW,gBAAgB,MAAM,CAAC,EACvC,OAAO,CAAC,kBAAkB,kBAAkB,IAAI;AAEnD,SAAO;AAAA,IACL;AAAA,IACA,OAAO,mBAAmB,cAAc;AAAA,EAC1C;AACF;AA0BA,eAAe,4BAA4B,kBAA0B,SAA8C;AACjH,QAAM,UAAU,2BAA2B,kBAAkB,OAAO;AACpE,QAAM,WAAW,wBAAwB,EAAE,MAAM,UAAU,YAAY,CAAC;AACxE,QAAM,cAAc,MAAM,gBAAgB;AAC1C,QAAM,cAAc,OAAO,KAAK,YAAY,WAAW,CAAC,CAAC;AAEzD,QAAM,uBAAuB,YAAY,SAAS,mBAAmB,IACjE,MAAM,oBAAoB;AAAA,IAC1B;AAAA,IACA;AAAA,EACF,CAAC,IACC,CAAC;AACL,QAAM,mBAAmB,YAAY,SAAS,sBAAsB,IAChE,MAAM,kBAAkB;AAAA,IACxB;AAAA,IACA;AAAA,EACF,CAAC,IACC,CAAC;AAEL,SAAO;AAAA,IACL,GAAG,qBAAqB,IAAI,CAAC,UAAU;AAAA,MACrC,YAAY;AAAA,MACZ;AAAA,IACF,EAAE;AAAA,IACF,GAAG,iBAAiB,IAAI,CAAC,UAAU;AAAA,MACjC,YAAY;AAAA,MACZ;AAAA,IACF,EAAE;AAAA,EACJ;AACF;AAOA,eAAe,8BAAiD;AAC9D,QAAM,eAAe,MAAM,aAAa,CAAC,OAAO,QAAQ,sBAAsB,UAAU,MAAM,QAAQ,GAAG,EAAE,SAAS,KAAK,CAAC;AAC1H,QAAM,SAAS,mBAAmB,YAAY;AAC9C,SAAO;AAAA,IACL,KAAK,UAAU,MAAM,OAAO,QAAQ;AAAA,IACpC,KAAK,UAAU,MAAM,UAAU,SAAS;AAAA,EAC1C;AACF;AAeA,SAAS,mBAAmB,OAAkB,YAAwE;AACpH,SAAO,eAAe,sBAClB,UAAU,sBACV,UAAU;AAChB;AAUA,SAAS,qBAAqB,mBAAuC,qBAAuC;AAC1G,SAAO,sBAAsB,UAAa;AAC5C;AAWA,SAAS,wBAAwB,MAAuC;AACtE,QAAM,iBAAiB,6BAA6B,KAAK,KAAK,KAAK,CAAC,GAAG,SAAS,YAAY;AAC5F,MAAI,gBAAgB,WAAW,yBAAyB,EAAE,EAAE,WAAW,kBAAkB,EAAE,MAAM,IAAI;AACnG,WAAO;AAAA,EACT;AAEA,SAAO,MAAM,KAAK,eAAe,SAAS,uBAAuB,GAAG,CAAC,UAA0B;AAC7F,UAAM,aAAa,sBAAsB,OAAO,YAAY;AAC5D,QAAI,eAAe,MAAM;AACvB,aAAO,EAAE,UAAU,IAAI,UAAU,IAAI,WAAW,CAAC,IAAI,UAAU,EAAE,EAAE;AAAA,IACrE;AACA,UAAM,WAAW,sBAAsB,OAAO,SAAS,KAAK,sBAAsB,OAAO,MAAM;AAC/F,UAAM,cAAc,sBAAsB,OAAO,WAAW,KAAK,sBAAsB,OAAO,YAAY;AAC1G,sBAAkB,QAAQ;AAC1B,sBAAkB,WAAW;AAC7B,UAAM,MAAM,sBAAsB,QAAQ,WAAW,WAAW;AAChE,WAAO,EAAE,UAAU,IAAI,GAAG,KAAK,WAAW,CAAC,GAAG,QAAQ,IAAI,WAAW,IAAI,KAAK,sBAAsB,QAAQ,SAAS,WAAW,EAAE,EAAE;AAAA,EACtI,CAAC;AACH;AAgBA,SAAS,mBAAmB,QAA+B;AACzD,aAAW,SAAS,OAAO,SAAS,OAAO,GAAG;AAC5C,QAAI;AAEJ,QAAI;AACF,gBAAU,KAAK,MAAM,OAAO,MAAM,MAAM,KAAK,CAAC;AAAA,IAChD,QAAQ;AACN;AAAA,IACF;AAEA,UAAM,UAAU,MAAM,QAAQ,OAAO,IAAI,UAA6B,OAAO,OAAO,OAAwC;AAC5H,UAAM,SAAS,QAAQ,CAAC;AAExB,QAAI,CAAC,QAAQ;AACX,YAAM,IAAI,MAAM,sDAAsD;AAAA,IACxE;AAEA,WAAO;AAAA,EACT;AAEA,QAAM,IAAI,MAAM,iEAAiE;AACnF;AAwBA,eAAe,iBAAiB,YAAoB,SAAkD;AACpG,QAAM;AAAA,IACJ;AAAA,IACA,sBAAsB;AAAA,EACxB,IAAI;AACJ,QAAM,cAAc,qBAAqB,mBAAmB,mBAAmB;AAC/E,QAAM,eAAe,cACjB,MAAM,iBAAiB,YAAY,iBAAiB,IACpD,MAAM,8BAA8B,YAAY,iBAAiB;AACrE,MAAI,mBAAmB;AACvB,MAAI,WAA+B,CAAC;AAMpC,aAAS;AACP,QAAI,aAAa;AACf,YAAM,oBAAoB,MAAM,gBAAgB,kBAAkB,QAAQ;AAC1E,UAAI,SAAS,SAAS,KAAK,sBAAsB,kBAAkB;AACjE,cAAM,yBAAyB,UAAU,UAAU;AAAA,MACrD;AAEA,yBAAmB;AAAA,IACrB;AAEA,eAAW,MAAM,4BAA4B,kBAAkB,UAAU;AACzE,QAAI,SAAS,WAAW,GAAG;AACzB;AAAA,IACF;AAEA,QAAI,CAAC,aAAa;AAChB,YAAM,yBAAyB,UAAU,UAAU;AAAA,IACrD;AAAA,EACF;AAMA,oCAAkC,kBAAkB,UAAU;AAC9D,QAAM,sCAAsC,kBAAkB,UAAU;AACxE,SAAO;AACT;AASA,eAAe,6BAAgD;AAC7D,QAAM,qBAAqB;AAC3B,QAAM,gBAAgB,wBAAwB,EAAE,MAAM,UAAU,YAAY,CAAC;AAC7E,MAAI,CAAC,WAAW,aAAa,GAAG;AAC9B,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,UAAU,MAAM,SAAS,eAAe,OAAO;AACrD,QAAM,yBAAyB,QAAQ,MAAM,IAAI,EAAE,MAAM,kBAAkB;AAC3E,MAAI,uBAAuB,GAAG,EAAE,MAAM,IAAI;AACxC,2BAAuB,IAAI;AAAA,EAC7B;AAEA,SAAO;AACT;AAeA,eAAe,uBAAuB,wBAAmD;AACvF,QAAM,UAAU,WAAW;AAAA,IACzB,SAAS,uBAAuB,CAAC,KAAK;AAAA,IACtC,UAAU;AAAA,IACV,aAAa;AAAA,EACf,CAAC;AAED,MAAI,CAAC,SAAS;AACZ,WAAO;AAAA,EACT;AAEA,QAAM,kBAAkB,MAAM,aAAa,CAAC,OAAO,aAAa,YAAY,WAAW,aAAa,OAAO,EAAE,GAAG;AAAA,IAC9G,SAAS;AAAA,IACT,sBAAsB;AAAA,EACxB,CAAC;AAED,MAAI,CAAC,iBAAiB;AACpB,mBAAe,SAAS;AAAA,MACtB,GAAG,UAAU,WAAW,kBAAkB,OAAO;AAAA,IACnD;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAWA,eAAe,gBAAgB,cAAsB,UAA+C;AAClG,QAAM,gBAAgB,MAAM,QAAQ,KAAK,OAAO,GAAG,YAAY,CAAC;AAChE,QAAM,uBAAuB,KAAK,eAAe,UAAU,WAAW;AAEtE,MAAI;AACF,UAAM,UAAU,sBAAsB,cAAc,OAAO;AAE3D,UAAM,cAAc,MAAM,aAAa,kBAAkB;AAAA,MACvD,SAAS;AAAA,MACT,sBAAsB;AAAA,IACxB,CAAC;AACD,UAAM,kBAAkB,eAAe,SAAS;AAChD,QAAI,SAAS,SAAS,GAAG;AACvB;AAAA,QACE,GAAG,UAAU,WAAW,kBAAkB,oBAAoB,QAAQ,CAAC;AAAA,EAAU,eAAe,QAAQ,CAAC;AAAA,MAC3G;AAAA,IACF;AAEA,QAAI,aAAa;AACf,sBAAgB,qBAAqB,UAAU,WAAW,sDAAsD;AAChH,YAAM,aAAa,CAAC,QAAQ,MAAM,oBAAoB,GAAG;AAAA,QACvD,SAAS;AAAA,QACT,sBAAsB;AAAA,MACxB,CAAC;AAAA,IACH,OAAO;AACL,sBAAgB,6EAA6E;AAC7F,YAAM,gBAAgB,QAAQ,OAAO,QAAQ,MAAM,EAAE;AAAA,QACnD,qBAAqB,oBAAoB;AAAA,MAC3C;AAAA,IACF;AAEA,WAAO,MAAM,SAAS,sBAAsB,OAAO;AAAA,EACrD,UAAE;AACA,UAAM,GAAG,eAAe;AAAA,MACtB,OAAO;AAAA,MACP,WAAW;AAAA,IACb,CAAC;AAAA,EACH;AACF;AAeA,SAAS,iBAAiB,WAAsB,SAAyC;AACvF,QAAM,eAAe,UAAU,eAC5B,IAAI,CAAC,kBAAkB,KAAK,cAAc,IAAI,MAAM,GAAG,gBAAgB,CAAC,KAAK,cAAc,OAAO,MAAM,cAAc,MAAM,GAAG,EAC/H,KAAK,IAAI;AAEZ,SAAO,IAAI;AAAA,IACT,qBAAqB,QAAQ,OAAO,qBAAqB,UAAU,KAAK,kBAAkB,QAAQ,iBAAiB,mBAC3G,QAAQ,UAAU,gBAAgB,QAAQ,UAAU;AAAA,EACrD,YAAY;AAAA,wKAGX,UAAU,KAAK;AAAA,EACzB;AACF;AAmBA,SAAS,iBAAiB,eAA+B;AACvD,QAAM,QAAQ,cAAc,MAAM,OAAO,EAAE,OAAO,OAAO;AACzD,QAAM,UAAU,MAAM,CAAC,KAAK;AAC5B,QAAM,YAAY,MAAM,MAAM,CAAC;AAC/B,QAAM,QAAQ,sBAAsB,KAAK,OAAO,IAAI,UAAU,KAAK,CAAC,SAAS,CAAC,wBAAwB,IAAI,CAAC,KAAK,UAAU;AAC1H,QAAM,aAAa,oBAAI,IAAY;AACnC,aAAW,aAAa,UAAU,QAAQ,CAAC,SAAS,wBAAwB,IAAI,KAAK,CAAC,CAAC,GAAG;AACxF,QAAI,UAAU,UAAU,MAAM,CAAC,aAAa,CAAC,IAAI,OAAO,OAAO,gBAAgB,aAAa,QAAQ,CAAC,QAAQ,EAAE,KAAK,KAAK,CAAC,GAAG;AAC3H,iBAAW,IAAI,UAAU,QAAQ;AAAA,IACnC;AAAA,EACF;AACA,SAAO,WAAW,SAAS,IAAI,QAAQ,GAAG,KAAK,KAAK,CAAC,GAAG,UAAU,EAAE,KAAK,IAAI,CAAC;AAChF;AAYA,SAAS,yBAAyB,UAA8B,SAAwB;AACtF,QAAM,cAAc,oBAAoB,QAAQ;AAChD,SAAO,IAAI;AAAA,IACT,OAAO,OAAO,eAAe,UAAU,WAAW,kBAAkB,WAAW;AAAA,EACxE,eAAe,QAAQ,CAAC;AAAA,ghBAMvB,WAAW;AAAA,EACrB;AACF;AAcA,SAAS,2BAA2B,kBAA0B,SAAyB;AACrF,QAAM,UAAU;AAAA;AAAA,KAAqB,OAAO;AAC5C,QAAM,UAAU,wBAAwB,kBAAkB,OAAO;AAGjE,SAAO,YAAY,KAAK,GAAG,OAAO;AAAA,IAAO,GAAG,OAAO;AAAA;AAAA,EAAO,OAAO;AAAA;AACnE;AAeA,SAAS,qBAAqB,aAAqB,YAAsC;AACvF,QAAM,OAAO,MAAM,WAAW;AAC9B,QAAM,OAAO,MAAM,UAAU;AAC7B,MAAI,CAAC,QAAQ,CAAC,MAAM;AAClB,WAAO;AAAA,EACT;AAEA,MAAI,KAAK,QAAQ,KAAK,OAAO;AAC3B,WAAO;AAAA,EACT;AAEA,SAAO,KAAK,QAAQ,KAAK,QAAQ,sBAA0B;AAC7D;AAWA,SAAS,oBAAoB,UAAsC;AACjE,QAAM,cAAc,CAAC,qBAAqB,sBAAsB,EAAE,OAAO,CAAC,eAAe,SAAS,KAAK,CAAC,YAAY,QAAQ,eAAe,UAAU,CAAC;AACtJ,SAAO,YAAY,KAAK,OAAO;AACjC;AAWA,SAAS,eAAe,UAAsC;AAC5D,SAAO,SAAS,IAAI,CAAC,YAAY,IAAI,QAAQ,UAAU,KAAK,QAAQ,IAAI,EAAE,EAAE,KAAK,IAAI;AACvF;AAUA,SAAS,gBAAgB,QAAsC;AAG7D,QAAM,CAAC,KAAK,aAAa,GAAG,SAAS,IAAI,OAAO,MAAM,IAAI;AAC1D,MAAI,CAAC,OAAO,gBAAgB,QAAW;AACrC,WAAO;AAAA,EACT;AAEA,QAAM,UAAU,YAAY,KAAK;AACjC,QAAM,OAAO,UAAU,KAAK,IAAI;AAChC,QAAM,eAAe,oCAAoC,KAAK,OAAO;AAErE,MAAI,cAAc,SAAS,UAAU,GAAG;AACtC,WAAO;AAAA,MACL,OAAO;AAAA,MACP,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,MAAI,+BAA+B,KAAK,IAAI,GAAG;AAC7C,WAAO;AAAA,MACL,OAAO;AAAA,MACP,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,SAAO,cAAc,SAAS,MAAM,GAAG,YAAY,MAAM,YACrD;AAAA,IACA,OAAO;AAAA,IACP,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,EACF,IACE;AACN;AASA,SAAS,mBAAmB,gBAAqD;AAC/E,MAAI,eAAe,KAAK,CAAC,kBAAkB,cAAc,UAAU,mBAAuB,GAAG;AAC3F,WAAO;AAAA,EACT;AAEA,SAAO,eAAe,SAAS,IAAI,sBAA0B;AAC/D;AASA,eAAe,eAAe,cAAqC;AACjE,QAAM,UAAU,wBAAwB,EAAE,MAAM,UAAU,YAAY,CAAC,GAAG,cAAc,OAAO;AACjG;","names":["VersionUpdateType"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/version.ts"],"sourcesContent":["/**\n * @file\n *\n * This module provides functions for managing version updates in a project.\n * It includes tasks such as validating version update types, checking the state\n * of Git and GitHub CLI, updating version numbers in files, and performing\n * Git operations such as tagging and pushing.\n */\n\nimport type { ParseArgsConfig } from 'node:util';\nimport type { ReleaseType } from 'semver';\n\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { errorToString } from '@mnaoumov/typescript-lib/error';\nimport { join } from '@mnaoumov/typescript-lib/path';\nimport {\n  escapeRegExp,\n  getOptionalNamedGroup\n} from '@mnaoumov/typescript-lib/reg-exp';\nimport { replaceAll } from '@mnaoumov/typescript-lib/string';\nimport { assertNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { existsSync } from 'node:fs';\nimport {\n  mkdtemp,\n  readFile,\n  rm,\n  writeFile\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { basename } from 'node:path';\nimport { createInterface } from 'node:readline/promises';\nimport { parseArgs } from 'node:util';\nimport {\n  inc,\n  parse,\n  prerelease\n} from 'semver';\n\nimport type { PackageLockJson } from './npm.ts';\n\nimport {\n  findForbiddenPatternMatches,\n  FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE,\n  readForbiddenPatterns\n} from './forbidden-patterns.ts';\nimport { gate } from './gate.ts';\nimport { spellcheckContent } from './linters/cspell-content.ts';\nimport {\n  fixMarkdownContent,\n  lintMarkdownContent\n} from './linters/markdownlint-content.ts';\nimport {\n  editNpmShrinkWrapJson,\n  editPackageJson,\n  editPackageLockJson,\n  readPackageJson\n} from './npm.ts';\nimport { closeReleasedIssues } from './released-issues.ts';\nimport { RepoPaths } from './repo-paths.ts';\nimport {\n  execFromRoot,\n  resolvePathFromRootSafe\n} from './root.ts';\n\n/**\n * Options for {@link addUpdatedFilesToGit}.\n */\nexport interface AddUpdatedFilesToGitOptions {\n  /**\n   * Whether to run the pre-commit hook when creating the release commit. When `false`, `--no-verify`\n   * is passed to the release commit to skip the hook.\n   *\n   * @default `true`\n   */\n  readonly shouldVerifyCommit?: boolean;\n}\n\n/**\n * The result of parsing the command-line arguments for a version update.\n */\nexport interface ParsedVersionArguments {\n  /**\n   * The {@link UpdateVersionOptions} parsed from the flags.\n   */\n  readonly options: UpdateVersionOptions;\n\n  /**\n   * The positional version update type argument, or `undefined` if none was provided.\n   */\n  readonly versionUpdateType: string | undefined;\n}\n\n/**\n * Options for {@link publishGitHubRelease}.\n */\nexport interface PublishGitHubReleaseOptions {\n  /**\n   * Returns the files to attach to the GitHub release, as paths relative to the project root. A path that does\n   * not exist is skipped.\n   *\n   * @default the `npm pack` tarball of the project, written into `dist/`, and `dist/styles.css`\n   */\n  readonly getReleaseAssetPaths?: (() => Promise<string[]>) | undefined;\n\n  /**\n   * Whether to close the issues the release carries once it is published: every issue a commit since the previous\n   * tag names with a closing keyword (`fixes #12`) is closed with a `Fixed in` / `Implemented in` comment linking\n   * the release. See {@link closeReleasedIssues}.\n   *\n   * @default `true`\n   */\n  readonly shouldCloseReleasedIssues?: boolean;\n\n  /**\n   * Whether to require every asset to exist, require an existing remote tag, and verify the published\n   * non-draft release and its uploaded assets before closing issues.\n   *\n   * @default `false`\n   */\n  readonly shouldVerifyRelease?: boolean;\n}\n\n/**\n * Options for {@link updateChangelog}.\n */\nexport interface UpdateChangelogOptions {\n  /**\n   * A path to a file whose contents become the body of the new version's changelog section, instead of\n   * the bullets derived from the commit messages. Use it to supply prepared release notes from a\n   * non-interactive caller (a background process, CI, an agent).\n   *\n   * Setting it implies no interactive review: the commit log is not read, and the changelog is never\n   * opened in the editor nor waited on at the console, regardless of {@link shouldEditChangelog}.\n   *\n   * @default the first-parent commit subjects since the previous version\n   */\n  readonly changelogFilePath?: string | undefined;\n\n  /**\n   * Whether to open the generated changelog in the editor for an interactive review. When `false`,\n   * the changelog is still generated from commit messages, but it is not opened in the editor for\n   * manual review.\n   *\n   * Ignored when {@link changelogFilePath} is set.\n   *\n   * @default `true`\n   */\n  readonly shouldEditChangelog?: boolean;\n}\n\n/**\n * Options for {@link updateVersion}.\n */\nexport interface UpdateVersionOptions {\n  /**\n   * A path to a file whose contents become the body of the new version's changelog section, instead of\n   * the bullets derived from the commit messages. Use it to supply prepared release notes from a\n   * non-interactive caller (a background process, CI, an agent).\n   *\n   * Setting it implies no interactive review: the commit log is not read, and the changelog is never\n   * opened in the editor nor waited on at the console, regardless of {@link shouldEditChangelog}.\n   *\n   * @default the first-parent commit subjects since the previous version\n   */\n  readonly changelogFilePath?: string | undefined;\n\n  /**\n   * Returns the files to attach to the GitHub release. See {@link PublishGitHubReleaseOptions.getReleaseAssetPaths}.\n   */\n  readonly getReleaseAssetPaths?: (() => Promise<string[]>) | undefined;\n\n  /**\n   * A callback function to prepare the GitHub release.\n   *\n   * @param newVersion - The new version number for the release.\n   * @returns A {@link Promise} that resolves when the GitHub release has been prepared.\n   */\n  readonly prepareGitHubRelease?: (newVersion: string) => Promise<void>;\n\n  /**\n   * Whether to run the build step. The build is a publishing prerequisite, not a verification check,\n   * so it is governed by this flag independently of {@link shouldRunChecks} — it runs even when the\n   * checks are skipped, so a fast release still ships fresh artifacts. Set to `false` only when the\n   * build output is known to already match the current code; otherwise the release would publish\n   * stale artifacts.\n   *\n   * @default `true`\n   */\n  readonly shouldBuild?: boolean;\n\n  /**\n   * Whether to close the issues the release carries once it is published. See\n   * {@link PublishGitHubReleaseOptions.shouldCloseReleasedIssues}.\n   *\n   * @default `true`\n   */\n  readonly shouldCloseReleasedIssues?: boolean;\n\n  /**\n   * Whether to open the generated changelog in the editor for an interactive review.\n   *\n   * Ignored when {@link changelogFilePath} is set. When it is neither set nor disabled, the release\n   * requires an interactive terminal, and {@link updateVersion} refuses up front without one rather\n   * than blocking on an editor nobody will close.\n   *\n   * @default `true`\n   */\n  readonly shouldEditChangelog?: boolean;\n\n  /**\n   * Whether to publish and verify the GitHub release before pushing the version commit to the branch.\n   * Preparation and asset validation happen before any push. Only the release tag is pushed first;\n   * a failed preparation, publication or verification leaves the remote branch unchanged.\n   * Uses the `origin` remote and pushes the verified commit to the original branch without force.\n   * Ignored when {@link shouldRelease} is `false`.\n   *\n   * @default `false`\n   */\n  readonly shouldPublishBeforePush?: boolean;\n\n  /**\n   * Whether to publish the release. When `false`, all local steps are executed (version bump,\n   * changelog, commit, tag), but the changes are not pushed and no GitHub release is published.\n   *\n   * @default `true`\n   */\n  readonly shouldRelease?: boolean;\n\n  /**\n   * Whether to run the preflight verification checks (clean-repo check, format, spellcheck, lint,\n   * over-exposure analysis, and tests). The build step is not one of these checks — it is governed\n   * separately by {@link shouldBuild}.\n   *\n   * @default `true`\n   */\n  readonly shouldRunChecks?: boolean;\n\n  /**\n   * Whether to run the pre-commit hook when creating the release commit. When `false`, `--no-verify`\n   * is passed to the release commit to skip the hook.\n   *\n   * @default `true`\n   */\n  readonly shouldVerifyCommit?: boolean;\n\n  /**\n   * Updates the version in any file beyond `package.json` and the lockfiles, once the new version is known and\n   * before the release commit is made. An Obsidian plugin's `manifest.json` and `versions.json` are the case this\n   * exists for.\n   *\n   * @param newVersion - The version being released.\n   * @returns A {@link Promise} that resolves when the files are updated.\n   */\n  readonly updateVersionInExtraFiles?: ((newVersion: string) => Promise<void>) | undefined;\n}\n\n/**\n * The lowest bump a range of commits may be published under, and the commits that force it.\n */\ninterface BumpFloor {\n  /**\n   * The commits whose Conventional-Commits markers force {@link level}, in the order `git log` reported them.\n   * Empty when nothing forces anything, which is the ordinary case for a range of `fix`es and `chore`s.\n   */\n  readonly forcingCommits: readonly ForcingCommit[];\n\n  /**\n   * The lowest {@link BumpLevel} the range may ship as.\n   */\n  readonly level: BumpLevel;\n}\n\n/**\n * What {@link toBumpFloorError} needs beyond the {@link BumpFloor} itself to say what was asked for and what\n * that would have shipped as.\n */\ninterface BumpFloorRefusalContext {\n  /**\n   * The previous release tag the range was measured from.\n   */\n  readonly lastTag: string;\n\n  /**\n   * The version the requested bump would have produced.\n   */\n  readonly newVersion: string;\n\n  /**\n   * The {@link BumpLevel} {@link newVersion} actually moves, relative to {@link lastTag}.\n   */\n  readonly takenLevel: BumpLevel;\n\n  /**\n   * The version update type the release was asked for, verbatim — which is a pre-release type or an explicit\n   * version as often as it is a plain `patch`, and is therefore worth quoting back rather than inferring.\n   */\n  readonly versionUpdateType: string;\n}\n\n/**\n * The three release lines a bump can move, ordered by {@link isBumpLevelAtLeast}.\n *\n * A pre-release type is not one of these: `premajor` moves the major line and `prerelease` moves whichever\n * line an earlier pre-release already chose, so what a pre-release did is read off the resulting version\n * rather than off its type. See {@link toEffectiveBumpLevel}.\n */\ntype BumpLevel = VersionUpdateType.Major | VersionUpdateType.Minor | VersionUpdateType.Patch;\n\n/**\n * One finding reported over the settled changelog section, tagged with the npm script whose check produced it.\n *\n * The tag is what lets one message name `lint:md`, `spellcheck` or both, truthfully. Both checks run over\n * every settle, so an author who has to fix a hard-wrapped line and a coined word fixes them in ONE round of\n * the review rather than being sent back twice.\n */\ninterface ChangelogFinding {\n  /**\n   * The npm script that would have reported this on the branch.\n   */\n  readonly scriptName: string;\n\n  /**\n   * The reported line, exactly as that script's own output would have carried it.\n   */\n  readonly text: string;\n}\n\n/**\n * One commit that forces a {@link BumpFloor}, rendered into the refusal so the author can go and look at it.\n */\ninterface ForcingCommit {\n  /**\n   * The {@link BumpLevel} this one commit forces on its own.\n   */\n  readonly level: BumpLevel;\n\n  /**\n   * What in the commit forced it — the `!` marker, the `BREAKING CHANGE:` footer, or the `feat` type — named\n   * so a reader can tell a deliberate breaking marker from a footer somebody wrote in passing.\n   */\n  readonly marker: string;\n\n  /**\n   * The full commit hash.\n   */\n  readonly sha: string;\n\n  /**\n   * The commit subject.\n   */\n  readonly subject: string;\n}\n\ninterface NpmPackResult {\n  readonly filename: string;\n}\n\n/**\n * A `BREAKING CHANGE:` footer, in both spellings Conventional Commits allows.\n *\n * Matched per line (`m`) rather than against the whole message, because a footer sits at the bottom of the\n * body. It is the half of the breaking-change signal that {@link MERGE_SUBJECT_REG_EXP}'s sibling rewrite\n * cannot carry: `toChangelogEntry` lifts only the merge body's first line onto the merge subject, so a footer\n * written on a branch commit never reaches the first-parent history at all. That is why\n * {@link getBumpFloor} reads every commit in the range rather than only the first-parent ones.\n */\nconst BREAKING_CHANGE_FOOTER_REG_EXP = /^BREAKING[ -]CHANGE:/m;\n\n/**\n * The marker names a {@link ForcingCommit} carries, and therefore what the refusal message says forced the\n * floor. They are spelled out rather than reduced to the level alone, because `feat!` and a `BREAKING CHANGE:`\n * footer buried in a body are very different things to be told about.\n */\nconst BREAKING_CHANGE_FOOTER_MARKER = 'a `BREAKING CHANGE:` footer';\n\n/**\n * See {@link BREAKING_CHANGE_FOOTER_MARKER}.\n */\nconst BREAKING_MARKER = 'the `!` breaking marker';\n\n/**\n * See {@link BREAKING_CHANGE_FOOTER_MARKER}.\n */\nconst FEAT_TYPE_MARKER = 'a `feat` type';\n\n/**\n * A Conventional-Commits subject: a type, an optional scope, an optional `!`, then the colon.\n *\n * Deliberately tolerant of a subject that is not one at all — an unparsable subject simply constrains\n * nothing, which is the same answer a `chore:` gives. This gate exists to catch a bump that is too LOW, so\n * failing to recognize a subject can only under-constrain, never refuse a release that should have shipped.\n */\nconst CONVENTIONAL_COMMIT_SUBJECT_REG_EXP = /^(?<type>[a-z]+)(?:\\([^()]*\\))?(?<breaking>!)?:\\s/i;\n\n/**\n * The default pre-release identifier used for pre-release versions.\n */\nconst DEFAULT_PREID = 'beta';\n\n/**\n * The Conventional-Commits type that forces a minor.\n */\nconst FEAT_TYPE = 'feat';\n\n/**\n * One issue reference inside an {@link ISSUE_REFERENCE_LINE_REG_EXP} line: an issue or pull request URL, an\n * `owner/repo#n`, or a bare `#n`.\n */\nconst ISSUE_REFERENCE_REG_EXP = /https:\\/\\/github\\.com\\/(?<urlSlug>[\\w.-]+\\/[\\w.-]+)\\/(?:issues|pull)\\/(?<urlNumber>\\d+)|(?<![\\w./-])(?<slug>[\\w.-]+\\/[\\w.-]+)#(?<slugNumber>\\d+)\\b|(?<![\\w/&#.-])#(?<bareNumber>\\d+)\\b/g;\n\n/**\n * A commit body line that names the issues the commit works on: `Refs owner/repo#12`, `Fixes #3`,\n * `Closes https://github.com/owner/repo/issues/4, #5`. The keyword is followed by references and nothing else\n * (see {@link parseIssueReferenceLine}), so a prose line that merely opens with `Fixes` names nothing.\n *\n * A fix made in one repository for an issue in another closes nothing here, and its commit subject cannot carry\n * the other repository's number, so this line is the only place the release can learn which issue it fixes.\n */\nconst ISSUE_REFERENCE_LINE_REG_EXP = /^(?:refs?|re|fix(?:e[sd])?|close[sd]?|resolve[sd]?|implements?):?\\s+(?<references>.+)$/i;\n\n/**\n * The npm scripts whose checks the settled changelog is held to, named in the messages so a reader knows which\n * gate they are looking at — and knows that fixing it here is the same fix as fixing it on the branch.\n */\nconst LINT_MD_SCRIPT_NAME = 'lint:md';\n\n/**\n * How much of a commit hash the bump-floor refusal prints. Long enough to paste into `git show`, short enough\n * that a list of them stays readable.\n */\nconst SHORT_SHA_LENGTH = 8;\n\n/**\n * See {@link LINT_MD_SCRIPT_NAME}.\n */\nconst SPELLCHECK_SCRIPT_NAME = 'spellcheck';\n\n/**\n * The shape of a merge subject git wrote itself, rather than one an author chose.\n *\n * Every default git produces opens with `Merge` and a word boundary — `Merge branch 'x'`,\n * `Merge branches 'x' and 'y'`, `Merge remote-tracking branch 'x'`, `Merge pull request #1 from y`,\n * `Merge tag 'x'`, `Merge commit 'abc'` — which is what the optional alternation and the trailing `\\b` cover\n * between them. Being that broad costs nothing here: every changelog entry in this workspace is a\n * Conventional-Commits subject, and those open with a type (`feat`, `fix`, `chore`, …), never with `Merge`.\n *\n * ONE pattern drives both halves of the guard, so they cannot drift apart: {@link toChangelogEntry} rewrites\n * a commit whose subject matches it, and {@link assertChangelogHasNoMergeSubjects} refuses a changelog line\n * that still does. The refusal is therefore reachable only for a merge the rewrite had nothing to work with.\n */\nconst MERGE_SUBJECT_REG_EXP = /^Merge(?: branch| remote-tracking| pull request)?\\b/;\n\n/**\n * Enum representing different types of version updates.\n *\n * Aligns with npm's `npm version` increment types plus `Manual` for explicit versions.\n */\nexport enum VersionUpdateType {\n  Invalid = 'invalid',\n  Major = 'major',\n  Manual = 'manual',\n  Minor = 'minor',\n  Patch = 'patch',\n  PreMajor = 'premajor',\n  PreMinor = 'preminor',\n  PrePatch = 'prepatch',\n  PreRelease = 'prerelease'\n}\n\n/**\n * The version update types a caller names directly, keyed by their name, as opposed to the two `getVersionUpdateType` derives.\n */\nconst NAMED_VERSION_UPDATE_TYPES = new Map<string, VersionUpdateType>([\n  VersionUpdateType.Major,\n  VersionUpdateType.Minor,\n  VersionUpdateType.Patch,\n  VersionUpdateType.PreMajor,\n  VersionUpdateType.PreMinor,\n  VersionUpdateType.PrePatch,\n  VersionUpdateType.PreRelease\n].map((type) => [type, type]));\n\n/**\n * Where `HEAD` stood when a release started: the branch it is on (empty for a detached `HEAD`) and its commit.\n */\nexport interface GitHeadState {\n  /**\n   * The checked-out branch, or an empty string for a detached `HEAD`.\n   */\n  readonly branch: string;\n\n  /**\n   * The commit `HEAD` points at.\n   */\n  readonly sha: string;\n}\n\n/**\n * Creates a Git tag for the new version.\n *\n * @param newVersion - The new version number to use for the tag.\n * @param commitSha - The commit to tag. When omitted, `HEAD` is tagged.\n * @returns A {@link Promise} that resolves when the tag has been created.\n */\nexport async function addGitTag(newVersion: string, commitSha?: string): Promise<void> {\n  await execFromRoot(`git tag -a ${newVersion} -m ${newVersion} --force${commitSha ? ` ${commitSha}` : ''}`, { isQuiet: true });\n}\n\n/**\n * Adds updated files to the Git staging area and commits them with the new version message.\n *\n * If the commit fails (for example, the pre-commit hook rejects a new word in the changelog) and the\n * process is attached to an interactive terminal, the user is prompted to fix the issue (for example,\n * add the missing word to `cspell.json`) and press Enter to retry. The retry re-stages all files, so the\n * fix is picked up without restarting the whole release lifecycle. In a non-interactive environment (no\n * TTY, such as CI), the error is re-thrown instead of prompting, so the script fails fast rather than\n * hanging. Pass `shouldVerifyCommit: false` to skip the pre-commit hook entirely in such cases.\n *\n * @param newVersion - The new version number used as the commit message.\n * @param options - The {@link AddUpdatedFilesToGitOptions} controlling the commit behavior.\n * @returns A {@link Promise} that resolves when the files have been added and committed.\n */\nexport async function addUpdatedFilesToGit(newVersion: string, options: AddUpdatedFilesToGitOptions = {}): Promise<void> {\n  const { shouldVerifyCommit = true } = options;\n  const versionDebugger = getLibDebugger('Version');\n\n  const commitArguments = ['git', 'commit', '-m', `chore: release ${newVersion}`, '--allow-empty', ...(shouldVerifyCommit ? [] : ['--no-verify'])];\n\n  for (;;) {\n    try {\n      await execFromRoot(['git', 'add', '--all'], { isQuiet: true });\n      await execFromRoot(commitArguments, { isQuiet: true });\n      return;\n    } catch (error) {\n      if (!process.stdin.isTTY) {\n        throw error;\n      }\n\n      versionDebugger(\n        `Failed to commit the release.\\n${errorToString(error)}\\n`\n          + 'Fix the issues (for example, add the missing word to cspell.json) and press Enter to retry the commit, or Ctrl+C to abort.'\n      );\n      await createInterface(process.stdin, process.stdout).question('Press Enter to retry the commit...');\n    }\n  }\n}\n\n/**\n * Checks if the GitHub CLI is installed on the system.\n *\n * Throws an error if the GitHub CLI is not installed.\n *\n * @throws Error if the GitHub CLI is not installed.\n */\nexport async function assertGitHubCliInstalled(): Promise<void> {\n  try {\n    await execFromRoot('gh --version', { isQuiet: true });\n  } catch {\n    throw new Error('GitHub CLI is not installed. Please install it from https://cli.github.com/');\n  }\n}\n\n/**\n * Checks if Git is installed on the system.\n *\n * Throws an error if Git is not installed.\n *\n * @throws Error if Git is not installed.\n */\nexport async function assertGitInstalled(): Promise<void> {\n  try {\n    await execFromRoot('git --version', { isQuiet: true });\n  } catch {\n    throw new Error('Git is not installed. Please install it from https://git-scm.com/');\n  }\n}\n\n/**\n * Checks if the Git repository is clean, meaning there are no uncommitted changes.\n *\n * Throws an error if the Git repository is not clean.\n *\n * @throws Error if the Git repository is not clean.\n */\nexport async function assertGitRepoClean(): Promise<void> {\n  try {\n    const stdout = await execFromRoot('git status --porcelain --untracked-files=all', { isQuiet: true });\n    if (stdout) {\n      throw new Error();\n    }\n  } catch {\n    throw new Error('Git repository is not clean. Please commit or stash your changes before releasing a new version.');\n  }\n}\n\n/**\n * Asserts that `HEAD` is the release commit: on the branch the release started on, a single commit on top of the\n * commit it started from, with the `chore: release <version>` subject.\n *\n * A successful `git commit` proves only that a commit was made somewhere. A checkout switched underneath a\n * release by another process takes the commit onto that other branch, and when it is switched back the tag and\n * the GitHub release go out on the commit before the bump, with the bump left staged in the working tree and nothing\n * reported. So the release checks where the commit landed before tagging, and again before pushing.\n *\n * @param newVersion - The version being released.\n * @param startHead - Where `HEAD` stood when the release started.\n * @param stage - The step about to run, for the error message (for example `tagging`).\n * @returns A {@link Promise} that resolves to the release commit's SHA.\n */\nexport async function assertReleaseCommitLanded(newVersion: string, startHead: GitHeadState, stage: string): Promise<string> {\n  const expectedSubject = `chore: release ${newVersion}`;\n  const branch = await execFromRoot(['git', 'branch', '--show-current'], { isQuiet: true });\n  const headLogFieldCount = 3;\n  const headLog = await execFromRoot(['git', 'log', '-1', '--format=%H%n%P%n%s'], { isQuiet: true });\n  const [sha = '', parents = '', subject = ''] = headLog.split('\\n', headLogFieldCount);\n\n  if (branch === startHead.branch && parents === startHead.sha && subject === expectedSubject) {\n    return sha;\n  }\n\n  throw new Error(\n    `Refusing to continue before ${stage}: the release commit for ${newVersion} is not where it should be. `\n      + `The release started on ${describeBranch(startHead.branch)} at ${startHead.sha} and expects a '${expectedSubject}' commit on top of it, `\n      + `but HEAD is ${sha} ('${subject}', parent ${parents || 'none'}) on ${describeBranch(branch)}. `\n      + 'Something else moved HEAD in this working tree while the release ran (a concurrent checkout, reset or commit). '\n      + 'Check `git reflog` to find the release commit, put it on the release branch, and tag and push it by hand.'\n  );\n}\n\n/**\n * Wraps any bare `http(s)://` URL in the given text in angle brackets (`<url>`) so that text emitted\n * into a Markdown document (such as a generated changelog bullet) passes markdownlint's\n * `MD034/no-bare-urls` rule while still rendering as a clickable autolink on GitHub.\n *\n * URLs that are already wrapped in angle brackets (`<url>`) or that form the target of a Markdown\n * link (`[text](url)`) are left untouched, so the function is safe to run repeatedly. Trailing\n * sentence punctuation (`.`, `,`, `;`, `:`, `!`, `?`) is kept outside the angle brackets so it does\n * not become part of the link.\n *\n * @param text - The text possibly containing bare URLs.\n * @returns The text with every bare URL wrapped in angle brackets.\n */\nexport function autolinkBareUrls(text: string): string {\n  return text.replaceAll(/(?<![<[(])https?:\\/\\/[^\\s<>)\\]]+/g, (url) => {\n    const trailingPunctuation = /[.,;:!?]+$/.exec(url)?.[0] ?? '';\n    const bareUrl = url.slice(0, url.length - trailingPunctuation.length);\n    return `<${bareUrl}>${trailingPunctuation}`;\n  });\n}\n\n/**\n * Generates a new version string based on the current version and the specified update type.\n *\n * Uses the `semver` package to compute the next version, supporting all npm increment types:\n * `major`, `minor`, `patch`, `premajor`, `preminor`, `prepatch`, and `prerelease`.\n * Pre-release versions use the `beta` identifier by default (e.g., `1.2.4-beta.0`).\n *\n * @param versionUpdateType - The type of version update or an explicit version string.\n * @returns A {@link Promise} that resolves to the new version string.\n * @throws Error if the current version is invalid or the increment fails.\n */\nexport async function getNewVersion(versionUpdateType: string): Promise<string> {\n  const versionType = getVersionUpdateType(versionUpdateType);\n  if (versionType === VersionUpdateType.Manual) {\n    return versionUpdateType;\n  }\n\n  const packageJson = await readPackageJson();\n  const currentVersion = packageJson.version ?? '';\n\n  const releaseType = versionType as ReleaseType;\n  const isPreReleaseType = releaseType.startsWith('pre');\n  const newVersion = isPreReleaseType\n    ? inc(currentVersion, releaseType, DEFAULT_PREID)\n    : inc(currentVersion, releaseType);\n  assertNonNullable(newVersion, `Failed to increment version from '${currentVersion}' with type '${versionType}'`);\n\n  return newVersion;\n}\n\n/**\n * Retrieves the release notes for a specific version from the changelog.\n *\n * @param newVersion - The new version number for which to get the release notes.\n * @returns A {@link Promise} that resolves to the release notes for the specified version.\n */\nexport async function getReleaseNotes(newVersion: string): Promise<string> {\n  const changelogPath = resolvePathFromRootSafe({ path: RepoPaths.ChangelogMd });\n  const content = await readFile(changelogPath, 'utf-8');\n  const section = extractChangelogSection(content, newVersion);\n  let releaseNotes = section ? `${section}\\n\\n` : '';\n\n  const tagOutput = await execFromRoot('git tag --sort=-creatordate', { isQuiet: true });\n  const tags = tagOutput.split(/\\r?\\n/);\n  const previousVersion = tags[1];\n\n  const repoUrl = await execFromRoot('gh repo view --json url -q .url', { isQuiet: true });\n\n  const changesUrl = previousVersion ? `${repoUrl}/compare/${previousVersion}...${newVersion}` : `${repoUrl}/commits/${newVersion}`;\n\n  releaseNotes += `**Full Changelog**: ${changesUrl}`;\n  return releaseNotes;\n}\n\n/**\n * Determines the type of version update based on the input string.\n *\n * @param versionUpdateType - The input string representing the version update type.\n * @returns The corresponding `VersionUpdateType`.\n */\nexport function getVersionUpdateType(versionUpdateType: string): VersionUpdateType {\n  const namedVersionUpdateType = NAMED_VERSION_UPDATE_TYPES.get(versionUpdateType);\n  if (namedVersionUpdateType) {\n    return namedVersionUpdateType;\n  }\n\n  return /^\\d+\\.\\d+\\.\\d+(?:-[\\w\\d.-]+)?$/.test(versionUpdateType) ? VersionUpdateType.Manual : VersionUpdateType.Invalid;\n}\n\n/**\n * Pushes commits and tags to the remote Git repository.\n *\n * @returns A {@link Promise} that resolves when the push operation is complete.\n */\nexport async function gitPush(): Promise<void> {\n  await execFromRoot('git push --follow-tags --force', { isQuiet: true });\n}\n\n/**\n * Reads where `HEAD` stands now.\n *\n * @returns A {@link Promise} that resolves to the current {@link GitHeadState}.\n */\nexport async function readGitHeadState(): Promise<GitHeadState> {\n  const branch = await execFromRoot(['git', 'branch', '--show-current'], { isQuiet: true });\n  const sha = await execFromRoot(['git', 'rev-parse', 'HEAD'], { isQuiet: true });\n  return { branch, sha };\n}\n\n/**\n * The flags {@link parseVersionArguments} recognizes, in the shape Node's `parseArgs` takes. Exported so a wrapper\n * that adds flags of its own can parse them all in one pass and still read these through\n * {@link toUpdateVersionOptions}.\n */\nexport const VERSION_ARGUMENT_OPTIONS = {\n  'changelog-file': { type: 'string' },\n  'no-build': { type: 'boolean' },\n  'no-changelog-editing': { type: 'boolean' },\n  'no-checks': { type: 'boolean' },\n  'no-commit-verification': { type: 'boolean' },\n  'no-issue-closing': { type: 'boolean' },\n  'no-release': { type: 'boolean' }\n} as const satisfies NonNullable<ParseArgsConfig['options']>;\n\n/**\n * The values `parseArgs` reports for {@link VERSION_ARGUMENT_OPTIONS}.\n */\nexport type VersionArgumentValues = ReturnType<typeof parseArgs<VersionArgumentParseConfig>>['values'];\n\n/**\n * An uploaded asset returned by GitHub CLI for publication verification.\n */\ninterface GitHubReleaseAssetMetadata {\n  /**\n   * The downloadable file name.\n   */\n  readonly name: string;\n  /**\n   * GitHub's upload state.\n   */\n  readonly state: string;\n}\n\n/**\n * The release fields returned by GitHub CLI for publication verification.\n */\ninterface GitHubReleaseMetadata {\n  /**\n   * Uploaded assets.\n   */\n  readonly assets: readonly GitHubReleaseAssetMetadata[];\n  /**\n   * Whether the release remains private as a draft.\n   */\n  readonly isDraft: boolean;\n  /**\n   * Whether GitHub marks it as a pre-release.\n   */\n  readonly isPrerelease: boolean;\n  /**\n   * The exact tag users will download.\n   */\n  readonly tagName: string;\n}\n\n/**\n * One issue reference a commit body names, as {@link parseIssueReferenceLine} reads it.\n */\ninterface IssueReference {\n  /**\n   * How the changelog line shows it: `#n` for a bare number, the issue URL in angle brackets otherwise.\n   */\n  readonly rendered: string;\n  /**\n   * Every way a line that already shows it may spell it: `#n`, or `owner/repo#n` and the issue URL.\n   */\n  readonly spellings: readonly string[];\n}\n\n/**\n * The `parseArgs` configuration {@link VersionArgumentValues} is derived from.\n */\ninterface VersionArgumentParseConfig {\n  /**\n   * The recognized flags.\n   */\n  readonly options: typeof VERSION_ARGUMENT_OPTIONS;\n}\n\n/**\n * Whether a version is a pre-release, such as `1.2.4-beta.0`.\n *\n * @param version - The version.\n * @returns Whether it carries a pre-release part.\n */\nexport function isPreRelease(version: string): boolean {\n  return prerelease(version) !== null;\n}\n/**\n * Parses the command-line arguments for a version update into a version update type and\n * {@link UpdateVersionOptions}.\n *\n * Each behavior is enabled by default; the corresponding `--no-*` flag turns it off. `--changelog-file` takes a\n * value instead and has no default. Recognized flags:\n * - `--changelog-file=<path>` — use this file's contents as the new version's changelog section instead of\n *   the commit-derived bullets, and skip the interactive review entirely.\n * - `--no-build` — skip the build step (only safe when the build output already matches the current code).\n * - `--no-changelog-editing` — generate the changelog without opening it for manual review.\n * - `--no-checks` — skip the clean-repo check, format, spellcheck, lint, over-exposure analysis, and tests (the build still runs).\n * - `--no-commit-verification` — pass `--no-verify` to the release commit, skipping the pre-commit hook.\n * - `--no-issue-closing` — do not close the issues the release carries once it is published.\n * - `--no-release` — run all local steps but skip the push and the GitHub release.\n *\n * @param $arguments - The command-line arguments to parse (typically `process.argv.slice(2)`).\n * @returns The {@link ParsedVersionArguments} containing the version update type and the options.\n */\nexport function parseVersionArguments($arguments: string[]): ParsedVersionArguments {\n  const { positionals, values } = parseArgs({\n    allowPositionals: true,\n    // eslint-disable-next-line unicorn/name-replacements -- `args` is the option name Node's `parseArgs` reads.\n    args: $arguments,\n    options: VERSION_ARGUMENT_OPTIONS\n  });\n\n  return {\n    options: toUpdateVersionOptions(values),\n    versionUpdateType: positionals[0]\n  };\n}\n\n/**\n * Publishes a GitHub release for the new version.\n *\n * Creates the release and attaches the files {@link PublishGitHubReleaseOptions.getReleaseAssetPaths} names.\n *\n * Once the release exists, the issues it carries are closed with a link to it (see {@link closeReleasedIssues}),\n * unless {@link PublishGitHubReleaseOptions.shouldCloseReleasedIssues} is `false`. A failure there is reported and\n * does not fail the release, which is already published.\n *\n * @param newVersion - The new version number for the release.\n * @param options - The {@link PublishGitHubReleaseOptions}.\n * @returns A {@link Promise} that resolves when the release has been published.\n */\nexport async function publishGitHubRelease(newVersion: string, options: PublishGitHubReleaseOptions = {}): Promise<void> {\n  const { getReleaseAssetPaths = getNpmPackReleaseAssetPaths, shouldCloseReleasedIssues = true, shouldVerifyRelease = false } = options;\n  const filePaths = await resolveReleaseAssetPaths(getReleaseAssetPaths, shouldVerifyRelease);\n\n  await execFromRoot([\n    'gh',\n    'release',\n    'create',\n    newVersion,\n    ...filePaths,\n    '--title',\n    `v${newVersion}`,\n    ...(shouldVerifyRelease ? ['--verify-tag'] : []),\n    ...(isPreRelease(newVersion) ? ['--prerelease'] : []),\n    '--notes-file',\n    '-'\n  ], {\n    isQuiet: true,\n    stdin: await getReleaseNotes(newVersion)\n  });\n\n  if (shouldVerifyRelease) {\n    await verifyGitHubRelease(newVersion, filePaths);\n  }\n\n  if (!shouldCloseReleasedIssues) {\n    return;\n  }\n\n  await closeReleasedIssuesSafely(newVersion, true);\n}\n\n/**\n * Maps the values `parseArgs` reports for {@link VERSION_ARGUMENT_OPTIONS} onto {@link UpdateVersionOptions}.\n *\n * @param values - The parsed values.\n * @returns The options.\n */\nexport function toUpdateVersionOptions(values: VersionArgumentValues): UpdateVersionOptions {\n  return {\n    changelogFilePath: values['changelog-file'],\n    shouldBuild: !(values['no-build'] ?? false),\n    shouldCloseReleasedIssues: !(values['no-issue-closing'] ?? false),\n    shouldEditChangelog: !(values['no-changelog-editing'] ?? false),\n    shouldRelease: !(values['no-release'] ?? false),\n    shouldRunChecks: !(values['no-checks'] ?? false),\n    shouldVerifyCommit: !(values['no-commit-verification'] ?? false)\n  };\n}\n/**\n * Updates the changelog file with new version information and commit messages.\n *\n * This function reads the current changelog, appends new entries for the latest version,\n * and prompts the user to review the changes.\n *\n * The review happens on a scratch copy in the OS temporary folder, and the repository's own\n * `CHANGELOG.md` is written only once the review is over — so interrupting the review leaves the\n * repository untouched.\n *\n * @param newVersion - The new version number to be added to the changelog.\n * @param options - The {@link UpdateChangelogOptions} controlling the changelog review behavior.\n * @returns A {@link Promise} that resolves when the changelog update is complete.\n */\nexport async function updateChangelog(newVersion: string, options: UpdateChangelogOptions = {}): Promise<void> {\n  await writeChangelog(await prepareChangelog(newVersion, options));\n}\n\n/**\n * Updates the version of the project based on the specified update type.\n *\n * This function performs a series of tasks to handle version updates:\n * 1. Validates the version update type.\n * 2. Checks if Git and GitHub CLI are installed.\n * 3. Verifies that the interactive changelog review, if one is due, can actually be answered.\n * 4. Verifies that the bump is not lower than the commits since the last tag force it to be.\n * 5. Verifies that the Git repository is clean.\n * 6. Runs spellcheck and linting.\n * 7. Builds the project.\n * 8. Settles the changelog — the only step that can block on a human, and deliberately the last one before\n *    anything is written, so an interrupt here leaves the working tree clean and the release re-runnable.\n *    The settled text is linted here too: `lint:md` ran in step 6, before a character of it existed.\n * 9. Updates version in files (and in whatever {@link UpdateVersionOptions.updateVersionInExtraFiles} adds), then\n *    writes the settled changelog.\n * 10. Adds updated files to Git, tags the commit, and pushes to the repository.\n * 11. Prepares and publishes a GitHub release.\n * 12. Closes the issues the release carries, with a link to it.\n *\n * With {@link UpdateVersionOptions.shouldPublishBeforePush}, preparation and asset validation precede\n * the tag push. Publication and verification then precede the branch push, and issue closing remains last.\n *\n * @param versionUpdateType - The type of version update to perform (major, minor, patch, premajor, preminor, prepatch, prerelease, or x.y.z[-suffix]).\n * @param options - The {@link UpdateVersionOptions} controlling the release behavior.\n * @returns A {@link Promise} that resolves when the version update is complete.\n */\nexport async function updateVersion(versionUpdateType?: string, options: UpdateVersionOptions = {}): Promise<void> {\n  const {\n    changelogFilePath,\n    getReleaseAssetPaths = getNpmPackReleaseAssetPaths,\n    prepareGitHubRelease,\n    shouldBuild = true,\n    shouldCloseReleasedIssues = true,\n    shouldEditChangelog = true,\n    shouldPublishBeforePush = false,\n    shouldRelease = true,\n    shouldRunChecks = true,\n    shouldVerifyCommit = true,\n    updateVersionInExtraFiles\n  } = options;\n\n  if (!versionUpdateType) {\n    const npmOldVersion = process.env['npm_old_version'];\n    const npmNewVersion = process.env['npm_new_version'];\n\n    if (npmOldVersion && npmNewVersion) {\n      await updateVersionInFiles(npmOldVersion);\n      await updateVersion(npmNewVersion, options);\n      return;\n    }\n\n    throw new Error('No version update type provided');\n  }\n\n  validate(versionUpdateType);\n  await assertGitInstalled();\n  await assertGitHubCliInstalled();\n  // Checked here, before the checks and the build, rather than at the changelog step itself: a non-interactive\n  // caller learns in seconds instead of paying for the whole preflight and only then blocking on an editor\n  // window nobody will ever close.\n  assertChangelogStepIsNonBlocking(changelogFilePath, shouldEditChangelog);\n  // Same placement, same reason. Deliberately NOT under `shouldRunChecks`: that flag buys a fast release by\n  // skipping the VERIFICATION of the code, and this is a correctness gate on the release itself — the bump\n  // a `--no-checks` release ships is as public, and as unfixable afterwards, as any other.\n  await assertVersionUpdateTypeMeetsBumpFloor(versionUpdateType);\n  // Same placement, same reason: a changelog section nobody will review is fully known before the gate, and a subject it\n  // fails on is already pushed, so learning that after the preflight only costs the preflight.\n  await assertNonInteractiveChangelogIsPublishable(versionUpdateType, changelogFilePath, shouldEditChangelog);\n\n  if (shouldRunChecks) {\n    await assertGitRepoClean();\n  }\n\n  // Read before the gate, so a checkout switched at any point of the release is caught after the commit.\n  const startHead = await readGitHeadState();\n\n  // The rest of the preflight IS `npm run gate`, not a copy of it: a check added to the gate is reachable\n  // from the branch and from the release by construction, instead of by two lists happening to agree.\n  // The clean-repo assertion above stays here, because the gate is run on a dirty tree on purpose.\n  // The build is a prerequisite for publishing, not a verification check, so it runs unless `shouldBuild` is `false` — this keeps the released artifacts in sync with the current code even on a fast release.\n  await gate({\n    shouldBuild,\n    shouldRunChecks,\n    shouldRunIntegrationTests: true\n  });\n\n  const newVersion = await getNewVersion(versionUpdateType);\n\n  // The changelog is settled BEFORE anything is written, because this is the only step that can block on a\n  // human. Interrupting it therefore leaves the working tree pristine and the whole release re-runnable,\n  // instead of stranding a bumped-but-uncommitted tree that `assertGitRepoClean` then refuses to re-release.\n  const newChangeLog = await prepareChangelog(newVersion, {\n    changelogFilePath,\n    shouldEditChangelog\n  });\n\n  await updateVersionInFiles(newVersion);\n  await updateVersionInExtraFiles?.(newVersion);\n\n  await writeChangelog(newChangeLog);\n  await addUpdatedFilesToGit(newVersion, { shouldVerifyCommit });\n  // The tag names the verified commit rather than whatever `HEAD` is by the time `git tag` runs.\n  const releaseCommitSha = await assertReleaseCommitLanded(newVersion, startHead, 'tagging');\n  await addGitTag(newVersion, releaseCommitSha);\n\n  if (!shouldRelease) {\n    getLibDebugger('Version')('Skipping git push and GitHub release (--no-release). The version bump, changelog, commit, and tag have been created locally.');\n    return;\n  }\n\n  if (shouldPublishBeforePush) {\n    await prepareGitHubRelease?.(newVersion);\n    const filePaths = await resolveReleaseAssetPaths(getReleaseAssetPaths, true);\n    await assertReleaseCommitLanded(newVersion, startHead, 'pushing');\n    const tagCommitSha = await execFromRoot(['git', 'rev-parse', `refs/tags/${newVersion}^{}`], { isQuiet: true });\n    if (tagCommitSha !== releaseCommitSha) {\n      throw new Error(`Refusing to push ${newVersion}: its tag no longer names the verified release commit.`);\n    }\n    await execFromRoot(['git', 'push', 'origin', `refs/tags/${newVersion}:refs/tags/${newVersion}`], { isQuiet: true });\n    await publishGitHubRelease(newVersion, {\n      getReleaseAssetPaths: () => Promise.resolve(filePaths),\n      shouldCloseReleasedIssues: false,\n      shouldVerifyRelease: true\n    });\n    await assertReleaseCommitLanded(newVersion, startHead, 'pushing');\n    await execFromRoot(['git', 'push', 'origin', `${releaseCommitSha}:refs/heads/${startHead.branch}`], { isQuiet: true });\n    await closeReleasedIssuesSafely(newVersion, shouldCloseReleasedIssues);\n    return;\n  }\n\n  await assertReleaseCommitLanded(newVersion, startHead, 'pushing');\n  await gitPush();\n  await prepareGitHubRelease?.(newVersion);\n  await publishGitHubRelease(newVersion, { getReleaseAssetPaths, shouldCloseReleasedIssues });\n}\n\n/**\n * Updates the version in `package.json` and, where they exist, `package-lock.json` and `npm-shrinkwrap.json`.\n *\n * @param newVersion - The new version string to update in the files.\n * @returns A {@link Promise} that resolves when the update is complete.\n */\nexport async function updateVersionInFiles(newVersion: string): Promise<void> {\n  await editPackageJson((packageJson) => {\n    packageJson.version = newVersion;\n  });\n\n  await editPackageLockJson(update, { shouldSkipIfMissing: true });\n  await editNpmShrinkWrapJson(update, { shouldSkipIfMissing: true });\n\n  function update(packageLockJson: PackageLockJson): void {\n    packageLockJson.version = newVersion;\n    const defaultPackage = packageLockJson.packages?.[''];\n    if (defaultPackage) {\n      defaultPackage.version = newVersion;\n    }\n  }\n}\n\n/**\n * Validates the version update type to ensure it is either a recognized type\n * or a valid manual version string.\n *\n * @param versionUpdateType - The version update type to validate.\n * @throws Error if the version update type is invalid.\n */\nexport function validate(versionUpdateType: string): void {\n  if (getVersionUpdateType(versionUpdateType) === VersionUpdateType.Invalid) {\n    throw new Error(\n      'Invalid version update type. Please use \\'major\\', \\'minor\\', \\'patch\\', \\'premajor\\', \\'preminor\\', \\'prepatch\\', \\'prerelease\\', or \\'x.y.z[-suffix]\\' format.'\n    );\n  }\n}\n\n/**\n * Refuses a changelog whose NEW section matches one of the maintainer's own unpublished forbidden patterns.\n *\n * Every commit subject since the last tag ships verbatim into the new section, so a subject that carries\n * vocabulary private to the maintainer — an internal tracker id, a private project short name — lands in a\n * checked-in, published file inside the release commit, where nothing ever looks at it again. The list of what\n * counts as private cannot live in this library or in the repository without publishing the very thing it\n * protects, so it comes from the file {@link FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE} names, and this is a no-op\n * wherever that is not configured.\n *\n * Like {@link assertChangelogHasNoMergeSubjects}, only the section being published is scanned, and the throw\n * comes before anything is written.\n *\n * @param changelogContent - The full composed `CHANGELOG.md` content.\n * @param version - The version whose section is about to be published.\n * @returns A {@link Promise} that resolves when the section is clean.\n */\nasync function assertChangelogHasNoForbiddenPatterns(changelogContent: string, version: string): Promise<void> {\n  const patterns = await readForbiddenPatterns();\n  const matches = findForbiddenPatternMatches(extractChangelogSection(changelogContent, version), patterns);\n\n  if (matches.length === 0) {\n    return;\n  }\n\n  throw new Error(\n    `The ${version} section of ${RepoPaths.ChangelogMd} matches a pattern from the file`\n      + ` ${FORBIDDEN_PATTERNS_FILE_ENV_VARIABLE} names:\\n`\n      + `${matches.map(({ line, match }) => `${line}    <- ${match}`).join('\\n')}\\n`\n      + 'Nothing has been written yet. Supply release notes that say the same thing without it, with'\n      + ' `--changelog-file <path>`, or remove it at the interactive review, and re-run the release.'\n  );\n}\n\n/**\n * Refuses a changelog whose NEW section still carries an entry that reads as a merge subject git wrote itself.\n *\n * The convention this enforces is that a non-ff merge takes the same Conventional-Commits subject as the branch\n * commit it lands. Nothing used to hold it: for a non-ff merge the first-parent commit is the merge commit, so a\n * default subject ships verbatim, publishing a bare branch name (`Merge branch 'fix-the-thing'`) as a changelog\n * entry — which says nothing about what changed, and on a branch named after a private tracker item decodes to\n * nothing at all for a reader. The interactive review was the de facto catch, and `--no-changelog-editing`, the\n * flag an unattended release actually uses, skips it; one sweep across this workspace found twelve such\n * published entries in a single repository.\n *\n * Only the section being published is scanned, so an entry already shipped under an older version cannot block\n * every future release. {@link toChangelogEntry} has already rewritten every merge that had a body to rewrite\n * from, so what reaches here is a merge whose author wrote nothing at all — which no rewrite can invent, and\n * which is therefore worth stopping the release for.\n *\n * @param changelogContent - The full composed `CHANGELOG.md` content.\n * @param version - The version whose section is about to be published.\n */\nfunction assertChangelogHasNoMergeSubjects(changelogContent: string, version: string): void {\n  const BULLET_REG_EXP = /^- /;\n  const offendingEntries = extractChangelogSection(changelogContent, version)\n    .split('\\n')\n    .filter((line) => MERGE_SUBJECT_REG_EXP.test(line.replace(BULLET_REG_EXP, '')));\n\n  if (offendingEntries.length === 0) {\n    return;\n  }\n\n  throw new Error(\n    `The ${version} section of ${RepoPaths.ChangelogMd} carries a merge subject git wrote itself:\\n`\n      + `${offendingEntries.join('\\n')}\\n`\n      + 'Such an entry publishes a branch name instead of saying what shipped. Give the merge commit the same'\n      + ' subject as the branch commit it lands (`git commit --amend` on the merge, then re-run the release), or'\n      + ' supply the release notes yourself with `--changelog-file <path>`.'\n  );\n}\n\n/**\n * Refuses a release that would have to stop at the interactive changelog review with nobody there to\n * finish it. Called from the preflight so the refusal costs seconds, not the whole check-and-build gate.\n *\n * @param changelogFilePath - The path to the prepared release notes, or `undefined` when there is none.\n * @param shouldEditChangelog - Whether the generated changelog is meant to be reviewed interactively.\n */\nfunction assertChangelogStepIsNonBlocking(changelogFilePath: string | undefined, shouldEditChangelog: boolean): void {\n  if (changelogFilePath !== undefined || !shouldEditChangelog || process.stdin.isTTY) {\n    return;\n  }\n\n  throw new Error(\n    'The interactive changelog review needs a terminal, and this process has none, so the release would block forever.'\n      + ' Pass `--changelog-file <path>` to supply prepared release notes, or `--no-changelog-editing` to accept the'\n      + ' changelog generated from the commit messages as is.'\n  );\n}\n\n/**\n * Runs the checks {@link prepareChangelog} runs on a changelog nobody will review, before the gate rather than\n * after it.\n *\n * Without an interactive review (`--no-changelog-editing`, or `--changelog-file`), the new section is fully decided\n * by what is already committed, so every check `prepareChangelog` would throw on can be answered in seconds. A\n * release once passed its whole 25-minute preflight and was then refused by `lint:md` over a pushed commit subject\n * it could have named at the start. With a review due, nothing is checked here, because the author can still fix\n * a finding in the editor.\n *\n * @param versionUpdateType - The requested version update type.\n * @param changelogFilePath - The prepared notes, when the release was given them.\n * @param shouldEditChangelog - Whether the interactive review was asked for.\n * @returns A {@link Promise} that resolves when the section would pass, and rejects naming what it fails on.\n */\nasync function assertNonInteractiveChangelogIsPublishable(\n  versionUpdateType: string,\n  changelogFilePath: string | undefined,\n  shouldEditChangelog: boolean\n): Promise<void> {\n  if (isChangelogReviewDue(changelogFilePath, shouldEditChangelog)) {\n    return;\n  }\n\n  const newVersion = await getNewVersion(versionUpdateType);\n  const changelog = await composeChangelogNobodyReviews(newVersion, changelogFilePath);\n  const findings = await getChangelogSectionFindings(changelog, newVersion);\n  if (findings.length > 0) {\n    throw toChangelogFindingsError(findings, newVersion);\n  }\n\n  assertChangelogHasNoMergeSubjects(changelog, newVersion);\n  await assertChangelogHasNoForbiddenPatterns(changelog, newVersion);\n}\n\n/**\n * Refuses a release whose bump is LOWER than the commits it is about to publish force it to be.\n *\n * The rule this enforces is old and was written down after `96.5.1` shipped six unreleased `feat:` commits as\n * a patch: choose the bump from the whole range since the last tag, never from the change you happen to be\n * working on. It did not hold — `105.1.0` of this library is a MINOR carrying `feat(vitest-config)!`, so every\n * consumer on a caret range took a breaking change with no version signal — and it could not hold, because it\n * asked a human to scan a range and then type a bump that nothing compared against what the scan would have\n * found. This is that comparison, at the one moment the rule is being broken.\n *\n * It refuses only a bump that is too LOW. A deliberately higher one — a major cut to signal a break late, a\n * minor for a range of pure `fix`es — passes untouched, and there is no flag to switch the gate off: an\n * opt-out is what gets reached for reflexively, and the legitimate escape (bump higher) already exists.\n *\n * Called from the preflight rather than at the bump itself, so a refusal costs seconds instead of the whole\n * check-and-build gate, and nothing has been written when it throws.\n *\n * @param versionUpdateType - The version update type the release was asked for.\n */\nasync function assertVersionUpdateTypeMeetsBumpFloor(versionUpdateType: string): Promise<void> {\n  const versionDebugger = getLibDebugger('Version');\n  const lastTag = await resolveLastReleasedTag(await readPreviousChangelogLines());\n\n  // No baseline, no range, no floor. This is a first release, or one whose previous tag was deleted — the\n  // changelog step falls back to the full history there, and deriving a floor from the full history of a repo\n  // about to cut `1.0.0` would refuse it over commits that predate the concept of a published surface.\n  if (!lastTag) {\n    versionDebugger('No previous release tag resolved, so the bump floor is not derived. The bump is taken as given.');\n    return;\n  }\n\n  const bumpFloor = await getBumpFloor(`${lastTag}..HEAD`);\n  const floorLevel = bumpFloor.level;\n  if (floorLevel === VersionUpdateType.Patch) {\n    return;\n  }\n\n  const newVersion = await getNewVersion(versionUpdateType);\n  const takenLevel = toEffectiveBumpLevel(lastTag, newVersion);\n\n  // An unparsable baseline or target is not this gate's business to fail a release over. It can only happen\n  // for a tag that is not a version at all, which every other step here would have its own trouble with.\n  if (!takenLevel) {\n    versionDebugger(`Could not compare '${newVersion}' against the previous tag '${lastTag}', so the bump floor is not enforced.`);\n    return;\n  }\n\n  if (isBumpLevelAtLeast(takenLevel, floorLevel)) {\n    return;\n  }\n\n  throw toBumpFloorError(bumpFloor, {\n    lastTag,\n    newVersion,\n    takenLevel,\n    versionUpdateType\n  });\n}\n\n/**\n * Reports issue-closing failures without failing an already published release.\n *\n * @param newVersion - The published version whose issues should close.\n * @param shouldClose - Whether to close the issues after successful delivery.\n */\nasync function closeReleasedIssuesSafely(newVersion: string, shouldClose: boolean): Promise<void> {\n  if (!shouldClose) {\n    return;\n  }\n  try {\n    await closeReleasedIssues({ newVersion });\n  } catch (error) {\n    console.warn(`The ${newVersion} release is published, but closing the issues it carries failed: ${errorToString(error)}`);\n  }\n}\n\n/**\n * Composes the new `CHANGELOG.md` content — the new section from the commits since the last tag, or from the\n * prepared notes, above the previous sections — without reviewing, checking or writing it.\n *\n * @param newVersion - The new version number the changelog section is written for.\n * @param changelogFilePath - The prepared notes, when the release was given them.\n * @returns A {@link Promise} that resolves to the composed content.\n */\nasync function composeChangelog(newVersion: string, changelogFilePath: string | undefined): Promise<string> {\n  const previousChangelogLines = await readPreviousChangelogLines();\n\n  let newChangeLog = `# CHANGELOG\\n\\n## ${newVersion}\\n\\n`;\n\n  if (changelogFilePath === undefined) {\n    const lastTag = await resolveLastReleasedTag(previousChangelogLines);\n    const commitRange = lastTag ? `${lastTag}..HEAD` : 'HEAD';\n    const commitMessagesString = await execFromRoot(`git log ${commitRange} --format=%B --first-parent -z`, { isQuiet: true });\n    const commitMessages = commitMessagesString.split('\\0').filter(Boolean).map((commitMessage) => toChangelogEntry(commitMessage));\n\n    for (const message of commitMessages) {\n      newChangeLog += `- ${autolinkBareUrls(message)}\\n`;\n    }\n  } else {\n    const preparedNotes = await readFile(changelogFilePath, 'utf-8');\n    newChangeLog += `${replaceAll({ $string: preparedNotes, replacer: '\\n', searchValue: '\\r\\n' }).trim()}\\n`;\n  }\n\n  if (previousChangelogLines.length > 0) {\n    newChangeLog += '\\n';\n    for (const line of previousChangelogLines) {\n      newChangeLog += `${line}\\n`;\n    }\n  }\n\n  return newChangeLog;\n}\n\n/**\n * Composes the new `CHANGELOG.md` content for a release nobody reviews, applying `lint:md:fix`'s fixes to a section\n * generated from commit subjects.\n *\n * A subject can fail `lint:md` without anyone having had the chance to fix it: a `--no-ff` merge is made with\n * `HUSKY=0`, so commitlint never sees it, and an issue-closing merge takes the issue title verbatim. An Obsidian\n * plugin's subject naming the plugin without backticks stopped a release that way three times, after the whole\n * preflight. Whatever the repository's configuration can fix is fixed here, and what it cannot is still refused by\n * the findings check that follows. Prepared notes are the author's reviewed text, so they are never rewritten, and\n * only the new section is touched, never a published one.\n *\n * @param newVersion - The new version number the changelog section is written for.\n * @param changelogFilePath - The prepared notes, when the release was given them.\n * @returns A {@link Promise} that resolves to the composed content.\n */\nasync function composeChangelogNobodyReviews(newVersion: string, changelogFilePath: string | undefined): Promise<string> {\n  const changelog = await composeChangelog(newVersion, changelogFilePath);\n  if (changelogFilePath !== undefined) {\n    return changelog;\n  }\n\n  const packageJson = await readPackageJson();\n  if (!Object.keys(packageJson.scripts ?? {}).includes(LINT_MD_SCRIPT_NAME)) {\n    return changelog;\n  }\n\n  const section = extractChangelogSection(changelog, newVersion);\n  const { content, fixCount } = await fixMarkdownContent({\n    content: toChangelogSectionDocument(changelog, newVersion),\n    filePath: resolvePathFromRootSafe({ path: RepoPaths.ChangelogMd })\n  });\n  if (fixCount === 0) {\n    return changelog;\n  }\n\n  console.warn(`Fixed ${String(fixCount)} markdownlint finding(s) in the generated ${newVersion} changelog section, so it differs from the commit subjects.`);\n  const heading = `## ${newVersion}\\n\\n`;\n  return changelog.replace(`${heading}${section}`, () => `${heading}${extractChangelogSection(content, newVersion)}`);\n}\n\nfunction describeBranch(branch: string): string {\n  return branch ? `branch '${branch}'` : 'a detached HEAD';\n}\n/**\n * Extracts the body of one version's `CHANGELOG.md` section — everything between its `## <version>` heading\n * and whichever comes first, the next `## ` heading or the end of the file.\n *\n * Ending at the end of the file is not an edge case but the normal shape of a FIRST release: sections are\n * prepended, so the newest one is bounded by the previous release only once a previous release exists. The\n * regex this replaced required a trailing `\\n\\n##`, so every `1.0.0` silently published empty release notes.\n * Terminating on `'## '` WITH its trailing space is what keeps an `###` sub-heading inside the section\n * instead of truncating it there.\n *\n * @param changelogContent - The full contents of `CHANGELOG.md`.\n * @param version - The version whose section to extract.\n * @returns The section body, trimmed, or an empty string when the changelog has no section for that version.\n */\nfunction extractChangelogSection(changelogContent: string, version: string): string {\n  const lines = changelogContent.split(/\\r?\\n/);\n  const headingIndex = lines.indexOf(`## ${version}`);\n  if (headingIndex === -1) {\n    return '';\n  }\n\n  const bodyStartIndex = headingIndex + 1;\n  const nextHeadingOffset = lines.slice(bodyStartIndex).findIndex((line) => line.startsWith('## '));\n  const bodyEndIndex = nextHeadingOffset === -1 ? lines.length : bodyStartIndex + nextHeadingOffset;\n  return lines.slice(bodyStartIndex, bodyEndIndex).join('\\n').trim();\n}\n\n/**\n * Derives the lowest bump a commit range may be published under, from the Conventional-Commits markers the\n * commits in it carry.\n *\n * A `!` before the subject's colon, or a `BREAKING CHANGE:` / `BREAKING-CHANGE:` footer, forces a major; a\n * `feat` type forces a minor; everything else — `fix`, `chore`, `docs`, `refactor`, an unparsable subject —\n * constrains nothing and yields a patch floor, which is no constraint at all.\n *\n * **Every commit in the range is read, deliberately NOT only the first-parent ones**, which is where this\n * differs from the changelog generated over the same range. The changelog is first-parent because it publishes\n * one line per landed change; a breaking change is breaking whichever parent it arrived on. Concretely,\n * {@link toChangelogEntry} lifts only the FIRST line of a merge body onto a default merge subject, so a\n * `BREAKING CHANGE:` footer written on a branch commit is invisible to the first-parent history — and a footer\n * is the one breaking signal Conventional Commits puts in the body rather than the subject. The cost of\n * reading everything is over-detection: a branch whose breaking commit was reworked into a non-breaking merge\n * still forces a major. That direction is safe — an over-bump costs a consumer nothing and the message names\n * the commit so the author can see exactly which one — and the other direction is the defect this exists for.\n *\n * @param commitRange - The git revision range to scan, e.g. `105.2.0..HEAD`.\n * @returns A {@link Promise} that resolves to the {@link BumpFloor} the range forces.\n */\nasync function getBumpFloor(commitRange: string): Promise<BumpFloor> {\n  // `%H%n%B` puts the hash on its own first line and the full message under it, and `-z` separates the\n  // commits with NUL — so nothing in a commit message can be mistaken for a record boundary.\n  const output = await execFromRoot(['git', 'log', commitRange, '--format=%H%n%B', '-z'], { isQuiet: true });\n\n  const forcingCommits = output\n    .split('\\0')\n    .map((record) => toForcingCommit(record))\n    .filter((forcingCommit) => forcingCommit !== null);\n\n  return {\n    forcingCommits,\n    level: toHighestBumpLevel(forcingCommits)\n  };\n}\n\n/**\n * Runs `lint:md`'s and `spellcheck`'s checks over the NEW section of a composed changelog, before any of it\n * reaches the repository.\n *\n * Only the new section is checked, and deliberately so. The honest check is the whole file, but it fails a\n * release on a defect in a section somebody shipped years ago — which is a release nobody can cut without\n * first fixing history, and is exactly how a changelog defect becomes a permanent blocker instead of a\n * two-minute fix. That is not hypothetical for the spelling half in particular: it is the state five\n * repositories in this workspace are in, each with a coined word already published in an old section. The new\n * section is the only part this release is responsible for.\n *\n * BOTH checks run over every settle, and neither short-circuits the other. An author who has a hard-wrapped\n * line and a coined word is told about both at once, in one round of the review, rather than fixing one and\n * being sent back for the other.\n *\n * Each half runs only where the project defines the script it stands for, just as {@link gate} runs that script\n * only where it is defined. A project with no `spellcheck` has no spelling configuration either, so `cspell` would\n * judge its release notes against the stock dictionaries alone and refuse the release over the plugin's own name:\n * a check the project never adopted, enforced only at release time.\n *\n * @param changelogContent - The full composed `CHANGELOG.md` content.\n * @param version - The version whose section is about to be published.\n * @returns A {@link Promise} that resolves to the findings, or an empty array when the section is clean.\n */\nasync function getChangelogSectionFindings(changelogContent: string, version: string): Promise<ChangelogFinding[]> {\n  const content = toChangelogSectionDocument(changelogContent, version);\n  const filePath = resolvePathFromRootSafe({ path: RepoPaths.ChangelogMd });\n  const packageJson = await readPackageJson();\n  const scriptNames = Object.keys(packageJson.scripts ?? {});\n\n  const markdownlintFindings = scriptNames.includes(LINT_MD_SCRIPT_NAME)\n    ? await lintMarkdownContent({\n      content,\n      filePath\n    })\n    : [];\n  const spellingFindings = scriptNames.includes(SPELLCHECK_SCRIPT_NAME)\n    ? await spellcheckContent({\n      content,\n      filePath\n    })\n    : [];\n\n  return [\n    ...markdownlintFindings.map((text) => ({\n      scriptName: LINT_MD_SCRIPT_NAME,\n      text\n    })),\n    ...spellingFindings.map((text) => ({\n      scriptName: SPELLCHECK_SCRIPT_NAME,\n      text\n    }))\n  ];\n}\n\n/**\n * The default release assets: the project's `npm pack` tarball, written into `dist/`, and `dist/styles.css`.\n *\n * @returns The asset paths, relative to the project root.\n */\nasync function getNpmPackReleaseAssetPaths(): Promise<string[]> {\n  const resultOutput = await execFromRoot(['npm', 'pack', '--pack-destination', RepoPaths.Dist, '--json'], { isQuiet: true });\n  const result = parseNpmPackOutput(resultOutput);\n  return [\n    join(RepoPaths.Dist, result.filename),\n    join(RepoPaths.Dist, RepoPaths.StylesCss)\n  ];\n}\n\n/**\n * Whether a bump reaches a floor.\n *\n * Spelled out rather than given numeric ranks, because three levels do not need an ordering scheme and a\n * `2 >= 3` in a release gate is one transposition away from silently passing everything. `floorLevel` excludes\n * {@link VersionUpdateType.Patch} for the same reason it is not tested for: a patch floor is no floor, and its\n * only caller has already returned by then — a branch that can only ever answer `true` is one nobody reads and\n * nothing covers.\n *\n * @param level - The {@link BumpLevel} actually taken.\n * @param floorLevel - The {@link BumpLevel} required.\n * @returns Whether `level` is at least `floorLevel`.\n */\nfunction isBumpLevelAtLeast(level: BumpLevel, floorLevel: VersionUpdateType.Major | VersionUpdateType.Minor): boolean {\n  return floorLevel === VersionUpdateType.Major\n    ? level === VersionUpdateType.Major\n    : level !== VersionUpdateType.Patch;\n}\n\n/**\n * Whether the release opens the interactive changelog review. Prepared notes are already the reviewed text, so\n * they never open an editor, whatever `shouldEditChangelog` says.\n *\n * @param changelogFilePath - The prepared notes, when the release was given them.\n * @param shouldEditChangelog - Whether the interactive review was asked for.\n * @returns Whether the review is due.\n */\nfunction isChangelogReviewDue(changelogFilePath: string | undefined, shouldEditChangelog: boolean): boolean {\n  return changelogFilePath === undefined && shouldEditChangelog;\n}\n\n/**\n * Reads the issue references off one {@link ISSUE_REFERENCE_LINE_REG_EXP} line.\n *\n * A cross-repository reference is rendered as its URL rather than as `owner/repo#n`: GitHub shows the URL as the\n * same short link, and the spellchecker the changelog section is held to skips a URL but not a repository name.\n *\n * @param line - One line of a commit body.\n * @returns The references, or `null` when the line is not a reference line or holds anything but references.\n */\nfunction parseIssueReferenceLine(line: string): IssueReference[] | null {\n  const referencesText = ISSUE_REFERENCE_LINE_REG_EXP.exec(line.trim())?.groups?.['references'];\n  if (referencesText?.replaceAll(ISSUE_REFERENCE_REG_EXP, '').replaceAll(/\\band\\b|[\\s,]/g, '') !== '') {\n    return null;\n  }\n\n  return Array.from(referencesText.matchAll(ISSUE_REFERENCE_REG_EXP), (match): IssueReference => {\n    const bareNumber = getOptionalNamedGroup(match, 'bareNumber');\n    if (bareNumber !== null) {\n      return { rendered: `#${bareNumber}`, spellings: [`#${bareNumber}`] };\n    }\n    const repoSlug = getOptionalNamedGroup(match, 'urlSlug') ?? getOptionalNamedGroup(match, 'slug');\n    const issueNumber = getOptionalNamedGroup(match, 'urlNumber') ?? getOptionalNamedGroup(match, 'slugNumber');\n    assertNonNullable(repoSlug);\n    assertNonNullable(issueNumber);\n    const url = `https://github.com/${repoSlug}/issues/${issueNumber}`;\n    return { rendered: `<${url}>`, spellings: [`${repoSlug}#${issueNumber}`, url, `https://github.com/${repoSlug}/pull/${issueNumber}`] };\n  });\n}\n\n/**\n * Extracts the single pack result from the output of `npm pack --json`.\n *\n * Two things make this more than a `JSON.parse()`. The payload is PRECEDED on stdout by whatever the\n * `prepare` script printed (the `npm notice` lines go to stderr, not here), so its start has to be found —\n * and it is found by parsing from each candidate start rather than by matching a literal, because the\n * prefix may itself contain a brace. And the payload's SHAPE depends on the npm major: npm 11 and earlier\n * emit an array of pack results, npm 12 emits an object keyed by package name. Both are accepted; scanning\n * for the array's literal opening is what broke every release on npm 12.\n *\n * @param output - The stdout of `npm pack --json`.\n * @returns The {@link NpmPackResult} describing the packed tarball.\n * @throws If the output holds no parsable JSON payload, or the payload holds no pack result.\n */\nfunction parseNpmPackOutput(output: string): NpmPackResult {\n  for (const match of output.matchAll(/[[{]/g)) {\n    let payload: unknown;\n\n    try {\n      payload = JSON.parse(output.slice(match.index));\n    } catch {\n      continue;\n    }\n\n    const results = Array.isArray(payload) ? payload as NpmPackResult[] : Object.values(payload as Record<string, NpmPackResult>);\n    const result = results[0];\n\n    if (!result) {\n      throw new Error('Found no pack result in the `npm pack --json` output');\n    }\n\n    return result;\n  }\n\n  throw new Error('Failed to find the JSON payload in the `npm pack --json` output');\n}\n\n/**\n * Composes the full new `CHANGELOG.md` content — including the interactive review, when one is due —\n * WITHOUT touching the repository. Nothing here writes into the repo, so an interrupt anywhere in the\n * review window (the whole point of the split) leaves the working tree exactly as it was.\n *\n * The settled content is handed to {@link assertChangelogHasNoMergeSubjects} before it is returned, which is\n * how that guard reaches every caller and every path — reviewed or not, commit-derived or prepared — from a\n * single site.\n *\n * It is also where the new section is LINTED and SPELLCHECKED, for the same reason and one the release's\n * ordering forces: the release's only `lint:md` and `spellcheck` run in the gate, which is over before this\n * text exists, so every character of a new changelog section used to enter the repository after the only\n * checks that could have looked at it. The generator's own bullets cannot fail them — they are one\n * `toFirstLine` per commit — but the two paths a human or an agent writes, the interactive review and\n * `--changelog-file`, are exactly the paths that carry prose. A defect there does not fail the release: it\n * lands on the default branch inside the `chore: release` commit, and turns the NEXT gate red, on a branch\n * belonging to somebody who did not write it.\n *\n * @param newVersion - The new version number the changelog section is written for.\n * @param options - The {@link UpdateChangelogOptions} controlling where the section body comes from.\n * @returns A {@link Promise} that resolves to the settled `CHANGELOG.md` content.\n */\nasync function prepareChangelog(newVersion: string, options: UpdateChangelogOptions): Promise<string> {\n  const {\n    changelogFilePath,\n    shouldEditChangelog = true\n  } = options;\n  const isReviewDue = isChangelogReviewDue(changelogFilePath, shouldEditChangelog);\n  const newChangeLog = isReviewDue\n    ? await composeChangelog(newVersion, changelogFilePath)\n    : await composeChangelogNobodyReviews(newVersion, changelogFilePath);\n  let settledChangeLog = newChangeLog;\n  let findings: ChangelogFinding[] = [];\n\n  // The checks run on the SETTLED text, so the review sits inside the loop rather than before it: the author is\n  // still sitting at the editor, so they are handed the findings and the same scratch copy back. A review that\n  // returns byte-identical text is the author declining to fix them, which ends the loop instead of reopening\n  // for ever. There is nobody to hand a finding to on the other paths, so those throw on the first one.\n  for (;;) {\n    if (isReviewDue) {\n      const reviewedChangeLog = await reviewChangelog(settledChangeLog, findings);\n      if (findings.length > 0 && reviewedChangeLog === settledChangeLog) {\n        throw toChangelogFindingsError(findings, newVersion);\n      }\n\n      settledChangeLog = reviewedChangeLog;\n    }\n\n    findings = await getChangelogSectionFindings(settledChangeLog, newVersion);\n    if (findings.length === 0) {\n      break;\n    }\n\n    if (!isReviewDue) {\n      throw toChangelogFindingsError(findings, newVersion);\n    }\n  }\n\n  // The last thing the composition does, and that placement is the whole point: this ONE site sees the\n  // commit-derived bullets, the prepared notes and whatever a review left behind, so the guard runs whether or not\n  // the interactive review does — and the review is precisely what `--no-changelog-editing` skips. Nothing has been\n  // written to the repository yet either, so the throw leaves the working tree pristine and the release re-runnable.\n  assertChangelogHasNoMergeSubjects(settledChangeLog, newVersion);\n  await assertChangelogHasNoForbiddenPatterns(settledChangeLog, newVersion);\n  return settledChangeLog;\n}\n\n/**\n * Reads `CHANGELOG.md` and returns everything below its `# CHANGELOG` header — so the first line is the\n * newest `## <version>` heading, which is what names the last released version.\n *\n * @returns A {@link Promise} that resolves to the lines, or an empty array when the repository has no changelog\n * yet.\n */\nasync function readPreviousChangelogLines(): Promise<string[]> {\n  const HEADER_LINES_COUNT = 2;\n  const changelogPath = resolvePathFromRootSafe({ path: RepoPaths.ChangelogMd });\n  if (!existsSync(changelogPath)) {\n    return [];\n  }\n\n  const content = await readFile(changelogPath, 'utf-8');\n  const previousChangelogLines = content.split('\\n').slice(HEADER_LINES_COUNT);\n  if (previousChangelogLines.at(-1) === '') {\n    previousChangelogLines.pop();\n  }\n\n  return previousChangelogLines;\n}\n\n/**\n * Resolves the tag of the last released version — the baseline both the changelog range and the bump floor are\n * measured from, derived once here so those two can never disagree about which commits are being published.\n *\n * A heading is not a tag. A hand-written `## 0.0.0` placeholder in a never-tagged repo, or a tag deleted after\n * the fact, would otherwise reach `git log` as a revision it cannot resolve — and it used to reach it at the\n * very END of the release, after the whole preflight had been paid for. Falling back to no baseline\n * over-includes when a tag was deleted, but that is safe and visible: the changelog review is exactly where an\n * over-included range gets trimmed, and the bump floor declines to derive anything at all without a baseline.\n *\n * @param previousChangelogLines - The lines {@link readPreviousChangelogLines} returned.\n * @returns A {@link Promise} that resolves to the tag name, or an empty string when there is none to resolve.\n */\nasync function resolveLastReleasedTag(previousChangelogLines: string[]): Promise<string> {\n  const lastTag = replaceAll({\n    $string: previousChangelogLines[0] ?? '',\n    replacer: '',\n    searchValue: '## '\n  });\n\n  if (!lastTag) {\n    return '';\n  }\n\n  const resolvedLastTag = await execFromRoot(['git', 'rev-parse', '--verify', '--quiet', `refs/tags/${lastTag}`], {\n    isQuiet: true,\n    shouldIgnoreExitCode: true\n  });\n\n  if (!resolvedLastTag) {\n    getLibDebugger('Version')(\n      `${RepoPaths.ChangelogMd} starts at '## ${lastTag}', but no such tag exists. Generating the changelog from the full history instead.`\n    );\n    return '';\n  }\n\n  return lastTag;\n}\n\n/**\n * Resolves assets once preparation has finished, refusing missing files in the guarded mode.\n *\n * @param getPaths - The callback naming the prepared assets.\n * @param shouldRequireAssets - Whether a missing requested asset fails the release.\n * @returns The existing paths to attach.\n */\nasync function resolveReleaseAssetPaths(getPaths: () => Promise<string[]>, shouldRequireAssets: boolean): Promise<string[]> {\n  const paths = await getPaths();\n  return paths.filter((path) => {\n    const isExists = existsSync(resolvePathFromRootSafe({ path }));\n    if (!isExists && shouldRequireAssets) {\n      throw new Error(`Release asset does not exist: ${path}`);\n    }\n    return isExists;\n  });\n}\n\n/**\n * Hands the composed changelog to the user for review on a scratch copy outside the repository, and\n * returns whatever they left behind. The scratch folder is removed even when the review fails.\n *\n * @param newChangeLog - The composed `CHANGELOG.md` content to hand over for review.\n * @param findings - The findings the previous round of this review left unfixed, printed above the prompt so\n * the author sees what has to change. Empty on the first round.\n * @returns A {@link Promise} that resolves to the reviewed content.\n */\nasync function reviewChangelog(newChangeLog: string, findings: ChangelogFinding[]): Promise<string> {\n  const scratchFolder = await mkdtemp(join(tmpdir(), 'changelog-'));\n  const scratchChangelogPath = join(scratchFolder, RepoPaths.ChangelogMd);\n\n  try {\n    await writeFile(scratchChangelogPath, newChangeLog, 'utf-8');\n\n    const codeVersion = await execFromRoot('code --version', {\n      isQuiet: true,\n      shouldIgnoreExitCode: true\n    });\n    const versionDebugger = getLibDebugger('Version');\n    if (findings.length > 0) {\n      versionDebugger(\n        `${RepoPaths.ChangelogMd} does not pass ${toFailedScriptNames(findings)} yet:\\n${toFindingLines(findings)}`\n      );\n    }\n\n    if (codeVersion) {\n      versionDebugger(`Please update the ${RepoPaths.ChangelogMd} file. Close Visual Studio Code when you are done...`);\n      await execFromRoot(['code', '-w', scratchChangelogPath], {\n        isQuiet: true,\n        shouldIgnoreExitCode: true\n      });\n    } else {\n      versionDebugger('Could not find Visual Studio Code in your PATH. Using console mode instead.');\n      await createInterface(process.stdin, process.stdout).question(\n        `Please update the ${scratchChangelogPath} file. Press Enter when you are done...`\n      );\n    }\n\n    return await readFile(scratchChangelogPath, 'utf-8');\n  } finally {\n    await rm(scratchFolder, {\n      force: true,\n      recursive: true\n    });\n  }\n}\n\n/**\n * Builds the error that refuses a bump lower than the range forces.\n *\n * It names every forcing commit with its short hash, its subject and WHICH marker forced it, because the\n * remedy depends on that: a `feat!` is a deliberate break somebody typed, while a `BREAKING CHANGE:` footer\n * sits in a body nobody re-reads and is exactly the thing this gate exists to surface. The instruction is to\n * take the higher bump, not to edit the commits — history that already reached the default branch is what a\n * release publishes, and rewriting it to dodge a version signal is the defect one level up.\n *\n * @param bumpFloor - The derived {@link BumpFloor}.\n * @param context - The {@link BumpFloorRefusalContext} describing what was asked for.\n * @returns The error to throw.\n */\nfunction toBumpFloorError(bumpFloor: BumpFloor, context: BumpFloorRefusalContext): Error {\n  const forcingLines = bumpFloor.forcingCommits\n    .map((forcingCommit) => `  ${forcingCommit.sha.slice(0, SHORT_SHA_LENGTH)}  ${forcingCommit.subject}  (${forcingCommit.marker})`)\n    .join('\\n');\n\n  return new Error(\n    `The commits since ${context.lastTag} force at least a ${bumpFloor.level} release, but '${context.versionUpdateType}' would publish`\n      + ` ${context.newVersion}, which is a ${context.takenLevel}.\\n`\n      + `${forcingLines}\\n`\n      + 'A release publishes every commit since the last tag, not the change you happen to be working on, so the'\n      + ' bump has to answer for all of them. Re-run the release with a'\n      + ` ${bumpFloor.level} bump — a higher one is always accepted, and nothing has been written yet.`\n  );\n}\n\n/**\n * Turns one full commit message (`git log --format=%B`) into the changelog line it should contribute.\n *\n * Normally that is the subject. The exception is a merge whose subject git wrote itself: for a non-ff merge\n * the first-parent commit IS the merge commit, so its subject is what ships, and a default one publishes a\n * private branch name as a changelog entry. The message the author actually wrote is usually still there —\n * one line below, as the merge body — so it is lifted out rather than discarded, which is exactly the edit a\n * human makes by hand at the review step. A merge with no body has nothing to lift and keeps its subject;\n * {@link assertChangelogHasNoMergeSubjects} is what stops that one from being published.\n *\n * The issues the body names on {@link ISSUE_REFERENCE_LINE_REG_EXP} lines are appended to the line, so the\n * release links them. Only the first-parent commit's body is read, so for a merge it is the merge message that\n * has to carry them. A reference the line already shows is not repeated.\n *\n * @param commitMessage - The full commit message.\n * @returns The changelog line for that commit.\n */\nfunction toChangelogEntry(commitMessage: string): string {\n  const lines = commitMessage.split(/\\r?\\n/).filter(Boolean);\n  const subject = lines[0] ?? '';\n  const bodyLines = lines.slice(1);\n  const entry = MERGE_SUBJECT_REG_EXP.test(subject) ? bodyLines.find((line) => !parseIssueReferenceLine(line)) ?? subject : subject;\n  const references = new Set<string>();\n  for (const reference of bodyLines.flatMap((line) => parseIssueReferenceLine(line) ?? [])) {\n    if (reference.spellings.every((spelling) => !new RegExp(String.raw`(?<![\\w/])${escapeRegExp(spelling)}(?!\\d)`).test(entry))) {\n      references.add(reference.rendered);\n    }\n  }\n  return references.size === 0 ? entry : `${entry} (${[...references].join(', ')})`;\n}\n\n/**\n * Builds the error that stops a release whose new changelog section does not pass `lint:md` or `spellcheck`.\n *\n * It is thrown from the composition step, which is BEFORE anything is written, so the recovery it describes is\n * the whole recovery: there is nothing to revert, and the release re-runs from the top.\n *\n * @param findings - The findings, as {@link getChangelogSectionFindings} collected them.\n * @param version - The version whose section was being published.\n * @returns The error to throw.\n */\nfunction toChangelogFindingsError(findings: ChangelogFinding[], version: string): Error {\n  const scriptNames = toFailedScriptNames(findings);\n  return new Error(\n    `The ${version} section of ${RepoPaths.ChangelogMd} does not pass ${scriptNames}:\\n`\n      + `${toFindingLines(findings)}\\n`\n      + 'The changelog is settled before it is written, so this stops the release with the repository untouched'\n      + ' and nothing to revert. The line numbers are the ones the written file would have had. Fix the release'\n      + ' notes — in the prepared notes file, or in the commit messages they were generated from — or, for a word'\n      + ' this project really does use, add it to the project\\'s `cspell` configuration, and re-run the release.'\n      + ' Releasing anyway would land the defect on the default branch inside the release commit, where the next'\n      + ` ${scriptNames} on anyone's branch reports it.`\n  );\n}\n\n/**\n * Wraps one version's changelog section in the minimal document the checks are handed.\n *\n * The section goes inside a document rather than on its own, so the heading and list rules see the\n * context they need (a document whose first line is a list item is a different document). The line numbers a\n * finding reports are then the composed `CHANGELOG.md`'s own, which is not a coincidence and is worth keeping:\n * a section is PREPENDED, so this document is character-for-character the head of the file about to be written.\n *\n * @param changelogContent - The full composed `CHANGELOG.md` content.\n * @param version - The version whose section is about to be published.\n * @returns The minimal document to check.\n */\nfunction toChangelogSectionDocument(changelogContent: string, version: string): string {\n  const heading = `# CHANGELOG\\n\\n## ${version}`;\n  const section = extractChangelogSection(changelogContent, version);\n  // An empty section is a real shape — a release with no commits to describe, or prepared notes that are an\n  // empty file — and appending a blank body to the heading would report a defect this release did not commit.\n  return section === '' ? `${heading}\\n` : `${heading}\\n\\n${section}\\n`;\n}\n\n/**\n * Reads off which release line a version actually moves, relative to the baseline it is being cut from.\n *\n * This is measured rather than read off the requested type on purpose, because the type does not always say.\n * `prerelease` advances whichever line an earlier `premajor` or `preminor` already chose, and an explicit\n * `x.y.z` says nothing at all until it is compared. Taking the coordinates of the resulting version answers all\n * of them with one rule — and it answers them the way a consumer's caret range sees it, which is the only\n * reading that matters for a published surface.\n *\n * @param baseVersion - The previous released version.\n * @param newVersion - The version about to be published.\n * @returns The {@link BumpLevel}, or `null` when either version is not parsable as semver.\n */\nfunction toEffectiveBumpLevel(baseVersion: string, newVersion: string): BumpLevel | null {\n  const base = parse(baseVersion);\n  const next = parse(newVersion);\n  if (!base || !next) {\n    return null;\n  }\n\n  if (next.major > base.major) {\n    return VersionUpdateType.Major;\n  }\n\n  return next.minor > base.minor ? VersionUpdateType.Minor : VersionUpdateType.Patch;\n}\n\n/**\n * Names the npm scripts that actually reported something, in the order they ran.\n *\n * Naming both unconditionally would be the easy version and would be a lie half the time: a release stopped by\n * a coined word would tell its author to go and look at `lint:md`, which passed.\n *\n * @param findings - The findings to name the scripts of.\n * @returns The script names, joined for prose — `lint:md`, `spellcheck`, or `lint:md and spellcheck`.\n */\nfunction toFailedScriptNames(findings: ChangelogFinding[]): string {\n  const scriptNames = [LINT_MD_SCRIPT_NAME, SPELLCHECK_SCRIPT_NAME].filter((scriptName) => findings.some((finding) => finding.scriptName === scriptName));\n  return scriptNames.join(' and ');\n}\n\n/**\n * Renders the findings for a message, each line tagged with the script that reported it.\n *\n * The tag is not decoration: the two tools' output shapes are similar enough to be mistaken for each other,\n * and the fix for one is not the fix for the other.\n *\n * @param findings - The findings to render.\n * @returns The rendered lines, one finding per line.\n */\nfunction toFindingLines(findings: ChangelogFinding[]): string {\n  return findings.map((finding) => `[${finding.scriptName}] ${finding.text}`).join('\\n');\n}\n\n/**\n * Classifies one `git log --format=%H%n%B -z` record into the {@link ForcingCommit} it is, or `null` when it\n * forces nothing.\n *\n * @param record - One NUL-delimited record: the full hash on the first line, the full commit message below it.\n * @returns The {@link ForcingCommit}, or `null` for a record that constrains nothing or is not a record at all\n * (the trailing empty string `-z` output ends with, among others).\n */\nfunction toForcingCommit(record: string): ForcingCommit | null {\n  // The trailing empty record `-z` leaves has no hash, and a record with no line under the hash is not one\n  // this can classify. Both are the same non-answer.\n  const [sha, subjectLine, ...bodyLines] = record.split('\\n');\n  if (!sha || subjectLine === undefined) {\n    return null;\n  }\n\n  const subject = subjectLine.trim();\n  const body = bodyLines.join('\\n');\n  const subjectMatch = CONVENTIONAL_COMMIT_SUBJECT_REG_EXP.exec(subject);\n\n  if (subjectMatch?.groups?.['breaking']) {\n    return {\n      level: VersionUpdateType.Major,\n      marker: BREAKING_MARKER,\n      sha,\n      subject\n    };\n  }\n\n  if (BREAKING_CHANGE_FOOTER_REG_EXP.test(body)) {\n    return {\n      level: VersionUpdateType.Major,\n      marker: BREAKING_CHANGE_FOOTER_MARKER,\n      sha,\n      subject\n    };\n  }\n\n  return subjectMatch?.groups?.['type']?.toLowerCase() === FEAT_TYPE\n    ? {\n      level: VersionUpdateType.Minor,\n      marker: FEAT_TYPE_MARKER,\n      sha,\n      subject\n    }\n    : null;\n}\n\n/**\n * Reduces the commits that force something to the one floor the range as a whole has to clear.\n *\n * @param forcingCommits - The {@link ForcingCommit}s found in the range.\n * @returns The highest {@link BumpLevel} any of them forces, or {@link VersionUpdateType.Patch} — no\n * constraint — when there are none.\n */\nfunction toHighestBumpLevel(forcingCommits: readonly ForcingCommit[]): BumpLevel {\n  if (forcingCommits.some((forcingCommit) => forcingCommit.level === VersionUpdateType.Major)) {\n    return VersionUpdateType.Major;\n  }\n\n  return forcingCommits.length > 0 ? VersionUpdateType.Minor : VersionUpdateType.Patch;\n}\n\n/**\n * Verifies public release metadata and completed uploads before exposing its version on the branch.\n *\n * @param newVersion - The exact version tag expected on the release.\n * @param filePaths - The files whose uploads must be complete.\n */\nasync function verifyGitHubRelease(newVersion: string, filePaths: readonly string[]): Promise<void> {\n  const release = JSON.parse(\n    await execFromRoot([\n      'gh',\n      'release',\n      'view',\n      newVersion,\n      '--json',\n      'isDraft,isPrerelease,tagName,assets'\n    ], { isQuiet: true })\n  ) as GitHubReleaseMetadata;\n  if (\n    release.isDraft || release.tagName !== newVersion || release.isPrerelease !== isPreRelease(newVersion)\n    || filePaths.some((path) => release.assets.every((asset) => !(asset.name === basename(path) && asset.state === 'uploaded')))\n  ) {\n    throw new Error(`Could not verify the public ${newVersion} release and its uploaded assets; the remote branch was not advanced.`);\n  }\n}\n\n/**\n * Writes the composed changelog into the repository. Deliberately the last thing the changelog step does,\n * so nothing lands on disk until the content is settled.\n *\n * @param newChangeLog - The settled `CHANGELOG.md` content to write.\n * @returns A {@link Promise} that resolves once the changelog has been written.\n */\nasync function writeChangelog(newChangeLog: string): Promise<void> {\n  await writeFile(resolvePathFromRootSafe({ path: RepoPaths.ChangelogMd }), newChangeLog, 'utf-8');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,SAAS,sBAAsB;AAC/B,SAAS,qBAAqB;AAC9B,SAAS,YAAY;AACrB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,kBAAkB;AAC3B,SAAS,yBAAyB;AAClC,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,cAAc;AACvB,SAAS,gBAAgB;AACzB,SAAS,uBAAuB;AAChC,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAIP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,YAAY;AACrB,SAAS,yBAAyB;AAClC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,2BAA2B;AACpC,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAgTP,MAAM,iCAAiC;AAOvC,MAAM,gCAAgC;AAKtC,MAAM,kBAAkB;AAKxB,MAAM,mBAAmB;AASzB,MAAM,sCAAsC;AAK5C,MAAM,gBAAgB;AAKtB,MAAM,YAAY;AAMlB,MAAM,0BAA0B;AAUhC,MAAM,+BAA+B;AAMrC,MAAM,sBAAsB;AAM5B,MAAM,mBAAmB;AAKzB,MAAM,yBAAyB;AAe/B,MAAM,wBAAwB;AAOvB,IAAK,oBAAL,kBAAKA,uBAAL;AACL,EAAAA,mBAAA,aAAU;AACV,EAAAA,mBAAA,WAAQ;AACR,EAAAA,mBAAA,YAAS;AACT,EAAAA,mBAAA,WAAQ;AACR,EAAAA,mBAAA,WAAQ;AACR,EAAAA,mBAAA,cAAW;AACX,EAAAA,mBAAA,cAAW;AACX,EAAAA,mBAAA,cAAW;AACX,EAAAA,mBAAA,gBAAa;AATH,SAAAA;AAAA,GAAA;AAeZ,MAAM,6BAA6B,IAAI,IAA+B;AAAA,EACpE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC,CAAC;AAwB7B,eAAsB,UAAU,YAAoB,WAAmC;AACrF,QAAM,aAAa,cAAc,UAAU,OAAO,UAAU,WAAW,YAAY,IAAI,SAAS,KAAK,EAAE,IAAI,EAAE,SAAS,KAAK,CAAC;AAC9H;AAgBA,eAAsB,qBAAqB,YAAoB,UAAuC,CAAC,GAAkB;AACvH,QAAM,EAAE,qBAAqB,KAAK,IAAI;AACtC,QAAM,kBAAkB,eAAe,SAAS;AAEhD,QAAM,kBAAkB,CAAC,OAAO,UAAU,MAAM,kBAAkB,UAAU,IAAI,iBAAiB,GAAI,qBAAqB,CAAC,IAAI,CAAC,aAAa,CAAE;AAE/I,aAAS;AACP,QAAI;AACF,YAAM,aAAa,CAAC,OAAO,OAAO,OAAO,GAAG,EAAE,SAAS,KAAK,CAAC;AAC7D,YAAM,aAAa,iBAAiB,EAAE,SAAS,KAAK,CAAC;AACrD;AAAA,IACF,SAAS,OAAO;AACd,UAAI,CAAC,QAAQ,MAAM,OAAO;AACxB,cAAM;AAAA,MACR;AAEA;AAAA,QACE;AAAA,EAAkC,cAAc,KAAK,CAAC;AAAA;AAAA,MAExD;AACA,YAAM,gBAAgB,QAAQ,OAAO,QAAQ,MAAM,EAAE,SAAS,oCAAoC;AAAA,IACpG;AAAA,EACF;AACF;AASA,eAAsB,2BAA0C;AAC9D,MAAI;AACF,UAAM,aAAa,gBAAgB,EAAE,SAAS,KAAK,CAAC;AAAA,EACtD,QAAQ;AACN,UAAM,IAAI,MAAM,6EAA6E;AAAA,EAC/F;AACF;AASA,eAAsB,qBAAoC;AACxD,MAAI;AACF,UAAM,aAAa,iBAAiB,EAAE,SAAS,KAAK,CAAC;AAAA,EACvD,QAAQ;AACN,UAAM,IAAI,MAAM,mEAAmE;AAAA,EACrF;AACF;AASA,eAAsB,qBAAoC;AACxD,MAAI;AACF,UAAM,SAAS,MAAM,aAAa,gDAAgD,EAAE,SAAS,KAAK,CAAC;AACnG,QAAI,QAAQ;AACV,YAAM,IAAI,MAAM;AAAA,IAClB;AAAA,EACF,QAAQ;AACN,UAAM,IAAI,MAAM,kGAAkG;AAAA,EACpH;AACF;AAgBA,eAAsB,0BAA0B,YAAoB,WAAyB,OAAgC;AAC3H,QAAM,kBAAkB,kBAAkB,UAAU;AACpD,QAAM,SAAS,MAAM,aAAa,CAAC,OAAO,UAAU,gBAAgB,GAAG,EAAE,SAAS,KAAK,CAAC;AACxF,QAAM,oBAAoB;AAC1B,QAAM,UAAU,MAAM,aAAa,CAAC,OAAO,OAAO,MAAM,qBAAqB,GAAG,EAAE,SAAS,KAAK,CAAC;AACjG,QAAM,CAAC,MAAM,IAAI,UAAU,IAAI,UAAU,EAAE,IAAI,QAAQ,MAAM,MAAM,iBAAiB;AAEpF,MAAI,WAAW,UAAU,UAAU,YAAY,UAAU,OAAO,YAAY,iBAAiB;AAC3F,WAAO;AAAA,EACT;AAEA,QAAM,IAAI;AAAA,IACR,+BAA+B,KAAK,4BAA4B,UAAU,sDAC5C,eAAe,UAAU,MAAM,CAAC,OAAO,UAAU,GAAG,mBAAmB,eAAe,sCACjG,GAAG,MAAM,OAAO,aAAa,WAAW,MAAM,QAAQ,eAAe,MAAM,CAAC;AAAA,EAGjG;AACF;AAeO,SAAS,iBAAiB,MAAsB;AACrD,SAAO,KAAK,WAAW,qCAAqC,CAAC,QAAQ;AACnE,UAAM,sBAAsB,aAAa,KAAK,GAAG,IAAI,CAAC,KAAK;AAC3D,UAAM,UAAU,IAAI,MAAM,GAAG,IAAI,SAAS,oBAAoB,MAAM;AACpE,WAAO,IAAI,OAAO,IAAI,mBAAmB;AAAA,EAC3C,CAAC;AACH;AAaA,eAAsB,cAAc,mBAA4C;AAC9E,QAAM,cAAc,qBAAqB,iBAAiB;AAC1D,MAAI,gBAAgB,uBAA0B;AAC5C,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,MAAM,gBAAgB;AAC1C,QAAM,iBAAiB,YAAY,WAAW;AAE9C,QAAM,cAAc;AACpB,QAAM,mBAAmB,YAAY,WAAW,KAAK;AACrD,QAAM,aAAa,mBACf,IAAI,gBAAgB,aAAa,aAAa,IAC9C,IAAI,gBAAgB,WAAW;AACnC,oBAAkB,YAAY,qCAAqC,cAAc,gBAAgB,WAAW,GAAG;AAE/G,SAAO;AACT;AAQA,eAAsB,gBAAgB,YAAqC;AACzE,QAAM,gBAAgB,wBAAwB,EAAE,MAAM,UAAU,YAAY,CAAC;AAC7E,QAAM,UAAU,MAAM,SAAS,eAAe,OAAO;AACrD,QAAM,UAAU,wBAAwB,SAAS,UAAU;AAC3D,MAAI,eAAe,UAAU,GAAG,OAAO;AAAA;AAAA,IAAS;AAEhD,QAAM,YAAY,MAAM,aAAa,+BAA+B,EAAE,SAAS,KAAK,CAAC;AACrF,QAAM,OAAO,UAAU,MAAM,OAAO;AACpC,QAAM,kBAAkB,KAAK,CAAC;AAE9B,QAAM,UAAU,MAAM,aAAa,mCAAmC,EAAE,SAAS,KAAK,CAAC;AAEvF,QAAM,aAAa,kBAAkB,GAAG,OAAO,YAAY,eAAe,MAAM,UAAU,KAAK,GAAG,OAAO,YAAY,UAAU;AAE/H,kBAAgB,uBAAuB,UAAU;AACjD,SAAO;AACT;AAQO,SAAS,qBAAqB,mBAA8C;AACjF,QAAM,yBAAyB,2BAA2B,IAAI,iBAAiB;AAC/E,MAAI,wBAAwB;AAC1B,WAAO;AAAA,EACT;AAEA,SAAO,iCAAiC,KAAK,iBAAiB,IAAI,wBAA2B;AAC/F;AAOA,eAAsB,UAAyB;AAC7C,QAAM,aAAa,kCAAkC,EAAE,SAAS,KAAK,CAAC;AACxE;AAOA,eAAsB,mBAA0C;AAC9D,QAAM,SAAS,MAAM,aAAa,CAAC,OAAO,UAAU,gBAAgB,GAAG,EAAE,SAAS,KAAK,CAAC;AACxF,QAAM,MAAM,MAAM,aAAa,CAAC,OAAO,aAAa,MAAM,GAAG,EAAE,SAAS,KAAK,CAAC;AAC9E,SAAO,EAAE,QAAQ,IAAI;AACvB;AAOO,MAAM,2BAA2B;AAAA,EACtC,kBAAkB,EAAE,MAAM,SAAS;AAAA,EACnC,YAAY,EAAE,MAAM,UAAU;AAAA,EAC9B,wBAAwB,EAAE,MAAM,UAAU;AAAA,EAC1C,aAAa,EAAE,MAAM,UAAU;AAAA,EAC/B,0BAA0B,EAAE,MAAM,UAAU;AAAA,EAC5C,oBAAoB,EAAE,MAAM,UAAU;AAAA,EACtC,cAAc,EAAE,MAAM,UAAU;AAClC;AAyEO,SAAS,aAAa,SAA0B;AACrD,SAAO,WAAW,OAAO,MAAM;AACjC;AAmBO,SAAS,sBAAsB,YAA8C;AAClF,QAAM,EAAE,aAAa,OAAO,IAAI,UAAU;AAAA,IACxC,kBAAkB;AAAA;AAAA,IAElB,MAAM;AAAA,IACN,SAAS;AAAA,EACX,CAAC;AAED,SAAO;AAAA,IACL,SAAS,uBAAuB,MAAM;AAAA,IACtC,mBAAmB,YAAY,CAAC;AAAA,EAClC;AACF;AAeA,eAAsB,qBAAqB,YAAoB,UAAuC,CAAC,GAAkB;AACvH,QAAM,EAAE,uBAAuB,6BAA6B,4BAA4B,MAAM,sBAAsB,MAAM,IAAI;AAC9H,QAAM,YAAY,MAAM,yBAAyB,sBAAsB,mBAAmB;AAE1F,QAAM,aAAa;AAAA,IACjB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAG;AAAA,IACH;AAAA,IACA,IAAI,UAAU;AAAA,IACd,GAAI,sBAAsB,CAAC,cAAc,IAAI,CAAC;AAAA,IAC9C,GAAI,aAAa,UAAU,IAAI,CAAC,cAAc,IAAI,CAAC;AAAA,IACnD;AAAA,IACA;AAAA,EACF,GAAG;AAAA,IACD,SAAS;AAAA,IACT,OAAO,MAAM,gBAAgB,UAAU;AAAA,EACzC,CAAC;AAED,MAAI,qBAAqB;AACvB,UAAM,oBAAoB,YAAY,SAAS;AAAA,EACjD;AAEA,MAAI,CAAC,2BAA2B;AAC9B;AAAA,EACF;AAEA,QAAM,0BAA0B,YAAY,IAAI;AAClD;AAQO,SAAS,uBAAuB,QAAqD;AAC1F,SAAO;AAAA,IACL,mBAAmB,OAAO,gBAAgB;AAAA,IAC1C,aAAa,EAAE,OAAO,UAAU,KAAK;AAAA,IACrC,2BAA2B,EAAE,OAAO,kBAAkB,KAAK;AAAA,IAC3D,qBAAqB,EAAE,OAAO,sBAAsB,KAAK;AAAA,IACzD,eAAe,EAAE,OAAO,YAAY,KAAK;AAAA,IACzC,iBAAiB,EAAE,OAAO,WAAW,KAAK;AAAA,IAC1C,oBAAoB,EAAE,OAAO,wBAAwB,KAAK;AAAA,EAC5D;AACF;AAeA,eAAsB,gBAAgB,YAAoB,UAAkC,CAAC,GAAkB;AAC7G,QAAM,eAAe,MAAM,iBAAiB,YAAY,OAAO,CAAC;AAClE;AA6BA,eAAsB,cAAc,mBAA4B,UAAgC,CAAC,GAAkB;AACjH,QAAM;AAAA,IACJ;AAAA,IACA,uBAAuB;AAAA,IACvB;AAAA,IACA,cAAc;AAAA,IACd,4BAA4B;AAAA,IAC5B,sBAAsB;AAAA,IACtB,0BAA0B;AAAA,IAC1B,gBAAgB;AAAA,IAChB,kBAAkB;AAAA,IAClB,qBAAqB;AAAA,IACrB;AAAA,EACF,IAAI;AAEJ,MAAI,CAAC,mBAAmB;AACtB,UAAM,gBAAgB,QAAQ,IAAI,iBAAiB;AACnD,UAAM,gBAAgB,QAAQ,IAAI,iBAAiB;AAEnD,QAAI,iBAAiB,eAAe;AAClC,YAAM,qBAAqB,aAAa;AACxC,YAAM,cAAc,eAAe,OAAO;AAC1C;AAAA,IACF;AAEA,UAAM,IAAI,MAAM,iCAAiC;AAAA,EACnD;AAEA,WAAS,iBAAiB;AAC1B,QAAM,mBAAmB;AACzB,QAAM,yBAAyB;AAI/B,mCAAiC,mBAAmB,mBAAmB;AAIvE,QAAM,sCAAsC,iBAAiB;AAG7D,QAAM,2CAA2C,mBAAmB,mBAAmB,mBAAmB;AAE1G,MAAI,iBAAiB;AACnB,UAAM,mBAAmB;AAAA,EAC3B;AAGA,QAAM,YAAY,MAAM,iBAAiB;AAMzC,QAAM,KAAK;AAAA,IACT;AAAA,IACA;AAAA,IACA,2BAA2B;AAAA,EAC7B,CAAC;AAED,QAAM,aAAa,MAAM,cAAc,iBAAiB;AAKxD,QAAM,eAAe,MAAM,iBAAiB,YAAY;AAAA,IACtD;AAAA,IACA;AAAA,EACF,CAAC;AAED,QAAM,qBAAqB,UAAU;AACrC,QAAM,4BAA4B,UAAU;AAE5C,QAAM,eAAe,YAAY;AACjC,QAAM,qBAAqB,YAAY,EAAE,mBAAmB,CAAC;AAE7D,QAAM,mBAAmB,MAAM,0BAA0B,YAAY,WAAW,SAAS;AACzF,QAAM,UAAU,YAAY,gBAAgB;AAE5C,MAAI,CAAC,eAAe;AAClB,mBAAe,SAAS,EAAE,8HAA8H;AACxJ;AAAA,EACF;AAEA,MAAI,yBAAyB;AAC3B,UAAM,uBAAuB,UAAU;AACvC,UAAM,YAAY,MAAM,yBAAyB,sBAAsB,IAAI;AAC3E,UAAM,0BAA0B,YAAY,WAAW,SAAS;AAChE,UAAM,eAAe,MAAM,aAAa,CAAC,OAAO,aAAa,aAAa,UAAU,KAAK,GAAG,EAAE,SAAS,KAAK,CAAC;AAC7G,QAAI,iBAAiB,kBAAkB;AACrC,YAAM,IAAI,MAAM,oBAAoB,UAAU,wDAAwD;AAAA,IACxG;AACA,UAAM,aAAa,CAAC,OAAO,QAAQ,UAAU,aAAa,UAAU,cAAc,UAAU,EAAE,GAAG,EAAE,SAAS,KAAK,CAAC;AAClH,UAAM,qBAAqB,YAAY;AAAA,MACrC,sBAAsB,MAAM,QAAQ,QAAQ,SAAS;AAAA,MACrD,2BAA2B;AAAA,MAC3B,qBAAqB;AAAA,IACvB,CAAC;AACD,UAAM,0BAA0B,YAAY,WAAW,SAAS;AAChE,UAAM,aAAa,CAAC,OAAO,QAAQ,UAAU,GAAG,gBAAgB,eAAe,UAAU,MAAM,EAAE,GAAG,EAAE,SAAS,KAAK,CAAC;AACrH,UAAM,0BAA0B,YAAY,yBAAyB;AACrE;AAAA,EACF;AAEA,QAAM,0BAA0B,YAAY,WAAW,SAAS;AAChE,QAAM,QAAQ;AACd,QAAM,uBAAuB,UAAU;AACvC,QAAM,qBAAqB,YAAY,EAAE,sBAAsB,0BAA0B,CAAC;AAC5F;AAQA,eAAsB,qBAAqB,YAAmC;AAC5E,QAAM,gBAAgB,CAAC,gBAAgB;AACrC,gBAAY,UAAU;AAAA,EACxB,CAAC;AAED,QAAM,oBAAoB,QAAQ,EAAE,qBAAqB,KAAK,CAAC;AAC/D,QAAM,sBAAsB,QAAQ,EAAE,qBAAqB,KAAK,CAAC;AAEjE,WAAS,OAAO,iBAAwC;AACtD,oBAAgB,UAAU;AAC1B,UAAM,iBAAiB,gBAAgB,WAAW,EAAE;AACpD,QAAI,gBAAgB;AAClB,qBAAe,UAAU;AAAA,IAC3B;AAAA,EACF;AACF;AASO,SAAS,SAAS,mBAAiC;AACxD,MAAI,qBAAqB,iBAAiB,MAAM,yBAA2B;AACzE,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACF;AAmBA,eAAe,sCAAsC,kBAA0B,SAAgC;AAC7G,QAAM,WAAW,MAAM,sBAAsB;AAC7C,QAAM,UAAU,4BAA4B,wBAAwB,kBAAkB,OAAO,GAAG,QAAQ;AAExG,MAAI,QAAQ,WAAW,GAAG;AACxB;AAAA,EACF;AAEA,QAAM,IAAI;AAAA,IACR,OAAO,OAAO,eAAe,UAAU,WAAW,oCAC1C,oCAAoC;AAAA,EACrC,QAAQ,IAAI,CAAC,EAAE,MAAM,MAAM,MAAM,GAAG,IAAI,UAAU,KAAK,EAAE,EAAE,KAAK,IAAI,CAAC;AAAA;AAAA,EAG9E;AACF;AAqBA,SAAS,kCAAkC,kBAA0B,SAAuB;AAC1F,QAAM,iBAAiB;AACvB,QAAM,mBAAmB,wBAAwB,kBAAkB,OAAO,EACvE,MAAM,IAAI,EACV,OAAO,CAAC,SAAS,sBAAsB,KAAK,KAAK,QAAQ,gBAAgB,EAAE,CAAC,CAAC;AAEhF,MAAI,iBAAiB,WAAW,GAAG;AACjC;AAAA,EACF;AAEA,QAAM,IAAI;AAAA,IACR,OAAO,OAAO,eAAe,UAAU,WAAW;AAAA,EAC3C,iBAAiB,KAAK,IAAI,CAAC;AAAA;AAAA,EAIpC;AACF;AASA,SAAS,iCAAiC,mBAAuC,qBAAoC;AACnH,MAAI,sBAAsB,UAAa,CAAC,uBAAuB,QAAQ,MAAM,OAAO;AAClF;AAAA,EACF;AAEA,QAAM,IAAI;AAAA,IACR;AAAA,EAGF;AACF;AAiBA,eAAe,2CACb,mBACA,mBACA,qBACe;AACf,MAAI,qBAAqB,mBAAmB,mBAAmB,GAAG;AAChE;AAAA,EACF;AAEA,QAAM,aAAa,MAAM,cAAc,iBAAiB;AACxD,QAAM,YAAY,MAAM,8BAA8B,YAAY,iBAAiB;AACnF,QAAM,WAAW,MAAM,4BAA4B,WAAW,UAAU;AACxE,MAAI,SAAS,SAAS,GAAG;AACvB,UAAM,yBAAyB,UAAU,UAAU;AAAA,EACrD;AAEA,oCAAkC,WAAW,UAAU;AACvD,QAAM,sCAAsC,WAAW,UAAU;AACnE;AAqBA,eAAe,sCAAsC,mBAA0C;AAC7F,QAAM,kBAAkB,eAAe,SAAS;AAChD,QAAM,UAAU,MAAM,uBAAuB,MAAM,2BAA2B,CAAC;AAK/E,MAAI,CAAC,SAAS;AACZ,oBAAgB,iGAAiG;AACjH;AAAA,EACF;AAEA,QAAM,YAAY,MAAM,aAAa,GAAG,OAAO,QAAQ;AACvD,QAAM,aAAa,UAAU;AAC7B,MAAI,eAAe,qBAAyB;AAC1C;AAAA,EACF;AAEA,QAAM,aAAa,MAAM,cAAc,iBAAiB;AACxD,QAAM,aAAa,qBAAqB,SAAS,UAAU;AAI3D,MAAI,CAAC,YAAY;AACf,oBAAgB,sBAAsB,UAAU,+BAA+B,OAAO,uCAAuC;AAC7H;AAAA,EACF;AAEA,MAAI,mBAAmB,YAAY,UAAU,GAAG;AAC9C;AAAA,EACF;AAEA,QAAM,iBAAiB,WAAW;AAAA,IAChC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACH;AAQA,eAAe,0BAA0B,YAAoB,aAAqC;AAChG,MAAI,CAAC,aAAa;AAChB;AAAA,EACF;AACA,MAAI;AACF,UAAM,oBAAoB,EAAE,WAAW,CAAC;AAAA,EAC1C,SAAS,OAAO;AACd,YAAQ,KAAK,OAAO,UAAU,oEAAoE,cAAc,KAAK,CAAC,EAAE;AAAA,EAC1H;AACF;AAUA,eAAe,iBAAiB,YAAoB,mBAAwD;AAC1G,QAAM,yBAAyB,MAAM,2BAA2B;AAEhE,MAAI,eAAe;AAAA;AAAA,KAAqB,UAAU;AAAA;AAAA;AAElD,MAAI,sBAAsB,QAAW;AACnC,UAAM,UAAU,MAAM,uBAAuB,sBAAsB;AACnE,UAAM,cAAc,UAAU,GAAG,OAAO,WAAW;AACnD,UAAM,uBAAuB,MAAM,aAAa,WAAW,WAAW,kCAAkC,EAAE,SAAS,KAAK,CAAC;AACzH,UAAM,iBAAiB,qBAAqB,MAAM,IAAI,EAAE,OAAO,OAAO,EAAE,IAAI,CAAC,kBAAkB,iBAAiB,aAAa,CAAC;AAE9H,eAAW,WAAW,gBAAgB;AACpC,sBAAgB,KAAK,iBAAiB,OAAO,CAAC;AAAA;AAAA,IAChD;AAAA,EACF,OAAO;AACL,UAAM,gBAAgB,MAAM,SAAS,mBAAmB,OAAO;AAC/D,oBAAgB,GAAG,WAAW,EAAE,SAAS,eAAe,UAAU,MAAM,aAAa,OAAO,CAAC,EAAE,KAAK,CAAC;AAAA;AAAA,EACvG;AAEA,MAAI,uBAAuB,SAAS,GAAG;AACrC,oBAAgB;AAChB,eAAW,QAAQ,wBAAwB;AACzC,sBAAgB,GAAG,IAAI;AAAA;AAAA,IACzB;AAAA,EACF;AAEA,SAAO;AACT;AAiBA,eAAe,8BAA8B,YAAoB,mBAAwD;AACvH,QAAM,YAAY,MAAM,iBAAiB,YAAY,iBAAiB;AACtE,MAAI,sBAAsB,QAAW;AACnC,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,MAAM,gBAAgB;AAC1C,MAAI,CAAC,OAAO,KAAK,YAAY,WAAW,CAAC,CAAC,EAAE,SAAS,mBAAmB,GAAG;AACzE,WAAO;AAAA,EACT;AAEA,QAAM,UAAU,wBAAwB,WAAW,UAAU;AAC7D,QAAM,EAAE,SAAS,SAAS,IAAI,MAAM,mBAAmB;AAAA,IACrD,SAAS,2BAA2B,WAAW,UAAU;AAAA,IACzD,UAAU,wBAAwB,EAAE,MAAM,UAAU,YAAY,CAAC;AAAA,EACnE,CAAC;AACD,MAAI,aAAa,GAAG;AAClB,WAAO;AAAA,EACT;AAEA,UAAQ,KAAK,SAAS,OAAO,QAAQ,CAAC,6CAA6C,UAAU,6DAA6D;AAC1J,QAAM,UAAU,MAAM,UAAU;AAAA;AAAA;AAChC,SAAO,UAAU,QAAQ,GAAG,OAAO,GAAG,OAAO,IAAI,MAAM,GAAG,OAAO,GAAG,wBAAwB,SAAS,UAAU,CAAC,EAAE;AACpH;AAEA,SAAS,eAAe,QAAwB;AAC9C,SAAO,SAAS,WAAW,MAAM,MAAM;AACzC;AAeA,SAAS,wBAAwB,kBAA0B,SAAyB;AAClF,QAAM,QAAQ,iBAAiB,MAAM,OAAO;AAC5C,QAAM,eAAe,MAAM,QAAQ,MAAM,OAAO,EAAE;AAClD,MAAI,iBAAiB,IAAI;AACvB,WAAO;AAAA,EACT;AAEA,QAAM,iBAAiB,eAAe;AACtC,QAAM,oBAAoB,MAAM,MAAM,cAAc,EAAE,UAAU,CAAC,SAAS,KAAK,WAAW,KAAK,CAAC;AAChG,QAAM,eAAe,sBAAsB,KAAK,MAAM,SAAS,iBAAiB;AAChF,SAAO,MAAM,MAAM,gBAAgB,YAAY,EAAE,KAAK,IAAI,EAAE,KAAK;AACnE;AAuBA,eAAe,aAAa,aAAyC;AAGnE,QAAM,SAAS,MAAM,aAAa,CAAC,OAAO,OAAO,aAAa,mBAAmB,IAAI,GAAG,EAAE,SAAS,KAAK,CAAC;AAEzG,QAAM,iBAAiB,OACpB,MAAM,IAAI,EACV,IAAI,CAAC,WAAW,gBAAgB,MAAM,CAAC,EACvC,OAAO,CAAC,kBAAkB,kBAAkB,IAAI;AAEnD,SAAO;AAAA,IACL;AAAA,IACA,OAAO,mBAAmB,cAAc;AAAA,EAC1C;AACF;AA0BA,eAAe,4BAA4B,kBAA0B,SAA8C;AACjH,QAAM,UAAU,2BAA2B,kBAAkB,OAAO;AACpE,QAAM,WAAW,wBAAwB,EAAE,MAAM,UAAU,YAAY,CAAC;AACxE,QAAM,cAAc,MAAM,gBAAgB;AAC1C,QAAM,cAAc,OAAO,KAAK,YAAY,WAAW,CAAC,CAAC;AAEzD,QAAM,uBAAuB,YAAY,SAAS,mBAAmB,IACjE,MAAM,oBAAoB;AAAA,IAC1B;AAAA,IACA;AAAA,EACF,CAAC,IACC,CAAC;AACL,QAAM,mBAAmB,YAAY,SAAS,sBAAsB,IAChE,MAAM,kBAAkB;AAAA,IACxB;AAAA,IACA;AAAA,EACF,CAAC,IACC,CAAC;AAEL,SAAO;AAAA,IACL,GAAG,qBAAqB,IAAI,CAAC,UAAU;AAAA,MACrC,YAAY;AAAA,MACZ;AAAA,IACF,EAAE;AAAA,IACF,GAAG,iBAAiB,IAAI,CAAC,UAAU;AAAA,MACjC,YAAY;AAAA,MACZ;AAAA,IACF,EAAE;AAAA,EACJ;AACF;AAOA,eAAe,8BAAiD;AAC9D,QAAM,eAAe,MAAM,aAAa,CAAC,OAAO,QAAQ,sBAAsB,UAAU,MAAM,QAAQ,GAAG,EAAE,SAAS,KAAK,CAAC;AAC1H,QAAM,SAAS,mBAAmB,YAAY;AAC9C,SAAO;AAAA,IACL,KAAK,UAAU,MAAM,OAAO,QAAQ;AAAA,IACpC,KAAK,UAAU,MAAM,UAAU,SAAS;AAAA,EAC1C;AACF;AAeA,SAAS,mBAAmB,OAAkB,YAAwE;AACpH,SAAO,eAAe,sBAClB,UAAU,sBACV,UAAU;AAChB;AAUA,SAAS,qBAAqB,mBAAuC,qBAAuC;AAC1G,SAAO,sBAAsB,UAAa;AAC5C;AAWA,SAAS,wBAAwB,MAAuC;AACtE,QAAM,iBAAiB,6BAA6B,KAAK,KAAK,KAAK,CAAC,GAAG,SAAS,YAAY;AAC5F,MAAI,gBAAgB,WAAW,yBAAyB,EAAE,EAAE,WAAW,kBAAkB,EAAE,MAAM,IAAI;AACnG,WAAO;AAAA,EACT;AAEA,SAAO,MAAM,KAAK,eAAe,SAAS,uBAAuB,GAAG,CAAC,UAA0B;AAC7F,UAAM,aAAa,sBAAsB,OAAO,YAAY;AAC5D,QAAI,eAAe,MAAM;AACvB,aAAO,EAAE,UAAU,IAAI,UAAU,IAAI,WAAW,CAAC,IAAI,UAAU,EAAE,EAAE;AAAA,IACrE;AACA,UAAM,WAAW,sBAAsB,OAAO,SAAS,KAAK,sBAAsB,OAAO,MAAM;AAC/F,UAAM,cAAc,sBAAsB,OAAO,WAAW,KAAK,sBAAsB,OAAO,YAAY;AAC1G,sBAAkB,QAAQ;AAC1B,sBAAkB,WAAW;AAC7B,UAAM,MAAM,sBAAsB,QAAQ,WAAW,WAAW;AAChE,WAAO,EAAE,UAAU,IAAI,GAAG,KAAK,WAAW,CAAC,GAAG,QAAQ,IAAI,WAAW,IAAI,KAAK,sBAAsB,QAAQ,SAAS,WAAW,EAAE,EAAE;AAAA,EACtI,CAAC;AACH;AAgBA,SAAS,mBAAmB,QAA+B;AACzD,aAAW,SAAS,OAAO,SAAS,OAAO,GAAG;AAC5C,QAAI;AAEJ,QAAI;AACF,gBAAU,KAAK,MAAM,OAAO,MAAM,MAAM,KAAK,CAAC;AAAA,IAChD,QAAQ;AACN;AAAA,IACF;AAEA,UAAM,UAAU,MAAM,QAAQ,OAAO,IAAI,UAA6B,OAAO,OAAO,OAAwC;AAC5H,UAAM,SAAS,QAAQ,CAAC;AAExB,QAAI,CAAC,QAAQ;AACX,YAAM,IAAI,MAAM,sDAAsD;AAAA,IACxE;AAEA,WAAO;AAAA,EACT;AAEA,QAAM,IAAI,MAAM,iEAAiE;AACnF;AAwBA,eAAe,iBAAiB,YAAoB,SAAkD;AACpG,QAAM;AAAA,IACJ;AAAA,IACA,sBAAsB;AAAA,EACxB,IAAI;AACJ,QAAM,cAAc,qBAAqB,mBAAmB,mBAAmB;AAC/E,QAAM,eAAe,cACjB,MAAM,iBAAiB,YAAY,iBAAiB,IACpD,MAAM,8BAA8B,YAAY,iBAAiB;AACrE,MAAI,mBAAmB;AACvB,MAAI,WAA+B,CAAC;AAMpC,aAAS;AACP,QAAI,aAAa;AACf,YAAM,oBAAoB,MAAM,gBAAgB,kBAAkB,QAAQ;AAC1E,UAAI,SAAS,SAAS,KAAK,sBAAsB,kBAAkB;AACjE,cAAM,yBAAyB,UAAU,UAAU;AAAA,MACrD;AAEA,yBAAmB;AAAA,IACrB;AAEA,eAAW,MAAM,4BAA4B,kBAAkB,UAAU;AACzE,QAAI,SAAS,WAAW,GAAG;AACzB;AAAA,IACF;AAEA,QAAI,CAAC,aAAa;AAChB,YAAM,yBAAyB,UAAU,UAAU;AAAA,IACrD;AAAA,EACF;AAMA,oCAAkC,kBAAkB,UAAU;AAC9D,QAAM,sCAAsC,kBAAkB,UAAU;AACxE,SAAO;AACT;AASA,eAAe,6BAAgD;AAC7D,QAAM,qBAAqB;AAC3B,QAAM,gBAAgB,wBAAwB,EAAE,MAAM,UAAU,YAAY,CAAC;AAC7E,MAAI,CAAC,WAAW,aAAa,GAAG;AAC9B,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,UAAU,MAAM,SAAS,eAAe,OAAO;AACrD,QAAM,yBAAyB,QAAQ,MAAM,IAAI,EAAE,MAAM,kBAAkB;AAC3E,MAAI,uBAAuB,GAAG,EAAE,MAAM,IAAI;AACxC,2BAAuB,IAAI;AAAA,EAC7B;AAEA,SAAO;AACT;AAeA,eAAe,uBAAuB,wBAAmD;AACvF,QAAM,UAAU,WAAW;AAAA,IACzB,SAAS,uBAAuB,CAAC,KAAK;AAAA,IACtC,UAAU;AAAA,IACV,aAAa;AAAA,EACf,CAAC;AAED,MAAI,CAAC,SAAS;AACZ,WAAO;AAAA,EACT;AAEA,QAAM,kBAAkB,MAAM,aAAa,CAAC,OAAO,aAAa,YAAY,WAAW,aAAa,OAAO,EAAE,GAAG;AAAA,IAC9G,SAAS;AAAA,IACT,sBAAsB;AAAA,EACxB,CAAC;AAED,MAAI,CAAC,iBAAiB;AACpB,mBAAe,SAAS;AAAA,MACtB,GAAG,UAAU,WAAW,kBAAkB,OAAO;AAAA,IACnD;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AASA,eAAe,yBAAyB,UAAmC,qBAAiD;AAC1H,QAAM,QAAQ,MAAM,SAAS;AAC7B,SAAO,MAAM,OAAO,CAAC,SAAS;AAC5B,UAAM,WAAW,WAAW,wBAAwB,EAAE,KAAK,CAAC,CAAC;AAC7D,QAAI,CAAC,YAAY,qBAAqB;AACpC,YAAM,IAAI,MAAM,iCAAiC,IAAI,EAAE;AAAA,IACzD;AACA,WAAO;AAAA,EACT,CAAC;AACH;AAWA,eAAe,gBAAgB,cAAsB,UAA+C;AAClG,QAAM,gBAAgB,MAAM,QAAQ,KAAK,OAAO,GAAG,YAAY,CAAC;AAChE,QAAM,uBAAuB,KAAK,eAAe,UAAU,WAAW;AAEtE,MAAI;AACF,UAAM,UAAU,sBAAsB,cAAc,OAAO;AAE3D,UAAM,cAAc,MAAM,aAAa,kBAAkB;AAAA,MACvD,SAAS;AAAA,MACT,sBAAsB;AAAA,IACxB,CAAC;AACD,UAAM,kBAAkB,eAAe,SAAS;AAChD,QAAI,SAAS,SAAS,GAAG;AACvB;AAAA,QACE,GAAG,UAAU,WAAW,kBAAkB,oBAAoB,QAAQ,CAAC;AAAA,EAAU,eAAe,QAAQ,CAAC;AAAA,MAC3G;AAAA,IACF;AAEA,QAAI,aAAa;AACf,sBAAgB,qBAAqB,UAAU,WAAW,sDAAsD;AAChH,YAAM,aAAa,CAAC,QAAQ,MAAM,oBAAoB,GAAG;AAAA,QACvD,SAAS;AAAA,QACT,sBAAsB;AAAA,MACxB,CAAC;AAAA,IACH,OAAO;AACL,sBAAgB,6EAA6E;AAC7F,YAAM,gBAAgB,QAAQ,OAAO,QAAQ,MAAM,EAAE;AAAA,QACnD,qBAAqB,oBAAoB;AAAA,MAC3C;AAAA,IACF;AAEA,WAAO,MAAM,SAAS,sBAAsB,OAAO;AAAA,EACrD,UAAE;AACA,UAAM,GAAG,eAAe;AAAA,MACtB,OAAO;AAAA,MACP,WAAW;AAAA,IACb,CAAC;AAAA,EACH;AACF;AAeA,SAAS,iBAAiB,WAAsB,SAAyC;AACvF,QAAM,eAAe,UAAU,eAC5B,IAAI,CAAC,kBAAkB,KAAK,cAAc,IAAI,MAAM,GAAG,gBAAgB,CAAC,KAAK,cAAc,OAAO,MAAM,cAAc,MAAM,GAAG,EAC/H,KAAK,IAAI;AAEZ,SAAO,IAAI;AAAA,IACT,qBAAqB,QAAQ,OAAO,qBAAqB,UAAU,KAAK,kBAAkB,QAAQ,iBAAiB,mBAC3G,QAAQ,UAAU,gBAAgB,QAAQ,UAAU;AAAA,EACrD,YAAY;AAAA,wKAGX,UAAU,KAAK;AAAA,EACzB;AACF;AAmBA,SAAS,iBAAiB,eAA+B;AACvD,QAAM,QAAQ,cAAc,MAAM,OAAO,EAAE,OAAO,OAAO;AACzD,QAAM,UAAU,MAAM,CAAC,KAAK;AAC5B,QAAM,YAAY,MAAM,MAAM,CAAC;AAC/B,QAAM,QAAQ,sBAAsB,KAAK,OAAO,IAAI,UAAU,KAAK,CAAC,SAAS,CAAC,wBAAwB,IAAI,CAAC,KAAK,UAAU;AAC1H,QAAM,aAAa,oBAAI,IAAY;AACnC,aAAW,aAAa,UAAU,QAAQ,CAAC,SAAS,wBAAwB,IAAI,KAAK,CAAC,CAAC,GAAG;AACxF,QAAI,UAAU,UAAU,MAAM,CAAC,aAAa,CAAC,IAAI,OAAO,OAAO,gBAAgB,aAAa,QAAQ,CAAC,QAAQ,EAAE,KAAK,KAAK,CAAC,GAAG;AAC3H,iBAAW,IAAI,UAAU,QAAQ;AAAA,IACnC;AAAA,EACF;AACA,SAAO,WAAW,SAAS,IAAI,QAAQ,GAAG,KAAK,KAAK,CAAC,GAAG,UAAU,EAAE,KAAK,IAAI,CAAC;AAChF;AAYA,SAAS,yBAAyB,UAA8B,SAAwB;AACtF,QAAM,cAAc,oBAAoB,QAAQ;AAChD,SAAO,IAAI;AAAA,IACT,OAAO,OAAO,eAAe,UAAU,WAAW,kBAAkB,WAAW;AAAA,EACxE,eAAe,QAAQ,CAAC;AAAA,ghBAMvB,WAAW;AAAA,EACrB;AACF;AAcA,SAAS,2BAA2B,kBAA0B,SAAyB;AACrF,QAAM,UAAU;AAAA;AAAA,KAAqB,OAAO;AAC5C,QAAM,UAAU,wBAAwB,kBAAkB,OAAO;AAGjE,SAAO,YAAY,KAAK,GAAG,OAAO;AAAA,IAAO,GAAG,OAAO;AAAA;AAAA,EAAO,OAAO;AAAA;AACnE;AAeA,SAAS,qBAAqB,aAAqB,YAAsC;AACvF,QAAM,OAAO,MAAM,WAAW;AAC9B,QAAM,OAAO,MAAM,UAAU;AAC7B,MAAI,CAAC,QAAQ,CAAC,MAAM;AAClB,WAAO;AAAA,EACT;AAEA,MAAI,KAAK,QAAQ,KAAK,OAAO;AAC3B,WAAO;AAAA,EACT;AAEA,SAAO,KAAK,QAAQ,KAAK,QAAQ,sBAA0B;AAC7D;AAWA,SAAS,oBAAoB,UAAsC;AACjE,QAAM,cAAc,CAAC,qBAAqB,sBAAsB,EAAE,OAAO,CAAC,eAAe,SAAS,KAAK,CAAC,YAAY,QAAQ,eAAe,UAAU,CAAC;AACtJ,SAAO,YAAY,KAAK,OAAO;AACjC;AAWA,SAAS,eAAe,UAAsC;AAC5D,SAAO,SAAS,IAAI,CAAC,YAAY,IAAI,QAAQ,UAAU,KAAK,QAAQ,IAAI,EAAE,EAAE,KAAK,IAAI;AACvF;AAUA,SAAS,gBAAgB,QAAsC;AAG7D,QAAM,CAAC,KAAK,aAAa,GAAG,SAAS,IAAI,OAAO,MAAM,IAAI;AAC1D,MAAI,CAAC,OAAO,gBAAgB,QAAW;AACrC,WAAO;AAAA,EACT;AAEA,QAAM,UAAU,YAAY,KAAK;AACjC,QAAM,OAAO,UAAU,KAAK,IAAI;AAChC,QAAM,eAAe,oCAAoC,KAAK,OAAO;AAErE,MAAI,cAAc,SAAS,UAAU,GAAG;AACtC,WAAO;AAAA,MACL,OAAO;AAAA,MACP,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,MAAI,+BAA+B,KAAK,IAAI,GAAG;AAC7C,WAAO;AAAA,MACL,OAAO;AAAA,MACP,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,SAAO,cAAc,SAAS,MAAM,GAAG,YAAY,MAAM,YACrD;AAAA,IACA,OAAO;AAAA,IACP,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,EACF,IACE;AACN;AASA,SAAS,mBAAmB,gBAAqD;AAC/E,MAAI,eAAe,KAAK,CAAC,kBAAkB,cAAc,UAAU,mBAAuB,GAAG;AAC3F,WAAO;AAAA,EACT;AAEA,SAAO,eAAe,SAAS,IAAI,sBAA0B;AAC/D;AAQA,eAAe,oBAAoB,YAAoB,WAA6C;AAClG,QAAM,UAAU,KAAK;AAAA,IACnB,MAAM,aAAa;AAAA,MACjB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,GAAG,EAAE,SAAS,KAAK,CAAC;AAAA,EACtB;AACA,MACE,QAAQ,WAAW,QAAQ,YAAY,cAAc,QAAQ,iBAAiB,aAAa,UAAU,KAClG,UAAU,KAAK,CAAC,SAAS,QAAQ,OAAO,MAAM,CAAC,UAAU,EAAE,MAAM,SAAS,SAAS,IAAI,KAAK,MAAM,UAAU,WAAW,CAAC,GAC3H;AACA,UAAM,IAAI,MAAM,+BAA+B,UAAU,uEAAuE;AAAA,EAClI;AACF;AASA,eAAe,eAAe,cAAqC;AACjE,QAAM,UAAU,wBAAwB,EAAE,MAAM,UAAU,YAAY,CAAC,GAAG,cAAc,OAAO;AACjG;","names":["VersionUpdateType"]}