@mintlify/common 1.0.1137 → 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/mdx/plugins/remark/remarkMdxRemoveJs.d.ts

@@ -3,4 +3,8 @@ import type { Root } from 'mdast';
 export declare function isStringSafe(value: string): boolean;
 export declare function filterStyleProperties(estree: Program): Program | null;
 export declare function rebuildStyleValue(properties: Property[]): string;
+export declare const MAX_PURE_DATA_DEPTH = 32;
+export declare function isPureDataExpression(value: unknown, depth?: number): boolean;
+export declare function isPureDataProgram(estree: Program): boolean;
+export declare function isUnsafeDataAttributeName(name: string): boolean;
 export declare function remarkMdxRemoveJs(): (tree: Root) => void;

package/dist/mdx/plugins/remark/remarkMdxRemoveJs.js

@@ -211,6 +211,76 @@ export function rebuildStyleValue(properties) {
     });
     return `{ ${parts.join(', ')} }`;
 }
+function isJsxLikeNode(value) {
+    return (typeof value === 'object' && value !== null && 'type' in value && typeof value.type === 'string');
+}
+const UNSAFE_OBJECT_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+export const MAX_PURE_DATA_DEPTH = 32;
+function isPureDataLiteral(node) {
+    if (node.type !== 'Literal' || 'regex' in node || 'bigint' in node)
+        return false;
+    const value = node.value;
+    return (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean');
+}
+function pureDataObjectKey(node) {
+    if (!isJsxLikeNode(node))
+        return null;
+    if (node.type === 'Identifier' && typeof node.name === 'string')
+        return node.name;
+    if (node.type === 'Literal' && (typeof node.value === 'string' || typeof node.value === 'number'))
+        return String(node.value);
+    return null;
+}
+function isPureDataProperty(value, depth) {
+    if (!isJsxLikeNode(value) || value.type !== 'Property')
+        return false;
+    if (value.kind !== 'init' ||
+        value.method === true ||
+        value.computed === true ||
+        value.shorthand === true)
+        return false;
+    const key = pureDataObjectKey(value.key);
+    if (key === null || UNSAFE_OBJECT_KEYS.has(key))
+        return false;
+    return isPureDataExpression(value.value, depth);
+}
+export function isPureDataExpression(value, depth = 0) {
+    if (!isJsxLikeNode(value))
+        return false;
+    if (isPureDataLiteral(value))
+        return true;
+    if (value.type === 'UnaryExpression') {
+        return (value.operator === '-' &&
+            isJsxLikeNode(value.argument) &&
+            value.argument.type === 'Literal' &&
+            typeof value.argument.value === 'number');
+    }
+    if (value.type === 'TemplateLiteral') {
+        return (Array.isArray(value.expressions) &&
+            value.expressions.length === 0 &&
+            Array.isArray(value.quasis));
+    }
+    if (depth >= MAX_PURE_DATA_DEPTH)
+        return false;
+    if (value.type === 'ArrayExpression') {
+        return (Array.isArray(value.elements) &&
+            value.elements.every((element) => isPureDataExpression(element, depth + 1)));
+    }
+    if (value.type === 'ObjectExpression') {
+        return (Array.isArray(value.properties) &&
+            value.properties.every((property) => isPureDataProperty(property, depth + 1)));
+    }
+    return false;
+}
+export function isPureDataProgram(estree) {
+    const stmt = estree.body[0];
+    if (estree.body.length !== 1 || (stmt === null || stmt === void 0 ? void 0 : stmt.type) !== 'ExpressionStatement')
+        return false;
+    return isPureDataExpression(stmt.expression);
+}
 function isPrimitiveLiteralExpression(node) {
     if (node.type === 'Literal')
         return true;
@@ -230,9 +300,7 @@ function isSafeJsxAttributeValue(value) {
         return true;
     if (node.type !== 'JSXExpressionContainer')
         return false;
-    if (typeof node.expression !== 'object' || node.expression == null)
-        return false;
-    return isPrimitiveLiteralExpression(node.expression);
+    return isPureDataExpression(node.expression);
 }
 const DANGEROUS_ELEMENT_NAMES = new Set(['script', 'style', 'iframe', 'meta']);
 function isSafeJsxElementName(name) {
@@ -246,6 +314,9 @@ function isSafeJsxElementName(name) {
         return false;
     return !DANGEROUS_ELEMENT_NAMES.has(elementName.toLowerCase());
 }
+export function isUnsafeDataAttributeName(name) {
+    return name === 'dangerouslySetInnerHTML' || /^on[A-Z]/.test(name);
+}
 function isEventHandlerAttribute(attributeNode) {
     const name = attributeNode.name;
     if (typeof name !== 'object' || name == null)
@@ -253,7 +324,7 @@ function isEventHandlerAttribute(attributeNode) {
     const nameNode = name;
     if (typeof nameNode.name !== 'string')
         return false;
-    return /^on[A-Z]/.test(nameNode.name);
+    return isUnsafeDataAttributeName(nameNode.name);
 }
 function isSafeStaticJsxNode(node) {
     if (node.type === 'JSXText')
@@ -463,14 +534,6 @@ function buildStubEsmNode(names) {
         },
     };
 }
-function isArrayOfStringLiterals(estree) {
-    const stmt = estree.body[0];
-    if (estree.body.length !== 1 || (stmt === null || stmt === void 0 ? void 0 : stmt.type) !== 'ExpressionStatement')
-        return false;
-    if (stmt.expression.type !== 'ArrayExpression')
-        return false;
-    return stmt.expression.elements.every((el) => (el === null || el === void 0 ? void 0 : el.type) === 'Literal' && typeof el.value === 'string');
-}
 export function remarkMdxRemoveJs() {
     return (tree) => {
         remove(tree, ['mdxTextExpression', 'mdxFlowExpression']);
@@ -505,7 +568,9 @@ export function remarkMdxRemoveJs() {
                             stubbedNamesMap.set(ident, { name: ident, isFunction: false });
                         return attr;
                     }
-                    if (((_b = attr.value.data) === null || _b === void 0 ? void 0 : _b.estree) && isArrayOfStringLiterals(attr.value.data.estree))
+                    if (!isUnsafeDataAttributeName(attr.name) &&
+                        ((_b = attr.value.data) === null || _b === void 0 ? void 0 : _b.estree) &&
+                        isPureDataProgram(attr.value.data.estree))
                         return attr;
                     if (isSafeStaticJsx((_c = attr.value.data) === null || _c === void 0 ? void 0 : _c.estree))
                         return attr;

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 {};