@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/util/vs/base/common/hash.ts

@@ -1,326 +0,0 @@
-//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { encodeHex, VSBuffer } from './buffer';
-import * as strings from './strings';
-
-type NotSyncHashable = ArrayBufferLike | ArrayBufferView;
-
-/**
- * Return a hash value for an object.
- *
- * Note that this should not be used for binary data types. Instead,
- * prefer {@link hashAsync}.
- */
-export function hash<T>(obj: T extends NotSyncHashable ? never : T): number {
-	return doHash(obj, 0);
-}
-
-export function doHash(obj: unknown, hashVal: number): number {
-	switch (typeof obj) {
-		case 'object':
-			if (obj === null) {
-				return numberHash(349, hashVal);
-			} else if (Array.isArray(obj)) {
-				return arrayHash(obj, hashVal);
-			}
-			return objectHash(obj, hashVal);
-		case 'string':
-			return stringHash(obj, hashVal);
-		case 'boolean':
-			return booleanHash(obj, hashVal);
-		case 'number':
-			return numberHash(obj, hashVal);
-		case 'undefined':
-			return numberHash(937, hashVal);
-		default:
-			return numberHash(617, hashVal);
-	}
-}
-
-export function numberHash(val: number, initialHashVal: number): number {
-	return (((initialHashVal << 5) - initialHashVal) + val) | 0;  // hashVal * 31 + ch, keep as int32
-}
-
-function booleanHash(b: boolean, initialHashVal: number): number {
-	return numberHash(b ? 433 : 863, initialHashVal);
-}
-
-export function stringHash(s: string, hashVal: number) {
-	hashVal = numberHash(149417, hashVal);
-	for (let i = 0, length = s.length; i < length; i++) {
-		hashVal = numberHash(s.charCodeAt(i), hashVal);
-	}
-	return hashVal;
-}
-
-function arrayHash(arr: any[], initialHashVal: number): number {
-	initialHashVal = numberHash(104579, initialHashVal);
-	return arr.reduce((hashVal, item) => doHash(item, hashVal), initialHashVal);
-}
-
-function objectHash(obj: any, initialHashVal: number): number {
-	initialHashVal = numberHash(181387, initialHashVal);
-	return Object.keys(obj).sort().reduce((hashVal, key) => {
-		hashVal = stringHash(key, hashVal);
-		return doHash(obj[key], hashVal);
-	}, initialHashVal);
-}
-
-
-
-/** Hashes the input as SHA-1, returning a hex-encoded string. */
-export const hashAsync = (input: string | ArrayBufferView | VSBuffer) => {
-	// Note: I would very much like to expose a streaming interface for hashing
-	// generally, but this is not available in web crypto yet, see
-	// https://github.com/w3c/webcrypto/issues/73
-
-	// StringSHA1 is faster for small string input, use it since we have it:
-	if (typeof input === 'string' && input.length < 250) {
-		const sha = new StringSHA1();
-		sha.update(input);
-		return Promise.resolve(sha.digest());
-	}
-
-	let buff: ArrayBufferView;
-	if (typeof input === 'string') {
-		buff = new TextEncoder().encode(input);
-	} else if (input instanceof VSBuffer) {
-		buff = input.buffer;
-	} else {
-		buff = input;
-	}
-
-	return crypto.subtle.digest('sha-1', buff as ArrayBufferView<ArrayBuffer>).then(toHexString); // CodeQL [SM04514] we use sha1 here for validating old stored client state, not for security
-};
-
-const enum SHA1Constant {
-	BLOCK_SIZE = 64, // 512 / 8
-	UNICODE_REPLACEMENT = 0xFFFD,
-}
-
-function leftRotate(value: number, bits: number, totalBits: number = 32): number {
-	// delta + bits = totalBits
-	const delta = totalBits - bits;
-
-	// All ones, expect `delta` zeros aligned to the right
-	const mask = ~((1 << delta) - 1);
-
-	// Join (value left-shifted `bits` bits) with (masked value right-shifted `delta` bits)
-	return ((value << bits) | ((mask & value) >>> delta)) >>> 0;
-}
-
-function toHexString(buffer: ArrayBuffer): string;
-function toHexString(value: number, bitsize?: number): string;
-function toHexString(bufferOrValue: ArrayBuffer | number, bitsize: number = 32): string {
-	if (bufferOrValue instanceof ArrayBuffer) {
-		return encodeHex(VSBuffer.wrap(new Uint8Array(bufferOrValue)));
-	}
-
-	return (bufferOrValue >>> 0).toString(16).padStart(bitsize / 4, '0');
-}
-
-/**
- * A SHA1 implementation that works with strings and does not allocate.
- *
- * Prefer to use {@link hashAsync} in async contexts
- */
-export class StringSHA1 {
-	private static _bigBlock32 = new DataView(new ArrayBuffer(320)); // 80 * 4 = 320
-
-	private _h0 = 0x67452301;
-	private _h1 = 0xEFCDAB89;
-	private _h2 = 0x98BADCFE;
-	private _h3 = 0x10325476;
-	private _h4 = 0xC3D2E1F0;
-
-	private readonly _buff: Uint8Array;
-	private readonly _buffDV: DataView;
-	private _buffLen: number;
-	private _totalLen: number;
-	private _leftoverHighSurrogate: number;
-	private _finished: boolean;
-
-	constructor() {
-		this._buff = new Uint8Array(SHA1Constant.BLOCK_SIZE + 3 /* to fit any utf-8 */);
-		this._buffDV = new DataView(this._buff.buffer);
-		this._buffLen = 0;
-		this._totalLen = 0;
-		this._leftoverHighSurrogate = 0;
-		this._finished = false;
-	}
-
-	public update(str: string): void {
-		const strLen = str.length;
-		if (strLen === 0) {
-			return;
-		}
-
-		const buff = this._buff;
-		let buffLen = this._buffLen;
-		let leftoverHighSurrogate = this._leftoverHighSurrogate;
-		let charCode: number;
-		let offset: number;
-
-		if (leftoverHighSurrogate !== 0) {
-			charCode = leftoverHighSurrogate;
-			offset = -1;
-			leftoverHighSurrogate = 0;
-		} else {
-			charCode = str.charCodeAt(0);
-			offset = 0;
-		}
-
-		while (true) {
-			let codePoint = charCode;
-			if (strings.isHighSurrogate(charCode)) {
-				if (offset + 1 < strLen) {
-					const nextCharCode = str.charCodeAt(offset + 1);
-					if (strings.isLowSurrogate(nextCharCode)) {
-						offset++;
-						codePoint = strings.computeCodePoint(charCode, nextCharCode);
-					} else {
-						// illegal => unicode replacement character
-						codePoint = SHA1Constant.UNICODE_REPLACEMENT;
-					}
-				} else {
-					// last character is a surrogate pair
-					leftoverHighSurrogate = charCode;
-					break;
-				}
-			} else if (strings.isLowSurrogate(charCode)) {
-				// illegal => unicode replacement character
-				codePoint = SHA1Constant.UNICODE_REPLACEMENT;
-			}
-
-			buffLen = this._push(buff, buffLen, codePoint);
-			offset++;
-			if (offset < strLen) {
-				charCode = str.charCodeAt(offset);
-			} else {
-				break;
-			}
-		}
-
-		this._buffLen = buffLen;
-		this._leftoverHighSurrogate = leftoverHighSurrogate;
-	}
-
-	private _push(buff: Uint8Array, buffLen: number, codePoint: number): number {
-		if (codePoint < 0x0080) {
-			buff[buffLen++] = codePoint;
-		} else if (codePoint < 0x0800) {
-			buff[buffLen++] = 0b11000000 | ((codePoint & 0b00000000000000000000011111000000) >>> 6);
-			buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
-		} else if (codePoint < 0x10000) {
-			buff[buffLen++] = 0b11100000 | ((codePoint & 0b00000000000000001111000000000000) >>> 12);
-			buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);
-			buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
-		} else {
-			buff[buffLen++] = 0b11110000 | ((codePoint & 0b00000000000111000000000000000000) >>> 18);
-			buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000111111000000000000) >>> 12);
-			buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);
-			buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
-		}
-
-		if (buffLen >= SHA1Constant.BLOCK_SIZE) {
-			this._step();
-			buffLen -= SHA1Constant.BLOCK_SIZE;
-			this._totalLen += SHA1Constant.BLOCK_SIZE;
-			// take last 3 in case of UTF8 overflow
-			buff[0] = buff[SHA1Constant.BLOCK_SIZE + 0];
-			buff[1] = buff[SHA1Constant.BLOCK_SIZE + 1];
-			buff[2] = buff[SHA1Constant.BLOCK_SIZE + 2];
-		}
-
-		return buffLen;
-	}
-
-	public digest(): string {
-		if (!this._finished) {
-			this._finished = true;
-			if (this._leftoverHighSurrogate) {
-				// illegal => unicode replacement character
-				this._leftoverHighSurrogate = 0;
-				this._buffLen = this._push(this._buff, this._buffLen, SHA1Constant.UNICODE_REPLACEMENT);
-			}
-			this._totalLen += this._buffLen;
-			this._wrapUp();
-		}
-
-		return toHexString(this._h0) + toHexString(this._h1) + toHexString(this._h2) + toHexString(this._h3) + toHexString(this._h4);
-	}
-
-	private _wrapUp(): void {
-		this._buff[this._buffLen++] = 0x80;
-		this._buff.subarray(this._buffLen).fill(0);
-
-		if (this._buffLen > 56) {
-			this._step();
-			this._buff.fill(0);
-		}
-
-		// this will fit because the mantissa can cover up to 52 bits
-		const ml = 8 * this._totalLen;
-
-		this._buffDV.setUint32(56, Math.floor(ml / 4294967296), false);
-		this._buffDV.setUint32(60, ml % 4294967296, false);
-
-		this._step();
-	}
-
-	private _step(): void {
-		const bigBlock32 = StringSHA1._bigBlock32;
-		const data = this._buffDV;
-
-		for (let j = 0; j < 64 /* 16*4 */; j += 4) {
-			bigBlock32.setUint32(j, data.getUint32(j, false), false);
-		}
-
-		for (let j = 64; j < 320 /* 80*4 */; j += 4) {
-			bigBlock32.setUint32(j, leftRotate((bigBlock32.getUint32(j - 12, false) ^ bigBlock32.getUint32(j - 32, false) ^ bigBlock32.getUint32(j - 56, false) ^ bigBlock32.getUint32(j - 64, false)), 1), false);
-		}
-
-		let a = this._h0;
-		let b = this._h1;
-		let c = this._h2;
-		let d = this._h3;
-		let e = this._h4;
-
-		let f: number, k: number;
-		let temp: number;
-
-		for (let j = 0; j < 80; j++) {
-			if (j < 20) {
-				f = (b & c) | ((~b) & d);
-				k = 0x5A827999;
-			} else if (j < 40) {
-				f = b ^ c ^ d;
-				k = 0x6ED9EBA1;
-			} else if (j < 60) {
-				f = (b & c) | (b & d) | (c & d);
-				k = 0x8F1BBCDC;
-			} else {
-				f = b ^ c ^ d;
-				k = 0xCA62C1D6;
-			}
-
-			temp = (leftRotate(a, 5) + f + e + k + bigBlock32.getUint32(j * 4, false)) & 0xffffffff;
-			e = d;
-			d = c;
-			c = leftRotate(b, 30);
-			b = a;
-			a = temp;
-		}
-
-		this._h0 = (this._h0 + a) & 0xffffffff;
-		this._h1 = (this._h1 + b) & 0xffffffff;
-		this._h2 = (this._h2 + c) & 0xffffffff;
-		this._h3 = (this._h3 + d) & 0xffffffff;
-		this._h4 = (this._h4 + e) & 0xffffffff;
-	}
-}

package/src/_internal/util/vs/base/common/htmlContent.ts

@@ -1,212 +0,0 @@
-//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { illegalArgument } from './errors';
-import { escapeIcons } from './iconLabels';
-import { Schemas } from './network';
-import { isEqual } from './resources';
-import { escapeRegExpCharacters } from './strings';
-import { URI, UriComponents } from './uri';
-
-export interface MarkdownStringTrustedOptions {
-	readonly enabledCommands: readonly string[];
-}
-
-export interface IMarkdownString {
-	readonly value: string;
-	readonly isTrusted?: boolean | MarkdownStringTrustedOptions;
-	readonly supportThemeIcons?: boolean;
-	readonly supportHtml?: boolean;
-	readonly baseUri?: UriComponents;
-	uris?: { [href: string]: UriComponents };
-}
-
-export const enum MarkdownStringTextNewlineStyle {
-	Paragraph = 0,
-	Break = 1,
-}
-
-export class MarkdownString implements IMarkdownString {
-
-	public value: string;
-	public isTrusted?: boolean | MarkdownStringTrustedOptions;
-	public supportThemeIcons?: boolean;
-	public supportHtml?: boolean;
-	public baseUri?: URI;
-	public uris?: { [href: string]: UriComponents } | undefined;
-
-	public static lift(dto: IMarkdownString): MarkdownString {
-		const markdownString = new MarkdownString(dto.value, dto);
-		markdownString.uris = dto.uris;
-		markdownString.baseUri = dto.baseUri ? URI.revive(dto.baseUri) : undefined;
-		return markdownString;
-	}
-
-	constructor(
-		value: string = '',
-		isTrustedOrOptions: boolean | { isTrusted?: boolean | MarkdownStringTrustedOptions; supportThemeIcons?: boolean; supportHtml?: boolean } = false,
-	) {
-		this.value = value;
-		if (typeof this.value !== 'string') {
-			throw illegalArgument('value');
-		}
-
-		if (typeof isTrustedOrOptions === 'boolean') {
-			this.isTrusted = isTrustedOrOptions;
-			this.supportThemeIcons = false;
-			this.supportHtml = false;
-		}
-		else {
-			this.isTrusted = isTrustedOrOptions.isTrusted ?? undefined;
-			this.supportThemeIcons = isTrustedOrOptions.supportThemeIcons ?? false;
-			this.supportHtml = isTrustedOrOptions.supportHtml ?? false;
-		}
-	}
-
-	appendText(value: string, newlineStyle: MarkdownStringTextNewlineStyle = MarkdownStringTextNewlineStyle.Paragraph): MarkdownString {
-		this.value += escapeMarkdownSyntaxTokens(this.supportThemeIcons ? escapeIcons(value) : value) // CodeQL [SM02383] The Markdown is fully sanitized after being rendered.
-			.replace(/([ \t]+)/g, (_match, g1) => ' '.repeat(g1.length)) // CodeQL [SM02383] The Markdown is fully sanitized after being rendered.
-			.replace(/\>/gm, '\\>') // CodeQL [SM02383] The Markdown is fully sanitized after being rendered.
-			.replace(/\n/g, newlineStyle === MarkdownStringTextNewlineStyle.Break ? '\\\n' : '\n\n'); // CodeQL [SM02383] The Markdown is fully sanitized after being rendered.
-
-		return this;
-	}
-
-	appendMarkdown(value: string): MarkdownString {
-		this.value += value;
-		return this;
-	}
-
-	appendCodeblock(langId: string, code: string): MarkdownString {
-		this.value += `\n${appendEscapedMarkdownCodeBlockFence(code, langId)}\n`;
-		return this;
-	}
-
-	appendLink(target: URI | string, label: string, title?: string): MarkdownString {
-		this.value += '[';
-		this.value += this._escape(label, ']');
-		this.value += '](';
-		this.value += this._escape(String(target), ')');
-		if (title) {
-			this.value += ` "${this._escape(this._escape(title, '"'), ')')}"`;
-		}
-		this.value += ')';
-		return this;
-	}
-
-	private _escape(value: string, ch: string): string {
-		const r = new RegExp(escapeRegExpCharacters(ch), 'g');
-		return value.replace(r, (match, offset) => {
-			if (value.charAt(offset - 1) !== '\\') {
-				return `\\${match}`;
-			} else {
-				return match;
-			}
-		});
-	}
-}
-
-export function isEmptyMarkdownString(oneOrMany: IMarkdownString | IMarkdownString[] | null | undefined): boolean {
-	if (isMarkdownString(oneOrMany)) {
-		return !oneOrMany.value;
-	} else if (Array.isArray(oneOrMany)) {
-		return oneOrMany.every(isEmptyMarkdownString);
-	} else {
-		return true;
-	}
-}
-
-export function isMarkdownString(thing: unknown): thing is IMarkdownString {
-	if (thing instanceof MarkdownString) {
-		return true;
-	} else if (thing && typeof thing === 'object') {
-		return typeof (<IMarkdownString>thing).value === 'string'
-			&& (typeof (<IMarkdownString>thing).isTrusted === 'boolean' || typeof (<IMarkdownString>thing).isTrusted === 'object' || (<IMarkdownString>thing).isTrusted === undefined)
-			&& (typeof (<IMarkdownString>thing).supportThemeIcons === 'boolean' || (<IMarkdownString>thing).supportThemeIcons === undefined);
-	}
-	return false;
-}
-
-export function markdownStringEqual(a: IMarkdownString, b: IMarkdownString): boolean {
-	if (a === b) {
-		return true;
-	} else if (!a || !b) {
-		return false;
-	} else {
-		return a.value === b.value
-			&& a.isTrusted === b.isTrusted
-			&& a.supportThemeIcons === b.supportThemeIcons
-			&& a.supportHtml === b.supportHtml
-			&& (a.baseUri === b.baseUri || !!a.baseUri && !!b.baseUri && isEqual(URI.from(a.baseUri), URI.from(b.baseUri)));
-	}
-}
-
-export function escapeMarkdownSyntaxTokens(text: string): string {
-	// escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
-	return text.replace(/[\\`*_{}[\]()#+\-!~]/g, '\\$&'); // CodeQL [SM02383] Backslash is escaped in the character class
-}
-
-/**
- * @see https://github.com/microsoft/vscode/issues/193746
- */
-export function appendEscapedMarkdownCodeBlockFence(code: string, langId: string) {
-	const longestFenceLength =
-		code.match(/^`+/gm)?.reduce((a, b) => (a.length > b.length ? a : b)).length ??
-		0;
-	const desiredFenceLength =
-		longestFenceLength >= 3 ? longestFenceLength + 1 : 3;
-
-	// the markdown result
-	return [
-		`${'`'.repeat(desiredFenceLength)}${langId}`,
-		code,
-		`${'`'.repeat(desiredFenceLength)}`,
-	].join('\n');
-}
-
-export function escapeDoubleQuotes(input: string) {
-	return input.replace(/"/g, '&quot;');
-}
-
-export function removeMarkdownEscapes(text: string): string {
-	if (!text) {
-		return text;
-	}
-	return text.replace(/\\([\\`*_{}[\]()#+\-.!~])/g, '$1');
-}
-
-export function parseHrefAndDimensions(href: string): { href: string; dimensions: string[] } {
-	const dimensions: string[] = [];
-	const splitted = href.split('|').map(s => s.trim());
-	href = splitted[0];
-	const parameters = splitted[1];
-	if (parameters) {
-		const heightFromParams = /height=(\d+)/.exec(parameters);
-		const widthFromParams = /width=(\d+)/.exec(parameters);
-		const height = heightFromParams ? heightFromParams[1] : '';
-		const width = widthFromParams ? widthFromParams[1] : '';
-		const widthIsFinite = isFinite(parseInt(width));
-		const heightIsFinite = isFinite(parseInt(height));
-		if (widthIsFinite) {
-			dimensions.push(`width="${width}"`);
-		}
-		if (heightIsFinite) {
-			dimensions.push(`height="${height}"`);
-		}
-	}
-	return { href, dimensions };
-}
-
-export function markdownCommandLink(command: { title: string; id: string; arguments?: unknown[] }, escapeTokens = true): string {
-	const uri = URI.from({
-		scheme: Schemas.command,
-		path: command.id,
-		query: command.arguments?.length ? encodeURIComponent(JSON.stringify(command.arguments)) : undefined,
-	}).toString();
-
-	return `[${escapeTokens ? escapeMarkdownSyntaxTokens(command.title) : command.title}](${uri})`;
-}

package/src/_internal/util/vs/base/common/iconLabels.ts

@@ -1,118 +0,0 @@
-//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { IMatch, matchesFuzzy } from './filters';
-import { ltrim } from './strings';
-import { ThemeIcon } from './themables';
-
-const iconStartMarker = '$(';
-
-const iconsRegex = new RegExp(`\\$\\(${ThemeIcon.iconNameExpression}(?:${ThemeIcon.iconModifierExpression})?\\)`, 'g'); // no capturing groups
-
-const escapeIconsRegex = new RegExp(`(\\\\)?${iconsRegex.source}`, 'g');
-export function escapeIcons(text: string): string {
-	return text.replace(escapeIconsRegex, (match, escaped) => escaped ? match : `\\${match}`);
-}
-
-const markdownEscapedIconsRegex = new RegExp(`\\\\${iconsRegex.source}`, 'g');
-export function markdownEscapeEscapedIcons(text: string): string {
-	// Need to add an extra \ for escaping in markdown
-	return text.replace(markdownEscapedIconsRegex, match => `\\${match}`);
-}
-
-const stripIconsRegex = new RegExp(`(\\s)?(\\\\)?${iconsRegex.source}(\\s)?`, 'g');
-
-/**
- * Takes a label with icons (`$(iconId)xyz`)  and strips the icons out (`xyz`)
- */
-export function stripIcons(text: string): string {
-	if (text.indexOf(iconStartMarker) === -1) {
-		return text;
-	}
-
-	return text.replace(stripIconsRegex, (match, preWhitespace, escaped, postWhitespace) => escaped ? match : preWhitespace || postWhitespace || '');
-}
-
-
-/**
- * Takes a label with icons (`$(iconId)xyz`), removes the icon syntax adds whitespace so that screen readers can read the text better.
- */
-export function getCodiconAriaLabel(text: string | undefined) {
-	if (!text) {
-		return '';
-	}
-
-	return text.replace(/\$\((.*?)\)/g, (_match, codiconName) => ` ${codiconName} `).trim();
-}
-
-
-export interface IParsedLabelWithIcons {
-	readonly text: string;
-	readonly iconOffsets?: readonly number[];
-}
-
-const _parseIconsRegex = new RegExp(`\\$\\(${ThemeIcon.iconNameCharacter}+\\)`, 'g');
-
-/**
- * Takes a label with icons (`abc $(iconId)xyz`) and returns the text (`abc xyz`) and the offsets of the icons (`[3]`)
- */
-export function parseLabelWithIcons(input: string): IParsedLabelWithIcons {
-
-	_parseIconsRegex.lastIndex = 0;
-
-	let text = '';
-	const iconOffsets: number[] = [];
-	let iconsOffset = 0;
-
-	while (true) {
-		const pos = _parseIconsRegex.lastIndex;
-		const match = _parseIconsRegex.exec(input);
-
-		const chars = input.substring(pos, match?.index);
-		if (chars.length > 0) {
-			text += chars;
-			for (let i = 0; i < chars.length; i++) {
-				iconOffsets.push(iconsOffset);
-			}
-		}
-		if (!match) {
-			break;
-		}
-		iconsOffset += match[0].length;
-	}
-
-	return { text, iconOffsets };
-}
-
-
-export function matchesFuzzyIconAware(query: string, target: IParsedLabelWithIcons, enableSeparateSubstringMatching = false): IMatch[] | null {
-	const { text, iconOffsets } = target;
-
-	// Return early if there are no icon markers in the word to match against
-	if (!iconOffsets || iconOffsets.length === 0) {
-		return matchesFuzzy(query, text, enableSeparateSubstringMatching);
-	}
-
-	// Trim the word to match against because it could have leading
-	// whitespace now if the word started with an icon
-	const wordToMatchAgainstWithoutIconsTrimmed = ltrim(text, ' ');
-	const leadingWhitespaceOffset = text.length - wordToMatchAgainstWithoutIconsTrimmed.length;
-
-	// match on value without icon
-	const matches = matchesFuzzy(query, wordToMatchAgainstWithoutIconsTrimmed, enableSeparateSubstringMatching);
-
-	// Map matches back to offsets with icon and trimming
-	if (matches) {
-		for (const match of matches) {
-			const iconOffset = iconOffsets[match.start + leadingWhitespaceOffset] /* icon offsets at index */ + leadingWhitespaceOffset /* overall leading whitespace offset */;
-			match.start += iconOffset;
-			match.end += iconOffset;
-		}
-	}
-
-	return matches;
-}