("pre", "") {}
+ assertEquals("\n\nfirstsecond
", composeHtmlToString {
+ PreparedContainer(pre) { Text("\nfirst"); Text("second") }
+ })
+ assertFailsWith {
+ composeHtmlToString(validateStrictly = true) { Table { PreparedContainer(attrs) {} } }
+ }
+ assertFailsWith {
+ composeHtmlToString { TagElement("script", null) { PreparedContainer(attrs) {} } }
+ }
+ var calls = 0
+ assertEquals("", composeHtmlToString {
+ TagElement("input", null) { PreparedContainer(attrs) { calls++; Text("discarded") } }
+ })
+ assertEquals(1, calls)
+ }
+
+ private val attrs = preparedHtmlAttributes("span", "") { classes("x") }
+
+ @Test
+ fun loweredContainersPreserveContentEffectsAndTextBoundaries() {
+ val trace = mutableListOf()
+ val content: @Composable ElementScope.() -> Unit = {
+ androidx.compose.runtime.remember { trace += "remember"; Unit }
+ androidx.compose.runtime.SideEffect { trace += "side" }
+ androidx.compose.runtime.DisposableEffect(Unit) { trace += "enter"; onDispose { trace += "dispose" } }
+ Text("a"); Text("b"); Span { Text("nested") }
+ }
+ val ordinary = composeHtmlToString { TagElement(attrs.elementBuilder, attrs.callback, content) }
+ val ordinaryTrace = trace.toList()
+ trace.clear()
+ val lowered = composeHtmlToString { PreparedContainer(attrs, content) }
+ assertEquals(ordinary, lowered)
+ assertEquals(ordinaryTrace, trace)
+ }
+
+ @Test
+ fun dynamicValuesKeepScopeAndCompositionLocals() {
+ val local = compositionLocalOf { "default" }
+ for (value in listOf("<&é😀", "", "next", "\n")) {
+ assertEquals(
+ "" + value.replace("&", "&").replace("<", "<") + "",
+ composeHtmlToString(key = "lowered-local") {
+ CompositionLocalProvider(local provides value) {
+ PreparedTextElement(attrs) { local.current }
+ }
+ })
+ }
+ }
+
+ @Test
+ fun textEvaluationAndFailuresKeepStreamingOrder() {
+ fun render(lowered: Boolean): Pair> {
+ val chunks = StringBuilder()
+ val events = mutableListOf()
+ assertFailsWith {
+ composeHtmlString(chunkSize = 1, chunkSink = { chunks.append(it); events += "chunk:$it" }) {
+ if (lowered) PreparedTextElement(attrs) { events += "value"; error("failed value") }
+ else Span(attrs = { classes("x") }) { Text(run { events += "value"; error("failed value") }) }
+ }
+ }
+ return chunks.toString() to events
+ }
+ assertEquals(render(false), render(true))
+ assertEquals("recovered", composeHtmlToString(key = "lowered-local") {
+ PreparedTextElement(attrs) { "recovered" }
+ })
+ }
+
+ @Test
+ fun discardedTextStillEvaluatesAndInvalidTextStillFails() {
+ var calls = 0
+ composeHtmlToString {
+ TagElement(
+ "input",
+ null
+ ) { PreparedTextElement(attrs) { calls++; "discarded" } }
+ }
+ assertEquals(1, calls)
+ assertFailsWith { composeHtmlToString { PreparedTextElement(attrs) { "bad\u0000" } } }
+ }
+
+ @Test
+ fun staticSubtreeMatchesOrdinaryAndStreamingOutput() {
+ val original: @Composable () -> Unit = {
+ Div {
+ Span {
+ Text("<&")
+ Text("")
+ Text("tail")
+ }
+ P { Text("é😀") }
+ }
+ }
+ val html = ""
+ assertEquals(html, composeHtmlToString(content = original))
+ val write: @Composable () -> Unit = { WriteStaticHtml("div", html) }
+ for (hydratable in listOf(false, true)) {
+ val boundary = if (hydratable) "" else ""
+ val expected = "before${html}after${boundary}next"
+ assertEquals(expected, composeHtmlToString(hydratable = hydratable) {
+ Text("before"); write(); Text("after"); Text("next")
+ })
+ val chunks = mutableListOf()
+ composeHtmlToStream(hydratable = hydratable, chunkSize = 1, sink = { chunks.add(it) }) {
+ Text("before"); write(); Text("after"); Text("next")
+ }
+ assertEquals(expected, chunks.joinToString(""))
+ assertEquals(listOf("before", html, "after", "${boundary}next"), chunks)
+ }
+ }
+
+ @Test
+ fun immutableOutputCanBeReturnedOrExtendedAndReusedUnderOneKey() {
+ val html = "constant
"
+ val write: @Composable () -> Unit = { WriteStaticHtml("div", html) }
+ for (hydratable in listOf(false, true)) {
+ fun render(content: @Composable () -> Unit) =
+ composeHtmlToString(key = "immutable-output", hydratable = hydratable, content = content)
+ assertSame(html, render { write() })
+ assertEquals(html + "tail", render { write(); Text("tail") })
+ assertEquals("head" + html, render { Text("head"); write() })
+ assertEquals(html + html, render { write(); write() })
+ assertEquals("", render {
+ Section { Text("head"); write(); Text("tail") }
+ })
+ assertSame(html, render { write() })
+ }
+ }
+
+ @Test
+ fun staticWritesCheckParentsAndDiscardVoidContent() {
+ val write: @Composable () -> Unit = { WriteStaticHtml("div", "safe
") }
+ assertFailsWith { composeHtmlToString(validateStrictly = true) { Table { write() } } }
+ for (tag in listOf("script", "iframe")) {
+ assertFailsWith {
+ composeHtmlToString {
+ TagElement(
+ tag,
+ null
+ ) { write() }
+ }
+ }
+ }
+ assertEquals("", composeHtmlToString { TagElement("input", null) { write() } })
+ }
+
+ @Test
+ fun staticWritesUseTheCurrentValidationMode() {
+ val write: @Composable () -> Unit = { WriteStaticHtml("tr", "| cell |
") }
+ for (strict in listOf(false, true)) for (stream in listOf(false, true)) {
+ // Override the outer setting to verify that static writes read the active provider.
+ val content: @Composable () -> Unit = {
+ CompositionLocalProvider(LocalHtmlValidationMode provides if (strict) HtmlValidationMode.Strict else HtmlValidationMode.Fast) {
+ Table { write() }
+ }
+ }
+
+ fun render(): String {
+ if (!stream) return composeHtmlToString(validateStrictly = !strict, content = content)
+ val output = StringBuilder()
+ composeHtmlToStream(
+ sink = { output.append(it) },
+ chunkSize = 1,
+ validateStrictly = !strict,
+ content = content
+ )
+ return output.toString()
+ }
+ if (strict) assertFailsWith { render() }
+ else assertEquals("", render())
+ }
+ }
+
+ @Test
+ fun staticWritesRetainDocumentRootMetadata() {
+ val document = ""
+ val write: @Composable () -> Unit = { WriteStaticHtml("html", document) }
+ assertSame(document, composeHtmlString(requireHtmlDocumentRoot = true) { write() })
+ val chunks = StringBuilder()
+ composeHtmlString(requireHtmlDocumentRoot = true, chunkSink = { chunks.append(it) }, chunkSize = 1) { write() }
+ assertEquals(document, chunks.toString())
+ val invalidRoots = listOf(
+ Triple("div", "", 1),
+ Triple("html", document, 2),
+ )
+ for ((tag, html, count) in invalidRoots) {
+ val content: @Composable () -> Unit = { repeat(count) { WriteStaticHtml(tag, html) } }
+ assertFailsWith {
+ composeHtmlString(requireHtmlDocumentRoot = true, content = content)
+ }
+ for (strict in listOf(false, true)) for (stream in listOf(false, true)) {
+ fun render(): String {
+ if (!stream) return renderHydratedDocument(validateStrictly = strict, content = content)
+ val output = StringBuilder()
+ renderHydratedDocumentToStream(
+ sink = { output.append(it) }, chunkSize = 1,
+ validateStrictly = strict, content = content
+ )
+ return output.toString()
+ }
+ if (strict) assertFailsWith { render() }
+ else assertEquals("" + composeHtmlToString(content = content), render())
+ }
+ }
+ }
+}
diff --git a/html/eap/core/src/commonTest/kotlin/org/jetbrains/compose/web/dom/PreparedHtmlAttributesTest.kt b/html/eap/core/src/commonTest/kotlin/org/jetbrains/compose/web/dom/PreparedHtmlAttributesTest.kt
new file mode 100644
index 0000000000..3546e0f5c3
--- /dev/null
+++ b/html/eap/core/src/commonTest/kotlin/org/jetbrains/compose/web/dom/PreparedHtmlAttributesTest.kt
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2026 JetBrains s.r.o. and respective authors and developers.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
+ */
+
+@file:OptIn(org.jetbrains.compose.web.internal.runtime.ComposeWebInternalApi::class)
+
+package org.jetbrains.compose.web.dom
+
+import androidx.compose.runtime.Composable
+import kotlinx.browser.dom.HTMLElement
+import org.jetbrains.compose.web.composeHtmlToString
+import org.jetbrains.compose.web.composeHtmlString
+import org.jetbrains.compose.web.composeHtmlToStream
+import kotlin.test.*
+
+class PreparedHtmlAttributesTest {
+ @Test
+ fun preparedTextPreservesLeadingNewlinesAndParentTextBoundaries() {
+ for (tag in listOf("pre", "textarea", "listing", "title")) {
+ val attributes = preparedHtmlAttributes(tag, "<$tag>") {}
+ for (value in listOf("", "\n<&é😀", "text")) {
+ for (strict in listOf(false, true)) {
+ for (hydratable in listOf(false, true)) {
+ for (stream in listOf(false, true)) {
+ fun render(content: @Composable () -> Unit): String {
+ if (!stream) return composeHtmlToString(
+ validateStrictly = strict, hydratable = hydratable, content = content,
+ )
+ val output = StringBuilder()
+ composeHtmlToStream(
+ validateStrictly = strict, hydratable = hydratable, chunkSize = 1,
+ sink = { output.append(it) }, content = content,
+ )
+ return output.toString()
+ }
+
+ val expected = render {
+ Pre {
+ TagElement(tag, null) { Text(value) }
+ Text("\ntail")
+ Text("adjacent")
+ }
+ }
+ assertEquals(expected, render {
+ Pre {
+ PreparedTextElement(attributes) { value }
+ Text("\ntail")
+ Text("adjacent")
+ }
+ }, "$tag, value=$value, strict=$strict, hydratable=$hydratable, stream=$stream")
+ }
+ }
+ }
+ }
+ }
+ }
+
+ @Test
+ fun preparedAttributesAndTextMatchOrdinaryRendering() {
+ val attrs = preparedHtmlAttributes("div", "") {
+ classes(
+ "a&",
+ "b"
+ ); id("x&")
+ }
+ val text = "é😀<&>"
+ for (strict in listOf(false, true)) {
+ assertEquals(
+ "
é😀<&>
",
+ composeHtmlToString(validateStrictly = strict) { PreparedTextElement(attrs) { text } })
+ }
+ }
+
+ @Test
+ fun changingTextUnderOneKeyDoesNotReuseEarlierValues() {
+ val attrs = preparedHtmlAttributes
("div", "") { classes("stable") }
+ for (value in listOf("first", "<&second", "", "é😀")) {
+ assertEquals(
+ composeHtmlToString { Div(attrs = { classes("stable") }) { Text(value) } },
+ composeHtmlToString(key = "static-changing-text") { PreparedTextElement(attrs) { value } })
+ }
+ }
+
+ @Test
+ fun incorrectEncodedDataAndUnsupportedTagsAreRejected() {
+ assertFailsWith
{ preparedHtmlAttributes("div", "") {} }
+ for (tag in listOf("bad tag", "script", "style", "iframe", "area", "meta", "noscript")) {
+ assertFailsWith
(tag) {
+ preparedHtmlAttributes(tag, "<$tag>") {}
+ }
+ }
+ }
+
+ @Test
+ fun aDifferentTagUsesTheOrdinaryAttributeCallback() {
+ val attrs = preparedHtmlAttributes("div", "") { id("x") }
+ assertEquals("
value", composeHtmlToString {
+ TagElement
("span", attrs.callback) { Text("value") }
+ })
+ }
+
+ @Test
+ fun parserChecksAndFailureRecoveryStillApplyToStaticLeaves() {
+ val div = preparedHtmlAttributes("div", "") {}
+ val tr = preparedHtmlAttributes
("tr", "") {}
+ assertFailsWith {
+ composeHtmlToString(key = "static-parser-recovery", validateStrictly = true) {
+ Table {
+ PreparedTextElement(
+ div
+ ) { "invalid child" }
+ }
+ }
+ }
+ assertFailsWith {
+ composeHtmlToString(validateStrictly = true) { Table { Tbody { PreparedTextElement(tr) { "text" } } } }
+ }
+ assertEquals("", composeHtmlToString(validateStrictly = false) {
+ Table { PreparedTextElement(div) { "invalid child" } }
+ })
+ assertEquals("", composeHtmlToString(validateStrictly = false) {
+ Table { Tbody { PreparedTextElement(tr) { "text" } } }
+ })
+ assertEquals("recovered
", composeHtmlToString(key = "static-parser-recovery") {
+ PreparedTextElement(div) { "recovered" }
+ })
+ assertFailsWith { composeHtmlToString { PreparedTextElement(div) { "bad\u0000" } } }
+ }
+
+ @Test
+ fun streamingAndTextBoundariesMatchTheOrdinaryPath() {
+ val attrs = preparedHtmlAttributes("div", "") { classes("x") }
+ val text = "\n<&é😀"
+ val expected = composeHtmlToString {
+ Text("before"); Div(attrs = { classes("x") }) { Text("\n<&é😀") }; Text("after"); Text("adjacent")
+ }
+ val chunks = StringBuilder()
+ val remainder = composeHtmlString(chunkSize = 1, chunkSink = { chunks.append(it) }) {
+ Text("before"); PreparedTextElement(attrs) { text }; Text("after"); Text("adjacent")
+ }
+ assertEquals(expected, chunks.append(remainder).toString())
+ }
+}
diff --git a/html/eap/core/src/commonTest/kotlin/org/jetbrains/compose/web/dom/RawTextScannerTest.kt b/html/eap/core/src/commonTest/kotlin/org/jetbrains/compose/web/dom/RawTextScannerTest.kt
index cf459f4aea..2905be247f 100644
--- a/html/eap/core/src/commonTest/kotlin/org/jetbrains/compose/web/dom/RawTextScannerTest.kt
+++ b/html/eap/core/src/commonTest/kotlin/org/jetbrains/compose/web/dom/RawTextScannerTest.kt
@@ -3,6 +3,9 @@
* Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
*/
+// Access shared serialization helpers without exposing them as public API.
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+
package org.jetbrains.compose.web.dom
import kotlin.test.Test
diff --git a/html/eap/core/src/jsMain/kotlin/org/jetbrains/compose/web/dom/AttributeEquals.kt b/html/eap/core/src/jsMain/kotlin/org/jetbrains/compose/web/dom/AttributeEquals.kt
index 208f7363e5..d8531fa0a8 100644
--- a/html/eap/core/src/jsMain/kotlin/org/jetbrains/compose/web/dom/AttributeEquals.kt
+++ b/html/eap/core/src/jsMain/kotlin/org/jetbrains/compose/web/dom/AttributeEquals.kt
@@ -3,6 +3,9 @@
* Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
*/
+// Access shared serialization helpers without exposing them as public API.
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+
package org.jetbrains.compose.web.dom
import kotlinx.browser.dom.Element
diff --git a/html/eap/core/src/jsMain/kotlin/org/jetbrains/compose/web/dom/DomChecks.kt b/html/eap/core/src/jsMain/kotlin/org/jetbrains/compose/web/dom/DomChecks.kt
index 8a99e4b781..7f493093d5 100644
--- a/html/eap/core/src/jsMain/kotlin/org/jetbrains/compose/web/dom/DomChecks.kt
+++ b/html/eap/core/src/jsMain/kotlin/org/jetbrains/compose/web/dom/DomChecks.kt
@@ -3,6 +3,9 @@
* Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
*/
+// Access shared serialization helpers without exposing them as public API.
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+
package org.jetbrains.compose.web.dom
import kotlinx.browser.dom.Element
@@ -13,6 +16,7 @@ import kotlinx.browser.dom.Text
internal actual fun Element.hasHtmlNamespace(): Boolean = namespaceURI == HtmlNamespace
internal actual fun Element.matchesElement(localName: String, namespace: String): Boolean =
this.localName == localName && namespaceURI == namespace
+
internal actual fun Text.matchesText(value: String): Boolean = data == value
internal actual fun Node.isRawTextContainer(): Boolean =
this is Element && isHtmlRawTextElement(localName, namespaceURI)
diff --git a/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/ComposeHtmlToStream.kt b/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/ComposeHtmlToStream.kt
index ad58596f3b..bd889a18d2 100644
--- a/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/ComposeHtmlToStream.kt
+++ b/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/ComposeHtmlToStream.kt
@@ -15,7 +15,8 @@ import java.io.Writer
* for each chunk. The writer is not flushed or closed. The writer must consume each write before returning.
*
* [chunkSize] is a target minimum in UTF-16 code units. Tags and individual `Text` calls stay
- * intact. Elements requiring content validation are emitted only after validation succeeds.
+ * intact on the runtime path. Compiler-validated fragments can stream in smaller pieces.
+ * Elements requiring content validation are emitted only after validation succeeds.
* A write can exceed [chunkSize]. No empty writes are made.
*
* Rendering uses the caller's current snapshot. Use a mutable snapshot around rendering for isolation.
diff --git a/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/dom/Elements.jvm.kt b/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/dom/Elements.jvm.kt
index 9cae7c0c04..a98aa2c6ec 100644
--- a/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/dom/Elements.jvm.kt
+++ b/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/dom/Elements.jvm.kt
@@ -3,6 +3,9 @@
* Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
*/
+// Access shared serialization helpers without exposing them as public API.
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+
package org.jetbrains.compose.web.dom
import kotlinx.browser.dom.Element
diff --git a/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/dom/HtmlStringSerialization.jvm.kt b/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/dom/HtmlStringSerialization.jvm.kt
index 17e34dd044..ef2d0891a7 100644
--- a/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/dom/HtmlStringSerialization.jvm.kt
+++ b/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/dom/HtmlStringSerialization.jvm.kt
@@ -9,13 +9,19 @@ package org.jetbrains.compose.web.dom
import org.jetbrains.compose.web.internal.unsafeCast
-internal actual fun canAppendUnescapedHtmlString(value: String, attribute: Boolean): Boolean {
- if (value.length < 32) return false
+internal actual fun canAppendUnescapedHtmlString(value: String, attribute: Boolean, startIndex: Int): Boolean {
+ if (value.length - startIndex < 32) return false
// Use JVM String searches to skip Kotlin's search wrappers.
val text = value.unsafeCast
()
- return text.indexOf('&'.code) < 0 && text.indexOf('<'.code) < 0 && text.indexOf('>'.code) < 0 &&
- text.indexOf('\r'.code) < 0 && text.indexOf('\u0000'.code) < 0 &&
- (!attribute || (text.indexOf('"'.code) < 0 && text.indexOf('\n'.code) < 0 && text.indexOf('\t'.code) < 0))
+ return text.indexOf('&'.code, startIndex) < 0 && text.indexOf('<'.code, startIndex) < 0 && text.indexOf(
+ '>'.code,
+ startIndex
+ ) < 0 &&
+ text.indexOf('\r'.code, startIndex) < 0 && text.indexOf('\u0000'.code, startIndex) < 0 &&
+ (!attribute || (text.indexOf('"'.code, startIndex) < 0 && text.indexOf(
+ '\n'.code,
+ startIndex
+ ) < 0 && text.indexOf('\t'.code, startIndex) < 0))
}
internal actual fun StringBuilder.appendHtmlRun(value: String, start: Int, end: Int) {
@@ -53,6 +59,7 @@ internal actual fun StringBuilder.appendEscapedHtmlString(value: String, attribu
if (attribute) "HTML attribute values must not contain NUL (U+0000)"
else "HTML text must not contain NUL (U+0000)"
)
+
'&' -> "&"
'<' -> "<"
'>' -> ">"
@@ -64,19 +71,9 @@ internal actual fun StringBuilder.appendEscapedHtmlString(value: String, attribu
appendHtmlRun(value, start, index)
append(replacement)
start = index + 1
- if (character == '&' && canAppendUnescapedHtmlSuffix(value, attribute, start)) {
+ if (character == '&' && canAppendUnescapedHtmlString(value, attribute, start)) {
appendHtmlRun(value, start, value.length)
return true
}
}
}
-
-private fun canAppendUnescapedHtmlSuffix(value: String, attribute: Boolean, start: Int): Boolean {
- if (value.length - start < 32) return false
- val text = value.unsafeCast()
- return text.indexOf('&'.code, start) < 0 && text.indexOf('<'.code, start) < 0 &&
- text.indexOf('>'.code, start) < 0 && text.indexOf('\r'.code, start) < 0 &&
- text.indexOf('\u0000'.code, start) < 0 &&
- (!attribute || (text.indexOf('"'.code, start) < 0 && text.indexOf('\n'.code, start) < 0 &&
- text.indexOf('\t'.code, start) < 0))
-}
diff --git a/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/dom/PreparedHtmlCallback.kt b/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/dom/PreparedHtmlCallback.kt
new file mode 100644
index 0000000000..9ac1f79d0e
--- /dev/null
+++ b/html/eap/core/src/jvmMain/kotlin/org/jetbrains/compose/web/dom/PreparedHtmlCallback.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2026 JetBrains s.r.o. and respective authors and developers.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
+ */
+
+@file:OptIn(org.jetbrains.compose.web.internal.runtime.ComposeWebInternalApi::class)
+
+package org.jetbrains.compose.web.dom
+
+import kotlinx.browser.dom.Element
+import org.jetbrains.compose.web.attributes.AttrsScope
+
+// Keep the start tag in the callback so SSR can write it directly.
+private class JvmPreparedHtmlCallback(
+ val attributes: PreparedHtmlAttributes,
+) : Function1, Unit> {
+ override fun invoke(target: AttrsScope) = attributes.applyTo(target)
+}
+
+internal actual fun createPreparedHtmlCallback(
+ attributes: PreparedHtmlAttributes,
+): AttrsScope.() -> Unit = JvmPreparedHtmlCallback(attributes)
+
+internal actual fun preparedHtmlCallbackMetadata(
+ callback: (AttrsScope.() -> Unit)?,
+): PreparedHtmlAttributes? = (callback as? JvmPreparedHtmlCallback)?.attributes
diff --git a/html/eap/core/src/jvmTest/kotlin/org/jetbrains/compose/web/dom/HtmlStringSerializationJvmTest.kt b/html/eap/core/src/jvmTest/kotlin/org/jetbrains/compose/web/dom/HtmlStringSerializationJvmTest.kt
new file mode 100644
index 0000000000..dc0f32e539
--- /dev/null
+++ b/html/eap/core/src/jvmTest/kotlin/org/jetbrains/compose/web/dom/HtmlStringSerializationJvmTest.kt
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2026 JetBrains s.r.o. and respective authors and developers.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
+ */
+
+package org.jetbrains.compose.web.dom
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+import kotlin.test.assertFailsWith
+import kotlin.random.Random
+
+class HtmlStringSerializationJvmTest {
+ @Test
+ fun specializedSerializerMatchesEscapingForEveryCodeUnit() {
+ val padding = "a".repeat(128)
+ for (code in Char.MIN_VALUE.code..Char.MAX_VALUE.code) {
+ for (offset in 0..3) {
+ val value = padding + "a".repeat(offset) + code.toChar() + padding
+ for (attribute in listOf(false, true)) {
+ val output = StringBuilder("prefix:")
+ if (code == 0) {
+ assertFailsWith { output.appendEscapedHtmlString(value, attribute) }
+ } else {
+ assertTrue(output.appendEscapedHtmlString(value, attribute))
+ assertEquals(
+ "prefix:" + referenceEscape(value, attribute),
+ output.toString(),
+ "Code unit $code"
+ )
+ }
+ }
+ }
+ }
+ }
+
+ @Test
+ fun serializersMatchForVariedEscapePositionsAndDensities() {
+ val random = Random(342625)
+ val alphabet = "abc f|~@MF éα日本語😀&<>\r\"\n\t"
+ for (length in listOf(0, 31, 32, 64, 127, 128, 129, 255, 256, 257, 1024, 8192)) {
+ repeat(16) {
+ val value = buildString { repeat(length) { append(alphabet[random.nextInt(alphabet.length)]) } }
+ assertEquals(referenceEscape(value, false), buildString { appendEscapedText(value) })
+ assertEquals(referenceEscape(value, true), buildString { appendEscapedAttribute(value) })
+ }
+ }
+ }
+
+ private fun referenceEscape(value: String, attribute: Boolean): String {
+ var result = value.replace("&", "&").replace("<", "<").replace(">", ">").replace("\r", "
")
+ if (attribute) result = result.replace("\"", """).replace("\n", "
").replace("\t", " ")
+ return result
+ }
+
+ @Test
+ fun fastPathChecksEveryUtf16CodeUnitInTextAndAttributes() {
+ for (paddingLength in listOf(32, 128)) {
+ val padding = "a".repeat(paddingLength)
+ for (code in Char.MIN_VALUE.code..Char.MAX_VALUE.code) {
+ val character = code.toChar()
+ val textSafe = character !in "\u0000&<>\r"
+ val attributeSafe = textSafe && character !in "\"\n\t"
+ for (offset in 0..3) {
+ val value = padding + "a".repeat(offset) + character + padding
+ assertEquals(
+ textSafe,
+ canAppendUnescapedHtmlString(value, attribute = false),
+ "Text code unit $code at $offset",
+ )
+ assertEquals(
+ attributeSafe,
+ canAppendUnescapedHtmlString(value, attribute = true),
+ "Attribute code unit $code at $offset",
+ )
+ }
+ }
+ }
+ }
+
+ @Test
+ fun fastPathChecksOnlyTheRequestedSuffixAndKeepsTheShortRunCutoff() {
+ for (attribute in listOf(false, true)) {
+ for (length in listOf(0, 1, 30, 31, 32, 33, 64, 127, 128, 129, 1024)) {
+ val value = "\u0000&<>\r\"\n\t" + "a".repeat(length)
+ assertEquals(length >= 32, canAppendUnescapedHtmlString(value, attribute, startIndex = 8))
+ }
+ for (character in "\u0000&<>\r" + if (attribute) "\"\n\t" else "") {
+ for (length in (32..35) + (128..131)) {
+ assertFalse(canAppendUnescapedHtmlString("a".repeat(length - 1) + character, attribute))
+ }
+ for (position in listOf(0, 31, 32, 64, 127, 128, 129)) {
+ val value = "&" + "a".repeat(position) + character + "a".repeat(64)
+ assertFalse(canAppendUnescapedHtmlString(value, attribute, startIndex = 1))
+ assertTrue(canAppendUnescapedHtmlString(value, attribute, startIndex = position + 2))
+ }
+ }
+ }
+ }
+}
diff --git a/html/eap/core/src/webMain/kotlin/org/jetbrains/compose/web/dom/Base.web.kt b/html/eap/core/src/webMain/kotlin/org/jetbrains/compose/web/dom/Base.web.kt
index 6c4e88e458..17924be877 100644
--- a/html/eap/core/src/webMain/kotlin/org/jetbrains/compose/web/dom/Base.web.kt
+++ b/html/eap/core/src/webMain/kotlin/org/jetbrains/compose/web/dom/Base.web.kt
@@ -5,6 +5,9 @@
@file:OptIn(kotlin.js.ExperimentalWasmJsInterop::class)
+// Access shared serialization helpers without exposing them as public API.
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+
package org.jetbrains.compose.web.dom
import androidx.compose.runtime.*
@@ -65,11 +68,11 @@ private class ElementAttrs(val builder: AttrsScopeBuilder<*>) {
val a = builder
val b = other.builder
return a.collect() == b.collect() &&
- a.classes == b.classes &&
- a.styleScopeOrNull == b.styleScopeOrNull &&
- a.propertyUpdatesOrEmpty == b.propertyUpdatesOrEmpty &&
- a.eventsListenerScopeBuilder.collectListeners() ==
- b.eventsListenerScopeBuilder.collectListeners()
+ a.classes == b.classes &&
+ a.styleScopeOrNull == b.styleScopeOrNull &&
+ a.propertyUpdatesOrEmpty == b.propertyUpdatesOrEmpty &&
+ a.eventsListenerScopeBuilder.collectListeners() ==
+ b.eventsListenerScopeBuilder.collectListeners()
}
override fun hashCode(): Int = builder.collect().hashCode()
@@ -336,7 +339,7 @@ private class HydratingDomElementWrapper(
}
applier.mismatch(
"attribute \"$name\": expected ${expected.describeAttributeValue()}, " +
- "found ${actual.describeAttributeValue()}",
+ "found ${actual.describeAttributeValue()}",
)
}
}
@@ -346,6 +349,7 @@ private fun Element.composedAttributeNamespace(name: String): String? =
if (namespaceURI == HtmlNamespace) null else when (name) {
"xlink:actuate", "xlink:arcrole", "xlink:href", "xlink:role", "xlink:show",
"xlink:title", "xlink:type" -> "http://www.w3.org/1999/xlink"
+
"xml:base", "xml:lang", "xml:space" -> "http://www.w3.org/XML/1998/namespace"
"xmlns", "xmlns:xlink" -> "http://www.w3.org/2000/xmlns/"
else -> null
@@ -601,7 +605,7 @@ private class HydratingComposeHtmlContext(
// Keep scripted