umberto 10.1.1 → 10.1.2

package/CHANGELOG.md

@@ -1,6 +1,13 @@
 Changelog
 =========
 
+## [10.1.2](https://github.com/cksource/umberto/compare/v10.1.1...v10.1.2) (March 9, 2026)
+
+### Bug fixes
+
+* Removed unmaintained `hexo-renderer-markdown-it-plus` and `@ckeditor/jsdoc-plugins` dependencies by replacing them with maintained and local implementations, resolving the reported `markdown-it`-related vulnerabilities in Umberto's dependency tree.
+
+
 ## [10.1.1](https://github.com/cksource/umberto/compare/v10.1.0...v10.1.1) (March 4, 2026)
 
 ### Bug fixes
@@ -43,21 +50,6 @@ Changelog
 
 * Reduced the size of API docs sidebars by only rendering the full navigation tree for the current package. Other packages now link to their landing pages, significantly lowering total link count and improving build size and performance.
 
-
-## [9.3.0](https://github.com/cksource/umberto/compare/v9.2.0...v9.3.0) (January 27, 2026)
-
-### Features
-
-* The API documentation builder now generates dedicated pages for [`Enum`](https://www.typescriptlang.org/docs/handbook/enums.html) types, presented in a format similar to object definitions.
-
-### Bug fixes
-
-* Improved rendering of `typedef` pages for union types by displaying their supported values, which were previously not shown.
-
-### Other changes
-
-* Improved rendering of [`templateLiteral`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html) types that reference a module. They are now rendered as clickable links pointing to the corresponding page.
-
 ---
 
 To see all releases, visit the [release page](https://github.com/cksource/umberto/releases).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umberto",
-  "version": "10.1.1",
+  "version": "10.1.2",
   "description": "CKSource Documentation builder",
   "main": "src/index.js",
   "type": "module",
@@ -17,8 +17,8 @@
   "dependencies": {
     "@babel/core": "^7.18.10",
     "@babel/preset-env": "^7.18.10",
-    "@ckeditor/jsdoc-plugins": "^43.0.0",
     "@minify-html/node": "^0.17.1",
+    "@vscode/markdown-it-katex": "^1.1.2",
     "babel-loader": "^10.0.0",
     "css-select": "^6.0.0",
     "dom-serializer": "^2.0.0",
@@ -33,16 +33,24 @@
     "hexo-generator-category": "^2.0.0",
     "hexo-generator-index": "^4.0.0",
     "hexo-generator-tag": "^2.0.0",
-    "hexo-renderer-markdown-it-plus": "^1.0.6",
+    "hexo-util": "^4.0.0",
     "hexo-renderer-pug": "^3.0.0",
+    "highlight.js": "^11.11.1",
     "htmlparser2": "^10.0.0",
     "javascript-stringify": "^2.1.0",
     "jquery": "~3.7.1",
     "js-beautify": "^1.14.4",
     "lodash": "^4.17.21",
+    "markdown-it-abbr": "^1.0.4",
+    "markdown-it-deflist": "^2.1.0",
+    "markdown-it-emoji": "^2.0.2",
     "markdown-it": "^14.1.1",
     "markdown-it-expand-tabs": "^1.0.13",
-    "markdown-it-toc-and-anchor": "^4.2.0",
+    "markdown-it-footnote": "^3.0.3",
+    "markdown-it-ins": "^3.0.1",
+    "markdown-it-mark": "^3.0.1",
+    "markdown-it-sub": "^1.0.0",
+    "markdown-it-sup": "^1.0.0",
     "medium-zoom": "^1.0.6",
     "minimatch": "^10.0.1",
     "moment": "^2.29.4",

package/scripts/renderer/markdown-it-plus.cjs

@@ -0,0 +1,201 @@
+/**
+ * @license Copyright (c) 2017-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const hljs = require( 'highlight.js' );
+const MarkdownIt = require( 'markdown-it' );
+const markdownItTocAndAnchor = require( '../utils/markdown-it-toc-and-anchor.cjs' );
+
+const LEGACY_KATEX_PLUGIN_NAME = '@iktakahiro/markdown-it-katex';
+const KATEX_PLUGIN_NAME = '@vscode/markdown-it-katex';
+
+const DEFAULT_PLUGINS = [
+	'markdown-it-emoji',
+	'markdown-it-sub',
+	'markdown-it-sup',
+	'markdown-it-deflist',
+	'markdown-it-abbr',
+	'markdown-it-footnote',
+	'markdown-it-ins',
+	'markdown-it-mark',
+	LEGACY_KATEX_PLUGIN_NAME,
+	'markdown-it-toc-and-anchor'
+];
+
+function checkValue( config, result, key, trueValue, falseValue ) {
+	result[ key ] =
+		config[ key ] === true || config[ key ] === undefined || config[ key ] === null ?
+			trueValue :
+			falseValue;
+}
+
+function escapeHtml( value ) {
+	return value.replace( /[&<>"']/g, match => {
+		return {
+			'&': '&amp;',
+			'<': '&lt;',
+			'>': '&gt;',
+			'"': '&quot;',
+			'\'': '&#39;'
+		}[ match ];
+	} );
+}
+
+function checkConfig( config ) {
+	const result = {};
+	const hljsClass = config.hljs_class;
+	const preClass = config.pre_class || 'highlight';
+
+	checkValue( config, result, 'highlight', ( str, lang ) => {
+		if ( lang && hljs.getLanguage( lang ) ) {
+			try {
+				const highlighted = hljs.highlight( str, {
+					language: lang,
+					ignoreIllegals: true
+				} );
+
+				return `<pre class="${ preClass }"><code class="${ lang } ${ hljsClass || '' }">${ highlighted.value }</code></pre>`;
+			} catch {
+				return `<pre class="${ preClass }"><code class="${ lang }">${ escapeHtml( str ) }</code></pre>`;
+			}
+		}
+
+		return `<pre class="${ preClass }"><code class="${ lang || '' }">${ escapeHtml( str ) }</code></pre>`;
+	}, ( str, lang ) => {
+		return `<pre class="${ preClass }"><code class="${ lang || '' }">${ escapeHtml( str ) }</code></pre>`;
+	} );
+	checkValue( config, result, 'html', true, false );
+	checkValue( config, result, 'xhtmlOut', true, false );
+	checkValue( config, result, 'breaks', true, false );
+	checkValue( config, result, 'linkify', true, false );
+	checkValue( config, result, 'typographer', true, false );
+
+	result.langPrefix = config.langPrefix || '';
+	result.quotes = config.quotes || '\u201c\u201d\u2018\u2019';
+
+	return result;
+}
+
+function checkPlugins( plugins ) {
+	const defaultPlugins = Object.fromEntries( DEFAULT_PLUGINS.map( pluginName => {
+		return [ pluginName, {
+			name: pluginName,
+			enable: true
+		} ];
+	} ) );
+	const customPlugins = [];
+
+	for ( const pluginConfig of plugins ) {
+		if ( !( pluginConfig instanceof Object ) || !( pluginConfig.plugin instanceof Object ) ) {
+			continue;
+		}
+
+		const pluginName = pluginConfig.plugin.name;
+
+		if ( !pluginName ) {
+			continue;
+		}
+
+		if ( pluginConfig.plugin.enable == null || pluginConfig.plugin.enable !== true ) {
+			pluginConfig.plugin.enable = false;
+		}
+
+		if ( defaultPlugins[ pluginName ] ) {
+			defaultPlugins[ pluginName ] = pluginConfig.plugin;
+		} else {
+			customPlugins.push( pluginConfig.plugin );
+		}
+	}
+
+	for ( let i = DEFAULT_PLUGINS.length - 1; i >= 0; i-- ) {
+		customPlugins.unshift( defaultPlugins[ DEFAULT_PLUGINS[ i ] ] );
+	}
+
+	return customPlugins;
+}
+
+function loadPlugin( pluginName ) {
+	if ( pluginName === 'markdown-it-toc-and-anchor' ) {
+		return markdownItTocAndAnchor;
+	}
+
+	if ( pluginName === LEGACY_KATEX_PLUGIN_NAME ) {
+		return require( KATEX_PLUGIN_NAME );
+	}
+
+	return require( pluginName );
+}
+
+function getPluginOptions( plugin ) {
+	if ( plugin.name !== 'markdown-it-toc-and-anchor' ) {
+		return plugin.options;
+	}
+
+	const options = plugin.options || {};
+
+	if ( !options.anchorLinkSymbol ) {
+		options.anchorLinkSymbol = '';
+	}
+
+	if ( !options.tocFirstLevel ) {
+		options.tocFirstLevel = 2;
+	}
+
+	return options;
+}
+
+function markdownItPlusRenderer( data ) {
+	let config = this.config.markdown_it_plus;
+
+	if ( !( config instanceof Object ) ) {
+		config = {};
+	}
+
+	const parserConfig = checkConfig( config );
+	let markdownIt = new MarkdownIt( parserConfig );
+
+	if ( config.plugins == null ) {
+		config.plugins = [];
+	}
+
+	const plugins = checkPlugins( config.plugins );
+
+	markdownIt = plugins.reduce( ( markdownInstance, plugin ) => {
+		if ( !plugin.enable ) {
+			return markdownInstance;
+		}
+
+		let loadedPlugin = loadPlugin( plugin.name );
+
+		if ( typeof loadedPlugin !== 'function' && typeof loadedPlugin.default === 'function' ) {
+			loadedPlugin = loadedPlugin.default;
+		}
+
+		const options = getPluginOptions( plugin );
+
+		if ( options ) {
+			return markdownInstance.use( loadedPlugin, options );
+		}
+
+		return markdownInstance.use( loadedPlugin );
+	}, markdownIt );
+
+	return markdownIt.render( data.text );
+}
+
+const markdownExtensions = [
+	'md',
+	'markdown',
+	'mkd',
+	'mkdn',
+	'mdwn',
+	'mdtxt',
+	'mdtext'
+];
+
+for ( const extension of markdownExtensions ) {
+	hexo.extend.renderer.register( extension, 'html', markdownItPlusRenderer, true );
+}

package/scripts/utils/markdown-it-toc-and-anchor.cjs

@@ -0,0 +1,322 @@
+/**
+ * @license Copyright (c) 2017-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const cloneDeep = require( 'lodash/cloneDeep' );
+const { slugize } = require( 'hexo-util' );
+
+class Token {
+	constructor( type, tag, nesting ) {
+		this.type = type;
+		this.tag = tag;
+		this.nesting = nesting;
+		this.attrs = null;
+		this.map = null;
+		this.level = 0;
+		this.children = null;
+		this.content = '';
+		this.markup = '';
+		this.info = '';
+		this.meta = null;
+		this.block = false;
+		this.hidden = false;
+	}
+}
+
+const TOC = '@[toc]';
+const TOC_RE = /^@\[toc\]/i;
+
+const repeat = ( string, num ) => new Array( num + 1 ).join( string );
+
+const defaultSlugify = title => slugize( title, { transform: 1 } );
+
+const makeSafe = ( string, localHeadingIds, slugifyFn ) => {
+	const key = slugifyFn( string );
+
+	if ( !localHeadingIds[ key ] ) {
+		localHeadingIds[ key ] = 0;
+	}
+
+	localHeadingIds[ key ]++;
+
+	return key + ( localHeadingIds[ key ] > 1 ? `-${ localHeadingIds[ key ] }` : '' );
+};
+
+const space = () => {
+	return {
+		...new Token( 'text', '', 0 ),
+		content: ' '
+	};
+};
+
+const renderAnchorLinkSymbol = options => {
+	if ( options.anchorLinkSymbolClassName ) {
+		return [
+			{
+				...new Token( 'span_open', 'span', 1 ),
+				attrs: [ [ 'class', options.anchorLinkSymbolClassName ] ]
+			},
+			{
+				...new Token( 'text', '', 0 ),
+				content: options.anchorLinkSymbol
+			},
+			new Token( 'span_close', 'span', -1 )
+		];
+	}
+
+	return [
+		{
+			...new Token( 'text', '', 0 ),
+			content: options.anchorLinkSymbol
+		}
+	];
+};
+
+const renderAnchorLink = ( anchor, options, tokens, idx ) => {
+	const attrs = [];
+
+	if ( options.anchorClassName != null ) {
+		attrs.push( [ 'class', options.anchorClassName ] );
+	}
+
+	attrs.push( [ 'href', `#${ anchor }` ] );
+
+	const openLinkToken = {
+		...new Token( 'link_open', 'a', 1 ),
+		attrs
+	};
+	const closeLinkToken = new Token( 'link_close', 'a', -1 );
+
+	if ( options.wrapHeadingTextInAnchor ) {
+		tokens[ idx + 1 ].children.unshift( openLinkToken );
+		tokens[ idx + 1 ].children.push( closeLinkToken );
+
+		return;
+	}
+
+	const linkTokens = [
+		openLinkToken,
+		...renderAnchorLinkSymbol( options ),
+		closeLinkToken
+	];
+	const actionOnArray = {
+		false: 'push',
+		true: 'unshift'
+	};
+
+	if ( options.anchorLinkSpace ) {
+		linkTokens[ actionOnArray[ !options.anchorLinkBefore ] ]( space() );
+	}
+
+	tokens[ idx + 1 ].children[ actionOnArray[ options.anchorLinkBefore ] ]( ...linkTokens );
+};
+
+const treeToMarkdownBulletList = ( tree, indent = 0 ) => {
+	return tree
+		.map( item => {
+			const indentation = '  ';
+			let node = `${ repeat( indentation, indent ) }*`;
+
+			if ( item.heading.content ) {
+				const contentWithoutAnchor = item.heading.content.replace( /\[([^\]]*)\]\([^)]*\)/g, '$1' );
+
+				node += ` [${ contentWithoutAnchor }](#${ item.heading.anchor })\n`;
+			} else {
+				node += '\n';
+			}
+
+			if ( item.nodes.length ) {
+				node += treeToMarkdownBulletList( item.nodes, indent + 1 );
+			}
+
+			return node;
+		} )
+		.join( '' );
+};
+
+const generateTocMarkdownFromArray = ( headings, options ) => {
+	const tree = {
+		nodes: []
+	};
+
+	for ( const heading of headings ) {
+		if ( heading.level < options.tocFirstLevel || heading.level > options.tocLastLevel ) {
+			continue;
+		}
+
+		let i = 1;
+		let lastItem = tree;
+
+		for ( ; i < heading.level - options.tocFirstLevel + 1; i++ ) {
+			if ( lastItem.nodes.length === 0 ) {
+				lastItem.nodes.push( {
+					heading: {},
+					nodes: []
+				} );
+			}
+
+			lastItem = lastItem.nodes[ lastItem.nodes.length - 1 ];
+		}
+
+		lastItem.nodes.push( {
+			heading,
+			nodes: []
+		} );
+	}
+
+	return treeToMarkdownBulletList( tree.nodes );
+};
+
+module.exports = function markdownItTocAndAnchor( md, options ) {
+	options = {
+		toc: true,
+		tocClassName: 'markdownIt-TOC',
+		tocFirstLevel: 1,
+		tocLastLevel: 6,
+		tocCallback: null,
+		anchorLink: true,
+		anchorLinkSymbol: '#',
+		anchorLinkBefore: true,
+		anchorClassName: 'markdownIt-Anchor',
+		resetIds: true,
+		anchorLinkSpace: true,
+		anchorLinkSymbolClassName: null,
+		wrapHeadingTextInAnchor: false,
+		...options
+	};
+
+	const markdownItSecondInstance = cloneDeep( md );
+	let headingIds = {};
+	let tocHtml = '';
+
+	md.core.ruler.push( 'init_toc', state => {
+		const tokens = state.tokens;
+
+		if ( options.resetIds ) {
+			headingIds = {};
+		}
+
+		const tocArray = [];
+		let tocMarkdown = '';
+		let tocTokens = [];
+
+		const slugifyFn = typeof options.slugify === 'function' ? options.slugify : defaultSlugify;
+
+		for ( let i = 0; i < tokens.length; i++ ) {
+			if ( tokens[ i ].type !== 'heading_close' ) {
+				continue;
+			}
+
+			const heading = tokens[ i - 1 ];
+			const headingClose = tokens[ i ];
+
+			if ( heading.type !== 'inline' ) {
+				continue;
+			}
+
+			let content;
+
+			if ( heading.children?.length > 0 && heading.children[ 0 ].type === 'link_open' ) {
+				content = heading.children[ 1 ].content;
+				heading._tocAnchor = makeSafe( content, headingIds, slugifyFn );
+			} else {
+				content = heading.content;
+				heading._tocAnchor = makeSafe(
+					heading.children.reduce( ( acc, token ) => acc + token.content, '' ),
+					headingIds,
+					slugifyFn
+				);
+			}
+
+			if ( options.anchorLinkPrefix ) {
+				heading._tocAnchor = options.anchorLinkPrefix + heading._tocAnchor;
+			}
+
+			tocArray.push( {
+				content,
+				anchor: heading._tocAnchor,
+				level: Number( headingClose.tag.slice( 1, 2 ) )
+			} );
+		}
+
+		tocMarkdown = generateTocMarkdownFromArray( tocArray, options );
+		tocTokens = markdownItSecondInstance.parse( tocMarkdown, {} );
+
+		if ( typeof tocTokens[ 0 ] === 'object' && tocTokens[ 0 ].type === 'bullet_list_open' ) {
+			const attrs = ( tocTokens[ 0 ].attrs = tocTokens[ 0 ].attrs || [] );
+
+			if ( options.tocClassName != null ) {
+				attrs.push( [ 'class', options.tocClassName ] );
+			}
+		}
+
+		tocHtml = markdownItSecondInstance.renderer.render( tocTokens, markdownItSecondInstance.options );
+
+		if ( typeof state.env.tocCallback === 'function' ) {
+			state.env.tocCallback.call( undefined, tocMarkdown, tocArray, tocHtml );
+		} else if ( typeof options.tocCallback === 'function' ) {
+			options.tocCallback.call( undefined, tocMarkdown, tocArray, tocHtml );
+		} else if ( typeof md.options.tocCallback === 'function' ) {
+			md.options.tocCallback.call( undefined, tocMarkdown, tocArray, tocHtml );
+		}
+	} );
+
+	md.inline.ruler.after( 'emphasis', 'toc', ( state, silent ) => {
+		if (
+			state.src.charCodeAt( state.pos ) !== 0x40 ||
+			state.src.charCodeAt( state.pos + 1 ) !== 0x5b ||
+			silent
+		) {
+			return false;
+		}
+
+		const currentSource = state.src.slice( state.pos );
+		const match = TOC_RE.exec( currentSource );
+
+		if ( !match ) {
+			return false;
+		}
+
+		let token = state.push( 'toc_open', 'toc', 1 );
+
+		token.markup = TOC;
+		token = state.push( 'toc_body', '', 0 );
+		token = state.push( 'toc_close', 'toc', -1 );
+
+		state.pos += match[ 0 ].length;
+
+		return true;
+	} );
+
+	const originalHeadingOpen = md.renderer.rules.heading_open || ( ( ...args ) => {
+		const [ tokens, idx, rendererOptions, , self ] = args;
+
+		return self.renderToken( tokens, idx, rendererOptions );
+	} );
+
+	md.renderer.rules.heading_open = function( ...args ) {
+		const [ tokens, idx ] = args;
+
+		const attrs = ( tokens[ idx ].attrs = tokens[ idx ].attrs || [] );
+		const anchor = tokens[ idx + 1 ]._tocAnchor;
+
+		attrs.push( [ 'id', anchor ] );
+
+		if ( options.anchorLink ) {
+			renderAnchorLink( anchor, options, ...args );
+		}
+
+		return originalHeadingOpen.apply( this, args );
+	};
+
+	md.renderer.rules.toc_open = () => '';
+	md.renderer.rules.toc_close = () => '';
+	md.renderer.rules.toc_body = () => '';
+
+	if ( options.toc ) {
+		md.renderer.rules.toc_body = () => tocHtml;
+	}
+};

package/src/api-builder/classes/doc-data-factory.js

@@ -188,8 +188,7 @@ export class DocDataFactory {
 
 		/* eslint-disable @stylistic/max-len */
 		// For all "typedef" doclets - copy property name as its id. Thanks to that we will be able to make a directly link to specified property. See #796.
-		// "member-" as a static string must be the same as defined in `addTypedefProperties()` helper in the `@ckeditor/jsdoc-plugins` package.
-		// See: https://github.com/ckeditor/ckeditor5-dev/blob/aa905a702d337db001445efc1036ab2b33069d44/packages/jsdoc-plugins/lib/relation-fixer/addtypedefproperties.js#L95
+		// "member-" as a static string must stay in sync with IDs generated for typedef properties in the data conversion pipeline.
 		/* eslint-enable @stylistic/max-len */
 		if ( doclet.kind == 'typedef' ) {
 			for ( const property of properties ) {

package/src/data-converter/middlewares/relation-fixer/add-missing-doclets.js

@@ -0,0 +1,112 @@
+/**
+ * @license Copyright (c) 2017-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+import { getMissingDocletsData } from './get-missing-doclets-data.js';
+import { DocletCollection } from './doclet-collection.js';
+
+/**
+ * Adds missing doclets for members coming from implemented interfaces, extended classes and mixins.
+ * Supports inheriting static members, which are not supported by JSDoc.
+ *
+ * @param {Doclet[]} doclets
+ * @returns {Doclet[]}
+ */
+export function addMissingDoclets( doclets ) {
+	const docletCollection = new DocletCollection();
+
+	for ( const doclet of doclets ) {
+		docletCollection.add( `memberof:${ doclet.memberof }`, doclet );
+	}
+
+	const extensibleDoclets = doclets.filter( doclet => {
+		return doclet.kind === 'class' || doclet.kind === 'interface' || doclet.kind === 'mixin';
+	} );
+
+	const newDocletsToAdd = [];
+	const docletsToIgnore = [];
+	const options = [
+		{
+			relation: 'augmentsNested'
+		},
+		{
+			relation: 'mixesNested',
+			onlyImplicitlyInherited: true
+		},
+		{
+			relation: 'implementsNested'
+		}
+	];
+
+	const docletMap = createDocletMap( docletCollection );
+
+	for ( const extensibleDoclet of extensibleDoclets ) {
+		for ( const option of options ) {
+			const missingDocletsData = getMissingDocletsData(
+				docletMap,
+				docletCollection,
+				extensibleDoclet,
+				option
+			);
+
+			newDocletsToAdd.push( ...missingDocletsData.newDoclets );
+			docletsToIgnore.push( ...missingDocletsData.docletsWhichShouldBeIgnored );
+		}
+	}
+
+	for ( const docletToIgnore of docletsToIgnore ) {
+		docletToIgnore.ignore = true;
+	}
+
+	const filteredDoclets = doclets.filter( doclet => !doclet.ignore );
+	const docletToAddMap = new Map(
+		newDocletsToAdd
+			.filter( doclet => !doclet.ignore )
+			.map( doclet => [ doclet.longname, doclet ] )
+	);
+	const existingDoclets = new Map( filteredDoclets.map( doclet => [ doclet.longname, doclet ] ) );
+
+	return [
+		...filteredDoclets.filter( doclet => {
+			const willDocletBeAdded = docletToAddMap.has( doclet.longname );
+
+			if ( willDocletBeAdded && doclet.inheritdoc === undefined ) {
+				return false;
+			}
+
+			return true;
+		} ),
+		...Array.from( docletToAddMap.values() ).filter( doclet => {
+			const existingDoclet = existingDoclets.get( doclet.longname );
+
+			if ( !existingDoclet ) {
+				return true;
+			}
+
+			if ( existingDoclet.inheritdoc === undefined ) {
+				return true;
+			}
+
+			return false;
+		} )
+	];
+}
+
+/**
+ * Creates a <longname, doclet> map.
+ *
+ * @param {DocletCollection} doclets
+ * @returns {Object.<String, Doclet>}
+ */
+function createDocletMap( doclets ) {
+	const docletMap = {};
+
+	for ( const doclet of doclets.getAll() ) {
+		if ( !docletMap[ doclet.longname ] ) {
+			docletMap[ doclet.longname ] = doclet;
+		}
+	}
+
+	return docletMap;
+}

package/src/data-converter/middlewares/relation-fixer/build-relations.js

@@ -0,0 +1,136 @@
+/**
+ * @license Copyright (c) 2017-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+import { DocletCollection } from './doclet-collection.js';
+
+const RELATIONS = {
+	implements: 'implementsNested',
+	mixes: 'mixesNested',
+	augments: 'augmentsNested'
+};
+
+/**
+ * Checks ascendants of every doclet and adds them to relation arrays.
+ * Handles nested inheritance, mixins and implementation of interfaces.
+ * Also adds descendants to doclets.
+ *
+ * @param {Doclet[]} doclets
+ * @returns {Doclet[]}
+ */
+export function buildRelations( doclets ) {
+	const processedDoclets = structuredClone( doclets );
+	const docletCollection = new DocletCollection();
+
+	for ( const doclet of processedDoclets ) {
+		docletCollection.add( doclet.longname, doclet );
+	}
+
+	const subjectDoclets = processedDoclets.filter( item => {
+		return (
+			item.kind === 'class' ||
+			item.kind === 'interface' ||
+			item.kind === 'mixin' ||
+			item.kind === 'typedef'
+		);
+	} );
+
+	for ( const doclet of subjectDoclets ) {
+		const related = getAncestors( docletCollection, doclet, {
+			relations: [ 'augments', 'implements', 'mixes' ]
+		} );
+
+		for ( const relation of Object.keys( related ) ) {
+			related[ relation ] = [ ...new Set( related[ relation ] ) ];
+		}
+
+		Object.assign( doclet, related );
+	}
+
+	for ( const doclet of subjectDoclets ) {
+		doclet.descendants = [ ...new Set( getDescendants( subjectDoclets, doclet ) ) ];
+	}
+
+	return processedDoclets;
+}
+
+/**
+ * Gets longnames of the current doclet ancestors.
+ *
+ * @param {DocletCollection} docletCollection
+ * @param {Doclet} currentDoclet
+ * @param {Object} options
+ * @param {Array.<'augments'|'implements'|'mixes'>} options.relations
+ * @returns {Object}
+ */
+function getAncestors( docletCollection, currentDoclet, options ) {
+	const { relations } = options;
+	const resultRelations = {};
+
+	for ( const baseRelation of relations ) {
+		resultRelations[ RELATIONS[ baseRelation ] ] = [];
+	}
+
+	for ( const baseRelation of relations ) {
+		const relation = RELATIONS[ baseRelation ];
+
+		if ( isEmpty( currentDoclet[ baseRelation ] ) ) {
+			continue;
+		}
+
+		resultRelations[ relation ].push( ...currentDoclet[ baseRelation ] );
+
+		for ( const longname of currentDoclet[ baseRelation ] ) {
+			const ancestors = docletCollection.get( longname );
+
+			for ( const ancestor of ancestors ) {
+				const ancestorsResultRelations = getAncestors( docletCollection, ancestor, {
+					relations
+				} );
+
+				for ( const key of Object.keys( resultRelations ) ) {
+					if ( key === 'augmentsNested' && ancestor.kind !== currentDoclet.kind ) {
+						continue;
+					}
+
+					resultRelations[ key ].push( ...ancestorsResultRelations[ key ] );
+				}
+			}
+		}
+	}
+
+	return resultRelations;
+}
+
+/**
+ * @param {Array|undefined} arr
+ * @returns {Boolean}
+ */
+function isEmpty( arr ) {
+	return !arr || arr.length === 0;
+}
+
+/**
+ * Gets longnames of descendants - entities that extend, implement or mix a doclet.
+ *
+ * @param {Doclet[]} searchedDoclets
+ * @param {Doclet} currentDoclet
+ * @returns {String[]}
+ */
+function getDescendants( searchedDoclets, currentDoclet ) {
+	const descendants = new Set();
+
+	for ( const doclet of searchedDoclets ) {
+		for ( const baseRelation in RELATIONS ) {
+			const relation = RELATIONS[ baseRelation ];
+
+			if ( !isEmpty( doclet[ relation ] ) && doclet[ relation ].includes( currentDoclet.longname ) ) {
+				descendants.add( doclet.longname );
+				break;
+			}
+		}
+	}
+
+	return Array.from( descendants );
+}

package/src/data-converter/middlewares/relation-fixer/doclet-collection.js

@@ -0,0 +1,62 @@
+/**
+ * @license Copyright (c) 2017-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+/**
+ * Collection of doclets as <String, Doclet[]> pairs. Also stores all doclets and their longnames as arrays.
+ */
+export class DocletCollection {
+	constructor() {
+		this._data = {};
+		this._allData = [];
+		this._allLongnames = [];
+	}
+
+	/**
+	 * Adds doclet to collection.
+	 *
+	 * @param {String} category
+	 * @param {Doclet} doclet
+	 */
+	add( category, doclet ) {
+		if ( !this._data[ category ] ) {
+			this._data[ category ] = [];
+		}
+
+		this._data[ category ].push( doclet );
+		this._allData.push( doclet );
+
+		if ( doclet.longname ) {
+			this._allLongnames.push( doclet.longname );
+		}
+	}
+
+	/**
+	 * Returns doclets filtered by category.
+	 *
+	 * @param {String} category
+	 * @returns {Doclet[]}
+	 */
+	get( category ) {
+		return this._data[ category ] || [];
+	}
+
+	/**
+	 * Returns all doclets.
+	 *
+	 * @returns {Doclet[]}
+	 */
+	getAll() {
+		return this._allData;
+	}
+
+	/**
+	 * Returns all longnames.
+	 *
+	 * @returns {String[]}
+	 */
+	getAllLongnames() {
+		return this._allLongnames;
+	}
+}

package/src/data-converter/middlewares/relation-fixer/get-missing-doclets-data.js

@@ -0,0 +1,191 @@
+/**
+ * @license Copyright (c) 2017-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+/**
+ * Gets missing doclets of members coming from implemented interfaces, extended classes and mixins.
+ * Returns also doclets which should be ignored.
+ *
+ * @param {Object.<String, Doclet>} docletMap
+ * @param {DocletCollection} docletCollection
+ * @param {Doclet} interfaceClassOrMixinDoclet
+ * @param {Options} options
+ * @returns {{newDoclets: Doclet[], docletsWhichShouldBeIgnored: Doclet[]}}
+ */
+export function getMissingDocletsData( docletMap, docletCollection, interfaceClassOrMixinDoclet, options ) {
+	const newDoclets = [];
+	const docletsWhichShouldBeIgnored = [];
+
+	const docletsToAdd = getDocletsToAdd( docletCollection, interfaceClassOrMixinDoclet, options );
+
+	for ( const docletToAdd of docletsToAdd ) {
+		const clonedDoclet = structuredClone( docletToAdd );
+
+		clonedDoclet.longname = getLongnameForNewDoclet( docletToAdd, interfaceClassOrMixinDoclet );
+		clonedDoclet.memberof = interfaceClassOrMixinDoclet.longname;
+
+		const relationProperty = getRelationProperty( docletMap, interfaceClassOrMixinDoclet, docletToAdd, options.relation );
+
+		if ( relationProperty ) {
+			clonedDoclet[ relationProperty ] = true;
+		}
+
+		const docletsOfSameMember = docletCollection.get( `memberof:${ clonedDoclet.memberof }` ).filter( doclet => {
+			if ( doclet.kind !== clonedDoclet.kind ) {
+				return false;
+			}
+
+			const docletName = doclet.name.replace( /^[#.]/, '' );
+			const clonedDocletName = clonedDoclet.name.replace( /^[#.]/, '' );
+
+			return docletName === clonedDocletName;
+		} );
+
+		if ( docletsOfSameMember.length === 0 ) {
+			newDoclets.push( clonedDoclet );
+		} else if ( doAllParentsExplicitlyInherit( docletsOfSameMember ) && !options.onlyImplicitlyInherited ) {
+			docletsWhichShouldBeIgnored.push( ...docletsOfSameMember );
+			newDoclets.push( clonedDoclet );
+		} else if ( docletsOfSameMember.length >= 2 ) {
+			const correctDoclet = structuredClone( docletsOfSameMember[ 0 ] );
+
+			if ( relationProperty ) {
+				correctDoclet[ relationProperty ] = true;
+			}
+
+			docletsWhichShouldBeIgnored.push( ...docletsOfSameMember );
+			newDoclets.push( correctDoclet );
+		}
+	}
+
+	return {
+		newDoclets,
+		docletsWhichShouldBeIgnored
+	};
+}
+
+/**
+ * Gets doclets from related entities and matching criteria from options.
+ *
+ * @param {DocletCollection} docletCollection
+ * @param {Doclet} childDoclet
+ * @param {Object} options
+ * @returns {Doclet[]}
+ */
+function getDocletsToAdd( docletCollection, childDoclet, options ) {
+	const ancestors = childDoclet[ options.relation ] || [];
+	const docletsToAdd = [];
+
+	for ( const ancestor of ancestors ) {
+		docletsToAdd.push(
+			...docletCollection
+				.get( `memberof:${ ancestor }` )
+				.filter( doclet => shouldDocletBeAdded( doclet, options ) )
+		);
+	}
+
+	return docletsToAdd;
+}
+
+/**
+ * @param {Doclet} doclet
+ * @param {Object} options
+ * @returns {Boolean}
+ */
+function shouldDocletBeAdded( doclet, options ) {
+	if ( doclet.ignore || doclet.undocumented || typeof doclet.inheritdoc === 'string' ) {
+		return false;
+	}
+
+	for ( const key of Object.keys( options.filter || {} ) ) {
+		if ( doclet[ key ] !== options.filter[ key ] ) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+/**
+ * @param {Doclet} parentDoclet
+ * @param {Doclet} childDoclet
+ * @returns {String}
+ */
+function getLongnameForNewDoclet( parentDoclet, childDoclet ) {
+	const dotIndex = parentDoclet.longname.lastIndexOf( '.' );
+	const hashIndex = parentDoclet.longname.lastIndexOf( '#' );
+	const name = parentDoclet.longname.slice( Math.max( dotIndex, hashIndex ) );
+
+	return childDoclet.longname + name;
+}
+
+/**
+ * Gets property which should be added to the new doclet.
+ *
+ * @param {Object.<String, Doclet>} docletMap
+ * @param {Doclet} childDoclet
+ * @param {Doclet} memberDoclet
+ * @param {'augmentsNested'|'mixesNested'|'implementsNested'} relation
+ * @returns {'inherited'|'mixed'|null}
+ */
+function getRelationProperty( docletMap, childDoclet, memberDoclet, relation ) {
+	if ( relation === 'augmentsNested' ) {
+		return 'inherited';
+	}
+
+	if ( relation === 'mixesNested' ) {
+		return 'mixed';
+	}
+
+	const memberDocletParent = docletMap[ memberDoclet.memberof ];
+
+	let isInherited = false;
+	let isMixed = false;
+
+	for ( const longname of memberDocletParent.descendants || [] ) {
+		const doclet = docletMap[ longname ];
+
+		if ( !doclet || !doclet.descendants || !doclet.descendants.includes( childDoclet.longname ) ) {
+			continue;
+		}
+
+		if ( doclet.kind === 'mixin' ) {
+			isMixed = true;
+		} else if ( doclet.kind === 'class' ) {
+			isInherited = true;
+		}
+	}
+
+	if ( isMixed ) {
+		return 'mixed';
+	}
+
+	if ( isInherited ) {
+		return 'inherited';
+	}
+
+	return null;
+}
+
+/**
+ * @param {Doclet[]} doclets
+ * @returns {Boolean}
+ */
+function doAllParentsExplicitlyInherit( doclets ) {
+	for ( const doclet of doclets ) {
+		if ( doclet.inheritdoc === undefined && doclet.overrides === undefined ) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+/**
+ * @typedef {Object} Options
+ *
+ * @property {'augmentsNested'|'mixesNested'|'implementsNested'} relation
+ * @property {Partial<Doclet>} [filter]
+ * @property {Boolean} [onlyImplicitlyInherited]
+ */

package/src/data-converter/middlewares/relation-fixer.js

@@ -3,8 +3,8 @@
  * For licensing, see LICENSE.md.
  */
 
-import buildRelations from '@ckeditor/jsdoc-plugins/lib/relation-fixer/buildrelations.js';
-import addMissingDoclets from '@ckeditor/jsdoc-plugins/lib/relation-fixer/addmissingdoclets.js';
+import { buildRelations } from './relation-fixer/build-relations.js';
+import { addMissingDoclets } from './relation-fixer/add-missing-doclets.js';
 
 /**
  * Builds relation chains between doclets and adds missing derived doclets.