mdream 0.2.7 → 0.3.0

package/dist/_chunks/plugins-DGakgpSl.mjs

@@ -0,0 +1,582 @@
+import { ELEMENT_NODE, TAG_FOOTER, TAG_H1, TAG_H2, TAG_H3, TAG_H4, TAG_H5, TAG_H6, TAG_HEADER, TAG_MAIN, TEXT_NODE, createPlugin$1 as createPlugin } from "./plugin-DCJFRZej.mjs";
+
+//#region src/libs/query-selector.ts
+/**
+* Matches a simple tag selector (e.g., 'div', 'p', 'h1')
+*/
+var TagSelector = class {
+	constructor(tagName) {
+		this.tagName = tagName;
+	}
+	matches(element) {
+		return element.name === this.tagName;
+	}
+	toString() {
+		return this.tagName;
+	}
+};
+/**
+* Matches an ID selector (e.g., '#main', '#content')
+*/
+var IdSelector = class {
+	id;
+	constructor(selector) {
+		this.id = selector.slice(1);
+	}
+	matches(element) {
+		return element.attributes?.id === this.id;
+	}
+	toString() {
+		return `#${this.id}`;
+	}
+};
+/**
+* Matches a class selector (e.g., '.container', '.header')
+*/
+var ClassSelector = class {
+	className;
+	constructor(selector) {
+		this.className = selector.slice(1);
+	}
+	matches(element) {
+		if (!element.attributes?.class) return false;
+		const classes = element.attributes.class.trim().split(" ").filter(Boolean);
+		return classes.includes(this.className);
+	}
+	toString() {
+		return `.${this.className}`;
+	}
+};
+/**
+* Matches an attribute selector (e.g., '[data-id]', '[href="https://example.com"]')
+*/
+var AttributeSelector = class {
+	attrName;
+	attrValue;
+	operator;
+	constructor(selector) {
+		const match = selector.match(/\[([^\]=~|^$*]+)(?:([=~|^$*]+)["']?([^"'\]]+)["']?)?\]/);
+		if (match) {
+			this.attrName = match[1];
+			this.operator = match[2];
+			this.attrValue = match[3];
+		} else this.attrName = selector.slice(1, -1);
+	}
+	matches(element) {
+		if (!(this.attrName in (element.attributes || {}))) return false;
+		if (!this.operator || !this.attrValue) return true;
+		const value = element.attributes[this.attrName];
+		switch (this.operator) {
+			case "=": return value === this.attrValue;
+			case "^=": return value.startsWith(this.attrValue);
+			case "$=": return value.endsWith(this.attrValue);
+			case "*=": return value.includes(this.attrValue);
+			case "~=": return value.trim().split(" ").filter(Boolean).includes(this.attrValue);
+			case "|=": return value === this.attrValue || value.startsWith(`${this.attrValue}-`);
+			default: return false;
+		}
+	}
+	toString() {
+		if (!this.operator || !this.attrValue) return `[${this.attrName}]`;
+		return `[${this.attrName}${this.operator}${this.attrValue}]`;
+	}
+};
+/**
+* Compound selector that combines multiple selectors (e.g., 'div.container', 'h1#title')
+*/
+var CompoundSelector = class {
+	constructor(selectors) {
+		this.selectors = selectors;
+	}
+	matches(element) {
+		return this.selectors.every((selector) => selector.matches(element));
+	}
+	toString() {
+		return this.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(new ClassSelector(current));
+			else if (current[0] === "#") selectorParts.push(new IdSelector(current));
+			else if (current[0] === "[") selectorParts.push(new AttributeSelector(current));
+			else selectorParts.push(new TagSelector(current));
+			current = char;
+		} else current += char;
+		if (char === "[") inAttribute = true;
+		if (char === "]") inAttribute = false;
+		if (inAttribute && char !== "[") {}
+	}
+	if (current) if (current[0] === ".") selectorParts.push(new ClassSelector(current));
+	else if (current[0] === "#") selectorParts.push(new IdSelector(current));
+	else if (current[0] === "[") selectorParts.push(new AttributeSelector(current));
+	else selectorParts.push(new TagSelector(current));
+	if (selectorParts.length === 1) return selectorParts[0];
+	return new CompoundSelector(selectorParts);
+}
+
+//#endregion
+//#region src/plugins/extraction.ts
+function extractionPlugin(selectors) {
+	const matcherCallbacks = Object.entries(selectors).map(([selector, callback]) => ({
+		matcher: parseSelector(selector),
+		callback
+	}));
+	const trackedElements = 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);
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/plugins/filter.ts
+/**
+* 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) => {
+		if (typeof selector === "string") return parseSelector(selector);
+		return { matches: (element) => element.tagId === selector };
+	}) || [];
+	const excludeSelectors = options.exclude?.map((selector) => {
+		if (typeof selector === "string") return parseSelector(selector);
+		return { matches: (element) => element.tagId === selector };
+	}) || [];
+	const processChildren = options.processChildren !== false;
+	return createPlugin({ beforeNodeProcess(event) {
+		const { node } = event;
+		if (node.type === TEXT_NODE) {
+			const textNode = node;
+			let currentParent$1 = textNode.parent;
+			while (currentParent$1 && excludeSelectors.length) {
+				const parentShouldExclude = excludeSelectors.some((selector) => selector.matches(currentParent$1));
+				if (parentShouldExclude) return { skip: true };
+				currentParent$1 = currentParent$1.parent;
+			}
+			return;
+		}
+		if (node.type !== ELEMENT_NODE) return;
+		const element = node;
+		if (excludeSelectors.length) {
+			if (element.attributes.style?.includes("absolute") || element.attributes.style?.includes("fixed")) return { skip: true };
+			const shouldExclude = excludeSelectors.some((selector) => selector.matches(element));
+			if (shouldExclude) return { skip: true };
+		}
+		let currentParent = element.parent;
+		while (currentParent) {
+			if (excludeSelectors.length) {
+				const parentShouldExclude = excludeSelectors.some((selector) => selector.matches(currentParent));
+				if (parentShouldExclude) return { skip: true };
+			}
+			currentParent = currentParent.parent;
+		}
+		if (includeSelectors.length) {
+			let currentElement = element;
+			while (currentElement) {
+				const shouldInclude = includeSelectors.some((selector) => selector.matches(currentElement));
+				if (shouldInclude) return;
+				if (!processChildren) break;
+				currentElement = currentElement.parent;
+			}
+			return { skip: true };
+		}
+	} });
+}
+
+//#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([
+		TAG_H1,
+		TAG_H2,
+		TAG_H3,
+		TAG_H4,
+		TAG_H5,
+		TAG_H6
+	]);
+	return createPlugin({ beforeNodeProcess(event) {
+		const { node } = event;
+		if (node.type === ELEMENT_NODE) {
+			const element = node;
+			if (!mainElement && element.tagId === TAG_MAIN && 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 && headerTagIds.has(element.tagId)) {
+				let current = element.parent;
+				let isInHeaderTag = false;
+				while (current) {
+					if (current.tagId === TAG_HEADER) {
+						isInHeaderTag = true;
+						break;
+					}
+					current = current.parent;
+				}
+				if (!isInHeaderTag) {
+					firstHeaderElement = element;
+					return;
+				}
+			}
+			if (firstHeaderElement && !afterFooter && element.tagId === TAG_FOOTER) {
+				const depthDifference = element.depth - firstHeaderElement.depth;
+				if (depthDifference <= 5) {
+					afterFooter = true;
+					return { skip: true };
+				}
+			}
+			if (!firstHeaderElement) return { skip: true };
+			if (afterFooter) return { skip: true };
+		}
+		if (node.type === TEXT_NODE) {
+			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) 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) {
+	const breakpoints = [
+		"sm:",
+		"md:",
+		"lg:",
+		"xl:",
+		"2xl:"
+	];
+	for (const bp of breakpoints) 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].sort((a, b) => {
+		const aBreakpoint = extractBaseClass(a).breakpoint;
+		const bBreakpoint = extractBaseClass(b).breakpoint;
+		return breakpointOrder[aBreakpoint] - breakpointOrder[bBreakpoint];
+	});
+}
+/**
+* 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 normalizedClasses = normalizeClasses(classes);
+	const grouped = groupByFormattingType(normalizedClasses);
+	if (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.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.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;
+		}
+	}
+	for (const cls of grouped.display) {
+		const { baseClass } = extractBaseClass(cls);
+		const mapping = TAILWIND_TO_MARKDOWN_MAP[baseClass];
+		if (mapping && mapping.hidden) {
+			hidden = true;
+			break;
+		}
+	}
+	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 classAttr = node.attributes?.class;
+			if (!classAttr) return;
+			const classes = classAttr.trim().split(" ").filter(Boolean);
+			const { prefix, suffix, hidden } = processTailwindClasses(classes);
+			node.context = node.context || {};
+			node.context.tailwind = {
+				prefix,
+				suffix,
+				hidden
+			};
+		},
+		processTextNode(node) {
+			const parentNode = node.parent;
+			if (!parentNode || parentNode.type !== ELEMENT_NODE) return void 0;
+			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 === ELEMENT_NODE) {
+				const elementNode = node;
+				const tailwindData = elementNode.context?.tailwind;
+				if (tailwindData?.hidden) return { skip: true };
+			}
+		}
+	});
+}
+
+//#endregion
+export { extractionPlugin, filterPlugin, isolateMainPlugin, tailwindPlugin };