nuxt-ai-ready 2.4.1 → 2.5.1

package/node_modules/@mdream/js/dist/_chunks/plugins.mjs

@@ -0,0 +1,725 @@
+import { TagIdMap } from "./const.mjs";
+function createPlugin(plugin) {
+	return plugin;
+}
+function createTagSelector(tagName) {
+	return {
+		matches: (element) => element.name === tagName,
+		toString: () => tagName
+	};
+}
+function createIdSelector(selector) {
+	const id = selector.slice(1);
+	return {
+		matches: (element) => element.attributes?.id === id,
+		toString: () => `#${id}`
+	};
+}
+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}`
+	};
+}
+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
+	};
+}
+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}]`;
+		}
+	};
+}
+function createCompoundSelector(selectors) {
+	return {
+		matches: (element) => selectors.every((selector) => selector.matches(element)),
+		toString: () => selectors.map((s) => s.toString()).join("")
+	};
+}
+function createSelectorList(selectors) {
+	return {
+		matches(element) {
+			for (let i = 0; i < selectors.length; i++) if (selectors[i].matches(element)) return true;
+			return false;
+		},
+		toString: () => selectors.map((s) => s.toString()).join(", ")
+	};
+}
+function parseCompoundSelector(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);
+}
+function parseSelector(selector) {
+	selector = selector.trim();
+	if (!selector) throw new Error("Empty selector");
+	const selectors = [];
+	let start = 0;
+	let inAttribute = false;
+	let quote = 0;
+	let escaped = false;
+	for (let i = 0; i < selector.length; i++) {
+		const char = selector.charCodeAt(i);
+		if (quote) {
+			if (escaped) escaped = false;
+			else if (char === 92) escaped = true;
+			else if (char === quote) quote = 0;
+			continue;
+		}
+		if (inAttribute) {
+			if (char === 34 || char === 39) quote = char;
+			else if (char === 93) inAttribute = false;
+			continue;
+		}
+		if (char === 91) inAttribute = true;
+		else if (char === 44) {
+			const part = selector.slice(start, i).trim();
+			if (!part) return createTagSelector(selector);
+			selectors.push(parseCompoundSelector(part));
+			start = i + 1;
+		}
+	}
+	if (!selectors.length) return parseCompoundSelector(selector);
+	const last = selector.slice(start).trim();
+	if (!last) return createTagSelector(selector);
+	selectors.push(parseCompoundSelector(last));
+	return createSelectorList(selectors);
+}
+function extractionPlugin(selectors) {
+	const matcherCallbacks = Object.entries(selectors).map(([selector, callback]) => ({
+		matcher: parseSelector(selector),
+		callback
+	}));
+	const trackedElements = /* @__PURE__ */ new Map();
+	return createPlugin({
+		onNodeEnter(element) {
+			let callbacks;
+			for (let i = 0; i < matcherCallbacks.length; i++) {
+				const { matcher, callback } = matcherCallbacks[i];
+				if (matcher.matches(element)) {
+					callbacks ||= [];
+					callbacks.push(callback);
+				}
+			}
+			if (callbacks) trackedElements.set(element, {
+				textContent: "",
+				callbacks
+			});
+		},
+		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) {
+				for (let i = 0; i < tracked.callbacks.length; i++) {
+					const extractedElement = {
+						...element,
+						attributes: { ...element.attributes },
+						textContent: tracked.textContent.trim()
+					};
+					tracked.callbacks[i](extractedElement, state);
+				}
+				trackedElements.delete(element);
+			}
+		}
+	});
+}
+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) {
+			let selectors;
+			for (let i = 0; i < matchers.length; i++) {
+				const m = matchers[i];
+				if (m.matcher.matches(element)) {
+					selectors ||= [];
+					selectors.push(m.selector);
+				}
+			}
+			if (selectors) trackedElements.set(element, {
+				textContent: "",
+				selectors
+			});
+		},
+		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) {
+				for (let i = 0; i < tracked.selectors.length; i++) {
+					const extracted = {
+						selector: tracked.selectors[i],
+						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
+	};
+}
+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);
+}
+function isHidden(element) {
+	const style = element.attributes?.style;
+	if (style && (style.includes("display:none") || style.includes("display: none") || style.includes("visibility:hidden") || style.includes("visibility: hidden") || style.includes("position:absolute") || style.includes("position: absolute") || style.includes("position:fixed") || style.includes("position: fixed"))) return true;
+	const hidden = element.attributes?.hidden;
+	return hidden !== void 0 && hidden.toLowerCase() !== "until-found";
+}
+function filterPlugin(options = {}) {
+	const includeSelectors = options.include?.map((selector) => compileSelector(selector)) || [];
+	const excludeSelectors = options.exclude?.map((selector) => compileSelector(selector)) || [];
+	const processChildren = options.processChildren !== false;
+	const skippedSubtrees = /* @__PURE__ */ new WeakSet();
+	const skippedByInclude = /* @__PURE__ */ new WeakSet();
+	function excludesSubtree(element) {
+		if (skippedSubtrees.has(element)) return true;
+		if ((element.parent ? skippedSubtrees.has(element.parent) : false) || isHidden(element) || excludeSelectors.some((selector) => selector.matches(element))) {
+			skippedSubtrees.add(element);
+			return true;
+		}
+		return false;
+	}
+	return createPlugin({
+		excludesOverflowSubtree: excludesSubtree,
+		beforeNodeProcess(event) {
+			const { node } = event;
+			if (node.type === 2) {
+				const textNode = node;
+				const parent = textNode.parent;
+				if (parent && skippedSubtrees.has(parent)) return { skip: true };
+				if (parent && skippedByInclude.has(parent)) textNode.excludedFromMarkdown = true;
+				return;
+			}
+			if (node.type !== 1) return;
+			const element = node;
+			if (excludesSubtree(element)) return { skip: true };
+			if (includeSelectors.length) {
+				let currentElement = element;
+				while (currentElement) {
+					if (includeSelectors.some((selector) => selector.matches(currentElement))) return;
+					if (!processChildren) break;
+					currentElement = currentElement.parent;
+				}
+				skippedByInclude.add(element);
+				return { skip: true };
+			}
+		}
+	});
+}
+const BACKSLASH_RE = /\\/g;
+const DOUBLE_QUOTE_RE = /"/g;
+const ESCAPED_DOUBLE_QUOTE_RE = /\\"/g;
+function frontmatterPlugin(options = {}) {
+	const additionalFields = options.additionalFields || {};
+	const metaFields = /* @__PURE__ */ 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.excludedFromMarkdown) return;
+			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.excludedFromMarkdown) return void 0;
+			if (node.type === 1 && node.tagId === 1) {
+				inHead = false;
+				if (state.options?.format === "text") return void 0;
+				if (Object.keys(frontmatter).length > 0) {
+					const frontmatterContent = generateFrontmatter();
+					if (frontmatterContent) {
+						state.buffer.push(frontmatterContent);
+						state.lastContentCache = frontmatterContent;
+					}
+				}
+			}
+		},
+		processTextNode(node) {
+			if (node.parent?.excludedFromMarkdown) return;
+			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;
+	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`;
+	}
+}
+function isolateMainPlugin() {
+	let mainElement = null;
+	let firstHeaderElement = null;
+	let afterFooter = false;
+	const headerTagIds = /* @__PURE__ */ new Set([
+		7,
+		8,
+		9,
+		10,
+		11,
+		12
+	]);
+	return createPlugin({ beforeNodeProcess(event) {
+		const { node } = event;
+		if (node.excludedFromMarkdown || node.parent?.excludedFromMarkdown) return;
+		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 };
+			}
+		}
+	} });
+}
+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 }
+};
+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: ""
+	};
+}
+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);
+	});
+}
+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;
+}
+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;
+}
+function hasBreakpoint(className) {
+	const { breakpoint } = extractBaseClass(className);
+	return breakpoint !== "";
+}
+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
+	};
+}
+function tailwindPlugin() {
+	return createPlugin({
+		excludesOverflowSubtree(node) {
+			if (node.parent?.context?.tailwind?.hidden) return true;
+			const classes = node.attributes?.class?.trim().split(" ").filter(Boolean);
+			return classes ? processTailwindClasses(classes).hidden : false;
+		},
+		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, state) {
+			const parentNode = node.parent;
+			if (!parentNode || parentNode.type !== 1) return;
+			const tailwindData = parentNode.context?.tailwind;
+			if (tailwindData?.hidden) return {
+				content: "",
+				skip: true
+			};
+			const prefix = state.options?.format === "text" ? "" : tailwindData?.prefix || "";
+			const suffix = state.options?.format === "text" ? "" : tailwindData?.suffix || "";
+			if (prefix || suffix) node.generatedMarkdown = {
+				prefix,
+				suffix
+			};
+		},
+		beforeNodeProcess({ node }) {
+			if (node.type === 1) {
+				if (node.context?.tailwind?.hidden) return { skip: true };
+			}
+		}
+	});
+}
+export { createPlugin, extractionCollectorPlugin, extractionPlugin, filterPlugin, frontmatterPlugin, isolateMainPlugin, tailwindPlugin };