@mnaoumov/typescript-dev-toolkit 6.1.0 → 6.3.0

package/dist/lib/cjs/version.d.cts

@@ -9,6 +9,7 @@
  * Git operations such as tagging and pushing.
  */
 import { parseArgs } from 'node:util';
+import type { ChangelogCommitEntry, ChangelogStyle } from './changelog-grouping.cjs';
 /**
  * Options for {@link addUpdatedFilesToGit}.
  */
@@ -76,6 +77,16 @@ export interface UpdateChangelogOptions {
      * @default the first-parent commit subjects since the previous version
      */
     readonly changelogFilePath?: string | undefined;
+    /**
+     * How the section generated from the commit messages is laid out: `grouped` sorts the entries under plain-language
+     * headings and counts the maintenance commits instead of listing them, `commits` writes one bullet per first-parent
+     * commit. See {@link ChangelogStyle}.
+     *
+     * Ignored when {@link changelogFilePath} is set.
+     *
+     * @default `'grouped'`
+     */
+    readonly changelogStyle?: ChangelogStyle | undefined;
     /**
      * Whether to open the generated changelog in the editor for an interactive review. When `false`,
      * the changelog is still generated from commit messages, but it is not opened in the editor for
@@ -102,6 +113,12 @@ export interface UpdateVersionOptions {
      * @default the first-parent commit subjects since the previous version
      */
     readonly changelogFilePath?: string | undefined;
+    /**
+     * How the section generated from the commit messages is laid out. See {@link UpdateChangelogOptions.changelogStyle}.
+     *
+     * @default `'grouped'`
+     */
+    readonly changelogStyle?: ChangelogStyle | undefined;
     /**
      * Returns the files to attach to the GitHub release. See {@link PublishGitHubReleaseOptions.getReleaseAssetPaths}.
      */
@@ -334,6 +351,9 @@ export declare const VERSION_ARGUMENT_OPTIONS: {
     readonly 'changelog-file': {
         readonly type: "string";
     };
+    readonly 'changelog-style': {
+        readonly type: "string";
+    };
     readonly 'no-build': {
         readonly type: "boolean";
     };
@@ -381,6 +401,7 @@ export declare function isPreRelease(version: string): boolean;
  * value instead and has no default. Recognized flags:
  * - `--changelog-file=<path>` — use this file's contents as the new version's changelog section instead of
  *   the commit-derived bullets, and skip the interactive review entirely.
+ * - `--changelog-style=<grouped|commits>` — how the commit-derived section is laid out (default `grouped`).
  * - `--no-build` — skip the build step (only safe when the build output already matches the current code).
  * - `--no-changelog-editing` — generate the changelog without opening it for manual review.
  * - `--no-checks` — skip the clean-repo check, format, spellcheck, lint, over-exposure analysis, and tests (the build still runs).
@@ -406,6 +427,14 @@ export declare function parseVersionArguments($arguments: string[]): ParsedVersi
  * @returns A {@link Promise} that resolves when the release has been published.
  */
 export declare function publishGitHubRelease(newVersion: string, options?: PublishGitHubReleaseOptions): Promise<void>;
+/**
+ * Reads one first-parent commit into the parts both changelog styles render: the line {@link toChangelogEntry}
+ * describes, the issue references it does not already show, and what else the body says.
+ *
+ * @param commitMessage - The full commit message.
+ * @returns The parts, with bare URLs in the entry and the detail lines autolinked.
+ */
+export declare function toChangelogCommitEntry(commitMessage: string): ChangelogCommitEntry;
 /**
  * Maps the values `parseArgs` reports for {@link VERSION_ARGUMENT_OPTIONS} onto {@link UpdateVersionOptions}.
  *

package/dist/lib/esm/changelog-grouping.d.mts

@@ -0,0 +1,70 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Groups the commit-derived entries of a new changelog section into plain-language sections, so the release notes a
+ * release writes with nobody reviewing them can be scanned rather than read commit by commit.
+ *
+ * The input is still the first-parent commit history, so this is a deterministic transformation of what the author
+ * already wrote: it sorts entries by their Conventional-Commits type, leaves out the commit types that do not change
+ * what a user gets, merges entries that say the same thing, and swaps a `re #<n>` subject for the issue title its body
+ * carries. Prose a human (or an agent) writes still goes in through `--changelog-file`.
+ */
+/**
+ * How the generated changelog section of a release is laid out.
+ *
+ * - `grouped` — a one-line summary, then the entries under `### Breaking changes`, `### New`, `### Fixed`,
+ *   `### Improved`, `### Documentation` and `### Other changes`, with maintenance commits counted rather than listed.
+ * - `commits` — one bullet per first-parent commit, in history order, as every release wrote before `grouped` existed.
+ */
+export type ChangelogStyle = 'commits' | 'grouped';
+/**
+ * Every {@link ChangelogStyle}, in the order the `--changelog-style` error lists them.
+ */
+export declare const CHANGELOG_STYLES: readonly ChangelogStyle[];
+/**
+ * One first-parent commit, as {@link renderGroupedChangelogSection} takes it.
+ */
+export interface ChangelogCommitEntry {
+    /**
+     * The body lines that are neither the entry itself nor an issue reference line nor a breaking-change footer, in
+     * order. The first of them is the issue title an issue-closing `re #<n>` merge carries.
+     */
+    readonly detailLines: readonly string[];
+    /**
+     * The changelog line the commit produces before grouping: its subject, or the body line lifted onto a default merge
+     * subject.
+     */
+    readonly entry: string;
+    /**
+     * Whether the commit carries a `BREAKING CHANGE:` footer. The `!` marker is read off {@link entry} itself.
+     */
+    readonly hasBreakingFooter: boolean;
+    /**
+     * The issue references the body names that {@link entry} does not already show, rendered as the line shows them.
+     */
+    readonly references: readonly string[];
+}
+/**
+ * The commit types that change nothing a user of the release gets, so the grouped section counts them instead of
+ * listing them. A commit of one of these types that is marked breaking is still listed, under breaking changes.
+ */
+export declare const MAINTENANCE_COMMIT_TYPES: ReadonlySet<string>;
+/**
+ * Escapes the square brackets of an issue title outside its code spans, so a title such as `[BUG] Links break` is
+ * published as text rather than read as a reference link with no definition (markdownlint's MD052).
+ *
+ * An issue title is written by whoever opened the issue, and no commit hook ever checks it, so it is the one part of a
+ * generated entry that can carry Markdown the author never meant. A bracket already escaped is left as it is.
+ *
+ * @param text - The issue title.
+ * @returns The title with every unescaped `[` and `]` outside a code span preceded by a backslash.
+ */
+export declare function escapeLinkBrackets(text: string): string;
+/**
+ * Renders the body of a new changelog section in the {@link ChangelogStyle} `grouped` layout.
+ *
+ * @param entries - The first-parent commits since the previous release, in `git log` order.
+ * @returns The section body, without its `## <version>` heading and without a trailing newline.
+ */
+export declare function renderGroupedChangelogSection(entries: readonly ChangelogCommitEntry[]): string;

package/dist/lib/esm/changelog-grouping.mjs

@@ -0,0 +1,126 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+const CHANGELOG_STYLES = ["grouped", "commits"];
+const MAINTENANCE_COMMIT_TYPES = /* @__PURE__ */ new Set(["build", "chore", "ci", "refactor", "style", "test"]);
+const BREAKING_SECTION = { heading: "Breaking changes", plural: "breaking changes", singular: "breaking change" };
+const NEW_SECTION = { heading: "New", plural: "new features", singular: "new feature" };
+const FIXED_SECTION = { heading: "Fixed", plural: "fixes", singular: "fix" };
+const IMPROVED_SECTION = { heading: "Improved", plural: "improvements", singular: "improvement" };
+const DOCUMENTATION_SECTION = { heading: "Documentation", plural: "documentation changes", singular: "documentation change" };
+const OTHER_SECTION = { heading: "Other changes", plural: "other changes", singular: "other change" };
+const SECTIONS = [BREAKING_SECTION, NEW_SECTION, FIXED_SECTION, IMPROVED_SECTION, DOCUMENTATION_SECTION, OTHER_SECTION];
+const SECTIONS_BY_TYPE = /* @__PURE__ */ new Map([
+  ["docs", DOCUMENTATION_SECTION],
+  ["feat", NEW_SECTION],
+  ["fix", FIXED_SECTION],
+  ["perf", IMPROVED_SECTION]
+]);
+const CONVENTIONAL_ENTRY_REG_EXP = /^(?<type>[a-z]+)(?:\((?<scope>[^()]*)\))?(?<breaking>!)?:\s+(?<description>\S.*)$/i;
+const ISSUE_ONLY_DESCRIPTION_REG_EXP = /^re (?<issue>#\d+)$/i;
+const CODE_SPAN_REG_EXP = /(?<!`)(?<fence>`+)(?!`)[\s\S]*?(?<!`)\k<fence>(?!`)/g;
+const BRACKET_REG_EXP = /\\*[[\]]/g;
+function escapeLinkBrackets(text) {
+  const parts = [];
+  let lastIndex = 0;
+  for (const match of text.matchAll(CODE_SPAN_REG_EXP)) {
+    parts.push(escapeBracketsInPlainText(text.slice(lastIndex, match.index)), match[0]);
+    lastIndex = match.index + match[0].length;
+  }
+  parts.push(escapeBracketsInPlainText(text.slice(lastIndex)));
+  return parts.join("");
+}
+function renderGroupedChangelogSection(entries) {
+  const sectionEntries = /* @__PURE__ */ new Map();
+  let maintenanceCount = 0;
+  for (const entry of entries) {
+    const classified = classifyEntry(entry);
+    if (!classified) {
+      maintenanceCount++;
+      continue;
+    }
+    const list = sectionEntries.get(classified.section) ?? [];
+    sectionEntries.set(classified.section, list);
+    const existing = list.find((sectionEntry) => sectionEntry.text === classified.text);
+    if (!existing) {
+      list.push({ references: [...classified.references], text: classified.text });
+      continue;
+    }
+    existing.references = [.../* @__PURE__ */ new Set([...existing.references, ...classified.references])];
+  }
+  const blocks = [toSummaryLine(sectionEntries, maintenanceCount)];
+  for (const section of SECTIONS) {
+    const list = sectionEntries.get(section);
+    if (!list) {
+      continue;
+    }
+    blocks.push(`### ${section.heading}`, list.map((sectionEntry) => `- ${toEntryLine(sectionEntry)}`).join("\n"));
+  }
+  return blocks.join("\n\n");
+}
+function classifyEntry(entry) {
+  const groups = CONVENTIONAL_ENTRY_REG_EXP.exec(entry.entry)?.groups;
+  if (!groups) {
+    return { references: entry.references, section: entry.hasBreakingFooter ? BREAKING_SECTION : OTHER_SECTION, text: entry.entry };
+  }
+  const type = String(groups["type"]).toLowerCase();
+  const isBreaking = groups["breaking"] !== void 0 || entry.hasBreakingFooter;
+  const section = isBreaking ? BREAKING_SECTION : toTypeSection(type);
+  if (!section) {
+    return null;
+  }
+  const description = String(groups["description"]);
+  const issue = ISSUE_ONLY_DESCRIPTION_REG_EXP.exec(description)?.groups?.["issue"];
+  const issueTitle = entry.detailLines[0];
+  const isIssueTitleUsed = issue !== void 0 && issueTitle !== void 0;
+  const text = isIssueTitleUsed ? escapeLinkBrackets(issueTitle) : description;
+  const references = isIssueTitleUsed ? [issue, ...entry.references] : entry.references;
+  const scope = groups["scope"];
+  return {
+    references,
+    section,
+    text: scope ? `**${scope}:** ${text}` : text
+  };
+}
+function countPhrase(count, section) {
+  return `${String(count)} ${count === 1 ? section.singular : section.plural}`;
+}
+function escapeBracketsInPlainText(text) {
+  return text.replaceAll(BRACKET_REG_EXP, (match) => {
+    const backslashes = match.slice(0, -1);
+    const isEscaped = backslashes.replaceAll("\\\\", "") === "\\";
+    return isEscaped ? match : `${backslashes}\\${match.slice(-1)}`;
+  });
+}
+function joinPhrases(phrases) {
+  const last = phrases.slice(-1).join("");
+  return phrases.length === 1 ? last : `${phrases.slice(0, -1).join(", ")} and ${last}`;
+}
+function toEntryLine(sectionEntry) {
+  return sectionEntry.references.length === 0 ? sectionEntry.text : `${sectionEntry.text} (${sectionEntry.references.join(", ")})`;
+}
+function toSummaryLine(sectionEntries, maintenanceCount) {
+  const phrases = SECTIONS.map((section) => ({ count: sectionEntries.get(section)?.length ?? 0, section })).filter(({ count }) => count > 0).map(({ count, section }) => countPhrase(count, section));
+  const isOne = maintenanceCount === 1;
+  const maintenance = maintenanceCount === 0 ? "" : ` ${String(maintenanceCount)} maintenance ${isOne ? "commit" : "commits"} (tests, build, CI, refactoring, dependencies) ${isOne ? "is" : "are"} not listed.`;
+  if (phrases.length > 0) {
+    return `This release has ${joinPhrases(phrases)}.${maintenance}`;
+  }
+  return maintenanceCount === 0 ? "This release has no changes." : `This release has maintenance changes only.${maintenance}`;
+}
+function toTypeSection(type) {
+  const section = SECTIONS_BY_TYPE.get(type);
+  if (section) {
+    return section;
+  }
+  return MAINTENANCE_COMMIT_TYPES.has(type) ? null : OTHER_SECTION;
+}
+export {
+  CHANGELOG_STYLES,
+  MAINTENANCE_COMMIT_TYPES,
+  escapeLinkBrackets,
+  renderGroupedChangelogSection
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/changelog-grouping.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Groups the commit-derived entries of a new changelog section into plain-language sections, so the release notes a\n * release writes with nobody reviewing them can be scanned rather than read commit by commit.\n *\n * The input is still the first-parent commit history, so this is a deterministic transformation of what the author\n * already wrote: it sorts entries by their Conventional-Commits type, leaves out the commit types that do not change\n * what a user gets, merges entries that say the same thing, and swaps a `re #<n>` subject for the issue title its body\n * carries. Prose a human (or an agent) writes still goes in through `--changelog-file`.\n */\n\n/**\n * How the generated changelog section of a release is laid out.\n *\n * - `grouped` \u2014 a one-line summary, then the entries under `### Breaking changes`, `### New`, `### Fixed`,\n *   `### Improved`, `### Documentation` and `### Other changes`, with maintenance commits counted rather than listed.\n * - `commits` \u2014 one bullet per first-parent commit, in history order, as every release wrote before `grouped` existed.\n */\nexport type ChangelogStyle = 'commits' | 'grouped';\n\n/**\n * Every {@link ChangelogStyle}, in the order the `--changelog-style` error lists them.\n */\nexport const CHANGELOG_STYLES: readonly ChangelogStyle[] = ['grouped', 'commits'];\n\n/**\n * One first-parent commit, as {@link renderGroupedChangelogSection} takes it.\n */\nexport interface ChangelogCommitEntry {\n  /**\n   * The body lines that are neither the entry itself nor an issue reference line nor a breaking-change footer, in\n   * order. The first of them is the issue title an issue-closing `re #<n>` merge carries.\n   */\n  readonly detailLines: readonly string[];\n\n  /**\n   * The changelog line the commit produces before grouping: its subject, or the body line lifted onto a default merge\n   * subject.\n   */\n  readonly entry: string;\n\n  /**\n   * Whether the commit carries a `BREAKING CHANGE:` footer. The `!` marker is read off {@link entry} itself.\n   */\n  readonly hasBreakingFooter: boolean;\n\n  /**\n   * The issue references the body names that {@link entry} does not already show, rendered as the line shows them.\n   */\n  readonly references: readonly string[];\n}\n\n/**\n * The commit types that change nothing a user of the release gets, so the grouped section counts them instead of\n * listing them. A commit of one of these types that is marked breaking is still listed, under breaking changes.\n */\nexport const MAINTENANCE_COMMIT_TYPES: ReadonlySet<string> = new Set(['build', 'chore', 'ci', 'refactor', 'style', 'test']);\n\ninterface ClassifiedEntry {\n  readonly references: readonly string[];\n  readonly section: SectionDefinition;\n  readonly text: string;\n}\n\ninterface SectionDefinition {\n  readonly heading: string;\n  readonly plural: string;\n  readonly singular: string;\n}\n\ninterface SectionEntry {\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Merged entries collect references in place.\n  references: string[];\n  readonly text: string;\n}\n\nconst BREAKING_SECTION: SectionDefinition = { heading: 'Breaking changes', plural: 'breaking changes', singular: 'breaking change' };\nconst NEW_SECTION: SectionDefinition = { heading: 'New', plural: 'new features', singular: 'new feature' };\nconst FIXED_SECTION: SectionDefinition = { heading: 'Fixed', plural: 'fixes', singular: 'fix' };\nconst IMPROVED_SECTION: SectionDefinition = { heading: 'Improved', plural: 'improvements', singular: 'improvement' };\nconst DOCUMENTATION_SECTION: SectionDefinition = { heading: 'Documentation', plural: 'documentation changes', singular: 'documentation change' };\nconst OTHER_SECTION: SectionDefinition = { heading: 'Other changes', plural: 'other changes', singular: 'other change' };\n\n/**\n * The sections, in the order they are rendered and summarized.\n */\nconst SECTIONS: readonly SectionDefinition[] = [BREAKING_SECTION, NEW_SECTION, FIXED_SECTION, IMPROVED_SECTION, DOCUMENTATION_SECTION, OTHER_SECTION];\n\nconst SECTIONS_BY_TYPE = new Map<string, SectionDefinition>([\n  ['docs', DOCUMENTATION_SECTION],\n  ['feat', NEW_SECTION],\n  ['fix', FIXED_SECTION],\n  ['perf', IMPROVED_SECTION]\n]);\n\nconst CONVENTIONAL_ENTRY_REG_EXP = /^(?<type>[a-z]+)(?:\\((?<scope>[^()]*)\\))?(?<breaking>!)?:\\s+(?<description>\\S.*)$/i;\n\n/**\n * An issue-closing merge subject, whose readable half is the issue title on the body's first line.\n */\nconst ISSUE_ONLY_DESCRIPTION_REG_EXP = /^re (?<issue>#\\d+)$/i;\n\n/**\n * A code span: a backtick run, the shortest text up to a backtick run of the same length.\n */\nconst CODE_SPAN_REG_EXP = /(?<!`)(?<fence>`+)(?!`)[\\s\\S]*?(?<!`)\\k<fence>(?!`)/g;\n\n/**\n * A square bracket and the backslashes right before it.\n */\nconst BRACKET_REG_EXP = /\\\\*[[\\]]/g;\n\n/**\n * Escapes the square brackets of an issue title outside its code spans, so a title such as `[BUG] Links break` is\n * published as text rather than read as a reference link with no definition (markdownlint's MD052).\n *\n * An issue title is written by whoever opened the issue, and no commit hook ever checks it, so it is the one part of a\n * generated entry that can carry Markdown the author never meant. A bracket already escaped is left as it is.\n *\n * @param text - The issue title.\n * @returns The title with every unescaped `[` and `]` outside a code span preceded by a backslash.\n */\nexport function escapeLinkBrackets(text: string): string {\n  const parts: string[] = [];\n  let lastIndex = 0;\n  for (const match of text.matchAll(CODE_SPAN_REG_EXP)) {\n    parts.push(escapeBracketsInPlainText(text.slice(lastIndex, match.index)), match[0]);\n    lastIndex = match.index + match[0].length;\n  }\n\n  parts.push(escapeBracketsInPlainText(text.slice(lastIndex)));\n  return parts.join('');\n}\n\n/**\n * Renders the body of a new changelog section in the {@link ChangelogStyle} `grouped` layout.\n *\n * @param entries - The first-parent commits since the previous release, in `git log` order.\n * @returns The section body, without its `## <version>` heading and without a trailing newline.\n */\nexport function renderGroupedChangelogSection(entries: readonly ChangelogCommitEntry[]): string {\n  const sectionEntries = new Map<SectionDefinition, SectionEntry[]>();\n  let maintenanceCount = 0;\n\n  for (const entry of entries) {\n    const classified = classifyEntry(entry);\n    if (!classified) {\n      maintenanceCount++;\n      continue;\n    }\n\n    const list = sectionEntries.get(classified.section) ?? [];\n    sectionEntries.set(classified.section, list);\n    const existing = list.find((sectionEntry) => sectionEntry.text === classified.text);\n    if (!existing) {\n      list.push({ references: [...classified.references], text: classified.text });\n      continue;\n    }\n\n    existing.references = [...new Set([...existing.references, ...classified.references])];\n  }\n\n  const blocks = [toSummaryLine(sectionEntries, maintenanceCount)];\n  for (const section of SECTIONS) {\n    const list = sectionEntries.get(section);\n    if (!list) {\n      continue;\n    }\n\n    blocks.push(`### ${section.heading}`, list.map((sectionEntry) => `- ${toEntryLine(sectionEntry)}`).join('\\n'));\n  }\n\n  return blocks.join('\\n\\n');\n}\n\nfunction classifyEntry(entry: ChangelogCommitEntry): ClassifiedEntry | null {\n  const groups = CONVENTIONAL_ENTRY_REG_EXP.exec(entry.entry)?.groups;\n  if (!groups) {\n    return { references: entry.references, section: entry.hasBreakingFooter ? BREAKING_SECTION : OTHER_SECTION, text: entry.entry };\n  }\n\n  // The regular expression's `type` and `description` groups are not optional, so a match always fills them.\n  const type = String(groups['type']).toLowerCase();\n  const isBreaking = groups['breaking'] !== undefined || entry.hasBreakingFooter;\n  const section = isBreaking ? BREAKING_SECTION : toTypeSection(type);\n  if (!section) {\n    return null;\n  }\n\n  const description = String(groups['description']);\n  const issue = ISSUE_ONLY_DESCRIPTION_REG_EXP.exec(description)?.groups?.['issue'];\n  const issueTitle = entry.detailLines[0];\n  const isIssueTitleUsed = issue !== undefined && issueTitle !== undefined;\n  const text = isIssueTitleUsed ? escapeLinkBrackets(issueTitle) : description;\n  const references = isIssueTitleUsed ? [issue, ...entry.references] : entry.references;\n  const scope = groups['scope'];\n  return {\n    references,\n    section,\n    text: scope ? `**${scope}:** ${text}` : text\n  };\n}\n\nfunction countPhrase(count: number, section: SectionDefinition): string {\n  return `${String(count)} ${count === 1 ? section.singular : section.plural}`;\n}\n\nfunction escapeBracketsInPlainText(text: string): string {\n  return text.replaceAll(BRACKET_REG_EXP, (match: string) => {\n    const backslashes = match.slice(0, -1);\n    // An odd run of backslashes escapes the bracket; an even one is escaped backslashes only.\n    const isEscaped = backslashes.replaceAll('\\\\\\\\', '') === '\\\\';\n    return isEscaped ? match : `${backslashes}\\\\${match.slice(-1)}`;\n  });\n}\n\nfunction joinPhrases(phrases: readonly string[]): string {\n  const last = phrases.slice(-1).join('');\n  return phrases.length === 1 ? last : `${phrases.slice(0, -1).join(', ')} and ${last}`;\n}\n\nfunction toEntryLine(sectionEntry: SectionEntry): string {\n  return sectionEntry.references.length === 0 ? sectionEntry.text : `${sectionEntry.text} (${sectionEntry.references.join(', ')})`;\n}\n\nfunction toSummaryLine(sectionEntries: ReadonlyMap<SectionDefinition, readonly SectionEntry[]>, maintenanceCount: number): string {\n  const phrases = SECTIONS\n    .map((section) => ({ count: sectionEntries.get(section)?.length ?? 0, section }))\n    .filter(({ count }) => count > 0)\n    .map(({ count, section }) => countPhrase(count, section));\n  const isOne = maintenanceCount === 1;\n  const maintenance = maintenanceCount === 0\n    ? ''\n    : ` ${String(maintenanceCount)} maintenance ${isOne ? 'commit' : 'commits'} (tests, build, CI, refactoring, dependencies) ${isOne ? 'is' : 'are'} not listed.`;\n\n  if (phrases.length > 0) {\n    return `This release has ${joinPhrases(phrases)}.${maintenance}`;\n  }\n\n  return maintenanceCount === 0 ? 'This release has no changes.' : `This release has maintenance changes only.${maintenance}`;\n}\n\nfunction toTypeSection(type: string): null | SectionDefinition {\n  const section = SECTIONS_BY_TYPE.get(type);\n  if (section) {\n    return section;\n  }\n\n  return MAINTENANCE_COMMIT_TYPES.has(type) ? null : OTHER_SECTION;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/changelog-rewrite-cli.d.mts

@@ -0,0 +1,105 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * The `rewrite-changelog` command: rewrites a project's published `CHANGELOG.md` sections, and optionally its GitHub
+ * release notes, into the `grouped` layout, by wiring {@link rewriteChangelog} to the real git, `gh` and file system.
+ *
+ * It changes nothing unless `--write` is passed, so the first run is always a report of what it would do.
+ */
+/**
+ * The result of one command the `rewrite-changelog` command runs.
+ */
+export interface RewriteChangelogCommandResult {
+    /**
+     * The exit code.
+     */
+    readonly exitCode: number;
+    /**
+     * The standard error.
+     */
+    readonly stderr: string;
+    /**
+     * The standard output.
+     */
+    readonly stdout: string;
+}
+/**
+ * The outside world of the `rewrite-changelog` command.
+ */
+export interface RewriteChangelogDependencies {
+    /**
+     * Runs a command in the working directory.
+     *
+     * @param file - The executable.
+     * @param arguments_ - Its arguments.
+     * @param input - What to write to its standard input.
+     * @returns The result.
+     */
+    readonly exec: (file: string, arguments_: readonly string[], input?: string) => RewriteChangelogCommandResult;
+    /**
+     * Writes one line of the report.
+     *
+     * @param text - The line.
+     */
+    readonly log: (text: string) => void;
+    /**
+     * Reads a text file.
+     *
+     * @param path - The path.
+     * @returns The content.
+     */
+    readonly readFile: (path: string) => string;
+    /**
+     * Writes a text file.
+     *
+     * @param path - The path.
+     * @param content - The content.
+     */
+    readonly writeFile: (path: string, content: string) => void;
+}
+/**
+ * The options of the `rewrite-changelog` command.
+ */
+export interface RewriteChangelogOptions {
+    /**
+     * The `CHANGELOG.md` to rewrite.
+     */
+    readonly changelogPath: string;
+    /**
+     * Whether a GitHub release whose notes are no longer its changelog section as it was is rewritten too.
+     */
+    readonly shouldOverwriteEditedReleases: boolean;
+    /**
+     * Whether the GitHub release of each rewritten section is rewritten too.
+     */
+    readonly shouldRewriteReleases: boolean;
+    /**
+     * Whether anything is changed. Without it the command only reports.
+     */
+    readonly shouldWrite: boolean;
+}
+/**
+ * Creates the command's outside world: commands run with `spawnSync`, files read and written with `node:fs`, the
+ * report written to stdout.
+ *
+ * @returns The dependencies.
+ */
+export declare function createNodeRewriteChangelogDependencies(): RewriteChangelogDependencies;
+/**
+ * Builds the command's options from the command line: `--write` applies the changes, `--releases` adds the GitHub
+ * releases to them, `--overwrite-edited-releases` includes the releases whose notes were edited after publishing, and
+ * `--path=<file>` names the changelog (`CHANGELOG.md` by default).
+ *
+ * @param cliArguments - The arguments after the command name.
+ * @returns The options.
+ */
+export declare function parseRewriteChangelogArguments(cliArguments: readonly string[]): RewriteChangelogOptions;
+/**
+ * Runs the `rewrite-changelog` command in the working directory, which is the repository root.
+ *
+ * @param cliArguments - The arguments after the command name.
+ * @param dependencies - The outside world. The real one when omitted.
+ * @returns The exit code: `1` when the arguments are wrong, git cannot be read or a release edit failed, `0` otherwise.
+ */
+export declare function runRewriteChangelogCli(cliArguments: readonly string[], dependencies?: RewriteChangelogDependencies): Promise<number>;

package/dist/lib/esm/changelog-rewrite-cli.mjs

@@ -0,0 +1,147 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { spawnSync } from "node:child_process";
+import {
+  readFileSync,
+  writeFileSync
+} from "node:fs";
+import process from "node:process";
+import {
+  rewriteChangelog,
+  rewriteReleaseNotes
+} from "./changelog-rewrite.mjs";
+const DEFAULT_CHANGELOG_PATH = "CHANGELOG.md";
+const KNOWN_ARGUMENTS = ["--write", "--releases", "--overwrite-edited-releases", "--path="];
+function createNodeRewriteChangelogDependencies() {
+  return {
+    exec(file, arguments_, input) {
+      return toResult(spawnSync(file, arguments_, { encoding: "utf-8", input, maxBuffer: Number.MAX_SAFE_INTEGER }));
+    },
+    log(text) {
+      process.stdout.write(`${text}
+`);
+    },
+    readFile(path) {
+      return readFileSync(path, "utf-8");
+    },
+    writeFile(path, content) {
+      writeFileSync(path, content, "utf-8");
+    }
+  };
+}
+function parseRewriteChangelogArguments(cliArguments) {
+  const unknown = cliArguments.filter((argument) => KNOWN_ARGUMENTS.every((known) => !(known.endsWith("=") ? argument.startsWith(known) : argument === known)));
+  if (unknown.length > 0) {
+    throw new Error(
+      `rewrite-changelog: unknown argument ${unknown.map((argument) => `"${argument}"`).join(", ")}. Known: ${KNOWN_ARGUMENTS.join(", ")}.`
+    );
+  }
+  const path = cliArguments.find((argument) => argument.startsWith("--path="))?.slice("--path=".length);
+  return {
+    changelogPath: path === void 0 || path === "" ? DEFAULT_CHANGELOG_PATH : path,
+    shouldOverwriteEditedReleases: cliArguments.includes("--overwrite-edited-releases"),
+    shouldRewriteReleases: cliArguments.includes("--releases"),
+    shouldWrite: cliArguments.includes("--write")
+  };
+}
+async function runRewriteChangelogCli(cliArguments, dependencies = createNodeRewriteChangelogDependencies()) {
+  try {
+    return await runRewriteChangelog(parseRewriteChangelogArguments(cliArguments), dependencies);
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    return 1;
+  }
+}
+function execOrThrow(dependencies, file, arguments_) {
+  const result = dependencies.exec(file, arguments_);
+  if (result.exitCode !== 0) {
+    throw new Error(`rewrite-changelog: ${file} ${arguments_.join(" ")} failed: ${result.stderr.trim()}`);
+  }
+  return result.stdout;
+}
+function readReleaseNotes(dependencies) {
+  const output = execOrThrow(dependencies, "gh", [
+    "api",
+    "--paginate",
+    "repos/{owner}/{repo}/releases?per_page=100",
+    "--jq",
+    '.[] | {tag: .tag_name, body: (.body // "")}'
+  ]);
+  const notesByTag = /* @__PURE__ */ new Map();
+  for (const line of output.split(/\r?\n/)) {
+    if (line.trim() === "") {
+      continue;
+    }
+    const release = JSON.parse(line);
+    notesByTag.set(release.tag, release.body);
+  }
+  return notesByTag;
+}
+function rewriteRelease(section, releaseNotes, options, dependencies) {
+  if (releaseNotes === void 0) {
+    dependencies.log(`release ${section.tag}: left alone, the repository has no GitHub release for it`);
+    return "ok";
+  }
+  const notes = rewriteReleaseNotes(releaseNotes, section, options.shouldOverwriteEditedReleases);
+  if (notes === null) {
+    dependencies.log(`release ${section.tag}: left alone, its notes are not the changelog section as it was (--overwrite-edited-releases rewrites it)`);
+    return "ok";
+  }
+  if (!options.shouldWrite) {
+    dependencies.log(`release ${section.tag}: would be rewritten`);
+    return "ok";
+  }
+  const edit = dependencies.exec("gh", ["release", "edit", section.tag, "--notes-file", "-"], notes);
+  if (edit.exitCode !== 0) {
+    dependencies.log(`release ${section.tag}: the edit FAILED: ${edit.stderr.trim()}`);
+    return "failed";
+  }
+  dependencies.log(`release ${section.tag}: rewritten`);
+  return "ok";
+}
+async function runRewriteChangelog(options, dependencies) {
+  const changelog = dependencies.readFile(options.changelogPath);
+  const tags = execOrThrow(dependencies, "git", ["tag", "--list"]).split(/\r?\n/).filter(Boolean);
+  const result = await rewriteChangelog(changelog, {
+    getCommitMessages: (fromTag, toTag) => Promise.resolve(
+      execOrThrow(dependencies, "git", ["log", "--format=%B", "--first-parent", "-z", fromTag === void 0 ? toTag : `${fromTag}..${toTag}`]).split("\0").filter((message) => message.trim() !== "")
+    ),
+    tags
+  });
+  for (const section of result.rewritten) {
+    const tagNote = section.tag === void 0 ? ", no tag, so grouped from the bullets alone" : "";
+    dependencies.log(`${section.version}: rewritten, ${String(section.matchedCount)} of ${String(section.oldBody.split("\n").length)} bullets matched to commits${tagNote}`);
+  }
+  for (const section of result.kept) {
+    dependencies.log(`${section.version}: kept, ${section.reason}`);
+  }
+  if (options.shouldWrite) {
+    dependencies.writeFile(options.changelogPath, result.content);
+    dependencies.log(`${options.changelogPath}: written`);
+  } else {
+    dependencies.log(`${options.changelogPath}: dry run, nothing written (pass --write to apply)`);
+  }
+  let isSuccess = true;
+  if (options.shouldRewriteReleases) {
+    const notesByTag = readReleaseNotes(dependencies);
+    for (const section of result.rewritten) {
+      if (section.tag !== void 0) {
+        isSuccess = rewriteRelease({ ...section, tag: section.tag }, notesByTag.get(section.tag), options, dependencies) === "ok" && isSuccess;
+      }
+    }
+  }
+  return isSuccess ? 0 : 1;
+}
+function toResult(result) {
+  return result.error ? { exitCode: 1, stderr: result.error.message, stdout: "" } : { exitCode: result.status ?? 1, stderr: result.stderr, stdout: result.stdout };
+}
+export {
+  createNodeRewriteChangelogDependencies,
+  parseRewriteChangelogArguments,
+  runRewriteChangelogCli
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/changelog-rewrite-cli.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The `rewrite-changelog` command: rewrites a project's published `CHANGELOG.md` sections, and optionally its GitHub\n * release notes, into the `grouped` layout, by wiring {@link rewriteChangelog} to the real git, `gh` and file system.\n *\n * It changes nothing unless `--write` is passed, so the first run is always a report of what it would do.\n */\n\nimport type { SpawnSyncReturns } from 'node:child_process';\n\nimport { spawnSync } from 'node:child_process';\nimport {\n  readFileSync,\n  writeFileSync\n} from 'node:fs';\nimport process from 'node:process';\n\nimport type { RewrittenChangelogSection } from './changelog-rewrite.ts';\n\nimport {\n  rewriteChangelog,\n  rewriteReleaseNotes\n} from './changelog-rewrite.ts';\n\n/**\n * The result of one command the `rewrite-changelog` command runs.\n */\nexport interface RewriteChangelogCommandResult {\n  /**\n   * The exit code.\n   */\n  readonly exitCode: number;\n\n  /**\n   * The standard error.\n   */\n  readonly stderr: string;\n\n  /**\n   * The standard output.\n   */\n  readonly stdout: string;\n}\n\n/**\n * The outside world of the `rewrite-changelog` command.\n */\nexport interface RewriteChangelogDependencies {\n  /**\n   * Runs a command in the working directory.\n   *\n   * @param file - The executable.\n   * @param arguments_ - Its arguments.\n   * @param input - What to write to its standard input.\n   * @returns The result.\n   */\n  readonly exec: (file: string, arguments_: readonly string[], input?: string) => RewriteChangelogCommandResult;\n\n  /**\n   * Writes one line of the report.\n   *\n   * @param text - The line.\n   */\n  readonly log: (text: string) => void;\n\n  /**\n   * Reads a text file.\n   *\n   * @param path - The path.\n   * @returns The content.\n   */\n  readonly readFile: (path: string) => string;\n\n  /**\n   * Writes a text file.\n   *\n   * @param path - The path.\n   * @param content - The content.\n   */\n  readonly writeFile: (path: string, content: string) => void;\n}\n\n/**\n * The options of the `rewrite-changelog` command.\n */\nexport interface RewriteChangelogOptions {\n  /**\n   * The `CHANGELOG.md` to rewrite.\n   */\n  readonly changelogPath: string;\n\n  /**\n   * Whether a GitHub release whose notes are no longer its changelog section as it was is rewritten too.\n   */\n  readonly shouldOverwriteEditedReleases: boolean;\n\n  /**\n   * Whether the GitHub release of each rewritten section is rewritten too.\n   */\n  readonly shouldRewriteReleases: boolean;\n\n  /**\n   * Whether anything is changed. Without it the command only reports.\n   */\n  readonly shouldWrite: boolean;\n}\n\ninterface ReleaseRecord {\n  readonly body: string;\n  readonly tag: string;\n}\n\ntype ReleaseRewriteOutcome = 'failed' | 'ok';\n\ninterface TaggedRewrittenSection extends RewrittenChangelogSection {\n  readonly tag: string;\n}\n\nconst DEFAULT_CHANGELOG_PATH = 'CHANGELOG.md';\n\nconst KNOWN_ARGUMENTS = ['--write', '--releases', '--overwrite-edited-releases', '--path='];\n\n/**\n * Creates the command's outside world: commands run with `spawnSync`, files read and written with `node:fs`, the\n * report written to stdout.\n *\n * @returns The dependencies.\n */\nexport function createNodeRewriteChangelogDependencies(): RewriteChangelogDependencies {\n  return {\n    exec(file, arguments_, input): RewriteChangelogCommandResult {\n      return toResult(spawnSync(file, arguments_, { encoding: 'utf-8', input, maxBuffer: Number.MAX_SAFE_INTEGER }));\n    },\n    log(text): void {\n      process.stdout.write(`${text}\\n`);\n    },\n    readFile(path): string {\n      return readFileSync(path, 'utf-8');\n    },\n    writeFile(path, content): void {\n      writeFileSync(path, content, 'utf-8');\n    }\n  };\n}\n\n/**\n * Builds the command's options from the command line: `--write` applies the changes, `--releases` adds the GitHub\n * releases to them, `--overwrite-edited-releases` includes the releases whose notes were edited after publishing, and\n * `--path=<file>` names the changelog (`CHANGELOG.md` by default).\n *\n * @param cliArguments - The arguments after the command name.\n * @returns The options.\n */\nexport function parseRewriteChangelogArguments(cliArguments: readonly string[]): RewriteChangelogOptions {\n  const unknown = cliArguments.filter((argument) => KNOWN_ARGUMENTS.every((known) => !(known.endsWith('=') ? argument.startsWith(known) : argument === known)));\n  if (unknown.length > 0) {\n    throw new Error(\n      `rewrite-changelog: unknown argument ${unknown.map((argument) => `\"${argument}\"`).join(', ')}. Known: ${KNOWN_ARGUMENTS.join(', ')}.`\n    );\n  }\n\n  const path = cliArguments.find((argument) => argument.startsWith('--path='))?.slice('--path='.length);\n  return {\n    changelogPath: path === undefined || path === '' ? DEFAULT_CHANGELOG_PATH : path,\n    shouldOverwriteEditedReleases: cliArguments.includes('--overwrite-edited-releases'),\n    shouldRewriteReleases: cliArguments.includes('--releases'),\n    shouldWrite: cliArguments.includes('--write')\n  };\n}\n\n/**\n * Runs the `rewrite-changelog` command in the working directory, which is the repository root.\n *\n * @param cliArguments - The arguments after the command name.\n * @param dependencies - The outside world. The real one when omitted.\n * @returns The exit code: `1` when the arguments are wrong, git cannot be read or a release edit failed, `0` otherwise.\n */\nexport async function runRewriteChangelogCli(\n  cliArguments: readonly string[],\n  dependencies: RewriteChangelogDependencies = createNodeRewriteChangelogDependencies()\n): Promise<number> {\n  try {\n    return await runRewriteChangelog(parseRewriteChangelogArguments(cliArguments), dependencies);\n  } catch (error) {\n    // A wrong argument or an unreadable repository is the user's to fix, so it gets its message rather than a stack trace.\n    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\\n`);\n    return 1;\n  }\n}\n\nfunction execOrThrow(dependencies: RewriteChangelogDependencies, file: string, arguments_: readonly string[]): string {\n  const result = dependencies.exec(file, arguments_);\n  if (result.exitCode !== 0) {\n    throw new Error(`rewrite-changelog: ${file} ${arguments_.join(' ')} failed: ${result.stderr.trim()}`);\n  }\n\n  return result.stdout;\n}\n\n/**\n * Reads the notes of every GitHub release of the repository in one paginated call, since one `gh release view` per\n * release takes minutes on a project with hundreds of them.\n *\n * @param dependencies - The outside world.\n * @returns The notes, by tag.\n */\nfunction readReleaseNotes(dependencies: RewriteChangelogDependencies): Map<string, string> {\n  const output = execOrThrow(dependencies, 'gh', [\n    'api',\n    '--paginate',\n    'repos/{owner}/{repo}/releases?per_page=100',\n    '--jq',\n    '.[] | {tag: .tag_name, body: (.body // \"\")}'\n  ]);\n  const notesByTag = new Map<string, string>();\n  for (const line of output.split(/\\r?\\n/)) {\n    if (line.trim() === '') {\n      continue;\n    }\n\n    const release = JSON.parse(line) as ReleaseRecord;\n    notesByTag.set(release.tag, release.body);\n  }\n\n  return notesByTag;\n}\n\nfunction rewriteRelease(\n  section: TaggedRewrittenSection,\n  releaseNotes: string | undefined,\n  options: RewriteChangelogOptions,\n  dependencies: RewriteChangelogDependencies\n): ReleaseRewriteOutcome {\n  if (releaseNotes === undefined) {\n    dependencies.log(`release ${section.tag}: left alone, the repository has no GitHub release for it`);\n    return 'ok';\n  }\n\n  const notes = rewriteReleaseNotes(releaseNotes, section, options.shouldOverwriteEditedReleases);\n  if (notes === null) {\n    dependencies.log(`release ${section.tag}: left alone, its notes are not the changelog section as it was (--overwrite-edited-releases rewrites it)`);\n    return 'ok';\n  }\n\n  if (!options.shouldWrite) {\n    dependencies.log(`release ${section.tag}: would be rewritten`);\n    return 'ok';\n  }\n\n  const edit = dependencies.exec('gh', ['release', 'edit', section.tag, '--notes-file', '-'], notes);\n  if (edit.exitCode !== 0) {\n    dependencies.log(`release ${section.tag}: the edit FAILED: ${edit.stderr.trim()}`);\n    return 'failed';\n  }\n\n  dependencies.log(`release ${section.tag}: rewritten`);\n  return 'ok';\n}\n\nasync function runRewriteChangelog(options: RewriteChangelogOptions, dependencies: RewriteChangelogDependencies): Promise<number> {\n  const changelog = dependencies.readFile(options.changelogPath);\n  const tags = execOrThrow(dependencies, 'git', ['tag', '--list']).split(/\\r?\\n/).filter(Boolean);\n  const result = await rewriteChangelog(changelog, {\n    getCommitMessages: (fromTag, toTag) =>\n      Promise.resolve(\n        execOrThrow(dependencies, 'git', ['log', '--format=%B', '--first-parent', '-z', fromTag === undefined ? toTag : `${fromTag}..${toTag}`])\n          .split('\\0')\n          .filter((message) => message.trim() !== '')\n      ),\n    tags\n  });\n\n  for (const section of result.rewritten) {\n    const tagNote = section.tag === undefined ? ', no tag, so grouped from the bullets alone' : '';\n    dependencies.log(`${section.version}: rewritten, ${String(section.matchedCount)} of ${String(section.oldBody.split('\\n').length)} bullets matched to commits${tagNote}`);\n  }\n\n  for (const section of result.kept) {\n    dependencies.log(`${section.version}: kept, ${section.reason}`);\n  }\n\n  if (options.shouldWrite) {\n    dependencies.writeFile(options.changelogPath, result.content);\n    dependencies.log(`${options.changelogPath}: written`);\n  } else {\n    dependencies.log(`${options.changelogPath}: dry run, nothing written (pass --write to apply)`);\n  }\n\n  let isSuccess = true;\n  if (options.shouldRewriteReleases) {\n    const notesByTag = readReleaseNotes(dependencies);\n    for (const section of result.rewritten) {\n      if (section.tag !== undefined) {\n        isSuccess = rewriteRelease({ ...section, tag: section.tag }, notesByTag.get(section.tag), options, dependencies) === 'ok' && isSuccess;\n      }\n    }\n  }\n\n  return isSuccess ? 0 : 1;\n}\n\nfunction toResult(result: SpawnSyncReturns<string>): RewriteChangelogCommandResult {\n  return result.error\n    ? { exitCode: 1, stderr: result.error.message, stdout: '' }\n    : { exitCode: result.status ?? 1, stderr: result.stderr, stdout: result.stdout };\n}\n"],
  "mappings": ";;;;;AAWA,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,OAAO,aAAa;AAIpB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAgGP,MAAM,yBAAyB;AAE/B,MAAM,kBAAkB,CAAC,WAAW,cAAc,+BAA+B,SAAS;AAQnF,SAAS,yCAAuE;AACrF,SAAO;AAAA,IACL,KAAK,MAAM,YAAY,OAAsC;AAC3D,aAAO,SAAS,UAAU,MAAM,YAAY,EAAE,UAAU,SAAS,OAAO,WAAW,OAAO,iBAAiB,CAAC,CAAC;AAAA,IAC/G;AAAA,IACA,IAAI,MAAY;AACd,cAAQ,OAAO,MAAM,GAAG,IAAI;AAAA,CAAI;AAAA,IAClC;AAAA,IACA,SAAS,MAAc;AACrB,aAAO,aAAa,MAAM,OAAO;AAAA,IACnC;AAAA,IACA,UAAU,MAAM,SAAe;AAC7B,oBAAc,MAAM,SAAS,OAAO;AAAA,IACtC;AAAA,EACF;AACF;AAUO,SAAS,+BAA+B,cAA0D;AACvG,QAAM,UAAU,aAAa,OAAO,CAAC,aAAa,gBAAgB,MAAM,CAAC,UAAU,EAAE,MAAM,SAAS,GAAG,IAAI,SAAS,WAAW,KAAK,IAAI,aAAa,MAAM,CAAC;AAC5J,MAAI,QAAQ,SAAS,GAAG;AACtB,UAAM,IAAI;AAAA,MACR,uCAAuC,QAAQ,IAAI,CAAC,aAAa,IAAI,QAAQ,GAAG,EAAE,KAAK,IAAI,CAAC,YAAY,gBAAgB,KAAK,IAAI,CAAC;AAAA,IACpI;AAAA,EACF;AAEA,QAAM,OAAO,aAAa,KAAK,CAAC,aAAa,SAAS,WAAW,SAAS,CAAC,GAAG,MAAM,UAAU,MAAM;AACpG,SAAO;AAAA,IACL,eAAe,SAAS,UAAa,SAAS,KAAK,yBAAyB;AAAA,IAC5E,+BAA+B,aAAa,SAAS,6BAA6B;AAAA,IAClF,uBAAuB,aAAa,SAAS,YAAY;AAAA,IACzD,aAAa,aAAa,SAAS,SAAS;AAAA,EAC9C;AACF;AASA,eAAsB,uBACpB,cACA,eAA6C,uCAAuC,GACnE;AACjB,MAAI;AACF,WAAO,MAAM,oBAAoB,+BAA+B,YAAY,GAAG,YAAY;AAAA,EAC7F,SAAS,OAAO;AAEd,YAAQ,OAAO,MAAM,GAAG,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC;AAAA,CAAI;AAClF,WAAO;AAAA,EACT;AACF;AAEA,SAAS,YAAY,cAA4C,MAAc,YAAuC;AACpH,QAAM,SAAS,aAAa,KAAK,MAAM,UAAU;AACjD,MAAI,OAAO,aAAa,GAAG;AACzB,UAAM,IAAI,MAAM,sBAAsB,IAAI,IAAI,WAAW,KAAK,GAAG,CAAC,YAAY,OAAO,OAAO,KAAK,CAAC,EAAE;AAAA,EACtG;AAEA,SAAO,OAAO;AAChB;AASA,SAAS,iBAAiB,cAAiE;AACzF,QAAM,SAAS,YAAY,cAAc,MAAM;AAAA,IAC7C;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACD,QAAM,aAAa,oBAAI,IAAoB;AAC3C,aAAW,QAAQ,OAAO,MAAM,OAAO,GAAG;AACxC,QAAI,KAAK,KAAK,MAAM,IAAI;AACtB;AAAA,IACF;AAEA,UAAM,UAAU,KAAK,MAAM,IAAI;AAC/B,eAAW,IAAI,QAAQ,KAAK,QAAQ,IAAI;AAAA,EAC1C;AAEA,SAAO;AACT;AAEA,SAAS,eACP,SACA,cACA,SACA,cACuB;AACvB,MAAI,iBAAiB,QAAW;AAC9B,iBAAa,IAAI,WAAW,QAAQ,GAAG,2DAA2D;AAClG,WAAO;AAAA,EACT;AAEA,QAAM,QAAQ,oBAAoB,cAAc,SAAS,QAAQ,6BAA6B;AAC9F,MAAI,UAAU,MAAM;AAClB,iBAAa,IAAI,WAAW,QAAQ,GAAG,2GAA2G;AAClJ,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,QAAQ,aAAa;AACxB,iBAAa,IAAI,WAAW,QAAQ,GAAG,sBAAsB;AAC7D,WAAO;AAAA,EACT;AAEA,QAAM,OAAO,aAAa,KAAK,MAAM,CAAC,WAAW,QAAQ,QAAQ,KAAK,gBAAgB,GAAG,GAAG,KAAK;AACjG,MAAI,KAAK,aAAa,GAAG;AACvB,iBAAa,IAAI,WAAW,QAAQ,GAAG,sBAAsB,KAAK,OAAO,KAAK,CAAC,EAAE;AACjF,WAAO;AAAA,EACT;AAEA,eAAa,IAAI,WAAW,QAAQ,GAAG,aAAa;AACpD,SAAO;AACT;AAEA,eAAe,oBAAoB,SAAkC,cAA6D;AAChI,QAAM,YAAY,aAAa,SAAS,QAAQ,aAAa;AAC7D,QAAM,OAAO,YAAY,cAAc,OAAO,CAAC,OAAO,QAAQ,CAAC,EAAE,MAAM,OAAO,EAAE,OAAO,OAAO;AAC9F,QAAM,SAAS,MAAM,iBAAiB,WAAW;AAAA,IAC/C,mBAAmB,CAAC,SAAS,UAC3B,QAAQ;AAAA,MACN,YAAY,cAAc,OAAO,CAAC,OAAO,eAAe,kBAAkB,MAAM,YAAY,SAAY,QAAQ,GAAG,OAAO,KAAK,KAAK,EAAE,CAAC,EACpI,MAAM,IAAI,EACV,OAAO,CAAC,YAAY,QAAQ,KAAK,MAAM,EAAE;AAAA,IAC9C;AAAA,IACF;AAAA,EACF,CAAC;AAED,aAAW,WAAW,OAAO,WAAW;AACtC,UAAM,UAAU,QAAQ,QAAQ,SAAY,gDAAgD;AAC5F,iBAAa,IAAI,GAAG,QAAQ,OAAO,gBAAgB,OAAO,QAAQ,YAAY,CAAC,OAAO,OAAO,QAAQ,QAAQ,MAAM,IAAI,EAAE,MAAM,CAAC,8BAA8B,OAAO,EAAE;AAAA,EACzK;AAEA,aAAW,WAAW,OAAO,MAAM;AACjC,iBAAa,IAAI,GAAG,QAAQ,OAAO,WAAW,QAAQ,MAAM,EAAE;AAAA,EAChE;AAEA,MAAI,QAAQ,aAAa;AACvB,iBAAa,UAAU,QAAQ,eAAe,OAAO,OAAO;AAC5D,iBAAa,IAAI,GAAG,QAAQ,aAAa,WAAW;AAAA,EACtD,OAAO;AACL,iBAAa,IAAI,GAAG,QAAQ,aAAa,oDAAoD;AAAA,EAC/F;AAEA,MAAI,YAAY;AAChB,MAAI,QAAQ,uBAAuB;AACjC,UAAM,aAAa,iBAAiB,YAAY;AAChD,eAAW,WAAW,OAAO,WAAW;AACtC,UAAI,QAAQ,QAAQ,QAAW;AAC7B,oBAAY,eAAe,EAAE,GAAG,SAAS,KAAK,QAAQ,IAAI,GAAG,WAAW,IAAI,QAAQ,GAAG,GAAG,SAAS,YAAY,MAAM,QAAQ;AAAA,MAC/H;AAAA,IACF;AAAA,EACF;AAEA,SAAO,YAAY,IAAI;AACzB;AAEA,SAAS,SAAS,QAAiE;AACjF,SAAO,OAAO,QACV,EAAE,UAAU,GAAG,QAAQ,OAAO,MAAM,SAAS,QAAQ,GAAG,IACxD,EAAE,UAAU,OAAO,UAAU,GAAG,QAAQ,OAAO,QAAQ,QAAQ,OAAO,OAAO;AACnF;",
  "names": []
}
