@ckeditor/ckeditor5-dev-manual-server 56.2.0

package/LICENSE.md

@@ -0,0 +1,16 @@
+Software License Agreement
+==========================
+
+Copyright (c) 2003-2026, [CKSource](http://cksource.com) Holding sp. z o.o. All rights reserved.
+
+Licensed under the terms of [GNU General Public License Version 2 or later](http://www.gnu.org/licenses/gpl.html).
+
+Sources of Intellectual Property Included in CKEditor
+-----------------------------------------------------
+
+Where not otherwise indicated, all CKEditor content is authored by CKSource engineers and consists of CKSource-owned intellectual property. In some specific instances, CKEditor will incorporate work done by developers outside of CKSource with their express permission.
+
+Trademarks
+----------
+
+**CKEditor** is a trademark of [CKSource](http://cksource.com) Holding sp. z o.o. All other brand and product names are trademarks, registered trademarks or service marks of their respective holders.

package/README.md

@@ -0,0 +1,17 @@
+CKEditor 5 manual server
+=======================
+
+[![npm version](https://badge.fury.io/js/%40ckeditor%2Fckeditor5-dev-manual-server.svg)](https://www.npmjs.com/package/@ckeditor/ckeditor5-dev-manual-server)
+[![CircleCI](https://circleci.com/gh/ckeditor/ckeditor5-dev.svg?style=shield)](https://app.circleci.com/pipelines/github/ckeditor/ckeditor5-dev?branch=master)
+
+Used to extend Vite to create a manual test server for CKEditor 5.
+
+More information about development tools packages can be found at the following URL: <https://github.com/ckeditor/ckeditor5-dev>.
+
+## Changelog
+
+See the [`CHANGELOG.md`](https://github.com/ckeditor/ckeditor5-dev/blob/master/packages/ckeditor5-dev-manual-server/CHANGELOG.md) file.
+
+## License
+
+Licensed under the terms of [GNU General Public License Version 2 or later](http://www.gnu.org/licenses/gpl.html). For full details about the license, please check the `LICENSE.md` file.

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+export { manualTestsPlugin } from "./manual-test-plugin/plugin.js";
+export type { ManualData } from "./manual-test-plugin/plugin.js";
+export { refreshPlugin } from "./refresh-plugin/plugin.js";
+export { rawHtmlPlugin } from "./raw-plugin/plugin.js";
+export { stringifyValues } from "./utils.js";

package/dist/index.js

@@ -0,0 +1,584 @@
+import { createReadStream, existsSync, globSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path, { extname, isAbsolute, posix, relative, resolve } from "node:path";
+import { parse, serialize } from "parse5";
+import { appendChild, createElement, getAttribute, getTextContent, hasAttribute, isElementNode, query, removeAttribute, removeNode, setAttribute, setTextContent } from "@parse5/tools";
+import { unified } from "unified";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { toHtml } from "hast-util-to-html";
+import { readFile } from "node:fs/promises";
+//#region src/utils.ts
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+/**
+* Caches the computed value until the cache is invalidated.
+*/
+function cacheValue(compute) {
+	let cached = null;
+	return {
+		get() {
+			cached ||= { value: compute() };
+			return cached.value;
+		},
+		invalidate() {
+			cached = null;
+		}
+	};
+}
+/**
+* Stringifies the values of the given object.
+*/
+function stringifyValues(obj) {
+	return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, JSON.stringify(value)]));
+}
+function toPublicFilePath(filePath, workspaceRoot) {
+	const relativeFilePath = relative(workspaceRoot, filePath);
+	if (!relativeFilePath.startsWith("..") && !isAbsolute(relativeFilePath)) return toPublicSpecifier(relativeFilePath);
+	return `/@fs/${toPosixPath(filePath)}`;
+}
+function toPublicSpecifier(relativeFilePath) {
+	return `/${stripLeadingSlash(toPosixPath(relativeFilePath))}`;
+}
+function toPosixPath(value) {
+	return value.replace(/\\/g, "/");
+}
+function stripLeadingSlash(value) {
+	return value.startsWith("/") ? value.slice(1) : value;
+}
+//#endregion
+//#region src/manual-test-plugin/collect-pages.ts
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+function collectManualPages(patterns, workspaceRoot) {
+	const groupedFiles = /* @__PURE__ */ new Map();
+	const manualPages = [];
+	for (const relativeFilePath of matchFiles(patterns, workspaceRoot)) {
+		if (relativeFilePath.includes("/_utils/")) continue;
+		const parsedPath = parseManualTestAssetPath(relativeFilePath);
+		if (!parsedPath) continue;
+		const entryKey = `${parsedPath.packageRootPath}/${parsedPath.packageName}/${parsedPath.slug}`;
+		const matchedFiles = groupedFiles.get(entryKey) || {};
+		matchedFiles[parsedPath.extension] = relativeFilePath;
+		groupedFiles.set(entryKey, matchedFiles);
+	}
+	for (const matchedFiles of groupedFiles.values()) {
+		if (!matchedFiles.html) continue;
+		const scriptFilePath = matchedFiles.ts || matchedFiles.js;
+		if (!scriptFilePath) continue;
+		const parsedPath = parseManualTestAssetPath(scriptFilePath);
+		manualPages.push({
+			displayName: humanizeSlug(parsedPath.slug),
+			htmlFilePath: toPublicSpecifier(matchedFiles.html),
+			instructionsFilePath: matchedFiles.md ? toPublicSpecifier(matchedFiles.md) : void 0,
+			packageName: parsedPath.packageName,
+			scriptFilePath: toPublicSpecifier(scriptFilePath),
+			slug: parsedPath.slug
+		});
+	}
+	manualPages.sort((a, b) => a.packageName.localeCompare(b.packageName) || a.slug.localeCompare(b.slug));
+	return new Map(manualPages.map((entry) => [entry.htmlFilePath, entry]));
+}
+function parseManualTestAssetPath(filePath) {
+	const match = stripLeadingSlash(toPosixPath(filePath)).match(/^(?:(.*?)\/)?([^/]+)\/tests\/manual\/(.+)\.(html|js|md|ts)$/);
+	if (!match) return null;
+	return {
+		extension: match[4],
+		packageName: match[2],
+		packageRootPath: match[1] || "",
+		slug: match[3]
+	};
+}
+function humanizeSlug(slug) {
+	return slug.split("/").map((pathPart) => pathPart.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ")).join(" / ");
+}
+function matchFiles(patterns, workspaceRoot) {
+	return patterns.flatMap((pattern) => globSync(pattern, { cwd: workspaceRoot }).map((match) => toPosixPath(match)));
+}
+//#endregion
+//#region src/manual-test-plugin/static-assets.ts
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+const PROCESSED_MANUAL_TEST_EXTENSIONS = new Set([
+	".css",
+	".html",
+	".js",
+	".md",
+	".ts"
+]);
+const VITE_MODULE_QUERY_PARAMETERS = new Set([
+	"import",
+	"raw",
+	"url",
+	"worker",
+	"inline"
+]);
+function collectManualStaticAssets(patterns, workspaceRoot) {
+	return new Map(patterns.flatMap((pattern) => globSync(pattern, { cwd: workspaceRoot })).sort().filter((relativeFilePath) => statSync(resolve(workspaceRoot, relativeFilePath), { throwIfNoEntry: false })?.isFile()).filter(isManualStaticAssetPath).map((relativeFilePath) => [toPublicSpecifier(relativeFilePath), resolve(workspaceRoot, relativeFilePath)]));
+}
+function createManualStaticAssetsMiddleware(collectStaticAssets) {
+	return (request, response, next) => {
+		if (request.method != "GET" && request.method != "HEAD") {
+			next();
+			return;
+		}
+		const publicPath = getManualStaticAssetPublicPath(request.url);
+		const filePath = publicPath && collectStaticAssets().get(publicPath);
+		const fileStats = filePath ? statSync(filePath, { throwIfNoEntry: false }) : void 0;
+		if (!filePath || !fileStats?.isFile()) {
+			next();
+			return;
+		}
+		response.statusCode = 200;
+		response.setHeader("Content-Length", fileStats.size);
+		response.setHeader("Content-Type", getContentType(extname(filePath)));
+		if (request.method == "HEAD") {
+			response.end();
+			return;
+		}
+		const fileStream = createReadStream(filePath);
+		fileStream.on("error", () => response.destroy());
+		fileStream.pipe(response);
+	};
+}
+function getManualStaticAssetPublicPath(requestUrl) {
+	const url = URL.parse(requestUrl || "", "http://localhost");
+	if (!url) return null;
+	if ([...url.searchParams.keys()].some((key) => VITE_MODULE_QUERY_PARAMETERS.has(key))) return null;
+	const pathname = decodePathname(url.pathname);
+	if (!pathname || !isManualStaticAssetPath(pathname)) return null;
+	return pathname;
+}
+function decodePathname(pathname) {
+	try {
+		return decodeURIComponent(pathname);
+	} catch {
+		return null;
+	}
+}
+function isManualStaticAssetPath(filePath) {
+	return extname(filePath) != "" && !PROCESSED_MANUAL_TEST_EXTENSIONS.has(extname(filePath));
+}
+function getContentType(extension) {
+	switch (extension) {
+		case ".avif": return "image/avif";
+		case ".css": return "text/css; charset=utf-8";
+		case ".gif": return "image/gif";
+		case ".ico": return "image/x-icon";
+		case ".jpg":
+		case ".jpeg": return "image/jpeg";
+		case ".json":
+		case ".map": return "application/json; charset=utf-8";
+		case ".mp3": return "audio/mpeg";
+		case ".mp4": return "video/mp4";
+		case ".png": return "image/png";
+		case ".svg": return "image/svg+xml";
+		case ".txt": return "text/plain; charset=utf-8";
+		case ".webp": return "image/webp";
+		case ".woff": return "font/woff";
+		case ".woff2": return "font/woff2";
+		default: return "application/octet-stream";
+	}
+}
+//#endregion
+//#region src/manual-test-plugin/parse-markdown.ts
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+const markdownProcessor = unified().use(remarkParse).use(remarkGfm).use(remarkRehype, { allowDangerousHtml: true });
+function loadRenderedInstructions(entry, workspaceRoot) {
+	if (!entry.instructionsFilePath) return "";
+	const markdown = readFileSync(resolve(workspaceRoot, entry.instructionsFilePath.slice(1)), "utf8").trim();
+	if (!markdown) return "";
+	return toHtml(markdownProcessor.runSync(markdownProcessor.parse(markdown)), { allowDangerousHtml: true });
+}
+//#endregion
+//#region src/manual-test-plugin/shell-html.ts
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+function createManualShellHtml({ entry, html, shellScriptPublicPath, shellTemplateFilePath, workspaceRoot }) {
+	const shellDocument = parse(readFileSync(shellTemplateFilePath, "utf8"));
+	const shellHead = getRequiredElementByTagName$1(shellDocument, "head");
+	const shellBody = getRequiredElementByTagName$1(shellDocument, "body");
+	const shellTitle = getRequiredElementByTagName$1(shellHead, "title");
+	const shellDataElement = query(shellBody, (candidate) => {
+		return isElementNode(candidate) && getAttribute(candidate, "id") == "manual-shell-data";
+	});
+	const shellScriptElement = getRequiredElementByAttribute(shellHead, "data-manual-shell-script");
+	const manualDocument = parse(html);
+	const manualHead = getRequiredElementByTagName$1(manualDocument, "head");
+	const manualBody = getRequiredElementByTagName$1(manualDocument, "body");
+	const manualTitle = findChildElement(manualHead, "title");
+	const testScriptElement = getRequiredElementByAttribute(shellHead, "data-manual-test-script");
+	const testScriptFileName = posix.basename(entry.scriptFilePath);
+	removeManualTestScriptNodes(manualDocument, testScriptFileName);
+	setTextContent(shellTitle, (manualTitle ? getTextContent(manualTitle) : "").trim() || entry.displayName);
+	setAttribute(shellScriptElement, "src", shellScriptPublicPath);
+	removeAttribute(shellScriptElement, "data-manual-shell-script");
+	setAttribute(testScriptElement, "src", `./${testScriptFileName}`);
+	removeAttribute(testScriptElement, "data-manual-test-script");
+	setTextContent(shellDataElement, stringifyHtmlScriptData(createManualData(entry, workspaceRoot)));
+	copyManualBodyAttributes(manualBody, shellBody);
+	appendChildren(shellHead, manualHead.childNodes.filter(shouldMoveManualHeadNode));
+	appendChild(shellBody, createManualTestContainer(manualBody));
+	return serialize(shellDocument);
+}
+function createManualData(entry, workspaceRoot) {
+	return {
+		displayName: entry.displayName,
+		instructionsHtml: loadRenderedInstructions(entry, workspaceRoot),
+		packageName: entry.packageName
+	};
+}
+function stringifyHtmlScriptData(value) {
+	return JSON.stringify(value).split("<").join("\\u003c");
+}
+function copyManualBodyAttributes(manualBody, shellBody) {
+	for (const { name, value } of manualBody.attrs) {
+		if (name == "class") {
+			setAttribute(shellBody, "class", [getAttribute(shellBody, "class"), value].filter(Boolean).join(" "));
+			continue;
+		}
+		if (!hasAttribute(shellBody, name)) setAttribute(shellBody, name, value);
+	}
+}
+function shouldMoveManualHeadNode(node) {
+	if (!isElementNode(node)) return true;
+	if (node.tagName == "title") return false;
+	if (node.tagName != "meta") return true;
+	return !getAttribute(node, "charset") && getAttribute(node, "name") != "viewport";
+}
+function appendChildren(parent, childNodes) {
+	for (const node of childNodes) {
+		removeNode(node);
+		appendChild(parent, node);
+	}
+}
+function createManualTestContainer(manualBody) {
+	const container = createElement("div", { class: "manual-test-container" });
+	appendChildren(container, [...manualBody.childNodes]);
+	return container;
+}
+function removeManualTestScriptNodes(parent, testScriptFileName) {
+	for (const node of [...parent.childNodes]) {
+		if (!isElementNode(node)) continue;
+		if (isManualTestScriptNode(node, testScriptFileName)) {
+			removeNode(node);
+			continue;
+		}
+		removeManualTestScriptNodes(node, testScriptFileName);
+	}
+}
+function isManualTestScriptNode(node, testScriptFileName) {
+	if (node.tagName != "script") return false;
+	const source = getAttribute(node, "src");
+	if (!source) return false;
+	return getScriptModuleName(posix.basename(source.split("?")[0].split("#")[0])) == getScriptModuleName(testScriptFileName);
+}
+function getScriptModuleName(fileName) {
+	return fileName.replace(/\.[jt]s$/, "");
+}
+function getRequiredElementByTagName$1(root, tagName) {
+	return query(root, (candidate) => isElementNode(candidate) && candidate.tagName == tagName);
+}
+function getRequiredElementByAttribute(root, attributeName) {
+	return query(root, (candidate) => isElementNode(candidate) && hasAttribute(candidate, attributeName));
+}
+function findChildElement(root, tagName) {
+	return root.childNodes.find((node) => isElementNode(node) && node.tagName == tagName);
+}
+//#endregion
+//#region src/manual-test-plugin/plugin.ts
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+const MANUAL_ENTRIES_VIRTUAL_ID = "virtual:ckeditor5-manual-entries";
+const MANUAL_THEME_ROOT = realpathSync(fileURLToPath(import.meta.resolve("@ckeditor/ckeditor5-dev-manual-server/theme")));
+const MANUAL_CATALOG_FILE_PATH = resolve(MANUAL_THEME_ROOT, "catalog.html");
+const MANUAL_CATALOG_SCRIPT_FILE_PATH = resolve(MANUAL_THEME_ROOT, "catalog.ts");
+const MANUAL_SHELL_TEMPLATE_FILE_PATH = resolve(MANUAL_THEME_ROOT, "shell.html");
+const MANUAL_SHELL_SCRIPT_FILE_PATH = resolve(MANUAL_THEME_ROOT, "shell.ts");
+function manualTestsPlugin(manualTestPatterns) {
+	let workspaceRoot = process.cwd();
+	const manualPagePatterns = manualTestPatterns.map(toManualPagePattern);
+	const manualPagesCache = cacheValue(() => collectManualPages(manualPagePatterns, workspaceRoot));
+	const manualStaticAssetsCache = cacheValue(() => collectManualStaticAssets(manualTestPatterns, workspaceRoot));
+	const getManualPages = manualPagesCache.get;
+	const getManualStaticAssets = manualStaticAssetsCache.get;
+	const invalidateManualFileCaches = () => {
+		manualPagesCache.invalidate();
+		manualStaticAssetsCache.invalidate();
+	};
+	const getManualPageEntryForFile = (filePath) => {
+		return getManualPages().get(toPublicSpecifier(relative(workspaceRoot, filePath)));
+	};
+	const getManualCatalogPublicPath = () => toPublicFilePath(MANUAL_CATALOG_FILE_PATH, workspaceRoot);
+	const getManualCatalogScriptPublicPath = () => toPublicFilePath(MANUAL_CATALOG_SCRIPT_FILE_PATH, workspaceRoot);
+	const getManualShellScriptPublicPath = () => toPublicFilePath(MANUAL_SHELL_SCRIPT_FILE_PATH, workspaceRoot);
+	const getManualBuildInputs = () => [MANUAL_CATALOG_FILE_PATH, ...[...getManualPages().values()].map((entry) => resolve(workspaceRoot, entry.htmlFilePath.slice(1)))];
+	const resolvedVirtualModuleId = `\0${MANUAL_ENTRIES_VIRTUAL_ID}`;
+	const getClientEntries = () => [...getManualPages().values()].map((entry) => ({
+		displayName: entry.displayName,
+		href: entry.htmlFilePath,
+		packageName: entry.packageName,
+		slug: entry.slug
+	}));
+	const getManualEntriesJson = () => JSON.stringify(getClientEntries(), null, 2);
+	return {
+		name: "ckeditor5-manual-tests",
+		config() {
+			return { build: { rolldownOptions: { input: getManualBuildInputs() } } };
+		},
+		configResolved(config) {
+			workspaceRoot = config.root;
+			invalidateManualFileCaches();
+			config.build.rolldownOptions.input = getManualBuildInputs();
+		},
+		configureServer(server) {
+			const { memoryFiles } = server.environments.client;
+			useManualTestMiddlewares(server, getManualCatalogPublicPath, getManualStaticAssets);
+			useBundledDevManualHtmlSource(memoryFiles, getManualPages, getManualShellScriptPublicPath, () => workspaceRoot);
+		},
+		configurePreviewServer(server) {
+			useManualCatalogMiddleware(server, getManualCatalogPublicPath);
+		},
+		resolveId(source) {
+			if (source == MANUAL_ENTRIES_VIRTUAL_ID) return resolvedVirtualModuleId;
+			return null;
+		},
+		load(id) {
+			if (id == resolvedVirtualModuleId) return `export const manualTestEntries = ${getManualEntriesJson()};`;
+			return null;
+		},
+		generateBundle() {
+			for (const [publicPath, filePath] of getManualStaticAssets()) this.emitFile({
+				type: "asset",
+				fileName: stripLeadingSlash(publicPath),
+				source: readFileSync(filePath)
+			});
+		},
+		transformIndexHtml: {
+			order: "pre",
+			handler(html, context) {
+				if (toPosixPath(context.filename) == toPosixPath(MANUAL_CATALOG_FILE_PATH)) return html.replace("./catalog.ts", getManualCatalogScriptPublicPath());
+				const entry = getManualPageEntryForFile(context.filename);
+				if (!entry) return;
+				return createManualShellHtml({
+					entry,
+					html,
+					shellScriptPublicPath: getManualShellScriptPublicPath(),
+					shellTemplateFilePath: MANUAL_SHELL_TEMPLATE_FILE_PATH,
+					workspaceRoot
+				});
+			}
+		}
+	};
+}
+function useManualTestMiddlewares(server, getManualCatalogPublicPath, getManualStaticAssets) {
+	server.middlewares.use(createManualStaticAssetsMiddleware(getManualStaticAssets));
+	useManualCatalogMiddleware(server, getManualCatalogPublicPath);
+}
+function useManualCatalogMiddleware(server, getManualCatalogPublicPath) {
+	server.middlewares.use((request, _response, next) => {
+		rewriteCatalogRequest(request, getManualCatalogPublicPath());
+		next();
+	});
+}
+function useBundledDevManualHtmlSource(memoryFiles, getManualPages, getManualShellScriptPublicPath, getWorkspaceRoot) {
+	if (!memoryFiles) return;
+	const getBundledFile = memoryFiles.get.bind(memoryFiles);
+	memoryFiles.get = (filePath) => {
+		const file = getBundledFile(filePath);
+		const entry = getManualPages().get(toPublicSpecifier(filePath));
+		if (!file || !entry) return file;
+		const workspaceRoot = getWorkspaceRoot();
+		const shellScriptPublicPath = getManualShellScriptPublicPath();
+		const bundledHtml = getFileSource(file);
+		return { source: mergeBundledAssetTags(createManualShellHtml({
+			entry,
+			html: readFileSync(resolve(workspaceRoot, stripLeadingSlash(entry.htmlFilePath)), "utf8"),
+			shellScriptPublicPath,
+			shellTemplateFilePath: MANUAL_SHELL_TEMPLATE_FILE_PATH,
+			workspaceRoot
+		}), bundledHtml, entry, shellScriptPublicPath) };
+	};
+}
+function getFileSource(file) {
+	return typeof file.source == "string" ? file.source : Buffer.from(file.source).toString("utf8");
+}
+function toManualPagePattern(pattern) {
+	if (/\.(?:html|js|md|ts|\{[^}]*\})$/.test(pattern)) return pattern;
+	return `${pattern}.{html,js,md,ts}`;
+}
+function mergeBundledAssetTags(sourceHtml, bundledHtml, entry, shellScriptPublicPath) {
+	const sourceDocument = parse(sourceHtml);
+	const bundledDocument = parse(bundledHtml);
+	const sourceHead = getRequiredElementByTagName(sourceDocument, "head");
+	const bundledHead = getRequiredElementByTagName(bundledDocument, "head");
+	const testScriptFileName = posix.basename(entry.scriptFilePath);
+	const hasBundledShellAsset = bundledHead.childNodes.some((node) => isBundledModuleAsset(node, "shell"));
+	for (const node of [...sourceHead.childNodes]) if (isSourceTestScript(node, testScriptFileName) || hasBundledShellAsset && isSourceShellScript(node, shellScriptPublicPath)) removeNode(node);
+	for (const node of bundledHead.childNodes.filter(isBundledAssetTag)) {
+		removeNode(node);
+		appendChild(sourceHead, node);
+	}
+	return serialize(sourceDocument);
+}
+function isSourceTestScript(node, testScriptFileName) {
+	if (!isElementNode(node) || node.tagName != "script") return false;
+	const source = getAttribute(node, "src");
+	if (!source) return false;
+	return posix.basename(source) == testScriptFileName;
+}
+function isSourceShellScript(node, shellScriptPublicPath) {
+	return isElementNode(node) && node.tagName == "script" && getAttribute(node, "src") == shellScriptPublicPath;
+}
+function isBundledModuleAsset(node, moduleName) {
+	if (!isElementNode(node)) return false;
+	if (node.tagName == "script") return isBundledModulePath(getAttribute(node, "src"), moduleName);
+	return node.tagName == "link" && getAttribute(node, "rel") == "modulepreload" && isBundledModulePath(getAttribute(node, "href"), moduleName);
+}
+function isBundledModulePath(path, moduleName) {
+	return Boolean(path?.startsWith(`/assets/${moduleName}-`));
+}
+function isBundledAssetTag(node) {
+	if (!isElementNode(node)) return false;
+	return Boolean(node.tagName == "script" && getAttribute(node, "src")?.startsWith("/assets/") || node.tagName == "link" && getAttribute(node, "href")?.startsWith("/assets/"));
+}
+function rewriteCatalogRequest(request, manualCatalogPublicPath) {
+	const url = parseRequestUrl(request.url);
+	if (!url) return;
+	if (url.pathname == "/" || url.pathname == "/index.html") request.url = `${manualCatalogPublicPath}${url.search}`;
+}
+function parseRequestUrl(requestUrl) {
+	return URL.parse(requestUrl || "", "http://localhost");
+}
+function getRequiredElementByTagName(root, tagName) {
+	return query(root, (candidate) => isElementNode(candidate) && candidate.tagName == tagName);
+}
+//#endregion
+//#region src/refresh-plugin/plugin.ts
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+const MANUAL_REFRESH_EVENT_NAME = "ckeditor5-manual:refresh-available";
+const isManualRefreshWrappedClient = Symbol("isManualRefreshWrappedClient");
+function refreshPlugin() {
+	return {
+		name: "ckeditor5-manual-refresh",
+		apply: "serve",
+		configureServer(server) {
+			const clientEnvironment = server.environments.client;
+			wrapBundledDevClientSend(clientEnvironment.clients);
+			wrapBundledDevFullReloads(clientEnvironment);
+		}
+	};
+}
+function wrapBundledDevClientSend(clients) {
+	if (!clients) return;
+	const setupIfNeeded = clients.setupIfNeeded.bind(clients);
+	clients.setupIfNeeded = (client, clientId) => {
+		if (!client[isManualRefreshWrappedClient]) {
+			const send = client.send.bind(client);
+			client.send = (payload) => {
+				sendManualRefreshPayload(payload, send);
+			};
+			client[isManualRefreshWrappedClient] = true;
+		}
+		return setupIfNeeded(client, clientId);
+	};
+}
+function wrapBundledDevFullReloads(clientEnvironment) {
+	if (!clientEnvironment.handleHmrOutput) return;
+	const handleHmrOutput = clientEnvironment.handleHmrOutput.bind(clientEnvironment);
+	clientEnvironment.handleHmrOutput = (client, files, hmrOutput, invalidateInformation) => {
+		if (hmrOutput.type == "FullReload" && shouldShowManualRefreshPromptForFiles(files)) {
+			clientEnvironment.devEngine?.ensureLatestBuildOutput().catch(() => {});
+			client.send({
+				type: "custom",
+				event: MANUAL_REFRESH_EVENT_NAME
+			});
+			return;
+		}
+		return handleHmrOutput(client, files, hmrOutput, invalidateInformation);
+	};
+}
+function sendManualRefreshPayload(payload, send) {
+	if (shouldShowManualRefreshPrompt(payload)) {
+		send({
+			type: "custom",
+			event: MANUAL_REFRESH_EVENT_NAME
+		});
+		return;
+	}
+	send(payload);
+}
+function shouldShowManualRefreshPrompt(payload) {
+	if (payload.type == "update") return !isCssUpdatePayload(payload);
+	return false;
+}
+function isCssUpdatePayload(payload) {
+	return payload.type == "update" && payload.updates.length > 0 && payload.updates.every((update) => {
+		return update.type == "css-update" || update.type == "js-update" && update.acceptedPath.endsWith(".css");
+	});
+}
+function shouldShowManualRefreshPromptForFiles(files) {
+	return files.some((file) => !file.endsWith(".css") && !file.endsWith(".html"));
+}
+//#endregion
+//#region src/raw-plugin/plugin.ts
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+const RAW_QUERY = "?ckeditor5-raw";
+function rawHtmlPlugin() {
+	return {
+		name: "ckeditor5-raw",
+		enforce: "pre",
+		resolveId(source, importer) {
+			if (!importer || source.includes("?")) return null;
+			if (path.extname(source) != ".html") return null;
+			const filePath = resolveHtmlFilePath(source, importer);
+			if (filePath) return `${filePath}${RAW_QUERY}`;
+			return null;
+		},
+		async load(id) {
+			if (!id.endsWith(RAW_QUERY)) return null;
+			const source = await readFile(id.slice(0, -14), "utf8");
+			return {
+				code: `export default ${JSON.stringify(source)};`,
+				map: null
+			};
+		}
+	};
+}
+function resolveHtmlFilePath(source, importer) {
+	if (!source.startsWith(".")) return null;
+	const filePath = path.resolve(path.dirname(getFilePathFromId(importer)), source);
+	return existsSync(filePath) ? toPosixPath(filePath) : null;
+}
+function getFilePathFromId(id) {
+	const queryIndex = id.indexOf("?");
+	return queryIndex >= 0 ? id.slice(0, queryIndex) : id;
+}
+//#endregion
+//#region src/index.ts
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+//#endregion
+export { manualTestsPlugin, rawHtmlPlugin, refreshPlugin, stringifyValues };

package/dist/manual-test-plugin/collect-pages.d.ts

@@ -0,0 +1,6 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+import type { ManualPageEntry } from "./types.js";
+export declare function collectManualPages(patterns: Array<string>, workspaceRoot: string): Map<string, ManualPageEntry>;

package/dist/manual-test-plugin/parse-markdown.d.ts

@@ -0,0 +1,6 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+import type { ManualPageEntry } from "./types.js";
+export declare function loadRenderedInstructions(entry: ManualPageEntry, workspaceRoot: string): string;

package/dist/manual-test-plugin/plugin.d.ts

@@ -0,0 +1,7 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+import type { Plugin } from "vite";
+export type { ManualData } from "./types.js";
+export declare function manualTestsPlugin(manualTestPatterns: Array<string>): Plugin;

package/dist/manual-test-plugin/shell-html.d.ts

@@ -0,0 +1,13 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+import type { ManualPageEntry } from "./types.js";
+export interface CreateManualShellHtmlOptions {
+	entry: ManualPageEntry;
+	html: string;
+	shellScriptPublicPath: string;
+	shellTemplateFilePath: string;
+	workspaceRoot: string;
+}
+export declare function createManualShellHtml({ entry, html, shellScriptPublicPath, shellTemplateFilePath, workspaceRoot }: CreateManualShellHtmlOptions): string;

package/dist/manual-test-plugin/static-assets.d.ts

@@ -0,0 +1,10 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+import type { IncomingMessage, ServerResponse } from "node:http";
+type ManualStaticAssetsMiddleware = (request: IncomingMessage, response: ServerResponse, next: () => void) => void;
+export declare function collectManualStaticAssets(patterns: Array<string>, workspaceRoot: string): Map<string, string>;
+export declare function createManualStaticAssetsMiddleware(collectStaticAssets: () => Map<string, string>): ManualStaticAssetsMiddleware;
+export declare function getManualStaticAssetFilePath(requestUrl: string | undefined, staticAssets: Map<string, string>): string | null;
+export {};