nuxt-ai-ready 2.5.3 → 3.0.1

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

@@ -1,725 +0,0 @@
-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 };