@mintlify/common 1.0.1114 → 1.0.1115

package/dist/mdx/plugins/rehype/rehypeDynamicTailwindCss.js

@@ -1,22 +1,21 @@
 import { walk } from 'estree-walker';
 import { visit } from 'unist-util-visit';
+import { segment } from './segment.js';
 export const MINTLIFY_TAILWIND_PREFIX = 'mint-';
 export const rehypeDynamicTailwindCss = (tailwindSelectors) => (tree) => {
+    const normalizedTailwindSelectors = tailwindSelectors === null || tailwindSelectors === void 0 ? void 0 : tailwindSelectors.map(normalizeSelector);
     visit(tree, (node) => {
         if ((node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') &&
             node.name &&
             typeof node.name === 'string' &&
-            // check for valid html tags
-            (/^[a-z]/.test(node.name) || node.name === 'Heading') &&
-            !node.name.includes('.') &&
             node.attributes.length > 0) {
             const className = node.attributes.find((attr) => attr.type === 'mdxJsxAttribute' && attr.name === 'className');
             if (className && typeof className.value === 'string') {
-                className.value = transformClassNames(className.value, tailwindSelectors);
+                className.value = transformClassNames(className.value, normalizedTailwindSelectors);
             }
         }
         if (node.type === 'mdxjsEsm' && node.data && node.data.estree) {
-            transformMdxJsEsmNode(node.data.estree, tailwindSelectors);
+            transformMdxJsEsmNode(node.data.estree, normalizedTailwindSelectors);
         }
     });
 };
@@ -93,31 +92,31 @@ const transformExpressionClassNames = (expr, tailwindSelectors) => {
 const transformClassNames = (value, tailwindSelectors) => {
     if (!tailwindSelectors || !tailwindSelectors.length)
         return value;
-    return value
-        .split(/\s+/)
-        .map((className) => {
-        if (!className)
-            return '';
-        if (className.startsWith('[') || className.startsWith(MINTLIFY_TAILWIND_PREFIX)) {
-            return className;
-        }
-        const parts = className.split(':');
-        let baseClass = parts.pop();
-        const hasImportantModifier = baseClass.startsWith('!');
-        if (hasImportantModifier) {
-            baseClass = baseClass.slice(1);
-        }
-        const variants = parts;
-        if (tailwindSelectors.some((selector) => {
-            // remove the leading dot and any escaping backslashes from the selector
-            // for example, .bg-orange-400\\/50 -> bg-orange-400/50
-            const normalizedSelector = selector.replace(/^\.|\\+/g, '');
-            return normalizedSelector.includes(baseClass);
-        })) {
-            const transformedClass = `${hasImportantModifier ? '!' : ''}${MINTLIFY_TAILWIND_PREFIX}${baseClass}`;
-            return [...variants, transformedClass].join(':');
-        }
-        return className;
-    })
+    return splitClassNames(value)
+        .map((className) => transformClassName(className, tailwindSelectors))
         .join(' ');
 };
+const transformClassName = (className, tailwindSelectors) => {
+    const classSegments = splitClassSegments(className);
+    const baseClassSegment = classSegments[classSegments.length - 1];
+    if (!baseClassSegment)
+        return className;
+    const hasImportantModifier = baseClassSegment.startsWith('!');
+    const baseClass = hasImportantModifier ? baseClassSegment.slice(1) : baseClassSegment;
+    if (!baseClass || baseClass.startsWith(MINTLIFY_TAILWIND_PREFIX)) {
+        return className;
+    }
+    if (!isTailwindClass(className, tailwindSelectors)) {
+        return className;
+    }
+    classSegments[classSegments.length - 1] =
+        `${hasImportantModifier ? '!' : ''}${MINTLIFY_TAILWIND_PREFIX}${baseClass}`;
+    return classSegments.join(':');
+};
+const isTailwindClass = (className, tailwindSelectors) => {
+    const normalizedClassName = normalizeSelector(className);
+    return tailwindSelectors.some((selector) => selector.includes(`.${normalizedClassName}`));
+};
+const splitClassNames = (value) => value.split(/\s+/).filter(Boolean);
+const splitClassSegments = (value) => segment(value, ':').filter(Boolean);
+const normalizeSelector = (selector) => selector.replace(/\\+/g, '');

package/dist/mdx/plugins/rehype/segment.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This splits a string on a top-level character.
+ *
+ * Regex doesn't support recursion (at least not the JS-flavored version),
+ * so we have to use a tiny state machine to keep track of paren placement.
+ *
+ * Expected behavior using commas:
+ * var(--a, 0 0 1px rgb(0, 0, 0)), 0 0 1px rgb(0, 0, 0)
+ *        ┬              ┬  ┬    ┬
+ *        x              x  x    ╰──────── Split because top-level
+ *        ╰──────────────┴──┴───────────── Ignored b/c inside >= 1 levels of parens
+ */
+export declare function segment(input: string, separator: string): string[];

package/dist/mdx/plugins/rehype/segment.js

@@ -0,0 +1,94 @@
+// Vendored from Tailwind CSS v4 (MIT), unchanged apart from formatting:
+// https://github.com/tailwindlabs/tailwindcss/blob/main/packages/tailwindcss/src/utils/segment.ts
+const BACKSLASH = 0x5c;
+const OPEN_CURLY = 0x7b;
+const CLOSE_CURLY = 0x7d;
+const OPEN_PAREN = 0x28;
+const CLOSE_PAREN = 0x29;
+const OPEN_BRACKET = 0x5b;
+const CLOSE_BRACKET = 0x5d;
+const DOUBLE_QUOTE = 0x22;
+const SINGLE_QUOTE = 0x27;
+// This is a shared buffer that is used to keep track of the current nesting level
+// of parens, brackets, and braces. It is used to determine if a character is at
+// the top-level of a string. This is a performance optimization to avoid memory
+// allocations on every call to `segment`.
+const closingBracketStack = new Uint8Array(256);
+/**
+ * This splits a string on a top-level character.
+ *
+ * Regex doesn't support recursion (at least not the JS-flavored version),
+ * so we have to use a tiny state machine to keep track of paren placement.
+ *
+ * Expected behavior using commas:
+ * var(--a, 0 0 1px rgb(0, 0, 0)), 0 0 1px rgb(0, 0, 0)
+ *        ┬              ┬  ┬    ┬
+ *        x              x  x    ╰──────── Split because top-level
+ *        ╰──────────────┴──┴───────────── Ignored b/c inside >= 1 levels of parens
+ */
+export function segment(input, separator) {
+    // SAFETY: We can use an index into a shared buffer because this function is
+    // synchronous, non-recursive, and runs in a single-threaded environment.
+    let stackPos = 0;
+    const parts = [];
+    let lastPos = 0;
+    const len = input.length;
+    const separatorCode = separator.charCodeAt(0);
+    for (let idx = 0; idx < len; idx++) {
+        const char = input.charCodeAt(idx);
+        if (stackPos === 0 && char === separatorCode) {
+            parts.push(input.slice(lastPos, idx));
+            lastPos = idx + 1;
+            continue;
+        }
+        switch (char) {
+            case BACKSLASH:
+                // The next character is escaped, so we skip it.
+                idx += 1;
+                break;
+            // Strings should be handled as-is until the end of the string. No need to
+            // worry about balancing parens, brackets, or curlies inside a string.
+            case SINGLE_QUOTE:
+            case DOUBLE_QUOTE:
+                // Ensure we don't go out of bounds.
+                while (++idx < len) {
+                    const nextChar = input.charCodeAt(idx);
+                    // The next character is escaped, so we skip it.
+                    if (nextChar === BACKSLASH) {
+                        idx += 1;
+                        continue;
+                    }
+                    if (nextChar === char) {
+                        break;
+                    }
+                }
+                break;
+            case OPEN_PAREN:
+                closingBracketStack[stackPos] = CLOSE_PAREN;
+                stackPos++;
+                break;
+            case OPEN_BRACKET:
+                closingBracketStack[stackPos] = CLOSE_BRACKET;
+                stackPos++;
+                break;
+            case OPEN_CURLY:
+                closingBracketStack[stackPos] = CLOSE_CURLY;
+                stackPos++;
+                break;
+            case CLOSE_BRACKET:
+            case CLOSE_CURLY:
+            case CLOSE_PAREN:
+                if (stackPos > 0 && char === closingBracketStack[stackPos - 1]) {
+                    // SAFETY: The buffer does not need to be mutated because the stack is
+                    // only ever read from or written to its current position. Its current
+                    // position is only ever incremented after writing to it. Meaning that
+                    // the buffer can be dirty for the next use and still be correct since
+                    // reading/writing always starts at position `0`.
+                    stackPos--;
+                }
+                break;
+        }
+    }
+    parts.push(input.slice(lastPos));
+    return parts;
+}