@solid-email/render 0.1.1 → 0.1.3

package/dist/node/index.cjs

@@ -25,7 +25,8 @@ let solid_js_web_dist_server_js = require("solid-js/web/dist/server.js");
 let prettier_plugins_html = require("prettier/plugins/html");
 prettier_plugins_html = __toESM(prettier_plugins_html, 1);
 let prettier_standalone = require("prettier/standalone");
-let html_to_text = require("html-to-text");
+let _solid_email_html_to_text = require("@solid-email/html-to-text");
+let solid_js_web = require("solid-js/web");
 //#region src/shared/utils/pretty.ts
 function getHtmlNode(path) {
 	const topNode = path.node;
@@ -106,12 +107,74 @@ const plainTextSelectors = [
 		}
 	}
 ];
-function toPlainText(html, options) {
-	return (0, html_to_text.convert)(html, {
+let defaultConverter;
+let defaultSelectorSnapshot;
+const OPTION_SNAPSHOT_KEYS = [
+	"baseElements",
+	"decodeEntities",
+	"encodeCharacters",
+	"formatters",
+	"limits",
+	"longWordSplit",
+	"preserveNewlines",
+	"selectors",
+	"whitespaceCharacters",
+	"wordwrap"
+];
+const customConverterCache = /* @__PURE__ */ new WeakMap();
+function plainSelectorsChanged(snapshot) {
+	return snapshot.length !== plainTextSelectors.length || snapshot.some((selector, index) => selector !== plainTextSelectors[index]);
+}
+function getDefaultConverter() {
+	const changed = !defaultSelectorSnapshot || plainSelectorsChanged(defaultSelectorSnapshot);
+	if (!defaultConverter || changed) {
+		defaultSelectorSnapshot = [...plainTextSelectors];
+		defaultConverter = (0, _solid_email_html_to_text.compile)({
+			wordwrap: false,
+			selectors: defaultSelectorSnapshot
+		});
+	}
+	return defaultConverter;
+}
+function createOptionsSnapshot(options, plainSelectorSnapshot, customSelectorSnapshot) {
+	return {
+		baseElements: options.baseElements,
+		decodeEntities: options.decodeEntities,
+		encodeCharacters: options.encodeCharacters,
+		formatters: options.formatters,
+		limits: options.limits,
+		longWordSplit: options.longWordSplit,
+		preserveNewlines: options.preserveNewlines,
+		customSelectorSnapshot,
+		plainSelectorSnapshot,
+		selectors: options.selectors,
+		whitespaceCharacters: options.whitespaceCharacters,
+		wordwrap: options.wordwrap
+	};
+}
+function customOptionsChanged(options, snapshot) {
+	return plainSelectorsChanged(snapshot.plainSelectorSnapshot) || OPTION_SNAPSHOT_KEYS.some((key) => options[key] !== snapshot[key]) || options.selectors?.length !== snapshot.customSelectorSnapshot?.length || (options.selectors?.some((selector, index) => selector !== snapshot.customSelectorSnapshot?.[index]) ?? false);
+}
+function getCustomConverter(options) {
+	const cached = customConverterCache.get(options);
+	if (cached && !customOptionsChanged(options, cached.snapshot)) return cached.converter;
+	const plainSelectorSnapshot = [...plainTextSelectors];
+	const customSelectorSnapshot = options.selectors ? [...options.selectors] : void 0;
+	const selectors = [...plainSelectorSnapshot, ...customSelectorSnapshot ?? []];
+	const converter = (0, _solid_email_html_to_text.compile)({
 		wordwrap: false,
 		...options,
-		selectors: [...plainTextSelectors, ...options?.selectors ?? []]
+		selectors
 	});
+	customConverterCache.set(options, {
+		converter,
+		snapshot: createOptionsSnapshot(options, plainSelectorSnapshot, customSelectorSnapshot)
+	});
+	return converter;
+}
+function toPlainText(html, options) {
+	if (!options) return getDefaultConverter()(html);
+	return getCustomConverter(options)(html);
 }
 //#endregion
 //#region src/shared/render.ts
@@ -154,8 +217,558 @@ function renderSync(node, options) {
 	return renderSyncOutput(removeSolidResourceScripts((0, solid_js_web_dist_server_js.renderToString)(normalizeRenderable(node))), options);
 }
 //#endregion
+//#region src/shared/slot-values.ts
+async function renderSlotValueAsync(value) {
+	if (value == null) return "";
+	if (Array.isArray(value)) return Promise.all(value.map(renderSlotValueAsync)).then((results) => results.join(""));
+	if (typeof value === "boolean") return value ? "true" : "";
+	if (typeof value === "string") return escapeHtml(value);
+	if (typeof value === "number") return String(value);
+	return removeSolidResourceScripts(await (0, solid_js_web_dist_server_js.renderToStringAsync)(() => value));
+}
+function renderSlotValueSync(value) {
+	if (value == null) return "";
+	if (Array.isArray(value)) return value.map(renderSlotValueSync).join("");
+	if (typeof value === "boolean") return value ? "true" : "";
+	if (typeof value === "string") return escapeHtml(value);
+	if (typeof value === "number") return String(value);
+	return removeSolidResourceScripts((0, solid_js_web_dist_server_js.renderToString)(() => value));
+}
+async function renderSlotValueTextAsync(value, options) {
+	if (value == null) return "";
+	if (Array.isArray(value)) return (await Promise.all(value.map((item) => renderSlotValueTextAsync(item, options)))).join("");
+	if (typeof value === "boolean") return value ? "true" : "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return String(value);
+	return toPlainText(removeSolidResourceScripts(await (0, solid_js_web_dist_server_js.renderToStringAsync)(() => value)), options);
+}
+function renderSlotValueTextSync(value, options) {
+	if (value == null) return "";
+	if (Array.isArray(value)) return value.map((item) => renderSlotValueTextSync(item, options)).join("");
+	if (typeof value === "boolean") return value ? "true" : "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return String(value);
+	return toPlainText(removeSolidResourceScripts((0, solid_js_web_dist_server_js.renderToString)(() => value)), options);
+}
+function renderAttrValue(name, value) {
+	if (value == null) return "";
+	if (typeof value === "boolean") return value ? "true" : "";
+	if (typeof value === "string") return escapeAttr(value);
+	if (typeof value === "number") return String(value);
+	throw new TypeError(`Attribute slot "${name}" only accepts string, number, boolean, null, or undefined. Use <Slot name="${name}" /> for JSX/content values.`);
+}
+function renderTextAttrValue(name, value) {
+	if (value == null) return "";
+	if (typeof value === "boolean") return value ? "true" : "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return String(value);
+	throw new TypeError(`Attribute slot "${name}" only accepts string, number, boolean, null, or undefined. Use <Slot name="${name}" /> for JSX/content values.`);
+}
+function renderTextLinkHrefValue(name, value) {
+	const href = renderTextAttrValue(name, value).replace(/^mailto:/, "");
+	return href.startsWith("#") ? "" : href;
+}
+function escapeHtml(str) {
+	return str.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeAttr(str) {
+	return str.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+//#endregion
+//#region src/shared/slot-replacer.ts
+function buildMarkerRegex(lookup) {
+	const markers = /* @__PURE__ */ new Set();
+	for (const occurrences of lookup.content.values()) for (const occ of occurrences) markers.add(occ.full);
+	for (const attrMarkers of lookup.attr.values()) for (const marker of attrMarkers) markers.add(marker);
+	if (markers.size === 0) return /$^/g;
+	return new RegExp(Array.from(markers).sort((a, b) => b.length - a.length).map(escapeRegex$2).join("|"), "g");
+}
+function validateSlots(data, lookup) {
+	const allSlotNames = /* @__PURE__ */ new Set([...lookup.content.keys(), ...lookup.attr.keys()]);
+	for (const name of allSlotNames) if (data[name] === void 0) {
+		if (!(lookup.content.get(name)?.some((occ) => occ.hasDefault) ?? false)) console.warn(`[solid-email] Slot "${name}" has no default and was not provided in render data. It will render as empty.`);
+	}
+}
+async function replaceSlots({ result, data, lookup, markerRegex, validate }) {
+	if (validate) validateSlots(data, lookup);
+	const replacements = /* @__PURE__ */ new Map();
+	for (const [name, occurrences] of lookup.content) {
+		const value = data[name];
+		const rendered = value !== void 0 ? await renderSlotValueAsync(value) : void 0;
+		for (const occ of occurrences) {
+			if (!result.includes(occ.full)) continue;
+			const replacement = rendered ?? await replaceSlots({
+				result: occ.defaultValue,
+				data,
+				lookup,
+				markerRegex,
+				validate: false
+			});
+			replacements.set(occ.full, replacement);
+		}
+	}
+	for (const [name, markers] of lookup.attr) {
+		const value = data[name];
+		const replacement = renderAttrValue(name, value);
+		for (const marker of markers) replacements.set(marker, replacement);
+	}
+	if (replacements.size === 0) return result;
+	return result.replace(markerRegex, (marker) => replacements.get(marker) ?? marker);
+}
+function replaceSlotsSync({ result, data, lookup, markerRegex, validate }) {
+	if (validate) validateSlots(data, lookup);
+	const replacements = /* @__PURE__ */ new Map();
+	for (const [name, occurrences] of lookup.content) {
+		const value = data[name];
+		const rendered = value !== void 0 ? renderSlotValueSync(value) : void 0;
+		for (const occ of occurrences) {
+			if (!result.includes(occ.full)) continue;
+			const replacement = rendered ?? replaceSlotsSync({
+				result: occ.defaultValue,
+				data,
+				lookup,
+				markerRegex,
+				validate: false
+			});
+			replacements.set(occ.full, replacement);
+		}
+	}
+	for (const [name, markers] of lookup.attr) {
+		const value = data[name];
+		const replacement = renderAttrValue(name, value);
+		for (const marker of markers) replacements.set(marker, replacement);
+	}
+	if (replacements.size === 0) return result;
+	return result.replace(markerRegex, (marker) => replacements.get(marker) ?? marker);
+}
+function escapeRegex$2(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/shared/slots.ts
+const MARKER_PREFIX = "__SM_";
+const CONTENT_START$1 = `${MARKER_PREFIX}CNT_`;
+const CONTENT_END$1 = `${MARKER_PREFIX}CNE_`;
+const ATTR_PREFIX$1 = `${MARKER_PREFIX}ATR_`;
+function encodeName(name) {
+	return encodeURIComponent(name).replace(/[!'()*_]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function decodeName(encoded) {
+	return decodeURIComponent(encoded);
+}
+function makeContentMarker(name, defaultValue) {
+	const encoded = encodeName(name);
+	const start = `${CONTENT_START$1}${encoded}__`;
+	if (defaultValue !== void 0) return `${start}${defaultValue}${CONTENT_END$1}${encoded}__`;
+	return `${start}${CONTENT_END$1}${encoded}__`;
+}
+function makeAttrMarker(name) {
+	return `${ATTR_PREFIX$1}${encodeName(name)}__`;
+}
+function escapeRegex$1(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildSlotLookup(html) {
+	const contentSlots = /* @__PURE__ */ new Map();
+	const attrSlots = /* @__PURE__ */ new Map();
+	const nameChars = "(?:[A-Za-z0-9.~-]|%[0-9A-Fa-f]{2})+";
+	const tokenRegex = new RegExp(`${escapeRegex$1(CONTENT_START$1)}(${nameChars})__|${escapeRegex$1(CONTENT_END$1)}(${nameChars})__`, "g");
+	const stack = [];
+	let match;
+	while (true) {
+		match = tokenRegex.exec(html);
+		if (match === null) break;
+		const startName = match[1];
+		if (startName !== void 0) {
+			stack.push({
+				encodedName: startName,
+				name: decodeName(startName),
+				startIndex: match.index,
+				contentStartIndex: tokenRegex.lastIndex
+			});
+			continue;
+		}
+		const endName = match[2];
+		if (endName === void 0) continue;
+		let openIndex = -1;
+		for (let index = stack.length - 1; index >= 0; index -= 1) if (stack[index]?.encodedName === endName) {
+			openIndex = index;
+			break;
+		}
+		if (openIndex === -1) continue;
+		const [open] = stack.splice(openIndex, 1);
+		if (open === void 0) continue;
+		const innerContent = html.slice(open.contentStartIndex, match.index);
+		const occurrence = {
+			full: html.slice(open.startIndex, tokenRegex.lastIndex),
+			hasDefault: innerContent.length > 0,
+			defaultValue: innerContent
+		};
+		const existing = contentSlots.get(open.name);
+		if (existing) existing.push(occurrence);
+		else contentSlots.set(open.name, [occurrence]);
+	}
+	const attrRegex = new RegExp(`${escapeRegex$1(ATTR_PREFIX$1)}(${nameChars})__`, "g");
+	while (true) {
+		match = attrRegex.exec(html);
+		if (match === null) break;
+		const name = decodeName(match[1] ?? "");
+		const existing = attrSlots.get(name);
+		if (existing) existing.push(match[0]);
+		else attrSlots.set(name, [match[0]]);
+	}
+	return {
+		content: contentSlots,
+		attr: attrSlots
+	};
+}
+function Slot(props) {
+	const encoded = encodeName(props.name);
+	const start = (0, solid_js_web.ssr)(`${CONTENT_START$1}${encoded}__`);
+	const end = (0, solid_js_web.ssr)(`${CONTENT_END$1}${encoded}__`);
+	if (props.children !== void 0 && props.children !== null) return [
+		start,
+		props.children,
+		end
+	];
+	return [start, end];
+}
+function slot(name) {
+	return makeAttrMarker(name);
+}
+function defineSlots() {
+	return {
+		content: (name, defaultValue) => makeContentMarker(name, defaultValue),
+		attr: (name) => makeAttrMarker(name)
+	};
+}
+//#endregion
+//#region src/shared/text-template.ts
+const MARKER_NAME_CHARS = "(?:[A-Za-z0-9.~-]|%[0-9A-Fa-f]{2})+";
+const CONTENT_START = "__SM_CNT_";
+const CONTENT_END = "__SM_CNE_";
+const ATTR_PREFIX = "__SM_ATR_";
+const TEXT_SKIP_START = "__SM_TXS_";
+const TEXT_SKIP_END = "__SM_TXE_";
+const LINK_HREF_PREFIX = "__SM_LNK_";
+function createPlainTextTemplate({ html, options, contentSlots, attrSlots }) {
+	const marked = markTextTemplateSlots(html, options);
+	const parsed = parseTextTemplate(toPlainText(marked.html, options));
+	return {
+		nodes: parsed.nodes,
+		usable: canUsePlainTextTemplate({
+			parsed,
+			supportedAttrMarkerCounts: marked.supportedAttrMarkerCounts,
+			expectedConditionalCount: marked.conditionalCount,
+			expectedLinkMarkerCounts: marked.expectedLinkMarkerCounts,
+			contentSlots,
+			attrSlots
+		})
+	};
+}
+async function renderTextTemplate(nodes, data, options) {
+	const chunks = [];
+	for (const node of nodes) switch (node.type) {
+		case "text":
+			chunks.push(node.value);
+			break;
+		case "contentSlot": {
+			const value = data[node.name];
+			chunks.push(value !== void 0 ? await renderSlotValueTextAsync(value, options) : await renderTextTemplate(node.fallback, data, options));
+			break;
+		}
+		case "attrSlot": {
+			const value = data[node.name];
+			chunks.push(renderTextAttrValue(node.name, value));
+			break;
+		}
+		case "linkHrefSlot": {
+			const value = data[node.name];
+			chunks.push(renderTextLinkHrefValue(node.name, value));
+			break;
+		}
+		case "conditionalSkip": {
+			const value = data[node.slotName];
+			if (renderTextAttrValue(node.slotName, value) !== "true") chunks.push(await renderTextTemplate(node.children, data, options));
+			break;
+		}
+	}
+	return chunks.join("");
+}
+function renderTextTemplateSync(nodes, data, options) {
+	const chunks = [];
+	for (const node of nodes) switch (node.type) {
+		case "text":
+			chunks.push(node.value);
+			break;
+		case "contentSlot": {
+			const value = data[node.name];
+			chunks.push(value !== void 0 ? renderSlotValueTextSync(value, options) : renderTextTemplateSync(node.fallback, data, options));
+			break;
+		}
+		case "attrSlot": {
+			const value = data[node.name];
+			chunks.push(renderTextAttrValue(node.name, value));
+			break;
+		}
+		case "linkHrefSlot": {
+			const value = data[node.name];
+			chunks.push(renderTextLinkHrefValue(node.name, value));
+			break;
+		}
+		case "conditionalSkip": {
+			const value = data[node.slotName];
+			if (renderTextAttrValue(node.slotName, value) !== "true") chunks.push(renderTextTemplateSync(node.children, data, options));
+			break;
+		}
+	}
+	return chunks.join("");
+}
+function canUsePlainTextTemplate({ parsed, supportedAttrMarkerCounts, expectedConditionalCount, expectedLinkMarkerCounts, contentSlots, attrSlots }) {
+	if (!parsed.valid) return false;
+	const remainingSupportedAttrMarkers = new Map(supportedAttrMarkerCounts);
+	for (const attrMarkers of attrSlots.values()) for (const marker of attrMarkers) {
+		const remaining = remainingSupportedAttrMarkers.get(marker) ?? 0;
+		if (remaining < 1) return false;
+		remainingSupportedAttrMarkers.set(marker, remaining - 1);
+	}
+	if (parsed.conditionalCount !== expectedConditionalCount) return false;
+	if (parsed.attrMarkerCounts.size > 0) return false;
+	for (const [marker, count] of expectedLinkMarkerCounts) if ((parsed.linkMarkerCounts.get(marker) ?? 0) < count) return false;
+	for (const [name, occurrences] of contentSlots) if ((parsed.contentSlotCounts.get(name) ?? 0) < occurrences.length) return false;
+	return true;
+}
+function markTextTemplateSlots(html, options) {
+	const supportedAttrMarkerCounts = /* @__PURE__ */ new Map();
+	const expectedLinkMarkerCounts = /* @__PURE__ */ new Map();
+	let conditionalCount = 0;
+	const incrementSupported = (marker) => {
+		incrementCount(supportedAttrMarkerCounts, marker);
+	};
+	const dataSkipRegex = new RegExp(`<([A-Za-z][\\w:-]*)([^>]*)\\sdata-skip-in-text=(["'])(__SM_ATR_(${MARKER_NAME_CHARS})__)\\3([^>]*)>([\\s\\S]*?)</\\1>`, "g");
+	let markedHtml = html.replace(dataSkipRegex, (_match, tagName, beforeAttrs, _quote, marker, encodedName, afterAttrs, children) => {
+		incrementSupported(marker);
+		conditionalCount += 1;
+		return `<${tagName}${beforeAttrs}${afterAttrs}>${TEXT_SKIP_START}${encodedName}__${children}${TEXT_SKIP_END}${encodedName}__</${tagName}>`;
+	});
+	if (!options) {
+		const linkHrefRegex = new RegExp(`<a([^>]*)\\shref=(["'])(__SM_ATR_(${MARKER_NAME_CHARS})__)\\2([^>]*)>([\\s\\S]*?)</a>`, "g");
+		markedHtml = markedHtml.replace(linkHrefRegex, (match, beforeAttrs, quote, marker, encodedName, afterAttrs, children) => {
+			const sameContentMarker = `${CONTENT_START}${encodedName}__`;
+			if (children.includes(sameContentMarker)) return match;
+			incrementSupported(marker);
+			incrementCount(expectedLinkMarkerCounts, marker);
+			return `<a${beforeAttrs} href=${quote}${LINK_HREF_PREFIX}${encodedName}__${quote}${afterAttrs}>${children}</a>`;
+		});
+	}
+	return {
+		html: markedHtml,
+		supportedAttrMarkerCounts,
+		expectedLinkMarkerCounts,
+		conditionalCount
+	};
+}
+function parseTextTemplate(text) {
+	const tokenRegex = new RegExp(`${escapeRegex(CONTENT_START)}(${MARKER_NAME_CHARS})__|${escapeRegex(CONTENT_END)}(${MARKER_NAME_CHARS})__|${escapeRegex(ATTR_PREFIX)}(${MARKER_NAME_CHARS})__|${escapeRegex(LINK_HREF_PREFIX)}(${MARKER_NAME_CHARS})__|${escapeRegex(TEXT_SKIP_START)}(${MARKER_NAME_CHARS})__|${escapeRegex(TEXT_SKIP_END)}(${MARKER_NAME_CHARS})__`, "g");
+	const root = {
+		kind: "root",
+		nodes: []
+	};
+	const stack = [root];
+	const contentSlotCounts = /* @__PURE__ */ new Map();
+	const attrMarkerCounts = /* @__PURE__ */ new Map();
+	const linkMarkerCounts = /* @__PURE__ */ new Map();
+	let conditionalCount = 0;
+	let valid = true;
+	let offset = 0;
+	let match;
+	const currentNodes = () => stack[stack.length - 1]?.nodes ?? root.nodes;
+	const addText = (value) => {
+		if (!value) return;
+		currentNodes().push({
+			type: "text",
+			value
+		});
+	};
+	while (true) {
+		match = tokenRegex.exec(text);
+		if (match === null) break;
+		addText(text.slice(offset, match.index));
+		offset = tokenRegex.lastIndex;
+		const [token, contentStart, contentEnd, attrName, linkName, conditionalStart, conditionalEnd] = match;
+		if (contentStart !== void 0) {
+			stack.push({
+				kind: "contentSlot",
+				encodedName: contentStart,
+				name: decodeName(contentStart),
+				nodes: []
+			});
+			continue;
+		}
+		if (contentEnd !== void 0) {
+			const frame = stack[stack.length - 1];
+			if (frame?.kind !== "contentSlot" || frame.encodedName !== contentEnd || !frame.name) {
+				valid = false;
+				addText(token);
+				continue;
+			}
+			stack.pop();
+			currentNodes().push({
+				type: "contentSlot",
+				name: frame.name,
+				fallback: frame.nodes
+			});
+			incrementCount(contentSlotCounts, frame.name);
+			continue;
+		}
+		if (attrName !== void 0) {
+			const marker = `${ATTR_PREFIX}${attrName}__`;
+			currentNodes().push({
+				type: "attrSlot",
+				name: decodeName(attrName),
+				marker
+			});
+			incrementCount(attrMarkerCounts, marker);
+			continue;
+		}
+		if (linkName !== void 0) {
+			const marker = `${ATTR_PREFIX}${linkName}__`;
+			currentNodes().push({
+				type: "linkHrefSlot",
+				name: decodeName(linkName),
+				marker
+			});
+			incrementCount(linkMarkerCounts, marker);
+			continue;
+		}
+		if (conditionalStart !== void 0) {
+			stack.push({
+				kind: "conditionalSkip",
+				encodedName: conditionalStart,
+				name: decodeName(conditionalStart),
+				nodes: []
+			});
+			continue;
+		}
+		if (conditionalEnd !== void 0) {
+			const frame = stack[stack.length - 1];
+			if (frame?.kind !== "conditionalSkip" || frame.encodedName !== conditionalEnd || !frame.name) {
+				valid = false;
+				addText(token);
+				continue;
+			}
+			stack.pop();
+			currentNodes().push({
+				type: "conditionalSkip",
+				slotName: frame.name,
+				children: frame.nodes
+			});
+			conditionalCount += 1;
+		}
+	}
+	addText(text.slice(offset));
+	return {
+		nodes: root.nodes,
+		contentSlotCounts,
+		attrMarkerCounts,
+		linkMarkerCounts,
+		conditionalCount,
+		valid: valid && stack.length === 1
+	};
+}
+function incrementCount(map, key) {
+	map.set(key, (map.get(key) ?? 0) + 1);
+}
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/shared/compile.ts
+var CompiledTemplate = class {
+	html;
+	htmlToTextOptions;
+	slotLookup;
+	markerRegex;
+	plainTextTemplate;
+	constructor(html, options = {}) {
+		this.html = html;
+		this.htmlToTextOptions = options.htmlToTextOptions;
+		this.slotLookup = buildSlotLookup(html);
+		this.markerRegex = buildMarkerRegex(this.slotLookup);
+		if (options.withPlainText) this.plainTextTemplate = createPlainTextTemplate({
+			html,
+			options: options.htmlToTextOptions,
+			contentSlots: this.slotLookup.content,
+			attrSlots: this.slotLookup.attr
+		});
+	}
+	async render(data, options) {
+		if (options?.plainText) return this.renderPlainText(data);
+		return renderOutput(await this.replaceHtmlSlots(data), options?.pretty ? { pretty: true } : void 0);
+	}
+	renderSync(data, options) {
+		if (options?.pretty) throw new Error("renderSync does not support pretty output; use render.");
+		if (options?.plainText) return this.renderPlainTextSync(data);
+		return renderSyncOutput(this.replaceHtmlSlotsSync(data));
+	}
+	async replaceHtmlSlots(data) {
+		return replaceSlots({
+			result: this.html,
+			data,
+			lookup: this.slotLookup,
+			markerRegex: this.markerRegex,
+			validate: true
+		});
+	}
+	replaceHtmlSlotsSync(data) {
+		return replaceSlotsSync({
+			result: this.html,
+			data,
+			lookup: this.slotLookup,
+			markerRegex: this.markerRegex,
+			validate: true
+		});
+	}
+	async renderPlainText(data) {
+		if (this.plainTextTemplate?.usable) {
+			validateSlots(data, this.slotLookup);
+			return renderTextTemplate(this.plainTextTemplate.nodes, data, this.htmlToTextOptions);
+		}
+		return toPlainText(await this.replaceHtmlSlots(data), this.htmlToTextOptions);
+	}
+	renderPlainTextSync(data) {
+		if (this.plainTextTemplate?.usable) {
+			validateSlots(data, this.slotLookup);
+			return renderTextTemplateSync(this.plainTextTemplate.nodes, data, this.htmlToTextOptions);
+		}
+		return toPlainText(this.replaceHtmlSlotsSync(data), this.htmlToTextOptions);
+	}
+};
+async function compile(node, options) {
+	return new CompiledTemplate(removeSolidResourceScripts(await (0, solid_js_web_dist_server_js.renderToStringAsync)(normalizeRenderable(node))), options);
+}
+function compileSync(node, options) {
+	if (options?.pretty) throw new Error("compileSync does not support pretty output; use compile.");
+	return new CompiledTemplate(removeSolidResourceScripts((0, solid_js_web_dist_server_js.renderToString)(normalizeRenderable(node))), options);
+}
+//#endregion
+exports.CompiledTemplate = CompiledTemplate;
+exports.Slot = Slot;
+exports.buildSlotLookup = buildSlotLookup;
+exports.compile = compile;
+exports.compileSync = compileSync;
+exports.decodeName = decodeName;
+exports.defineSlots = defineSlots;
+exports.makeAttrMarker = makeAttrMarker;
+exports.makeContentMarker = makeContentMarker;
+exports.normalizeRenderable = normalizeRenderable;
 exports.plainTextSelectors = plainTextSelectors;
 exports.pretty = pretty;
+exports.removeSolidResourceScripts = removeSolidResourceScripts;
 exports.render = render;
+exports.renderDocument = renderDocument;
+exports.renderOutput = renderOutput;
 exports.renderSync = renderSync;
+exports.renderSyncOutput = renderSyncOutput;
+exports.slot = slot;
 exports.toPlainText = toPlainText;