@singapore-editor/find 0.1.1

package/dist/search.js

@@ -0,0 +1,470 @@
+import { codePointSizeAt, compareTextOffsetRanges, isWholeWordRange } from "@singapore-editor/core/document";
+//#region src/search.ts
+var FIND_MATCHES_LIMIT = 19999;
+var FIND_REPLACE_ALL_LIMIT = 1073741824;
+var FIND_WINDOW_UNITS = 65536;
+var LINE_SAFE_ESCAPES = /* @__PURE__ */ new Set([
+	"d",
+	"w",
+	"t",
+	"r",
+	"f",
+	"v",
+	"b",
+	"B",
+	"0"
+]);
+function findTextSourceFromSnapshot(snapshot) {
+	return {
+		length: snapshot.length,
+		readRange: (start, end) => snapshot.readRange(start, end),
+		lineStartsView: {
+			length: snapshot.lineCount,
+			at: (index) => index < 0 || index >= snapshot.lineCount ? void 0 : snapshot.lineStart(index),
+			indexForOffset: (offset) => snapshot.lineAt(offset)
+		}
+	};
+}
+function findMatches(source, query, ranges = null, captureMatches = false, limit = FIND_MATCHES_LIMIT) {
+	const compiled = compileFindQuery(query);
+	if (!compiled || limit <= 0) return [];
+	const matches = [];
+	const collect = (start, end, captures) => {
+		matches.push({
+			start,
+			end,
+			matches: captures
+		});
+		return matches.length < limit;
+	};
+	for (const range of searchRanges(source, ranges)) {
+		scanRange(source, compiled, range, captureMatches, collect);
+		if (matches.length >= limit) break;
+	}
+	return matches;
+}
+/**
+* Every match counted, none kept: a total costs no record per match.
+*
+* With `before`, only the matches starting in front of that offset, which is the
+* position of a match the listing stopped short of.
+*/
+function countMatches(source, query, ranges = null, before = Number.POSITIVE_INFINITY) {
+	const compiled = compileFindQuery(query);
+	if (!compiled) return 0;
+	let count = 0;
+	const tally = (start) => {
+		if (start >= before) return false;
+		count += 1;
+		return true;
+	};
+	for (const range of searchRanges(source, ranges)) {
+		if (range.start >= before) break;
+		scanRange(source, compiled, range, false, tally);
+	}
+	return count;
+}
+/** The line holding `offset`, break excluded. */
+function findLineRange(source, offset) {
+	const index = source.lineStartsView.indexForOffset(offset);
+	return {
+		start: source.lineStartsView.at(index) ?? 0,
+		end: lineEndAt(source, index)
+	};
+}
+/**
+* One match, scanned for from an offset instead of picked out of a list.
+*
+* A listing stops at FIND_MATCHES_LIMIT, and past that every entry in it sits
+* behind the cursor: picking from it answers each press with the top of the
+* document. Scanning outward stops at the first match it reaches, so how far
+* navigation can go is not what a paint budget allowed.
+*/
+function findNextMatchFrom(source, query, offset, ranges = null, options = {}) {
+	const compiled = compileFindQuery(query);
+	if (!compiled) return null;
+	const searched = searchRanges(source, ranges);
+	const ahead = firstMatchAfter(source, compiled, searched, clampSourceOffset(source, offset), options);
+	if (ahead) return ahead;
+	if (options.loop === false) return null;
+	return firstMatchAtOrAfter(source, compiled, searched, searched[0]?.start ?? 0, options);
+}
+function findPreviousMatchFrom(source, query, offset, ranges = null, options = {}) {
+	const compiled = compileFindQuery(query);
+	if (!compiled) return null;
+	const searched = searchRanges(source, ranges);
+	const behind = lastMatchBefore(source, compiled, searched, clampSourceOffset(source, offset), options);
+	if (behind) return behind;
+	if (options.loop === false) return null;
+	return lastMatchBefore(source, compiled, searched, source.length, {
+		...options,
+		escapeEmptyMatchAtOffset: false
+	});
+}
+function findMatchIndex(matches, range) {
+	return matches.findIndex((match) => match.start === range.start && match.end === range.end);
+}
+function escapeRegExpCharacters(value) {
+	return value.replace(/[\\{}*+?|^$.[\]()]/g, "\\$&");
+}
+function lineEndAt(source, index) {
+	const nextLineStart = source.lineStartsView.at(index + 1);
+	return nextLineStart === void 0 ? source.length : nextLineStart - 1;
+}
+function escapesEmptyMatch(match, offset, escape) {
+	return escape && match.start === match.end && match.start === offset;
+}
+function firstMatchAfter(source, query, ranges, offset, options) {
+	const found = firstMatchAtOrAfter(source, query, ranges, offset, options);
+	if (!found) return null;
+	if (!escapesEmptyMatch(found, offset, options.escapeEmptyMatchAtOffset ?? false)) return found;
+	return firstMatchAtOrAfter(source, query, ranges, nextCodePointOffset(source, offset), options);
+}
+function firstMatchAtOrAfter(source, query, ranges, offset, options) {
+	for (const range of ranges) {
+		if (range.end < offset) continue;
+		const found = firstMatchInRange(source, query, range, offset, options.captureMatches ?? false);
+		if (found) return found;
+	}
+	return null;
+}
+function firstMatchInRange(source, query, range, offset, captureMatches) {
+	let found = null;
+	scanRange(source, query, {
+		start: forwardScanStart(source, query, range, offset),
+		end: range.end
+	}, captureMatches, (start, end, captures) => {
+		if (start < offset) return true;
+		found = {
+			start,
+			end,
+			matches: captures
+		};
+		return false;
+	});
+	return found;
+}
+function forwardScanStart(source, query, range, offset) {
+	if (!isLineLocalPlan(query.plan)) return range.start;
+	const lineStartsView = source.lineStartsView;
+	const line = lineStartsView.indexForOffset(Math.max(range.start, offset));
+	return Math.max(range.start, lineStartsView.at(line) ?? 0);
+}
+function isLineLocalPlan(plan) {
+	return plan.kind === "lines" || plan.kind === "anchored-lines";
+}
+function lastMatchBefore(source, query, ranges, offset, options) {
+	for (const range of ranges.toReversed()) {
+		if (range.start > offset) continue;
+		const found = lastMatchInRange(source, query, range, offset, options);
+		if (found) return found;
+	}
+	return null;
+}
+function lastMatchInRange(source, query, searched, offset, options) {
+	if (!isLineLocalPlan(query.plan)) return lastMatchInWindow(source, query, searched, offset, options);
+	const range = {
+		start: searched.start,
+		end: Math.min(searched.end, offset)
+	};
+	const lineStartsView = source.lineStartsView;
+	let last = lineStartsView.indexForOffset(range.end);
+	while (last >= 0) {
+		const reach = Math.max(range.start, (lineStartsView.at(last) ?? 0) - FIND_WINDOW_UNITS);
+		const first = lineStartsView.indexForOffset(reach);
+		const firstStart = lineStartsView.at(first) ?? 0;
+		const window = {
+			start: Math.max(range.start, firstStart),
+			end: Math.min(range.end, lineEndAt(source, last))
+		};
+		const found = window.end < window.start ? null : lastMatchInWindow(source, query, window, offset, options);
+		if (found) return found;
+		if (firstStart <= range.start) return null;
+		last = first - 1;
+	}
+	return null;
+}
+function lastMatchInWindow(source, query, range, offset, options) {
+	let last = null;
+	let beforeLast = null;
+	scanRange(source, query, range, options.captureMatches ?? false, (start, end, captures) => {
+		if (end > offset) return false;
+		beforeLast = last;
+		last = {
+			start,
+			end,
+			matches: captures
+		};
+		return true;
+	});
+	if (!last) return null;
+	if (!escapesEmptyMatch(last, offset, options.escapeEmptyMatchAtOffset ?? false)) return last;
+	return beforeLast;
+}
+function nextCodePointOffset(source, offset) {
+	const text = source.readRange(offset, Math.min(source.length, offset + 2));
+	return offset + Math.max(1, codePointSizeAt(text, 0));
+}
+function queryIsCaseSensitiveByContent(searchString) {
+	return searchString.toLowerCase() !== searchString.toUpperCase();
+}
+/**
+* Whether every part of a pattern is provably unable to match a line break.
+*
+* Asked the safe way round. Listing the constructs that CAN hold a break means
+* one nobody thought of routes a query to the windowed path, where it answers
+* "no results" for text that is plainly there — the one wrong answer a search
+* must never give. So a query is windowed only when every part of it is provably
+* break-free, and anything unrecognized takes the slower path that is always
+* correct.
+*/
+function isLineSafePattern(pattern) {
+	for (let index = 0; index < pattern.length; index += 1) {
+		const char = pattern[index];
+		if (char === "\n") return false;
+		if (char === "[") {
+			const end = characterClassEnd(pattern, index);
+			if (end === null || !isLineSafeCharacterClass(pattern.slice(index + 1, end))) return false;
+			index = end;
+			continue;
+		}
+		if (char === "(" && !isLineSafeGroupOpener(pattern, index)) return false;
+		if (char !== "\\") continue;
+		index += 1;
+		const escaped = pattern[index];
+		if (escaped === void 0) return false;
+		if (!LINE_SAFE_ESCAPES.has(escaped) && /[\p{L}\p{N}]/u.test(escaped)) return false;
+	}
+	return true;
+}
+/**
+* Only a group that bundles what is written inside it, leaving its meaning alone.
+*
+* A capture, a non-capture and either lookaround are all of those. A modifier
+* group is not: it can switch on the flag under which a dot spans a break, so the
+* characters inside it stop saying what they say anywhere else — and reading back
+* which flags one names is more machinery than routing it to the correct path
+* costs. Every other spelling is one nobody here recognized, which is the same
+* answer.
+*/
+function isLineSafeGroupOpener(pattern, index) {
+	if (pattern[index + 1] !== "?") return true;
+	const kind = pattern[index + 2];
+	return kind === ":" || kind === "=" || kind === "!" || kind === "<";
+}
+function isLineSafeCharacterClass(body) {
+	if (body.startsWith("^")) return false;
+	return !body.includes("\\") && !body.includes("\n");
+}
+function characterClassEnd(pattern, from) {
+	for (let index = from + 1; index < pattern.length; index += 1) if (pattern[index] === "\\") index += 1;
+	else if (pattern[index] === "]") return index;
+	return null;
+}
+function compileFindQuery(query) {
+	if (query.searchString.length === 0) return null;
+	const source = query.isRegex ? query.searchString : escapeRegExpCharacters(query.searchString);
+	const plan = planFindQuery(query);
+	const lineCrossing = plan.kind === "range" || plan.kind === "literal-lines";
+	const flags = `g${query.matchCase ? "" : "i"}${lineCrossing ? "m" : ""}`;
+	const canUseSimpleSearch = !query.isRegex && (query.matchCase || !queryIsCaseSensitiveByContent(query.searchString));
+	const regex = compileRegex(source, flags);
+	if (!regex) return null;
+	return {
+		regex,
+		simpleSearch: canUseSimpleSearch ? query.searchString : null,
+		wholeWord: query.wholeWord,
+		plan
+	};
+}
+function planFindQuery(query) {
+	if (!query.isRegex) {
+		const lineBreaks = query.searchString.split("\n").length - 1;
+		return lineBreaks === 0 ? { kind: "lines" } : {
+			kind: "literal-lines",
+			lineBreaks
+		};
+	}
+	if (!isLineSafePattern(query.searchString)) return {
+		kind: "range",
+		reason: "pattern-may-match-line-break"
+	};
+	return hasLineAnchor(query.searchString) ? { kind: "anchored-lines" } : { kind: "lines" };
+}
+function hasLineAnchor(pattern) {
+	for (let index = 0; index < pattern.length; index += 1) {
+		const char = pattern[index];
+		if (char === "\\") index += 1;
+		else if (char === "[") index = characterClassEnd(pattern, index) ?? pattern.length;
+		else if (char === "^" || char === "$") return true;
+	}
+	return false;
+}
+/**
+* The pattern under the unicode flag where it takes it, and without it where it
+* does not.
+*
+* Wanted, because `u` is what makes a surrogate pair one character to a dot and
+* `\p{...}` mean anything at all. Not required, because its grammar rejects
+* spellings the flagless one accepts — an identity escape of a character that
+* needs none (`\-`, `\ `), a brace or bracket standing for itself, a legacy
+* back-reference — and every one of those is what escaping a search by hand
+* produces. A rejected pattern is not reported anywhere the user can see it: it
+* reaches them as "No results", indistinguishable from text that is not there.
+*/
+function compileRegex(source, flags) {
+	try {
+		return new RegExp(source, `${flags}u`);
+	} catch {}
+	try {
+		return new RegExp(source, flags);
+	} catch {
+		return null;
+	}
+}
+function searchRanges(source, ranges) {
+	if (!ranges || ranges.length === 0) return [{
+		start: 0,
+		end: source.length
+	}];
+	const clamped = ranges.map((range) => ({
+		start: clampSourceOffset(source, range.start),
+		end: clampSourceOffset(source, range.end)
+	})).filter((range) => range.start <= range.end).toSorted(compareTextOffsetRanges);
+	const merged = [];
+	for (const range of clamped) {
+		const previous = merged.at(-1);
+		if (previous && range.start <= previous.end) {
+			merged[merged.length - 1] = {
+				start: previous.start,
+				end: Math.max(previous.end, range.end)
+			};
+			continue;
+		}
+		merged.push(range);
+	}
+	return merged;
+}
+function clampSourceOffset(source, offset) {
+	return Math.min(Math.max(0, offset), source.length);
+}
+/** False once the range is spent or the visitor stopped: nothing later in it is read. */
+function scanRange(source, query, range, captureMatches, visit) {
+	if (query.plan.kind === "range") return scanWholeRange(source, query, range, captureMatches, visit);
+	if (query.plan.kind === "literal-lines") return scanSpanningLiteral(source, query, range, query.plan.lineBreaks, visit);
+	return scanLines(source, query, range, captureMatches, visit);
+}
+function scanLines(source, query, range, captureMatches, visit) {
+	const lineStartsView = source.lineStartsView;
+	let index = lineStartsView.indexForOffset(range.start);
+	while (index < lineStartsView.length) {
+		const start = lineStartsView.at(index);
+		if (start === void 0 || start > range.end) return true;
+		const last = lastWindowLine(source, index, start, range.end);
+		if (!scanLineWindow(readWindow(source, start, lineEndAt(source, last), range), query, range, captureMatches, visit)) return false;
+		index = last + 1;
+	}
+	return true;
+}
+function lastWindowLine(source, first, start, rangeEnd) {
+	const reach = Math.min(rangeEnd, start + FIND_WINDOW_UNITS);
+	return Math.max(first, source.lineStartsView.indexForOffset(reach));
+}
+function scanLineWindow(window, query, range, captureMatches, visit) {
+	if (query.plan.kind !== "anchored-lines") return scanWindow(window, query, range, captureMatches, visit);
+	let lineStart = 0;
+	while (lineStart <= window.text.length) {
+		const found = window.text.indexOf("\n", lineStart);
+		const lineEnd = found === -1 ? window.text.length : found;
+		const line = {
+			text: window.text.slice(lineStart, lineEnd),
+			start: window.start + lineStart,
+			from: Math.max(0, window.from - lineStart)
+		};
+		if (lineEnd >= window.from && !scanWindow(line, query, range, captureMatches, visit)) return false;
+		lineStart = lineEnd + 1;
+	}
+	return true;
+}
+function scanSpanningLiteral(source, query, range, lineBreaks, visit) {
+	const lineStartsView = source.lineStartsView;
+	const finalLine = lineStartsView.indexForOffset(range.end);
+	let first = lineStartsView.indexForOffset(range.start);
+	const cursor = { offset: range.start };
+	while (first <= finalLine) {
+		const start = lineStartsView.at(first) ?? 0;
+		const last = Math.min(finalLine, Math.max(first + lineBreaks, lastWindowLine(source, first, start, range.end)));
+		if (!scanWindow({
+			text: source.readRange(start, Math.max(start, lineEndAt(source, last))),
+			start,
+			from: Math.max(0, cursor.offset - start)
+		}, query, range, false, visit, cursor)) return false;
+		if (last === finalLine) return true;
+		first = last + 1 - lineBreaks;
+	}
+	return true;
+}
+function scanWholeRange(source, query, range, captureMatches, visit) {
+	const lineStartsView = source.lineStartsView;
+	const start = lineStartsView.at(lineStartsView.indexForOffset(range.start)) ?? 0;
+	const end = lineEndAt(source, lineStartsView.indexForOffset(range.end));
+	return scanWindow(readWindow(source, start, Math.max(start, end), range), query, range, captureMatches, visit);
+}
+function readWindow(source, start, end, range) {
+	return {
+		text: source.readRange(start, end),
+		start,
+		from: Math.max(0, range.start - start)
+	};
+}
+/** False once the range is spent or the visitor stopped, so no later window can add anything. */
+function scanWindow(window, query, range, captureMatches, visit, cursor) {
+	if (query.simpleSearch && !captureMatches) return scanSimpleMatches(window, query.simpleSearch, query.wholeWord, range, visit, cursor);
+	return scanRegexMatches(window, query, range, captureMatches, visit, cursor);
+}
+function scanSimpleMatches(window, searchString, wholeWord, range, visit, cursor) {
+	let index = window.text.indexOf(searchString, window.from);
+	while (index !== -1) {
+		const start = window.start + index;
+		const end = start + searchString.length;
+		if (end > range.end) return false;
+		if (cursor) cursor.offset = end;
+		if (validWholeWordMatch(window.text, index, searchString.length, wholeWord)) {
+			if (!visit(start, end, null)) return false;
+		}
+		index = window.text.indexOf(searchString, index + searchString.length);
+	}
+	return true;
+}
+function scanRegexMatches(window, query, range, captureMatches, visit, cursor) {
+	query.regex.lastIndex = window.from;
+	while (true) {
+		const match = query.regex.exec(window.text);
+		if (!match) return true;
+		const start = window.start + match.index;
+		const end = start + match[0].length;
+		if (start > range.end || end > range.end) return false;
+		if (cursor) cursor.offset = end;
+		if (validWholeWordMatch(window.text, match.index, match[0].length, query.wholeWord)) {
+			if (!visit(start, end, captureMatches ? match : null)) return false;
+		}
+		if (match[0].length === 0) advancePastEmptyMatch(query.regex, window.text);
+	}
+}
+function advancePastEmptyMatch(regex, text) {
+	const current = regex.lastIndex;
+	if (current > text.length) return;
+	const size = codePointSizeAt(text, current);
+	regex.lastIndex = current + Math.max(1, size);
+}
+function validWholeWordMatch(text, start, length, wholeWord) {
+	if (!wholeWord) return true;
+	return isWholeWordRange(text, {
+		start,
+		end: start + length
+	});
+}
+//#endregion
+export { FIND_MATCHES_LIMIT, FIND_REPLACE_ALL_LIMIT, FIND_WINDOW_UNITS, countMatches, escapeRegExpCharacters, findLineRange, findMatchIndex, findMatches, findNextMatchFrom, findPreviousMatchFrom, findTextSourceFromSnapshot };
+
+//# sourceMappingURL=search.js.map

package/dist/search.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.js","names":[],"sources":["../src/search.ts"],"sourcesContent":["import {\n  codePointSizeAt,\n  compareTextOffsetRanges,\n  isWholeWordRange,\n  type TextOffsetRange,\n  type TextReadSnapshot,\n} from '@singapore-editor/core/document'\n\n// Bounds the match set the widget counts and paints, so a pathological query\n// on a huge file cannot stall the frame.\nexport const FIND_MATCHES_LIMIT = 19_999\n\n// Replace All must never apply to a truncated match set: stopping early would\n// silently rewrite part of the document and leave the rest, with no signal to\n// the user. Searching is linear, so the only real cost of lifting the cap here\n// is the edit batch itself.\nexport const FIND_REPLACE_ALL_LIMIT = 1_073_741_824\n\n// How much text a windowed scan reads at once, rounded up to whole lines. Large\n// enough that the tree descent per read is noise, small enough that a fragmented\n// document is never joined into one string the size of the file.\nexport const FIND_WINDOW_UNITS = 65_536\n\n// Escapes whose class cannot hold a line break, so a pattern built only from\n// these can be answered a line at a time. A carriage return is among them: it\n// sits inside a line, not between two.\nconst LINE_SAFE_ESCAPES = new Set(['d', 'w', 't', 'r', 'f', 'v', 'b', 'B', '0'])\n\nexport type FindRange = TextOffsetRange\n\n// Read-only line-start access, structurally the view a document snapshot\n// already hands out, so a search never asks for the array behind it.\nexport type FindLineStartsView = {\n  readonly length: number\n  at(index: number): number | undefined\n  indexForOffset(offset: number): number\n}\n\n/**\n * The text a search reads, in ranges rather than as one string.\n *\n * A query that cannot match a line break is answered a line at a time, so a\n * keystroke in the find box costs the lines examined instead of a copy of the\n * whole document — and a chunked buffer gets searched where it lies.\n */\nexport type FindTextSource = {\n  readonly length: number\n  readRange(start: number, end: number): string\n  readonly lineStartsView: FindLineStartsView\n}\n\nexport function findTextSourceFromSnapshot(snapshot: TextReadSnapshot): FindTextSource {\n  return {\n    length: snapshot.length,\n    readRange: (start, end) => snapshot.readRange(start, end),\n    lineStartsView: {\n      length: snapshot.lineCount,\n      at: (index) =>\n        index < 0 || index >= snapshot.lineCount ? undefined : snapshot.lineStart(index),\n      indexForOffset: (offset) => snapshot.lineAt(offset),\n    },\n  }\n}\n\nexport type FindQuery = {\n  readonly searchString: string\n  readonly isRegex: boolean\n  readonly matchCase: boolean\n  readonly wholeWord: boolean\n}\n\nexport type FindMatch = FindRange & {\n  readonly matches: readonly string[] | null\n}\n\nexport type FindMatchFromOptions = {\n  readonly captureMatches?: boolean\n  readonly loop?: boolean\n  readonly escapeEmptyMatchAtOffset?: boolean\n}\n\n/** What the two directions have in common, so one caller can hold either. */\nexport type FindMatchFromSearcher = (\n  source: FindTextSource,\n  query: FindQuery,\n  offset: number,\n  ranges: readonly FindRange[] | null,\n  options: FindMatchFromOptions,\n) => FindMatch | null\n\ntype CompiledFindQuery = {\n  readonly regex: RegExp\n  // Non-null only when a plain indexOf over the untouched text is exactly\n  // equivalent to the regex; see compileFindQuery.\n  readonly simpleSearch: string | null\n  readonly wholeWord: boolean\n  readonly plan: FindQueryPlan\n}\n\n/**\n * How much text one match can depend on, which is what decides how it is read.\n *\n * `lines` and `anchored-lines` cannot match a break, so they are read in windows\n * of whole lines. `literal-lines` is a literal holding breaks: it spans a known\n * number of lines, so it is windowed too. `range` is every pattern nothing here\n * can bound, read as one window because that is the only reading always correct.\n */\nexport type FindQueryPlan =\n  | { readonly kind: 'lines' }\n  | { readonly kind: 'anchored-lines' }\n  | { readonly kind: 'literal-lines'; readonly lineBreaks: number }\n  | { readonly kind: 'range'; readonly reason: 'pattern-may-match-line-break' }\n\n// One stretch of the document already read: the text of\n// `[start, start + text.length)`, to be searched from `from` onward.\ntype FindWindow = {\n  readonly text: string\n  readonly start: number\n  readonly from: number\n}\n\nexport function findMatches(\n  source: FindTextSource,\n  query: FindQuery,\n  ranges: readonly FindRange[] | null = null,\n  captureMatches = false,\n  limit = FIND_MATCHES_LIMIT,\n): readonly FindMatch[] {\n  const compiled = compileFindQuery(query)\n  if (!compiled || limit <= 0) return []\n\n  const matches: FindMatch[] = []\n  const collect: FindMatchVisitor = (start, end, captures) => {\n    matches.push({ start, end, matches: captures })\n    return matches.length < limit\n  }\n  for (const range of searchRanges(source, ranges)) {\n    scanRange(source, compiled, range, captureMatches, collect)\n    if (matches.length >= limit) break\n  }\n\n  return matches\n}\n\n/**\n * Every match counted, none kept: a total costs no record per match.\n *\n * With `before`, only the matches starting in front of that offset, which is the\n * position of a match the listing stopped short of.\n */\nexport function countMatches(\n  source: FindTextSource,\n  query: FindQuery,\n  ranges: readonly FindRange[] | null = null,\n  before = Number.POSITIVE_INFINITY,\n): number {\n  const compiled = compileFindQuery(query)\n  if (!compiled) return 0\n\n  let count = 0\n  const tally: FindMatchVisitor = (start) => {\n    if (start >= before) return false\n\n    count += 1\n    return true\n  }\n  for (const range of searchRanges(source, ranges)) {\n    if (range.start >= before) break\n    scanRange(source, compiled, range, false, tally)\n  }\n\n  return count\n}\n\n/** Null for a query that cannot be compiled, which is one that finds nothing. */\nexport function findQueryPlan(query: FindQuery): FindQueryPlan | null {\n  return compileFindQuery(query)?.plan ?? null\n}\n\n/** The line holding `offset`, break excluded. */\nexport function findLineRange(source: FindTextSource, offset: number): FindRange {\n  const index = source.lineStartsView.indexForOffset(offset)\n  return { start: source.lineStartsView.at(index) ?? 0, end: lineEndAt(source, index) }\n}\n\n/**\n * One match, scanned for from an offset instead of picked out of a list.\n *\n * A listing stops at FIND_MATCHES_LIMIT, and past that every entry in it sits\n * behind the cursor: picking from it answers each press with the top of the\n * document. Scanning outward stops at the first match it reaches, so how far\n * navigation can go is not what a paint budget allowed.\n */\nexport function findNextMatchFrom(\n  source: FindTextSource,\n  query: FindQuery,\n  offset: number,\n  ranges: readonly FindRange[] | null = null,\n  options: FindMatchFromOptions = {},\n): FindMatch | null {\n  const compiled = compileFindQuery(query)\n  if (!compiled) return null\n\n  const searched = searchRanges(source, ranges)\n  const from = clampSourceOffset(source, offset)\n  const ahead = firstMatchAfter(source, compiled, searched, from, options)\n  if (ahead) return ahead\n  if (options.loop === false) return null\n\n  // Wrapping is a second bounded scan rather than a listing, so a cursor past\n  // the last match still costs only the text up to the first one.\n  return firstMatchAtOrAfter(source, compiled, searched, searched[0]?.start ?? 0, options)\n}\n\nexport function findPreviousMatchFrom(\n  source: FindTextSource,\n  query: FindQuery,\n  offset: number,\n  ranges: readonly FindRange[] | null = null,\n  options: FindMatchFromOptions = {},\n): FindMatch | null {\n  const compiled = compileFindQuery(query)\n  if (!compiled) return null\n\n  const searched = searchRanges(source, ranges)\n  const from = clampSourceOffset(source, offset)\n  const behind = lastMatchBefore(source, compiled, searched, from, options)\n  if (behind) return behind\n  if (options.loop === false) return null\n\n  return lastMatchBefore(source, compiled, searched, source.length, {\n    ...options,\n    escapeEmptyMatchAtOffset: false,\n  })\n}\n\nexport function findMatchIndex(matches: readonly FindMatch[], range: FindRange): number {\n  return matches.findIndex((match) => match.start === range.start && match.end === range.end)\n}\n\nexport function escapeRegExpCharacters(value: string): string {\n  return value.replace(/[\\\\{}*+?|^$.[\\]()]/g, '\\\\$&')\n}\n\n// The break belongs to no line: a query that cannot match one would otherwise be\n// handed a haystack whose `$` sits behind it.\nfunction lineEndAt(source: FindTextSource, index: number): number {\n  const nextLineStart = source.lineStartsView.at(index + 1)\n  return nextLineStart === undefined ? source.length : nextLineStart - 1\n}\n\nfunction escapesEmptyMatch(match: FindMatch, offset: number, escape: boolean): boolean {\n  return escape && match.start === match.end && match.start === offset\n}\n\nfunction firstMatchAfter(\n  source: FindTextSource,\n  query: CompiledFindQuery,\n  ranges: readonly FindRange[],\n  offset: number,\n  options: FindMatchFromOptions,\n): FindMatch | null {\n  const found = firstMatchAtOrAfter(source, query, ranges, offset, options)\n  if (!found) return null\n  if (!escapesEmptyMatch(found, offset, options.escapeEmptyMatchAtOffset ?? false)) return found\n\n  // Resumed past the offset itself, once: whatever stands there is the entry\n  // after the one being escaped, empty or not.\n  return firstMatchAtOrAfter(source, query, ranges, nextCodePointOffset(source, offset), options)\n}\n\nfunction firstMatchAtOrAfter(\n  source: FindTextSource,\n  query: CompiledFindQuery,\n  ranges: readonly FindRange[],\n  offset: number,\n  options: FindMatchFromOptions,\n): FindMatch | null {\n  for (const range of ranges) {\n    if (range.end < offset) continue\n\n    const found = firstMatchInRange(source, query, range, offset, options.captureMatches ?? false)\n    if (found) return found\n  }\n\n  return null\n}\n\n// The range is never cut at the offset: a pattern resumed there simply begins a\n// fresh match at the cursor — 'pha' inside 'alpha' for `\\w+` — and a range no\n// listing of the document holds is one the reader was never shown and Replace\n// must never rewrite. What the offset decides is which matches are kept, not\n// where the scan starts. Uncapped, because what stands at the cursor is being\n// asked for regardless of where the paint budget ran out.\nfunction firstMatchInRange(\n  source: FindTextSource,\n  query: CompiledFindQuery,\n  range: FindRange,\n  offset: number,\n  captureMatches: boolean,\n): FindMatch | null {\n  let found: FindMatch | null = null\n  const scanned = { start: forwardScanStart(source, query, range, offset), end: range.end }\n  scanRange(source, query, scanned, captureMatches, (start, end, captures) => {\n    if (start < offset) return true\n\n    found = { start, end, matches: captures }\n    return false\n  })\n\n  return found\n}\n\n// Lines in front of the cursor are skipped rather than searched: a match that\n// cannot hold a break cannot reach out of the line it starts on, so none of them\n// could answer at or after the offset anyway.\nfunction forwardScanStart(\n  source: FindTextSource,\n  query: CompiledFindQuery,\n  range: FindRange,\n  offset: number,\n): number {\n  if (!isLineLocalPlan(query.plan)) return range.start\n\n  const lineStartsView = source.lineStartsView\n  const line = lineStartsView.indexForOffset(Math.max(range.start, offset))\n  return Math.max(range.start, lineStartsView.at(line) ?? 0)\n}\n\nfunction isLineLocalPlan(plan: FindQueryPlan): boolean {\n  return plan.kind === 'lines' || plan.kind === 'anchored-lines'\n}\n\nfunction lastMatchBefore(\n  source: FindTextSource,\n  query: CompiledFindQuery,\n  ranges: readonly FindRange[],\n  offset: number,\n  options: FindMatchFromOptions,\n): FindMatch | null {\n  for (const range of ranges.toReversed()) {\n    if (range.start > offset) continue\n\n    const found = lastMatchInRange(source, query, range, offset, options)\n    if (found) return found\n  }\n\n  return null\n}\n\n// Walked back a window at a time, because the match before the cursor is the one\n// being asked for and listing everything behind it to reach the last entry is\n// the whole document on a search that started near its end.\nfunction lastMatchInRange(\n  source: FindTextSource,\n  query: CompiledFindQuery,\n  searched: FindRange,\n  offset: number,\n  options: FindMatchFromOptions,\n): FindMatch | null {\n  // A pattern that can run past a break is shown the text behind the cursor too:\n  // cut at the cursor's line, `[^a]+$` would end there on a match no listing of\n  // the document holds. The scan still stops at the first match past the cursor.\n  if (!isLineLocalPlan(query.plan))\n    return lastMatchInWindow(source, query, searched, offset, options)\n\n  const range = { start: searched.start, end: Math.min(searched.end, offset) }\n  const lineStartsView = source.lineStartsView\n  let last = lineStartsView.indexForOffset(range.end)\n  while (last >= 0) {\n    const reach = Math.max(range.start, (lineStartsView.at(last) ?? 0) - FIND_WINDOW_UNITS)\n    const first = lineStartsView.indexForOffset(reach)\n    const firstStart = lineStartsView.at(first) ?? 0\n    const window = {\n      start: Math.max(range.start, firstStart),\n      end: Math.min(range.end, lineEndAt(source, last)),\n    }\n    const found =\n      window.end < window.start ? null : lastMatchInWindow(source, query, window, offset, options)\n    if (found) return found\n    if (firstStart <= range.start) return null\n\n    last = first - 1\n  }\n\n  return null\n}\n\n// The last match in one window, escaping the same way stepping an ordered list\n// does: what stands before a zero-width match parked on the cursor is the entry\n// the search is being asked for, and it may be in an earlier window. Uncapped,\n// and only the last two are kept: a listing that stopped at the paint cap would\n// answer every press behind the cursor with the 19,999th match.\nfunction lastMatchInWindow(\n  source: FindTextSource,\n  query: CompiledFindQuery,\n  range: FindRange,\n  offset: number,\n  options: FindMatchFromOptions,\n): FindMatch | null {\n  let last: FindMatch | null = null\n  let beforeLast: FindMatch | null = null\n  scanRange(source, query, range, options.captureMatches ?? false, (start, end, captures) => {\n    if (end > offset) return false\n\n    beforeLast = last\n    last = { start, end, matches: captures }\n    return true\n  })\n  if (!last) return null\n  if (!escapesEmptyMatch(last, offset, options.escapeEmptyMatchAtOffset ?? false)) return last\n\n  return beforeLast\n}\n\n// A pattern compiled with the unicode flag may not be resumed inside a surrogate\n// pair, so stepping off an empty match steps a code point rather than a unit.\nfunction nextCodePointOffset(source: FindTextSource, offset: number): number {\n  const text = source.readRange(offset, Math.min(source.length, offset + 2))\n  return offset + Math.max(1, codePointSizeAt(text, 0))\n}\n\n// True when the query contains at least one character whose case can differ,\n// which is the only situation where matchCase changes what a plain search\n// finds. Digits, punctuation and CJK are caseless, so an untouched indexOf is\n// still exact for them even with matchCase off.\nfunction queryIsCaseSensitiveByContent(searchString: string): boolean {\n  return searchString.toLowerCase() !== searchString.toUpperCase()\n}\n\n/**\n * Whether every part of a pattern is provably unable to match a line break.\n *\n * Asked the safe way round. Listing the constructs that CAN hold a break means\n * one nobody thought of routes a query to the windowed path, where it answers\n * \"no results\" for text that is plainly there — the one wrong answer a search\n * must never give. So a query is windowed only when every part of it is provably\n * break-free, and anything unrecognized takes the slower path that is always\n * correct.\n */\nfunction isLineSafePattern(pattern: string): boolean {\n  for (let index = 0; index < pattern.length; index += 1) {\n    const char = pattern[index]\n    if (char === '\\n') return false\n    if (char === '[') {\n      const end = characterClassEnd(pattern, index)\n      if (end === null || !isLineSafeCharacterClass(pattern.slice(index + 1, end))) return false\n\n      index = end\n      continue\n    }\n\n    if (char === '(' && !isLineSafeGroupOpener(pattern, index)) return false\n    if (char !== '\\\\') continue\n\n    index += 1\n    const escaped = pattern[index]\n    if (escaped === undefined) return false\n    // A hex or unicode escape can spell the break itself, and reading which one\n    // it spells is more machinery than routing it to the correct path costs.\n    if (!LINE_SAFE_ESCAPES.has(escaped) && /[\\p{L}\\p{N}]/u.test(escaped)) return false\n  }\n\n  return true\n}\n\n/**\n * Only a group that bundles what is written inside it, leaving its meaning alone.\n *\n * A capture, a non-capture and either lookaround are all of those. A modifier\n * group is not: it can switch on the flag under which a dot spans a break, so the\n * characters inside it stop saying what they say anywhere else — and reading back\n * which flags one names is more machinery than routing it to the correct path\n * costs. Every other spelling is one nobody here recognized, which is the same\n * answer.\n */\nfunction isLineSafeGroupOpener(pattern: string, index: number): boolean {\n  if (pattern[index + 1] !== '?') return true\n\n  const kind = pattern[index + 2]\n  // '<' opens a lookbehind or names a capture, and neither changes what matches.\n  return kind === ':' || kind === '=' || kind === '!' || kind === '<'\n}\n\n// Only a positive class naming its members outright: a negated one holds a break\n// unless it names it, and an escape inside one can bring a whole class with it.\nfunction isLineSafeCharacterClass(body: string): boolean {\n  if (body.startsWith('^')) return false\n  return !body.includes('\\\\') && !body.includes('\\n')\n}\n\nfunction characterClassEnd(pattern: string, from: number): number | null {\n  for (let index = from + 1; index < pattern.length; index += 1) {\n    if (pattern[index] === '\\\\') index += 1\n    else if (pattern[index] === ']') return index\n  }\n\n  return null\n}\n\nfunction compileFindQuery(query: FindQuery): CompiledFindQuery | null {\n  if (query.searchString.length === 0) return null\n\n  const source = query.isRegex ? query.searchString : escapeRegExpCharacters(query.searchString)\n  const plan = planFindQuery(query)\n  const lineCrossing = plan.kind === 'range' || plan.kind === 'literal-lines'\n  // Flags describe the haystack, and only a line-crossing search is ever handed\n  // one holding a break: a per-line slice bounds `^` and `$` by itself, so `m`\n  // there would only claim breaks the slice does not contain.\n  const flags = `g${query.matchCase ? '' : 'i'}${lineCrossing ? 'm' : ''}`\n\n  // The fast path may never case-fold the haystack: folding is not\n  // length-preserving (U+0130 'İ' lowercases to two code units), so an index\n  // into folded text does not address the original text, and a match reported\n  // from it slices the wrong characters — Replace would then overwrite them.\n  // Fall back to the case-insensitive regex, which reports original indices.\n  const canUseSimpleSearch =\n    !query.isRegex && (query.matchCase || !queryIsCaseSensitiveByContent(query.searchString))\n\n  const regex = compileRegex(source, flags)\n  if (!regex) return null\n\n  return {\n    regex,\n    simpleSearch: canUseSimpleSearch ? query.searchString : null,\n    wholeWord: query.wholeWord,\n    plan,\n  }\n}\n\nfunction planFindQuery(query: FindQuery): FindQueryPlan {\n  if (!query.isRegex) {\n    const lineBreaks = query.searchString.split('\\n').length - 1\n    return lineBreaks === 0 ? { kind: 'lines' } : { kind: 'literal-lines', lineBreaks }\n  }\n\n  if (!isLineSafePattern(query.searchString))\n    return { kind: 'range', reason: 'pattern-may-match-line-break' }\n  return hasLineAnchor(query.searchString) ? { kind: 'anchored-lines' } : { kind: 'lines' }\n}\n\n// Asked of a pattern already known to be line-safe, so a class cannot be negated\n// and a `^` inside one is a member rather than an anchor.\nfunction hasLineAnchor(pattern: string): boolean {\n  for (let index = 0; index < pattern.length; index += 1) {\n    const char = pattern[index]\n    if (char === '\\\\') index += 1\n    else if (char === '[') index = characterClassEnd(pattern, index) ?? pattern.length\n    else if (char === '^' || char === '$') return true\n  }\n\n  return false\n}\n\n/**\n * The pattern under the unicode flag where it takes it, and without it where it\n * does not.\n *\n * Wanted, because `u` is what makes a surrogate pair one character to a dot and\n * `\\p{...}` mean anything at all. Not required, because its grammar rejects\n * spellings the flagless one accepts — an identity escape of a character that\n * needs none (`\\-`, `\\ `), a brace or bracket standing for itself, a legacy\n * back-reference — and every one of those is what escaping a search by hand\n * produces. A rejected pattern is not reported anywhere the user can see it: it\n * reaches them as \"No results\", indistinguishable from text that is not there.\n */\nfunction compileRegex(source: string, flags: string): RegExp | null {\n  try {\n    return new RegExp(source, `${flags}u`)\n  } catch {\n    // Ignored: whether the pattern is invalid outright or only invalid under the\n    // stricter grammar is what the second construction answers.\n  }\n\n  try {\n    return new RegExp(source, flags)\n  } catch {\n    return null\n  }\n}\n\nfunction searchRanges(\n  source: FindTextSource,\n  ranges: readonly FindRange[] | null,\n): readonly FindRange[] {\n  if (!ranges || ranges.length === 0) return [{ start: 0, end: source.length }]\n\n  const clamped = ranges\n    .map((range) => ({\n      start: clampSourceOffset(source, range.start),\n      end: clampSourceOffset(source, range.end),\n    }))\n    .filter((range) => range.start <= range.end)\n    .toSorted(compareTextOffsetRanges)\n\n  // Scopes are followed through edits, and an edit spanning the seam between two\n  // of them leaves them overlapping. Searching both would report the text they\n  // share twice, which a Replace All then tries to rewrite twice.\n  const merged: FindRange[] = []\n  for (const range of clamped) {\n    const previous = merged.at(-1)\n    if (previous && range.start <= previous.end) {\n      merged[merged.length - 1] = { start: previous.start, end: Math.max(previous.end, range.end) }\n      continue\n    }\n\n    merged.push(range)\n  }\n\n  return merged\n}\n\nfunction clampSourceOffset(source: FindTextSource, offset: number): number {\n  return Math.min(Math.max(0, offset), source.length)\n}\n\n// Visited in document order; false stops the scan where it stands.\ntype FindMatchVisitor = (start: number, end: number, captures: RegExpExecArray | null) => boolean\n\n/** False once the range is spent or the visitor stopped: nothing later in it is read. */\nfunction scanRange(\n  source: FindTextSource,\n  query: CompiledFindQuery,\n  range: FindRange,\n  captureMatches: boolean,\n  visit: FindMatchVisitor,\n): boolean {\n  if (query.plan.kind === 'range')\n    return scanWholeRange(source, query, range, captureMatches, visit)\n  if (query.plan.kind === 'literal-lines')\n    return scanSpanningLiteral(source, query, range, query.plan.lineBreaks, visit)\n\n  return scanLines(source, query, range, captureMatches, visit)\n}\n\n// Whole lines, even where the range was cut inside one: the anchors and the word\n// boundaries have to answer for the line the reader sees rather than for where\n// the range happens to end, so the range only decides which matches are kept.\n//\n// Read many lines to a window. A match that cannot hold a break cannot leave its\n// line, and a break is no word character, so a pattern with no `^` or `$` finds in\n// the window exactly what it finds line by line, without a tree descent per line.\nfunction scanLines(\n  source: FindTextSource,\n  query: CompiledFindQuery,\n  range: FindRange,\n  captureMatches: boolean,\n  visit: FindMatchVisitor,\n): boolean {\n  const lineStartsView = source.lineStartsView\n  let index = lineStartsView.indexForOffset(range.start)\n  while (index < lineStartsView.length) {\n    const start = lineStartsView.at(index)\n    if (start === undefined || start > range.end) return true\n\n    const last = lastWindowLine(source, index, start, range.end)\n    const window = readWindow(source, start, lineEndAt(source, last), range)\n    if (!scanLineWindow(window, query, range, captureMatches, visit)) return false\n    index = last + 1\n  }\n\n  return true\n}\n\nfunction lastWindowLine(\n  source: FindTextSource,\n  first: number,\n  start: number,\n  rangeEnd: number,\n): number {\n  const reach = Math.min(rangeEnd, start + FIND_WINDOW_UNITS)\n  return Math.max(first, source.lineStartsView.indexForOffset(reach))\n}\n\nfunction scanLineWindow(\n  window: FindWindow,\n  query: CompiledFindQuery,\n  range: FindRange,\n  captureMatches: boolean,\n  visit: FindMatchVisitor,\n): boolean {\n  if (query.plan.kind !== 'anchored-lines')\n    return scanWindow(window, query, range, captureMatches, visit)\n\n  // `^` and `$` answer for the ends of the haystack, so each line is its own.\n  let lineStart = 0\n  while (lineStart <= window.text.length) {\n    const found = window.text.indexOf('\\n', lineStart)\n    const lineEnd = found === -1 ? window.text.length : found\n    const line = {\n      text: window.text.slice(lineStart, lineEnd),\n      start: window.start + lineStart,\n      from: Math.max(0, window.from - lineStart),\n    }\n    if (lineEnd >= window.from && !scanWindow(line, query, range, captureMatches, visit))\n      return false\n\n    lineStart = lineEnd + 1\n  }\n\n  return true\n}\n\n// A literal holding breaks spans exactly that many lines past the one it starts\n// on, so windows overlapping by that many lines show every match whole to at\n// least one of them. The cursor is carried across: restarting the greedy scan at\n// an overlap's first character would change which of two overlapping candidates\n// wins, and with it every match after them.\nfunction scanSpanningLiteral(\n  source: FindTextSource,\n  query: CompiledFindQuery,\n  range: FindRange,\n  lineBreaks: number,\n  visit: FindMatchVisitor,\n): boolean {\n  const lineStartsView = source.lineStartsView\n  const finalLine = lineStartsView.indexForOffset(range.end)\n  let first = lineStartsView.indexForOffset(range.start)\n  const cursor = { offset: range.start }\n  while (first <= finalLine) {\n    const start = lineStartsView.at(first) ?? 0\n    const last = Math.min(\n      finalLine,\n      Math.max(first + lineBreaks, lastWindowLine(source, first, start, range.end)),\n    )\n    const text = source.readRange(start, Math.max(start, lineEndAt(source, last)))\n    const window = { text, start, from: Math.max(0, cursor.offset - start) }\n    if (!scanWindow(window, query, range, false, visit, cursor)) return false\n    if (last === finalLine) return true\n\n    first = last + 1 - lineBreaks\n  }\n\n  return true\n}\n\n// Listing every match of a pattern that can span the range's ends has to look at\n// every character between them, so the range is read as one window: a window\n// grown in steps would only re-run the pattern over text it already scanned. The\n// window still stops on line boundaries, or `^` and `$` would answer for its cut\n// ends instead of for real ones.\nfunction scanWholeRange(\n  source: FindTextSource,\n  query: CompiledFindQuery,\n  range: FindRange,\n  captureMatches: boolean,\n  visit: FindMatchVisitor,\n): boolean {\n  const lineStartsView = source.lineStartsView\n  const start = lineStartsView.at(lineStartsView.indexForOffset(range.start)) ?? 0\n  const end = lineEndAt(source, lineStartsView.indexForOffset(range.end))\n  const window = readWindow(source, start, Math.max(start, end), range)\n  return scanWindow(window, query, range, captureMatches, visit)\n}\n\nfunction readWindow(\n  source: FindTextSource,\n  start: number,\n  end: number,\n  range: FindRange,\n): FindWindow {\n  return { text: source.readRange(start, end), start, from: Math.max(0, range.start - start) }\n}\n\n// Where the next raw match may begin. It moves past every raw match, including\n// one the whole-word filter rejects, so the scan keeps one non-overlap phase.\ntype FindCursor = { offset: number }\n\n/** False once the range is spent or the visitor stopped, so no later window can add anything. */\nfunction scanWindow(\n  window: FindWindow,\n  query: CompiledFindQuery,\n  range: FindRange,\n  captureMatches: boolean,\n  visit: FindMatchVisitor,\n  cursor?: FindCursor,\n): boolean {\n  if (query.simpleSearch && !captureMatches)\n    return scanSimpleMatches(window, query.simpleSearch, query.wholeWord, range, visit, cursor)\n\n  return scanRegexMatches(window, query, range, captureMatches, visit, cursor)\n}\n\nfunction scanSimpleMatches(\n  window: FindWindow,\n  searchString: string,\n  wholeWord: boolean,\n  range: FindRange,\n  visit: FindMatchVisitor,\n  cursor?: FindCursor,\n): boolean {\n  // Searched as-is: no folded copy of the text is allocated, and every index\n  // returned addresses the window it came from.\n  let index = window.text.indexOf(searchString, window.from)\n  while (index !== -1) {\n    const start = window.start + index\n    const end = start + searchString.length\n    if (end > range.end) return false\n    if (cursor) cursor.offset = end\n    if (validWholeWordMatch(window.text, index, searchString.length, wholeWord)) {\n      if (!visit(start, end, null)) return false\n    }\n\n    index = window.text.indexOf(searchString, index + searchString.length)\n  }\n\n  return true\n}\n\nfunction scanRegexMatches(\n  window: FindWindow,\n  query: CompiledFindQuery,\n  range: FindRange,\n  captureMatches: boolean,\n  visit: FindMatchVisitor,\n  cursor?: FindCursor,\n): boolean {\n  query.regex.lastIndex = window.from\n  while (true) {\n    const match = query.regex.exec(window.text)\n    if (!match) return true\n\n    const start = window.start + match.index\n    const end = start + match[0].length\n    if (start > range.end || end > range.end) return false\n    if (cursor) cursor.offset = end\n    if (validWholeWordMatch(window.text, match.index, match[0].length, query.wholeWord)) {\n      if (!visit(start, end, captureMatches ? match : null)) return false\n    }\n\n    if (match[0].length === 0) advancePastEmptyMatch(query.regex, window.text)\n  }\n}\n\nfunction advancePastEmptyMatch(regex: RegExp, text: string): void {\n  const current = regex.lastIndex\n  if (current > text.length) return\n\n  const size = codePointSizeAt(text, current)\n  regex.lastIndex = current + Math.max(1, size)\n}\n\nfunction validWholeWordMatch(\n  text: string,\n  start: number,\n  length: number,\n  wholeWord: boolean,\n): boolean {\n  if (!wholeWord) return true\n  return isWholeWordRange(text, { start, end: start + length })\n}\n"],"mappings":"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"}