@savvy-web/silk-effects 9.6.0 → 10.0.1

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

@@ -0,0 +1,54 @@
+import { parseDependencyTable } from "../utils/dependency-table.js";
+import { RULE_DOCS } from "../constants.js";
+import { finding } from "./types.js";
+import { scanDependencySection } from "../utils/dependency-section.js";
+import { Mdast } from "@effected/markdown";
+
+// src/changesets/rules/dependency-table-format.ts
+/**
+* Lint rule: changeset-dependency-table-format (CSH005).
+*
+* @remarks
+* Kit rule. A `## Dependencies` section must
+* contain a table anywhere before the next heading (prose may precede or
+* follow it); a section without one reports at the heading. The table must
+* parse through `parseDependencyTable` (columns, types, actions), and the
+* em-dash rules apply: `from` is `—` when `added`, `to` is `—` when
+* `removed`. Table-level findings anchor at the table.
+*
+* @internal
+*/
+const RULE = "changeset-dependency-table-format";
+const EM_DASH = "—";
+/**
+* Validate the structure and semantics of `## Dependencies` tables.
+*
+* @internal
+*/
+const dependencyTableFormat = (root) => {
+	const findings = [];
+	root.children.forEach((node, index) => {
+		if (node.type !== "heading" || node.depth !== 2) return;
+		if (Mdast.toText(node).toLowerCase() !== "dependencies") return;
+		const table = scanDependencySection(root.children, index + 1, {
+			isHeading: (n) => n.type === "heading",
+			isTable: (n) => n.type === "table"
+		}).table;
+		if (table === void 0 || table.type !== "table") {
+			findings.push(finding(RULE, `Dependencies section must contain a table, not a list or paragraph. See: ${RULE_DOCS.CSH005}`, node));
+			return;
+		}
+		try {
+			const rows = parseDependencyTable(table);
+			for (const row of rows) {
+				if (row.action === "added" && row.from !== EM_DASH) findings.push(finding(RULE, `'from' must be '—' when action is 'added' (got '${row.from}'). See: ${RULE_DOCS.CSH005}`, table));
+				if (row.action === "removed" && row.to !== EM_DASH) findings.push(finding(RULE, `'to' must be '—' when action is 'removed' (got '${row.to}'). See: ${RULE_DOCS.CSH005}`, table));
+			}
+		} catch (error) {
+			findings.push(finding(RULE, `${error instanceof Error ? error.message : String(error)}. See: ${RULE_DOCS.CSH005}`, table));
+		}
+	});
+	return findings;
+};
+
+export { dependencyTableFormat };

package/changesets/rules/heading-hierarchy.js

@@ -0,0 +1,37 @@
+import { RULE_DOCS } from "../constants.js";
+import { finding } from "./types.js";
+import { MarkdownVisitor } from "@effected/markdown";
+
+// src/changesets/rules/heading-hierarchy.ts
+/**
+* Lint rule: changeset-heading-hierarchy (CSH001).
+*
+* @remarks
+* Kit rule. Forbids h1 headings and sequential
+* depth skips.
+*
+* @internal
+*/
+const RULE = "changeset-heading-hierarchy";
+/**
+* Validate heading depth structure.
+*
+* @internal
+*/
+const headingHierarchy = (root) => {
+	const findings = [];
+	let prevDepth = 0;
+	for (const event of MarkdownVisitor.walk(root)) {
+		if (event._tag !== "Enter" || event.node.type !== "heading") continue;
+		const node = event.node;
+		if (node.depth === 1) {
+			findings.push(finding(RULE, `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}`, node));
+			continue;
+		}
+		if (prevDepth > 0 && node.depth > prevDepth + 1) findings.push(finding(RULE, `Heading level skipped: expected h${prevDepth + 1} or lower, found h${node.depth}. Headings must increase sequentially (h2 → h3 → h4). Add the missing intermediate level or reduce this heading's depth. See: ${RULE_DOCS.CSH001}`, node));
+		prevDepth = node.depth;
+	}
+	return findings;
+};
+
+export { headingHierarchy };

package/changesets/rules/required-sections.js

@@ -0,0 +1,34 @@
+import { allHeadings, isValidHeading } from "../categories/index.js";
+import { RULE_DOCS } from "../constants.js";
+import { finding } from "./types.js";
+import { MarkdownVisitor, Mdast } from "@effected/markdown";
+
+// src/changesets/rules/required-sections.ts
+/**
+* Lint rule: changeset-required-sections (CSH002).
+*
+* @remarks
+* Kit rule. Every h2 must match a known category
+* heading (case-insensitive).
+*
+* @internal
+*/
+const RULE = "changeset-required-sections";
+/**
+* Validate that h2 headings are known categories.
+*
+* @internal
+*/
+const requiredSections = (root) => {
+	const findings = [];
+	for (const event of MarkdownVisitor.walk(root)) {
+		if (event._tag !== "Enter" || event.node.type !== "heading") continue;
+		const node = event.node;
+		if (node.depth !== 2) continue;
+		const text = Mdast.toText(node);
+		if (!isValidHeading(text)) findings.push(finding(RULE, `Unknown section "${text}". Valid h2 headings are: ${allHeadings().join(", ")}. Heading comparison is case-insensitive. See: ${RULE_DOCS.CSH002}`, node));
+	}
+	return findings;
+};
+
+export { requiredSections };

package/changesets/rules/types.js

@@ -0,0 +1,20 @@
+// src/changesets/rules/types.ts
+/**
+* Build a {@link RuleFinding} positioned on a node.
+*
+* @param rule - The rule id
+* @param message - The finding message
+* @param node - The offending node
+* @returns The finding
+*
+* @internal
+*/
+function finding(rule, message, node) {
+	return {
+		rule,
+		message,
+		position: node.position
+	};
+}
+
+export { finding };

package/changesets/rules/uncategorized-content.js

@@ -0,0 +1,30 @@
+import { RULE_DOCS } from "../constants.js";
+import { finding } from "./types.js";
+
+// src/changesets/rules/uncategorized-content.ts
+/**
+* Lint rule: changeset-uncategorized-content (CSH004).
+*
+* @remarks
+* Kit rule. Flags substantive content before
+* the first h2; html nodes (comments) are ignored.
+*
+* @internal
+*/
+const RULE = "changeset-uncategorized-content";
+/**
+* Detect content that appears before the first h2 heading.
+*
+* @internal
+*/
+const uncategorizedContent = (root) => {
+	const findings = [];
+	for (const node of root.children) {
+		if (node.type === "heading" && node.depth === 2) break;
+		if (node.type === "heading" || node.type === "html") continue;
+		findings.push(finding(RULE, `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}`, node));
+	}
+	return findings;
+};
+
+export { uncategorizedContent };

package/changesets/schemas/changeset.js

@@ -8,7 +8,7 @@ import { Schema } from "effect";
 * @remarks
 * These schemas define the canonical representation of changeset data
 * consumed by the changelog formatter (Layer 2) and validated by the
-* remark-lint pre-validation layer (Layer 1). They enforce constraints
+* lint pre-validation layer (Layer 1). They enforce constraints
 * such as summary length limits and valid dependency types at system
 * boundaries.
 *

package/changesets/transforms/aggregate-dependency-tables.js

@@ -0,0 +1,96 @@
+import { collapseDependencyRows, parseDependencyTable, serializeDependencyTable, sortDependencyRows } from "../utils/dependency-table.js";
+import { getBlockSections, getHeadingText, getVersionBlocks } from "../utils/blocks.js";
+import { Heading, List, ListItem, Root, Text } from "@effected/markdown";
+
+// src/changesets/transforms/aggregate-dependency-tables.ts
+/**
+* Unwrap dependency tables that an earlier (broken) formatter nested inside
+* list items.
+*
+* @remarks
+* Only tables that parse as dependency tables leave the list; every other
+* item child keeps its bullet structure, surviving as a rebuilt `List` in the
+* legacy content. When no table parses the caller keeps the whole list.
+*
+* @param list - A list node found inside a `### Dependencies` section
+* @returns Parsed rows plus the remaining non-table content
+*
+* @internal
+*/
+function extractTablesFromList(list) {
+	const rows = [];
+	const keptItems = [];
+	for (const item of list.children) {
+		const keptChildren = [];
+		for (const child of item.children) {
+			if (child.type === "table") try {
+				rows.push(...parseDependencyTable(child));
+				continue;
+			} catch {}
+			keptChildren.push(child);
+		}
+		if (keptChildren.length > 0) keptItems.push(new ListItem({
+			...item,
+			children: keptChildren
+		}));
+	}
+	return {
+		rows,
+		rest: keptItems.length > 0 ? [new List({
+			...list,
+			children: keptItems
+		})] : []
+	};
+}
+/**
+* Merge every `### Dependencies` section of each version block into one.
+*
+* @param root - The changelog tree
+* @returns A tree with at most one aggregated dependencies section per block
+*
+* @internal
+*/
+const aggregateDependencyTables = (root) => {
+	const children = [...root.children];
+	const blocks = getVersionBlocks(children);
+	for (let b = blocks.length - 1; b >= 0; b--) {
+		const depSections = getBlockSections(children, 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 {
+			allRows.push(...parseDependencyTable(node));
+		} catch {
+			legacyContent.push(node);
+		}
+		else if (node.type === "list") {
+			const extracted = extractTablesFromList(node);
+			if (extracted.rows.length > 0) {
+				allRows.push(...extracted.rows);
+				legacyContent.push(...extracted.rest);
+			} else 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((x, y) => y - x);
+		for (const idx of indicesToRemove) children.splice(idx, 1);
+		if (collapsed.length === 0 && legacyContent.length === 0) continue;
+		const newNodes = [new Heading({
+			depth: 3,
+			children: [new Text({ value: "Dependencies" })]
+		})];
+		if (collapsed.length > 0) newNodes.push(serializeDependencyTable(collapsed));
+		newNodes.push(...legacyContent);
+		children.splice(depSections[0].headingIndex, 0, ...newNodes);
+	}
+	return new Root({
+		...root,
+		children
+	});
+};
+
+export { aggregateDependencyTables };

package/changesets/transforms/contributor-footnotes.js

@@ -0,0 +1,290 @@
+import { getVersionBlocks, isHeadingOfDepth } from "../utils/blocks.js";
+import { Heading, Link, List, ListItem, MarkdownTransform, MarkdownVisitor, Paragraph, Root, Text } from "@effected/markdown";
+
+// src/changesets/transforms/contributor-footnotes.ts
+/** Pattern matching `Thanks @user!` at end of text. */
+const ATTRIBUTION_PLAIN_RE = /\s*Thanks @(\w[\w-]*)!$/;
+/** Pattern matching the `Thanks ` text suffix that precedes a linked attribution. */
+const LINKED_PREFIX_RE = /\s*Thanks $/;
+/** Pattern matching `@user` mentions inside text. */
+const MENTION_RE = /@(\w[\w-]*)/g;
+/**
+* Pattern matching the transform's own merged summary paragraph, e.g.
+* `Thanks to @alice, @bob, and @carol for their contributions!`.
+*/
+const MERGED_SUMMARY_RE = /^Thanks to @\w[\w-]*(?:(?:, | and |, and |,and )@\w[\w-]*)* for their contributions!$/;
+/** Record a contributor unless one with the same lowercase username is already known. */
+function addContributor(contributors, contributor) {
+	const key = contributor.username.toLowerCase();
+	if (!contributors.has(key)) contributors.set(key, contributor);
+}
+/**
+* Match a linked attribution at the end of a paragraph's children:
+* text `"...Thanks "` + link `"@user"` + text `"!"`.
+*/
+function extractLinkedAttribution(children) {
+	if (children.length < 3) return void 0;
+	const last = children[children.length - 1];
+	const link = children[children.length - 2];
+	const prefix = children[children.length - 3];
+	if (last.type !== "text" || last.value !== "!") return void 0;
+	if (link.type !== "link" || link.children.length !== 1) return void 0;
+	const [label] = link.children;
+	if (label.type !== "text" || !label.value.startsWith("@")) return void 0;
+	if (prefix.type !== "text" || !LINKED_PREFIX_RE.test(prefix.value)) return void 0;
+	return {
+		contributor: {
+			username: label.value.slice(1),
+			url: link.url
+		},
+		removeFrom: children.length - 3,
+		prefix
+	};
+}
+/**
+* Strip one trailing attribution (linked or plain) from a paragraph, recording
+* the contributor.
+*
+* @param para - The paragraph to inspect
+* @param contributors - The per-block contributor accumulator
+* @returns The rebuilt paragraph, or `undefined` when nothing was stripped
+*/
+function stripAttribution(para, contributors) {
+	const linked = extractLinkedAttribution(para.children);
+	if (linked) {
+		addContributor(contributors, linked.contributor);
+		const value = linked.prefix.value.replace(LINKED_PREFIX_RE, "");
+		const kept = para.children.slice(0, linked.removeFrom);
+		const children = value === "" ? kept : [...kept, new Text({
+			...linked.prefix,
+			value
+		})];
+		return new Paragraph({
+			...para,
+			children
+		});
+	}
+	const last = para.children[para.children.length - 1];
+	if (last?.type === "text") {
+		const match = last.value.match(ATTRIBUTION_PLAIN_RE);
+		if (match) {
+			addContributor(contributors, {
+				username: match[1],
+				url: void 0
+			});
+			const value = last.value.replace(ATTRIBUTION_PLAIN_RE, "");
+			const kept = para.children.slice(0, -1);
+			const children = value === "" ? kept : [...kept, new Text({
+				...last,
+				value
+			})];
+			return new Paragraph({
+				...para,
+				children
+			});
+		}
+	}
+}
+/**
+* Harvest every `@user` mention (linked or plain) from a node subtree.
+*
+* @remarks
+* A mention link is entered before its own label text, so the link's URL wins
+* and the label's plain re-match is a no-op.
+*/
+function harvestMentions(node, contributors) {
+	for (const event of MarkdownVisitor.walk(new Root({ children: [node] }))) {
+		if (event._tag !== "Enter") continue;
+		const child = event.node;
+		if (child.type === "link") {
+			const [only] = child.children;
+			if (child.children.length === 1 && only.type === "text" && only.value.startsWith("@")) addContributor(contributors, {
+				username: only.value.slice(1),
+				url: child.url
+			});
+		} else if (child.type === "text") for (const match of child.value.matchAll(MENTION_RE)) addContributor(contributors, {
+			username: match[1],
+			url: void 0
+		});
+	}
+}
+/** Build the `Thanks to ... for their contributions!` summary paragraph. */
+function buildSummaryParagraph(contributors) {
+	const sorted = [...contributors.values()].sort((a, b) => a.username.toLowerCase().localeCompare(b.username.toLowerCase()));
+	const children = [new Text({ value: "Thanks to " })];
+	sorted.forEach((contrib, i) => {
+		if (i > 0 && sorted.length > 2) children.push(new Text({ value: ", " }));
+		if (i > 0 && i === sorted.length - 1) children.push(new Text({ value: sorted.length === 2 ? " and " : "and " }));
+		const mention = `@${contrib.username}`;
+		children.push(contrib.url ? new Link({
+			url: contrib.url,
+			children: [new Text({ value: mention })]
+		}) : new Text({ value: mention }));
+	});
+	children.push(new Text({ value: " for their contributions!" }));
+	return new Paragraph({ children });
+}
+/**
+* Remove list items (recursively) emptied by attribution stripping, so a
+* bullet that held only `Thanks @user!` does not survive as a bare `- `.
+*
+* @param list - The list to prune
+* @returns The rebuilt list
+*/
+function pruneEmptiedListItems(list) {
+	const items = [];
+	for (const item of list.children) {
+		const kept = [];
+		for (const child of item.children) if (child.type === "paragraph") {
+			if (child.children.length > 0) kept.push(child);
+		} else if (child.type === "list") {
+			const nested = pruneEmptiedListItems(child);
+			if (nested.children.length > 0) kept.push(nested);
+		} else kept.push(child);
+		if (kept.length > 0) items.push(new ListItem({
+			...item,
+			children: kept
+		}));
+	}
+	return new List({
+		...list,
+		children: items
+	});
+}
+/**
+* Text form of a paragraph, with single-text links flattened to their label;
+* `undefined` when the paragraph holds anything else.
+*/
+function flattenToText(para) {
+	let out = "";
+	for (const child of para.children) {
+		if (child.type === "text") {
+			out += child.value;
+			continue;
+		}
+		if (child.type === "link" && child.children.length === 1) {
+			const [only] = child.children;
+			if (only.type === "text") {
+				out += only.value;
+				continue;
+			}
+		}
+		return;
+	}
+	return out;
+}
+/**
+* Whether a paragraph consists ENTIRELY of attribution content the transform
+* owns: its own merged summary, or one or more trailing attributions with
+* nothing else.
+*/
+function isPureAttributionParagraph(para) {
+	const text = flattenToText(para);
+	if (text !== void 0 && MERGED_SUMMARY_RE.test(text)) return true;
+	const scratch = /* @__PURE__ */ new Map();
+	let current = para;
+	while (current.children.length > 0) {
+		const next = stripAttribution(current, scratch);
+		if (next === void 0) break;
+		current = next;
+	}
+	return current.children.length === 0;
+}
+/**
+* Whether a Thanks-section body node is a pure attribution shape: an
+* attribution-only paragraph, or a non-empty list whose every item holds only
+* attribution-only paragraphs.
+*/
+function isPureAttributionNode(node) {
+	if (node.type === "paragraph") return isPureAttributionParagraph(node);
+	if (node.type === "list") return node.children.length > 0 && node.children.every((item) => item.children.length > 0 && item.children.every((child) => child.type === "paragraph" && isPureAttributionParagraph(child)));
+	return false;
+}
+/** Whether a node is a depth-3 heading whose text is `Thanks`. */
+function isThanksHeading(node) {
+	if (!isHeadingOfDepth(node, [3]) || node.children.length !== 1) return false;
+	const [only] = node.children;
+	return only.type === "text" && only.value.trim().toLowerCase() === "thanks";
+}
+/**
+* Create the contributor-footnotes transform.
+*
+* @param options - Whether to emit the aggregated Thanks section
+* @returns A transform that strips attributions and aggregates them per version block
+*
+* @internal
+*/
+function contributorFootnotes(options) {
+	const emitThanks = options?.thanks !== false;
+	return (root) => {
+		const children = [...root.children];
+		const blocks = getVersionBlocks(children);
+		for (let b = blocks.length - 1; b >= 0; b--) {
+			const block = blocks[b];
+			const contributors = /* @__PURE__ */ new Map();
+			const indicesToRemove = [];
+			let preservedThanksAnchor;
+			for (let i = block.startIndex; i < block.endIndex; i++) {
+				const node = children[i];
+				if (node.type === "list") {
+					const pruned = pruneEmptiedListItems(MarkdownTransform.map(node, { paragraph: (para) => stripAttribution(para, contributors) ?? para }));
+					children[i] = pruned;
+					if (pruned.children.length === 0) indicesToRemove.push(i);
+					continue;
+				}
+				if (node.type === "paragraph") {
+					const stripped = stripAttribution(node, contributors);
+					if (stripped !== void 0) {
+						children[i] = stripped;
+						if (stripped.children.length === 0) indicesToRemove.push(i);
+					}
+					continue;
+				}
+				if (isThanksHeading(node)) {
+					const headingIndex = i;
+					const harvested = [];
+					let lastPreserved;
+					let j = i + 1;
+					for (; j < block.endIndex; j++) {
+						const contentNode = children[j];
+						if (isHeadingOfDepth(contentNode, [2, 3])) break;
+						if (contentNode.type === "definition") continue;
+						if (isPureAttributionNode(contentNode)) {
+							harvestMentions(contentNode, contributors);
+							harvested.push(j);
+						} else lastPreserved = contentNode;
+					}
+					if (lastPreserved === void 0) indicesToRemove.push(headingIndex, ...harvested);
+					else {
+						indicesToRemove.push(...harvested);
+						preservedThanksAnchor ??= lastPreserved;
+					}
+					i = j - 1;
+				}
+			}
+			const uniqueIndices = [...new Set(indicesToRemove)].sort((x, y) => y - x);
+			for (const idx of uniqueIndices) children.splice(idx, 1);
+			if (!emitThanks || contributors.size === 0) continue;
+			if (preservedThanksAnchor !== void 0) {
+				const anchorIndex = children.indexOf(preservedThanksAnchor);
+				if (anchorIndex !== -1) {
+					children.splice(anchorIndex + 1, 0, buildSummaryParagraph(contributors));
+					continue;
+				}
+			}
+			let insertAt = block.endIndex - uniqueIndices.length;
+			while (insertAt > block.startIndex && children[insertAt - 1]?.type === "definition") insertAt--;
+			const heading = new Heading({
+				depth: 3,
+				children: [new Text({ value: "Thanks" })]
+			});
+			children.splice(insertAt, 0, heading, buildSummaryParagraph(contributors));
+		}
+		return new Root({
+			...root,
+			children
+		});
+	};
+}
+
+export { contributorFootnotes };

package/changesets/transforms/deduplicate-items.js

@@ -0,0 +1,47 @@
+import { getBlockSections, getVersionBlocks } from "../utils/blocks.js";
+import { List, Mdast, Root } from "@effected/markdown";
+
+// src/changesets/transforms/deduplicate-items.ts
+/**
+* Changelog transform: drop duplicate list items within a section.
+*
+* @remarks
+* Kit transform. Seen item text is tracked across every
+* list in a section, not per list, because merging sections can leave
+* duplicate content as sibling lists. Lists left empty are removed.
+*
+* @internal
+*/
+/**
+* Remove duplicate list items within each section of each version block.
+*
+* @param root - The changelog tree
+* @returns A tree with duplicates (and resulting empty lists) removed
+*
+* @internal
+*/
+const deduplicateItems = (root) => {
+	const children = [...root.children];
+	for (const block of getVersionBlocks(children)) for (const section of getBlockSections(children, block)) {
+		const seen = /* @__PURE__ */ new Set();
+		section.contentNodes.forEach((node, offset) => {
+			if (node.type !== "list") return;
+			const filtered = node.children.filter((item) => {
+				const text = Mdast.toText(item);
+				if (seen.has(text)) return false;
+				seen.add(text);
+				return true;
+			});
+			children[section.headingIndex + 1 + offset] = new List({
+				...node,
+				children: filtered
+			});
+		});
+	}
+	return new Root({
+		...root,
+		children: children.filter((node) => node.type !== "list" || node.children.length > 0)
+	});
+};
+
+export { deduplicateItems };

package/changesets/transforms/issue-link-refs.js

@@ -0,0 +1,47 @@
+import { getVersionBlocks } from "../utils/blocks.js";
+import { Definition, LinkReference, MarkdownTransform, Root, Text } from "@effected/markdown";
+
+// src/changesets/transforms/issue-link-refs.ts
+/** Pattern matching issue numbers like `#123`. */
+const ISSUE_RE = /^#\d+$/;
+/**
+* Convert issue links to reference-style links with per-block definitions.
+*
+* @param root - The changelog tree
+* @returns A tree with reference links and appended definitions
+*
+* @internal
+*/
+const issueLinkRefs = (root) => {
+	const children = [...root.children];
+	const blocks = getVersionBlocks(children);
+	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++) children[i] = MarkdownTransform.map(children[i], { link: (link) => {
+			const [only] = link.children;
+			if (link.children.length !== 1 || only.type !== "text" || !ISSUE_RE.test(only.value)) return link;
+			const label = only.value;
+			if (!definitions.has(label)) definitions.set(label, link.url);
+			return new LinkReference({
+				identifier: label,
+				label,
+				referenceType: "full",
+				children: [new Text({ value: label })]
+			});
+		} });
+		if (definitions.size === 0) continue;
+		const defNodes = [...definitions.entries()].sort(([x], [y]) => Number.parseInt(x.slice(1), 10) - Number.parseInt(y.slice(1), 10)).map(([label, url]) => new Definition({
+			identifier: label,
+			label,
+			url
+		}));
+		children.splice(block.endIndex, 0, ...defNodes);
+	}
+	return new Root({
+		...root,
+		children
+	});
+};
+
+export { issueLinkRefs };