@savvy-web/silk-effects 0.6.0 → 1.0.0

package/changesets/markdownlint/rules/dependency-table-format.js

@@ -0,0 +1,170 @@
+import { RULE_DOCS } from "../../constants.js";
+import { getHeadingLevel, getHeadingText } from "./utils.js";
+
+//#region src/changesets/markdownlint/rules/dependency-table-format.ts
+const EM_DASH = "—";
+const VALID_TYPES = new Set([
+	"dependency",
+	"devDependency",
+	"peerDependency",
+	"optionalDependency",
+	"workspace",
+	"config"
+]);
+const VALID_ACTIONS = new Set([
+	"added",
+	"updated",
+	"removed"
+]);
+const EXPECTED_HEADERS = [
+	"dependency",
+	"type",
+	"action",
+	"from",
+	"to"
+];
+const VERSION_RE = /^(\u2014|[~^]?\d+\.\d+\.\d+(?:[-+.][\w.+-]*)?)$/;
+/**
+* Extract text from a `tableHeader` or `tableData` cell token.
+*
+* The cell contains: `tableCellDivider`, whitespace, `tableContent`, whitespace.
+* The `tableContent` token has a `.text` property with the cell value.
+*
+* @param cell - A GFM table cell token (header or data)
+* @returns The trimmed text content of the cell, or an empty string
+*
+* @internal
+*/
+function getCellText(cell) {
+	const content = cell.children.find((c) => c.type === "tableContent");
+	return content ? content.text.trim() : "";
+}
+/**
+* Extract all cell texts from a `tableRow` token.
+*
+* @param row - A GFM `tableRow` token
+* @returns An array of trimmed cell text values
+*
+* @internal
+*/
+function getRowCells(row) {
+	return row.children.filter((c) => c.type === "tableHeader" || c.type === "tableData").map(getCellText);
+}
+/**
+* The markdownlint `Rule` object for CSH005 (`changeset-dependency-table-format`).
+*
+* @public
+*/
+const DependencyTableFormatRule = {
+	names: ["changeset-dependency-table-format", "CSH005"],
+	description: "Dependencies section must contain a valid dependency table",
+	tags: ["changeset"],
+	parser: "micromark",
+	function: function CSH005(params, onError) {
+		const tokens = params.parsers.micromark.tokens;
+		for (let i = 0; i < tokens.length; i++) {
+			const token = tokens[i];
+			if (token.type !== "atxHeading") continue;
+			if (getHeadingLevel(token) !== 2) continue;
+			if (getHeadingText(token).toLowerCase() !== "dependencies") continue;
+			const headingLine = token.startLine;
+			let tableToken = null;
+			for (let j = i + 1; j < tokens.length; j++) {
+				const next = tokens[j];
+				if (next.type === "lineEnding" || next.type === "lineEndingBlank") continue;
+				if (next.type === "atxHeading") break;
+				if (next.type === "table") tableToken = next;
+				break;
+			}
+			if (tableToken === null) {
+				onError({
+					lineNumber: headingLine,
+					detail: `Dependencies section must contain a table, not a list or paragraph. See: ${RULE_DOCS.CSH005}`
+				});
+				continue;
+			}
+			const tableHead = tableToken.children.find((c) => c.type === "tableHead");
+			if (!tableHead) {
+				onError({
+					lineNumber: tableToken.startLine,
+					detail: `Dependencies table is missing a header row. See: ${RULE_DOCS.CSH005}`
+				});
+				continue;
+			}
+			const headerRow = tableHead.children.find((c) => c.type === "tableRow");
+			if (!headerRow) {
+				onError({
+					lineNumber: tableToken.startLine,
+					detail: `Dependencies table is missing a header row. See: ${RULE_DOCS.CSH005}`
+				});
+				continue;
+			}
+			const headers = getRowCells(headerRow).map((h) => h.toLowerCase());
+			if (headers.length !== EXPECTED_HEADERS.length || !headers.every((h, idx) => h === EXPECTED_HEADERS[idx])) {
+				onError({
+					lineNumber: headerRow.startLine,
+					detail: `Dependencies table must have columns: Dependency, Type, Action, From, To. Got: ${headers.join(", ")}. See: ${RULE_DOCS.CSH005}`
+				});
+				continue;
+			}
+			const tableBody = tableToken.children.find((c) => c.type === "tableBody");
+			if (!tableBody) {
+				onError({
+					lineNumber: tableToken.startLine,
+					detail: `Dependencies table must have at least one data row. See: ${RULE_DOCS.CSH005}`
+				});
+				continue;
+			}
+			const dataRows = tableBody.children.filter((c) => c.type === "tableRow");
+			if (dataRows.length === 0) {
+				onError({
+					lineNumber: tableToken.startLine,
+					detail: `Dependencies table must have at least one data row. See: ${RULE_DOCS.CSH005}`
+				});
+				continue;
+			}
+			for (const row of dataRows) {
+				const cells = getRowCells(row);
+				if (cells.length < 5) {
+					onError({
+						lineNumber: row.startLine,
+						detail: `Dependencies table row has too few columns (expected 5, got ${cells.length}). See: ${RULE_DOCS.CSH005}`
+					});
+					continue;
+				}
+				const [dependency, type, action, from, to] = cells;
+				if (!dependency) onError({
+					lineNumber: row.startLine,
+					detail: `Dependencies table row has an empty 'Dependency' cell. See: ${RULE_DOCS.CSH005}`
+				});
+				if (!VALID_TYPES.has(type)) onError({
+					lineNumber: row.startLine,
+					detail: `Invalid dependency type '${type}'. Valid types are: ${[...VALID_TYPES].join(", ")}. See: ${RULE_DOCS.CSH005}`
+				});
+				if (!VALID_ACTIONS.has(action)) onError({
+					lineNumber: row.startLine,
+					detail: `Invalid dependency action '${action}'. Valid actions are: ${[...VALID_ACTIONS].join(", ")}. See: ${RULE_DOCS.CSH005}`
+				});
+				if (from && !VERSION_RE.test(from)) onError({
+					lineNumber: row.startLine,
+					detail: `Invalid 'from' value '${from}'. Must be a semver string or em dash (\u2014). See: ${RULE_DOCS.CSH005}`
+				});
+				if (to && !VERSION_RE.test(to)) onError({
+					lineNumber: row.startLine,
+					detail: `Invalid 'to' value '${to}'. Must be a semver string or em dash (\u2014). See: ${RULE_DOCS.CSH005}`
+				});
+				if (action === "added" && from !== EM_DASH) onError({
+					lineNumber: row.startLine,
+					detail: `'from' must be '\u2014' when action is 'added' (got '${from}'). See: ${RULE_DOCS.CSH005}`
+				});
+				if (action === "removed" && to !== EM_DASH) onError({
+					lineNumber: row.startLine,
+					detail: `'to' must be '\u2014' when action is 'removed' (got '${to}'). See: ${RULE_DOCS.CSH005}`
+				});
+			}
+		}
+	}
+};
+
+//#endregion
+export { DependencyTableFormatRule };

package/changesets/markdownlint/rules/heading-hierarchy.js

@@ -0,0 +1,61 @@
+import { RULE_DOCS } from "../../constants.js";
+import { getHeadingLevel } from "./utils.js";
+
+//#region src/changesets/markdownlint/rules/heading-hierarchy.ts
+/**
+* markdownlint rule: `changeset-heading-hierarchy` (CSH001).
+*
+* Validates heading structure in changeset markdown files by inspecting
+* `atxHeading` micromark tokens for three constraints:
+*
+* 1. **No h1 headings** -- h1 is reserved for the version title generated by
+*    the changelog formatter.
+* 2. **Start at h2** -- the first heading in a changeset must be h2.
+* 3. **No depth skips** -- heading levels must increase sequentially
+*    (h2 then h3, not h2 then h4).
+*
+* @remarks
+* This rule mirrors the remark-lint rule `remarkLintHeadingHierarchy` but uses
+* markdownlint's micromark token API so it can run inside markdownlint-cli2 and
+* the VS Code markdownlint extension.
+*
+* @example
+* ```json
+* {
+*   "changeset-heading-hierarchy": true
+* }
+* ```
+*
+* @see {@link https://github.com/savvy-web/changesets/blob/main/docs/rules/CSH001.md | CSH001 rule documentation}
+* @see `src/remark/rules/heading-hierarchy.ts` for the corresponding remark-lint rule
+*
+* @public
+*/
+const HeadingHierarchyRule = {
+	names: ["changeset-heading-hierarchy", "CSH001"],
+	description: "Heading hierarchy must start at h2 with no h1 or depth skips",
+	tags: ["changeset"],
+	parser: "micromark",
+	function: function CSH001(params, onError) {
+		let prevDepth = 0;
+		for (const token of params.parsers.micromark.tokens) {
+			if (token.type !== "atxHeading") continue;
+			const depth = getHeadingLevel(token);
+			if (depth === 1) {
+				onError({
+					lineNumber: token.startLine,
+					detail: `h1 headings are not allowed in changeset files. Use h2 (##) for top-level sections like "## Features" or "## Bug Fixes". h1 is reserved for the version title generated by the changelog formatter. See: ${RULE_DOCS.CSH001}`
+				});
+				continue;
+			}
+			if (prevDepth > 0 && depth > prevDepth + 1) onError({
+				lineNumber: token.startLine,
+				detail: `Heading level skipped: expected h${prevDepth + 1} or lower, found h${depth}. Headings must increase sequentially (h2 → h3 → h4). Add the missing intermediate level or reduce this heading's depth. See: ${RULE_DOCS.CSH001}`
+			});
+			prevDepth = depth;
+		}
+	}
+};
+
+//#endregion
+export { HeadingHierarchyRule };

package/changesets/markdownlint/rules/required-sections.js

@@ -0,0 +1,54 @@
+import { allHeadings, isValidHeading } from "../../categories/index.js";
+import { RULE_DOCS } from "../../constants.js";
+import { getHeadingLevel, getHeadingText } from "./utils.js";
+
+//#region src/changesets/markdownlint/rules/required-sections.ts
+/**
+* markdownlint rule: `changeset-required-sections` (CSH002).
+*
+* Validates that every h2 (`atxHeading` with depth 2) in a changeset markdown
+* file matches a known category heading from the category system. When an
+* unrecognized heading is found, the error detail lists all valid headings.
+*
+* @remarks
+* Heading comparison is case-insensitive. The set of valid headings is provided
+* by `allHeadings()` and `isValidHeading()` from the category system
+* (`src/categories/index.ts`). This rule inspects `atxHeading` micromark
+* tokens and extracts their text via the {@link getHeadingText} utility.
+*
+* This rule mirrors the remark-lint rule `remarkLintRequiredSections` but uses
+* markdownlint's micromark token API so it can run inside markdownlint-cli2 and
+* the VS Code markdownlint extension.
+*
+* @example
+* ```json
+* {
+*   "changeset-required-sections": true
+* }
+* ```
+*
+* @see {@link https://github.com/savvy-web/changesets/blob/main/docs/rules/CSH002.md | CSH002 rule documentation}
+* @see `src/remark/rules/required-sections.ts` for the corresponding remark-lint rule
+*
+* @public
+*/
+const RequiredSectionsRule = {
+	names: ["changeset-required-sections", "CSH002"],
+	description: "Section headings must match known changeset categories",
+	tags: ["changeset"],
+	parser: "micromark",
+	function: function CSH002(params, onError) {
+		for (const token of params.parsers.micromark.tokens) {
+			if (token.type !== "atxHeading") continue;
+			if (getHeadingLevel(token) !== 2) continue;
+			const text = getHeadingText(token);
+			if (!isValidHeading(text)) onError({
+				lineNumber: token.startLine,
+				detail: `Unknown section "${text}". Valid h2 headings are: ${allHeadings().join(", ")}. Heading comparison is case-insensitive. See: ${RULE_DOCS.CSH002}`
+			});
+		}
+	}
+};
+
+//#endregion
+export { RequiredSectionsRule };

package/changesets/markdownlint/rules/uncategorized-content.js

@@ -0,0 +1,54 @@
+import { RULE_DOCS } from "../../constants.js";
+import { getHeadingLevel } from "./utils.js";
+
+//#region src/changesets/markdownlint/rules/uncategorized-content.ts
+/**
+* markdownlint rule: `changeset-uncategorized-content` (CSH004).
+*
+* Detects content that appears before the first h2 heading in a changeset
+* markdown file. All substantive content must be placed under a categorized
+* section (`## heading`).
+*
+* @remarks
+* The rule iterates over the top-level micromark token stream and stops at the
+* first `atxHeading` with depth 2. Any token encountered before that heading
+* that is not a `lineEnding`, `lineEndingBlank`, or `htmlFlow` (HTML comments)
+* triggers an error. This ensures that changeset content is always grouped
+* under a recognized category heading.
+*
+* This rule mirrors the remark-lint rule `remarkLintUncategorizedContent` but
+* uses markdownlint's micromark token API so it can run inside
+* markdownlint-cli2 and the VS Code markdownlint extension.
+*
+* @example
+* ```json
+* {
+*   "changeset-uncategorized-content": true
+* }
+* ```
+*
+* @see {@link https://github.com/savvy-web/changesets/blob/main/docs/rules/CSH004.md | CSH004 rule documentation}
+* @see `src/remark/rules/uncategorized-content.ts` for the corresponding remark-lint rule
+*
+* @public
+*/
+const UncategorizedContentRule = {
+	names: ["changeset-uncategorized-content", "CSH004"],
+	description: "All content must be placed under a category heading (## heading)",
+	tags: ["changeset"],
+	parser: "micromark",
+	function: function CSH004(params, onError) {
+		const tokens = params.parsers.micromark.tokens;
+		for (const token of tokens) {
+			if (token.type === "atxHeading" && getHeadingLevel(token) === 2) break;
+			if (token.type === "lineEnding" || token.type === "lineEndingBlank" || token.type === "htmlFlow") continue;
+			if (token.type !== "atxHeading") onError({
+				lineNumber: token.startLine,
+				detail: `Content must be placed under a category heading (## heading). Move this content under an appropriate section like "## Features" or "## Bug Fixes". If it doesn't fit an existing category, use "## Other". See: ${RULE_DOCS.CSH004}`
+			});
+		}
+	}
+};
+
+//#endregion
+export { UncategorizedContentRule };

package/changesets/markdownlint/rules/utils.js

@@ -0,0 +1,30 @@
+import { RULE_DOCS } from "../../constants.js";
+
+//#region src/changesets/markdownlint/rules/utils.ts
+/**
+* Get the heading level (1-6) from an `atxHeading` token.
+*
+* @param heading - The `atxHeading` micromark token
+* @returns The heading depth (number of `#` characters), or 0 if no sequence found
+*
+* @internal
+*/
+function getHeadingLevel(heading) {
+	const sequence = heading.children.find((c) => c.type === "atxHeadingSequence");
+	return sequence ? sequence.text.length : 0;
+}
+/**
+* Get the plain text content of an `atxHeading` token.
+*
+* @param heading - The `atxHeading` micromark token
+* @returns The heading text, or empty string if no text token found
+*
+* @internal
+*/
+function getHeadingText(heading) {
+	const textToken = heading.children.find((c) => c.type === "atxHeadingText");
+	return textToken ? textToken.text : "";
+}
+
+//#endregion
+export { getHeadingLevel, getHeadingText };

package/changesets/remark/plugins/aggregate-dependency-tables.js

@@ -0,0 +1,47 @@
+import { collapseDependencyRows, parseDependencyTable, serializeDependencyTable, sortDependencyRows } from "../../utils/dependency-table.js";
+import { getBlockSections, getHeadingText, getVersionBlocks } from "../../utils/version-blocks.js";
+
+//#region src/changesets/remark/plugins/aggregate-dependency-tables.ts
+const AggregateDependencyTablesPlugin = () => {
+	return (tree) => {
+		const blocks = getVersionBlocks(tree);
+		for (let b = blocks.length - 1; b >= 0; b--) {
+			const depSections = getBlockSections(tree, blocks[b]).filter((s) => getHeadingText(s.heading).toLowerCase() === "dependencies");
+			if (depSections.length === 0) continue;
+			const allRows = [];
+			const legacyContent = [];
+			for (const section of depSections) for (const node of section.contentNodes) if (node.type === "table") try {
+				const rows = parseDependencyTable(node);
+				allRows.push(...rows);
+			} catch {
+				legacyContent.push(node);
+			}
+			else legacyContent.push(node);
+			const collapsed = sortDependencyRows(collapseDependencyRows(allRows));
+			const indicesToRemove = [];
+			for (const section of depSections) {
+				indicesToRemove.push(section.headingIndex);
+				for (let c = 0; c < section.contentNodes.length; c++) indicesToRemove.push(section.headingIndex + 1 + c);
+			}
+			indicesToRemove.sort((a, b) => b - a);
+			for (const idx of indicesToRemove) tree.children.splice(idx, 1);
+			if (collapsed.length === 0 && legacyContent.length === 0) continue;
+			const insertAt = depSections[0].headingIndex;
+			const newNodes = [];
+			newNodes.push({
+				type: "heading",
+				depth: 3,
+				children: [{
+					type: "text",
+					value: "Dependencies"
+				}]
+			});
+			if (collapsed.length > 0) newNodes.push(serializeDependencyTable(collapsed));
+			newNodes.push(...legacyContent);
+			tree.children.splice(insertAt, 0, ...newNodes);
+		}
+	};
+};
+
+//#endregion
+export { AggregateDependencyTablesPlugin };

package/changesets/remark/plugins/contributor-footnotes.js

@@ -0,0 +1,123 @@
+import { getVersionBlocks } from "../../utils/version-blocks.js";
+import { visit } from "unist-util-visit";
+
+//#region src/changesets/remark/plugins/contributor-footnotes.ts
+/**
+* Pattern matching `Thanks @user!` at end of text.
+*
+* @internal
+*/
+const ATTRIBUTION_PLAIN_RE = /\s*Thanks @(\w[\w-]*)!$/;
+/**
+* Try to extract a linked attribution from the end of a paragraph's children.
+* Pattern: text "...Thanks " + link "\@user" + text "!"
+*
+* @param children - The phrasing content children of a paragraph node
+* @returns The contributor and the index to start removal from, or `undefined`
+*
+* @internal
+*/
+function extractLinkedAttribution(children) {
+	if (children.length < 3) return void 0;
+	const last = children[children.length - 1];
+	const secondLast = children[children.length - 2];
+	const thirdLast = children[children.length - 3];
+	if (last.type !== "text" || last.value !== "!") return void 0;
+	if (secondLast.type !== "link") return void 0;
+	const linkNode = secondLast;
+	if (linkNode.children.length !== 1 || linkNode.children[0].type !== "text") return void 0;
+	const linkText = linkNode.children[0].value;
+	if (!linkText.startsWith("@")) return void 0;
+	const username = linkText.slice(1);
+	if (thirdLast.type !== "text") return void 0;
+	const textNode = thirdLast;
+	if (!/\s*Thanks $/.test(textNode.value)) return void 0;
+	return {
+		contributor: {
+			username,
+			url: linkNode.url
+		},
+		removeFrom: children.length - 3
+	};
+}
+const ContributorFootnotesPlugin = () => {
+	return (tree) => {
+		const blocks = getVersionBlocks(tree);
+		for (let b = blocks.length - 1; b >= 0; b--) {
+			const block = blocks[b];
+			const contributors = /* @__PURE__ */ new Map();
+			for (let i = block.startIndex; i < block.endIndex; i++) {
+				const node = tree.children[i];
+				if (node.type !== "list") continue;
+				visit(node, "paragraph", (para) => {
+					const linked = extractLinkedAttribution(para.children);
+					if (linked) {
+						const key = linked.contributor.username.toLowerCase();
+						if (!contributors.has(key)) contributors.set(key, linked.contributor);
+						const textNode = para.children[linked.removeFrom];
+						textNode.value = textNode.value.replace(/\s*Thanks $/, "");
+						para.children.splice(linked.removeFrom + 1, 2);
+						if (textNode.value === "") para.children.splice(linked.removeFrom, 1);
+						return;
+					}
+					const last = para.children[para.children.length - 1];
+					if (last?.type === "text") {
+						const textNode = last;
+						const match = textNode.value.match(ATTRIBUTION_PLAIN_RE);
+						if (match) {
+							const username = match[1];
+							const key = username.toLowerCase();
+							if (!contributors.has(key)) contributors.set(key, {
+								username,
+								url: void 0
+							});
+							textNode.value = textNode.value.replace(ATTRIBUTION_PLAIN_RE, "");
+						}
+					}
+				});
+			}
+			if (contributors.size === 0) continue;
+			const sorted = [...contributors.values()].sort((a, b) => a.username.toLowerCase().localeCompare(b.username.toLowerCase()));
+			const phrasingChildren = [];
+			phrasingChildren.push({
+				type: "text",
+				value: "Thanks to "
+			});
+			for (let i = 0; i < sorted.length; i++) {
+				const contrib = sorted[i];
+				if (i > 0 && sorted.length > 2) phrasingChildren.push({
+					type: "text",
+					value: ", "
+				});
+				if (i > 0 && i === sorted.length - 1) phrasingChildren.push({
+					type: "text",
+					value: sorted.length === 2 ? " and " : "and "
+				});
+				if (contrib.url) phrasingChildren.push({
+					type: "link",
+					url: contrib.url,
+					children: [{
+						type: "text",
+						value: `@${contrib.username}`
+					}]
+				});
+				else phrasingChildren.push({
+					type: "text",
+					value: `@${contrib.username}`
+				});
+			}
+			phrasingChildren.push({
+				type: "text",
+				value: " for their contributions!"
+			});
+			const paragraph = {
+				type: "paragraph",
+				children: phrasingChildren
+			};
+			tree.children.splice(block.endIndex, 0, paragraph);
+		}
+	};
+};
+
+//#endregion
+export { ContributorFootnotesPlugin };

package/changesets/remark/plugins/deduplicate-items.js

@@ -0,0 +1,30 @@
+import { getBlockSections, getVersionBlocks } from "../../utils/version-blocks.js";
+import { toString } from "mdast-util-to-string";
+
+//#region src/changesets/remark/plugins/deduplicate-items.ts
+const DeduplicateItemsPlugin = () => {
+	return (tree) => {
+		const blocks = getVersionBlocks(tree);
+		for (const block of blocks) {
+			const sections = getBlockSections(tree, block);
+			for (const section of sections) for (const node of section.contentNodes) {
+				if (node.type !== "list") continue;
+				const list = node;
+				const seen = /* @__PURE__ */ new Set();
+				list.children = list.children.filter((item) => {
+					const text = toString(item);
+					if (seen.has(text)) return false;
+					seen.add(text);
+					return true;
+				});
+			}
+		}
+		tree.children = tree.children.filter((node) => {
+			if (node.type === "list") return node.children.length > 0;
+			return true;
+		});
+	};
+};
+
+//#endregion
+export { DeduplicateItemsPlugin };

package/changesets/remark/plugins/issue-link-refs.js

@@ -0,0 +1,58 @@
+import { getVersionBlocks } from "../../utils/version-blocks.js";
+import { SKIP, visit } from "unist-util-visit";
+
+//#region src/changesets/remark/plugins/issue-link-refs.ts
+/**
+* Pattern matching issue numbers like `#123`.
+*
+* @internal
+*/
+const ISSUE_RE = /^#\d+$/;
+const IssueLinkRefsPlugin = () => {
+	return (tree) => {
+		const blocks = getVersionBlocks(tree);
+		for (let b = blocks.length - 1; b >= 0; b--) {
+			const block = blocks[b];
+			const definitions = /* @__PURE__ */ new Map();
+			for (let i = block.startIndex; i < block.endIndex; i++) {
+				const node = tree.children[i];
+				visit(node, "link", (linkNode, index, parent) => {
+					if (!parent || index === void 0) return;
+					if (linkNode.children.length !== 1 || linkNode.children[0].type !== "text") return;
+					const text = linkNode.children[0].value;
+					if (!ISSUE_RE.test(text)) return;
+					const label = text;
+					if (!definitions.has(label)) definitions.set(label, {
+						label,
+						url: linkNode.url
+					});
+					const ref = {
+						type: "linkReference",
+						identifier: label,
+						label,
+						referenceType: "full",
+						children: [{
+							type: "text",
+							value: label
+						}]
+					};
+					parent.children[index] = ref;
+					return SKIP;
+				});
+			}
+			if (definitions.size === 0) continue;
+			const defNodes = [...definitions.values()].sort((a, b) => {
+				return Number.parseInt(a.label.slice(1), 10) - Number.parseInt(b.label.slice(1), 10);
+			}).map((def) => ({
+				type: "definition",
+				identifier: def.label,
+				label: def.label,
+				url: def.url
+			}));
+			tree.children.splice(block.endIndex, 0, ...defNodes);
+		}
+	};
+};
+
+//#endregion
+export { IssueLinkRefsPlugin };

package/changesets/remark/plugins/merge-sections.js

@@ -0,0 +1,43 @@
+import { fromHeading } from "../../categories/index.js";
+import { getBlockSections, getHeadingText, getVersionBlocks } from "../../utils/version-blocks.js";
+
+//#region src/changesets/remark/plugins/merge-sections.ts
+const MergeSectionsPlugin = () => {
+	return (tree) => {
+		const blocks = getVersionBlocks(tree);
+		for (let b = blocks.length - 1; b >= 0; b--) {
+			const sections = getBlockSections(tree, blocks[b]);
+			if (sections.length <= 1) continue;
+			const groups = /* @__PURE__ */ new Map();
+			for (let s = 0; s < sections.length; s++) {
+				const text = getHeadingText(sections[s].heading);
+				const category = fromHeading(text);
+				const key = category ? category.heading.toLowerCase() : text.toLowerCase();
+				const existing = groups.get(key);
+				if (existing) existing.push(s);
+				else groups.set(key, [s]);
+			}
+			const indicesToRemove = [];
+			for (const indices of groups.values()) {
+				if (indices.length <= 1) continue;
+				const target = sections[indices[0]];
+				const targetEndIndex = target.headingIndex + 1 + target.contentNodes.length;
+				const mergedContent = [];
+				for (let d = 1; d < indices.length; d++) {
+					const dup = sections[indices[d]];
+					mergedContent.push(...dup.contentNodes);
+					indicesToRemove.push(dup.headingIndex);
+					for (let c = 0; c < dup.contentNodes.length; c++) indicesToRemove.push(dup.headingIndex + 1 + c);
+				}
+				tree.children.splice(targetEndIndex, 0, ...mergedContent);
+				const shift = mergedContent.length;
+				for (let r = 0; r < indicesToRemove.length; r++) if (indicesToRemove[r] >= targetEndIndex) indicesToRemove[r] += shift;
+			}
+			indicesToRemove.sort((a, b) => b - a);
+			for (const idx of indicesToRemove) tree.children.splice(idx, 1);
+		}
+	};
+};
+
+//#endregion
+export { MergeSectionsPlugin };