@mintlify/common 1.0.1138 → 1.0.1139

package/dist/index.d.ts

@@ -21,6 +21,7 @@ export * from './asyncapi/index.js';
 export * from './isAbsoluteUrl.js';
 export * from './isValidEmail.js';
 export * from './rss/index.js';
+export * from './search/index.js';
 export * from './services/aws.js';
 export * from './slugify.js';
 export * from './services/aws.js';

package/dist/index.js

@@ -21,6 +21,7 @@ export * from './asyncapi/index.js';
 export * from './isAbsoluteUrl.js';
 export * from './isValidEmail.js';
 export * from './rss/index.js';
+export * from './search/index.js';
 export * from './services/aws.js';
 export * from './slugify.js';
 export * from './services/aws.js';

package/dist/search/highlight.d.ts

@@ -0,0 +1,7 @@
+export declare function getHighlightedText(text: string, query: string): string;
+export type HighlightSnippetOptions = {
+    leadingContext?: number;
+    maxLength?: number;
+};
+export declare function stripDuplicatedTitleLine(content: string, header: string): string;
+export declare function getHighlightedSnippet(text: string, query: string, options?: HighlightSnippetOptions): string;

package/dist/search/highlight.js

@@ -0,0 +1,400 @@
+const STOP_WORDS = new Set([
+    'i',
+    'me',
+    'my',
+    'myself',
+    'we',
+    'our',
+    'ours',
+    'ourselves',
+    'you',
+    'your',
+    'yours',
+    'yourself',
+    'yourselves',
+    'he',
+    'him',
+    'his',
+    'himself',
+    'she',
+    'her',
+    'hers',
+    'herself',
+    'it',
+    'its',
+    'itself',
+    'they',
+    'them',
+    'their',
+    'theirs',
+    'themselves',
+    'what',
+    'which',
+    'who',
+    'whom',
+    'this',
+    'that',
+    'these',
+    'those',
+    'am',
+    'is',
+    'are',
+    'was',
+    'were',
+    'be',
+    'been',
+    'being',
+    'have',
+    'has',
+    'had',
+    'having',
+    'do',
+    'does',
+    'did',
+    'doing',
+    'a',
+    'an',
+    'the',
+    'and',
+    'but',
+    'if',
+    'or',
+    'because',
+    'as',
+    'until',
+    'while',
+    'of',
+    'at',
+    'by',
+    'for',
+    'with',
+    'about',
+    'against',
+    'between',
+    'into',
+    'through',
+    'during',
+    'before',
+    'after',
+    'above',
+    'below',
+    'to',
+    'from',
+    'up',
+    'down',
+    'in',
+    'out',
+    'on',
+    'off',
+    'over',
+    'under',
+    'again',
+    'further',
+    'then',
+    'once',
+    'here',
+    'there',
+    'when',
+    'where',
+    'why',
+    'how',
+    'all',
+    'any',
+    'both',
+    'each',
+    'few',
+    'more',
+    'most',
+    'other',
+    'some',
+    'such',
+    'no',
+    'nor',
+    'not',
+    'only',
+    'own',
+    'same',
+    'so',
+    'than',
+    'too',
+    'very',
+    's',
+    't',
+    'can',
+    'will',
+    'just',
+    'don',
+    'should',
+    'now',
+    "aren't",
+    "it's",
+    "don't",
+    'get',
+]);
+const MAX_QUERY_WORDS = 20;
+const HIGHLIGHT_TIMEOUT_MS = 100;
+const PRE_TAG = '<mark><b>';
+const POST_TAG = '</b></mark>';
+function escapeHtml(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+// Server-side search results arrive pre-wrapped with <mark><b>…</b></mark>
+// highlight tags. We re-highlight on the client now, so strip them here —
+// otherwise escapeHtml below would turn them into visible &lt;mark&gt; text.
+const SERVER_HIGHLIGHT_TAGS = /<\/?(?:mark|b)\b[^>]*>/gi;
+function stripServerHighlightTags(text) {
+    return text.replace(SERVER_HIGHLIGHT_TAGS, '');
+}
+function isStopWord(word) {
+    return STOP_WORDS.has(word.toLowerCase());
+}
+function chunkByNonStopWords(words) {
+    const groups = [];
+    let current = [];
+    for (const w of words) {
+        if (!w)
+            continue;
+        if (isStopWord(w)) {
+            if (current.length > 0) {
+                groups.push(current);
+                current = [];
+            }
+            continue;
+        }
+        current.push(w);
+    }
+    if (current.length > 0)
+        groups.push(current);
+    return groups;
+}
+function findAllCaseInsensitive(text, search) {
+    const lower = text.toLowerCase();
+    const searchLower = search.toLowerCase();
+    const indices = [];
+    let start = 0;
+    while (start <= lower.length - searchLower.length) {
+        const idx = lower.indexOf(searchLower, start);
+        if (idx === -1)
+            break;
+        indices.push(idx);
+        start = idx + 1;
+    }
+    return indices;
+}
+function generateQueryVariations(query) {
+    const cleanedQuery = query.replace(/[?,.!\n"]/g, '');
+    const queryWords = cleanedQuery.split(/\s+/).filter(Boolean).slice(0, MAX_QUERY_WORDS);
+    const groups = chunkByNonStopWords(queryWords);
+    const multiToken = [];
+    for (const group of groups) {
+        if (group.length > 1)
+            multiToken.push(group.join(' '));
+    }
+    const groupStarts = groups
+        .map((g) => cleanedQuery.indexOf(g.join(' ')))
+        .filter((i) => i >= 0)
+        .sort((a, b) => a - b);
+    for (let i = 0; i < groupStarts.length - 1; i++) {
+        const span = cleanedQuery.slice(groupStarts[i], groupStarts[i + 1]).trim();
+        const nonStopCount = span.split(/\s+/).filter((w) => !isStopWord(w)).length;
+        if (nonStopCount > 1) {
+            if (span.split(/\s+/).length > 1)
+                multiToken.push(span);
+        }
+    }
+    if (groupStarts.length > 0) {
+        const tail = cleanedQuery.slice(groupStarts[groupStarts.length - 1]).trim();
+        if (tail)
+            multiToken.push(tail);
+    }
+    for (let len = queryWords.length - 1; len > 0; len--) {
+        for (let skip = 0; skip <= queryWords.length - len; skip++) {
+            const sub = queryWords
+                .slice(skip, skip + len)
+                .map((w) => w.trim())
+                .join(' ');
+            const nonStopCount = sub.split(/\s+/).filter((w) => !isStopWord(w)).length;
+            if (len > 2 || nonStopCount >= 1) {
+                multiToken.push(sub);
+            }
+        }
+    }
+    const variations = [query, cleanedQuery, ...multiToken].filter((x) => x.trim().length > 0);
+    const seen = new Set();
+    const unique = [];
+    for (const v of variations) {
+        if (!seen.has(v)) {
+            seen.add(v);
+            unique.push(v);
+        }
+    }
+    const numWords = queryWords.length;
+    unique.sort((a, b) => {
+        if (numWords >= MAX_QUERY_WORDS)
+            return b.trim().length - a.trim().length;
+        const aWords = a.split(/\s+/).filter(Boolean).length;
+        const bWords = b.split(/\s+/).filter(Boolean).length;
+        if (bWords !== aWords)
+            return bWords - aWords;
+        return b.trim().length - a.trim().length;
+    });
+    return unique;
+}
+function computeMergedSpans(text, matchedQueries) {
+    var _a;
+    const spans = [];
+    const isWordChar = /\w/;
+    for (const q of matchedQueries) {
+        const trimmed = q.trim();
+        if (!trimmed)
+            continue;
+        const isSingleWord = !/\s/.test(trimmed);
+        for (const idx of findAllCaseInsensitive(text, trimmed)) {
+            const end = idx + trimmed.length;
+            if (isSingleWord) {
+                const beforeOk = idx === 0 || !isWordChar.test((_a = text[idx - 1]) !== null && _a !== void 0 ? _a : '');
+                if (!beforeOk)
+                    continue;
+            }
+            spans.push({ start: idx, end });
+        }
+    }
+    spans.sort((a, b) => a.start - b.start || b.end - a.end);
+    const mergedSpans = [];
+    for (const span of spans) {
+        const last = mergedSpans[mergedSpans.length - 1];
+        if (last && span.start <= last.end) {
+            last.end = Math.max(last.end, span.end);
+        }
+        else {
+            mergedSpans.push({ start: span.start, end: span.end });
+        }
+    }
+    return mergedSpans;
+}
+function renderSpans(text, mergedSpans) {
+    let result = '';
+    let cursor = 0;
+    for (const span of mergedSpans) {
+        result += escapeHtml(text.slice(cursor, span.start));
+        const original = text.slice(span.start, span.end);
+        if (original)
+            result += `${PRE_TAG}${escapeHtml(original)}${POST_TAG}`;
+        cursor = span.end;
+    }
+    result += escapeHtml(text.slice(cursor));
+    return result;
+}
+function renderHighlightedSpans(text, matchedQueries) {
+    return renderSpans(text, computeMergedSpans(text, matchedQueries));
+}
+const VARIATIONS_CACHE_LIMIT = 64;
+const variationsCache = new Map();
+function getCachedVariations(query) {
+    const cached = variationsCache.get(query);
+    if (cached)
+        return cached;
+    const variations = generateQueryVariations(query);
+    variationsCache.set(query, variations);
+    if (variationsCache.size > VARIATIONS_CACHE_LIMIT) {
+        const oldestKey = variationsCache.keys().next().value;
+        if (oldestKey !== undefined)
+            variationsCache.delete(oldestKey);
+    }
+    return variations;
+}
+function getMatchedQueries(text, query) {
+    const deadline = Date.now() + HIGHLIGHT_TIMEOUT_MS;
+    const variations = getCachedVariations(query);
+    const matchedQueries = [];
+    for (const variation of variations) {
+        if (Date.now() > deadline)
+            return [];
+        const trimmed = variation.trim();
+        if (matchedQueries.some((q) => q.trim() === trimmed))
+            continue;
+        if (findAllCaseInsensitive(text, variation).length > 0) {
+            matchedQueries.push(variation);
+        }
+    }
+    return matchedQueries;
+}
+export function getHighlightedText(text, query) {
+    const stripped = stripServerHighlightTags(text);
+    if (!stripped || !query)
+        return escapeHtml(stripped);
+    const matchedQueries = getMatchedQueries(stripped, query);
+    if (matchedQueries.length === 0)
+        return escapeHtml(stripped);
+    return renderHighlightedSpans(stripped, matchedQueries);
+}
+const ELLIPSIS = '…';
+const SNIPPET_LEADING_CONTEXT = 24;
+const SNIPPET_MAX_LENGTH = 240;
+const SNIPPET_BOUNDARY_LOOKAROUND = 12;
+function snapStartToWordBoundary(text, index, lookaround) {
+    if (index <= 0)
+        return 0;
+    const earliest = Math.max(0, index - lookaround);
+    const previousSpace = text.lastIndexOf(' ', index - 1);
+    return previousSpace >= earliest ? previousSpace + 1 : index;
+}
+function snapEndToWordBoundary(text, index, lookaround) {
+    if (index >= text.length)
+        return text.length;
+    const latest = Math.min(text.length, index + lookaround);
+    const nextSpace = text.indexOf(' ', index);
+    return nextSpace !== -1 && nextSpace < latest ? nextSpace : index;
+}
+function leadingWindow(text, maxLength) {
+    if (text.length <= maxLength)
+        return escapeHtml(text);
+    const end = snapEndToWordBoundary(text, maxLength, SNIPPET_BOUNDARY_LOOKAROUND);
+    return `${escapeHtml(text.slice(0, end))} ${ELLIPSIS}`;
+}
+export function stripDuplicatedTitleLine(content, header) {
+    const newlineIdx = content.indexOf('\n');
+    if (newlineIdx < 0 || !header)
+        return content;
+    const normalize = (value) => stripServerHighlightTags(value).replace(/\s+/g, ' ').trim();
+    return normalize(content.slice(0, newlineIdx)) === normalize(header)
+        ? content.slice(newlineIdx + 1)
+        : content;
+}
+export function getHighlightedSnippet(text, query, options) {
+    var _a, _b;
+    const stripped = stripServerHighlightTags(text);
+    const leadingContext = (_a = options === null || options === void 0 ? void 0 : options.leadingContext) !== null && _a !== void 0 ? _a : SNIPPET_LEADING_CONTEXT;
+    const maxLength = (_b = options === null || options === void 0 ? void 0 : options.maxLength) !== null && _b !== void 0 ? _b : SNIPPET_MAX_LENGTH;
+    if (!stripped || !query)
+        return leadingWindow(stripped, maxLength);
+    const matchedQueries = getMatchedQueries(stripped, query);
+    if (matchedQueries.length === 0)
+        return leadingWindow(stripped, maxLength);
+    const mergedSpans = computeMergedSpans(stripped, matchedQueries);
+    const firstMatch = mergedSpans[0];
+    if (!firstMatch)
+        return leadingWindow(stripped, maxLength);
+    let windowStart = firstMatch.start <= leadingContext ? 0 : firstMatch.start - leadingContext;
+    let windowEnd = Math.min(stripped.length, Math.max(firstMatch.end, windowStart + maxLength));
+    windowStart = snapStartToWordBoundary(stripped, windowStart, SNIPPET_BOUNDARY_LOOKAROUND);
+    windowEnd = snapEndToWordBoundary(stripped, windowEnd, SNIPPET_BOUNDARY_LOOKAROUND);
+    const windowed = stripped.slice(windowStart, windowEnd);
+    const windowedSpans = [];
+    for (const span of mergedSpans) {
+        if (span.end <= windowStart || span.start >= windowEnd)
+            continue;
+        windowedSpans.push({
+            start: Math.max(0, span.start - windowStart),
+            end: Math.min(windowed.length, span.end - windowStart),
+        });
+    }
+    const body = renderSpans(windowed, windowedSpans);
+    const lead = windowStart > 0 ? `${ELLIPSIS} ` : '';
+    const trail = windowEnd < stripped.length ? ` ${ELLIPSIS}` : '';
+    return `${lead}${body}${trail}`;
+}

package/dist/search/highlight.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/search/highlight.test.js

@@ -0,0 +1,176 @@
+import { describe, expect, test } from 'vitest';
+import { getHighlightedSnippet, getHighlightedText, stripDuplicatedTitleLine, } from './highlight.js';
+const PRE = '<mark><b>';
+const POST = '</b></mark>';
+const ELLIPSIS = '…';
+describe('getHighlightedText', () => {
+    test('returns escaped text unchanged when query is empty', () => {
+        expect(getHighlightedText('Quickstart', '')).toBe('Quickstart');
+        expect(getHighlightedText('', 'foo')).toBe('');
+    });
+    test('returns escaped text unchanged when no match is found', () => {
+        expect(getHighlightedText('Quickstart', 'foobar')).toBe('Quickstart');
+    });
+    test('wraps a case-insensitive match in mark/b tags and preserves original casing', () => {
+        expect(getHighlightedText('Quickstart', 'quickstart')).toBe(`${PRE}Quickstart${POST}`);
+    });
+    test('highlights every occurrence of the query', () => {
+        expect(getHighlightedText('search and search again', 'search')).toBe(`${PRE}search${POST} and ${PRE}search${POST} again`);
+    });
+    test('escapes HTML in the surrounding text', () => {
+        expect(getHighlightedText('<script>quickstart</script>', 'quickstart')).toBe(`&lt;script&gt;${PRE}quickstart${POST}&lt;/script&gt;`);
+    });
+    test('highlights matches across a full chunk without truncating', () => {
+        const content = Array.from({ length: 200 }, (_, i) => (i === 100 ? 'target' : `w${i}`)).join(' ');
+        const result = getHighlightedText(content, 'target');
+        expect(result).toContain(`${PRE}target${POST}`);
+        expect(result).toContain('w0');
+        expect(result).toContain('w199');
+    });
+    test('highlights multi-word query terms', () => {
+        const content = 'Learn how to configure webhooks for your application and receive events';
+        const result = getHighlightedText(content, 'configure webhooks');
+        expect(result).toContain(`${PRE}configure webhooks${POST}`);
+    });
+    test('preserves original case in highlighted text', () => {
+        const content = 'The TypeScript SDK provides type safety';
+        const result = getHighlightedText(content, 'typescript sdk');
+        expect(result).toContain(`${PRE}TypeScript SDK${POST}`);
+    });
+    test('escapes HTML in non-highlighted content to prevent XSS', () => {
+        const content = 'Use <script>alert("xss")</script> to test the API endpoint';
+        const result = getHighlightedText(content, 'API');
+        expect(result).not.toContain('<script>');
+        expect(result).toContain('&lt;script&gt;');
+        expect(result).toContain(`${PRE}API${POST}`);
+    });
+    test('respects word boundaries when only padded variations match', () => {
+        const result = getHighlightedText('shellofoo and a stray foo here', 'foo bar');
+        expect(result).toContain(`stray ${PRE}foo${POST} here`);
+        expect(result).not.toContain(`shello${PRE}foo${POST}`);
+    });
+    test('highlights standalone words when a compound match also appears', () => {
+        const result = getHighlightedText('foo bar here, also foo standalone, and bar elsewhere', 'foo bar');
+        expect(result).toContain(`${PRE}foo bar${POST}`);
+        expect(result).toContain(`also ${PRE}foo${POST} standalone`);
+        expect(result).toContain(`and ${PRE}bar${POST} elsewhere`);
+    });
+    test('highlights an individual query word inside a short text segment', () => {
+        expect(getHighlightedText('Webhooks', 'configure webhooks')).toBe(`${PRE}Webhooks${POST}`);
+    });
+    test('highlights a word prefix when the query is a partial word', () => {
+        expect(getHighlightedText('Test the integration', 'tes')).toBe(`${PRE}Tes${POST}t the integration`);
+        expect(getHighlightedText('Testing your proxy setup', 'tes')).toBe(`${PRE}Tes${POST}ting your proxy setup`);
+    });
+    test('highlights the full word when the query matches it exactly', () => {
+        expect(getHighlightedText('Test the integration', 'test')).toBe(`${PRE}Test${POST} the integration`);
+    });
+    test('does not highlight a partial match in the middle of a word', () => {
+        expect(getHighlightedText('latest greatest', 'test')).toBe('latest greatest');
+    });
+    test('strips server-emitted <mark><b> highlight tags before re-highlighting', () => {
+        expect(getHighlightedText('<mark><b>Install</b></mark> the Mintlify CLI', 'install')).toBe(`${PRE}Install${POST} the Mintlify CLI`);
+    });
+    test('strips server highlight tags even when query has no match', () => {
+        expect(getHighlightedText('<mark><b>Install</b></mark> the CLI', 'foobar')).toBe('Install the CLI');
+    });
+    test('strips server highlight tags when query is empty', () => {
+        expect(getHighlightedText('<mark><b>Install</b></mark> the CLI', '')).toBe('Install the CLI');
+    });
+    test('completes within timeout for very long queries', () => {
+        const content = 'A '.repeat(1000) + 'needle ' + 'B '.repeat(1000);
+        const longQuery = Array.from({ length: 30 }, (_, i) => `word${i}`).join(' ');
+        const start = Date.now();
+        getHighlightedText(content, longQuery);
+        const elapsed = Date.now() - start;
+        expect(elapsed).toBeLessThan(500);
+    });
+});
+describe('getHighlightedSnippet', () => {
+    test('returns escaped text unchanged when query is empty', () => {
+        expect(getHighlightedSnippet('Quickstart', '')).toBe('Quickstart');
+        expect(getHighlightedSnippet('', 'foo')).toBe('');
+    });
+    test('returns escaped text unchanged when no match is found', () => {
+        expect(getHighlightedSnippet('Quickstart guide', 'foobar')).toBe('Quickstart guide');
+    });
+    test('does not window when the match is near the start', () => {
+        expect(getHighlightedSnippet('Quickstart guide for the API', 'quickstart')).toBe(`${PRE}Quickstart${POST} guide for the API`);
+    });
+    test('windows around a match buried deep in the content', () => {
+        const boilerplate = 'REST Endpoint POST /v1/resources Summary Creates a resource Description This endpoint ';
+        const content = `${boilerplate}accepts a customerEmail field in the request body`;
+        const result = getHighlightedSnippet(content, 'customerEmail');
+        expect(result.startsWith(`${ELLIPSIS} `)).toBe(true);
+        expect(result).toContain(`${PRE}customerEmail${POST}`);
+        // Leading boilerplate is windowed out of the snippet.
+        expect(result).not.toContain('REST Endpoint POST');
+    });
+    test('keeps preceding context before the match within the leading window', () => {
+        const content = 'word '.repeat(40) + 'before target needle after';
+        const result = getHighlightedSnippet(content, 'needle');
+        expect(result).toContain(`${PRE}needle${POST}`);
+        expect(result).toContain('target');
+    });
+    test('adds a trailing ellipsis when content is windowed at both ends', () => {
+        const lead = 'lorem ipsum dolor sit amet '.repeat(5);
+        const tail = ' consectetur adipiscing elit sed do eiusmod tempor incididunt'.repeat(10);
+        const content = `${lead}MATCHWORD${tail}`;
+        const result = getHighlightedSnippet(content, 'matchword');
+        expect(result.startsWith(`${ELLIPSIS} `)).toBe(true);
+        expect(result.endsWith(` ${ELLIPSIS}`)).toBe(true);
+        expect(result).toContain(`${PRE}MATCHWORD${POST}`);
+    });
+    test('does not add a trailing ellipsis when the match is at the very end', () => {
+        const content = 'word '.repeat(40) + 'finalToken';
+        const result = getHighlightedSnippet(content, 'finalToken');
+        expect(result.startsWith(`${ELLIPSIS} `)).toBe(true);
+        expect(result.endsWith(`${PRE}finalToken${POST}`)).toBe(true);
+    });
+    test('escapes HTML in the windowed snippet', () => {
+        const content = 'intro text '.repeat(10) + '<script>danger</script> targetField value';
+        const result = getHighlightedSnippet(content, 'targetField');
+        expect(result).not.toContain('<script>');
+        expect(result).toContain('&lt;script&gt;');
+        expect(result).toContain(`${PRE}targetField${POST}`);
+    });
+    test('caps output length even when the match is near the start', () => {
+        const content = 'match ' + 'word '.repeat(400);
+        const result = getHighlightedSnippet(content, 'match', { maxLength: 40 });
+        expect(result.startsWith(`${PRE}match${POST}`)).toBe(true);
+        expect(result.endsWith(` ${ELLIPSIS}`)).toBe(true);
+        // No leading ellipsis since the window starts at the beginning.
+        expect(result.startsWith(`${ELLIPSIS}`)).toBe(false);
+        // Bounded output rather than the full ~2k-char chunk.
+        expect(result.length).toBeLessThan(120);
+    });
+    test('respects a custom leading context', () => {
+        const content = 'aaaa bbbb cccc dddd eeee ffff gggg needle tail';
+        const result = getHighlightedSnippet(content, 'needle', { leadingContext: 5 });
+        expect(result.startsWith(`${ELLIPSIS} `)).toBe(true);
+        expect(result).toContain(`${PRE}needle${POST}`);
+        expect(result).not.toContain('aaaa');
+    });
+    test('caps the leading window when there is no query or no match', () => {
+        const content = 'word '.repeat(100).trim();
+        const noQuery = getHighlightedSnippet(content, '', { maxLength: 40 });
+        const noMatch = getHighlightedSnippet(content, 'zzz', { maxLength: 40 });
+        for (const result of [noQuery, noMatch]) {
+            expect(result.endsWith(` ${ELLIPSIS}`)).toBe(true);
+            expect(result.length).toBeLessThan(60);
+            expect(result).not.toContain(PRE);
+        }
+        expect(getHighlightedSnippet('short text', 'zzz', { maxLength: 40 })).toBe('short text');
+    });
+});
+describe('stripDuplicatedTitleLine', () => {
+    test('drops a first line that repeats the header', () => {
+        expect(stripDuplicatedTitleLine('Install\nRun npm install', 'Install')).toBe('Run npm install');
+        expect(stripDuplicatedTitleLine('<mark>Install</mark>\nRun it', 'Install')).toBe('Run it');
+    });
+    test('leaves content alone otherwise', () => {
+        expect(stripDuplicatedTitleLine('Overview\nRun it', 'Install')).toBe('Overview\nRun it');
+        expect(stripDuplicatedTitleLine('Install', 'Install')).toBe('Install');
+        expect(stripDuplicatedTitleLine('Install\nRun it', '')).toBe('Install\nRun it');
+    });
+});

package/dist/search/index.d.ts

@@ -0,0 +1 @@
+export * from './highlight.js';

package/dist/search/index.js

@@ -0,0 +1 @@
+export * from './highlight.js';