@pracht/preact-ssr-precompile 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jovi De Croock
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,141 @@
+# @pracht/preact-ssr-precompile
+
+Experimental Rolldown/Vite plugin that precompiles safe Preact JSX DOM subtrees
+into `preact/jsx-runtime` template calls for faster server-side string rendering.
+
+It targets SSR/SSG server bundles only. Client bundles should keep using the
+normal Preact JSX transform so hydration still builds a normal VNode tree.
+
+## Install
+
+```sh
+pnpm add -D @pracht/preact-ssr-precompile
+```
+
+## Usage
+
+### Vite / Pracht
+
+Place the plugin before `pracht()` or `@preact/preset-vite` so it sees JSX before
+the normal Preact transform runs:
+
+```ts
+import { defineConfig } from "vite";
+import { pracht } from "@pracht/vite-plugin";
+import { preactSsrPrecompile } from "@pracht/preact-ssr-precompile";
+
+export default defineConfig({
+  plugins: [
+    preactSsrPrecompile(),
+    pracht(),
+  ],
+});
+```
+
+Pracht also exposes the transform as an opt-in framework flag:
+
+```ts
+export default defineConfig({
+  plugins: [pracht({ precompileSsrJsx: true })],
+});
+```
+
+For non-Pracht Vite SSR builds:
+
+```ts
+import preact from "@preact/preset-vite";
+import { preactSsrPrecompile } from "@pracht/preact-ssr-precompile";
+
+export default defineConfig({
+  plugins: [preactSsrPrecompile(), preact()],
+});
+```
+
+By default the transform runs only when Vite calls plugin transforms with
+`options.ssr === true`.
+
+### Rolldown server builds
+
+For a dedicated server-only Rolldown build, disable the Vite SSR guard:
+
+```ts
+import { defineConfig } from "rolldown";
+import { preactSsrPrecompile } from "@pracht/preact-ssr-precompile";
+
+export default defineConfig({
+  plugins: [preactSsrPrecompile({ ssrOnly: false })],
+});
+```
+
+## What it does
+
+```tsx
+<div class="card">Hello {name}</div>
+```
+
+becomes roughly:
+
+```ts
+import { jsxTemplate as _jsxTemplate, jsxEscape as _jsxEscape } from "preact/jsx-runtime";
+
+const $$_tpl_1 = ["<div class=\"card\">Hello ", "</div>"];
+
+_jsxTemplate($$_tpl_1, _jsxEscape(name));
+```
+
+`preact-render-to-string` recognizes these template VNodes and concatenates the
+pre-escaped strings directly, avoiding most VNode/props allocations for static
+HTML.
+
+## Safety model
+
+The plugin is conservative. It precompiles lowercase native HTML elements only
+and falls back to the normal `jsx()` runtime for cases where Preact has special
+SSR semantics, including:
+
+- components and member-expression tags;
+- spread props;
+- `dangerouslySetInnerHTML`;
+- custom elements;
+- SVG/MathML;
+- `textarea`, `select`, and `option`.
+
+Dynamic children are wrapped in `jsxEscape()`. Dynamic attributes are serialized
+with `jsxAttr()`, with extra handling for ARIA and enumerated boolean attributes
+so output matches `preact-render-to-string`.
+
+## Options
+
+```ts
+preactSsrPrecompile({
+  include: [/\.[cm]?[tj]sx$/],
+  exclude: [/node_modules/],
+  importSource: "preact",
+  ssrOnly: true,
+  skipElements: ["canvas"],
+  dynamicProps: ["data-client"],
+});
+```
+
+- `include` / `exclude`: Vite filter patterns.
+- `importSource`: runtime import source. The plugin imports from
+  `${importSource}/jsx-runtime`.
+- `ssrOnly`: keep the default `true` for apps. Set to `false` only for dedicated
+  server-only builds where transform hooks do not receive an SSR flag.
+- `skipElements`: additional lowercase element names that should always fall
+  back to normal JSX.
+- `dynamicProps`: attributes that should always be emitted through `jsxAttr()`.
+
+## Benchmarks
+
+Run the render-to-string microbenchmark from the workspace root:
+
+```sh
+pnpm --filter @pracht/preact-ssr-precompile bench
+```
+
+The benchmark compiles the same Preact component twice — once with the normal
+automatic JSX transform and once through this precompile transform — then renders
+each version with `preact-render-to-string` and reports ops/sec and speedup.
+Tune the loop size with `BENCH_ITERATIONS=100000` and the warmup count with
+`BENCH_WARMUP=5000`.

package/dist/index.d.mts

@@ -0,0 +1,32 @@
+import { Plugin } from "vite";
+
+//#region src/index.d.ts
+type FilterPattern = string | RegExp | ReadonlyArray<string | RegExp>;
+interface PreactSsrPrecompileOptions {
+  /** Files to transform. Defaults to JS/TS files, including JSX/TSX. */
+  include?: FilterPattern;
+  /** Files to skip. Defaults to node_modules. */
+  exclude?: FilterPattern;
+  /** JSX runtime import source. Imports are generated from `${importSource}/jsx-runtime`. */
+  importSource?: string;
+  /** Run only for Vite SSR transforms. Defaults to true. */
+  ssrOnly?: boolean;
+  /** Additional lowercase HTML element names to keep on the normal JSX path. */
+  skipElements?: string[];
+  /** Attributes that should always be serialized at runtime with `jsxAttr()`. */
+  dynamicProps?: string[];
+}
+interface TransformPreactSsrJsxOptions {
+  importSource?: string;
+  skipElements?: string[];
+  dynamicProps?: string[];
+}
+/**
+ * Create a Vite/Rolldown plugin that precompiles safe Preact JSX for server
+ * bundles into `jsxTemplate()` calls understood by `preact-render-to-string`.
+ */
+declare function preactSsrPrecompile(options?: PreactSsrPrecompileOptions): Plugin;
+/** Transform JSX in a single module. Exposed for tests and non-Vite integrations. */
+declare function transformPreactSsrJsx(code: string, id?: string, options?: TransformPreactSsrJsxOptions): string | null;
+//#endregion
+export { PreactSsrPrecompileOptions, TransformPreactSsrJsxOptions, preactSsrPrecompile as default, preactSsrPrecompile, transformPreactSsrJsx };

package/dist/index.mjs

@@ -0,0 +1,551 @@
+import { parseSync } from "rolldown/utils";
+import { generateTransform, rolldownString, withMagicString } from "rolldown-string";
+//#region src/index.ts
+const DEFAULT_INCLUDE = [/\.[cm]?[tj]sx?$/];
+const DEFAULT_EXCLUDE = [/node_modules/];
+const DEFAULT_IMPORT_SOURCE = "preact";
+const DEFAULT_SKIP_ELEMENTS = new Set([
+	"svg",
+	"math",
+	"textarea",
+	"select",
+	"option"
+]);
+const VOID_ELEMENTS = new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+const HTML_ENUMERATED_ATTRS = new Set(["draggable", "spellcheck"]);
+const NAMESPACE_REPLACE_REGEX = /^(xlink|xmlns|xml)([A-Z])/;
+const HTML_LOWER_CASE = /^(?:accessK|auto[A-Z]|cell|ch|col|cont|cross|dateT|encT|form[A-Z]|frame|hrefL|inputM|maxL|minL|noV|playsI|popoverT|readO|rowS|src[A-Z]|tabI|useM|item[A-Z])/;
+const UNSAFE_NAME = /[\s\n\\/='"<>]/;
+const ENCODED_ENTITIES = /["&<]/;
+const IDENTIFIER_NAME = /^[$A-Z_a-z][$\w]*$/;
+/**
+* Create a Vite/Rolldown plugin that precompiles safe Preact JSX for server
+* bundles into `jsxTemplate()` calls understood by `preact-render-to-string`.
+*/
+function preactSsrPrecompile(options = {}) {
+	const filter = createSimpleFilter(options.include ?? DEFAULT_INCLUDE, options.exclude ?? DEFAULT_EXCLUDE);
+	const ssrOnly = options.ssrOnly ?? true;
+	return {
+		name: "preact-ssr-precompile",
+		enforce: "pre",
+		transform: {
+			filter: { id: /\.[cm]?[jt]sx?(?:$|\?)/ },
+			handler: withMagicString(function(s, id, transformOptions) {
+				const filename = stripQuery(id);
+				if (ssrOnly && transformOptions?.ssr !== true) return;
+				if (!filter(filename)) return;
+				if (!looksLikeJSX(s.original)) return;
+				transformPreactSsrMagicString(s, filename, options);
+			})
+		}
+	};
+}
+/** Transform JSX in a single module. Exposed for tests and non-Vite integrations. */
+function transformPreactSsrJsx(code, id = "preact-ssr.tsx", options = {}) {
+	const s = rolldownString(code, id);
+	if (!transformPreactSsrMagicString(s, id, options)) return null;
+	const result = generateTransform(s, id, true);
+	return result ? String(result.code) : null;
+}
+function transformPreactSsrMagicString(s, id, options) {
+	let program;
+	try {
+		program = parseProgram(id, s.original);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		console.warn(`[preact-ssr-precompile] Skipping ${id}: ${message}`);
+		return false;
+	}
+	const ctx = new TransformContext(s.original, options, collectIdentifierNames(program));
+	const replacements = ctx.collectJsxReplacements(program);
+	if (replacements.length === 0) return false;
+	for (const replacement of replacements) s.update(replacement.start, replacement.end, replacement.code);
+	insertPrelude(s, program, ctx.renderPrelude());
+	return true;
+}
+var TransformContext = class {
+	code;
+	dynamicProps;
+	importSource;
+	skipElements;
+	jsxIdent;
+	jsxTemplateIdent;
+	jsxAttrIdent;
+	jsxEscapeIdent;
+	templateIndex = 0;
+	takenNames;
+	templates = [];
+	usedHelpers = /* @__PURE__ */ new Set();
+	constructor(code, options, takenNames) {
+		this.takenNames = takenNames;
+		this.code = code;
+		this.importSource = options.importSource ?? DEFAULT_IMPORT_SOURCE;
+		this.dynamicProps = new Set(options.dynamicProps ?? []);
+		this.skipElements = new Set([...DEFAULT_SKIP_ELEMENTS, ...options.skipElements ?? []]);
+		this.jsxIdent = uniqueName("_jsx", takenNames);
+		this.jsxTemplateIdent = uniqueName("_jsxTemplate", takenNames);
+		this.jsxAttrIdent = uniqueName("_jsxAttr", takenNames);
+		this.jsxEscapeIdent = uniqueName("_jsxEscape", takenNames);
+	}
+	collectJsxReplacements(node) {
+		const replacements = [];
+		this.collectJsxReplacementsInto(node, replacements);
+		return replacements.sort((a, b) => a.start - b.start);
+	}
+	renderPrelude() {
+		const imports = [
+			["jsx", this.jsxIdent],
+			["jsxTemplate", this.jsxTemplateIdent],
+			["jsxAttr", this.jsxAttrIdent],
+			["jsxEscape", this.jsxEscapeIdent]
+		].filter(([helper]) => this.usedHelpers.has(helper)).map(([helper, alias]) => `${helper} as ${alias}`);
+		if (imports.length === 0 && this.templates.length === 0) return "";
+		const lines = [`import { ${imports.join(", ")} } from ${JSON.stringify(`${this.importSource}/jsx-runtime`)};`];
+		for (const template of this.templates) lines.push(`const ${template.name} = [${template.strings.map((value) => JSON.stringify(value)).join(", ")}];`);
+		return `${lines.join("\n")}\n`;
+	}
+	serializeJsx(node) {
+		if (node.type === "JSXFragment") {
+			const strings = [""];
+			const dynamics = [];
+			this.serializeChildrenToTemplate(getNodeArray(node.children), strings, dynamics, false);
+			return this.genTemplate(strings, dynamics);
+		}
+		if (node.type !== "JSXElement") return this.code.slice(node.start, node.end);
+		const opening = node.openingElement;
+		if (!this.isSerializableOpening(opening)) return this.serializeJsxToCall(node);
+		const strings = [];
+		const dynamics = [];
+		this.serializeElementToTemplate(node, strings, dynamics);
+		return this.genTemplate(strings, dynamics);
+	}
+	renderExpression(expr) {
+		const replacements = [];
+		this.collectJsxReplacementsInto(expr, replacements);
+		if (replacements.length === 0) return this.code.slice(expr.start, expr.end);
+		return applyReplacementsInRange(this.code, expr.start, expr.end, replacements.sort((a, b) => a.start - b.start));
+	}
+	collectJsxReplacementsInto(node, replacements) {
+		if (!isNode(node)) return;
+		if (node.type === "JSXElement" || node.type === "JSXFragment") {
+			replacements.push({
+				start: node.start,
+				end: node.end,
+				code: this.serializeJsx(node)
+			});
+			return;
+		}
+		for (const [key, value] of Object.entries(node)) {
+			if (key === "parent" || key === "comments") continue;
+			if (Array.isArray(value)) for (const item of value) this.collectJsxReplacementsInto(item, replacements);
+			else if (isNode(value)) this.collectJsxReplacementsInto(value, replacements);
+		}
+	}
+	serializeElementToTemplate(node, strings, dynamics) {
+		const opening = node.openingElement;
+		if (!this.isSerializableOpening(opening)) {
+			strings.push("");
+			dynamics.push(this.serializeJsxToCall(node));
+			return;
+		}
+		if (strings.length === 0) strings.push("");
+		const tagName = getElementIdentifierName(opening.name) ?? "";
+		strings[strings.length - 1] += `<${encodeEntities(tagName)}`;
+		for (const attr of getNodeArray(opening.attributes)) {
+			if (attr.type !== "JSXAttribute") continue;
+			this.serializeAttributeToTemplate(attr, strings, dynamics);
+		}
+		const children = getNodeArray(node.children);
+		if (VOID_ELEMENTS.has(tagName)) {
+			strings[strings.length - 1] += "/>";
+			return;
+		}
+		strings[strings.length - 1] += ">";
+		this.serializeChildrenToTemplate(children, strings, dynamics, true);
+		strings[strings.length - 1] += `</${tagName}>`;
+	}
+	serializeAttributeToTemplate(attr, strings, dynamics) {
+		const rawAttrName = getAttributeName(attr, this.code);
+		if (!rawAttrName) return;
+		const attrName = normalizeHtmlAttrName(rawAttrName);
+		if (this.dynamicProps.has(rawAttrName) || attrName === "key" || attrName === "ref") {
+			strings.push("");
+			dynamics.push(this.jsxAttrCall(attrName, this.getAttributeValueExpression(attr)));
+			return;
+		}
+		const value = attr.value;
+		if (!value) {
+			this.appendStaticAttribute(strings, attrName, true);
+			return;
+		}
+		if (value.type === "Literal") {
+			this.appendStaticAttribute(strings, attrName, value.value);
+			return;
+		}
+		if (value.type === "JSXExpressionContainer") {
+			const expr = value.expression;
+			if (!expr || expr.type === "JSXEmptyExpression") return;
+			if (expr.type === "Literal") {
+				this.appendStaticAttribute(strings, attrName, expr.value);
+				return;
+			}
+			strings.push("");
+			dynamics.push(this.jsxAttrCall(attrName, this.renderExpression(expr)));
+			return;
+		}
+		if (value.type === "JSXElement" || value.type === "JSXFragment") {
+			strings.push("");
+			dynamics.push(this.jsxAttrCall(attrName, this.serializeJsx(value)));
+		}
+	}
+	serializeChildrenToTemplate(children, strings, dynamics, isParentSerializable) {
+		for (const [index, child] of children.entries()) {
+			if (child.type === "JSXText") {
+				const text = jsxTextToString(String(child.value ?? ""), true, isParentSerializable && index === children.length - 1);
+				strings[strings.length - 1] += text;
+				continue;
+			}
+			if (child.type === "JSXExpressionContainer") {
+				const expr = child.expression;
+				if (!expr || expr.type === "JSXEmptyExpression") continue;
+				const staticText = getStaticChildText(expr);
+				if (staticText != null) {
+					strings[strings.length - 1] += staticText;
+					continue;
+				}
+				strings.push("");
+				this.usedHelpers.add("jsxEscape");
+				dynamics.push(`${this.jsxEscapeIdent}(${this.renderExpression(expr)})`);
+				continue;
+			}
+			if (child.type === "JSXElement") {
+				this.serializeElementToTemplate(child, strings, dynamics);
+				continue;
+			}
+			if (child.type === "JSXFragment") this.serializeChildrenToTemplate(getNodeArray(child.children), strings, dynamics, false);
+		}
+	}
+	serializeJsxToCall(node) {
+		const opening = node.openingElement;
+		const isComponent = isComponentElementName(opening.name);
+		const typeExpr = jsxElementNameToExpression(opening.name, this.code, isComponent);
+		const props = [];
+		let keyExpr;
+		for (const attr of getNodeArray(opening.attributes)) {
+			if (attr.type === "JSXSpreadAttribute") {
+				const argument = attr.argument;
+				props.push(`...${this.renderExpression(argument)}`);
+				continue;
+			}
+			if (attr.type !== "JSXAttribute") continue;
+			const rawAttrName = getAttributeName(attr, this.code);
+			if (!rawAttrName) continue;
+			const propName = isComponent ? rawAttrName : normalizeHtmlAttrName(rawAttrName);
+			const value = attr.value;
+			if (propName === "key") {
+				keyExpr = value ? this.getAttributeValueExpression(attr) : "true";
+				continue;
+			}
+			props.push(`${objectPropertyKey(propName)}: ${value ? this.getAttributeValueExpression(attr) : "true"}`);
+		}
+		const children = this.serializeChildrenToExpression(getNodeArray(node.children));
+		if (children) props.push(`children: ${children}`);
+		const args = [typeExpr, props.length > 0 ? `{ ${props.join(", ")} }` : "null"];
+		if (keyExpr) args.push(keyExpr);
+		this.usedHelpers.add("jsx");
+		return `${this.jsxIdent}(${args.join(", ")})`;
+	}
+	serializeChildrenToExpression(children) {
+		const values = [];
+		for (const [index, child] of children.entries()) {
+			if (child.type === "JSXText") {
+				const text = jsxTextToString(String(child.value ?? ""), false, index === children.length - 1);
+				if (text !== "") values.push(JSON.stringify(text));
+				continue;
+			}
+			if (child.type === "JSXExpressionContainer") {
+				const expr = child.expression;
+				if (!expr || expr.type === "JSXEmptyExpression") continue;
+				if (isIgnoredLiteralChild(expr)) continue;
+				values.push(this.renderExpression(expr));
+				continue;
+			}
+			if (child.type === "JSXElement" || child.type === "JSXFragment") values.push(this.serializeJsx(child));
+		}
+		if (values.length === 0) return null;
+		if (values.length === 1) return values[0];
+		return `[${values.join(", ")}]`;
+	}
+	getAttributeValueExpression(attr) {
+		const value = attr.value;
+		if (!value) return "true";
+		if (value.type === "Literal") return JSON.stringify(String(value.value ?? ""));
+		if (value.type === "JSXExpressionContainer") {
+			const expr = value.expression;
+			if (!expr || expr.type === "JSXEmptyExpression") return "undefined";
+			return this.renderExpression(expr);
+		}
+		if (value.type === "JSXElement" || value.type === "JSXFragment") return this.serializeJsx(value);
+		return this.code.slice(value.start, value.end);
+	}
+	appendStaticAttribute(strings, attrName, value) {
+		if (value == null) return;
+		if (isAriaOrEnumerated(attrName) && typeof value === "boolean") {
+			strings[strings.length - 1] += ` ${encodeEntities(attrName)}=${JSON.stringify(String(value))}`;
+			return;
+		}
+		if (value === false || typeof value === "function" || typeof value === "object") return;
+		if (value === true || value === "") {
+			strings[strings.length - 1] += ` ${encodeEntities(attrName)}`;
+			return;
+		}
+		strings[strings.length - 1] += ` ${encodeEntities(attrName)}=${JSON.stringify(encodeEntities(String(value)))}`;
+	}
+	jsxAttrCall(attrName, expression) {
+		const serializedName = JSON.stringify(attrName);
+		this.usedHelpers.add("jsxAttr");
+		return `((attr) => attr ? " " + attr : "")(${isAriaOrEnumerated(attrName) ? `((value) => typeof value === "boolean" ? ${this.jsxAttrIdent}(${serializedName}, String(value)) : ${this.jsxAttrIdent}(${serializedName}, value))(${expression})` : `${this.jsxAttrIdent}(${serializedName}, ${expression})`})`;
+	}
+	genTemplate(strings, dynamics) {
+		const templateName = uniqueName(`$$_tpl_${++this.templateIndex}`, this.takenNames);
+		this.templates.push({
+			name: templateName,
+			strings
+		});
+		this.usedHelpers.add("jsxTemplate");
+		return `${this.jsxTemplateIdent}(${[templateName, ...dynamics].join(", ")})`;
+	}
+	isSerializableOpening(opening) {
+		const name = getElementIdentifierName(opening.name);
+		if (!name) return false;
+		if (isComponentTagName(name)) return false;
+		if (this.skipElements.has(name)) return false;
+		if (name.includes("-")) return false;
+		if (name.includes("\0") || UNSAFE_NAME.test(name)) return false;
+		for (const attr of getNodeArray(opening.attributes)) {
+			if (attr.type === "JSXSpreadAttribute") return false;
+			if (attr.type !== "JSXAttribute") continue;
+			if (getAttributeName(attr, this.code) === "dangerouslySetInnerHTML") return false;
+		}
+		return true;
+	}
+};
+function getStaticChildText(expr) {
+	if (expr.type !== "Literal") return null;
+	if (expr.value == null || typeof expr.value === "boolean") return "";
+	return encodeEntities(String(expr.value));
+}
+function isIgnoredLiteralChild(expr) {
+	return expr.type === "Literal" && (expr.value == null || typeof expr.value === "boolean");
+}
+function jsxElementNameToExpression(name, code, isComponent) {
+	if (name.type === "JSXIdentifier") {
+		const tagName = String(name.name ?? "");
+		return isComponent ? tagName : JSON.stringify(tagName);
+	}
+	if (name.type === "JSXMemberExpression" || name.type === "JSXNamespacedName") {
+		if (name.type === "JSXNamespacedName") return JSON.stringify(code.slice(name.start, name.end));
+		return code.slice(name.start, name.end);
+	}
+	return code.slice(name.start, name.end);
+}
+function isComponentElementName(name) {
+	if (name.type === "JSXMemberExpression") return true;
+	if (name.type !== "JSXIdentifier") return false;
+	return isComponentTagName(String(name.name ?? ""));
+}
+function isComponentTagName(name) {
+	const first = name.charCodeAt(0);
+	return first >= 65 && first <= 90;
+}
+function getElementIdentifierName(name) {
+	return name.type === "JSXIdentifier" ? String(name.name ?? "") : null;
+}
+function getAttributeName(attr, code) {
+	const name = attr.name;
+	if (!name) return null;
+	if (name.type === "JSXIdentifier") return String(name.name ?? "");
+	if (name.type === "JSXNamespacedName") return code.slice(name.start, name.end);
+	return null;
+}
+function normalizeHtmlAttrName(name) {
+	switch (name) {
+		case "htmlFor": return "for";
+		case "className": return "class";
+		case "defaultChecked": return "checked";
+		case "defaultSelected": return "selected";
+		case "defaultValue": return "value";
+		case "acceptCharset": return "accept-charset";
+		case "httpEquiv": return "http-equiv";
+		default:
+			if (NAMESPACE_REPLACE_REGEX.test(name)) return name.replace(NAMESPACE_REPLACE_REGEX, "$1:$2").toLowerCase();
+			if (HTML_LOWER_CASE.test(name)) return name.toLowerCase();
+			return name;
+	}
+}
+function objectPropertyKey(name) {
+	return IDENTIFIER_NAME.test(name) ? name : JSON.stringify(name);
+}
+function jsxTextToString(value, escape, trimLastChild) {
+	let text = "";
+	const lines = value.split(/\r\n|\r|\n/);
+	for (const [index, originalLine] of lines.entries()) {
+		let line = index === 0 ? originalLine : originalLine.trimStart();
+		if (index < lines.length - 1 || trimLastChild) line = line.trimEnd();
+		if (line === "") continue;
+		if (index > 0 && text !== "") text += " ";
+		text += line;
+	}
+	return escape ? encodeEntities(text) : text;
+}
+function encodeEntities(value) {
+	if (value.length === 0 || ENCODED_ENTITIES.test(value) === false) return value;
+	let last = 0;
+	let out = "";
+	for (let index = 0; index < value.length; index++) {
+		let replacement = "";
+		switch (value.charCodeAt(index)) {
+			case 34:
+				replacement = "&quot;";
+				break;
+			case 38:
+				replacement = "&amp;";
+				break;
+			case 60:
+				replacement = "&lt;";
+				break;
+			default: continue;
+		}
+		if (index !== last) out += value.slice(last, index);
+		out += replacement;
+		last = index + 1;
+	}
+	if (last !== value.length) out += value.slice(last);
+	return out;
+}
+function isAriaOrEnumerated(name) {
+	return name.startsWith("aria-") || HTML_ENUMERATED_ATTRS.has(name);
+}
+function insertPrelude(s, program, prelude) {
+	if (prelude.trim() === "") return;
+	const insertAt = findPreludeInsertionPoint(s.original, program);
+	const needsLeadingNewline = insertAt > 0 && !s.original.slice(0, insertAt).endsWith("\n");
+	s.appendLeft(insertAt, `${needsLeadingNewline ? "\n" : ""}${prelude}`);
+}
+function findPreludeInsertionPoint(code, program) {
+	const body = getNodeArray(program.body);
+	let insertAt = code.startsWith("#!") ? code.indexOf("\n") + 1 : 0;
+	for (const statement of body) {
+		if (statement.type === "ImportDeclaration") {
+			insertAt = Math.max(insertAt, statement.end);
+			continue;
+		}
+		if (statement.type === "ExpressionStatement") {
+			const expression = statement.expression;
+			if (expression?.type === "Literal" && typeof expression.value === "string") {
+				insertAt = Math.max(insertAt, statement.end);
+				continue;
+			}
+		}
+		break;
+	}
+	while (code[insertAt] === "\r" || code[insertAt] === "\n") insertAt++;
+	return insertAt;
+}
+function applyReplacementsInRange(code, start, end, replacements) {
+	let cursor = start;
+	let out = "";
+	for (const replacement of replacements) {
+		if (replacement.start < cursor || replacement.end > end) continue;
+		out += code.slice(cursor, replacement.start);
+		out += replacement.code;
+		cursor = replacement.end;
+	}
+	out += code.slice(cursor, end);
+	return out;
+}
+function collectIdentifierNames(node) {
+	const names = /* @__PURE__ */ new Set();
+	function visit(value) {
+		if (!isNode(value)) return;
+		if ((value.type === "Identifier" || value.type === "JSXIdentifier") && typeof value.name === "string") names.add(value.name);
+		for (const [key, child] of Object.entries(value)) {
+			if (key === "parent" || key === "comments") continue;
+			if (Array.isArray(child)) for (const item of child) visit(item);
+			else if (isNode(child)) visit(child);
+		}
+	}
+	visit(node);
+	return names;
+}
+function uniqueName(base, takenNames) {
+	let name = base;
+	let index = 1;
+	while (takenNames.has(name)) name = `${base}_${index++}`;
+	takenNames.add(name);
+	return name;
+}
+function getNodeArray(value) {
+	return Array.isArray(value) ? value.filter(isNode) : [];
+}
+function isNode(value) {
+	return !!value && typeof value === "object" && typeof value.type === "string";
+}
+function stripQuery(id) {
+	return id.split("?", 1)[0];
+}
+function parseProgram(id, code) {
+	const parseOptions = getParseOptions(id, code);
+	return parseSync(id, code, {
+		lang: parseOptions.lang,
+		sourceType: parseOptions.sourceType
+	}).program;
+}
+function getParseOptions(id, code) {
+	const filename = stripQuery(id);
+	const isCommonJS = /(^|\W)require\s*\(|(^|\W)module\.exports\b|(^|\W)exports\./.test(code);
+	let lang = "js";
+	if (/\.[cm]?tsx$/i.test(filename)) lang = "tsx";
+	else if (/\.[cm]?ts$/i.test(filename)) lang = looksLikeJSX(code) ? "tsx" : "ts";
+	else if (/\.[cm]?jsx$/i.test(filename)) lang = "jsx";
+	else if (looksLikeJSX(code)) lang = "jsx";
+	return {
+		lang,
+		sourceType: isCommonJS ? "commonjs" : "module"
+	};
+}
+function looksLikeJSX(code) {
+	return /<>|<\/[A-Za-z]|<[A-Za-z]/.test(code);
+}
+function createSimpleFilter(include, exclude) {
+	const includes = normalizeFilterPattern(include);
+	const excludes = normalizeFilterPattern(exclude);
+	return (id) => matchesAny(id, includes) && !matchesAny(id, excludes);
+}
+function normalizeFilterPattern(pattern) {
+	if (Array.isArray(pattern)) return [...pattern];
+	return [pattern];
+}
+function matchesAny(id, patterns) {
+	return patterns.some((pattern) => {
+		if (typeof pattern === "string") return id.includes(pattern);
+		return pattern.test(id);
+	});
+}
+//#endregion
+export { preactSsrPrecompile as default, preactSsrPrecompile, transformPreactSsrJsx };

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@pracht/preact-ssr-precompile",
+  "version": "0.1.0",
+  "description": "Experimental Vite/Rolldown plugin that precompiles safe Preact JSX for faster server-side rendering.",
+  "keywords": [
+    "pracht",
+    "preact",
+    "ssr",
+    "server-rendering",
+    "jsx",
+    "precompile",
+    "vite",
+    "rolldown",
+    "performance",
+    "plugin"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/JoviDeCroock/pracht/tree/main/packages/preact-ssr-precompile",
+  "bugs": {
+    "url": "https://github.com/JoviDeCroock/pracht/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JoviDeCroock/pracht",
+    "directory": "packages/preact-ssr-precompile"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
+  },
+  "peerDependencies": {
+    "preact": "^10.26.0",
+    "preact-render-to-string": "^6.5.13",
+    "vite": "^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "rolldown": "^1.0.0-rc.12",
+    "rolldown-string": "^0.3.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "bench": "pnpm run build && node bench/render-to-string.mjs"
+  }
+}