@ckeditor/ckeditor5-dev-manual-server 57.4.0 → 59.0.0

package/dist/index.d.ts

@@ -3,7 +3,6 @@
 * For licensing, see LICENSE.md.
 */
 export { manualTestsPlugin, type ManualTestsPluginOptions } from "./manual-test-plugin/plugin.js";
-export { manualStaticAssetsPlugin, type ManualStaticAssetsPluginOptions } from "./static-assets-plugin/plugin.js";
 export { ckDebugPlugin } from "./debug-plugin/plugin.js";
 export { refreshPlugin } from "./refresh-plugin/plugin.js";
 export { rawSvgPlugin } from "./svg-plugin/plugin.js";

package/dist/index.js

@@ -1,6 +1,6 @@
-import { createReadStream, existsSync, globSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { existsSync, globSync, readFileSync, realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { basename, extname, isAbsolute, posix, relative, resolve } from "node:path";
+import { basename, isAbsolute, posix, relative, resolve } from "node:path";
 //#region src/utils.ts
 /**
 * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
@@ -61,11 +61,11 @@ function stripLeadingSlash(value) {
 * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
 * For licensing, see LICENSE.md.
 */
-const MANUAL_TESTS_DIRECTORY$1 = "tests/manual/";
-const MANUAL_TEST_SUFFIX$2 = ".manual.html";
+const MANUAL_TESTS_DIRECTORY$1 = "manual/";
+const MANUAL_TEST_SUFFIX$1 = ".manual.html";
 /**
 * Discovers manual test pages. A manual test is a single full HTML document named
-* `<slug>.manual.html` located under a package's `tests/manual/` directory. Plain `.html`
+* `<slug>.manual.html` located under a package's `manual/` directory. Plain `.html`
 * files are treated as static fixtures and are never collected here.
 *
 * The `patterns` are package root globs, for example `packages/*`.
@@ -75,12 +75,12 @@ function collectManualPages(patterns, workspaceRoot) {
 	return new Map(manualPages);
 }
 function matchManualPageFiles(patterns, workspaceRoot) {
-	return patterns.map((pattern) => `${pattern.replace(/\/+$/, "")}/${MANUAL_TESTS_DIRECTORY$1}**/*${MANUAL_TEST_SUFFIX$2}`).flatMap((pattern) => globSync(pattern, { cwd: workspaceRoot }).map((match) => toPosixPath(match)));
+	return patterns.map((pattern) => `${pattern.replace(/\/+$/, "")}/${MANUAL_TESTS_DIRECTORY$1}**/*${MANUAL_TEST_SUFFIX$1}`).flatMap((pattern) => globSync(pattern, { cwd: workspaceRoot }).map((match) => toPosixPath(match)));
 }
 function toManualPageEntry(relativeFilePath, workspaceRoot) {
 	const directoryStartIndex = relativeFilePath.startsWith(MANUAL_TESTS_DIRECTORY$1) ? 0 : relativeFilePath.indexOf(`/${MANUAL_TESTS_DIRECTORY$1}`) + 1;
 	const packagePath = relativeFilePath.slice(0, Math.max(directoryStartIndex - 1, 0));
-	const slugPath = relativeFilePath.slice(directoryStartIndex + 13);
+	const slugPath = relativeFilePath.slice(directoryStartIndex + 7);
 	return {
 		htmlFilePath: toPublicSpecifier(relativeFilePath),
 		packageName: packagePath ? packagePath.slice(packagePath.lastIndexOf("/") + 1) : basename(workspaceRoot),
@@ -94,9 +94,9 @@ function toManualPageEntry(relativeFilePath, workspaceRoot) {
 * For licensing, see LICENSE.md.
 */
 const MANUAL_HEADER_ELEMENT = "ck-manual-header";
-const MANUAL_TEST_SUFFIX$1 = ".manual.html";
-const MANUAL_TESTS_DIRECTORY = "/tests/manual/";
-const THEME_ENTRY_FILE_PATH = "theme/index.css";
+const MANUAL_TEST_SUFFIX = ".manual.html";
+const MANUAL_TESTS_DIRECTORY = "/manual/";
+const THEME_ENTRY_FILE_PATHS = ["theme/index-editor.css", "theme/index-content.css"];
 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");
@@ -113,14 +113,14 @@ function manualTestsPlugin(options) {
 		return getManualPages().get(toPublicSpecifier(relative(workspaceRoot, filePath)));
 	};
 	const getManualPageEntryForScriptSpecifier = (scriptSpecifier) => {
-		const htmlSpecifier = scriptSpecifier.replace(/\.(?:js|ts)$/, MANUAL_TEST_SUFFIX$1);
+		const htmlSpecifier = scriptSpecifier.replace(/\.(?:js|ts)$/, MANUAL_TEST_SUFFIX);
 		return htmlSpecifier == scriptSpecifier ? void 0 : getManualPages().get(htmlSpecifier);
 	};
 	const packageThemeEntryCache = /* @__PURE__ */ new Map();
-	const hasPackageThemeEntry = (packageRootSpecifier) => {
+	const getPackageThemeEntries = (packageRootSpecifier) => {
 		if (!packageThemeEntryCache.has(packageRootSpecifier)) {
-			const themeEntryFilePath = resolve(workspaceRoot, stripLeadingSlash(packageRootSpecifier), THEME_ENTRY_FILE_PATH);
-			packageThemeEntryCache.set(packageRootSpecifier, existsSync(themeEntryFilePath));
+			const themeEntries = THEME_ENTRY_FILE_PATHS.filter((themeEntryFilePath) => existsSync(resolve(workspaceRoot, stripLeadingSlash(packageRootSpecifier), themeEntryFilePath)));
+			packageThemeEntryCache.set(packageRootSpecifier, themeEntries);
 		}
 		return packageThemeEntryCache.get(packageRootSpecifier);
 	};
@@ -174,9 +174,12 @@ function manualTestsPlugin(options) {
 				const entry = getManualPageEntryForScriptSpecifier(scriptSpecifier);
 				if (!entry) return;
 				const packageRootSpecifier = entry.htmlFilePath.slice(0, entry.htmlFilePath.indexOf(MANUAL_TESTS_DIRECTORY));
-				if (!hasPackageThemeEntry(packageRootSpecifier)) return;
+				const themeEntries = getPackageThemeEntries(packageRootSpecifier);
+				if (!themeEntries.length) return;
 				return {
-					code: `${code}\nimport '${posix.relative(posix.dirname(scriptSpecifier), `${packageRootSpecifier}/${THEME_ENTRY_FILE_PATH}`)}';\n`,
+					code: `${code}\n${themeEntries.map((themeEntryFilePath) => {
+						return `import '${posix.relative(posix.dirname(scriptSpecifier), `${packageRootSpecifier}/${themeEntryFilePath}`)}';`;
+					}).join("\n")}\n`,
 					map: null
 				};
 			}
@@ -324,126 +327,6 @@ function parseRequestUrl(requestUrl) {
 	return URL.parse(requestUrl || "", "http://localhost");
 }
 //#endregion
-//#region src/static-assets-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 = /* @__PURE__ */ new Set([".js", ".ts"]);
-const MANUAL_TEST_SUFFIX = ".manual.html";
-const VITE_MODULE_QUERY_PARAMETERS = /* @__PURE__ */ new Set([
-	"import",
-	"raw",
-	"url",
-	"worker",
-	"inline"
-]);
-function collectManualStaticAssets(patterns, workspaceRoot) {
-	return new Map(patterns.map((pattern) => `${pattern.replace(/\/+$/, "")}/tests/manual/**/*`).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) {
-	if (filePath.endsWith(MANUAL_TEST_SUFFIX)) return false;
-	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 ".htm":
-		case ".html": return "text/html; charset=utf-8";
-		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/static-assets-plugin/plugin.ts
-/**
-* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
-* For licensing, see LICENSE.md.
-*/
-function manualStaticAssetsPlugin(options) {
-	let workspaceRoot = process.cwd();
-	const includePackageNames = (options.include || []).filter(Boolean);
-	const getManualStaticAssets = cacheValue(() => filterManualStaticAssets(collectManualStaticAssets(options.paths, workspaceRoot), includePackageNames, workspaceRoot)).get;
-	return {
-		name: "ckeditor5-manual-static-assets",
-		configResolved(config) {
-			workspaceRoot = config.root;
-		},
-		configureServer(server) {
-			server.middlewares.use(createManualStaticAssetsMiddleware(getManualStaticAssets));
-		},
-		generateBundle() {
-			for (const [publicPath, filePath] of getManualStaticAssets()) this.emitFile({
-				type: "asset",
-				fileName: stripLeadingSlash(publicPath),
-				source: readFileSync(filePath)
-			});
-		}
-	};
-}
-function filterManualStaticAssets(staticAssets, includePackageNames, workspaceRoot) {
-	const isIncluded = createPackageNameFilter(includePackageNames);
-	return new Map([...staticAssets].filter(([publicPath]) => isIncluded(getManualTestPackageName(publicPath, workspaceRoot))));
-}
-function getManualTestPackageName(publicPath, workspaceRoot) {
-	if (publicPath.startsWith("/tests/manual/")) return basename(workspaceRoot);
-	return publicPath.match(/^\/(?:.*\/)?([^/]+)\/tests\/manual\//)?.[1] || null;
-}
-//#endregion
 //#region src/debug-plugin/plugin.ts
 /**
 * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
@@ -494,7 +377,7 @@ function refreshPlugin() {
 			const bundledDev = server.environments.client.bundledDev;
 			if (!bundledDev) return;
 			wrapBundledDevClientSend(bundledDev.clients);
-			wrapBundledDevFullReloads(bundledDev);
+			wrapBundledDevFullReloads(bundledDev, server.config.root);
 		}
 	};
 }
@@ -512,27 +395,42 @@ function wrapBundledDevClientSend(clients) {
 		return setupIfNeeded(client, clientId);
 	};
 }
-function wrapBundledDevFullReloads(bundledDev) {
+function wrapBundledDevFullReloads(bundledDev, workspaceRoot) {
 	if (typeof bundledDev.handleHmrOutput != "function") return;
 	const handleHmrOutput = bundledDev.handleHmrOutput.bind(bundledDev);
 	bundledDev.handleHmrOutput = (client, files, hmrOutput, invalidateInformation) => {
-		if (hmrOutput.type == "FullReload" && shouldShowManualRefreshPromptForFiles(files)) {
-			ensureLatestBuildOutput(bundledDev);
-			client.send({
-				type: "custom",
-				event: MANUAL_REFRESH_EVENT_NAME
-			});
+		if (hmrOutput.type != "FullReload") return handleHmrOutput(client, files, hmrOutput, invalidateInformation);
+		if (!shouldShowManualRefreshPromptForFiles(files)) {
+			reloadClientAfterLatestBuildOutput(bundledDev, client, files, workspaceRoot);
 			return;
 		}
-		return handleHmrOutput(client, files, hmrOutput, invalidateInformation);
+		ensureLatestBuildOutput(bundledDev);
+		client.send({
+			type: "custom",
+			event: MANUAL_REFRESH_EVENT_NAME
+		});
 	};
 }
+async function reloadClientAfterLatestBuildOutput(bundledDev, client, files, workspaceRoot) {
+	try {
+		await bundledDev.devEngine?.ensureLatestBuildOutput();
+	} catch {}
+	client.send({
+		type: "full-reload",
+		path: getChangedHtmlPublicPath(files, workspaceRoot)
+	});
+}
+function getChangedHtmlPublicPath(files, workspaceRoot) {
+	const htmlFile = files.find((file) => file.endsWith(".html"));
+	return htmlFile ? toPublicFilePath(htmlFile, workspaceRoot) : void 0;
+}
 function ensureLatestBuildOutput(bundledDev) {
 	try {
 		bundledDev.devEngine?.ensureLatestBuildOutput().catch(() => {});
 	} catch {}
 }
 function sendManualRefreshPayload(payload, send) {
+	if (payload.type == "update" && !payload.updates.length) return;
 	if (shouldShowManualRefreshPrompt(payload)) {
 		send({
 			type: "custom",
@@ -583,4 +481,4 @@ function rawSvgPlugin() {
 * For licensing, see LICENSE.md.
 */
 //#endregion
-export { ckDebugPlugin, manualStaticAssetsPlugin, manualTestsPlugin, rawSvgPlugin, refreshPlugin, stringifyValues };
+export { ckDebugPlugin, manualTestsPlugin, rawSvgPlugin, refreshPlugin, stringifyValues };

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

@@ -5,7 +5,7 @@
 import type { ManualPageEntry } from "./types.js";
 /**
 * Discovers manual test pages. A manual test is a single full HTML document named
-* `<slug>.manual.html` located under a package's `tests/manual/` directory. Plain `.html`
+* `<slug>.manual.html` located under a package's `manual/` directory. Plain `.html`
 * files are treated as static fixtures and are never collected here.
 *
 * The `patterns` are package root globs, for example `packages/*`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckeditor/ckeditor5-dev-manual-server",
-  "version": "57.4.0",
+  "version": "59.0.0",
   "description": "Used to extend Vite to create a manual test server for CKEditor 5.",
   "keywords": [],
   "author": "CKSource (http://cksource.com/)",

package/theme/catalog-favorites.ts

@@ -0,0 +1,94 @@
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+interface FavoritableEntry {
+	packageName: string;
+	slug: string;
+}
+
+const FAVORITES_STORAGE_KEY = 'ckeditor5-manual-test-favorites';
+
+/**
+ * Returns the stable identifier used to persist a manual test as a favorite.
+ */
+export function getFavoriteId( entry: FavoritableEntry ): string {
+	return `${ entry.packageName }/${ entry.slug }`;
+}
+
+/**
+ * Returns the accessible label for a favorite toggle action.
+ */
+export function getFavoriteActionLabel( isFavorite: boolean ): string {
+	return isFavorite ? 'Remove from favorites' : 'Add to favorites';
+}
+
+/**
+ * Updates a favorite button from the current favorite identifier set.
+ */
+export function updateFavoriteButtonState(
+	button: HTMLButtonElement,
+	favoriteIds: Set<string>,
+	favoriteId: string
+): void {
+	const isFavorite = favoriteIds.has( favoriteId );
+	const label = getFavoriteActionLabel( isFavorite );
+
+	button.title = label;
+	button.setAttribute( 'aria-label', label );
+	button.setAttribute( 'aria-pressed', String( isFavorite ) );
+	button.classList.toggle( 'favorite--active', isFavorite );
+}
+
+/**
+ * Returns favorite entries in their original order.
+ */
+export function filterFavoriteEntries<T extends FavoritableEntry>( entries: Array<T>, favoriteIds: Set<string> ): Array<T> {
+	return entries.filter( entry => favoriteIds.has( getFavoriteId( entry ) ) );
+}
+
+/**
+ * Toggles an identifier in the favorite set.
+ */
+export function toggleFavoriteId( favoriteIds: Set<string>, favoriteId: string ): void {
+	if ( favoriteIds.has( favoriteId ) ) {
+		favoriteIds.delete( favoriteId );
+	} else {
+		favoriteIds.add( favoriteId );
+	}
+}
+
+/**
+ * Loads favorite entry identifiers from local storage.
+ */
+export function loadFavoriteIds(): Set<string> {
+	try {
+		const storedValue = localStorage.getItem( FAVORITES_STORAGE_KEY );
+
+		if ( !storedValue ) {
+			return new Set();
+		}
+
+		const parsedValue: unknown = JSON.parse( storedValue );
+
+		if ( !Array.isArray( parsedValue ) || parsedValue.some( value => typeof value != 'string' ) ) {
+			return new Set();
+		}
+
+		return new Set( parsedValue );
+	} catch {
+		return new Set();
+	}
+}
+
+/**
+ * Persists favorite entry identifiers in local storage.
+ */
+export function saveFavoriteIds( favoriteIds: Set<string> ): void {
+	try {
+		localStorage.setItem( FAVORITES_STORAGE_KEY, JSON.stringify( [ ...favoriteIds ] ) );
+	} catch {
+		// Favorites are optional, so storage failures must not block the catalog.
+	}
+}

package/theme/catalog-search.ts

@@ -0,0 +1,152 @@
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+interface SearchableEntry {
+	packageName: string;
+	slug: string;
+}
+
+const PACKAGE_MATCH_PRIORITY = {
+	exactName: 0,
+	namePrefix: 1,
+	nameContains: 2,
+	testSlugOnly: 3
+} as const;
+
+type PackageMatchPriority = typeof PACKAGE_MATCH_PRIORITY[keyof typeof PACKAGE_MATCH_PRIORITY];
+
+interface PackageSearchResult<T extends SearchableEntry> {
+	visibleEntries: Array<T>;
+	priority: PackageMatchPriority;
+	matchingSlugCount: number;
+}
+
+export interface MatchOffset {
+	start: number;
+	end: number;
+}
+
+/**
+ * Filters tests and orders matching packages by relevance:
+ *
+ * 1. Exact full or short package name, e.g. `ckeditor5-table` or `table`.
+ * 2. Package name whose full or short name starts with the query.
+ * 3. Package name containing the query.
+ * 4. Packages with matching test slugs only.
+ *
+ * Packages at the same priority are ordered by the number of matching test slugs. Stable sorting
+ * preserves the original package order when that number is also equal. Tests within a package
+ * always retain their original order.
+ *
+ * A package-name match shows all tests from that package. A slug match shows only matching tests.
+ */
+export function filterEntries<T extends SearchableEntry>( entries: Array<T>, normalizedQuery: string ): Array<T> {
+	if ( !normalizedQuery ) {
+		return entries;
+	}
+
+	const packageGroups = groupEntriesByPackage( entries );
+	const searchResults = [ ...packageGroups.entries() ]
+		.map( ( [ packageName, packageEntries ] ) => createPackageSearchResult(
+			packageName,
+			packageEntries,
+			normalizedQuery
+		) )
+		.filter( result => result.visibleEntries.length );
+
+	searchResults.sort( comparePackageSearchResults );
+
+	return searchResults.flatMap( result => result.visibleEntries );
+}
+
+/**
+ * Groups entries by package while preserving their original order.
+ */
+function groupEntriesByPackage<T extends SearchableEntry>( entries: Array<T> ): Map<string, Array<T>> {
+	const packageGroups = new Map<string, Array<T>>();
+
+	for ( const entry of entries ) {
+		const packageEntries = packageGroups.get( entry.packageName ) || [];
+
+		packageEntries.push( entry );
+		packageGroups.set( entry.packageName, packageEntries );
+	}
+
+	return packageGroups;
+}
+
+/**
+ * Creates the visible entries and ranking metadata for one package.
+ */
+function createPackageSearchResult<T extends SearchableEntry>(
+	packageName: string,
+	packageEntries: Array<T>,
+	normalizedQuery: string
+): PackageSearchResult<T> {
+	const priority = getPackageMatchPriority( packageName, normalizedQuery );
+	const matchingSlugEntries = packageEntries.filter( entry => entry.slug.toLowerCase().includes( normalizedQuery ) );
+	const packageNameMatches = priority != PACKAGE_MATCH_PRIORITY.testSlugOnly;
+
+	return {
+		visibleEntries: packageNameMatches ? packageEntries : matchingSlugEntries,
+		priority,
+		matchingSlugCount: matchingSlugEntries.length
+	};
+}
+
+/**
+ * Orders package search results by match priority and matching test count.
+ */
+function comparePackageSearchResults<T extends SearchableEntry>(
+	first: PackageSearchResult<T>,
+	second: PackageSearchResult<T>
+): number {
+	return first.priority - second.priority ||
+		second.matchingSlugCount - first.matchingSlugCount;
+}
+
+/**
+ * Returns how closely a package name matches the normalized query.
+ */
+function getPackageMatchPriority( packageName: string, normalizedQuery: string ): PackageMatchPriority {
+	const normalizedPackageName = packageName.toLowerCase();
+	const searchablePackageNames = [ normalizedPackageName, normalizedPackageName.replace( /^ckeditor5-/, '' ) ];
+
+	if ( searchablePackageNames.includes( normalizedQuery ) ) {
+		return PACKAGE_MATCH_PRIORITY.exactName;
+	}
+
+	if ( searchablePackageNames.some( name => name.startsWith( normalizedQuery ) ) ) {
+		return PACKAGE_MATCH_PRIORITY.namePrefix;
+	}
+
+	if ( searchablePackageNames.some( name => name.includes( normalizedQuery ) ) ) {
+		return PACKAGE_MATCH_PRIORITY.nameContains;
+	}
+
+	return PACKAGE_MATCH_PRIORITY.testSlugOnly;
+}
+
+/**
+ * Returns offsets of all non-overlapping, case-insensitive query matches in text.
+ */
+export function findMatchOffsets( text: string, normalizedQuery: string ): Array<MatchOffset> {
+	if ( !normalizedQuery ) {
+		return [];
+	}
+
+	const normalizedText = text.toLowerCase();
+	const matches: Array<MatchOffset> = [];
+	let matchStart = normalizedText.indexOf( normalizedQuery );
+
+	while ( matchStart != -1 ) {
+		const matchEnd = matchStart + normalizedQuery.length;
+
+		matches.push( { start: matchStart, end: matchEnd } );
+		matchStart = normalizedText.indexOf( normalizedQuery, matchEnd );
+	}
+
+	return matches;
+}