@mdream/js 0.17.0

package/dist/_chunks/plugins.mjs

@@ -0,0 +1,791 @@
+import { _ as TagIdMap } from "./const.mjs";
+//#region src/pluggable/plugin.ts
+/**
+* Create a plugin with type-safe hook definitions.
+* All TransformPlugin fields are optional, so this is a typed identity function.
+*/
+function createPlugin(plugin) {
+	return plugin;
+}
+//#endregion
+//#region src/libs/query-selector.ts
+/**
+* Creates a tag selector matcher (e.g., 'div', 'p', 'h1')
+*/
+function createTagSelector(tagName) {
+	return {
+		matches: (element) => element.name === tagName,
+		toString: () => tagName
+	};
+}
+/**
+* Creates an ID selector matcher (e.g., '#main', '#content')
+*/
+function createIdSelector(selector) {
+	const id = selector.slice(1);
+	return {
+		matches: (element) => element.attributes?.id === id,
+		toString: () => `#${id}`
+	};
+}
+/**
+* Creates a class selector matcher (e.g., '.container', '.header')
+*/
+function createClassSelector(selector) {
+	const className = selector.slice(1);
+	return {
+		matches: (element) => {
+			if (!element.attributes?.class) return false;
+			return element.attributes.class.trim().split(" ").filter(Boolean).includes(className);
+		},
+		toString: () => `.${className}`
+	};
+}
+/**
+* Parses attribute selectors like [attr], [attr=value], [attr^="value"]
+* Uses a manual parser to avoid polynomial regex backtracking (CodeQL ReDoS).
+*/
+function parseAttributeSelector(selector) {
+	if (selector.charCodeAt(0) !== 91) return null;
+	const end = selector.indexOf("]", 1);
+	if (end === -1) return null;
+	const inner = selector.slice(1, end);
+	let opIdx = -1;
+	for (let i = 0; i < inner.length; i++) {
+		const c = inner.charCodeAt(i);
+		if (c === 61 || c === 126 || c === 124 || c === 94 || c === 36 || c === 42) {
+			opIdx = i;
+			break;
+		}
+	}
+	if (opIdx === -1) return { attr: inner };
+	const attr = inner.slice(0, opIdx);
+	let opEnd = opIdx + 1;
+	if (opEnd < inner.length && inner.charCodeAt(opEnd) === 61) opEnd++;
+	const op = inner.slice(opIdx, opEnd);
+	let value = inner.slice(opEnd);
+	if ((value.charCodeAt(0) === 34 || value.charCodeAt(0) === 39) && value.charCodeAt(value.length - 1) === value.charCodeAt(0)) value = value.slice(1, -1);
+	return {
+		attr,
+		op,
+		value
+	};
+}
+/**
+* Creates an attribute selector matcher (e.g., '[data-id]', '[href="https://example.com"]')
+*/
+function createAttributeSelector(selector) {
+	const parsed = parseAttributeSelector(selector);
+	const attrName = parsed ? parsed.attr : selector.slice(1, -1);
+	const operator = parsed?.op;
+	const attrValue = parsed?.value;
+	return {
+		matches: (element) => {
+			if (!(attrName in (element.attributes || {}))) return false;
+			if (!operator || !attrValue) return true;
+			const value = element.attributes[attrName];
+			if (value === void 0) return false;
+			switch (operator) {
+				case "=": return value === attrValue;
+				case "^=": return value.startsWith(attrValue);
+				case "$=": return value.endsWith(attrValue);
+				case "*=": return value.includes(attrValue);
+				case "~=": return value.trim().split(" ").filter(Boolean).includes(attrValue);
+				case "|=": return value === attrValue || value.startsWith(`${attrValue}-`);
+				default: return false;
+			}
+		},
+		toString: () => {
+			if (!operator || !attrValue) return `[${attrName}]`;
+			return `[${attrName}${operator}${attrValue}]`;
+		}
+	};
+}
+/**
+* Creates a compound selector that combines multiple selectors (e.g., 'div.container', 'h1#title')
+*/
+function createCompoundSelector(selectors) {
+	return {
+		matches: (element) => selectors.every((selector) => selector.matches(element)),
+		toString: () => selectors.map((s) => s.toString()).join("")
+	};
+}
+/**
+* Parses a CSS selector into a matcher
+*/
+function parseSelector(selector) {
+	selector = selector.trim();
+	if (!selector) throw new Error("Empty selector");
+	const selectorParts = [];
+	let current = "";
+	let inAttribute = false;
+	for (let i = 0; i < selector.length; i++) {
+		const char = selector[i];
+		if ((char === "." || char === "#" || char === "[") && current) {
+			if (current[0] === ".") selectorParts.push(createClassSelector(current));
+			else if (current[0] === "#") selectorParts.push(createIdSelector(current));
+			else if (current[0] === "[") selectorParts.push(createAttributeSelector(current));
+			else if (current) selectorParts.push(createTagSelector(current));
+			current = char;
+		} else current += char;
+		if (char === "[") inAttribute = true;
+		if (char === "]") inAttribute = false;
+		if (inAttribute && char !== "[") {}
+	}
+	if (current) {
+		if (current[0] === ".") selectorParts.push(createClassSelector(current));
+		else if (current[0] === "#") selectorParts.push(createIdSelector(current));
+		else if (current[0] === "[") selectorParts.push(createAttributeSelector(current));
+		else if (current) selectorParts.push(createTagSelector(current));
+	}
+	if (selectorParts.length === 1) return selectorParts[0];
+	return createCompoundSelector(selectorParts);
+}
+//#endregion
+//#region src/plugins/extraction.ts
+/**
+* @deprecated Use `plugins.extraction` config for declarative extraction that works with both JS and Rust engines.
+*/
+function extractionPlugin(selectors) {
+	const matcherCallbacks = Object.entries(selectors).map(([selector, callback]) => ({
+		matcher: parseSelector(selector),
+		callback
+	}));
+	const trackedElements = /* @__PURE__ */ new Map();
+	return createPlugin({
+		onNodeEnter(element) {
+			matcherCallbacks.forEach(({ matcher, callback }) => {
+				if (matcher.matches(element)) trackedElements.set(element, {
+					textContent: "",
+					callback
+				});
+			});
+		},
+		processTextNode(textNode) {
+			let currentParent = textNode.parent;
+			while (currentParent) {
+				const tracked = trackedElements.get(currentParent);
+				if (tracked) tracked.textContent += textNode.value;
+				currentParent = currentParent.parent;
+			}
+		},
+		onNodeExit(element, state) {
+			const tracked = trackedElements.get(element);
+			if (tracked) {
+				const extractedElement = {
+					...element,
+					textContent: tracked.textContent.trim()
+				};
+				tracked.callback(extractedElement, state);
+				trackedElements.delete(element);
+			}
+		}
+	});
+}
+/**
+* Extraction collector for `plugins.extraction` config.
+* Collects results during processing; callbacks are called post-conversion
+* to match Rust engine behavior.
+*/
+function extractionCollectorPlugin(config) {
+	const matchers = Object.entries(config).map(([selector, callback]) => ({
+		selector,
+		matcher: parseSelector(selector),
+		callback
+	}));
+	const results = [];
+	const trackedElements = /* @__PURE__ */ new Map();
+	const plugin = createPlugin({
+		onNodeEnter(element) {
+			for (let i = 0; i < matchers.length; i++) {
+				const m = matchers[i];
+				if (m.matcher.matches(element)) trackedElements.set(element, {
+					textContent: "",
+					selector: m.selector,
+					callback: m.callback
+				});
+			}
+		},
+		processTextNode(textNode) {
+			let currentParent = textNode.parent;
+			while (currentParent) {
+				const tracked = trackedElements.get(currentParent);
+				if (tracked) tracked.textContent += textNode.value;
+				currentParent = currentParent.parent;
+			}
+		},
+		onNodeExit(element) {
+			const tracked = trackedElements.get(element);
+			if (tracked) {
+				const extracted = {
+					selector: tracked.selector,
+					tagName: element.name,
+					textContent: tracked.textContent.trim(),
+					attributes: { ...element.attributes }
+				};
+				results.push(extracted);
+				trackedElements.delete(element);
+			}
+		}
+	});
+	function callHandlers() {
+		for (let i = 0; i < results.length; i++) {
+			const el = results[i];
+			for (let j = 0; j < matchers.length; j++) if (matchers[j].selector === el.selector) {
+				matchers[j].callback(el);
+				break;
+			}
+		}
+	}
+	return {
+		plugin,
+		getResults: () => results,
+		callHandlers
+	};
+}
+//#endregion
+//#region src/plugins/filter.ts
+/**
+* Compiles a selector (string or TAG_* number) into a fast matcher.
+* String tag names (e.g. 'form') are compiled to TAG_* ID comparisons at creation time,
+* avoiding per-element string comparison. CSS selectors (e.g. '.class', '#id') use parseSelector.
+*/
+function compileSelector(selector) {
+	if (typeof selector === "number") return {
+		matches: (element) => element.tagId === selector,
+		toString: () => String(selector)
+	};
+	const tagId = TagIdMap[selector];
+	if (tagId !== void 0) return {
+		matches: (element) => element.tagId === tagId,
+		toString: () => selector
+	};
+	return parseSelector(selector);
+}
+/**
+* Plugin that filters nodes based on CSS selectors.
+* Allows including or excluding nodes based on selectors.
+*
+* @example
+* // Include only heading elements and their children
+* withQuerySelectorPlugin({ include: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] })
+*
+* @example
+* // Exclude navigation, sidebar, and footer
+* withQuerySelectorPlugin({ exclude: ['nav', '#sidebar', '.footer'] })
+*/
+function filterPlugin(options = {}) {
+	const includeSelectors = options.include?.map((selector) => compileSelector(selector)) || [];
+	const excludeSelectors = options.exclude?.map((selector) => compileSelector(selector)) || [];
+	const processChildren = options.processChildren !== false;
+	return createPlugin({ beforeNodeProcess(event) {
+		const { node } = event;
+		if (node.type === 2) {
+			let currentParent = node.parent;
+			while (currentParent && excludeSelectors.length) {
+				if (excludeSelectors.some((selector) => selector.matches(currentParent))) return { skip: true };
+				currentParent = currentParent.parent;
+			}
+			return;
+		}
+		if (node.type !== 1) return;
+		const element = node;
+		if (excludeSelectors.length) {
+			if (element.attributes.style?.includes("absolute") || element.attributes.style?.includes("fixed")) return { skip: true };
+			if (excludeSelectors.some((selector) => selector.matches(element))) return { skip: true };
+		}
+		let currentParent = element.parent;
+		while (currentParent) {
+			if (excludeSelectors.length) {
+				if (excludeSelectors.some((selector) => selector.matches(currentParent))) return { skip: true };
+			}
+			currentParent = currentParent.parent;
+		}
+		if (includeSelectors.length) {
+			let currentElement = element;
+			while (currentElement) {
+				if (includeSelectors.some((selector) => selector.matches(currentElement))) return;
+				if (!processChildren) break;
+				currentElement = currentElement.parent;
+			}
+			return { skip: true };
+		}
+	} });
+}
+//#endregion
+//#region src/plugins/frontmatter.ts
+const BACKSLASH_RE = /\\/g;
+const DOUBLE_QUOTE_RE = /"/g;
+const ESCAPED_DOUBLE_QUOTE_RE = /\\"/g;
+/**
+* A plugin that manages frontmatter generation from HTML head elements
+* Extracts metadata from meta tags and title and generates YAML frontmatter
+*/
+function frontmatterPlugin(options = {}) {
+	const additionalFields = options.additionalFields || {};
+	const metaFields = new Set([
+		"description",
+		"keywords",
+		"author",
+		"date",
+		"og:title",
+		"og:description",
+		"twitter:title",
+		"twitter:description",
+		...options.metaFields || []
+	]);
+	const frontmatter = {
+		...additionalFields,
+		meta: {}
+	};
+	let inHead = false;
+	function formatValue(_name, value) {
+		value = value.replace(BACKSLASH_RE, "\\\\").replace(DOUBLE_QUOTE_RE, "\\\"");
+		if (value.includes("\n") || value.includes(":") || value.includes("#") || value.includes(" ")) return `"${value}"`;
+		return value;
+	}
+	function getStructuredData() {
+		const result = {};
+		if (frontmatter.title) {
+			const raw = frontmatter.title;
+			result.title = raw.startsWith("\"") && raw.endsWith("\"") ? raw.slice(1, -1).replace(ESCAPED_DOUBLE_QUOTE_RE, "\"") : raw;
+		}
+		for (const [k, v] of Object.entries(frontmatter.meta)) {
+			const cleanKey = k.startsWith("\"") && k.endsWith("\"") ? k.slice(1, -1) : k;
+			result[cleanKey] = typeof v === "string" && v.startsWith("\"") && v.endsWith("\"") ? v.slice(1, -1).replace(ESCAPED_DOUBLE_QUOTE_RE, "\"") : String(v);
+		}
+		if (additionalFields) {
+			for (const [k, v] of Object.entries(additionalFields)) if (typeof v === "string") result[k] = v;
+		}
+		return Object.keys(result).length > 0 ? result : void 0;
+	}
+	const plugin = createPlugin({
+		onNodeEnter(node) {
+			if (node.tagId === 1) {
+				inHead = true;
+				return;
+			}
+			if (inHead && node.type === 1 && node.tagId === 4) return;
+			if (inHead && node.type === 1 && node.tagId === 5) {
+				const { name, property, content } = node.attributes || {};
+				const metaName = property || name;
+				if (metaName && content && metaFields.has(metaName)) frontmatter.meta[metaName.includes(":") ? `"${metaName}"` : metaName] = formatValue(metaName, content);
+				return;
+			}
+		},
+		onNodeExit(node, state) {
+			if (node.type === 1 && node.tagId === 1) {
+				inHead = false;
+				if (Object.keys(frontmatter).length > 0) {
+					const frontmatterContent = generateFrontmatter();
+					if (frontmatterContent) {
+						state.buffer.push(frontmatterContent);
+						state.lastContentCache = frontmatterContent;
+					}
+				}
+			}
+		},
+		processTextNode(node) {
+			if (!inHead) return;
+			const parent = node.parent;
+			if (parent && parent.tagId === 4 && node.value) {
+				frontmatter.title = formatValue("title", node.value.trim());
+				return {
+					content: "",
+					skip: true
+				};
+			}
+		}
+	});
+	plugin.getFrontmatter = getStructuredData;
+	return plugin;
+	/**
+	* Generate YAML frontmatter string from collected metadata
+	*/
+	function generateFrontmatter() {
+		if (Object.keys(frontmatter).length === 0) return "";
+		let yamlLines = [];
+		const entries = Object.entries(frontmatter).sort(([a], [b]) => {
+			if (a === "title") return -1;
+			if (b === "title") return 1;
+			if (a === "description") return -1;
+			if (b === "description") return 1;
+			return a.localeCompare(b);
+		});
+		for (const [key, value] of entries) if (key === "meta" && typeof value === "object" && value && Object.keys(value).length > 0) {
+			yamlLines.push("meta:");
+			const metaEntries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([metaKey, metaValue]) => `  ${metaKey}: ${metaValue}`);
+			yamlLines.push(...metaEntries);
+		} else if (key !== "meta" && typeof value === "string") yamlLines.push(`${key}: ${value}`);
+		if (Object.keys(frontmatter.meta).length === 0) yamlLines = yamlLines.filter((line) => !line.startsWith("meta:"));
+		return `---\n${yamlLines.join("\n")}\n---\n\n`;
+	}
+}
+//#endregion
+//#region src/plugins/isolate-main.ts
+/**
+* Plugin that isolates main content using the following priority order:
+* 1. If an explicit <main> element exists (within 5 depth levels), use its content exclusively
+* 2. Otherwise, find content between the first header tag (h1-h6) and first footer
+* 3. If footer is within 5 levels of nesting from the header, use it as the end boundary
+* 4. Exclude all content before the start marker and after the end marker
+*
+* @example
+* ```html
+* <body>
+*   <nav>Navigation (excluded)</nav>
+*   <main>
+*     <h1>Main Title (included)</h1>
+*     <p>Main content (included)</p>
+*   </main>
+*   <footer>Footer (excluded)</footer>
+* </body>
+* ```
+*
+* @example
+* ```html
+* <body>
+*   <nav>Navigation (excluded)</nav>
+*   <h1>Main Title (included)</h1>
+*   <p>Main content (included)</p>
+*   <footer>Footer (excluded)</footer>
+* </body>
+* ```
+*/
+function isolateMainPlugin() {
+	let mainElement = null;
+	let firstHeaderElement = null;
+	let afterFooter = false;
+	const headerTagIds = new Set([
+		7,
+		8,
+		9,
+		10,
+		11,
+		12
+	]);
+	return createPlugin({ beforeNodeProcess(event) {
+		const { node } = event;
+		if (node.type === 1) {
+			const element = node;
+			if (!mainElement && element.tagId === 104 && element.depth <= 5) {
+				mainElement = element;
+				return;
+			}
+			if (mainElement) {
+				let current = element.parent;
+				let isInsideMain = element === mainElement;
+				while (current && !isInsideMain) {
+					if (current === mainElement) {
+						isInsideMain = true;
+						break;
+					}
+					current = current.parent;
+				}
+				if (!isInsideMain) return { skip: true };
+				return;
+			}
+			if (!firstHeaderElement && element.tagId !== void 0 && headerTagIds.has(element.tagId)) {
+				let current = element.parent;
+				let isInHeaderTag = false;
+				while (current) {
+					if (current.tagId === 105) {
+						isInHeaderTag = true;
+						break;
+					}
+					current = current.parent;
+				}
+				if (!isInHeaderTag) {
+					firstHeaderElement = element;
+					return;
+				}
+			}
+			if (firstHeaderElement && !afterFooter && element.tagId === 47) {
+				if (element.depth - firstHeaderElement.depth <= 5) {
+					afterFooter = true;
+					return { skip: true };
+				}
+			}
+			if (!firstHeaderElement) {
+				if (element.tagId === 1) return;
+				let current = element.parent;
+				while (current) {
+					if (current.tagId === 1) return;
+					current = current.parent;
+				}
+				return { skip: true };
+			}
+			if (afterFooter) return { skip: true };
+		}
+		if (node.type === 2) {
+			if (mainElement) {
+				let current = node.parent;
+				let isInsideMain = false;
+				while (current) {
+					if (current === mainElement) {
+						isInsideMain = true;
+						break;
+					}
+					current = current.parent;
+				}
+				if (!isInsideMain) return { skip: true };
+				return;
+			}
+			if (!firstHeaderElement || afterFooter) {
+				let current = node.parent;
+				while (current) {
+					if (current.tagId === 1) return;
+					current = current.parent;
+				}
+				return { skip: true };
+			}
+		}
+	} });
+}
+//#endregion
+//#region src/plugins/tailwind.ts
+/**
+* Mapping of Tailwind classes to Markdown formatting
+*/
+const TAILWIND_TO_MARKDOWN_MAP = {
+	"font-bold": {
+		prefix: "**",
+		suffix: "**"
+	},
+	"font-semibold": {
+		prefix: "**",
+		suffix: "**"
+	},
+	"font-black": {
+		prefix: "**",
+		suffix: "**"
+	},
+	"font-extrabold": {
+		prefix: "**",
+		suffix: "**"
+	},
+	"font-medium": {
+		prefix: "**",
+		suffix: "**"
+	},
+	"font-italic": {
+		prefix: "*",
+		suffix: "*"
+	},
+	"italic": {
+		prefix: "*",
+		suffix: "*"
+	},
+	"line-through": {
+		prefix: "~~",
+		suffix: "~~"
+	},
+	"hidden": { hidden: true },
+	"invisible": { hidden: true },
+	"absolute": { hidden: true },
+	"fixed": { hidden: true },
+	"sticky": { hidden: true }
+};
+/**
+* Extract base class name from a responsive breakpoint variant
+*/
+function extractBaseClass(className) {
+	for (const bp of [
+		"sm:",
+		"md:",
+		"lg:",
+		"xl:",
+		"2xl:"
+	]) if (className.startsWith(bp)) return {
+		baseClass: className.substring(bp.length),
+		breakpoint: bp
+	};
+	return {
+		baseClass: className,
+		breakpoint: ""
+	};
+}
+/**
+* Sort classes by breakpoint for mobile-first processing
+*/
+function sortByBreakpoint(classes) {
+	const breakpointOrder = {
+		"": 0,
+		"sm:": 1,
+		"md:": 2,
+		"lg:": 3,
+		"xl:": 4,
+		"2xl:": 5
+	};
+	return classes.toSorted((a, b) => {
+		const aBreakpoint = extractBaseClass(a).breakpoint;
+		const bBreakpoint = extractBaseClass(b).breakpoint;
+		return (breakpointOrder[aBreakpoint] || 0) - (breakpointOrder[bBreakpoint] || 0);
+	});
+}
+/**
+* Group classes by their formatting type to handle overrides
+*/
+function groupByFormattingType(classes) {
+	const sorted = sortByBreakpoint(classes);
+	const groups = {
+		emphasis: [],
+		weight: [],
+		decoration: [],
+		display: [],
+		position: [],
+		other: []
+	};
+	for (const cls of sorted) {
+		const { baseClass } = extractBaseClass(cls);
+		if (baseClass.includes("italic")) groups.emphasis?.push(cls);
+		else if (baseClass.includes("font-") || baseClass === "bold") groups.weight?.push(cls);
+		else if (baseClass.includes("line-through") || baseClass.includes("underline")) groups.decoration?.push(cls);
+		else if (baseClass === "hidden" || baseClass.includes("invisible")) groups.display?.push(cls);
+		else if ([
+			"absolute",
+			"fixed",
+			"sticky"
+		].includes(baseClass)) groups.position?.push(cls);
+		else groups.other?.push(cls);
+	}
+	return groups;
+}
+/**
+* Fix redundant markdown delimiters without regex
+*/
+function fixRedundantDelimiters(content) {
+	content = content.replaceAll("****", "**");
+	content = content.replaceAll("~~~~", "~~");
+	if (content.includes("***") && content.split("***").length > 3) {
+		const parts = content.split("***");
+		if (parts.length >= 4) content = `${parts[0]}***${parts[1]} ${parts[2]}***${parts.slice(3).join("***")}`;
+	}
+	return content;
+}
+/**
+* Normalizes a list of Tailwind classes by processing breakpoints and resolving conflicts
+*/
+function normalizeClasses(classes) {
+	const result = [];
+	const mobileClasses = classes.filter((cls) => !hasBreakpoint(cls));
+	const breakpointClasses = classes.filter((cls) => hasBreakpoint(cls));
+	result.push(...mobileClasses);
+	result.push(...breakpointClasses);
+	return result;
+}
+/**
+* Check if a class has a breakpoint prefix
+*/
+function hasBreakpoint(className) {
+	const { breakpoint } = extractBaseClass(className);
+	return breakpoint !== "";
+}
+/**
+* Process Tailwind classes for an element with mobile-first approach
+*/
+function processTailwindClasses(classes) {
+	let prefix = "";
+	let suffix = "";
+	let hidden = false;
+	const grouped = groupByFormattingType(normalizeClasses(classes));
+	if (grouped.weight && grouped.weight.length > 0) {
+		const { baseClass } = extractBaseClass(grouped.weight[0]);
+		const mapping = TAILWIND_TO_MARKDOWN_MAP[baseClass];
+		if (mapping) {
+			if (mapping.prefix) prefix += mapping.prefix;
+			if (mapping.suffix) suffix = mapping.suffix + suffix;
+		}
+	}
+	if (grouped.emphasis && grouped.emphasis.length > 0) {
+		const { baseClass } = extractBaseClass(grouped.emphasis[0]);
+		const mapping = TAILWIND_TO_MARKDOWN_MAP[baseClass];
+		if (mapping) {
+			if (mapping.prefix) prefix += mapping.prefix;
+			if (mapping.suffix) suffix = mapping.suffix + suffix;
+		}
+	}
+	if (grouped.decoration && grouped.decoration.length > 0) {
+		const { baseClass } = extractBaseClass(grouped.decoration[0]);
+		const mapping = TAILWIND_TO_MARKDOWN_MAP[baseClass];
+		if (mapping) {
+			if (mapping.prefix) prefix += mapping.prefix;
+			if (mapping.suffix) suffix = mapping.suffix + suffix;
+		}
+	}
+	if (grouped.display) for (const cls of grouped.display) {
+		const { baseClass } = extractBaseClass(cls);
+		const mapping = TAILWIND_TO_MARKDOWN_MAP[baseClass];
+		if (mapping && mapping.hidden) {
+			hidden = true;
+			break;
+		}
+	}
+	if (grouped.position) for (const cls of grouped.position) {
+		const { baseClass } = extractBaseClass(cls);
+		const mapping = TAILWIND_TO_MARKDOWN_MAP[baseClass];
+		if (mapping && mapping.hidden) {
+			hidden = true;
+			break;
+		}
+	}
+	return {
+		prefix,
+		suffix,
+		hidden
+	};
+}
+/**
+* Creates a plugin that adds Tailwind class processing
+*/
+function tailwindPlugin() {
+	return createPlugin({
+		processAttributes(node) {
+			const parentHidden = node.parent?.context?.tailwind?.hidden;
+			const classAttr = node.attributes?.class;
+			if (!classAttr && !parentHidden) return;
+			let prefix = "";
+			let suffix = "";
+			let hidden = false;
+			if (classAttr) {
+				const result = processTailwindClasses(classAttr.trim().split(" ").filter(Boolean));
+				prefix = result.prefix;
+				suffix = result.suffix;
+				hidden = result.hidden;
+			}
+			node.context = node.context || {};
+			node.context.tailwind = {
+				prefix,
+				suffix,
+				hidden: hidden || !!parentHidden
+			};
+		},
+		processTextNode(node) {
+			const parentNode = node.parent;
+			if (!parentNode || parentNode.type !== 1) return;
+			const tailwindData = parentNode.context?.tailwind;
+			if (tailwindData?.hidden) return {
+				content: "",
+				skip: true
+			};
+			let content = node.value;
+			const prefix = tailwindData?.prefix || "";
+			const suffix = tailwindData?.suffix || "";
+			if (prefix || suffix) {
+				content = prefix + content + suffix;
+				content = fixRedundantDelimiters(content);
+			}
+			return {
+				content,
+				skip: false
+			};
+		},
+		beforeNodeProcess({ node }) {
+			if (node.type === 1) {
+				if (node.context?.tailwind?.hidden) return { skip: true };
+			}
+		}
+	});
+}
+//#endregion
+export { extractionCollectorPlugin as a, filterPlugin as i, isolateMainPlugin as n, extractionPlugin as o, frontmatterPlugin as r, createPlugin as s, tailwindPlugin as t };