@mpen/jsxhtml 0.2.2 → 0.4.0

package/dist/{jsx-runtime-DpEMYmD9.js → jsx-runtime-BQPDXeiv.js}

@@ -1318,29 +1318,43 @@ const entityMap = {
     ffl: "ffllig"
 };
 
-function cc(names) {
-    if (typeof names === "string" || typeof names === "number") return "" + names;
-    let out = "";
-    if (Array.isArray(names)) {
-        for (let i = 0, tmp; i < names.length; i++) {
-            if ((tmp = cc(names[i])) !== "") {
-                out += (out && " ") + tmp;
-            }
+function pushClassNames(value, classes) {
+    if (value == null || value === false || value === true) return;
+    if (typeof value === "string") {
+        if (value) classes.push(value);
+        return;
+    }
+    if (typeof value === "number" || typeof value === "bigint") {
+        classes.push(String(value));
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            pushClassNames(item, classes);
         }
-    } else {
-        for (let k in names) {
-            if (names[k]) out += (out && " ") + k;
+        return;
+    }
+    for (const key of Object.keys(value)) {
+        if (value[key]) {
+            classes.push(key);
         }
     }
-    return out;
 }
 
-function isFunction(obj) {
+function classCat(...values) {
+    const classes = [];
+    for (const value of values) {
+        pushClassNames(value, classes);
+    }
+    return classes.join(" ");
+}
+
+function isFunction$1(obj) {
     return typeof obj === "function";
 }
 
 function isIterable(obj) {
-    return isObjectLike(obj) && isFunction(obj[Symbol.iterator]);
+    return isObjectLike(obj) && isFunction$1(obj[Symbol.iterator]);
 }
 
 function isNumber(obj) {
@@ -1351,7 +1365,7 @@ function isObjectLike(obj) {
     return typeof obj === "object" && obj !== null;
 }
 
-function isObject(obj) {
+function isObject$1(obj) {
     return obj != null && (typeof obj === "object" || typeof obj === "function");
 }
 
@@ -1361,7 +1375,7 @@ function isPlainObject(obj) {
     return proto === null || proto === Object.prototype;
 }
 
-function isString(obj) {
+function isString$1(obj) {
     return typeof obj === "string";
 }
 
@@ -1416,7 +1430,7 @@ function styleObjectToString(styles) {
 }
 
 function entity(ch) {
-    return Object.hasOwn(entityMap, ch) ? `&${entityMap[ch]};` : `&#x${ch.codePointAt(0).toString(16)};`;
+    return Object.prototype.hasOwnProperty.call(entityMap, ch) ? `&${entityMap[ch]};` : `&#x${ch.codePointAt(0).toString(16)};`;
 }
 
 function tagName(string) {
@@ -1428,15 +1442,15 @@ function attrName(string) {
 }
 
 function attrValue(value) {
-    if (isFunction(value)) {
-        value = `(${value}).call(this)`;
+    if (isFunction$1(value)) {
+        value = `(${value}).call(this,event)`;
     }
     return `"${String(value).replace(/"/gu, entity)}"`;
 }
 
 function attrKvPair(rawAttr, rawVal) {
     let escAttr = attrName(rawAttr);
-    if (/^data-/.test(rawAttr) && !isString(rawVal)) {
+    if (/^data-/.test(rawAttr) && !isString$1(rawVal)) {
         rawVal = JSON.stringify(rawVal);
     }
     if (rawVal === true) {
@@ -1445,8 +1459,8 @@ function attrKvPair(rawAttr, rawVal) {
     if (rawVal === false || rawVal == null) {
         return null;
     }
-    if (rawAttr === "class" && !isString(rawVal)) {
-        rawVal = cc(rawVal);
+    if (rawAttr === "class" && !isString$1(rawVal)) {
+        rawVal = classCat(rawVal);
     }
     if (rawAttr === "style" && isPlainObject(rawVal)) {
         rawVal = styleObjectToString(rawVal);
@@ -1456,7 +1470,7 @@ function attrKvPair(rawAttr, rawVal) {
 
 function attrs(attributes) {
     if (attributes == null) return "";
-    if (isObject(attributes)) {
+    if (isObject$1(attributes)) {
         attributes = Object.entries(attributes);
     }
     return attributes.map((([k, v]) => attrKvPair(k, v))).filter((x => x)).map((x => ` ${x}`)).join("");
@@ -1484,6 +1498,598 @@ function isJsxNode(x) {
     return x instanceof JsxNode;
 }
 
+/*! Adapted from https://github.com/mathiasbynens/CSS.escape/blob/4b25c283eaf4dd443f44a7096463e973d56dd1b2/css.escape.js */ function cssEscape(value) {
+    const string = String(value);
+    const length = string.length;
+    let index = -1;
+    let codeUnit;
+    let result = "";
+    const firstCodeUnit = string.charCodeAt(0);
+    if (length === 1 && firstCodeUnit === 45) {
+        return "\\" + string;
+    }
+    while (++index < length) {
+        codeUnit = string.charCodeAt(index);
+        if (codeUnit === 0) {
+            result += "�";
+            continue;
+        }
+        if (codeUnit >= 1 && codeUnit <= 31 || codeUnit === 127 || index === 0 && codeUnit >= 48 && codeUnit <= 57 || index === 1 && codeUnit >= 48 && codeUnit <= 57 && firstCodeUnit === 45) {
+            result += "\\" + codeUnit.toString(16) + " ";
+            continue;
+        }
+        if (codeUnit >= 128 || codeUnit === 45 || codeUnit === 95 || codeUnit >= 48 && codeUnit <= 57 || codeUnit >= 65 && codeUnit <= 90 || codeUnit >= 97 && codeUnit <= 122) {
+            result += string.charAt(index);
+            continue;
+        }
+        result += "\\" + string.charAt(index);
+    }
+    return result;
+}
+
+function isFunction(obj) {
+    return typeof obj === "function";
+}
+
+function isString(obj) {
+    return typeof obj === "string";
+}
+
+function isStringLike(obj) {
+    return typeof obj === "string" || obj instanceof String;
+}
+
+function isNumberLike(obj) {
+    return typeof obj === "number" || obj instanceof Number;
+}
+
+function isBigInt(obj) {
+    return typeof obj === "bigint";
+}
+
+function isBoolean(obj) {
+    return obj === true || obj === false;
+}
+
+function isRegExp(obj) {
+    return obj instanceof RegExp;
+}
+
+function isArray(obj) {
+    return Array.isArray(obj);
+}
+
+function isObject(obj) {
+    return obj !== null && typeof obj === "object";
+}
+
+function isSymbol(obj) {
+    return Object.prototype.toString.call(obj) === "[object Symbol]";
+}
+
+function findFunction(lib, fn, maxDepth = 3) {
+    let queue = [];
+    let path = [];
+    let seen = new Set;
+    --maxDepth;
+    for (;;) {
+        if (lib[fn.name] === fn) {
+            return [ ...path, fn.name ];
+        }
+        seen.add(lib);
+        if (path.length < maxDepth) {
+            for (let n of Object.getOwnPropertyNames(lib)) {
+                if (n[0] !== "_" && n !== "prototype" && lib[n] && !seen.has(lib[n])) {
+                    queue.push([ [ ...path, n ], lib[n] ]);
+                }
+            }
+        }
+        if (!queue.length) {
+            return null;
+        }
+        [path, lib] = queue.shift();
+    }
+}
+
+var nativeFuncs = new Map;
+
+var isRaw = Symbol("isRaw");
+
+var wellKnownSymbols;
+
+function merge(target, ...sources) {
+    for (let obj of sources) {
+        if (obj) {
+            for (let key of Object.keys(obj)) {
+                if (obj[key] !== undefined) {
+                    target[key] = obj[key];
+                }
+            }
+        }
+    }
+    return target;
+}
+
+function jsSerialize(object, options) {
+    return startSerialize(object, options).replace(/<\/(script)/gi, "<\\/$1");
+}
+
+function startSerialize(object, options) {
+    const counts = referenceCount(object);
+    let c = 0;
+    const dupes = [ ...counts ].filter((x => x[1] > 1)).sort(((a, b) => b[1] - a[1])).map((x => [ x[0], `$${c++}` ]));
+    const refs = new Map(dupes);
+    let ctx = {
+        seen: new Set,
+        refs,
+        opts: Object.freeze(merge({
+            compact: false,
+            safe: true
+        }, options))
+    };
+    let js = serializeAny(object, ctx);
+    if (dupes.length) {
+        let varDecl = dupes.map((x => x[1])).join(",");
+        if (dupes.length > 1) {
+            varDecl = `(${varDecl})`;
+        }
+        if (js.startsWith("{")) {
+            js = `(${js})`;
+        }
+        return `(${varDecl}=>${js})()`;
+    }
+    return js;
+}
+
+var STRING_REF_MIN_LENGTH = 12;
+
+function referenceCount(object) {
+    const m = new Map;
+    function r(o) {
+        let c = m.get(o);
+        if (c) {
+            m.set(o, c + 1);
+            return;
+        }
+        if (isArray(o) || o instanceof Set) {
+            m.set(o, 1);
+            for (const v of o) {
+                r(v);
+            }
+        } else if (isString(o)) {
+            if (o.length >= STRING_REF_MIN_LENGTH) {
+                m.set(o, 1);
+            }
+        } else if (o instanceof Map) {
+            m.set(o, 1);
+            for (const v of o.values()) {
+                r(v);
+            }
+        } else if (isRegExp(o) || o instanceof Date || isSymbol(o) || isFunction(o)) {
+            m.set(o, 1);
+        } else if (isObject(o)) {
+            m.set(o, 1);
+            for (const k of Reflect.ownKeys(o)) {
+                r(o[k]);
+            }
+        }
+    }
+    r(object);
+    return m;
+}
+
+function isNegativeZero(value) {
+    return 1 / value === -Infinity;
+}
+
+function serializeArray(obj, ctx) {
+    const varName = ctx.refs.get(obj);
+    const assign = varName ? `${varName}=` : "";
+    if (obj.length === 0) {
+        return `${assign}[]`;
+    }
+    let sb = [];
+    let hasProp = false;
+    let isSparse = false;
+    for (let i = 0; i < obj.length; ++i) {
+        if (obj.hasOwnProperty(i)) {
+            hasProp = true;
+            sb.push(serializeAny(obj[i], ctx));
+        } else {
+            isSparse = true;
+            sb.push("");
+        }
+    }
+    if (!hasProp) {
+        return `${assign}new Array(${obj.length})`;
+    }
+    if (sb[sb.length - 1] === "") {
+        sb.push("");
+    }
+    const inner = sb.join(",");
+    if (varName) {
+        if (isSparse) {
+            let sb2 = [ `(${varName}=new Array(${obj.length})` ];
+            for (let i = 0; i < obj.length; ++i) {
+                if (obj.hasOwnProperty(i)) {
+                    sb2.push(`${varName}[${i}]=${serializeAny(obj[i], ctx)}`);
+                }
+            }
+            sb2.push(`${varName})`);
+            return sb2.join(",");
+        }
+        return `(${varName}=[],${varName}.push(${inner}),${varName})`;
+    }
+    return `[${inner}]`;
+}
+
+function serializeSet(obj, ctx) {
+    const varName = ctx.refs.get(obj);
+    if (obj.size) {
+        if (varName) {
+            return `(${varName}=new Set,${varName}` + Array.from(obj).map((x => `.add(${serializeAny(x, ctx)})`)).join("") + ")";
+        }
+        return "new Set(" + serializeAny(Array.from(obj), ctx) + ")";
+    }
+    if (varName) {
+        return `${varName}=new Set`;
+    }
+    return "new Set";
+}
+
+function serializeMap(obj, ctx) {
+    const varName = ctx.refs.get(obj);
+    if (obj.size) {
+        if (varName) {
+            return `(${varName}=new Map,${varName}` + Array.from(obj).map((([k, v]) => `.set(${serializeAny(k, ctx)},${serializeAny(v, ctx)})`)).join("") + ")";
+        }
+        return "new Map(" + serializeAny(Array.from(obj), ctx) + ")";
+    }
+    if (varName) {
+        return `${varName}=new Map`;
+    }
+    return "new Map";
+}
+
+function serializeDate(obj, ctx) {
+    if (ctx.opts.compact) {
+        return `new Date(${obj.valueOf()})`;
+    }
+    const parts = [ obj.getUTCFullYear(), obj.getUTCMonth(), obj.getUTCDate() ];
+    if (+obj % 864e5 !== 0) {
+        parts.push(obj.getUTCHours(), obj.getUTCMinutes(), obj.getUTCSeconds());
+        const ms = obj.getUTCMilliseconds();
+        if (ms) {
+            parts.push(ms);
+        }
+    }
+    return `new Date(Date.UTC(${parts.join(",")}))`;
+}
+
+function wrapSimpleRef(serialize) {
+    return (obj, ctx) => {
+        const js = serialize(obj, ctx);
+        const varName = ctx.refs.get(obj);
+        if (varName) {
+            ctx.seen.add(obj);
+            return `${varName}=${js}`;
+        }
+        return js;
+    };
+}
+
+function serializeAnySymbol(obj, ctx) {
+    if (!wellKnownSymbols) {
+        wellKnownSymbols = new Map(Object.getOwnPropertyNames(Symbol).filter((k => isSymbol(Symbol[k]))).map((k => [ Symbol[k], k ])));
+    }
+    let symbolName = wellKnownSymbols.get(obj);
+    if (symbolName) {
+        return `Symbol.${symbolName}`;
+    }
+    return serializeSymbol(obj, ctx);
+}
+
+function serializeNativeFunction(obj, ctx) {
+    let cachedPath = nativeFuncs.get(obj);
+    if (cachedPath !== undefined) {
+        return cachedPath;
+    }
+    const foundPath = findFunction(global, obj);
+    if (foundPath === null) {
+        throw new Error(`Could not determine fully-qualified name of native function '${obj.name}'`);
+    }
+    const joinedPath = foundPath.join(".");
+    nativeFuncs.set(obj, joinedPath);
+    return joinedPath;
+}
+
+function serializeNonNativeFunction(obj, ctx) {
+    return obj.toString();
+}
+
+function serializeAnyFunction(obj, ctx) {
+    if (/\{\s*\[native code]\s*}$/.test(obj.toString())) {
+        return serializeNativeFunction(obj);
+    }
+    return serializeNonNativeFunction(obj);
+}
+
+function serializeBoolean(obj, ctx) {
+    if (obj) {
+        return ctx.opts.compact ? "!0" : "true";
+    }
+    return ctx.opts.compact ? "!1" : "false";
+}
+
+function serializeRegExp(obj, ctx) {
+    return obj.toString();
+}
+
+function serializeUndefined(obj, ctx) {
+    return ctx.opts.compact ? "void 0" : "undefined";
+}
+
+function serializeNull(obj, ctx) {
+    return "null";
+}
+
+function maybeFreeze(obj, js) {
+    if (Object.isFrozen(obj)) {
+        return `Object.freeze(${js})`;
+    }
+    if (Object.isSealed(obj)) {
+        return `Object.seal(${js})`;
+    }
+    if (!Object.isExtensible(obj)) {
+        return `Object.preventExtensions(${js})`;
+    }
+    return js;
+}
+
+function serializeAnyObject(obj, ctx) {
+    const tmp = serializeObject(obj, ctx);
+    const name = ctx.refs.get(obj);
+    if (name) {
+        if (Reflect.ownKeys(obj).length) {
+            return `(${name}={},${maybeFreeze(obj, `Object.assign(${name},${tmp})`)})`;
+        }
+        return `${name}=${maybeFreeze(obj, "{}")}`;
+    }
+    return maybeFreeze(obj, tmp);
+}
+
+function serializeAny(obj, ctx) {
+    if (ctx.seen.has(obj) && ctx.refs.has(obj)) {
+        return ctx.refs.get(obj);
+    }
+    if (isArray(obj)) {
+        ctx.seen.add(obj);
+        return serializeArray(obj, ctx);
+    }
+    if (obj instanceof Set) {
+        ctx.seen.add(obj);
+        return serializeSet(obj, ctx);
+    }
+    if (obj instanceof Map) {
+        ctx.seen.add(obj);
+        return serializeMap(obj, ctx);
+    }
+    if (obj instanceof Date) {
+        return wrapSimpleRef(serializeDate)(obj, ctx);
+    }
+    if (isSymbol(obj)) {
+        return wrapSimpleRef(serializeAnySymbol)(obj, ctx);
+    }
+    if (isFunction(obj)) {
+        return wrapSimpleRef(serializeAnyFunction)(obj, ctx);
+    }
+    if (isRegExp(obj)) {
+        return wrapSimpleRef(serializeRegExp)(obj, ctx);
+    }
+    if (isNumberLike(obj)) {
+        return serializeNumberLike(obj, ctx);
+    }
+    if (isBigInt(obj)) {
+        return serializeBigInt(obj, ctx);
+    }
+    if (isBoolean(obj)) {
+        return serializeBoolean(obj, ctx);
+    }
+    if (isStringLike(obj)) {
+        return serializeStringLike(obj, ctx);
+    }
+    if (obj === undefined) {
+        return serializeUndefined(obj, ctx);
+    }
+    if (obj === null) {
+        return serializeNull();
+    }
+    if (isObject(obj)) {
+        ctx.seen.add(obj);
+        return serializeAnyObject(obj, ctx);
+    }
+    throw new Error("Could not serialize unknown type");
+}
+
+function serializeNumberLike(obj, ctx) {
+    const tmp = serializeNumber(Number(obj), ctx);
+    if (obj instanceof Number) {
+        return `new Number(${tmp})`;
+    }
+    return tmp;
+}
+
+function serializeNumber(obj, ctx) {
+    switch (obj) {
+      case Math.E:
+        return "Math.E";
+
+      case Math.LN2:
+        return "Math.LN2";
+
+      case Math.LN10:
+        return "Math.LN10";
+
+      case Math.LOG2E:
+        return "Math.LOG2E";
+
+      case Math.PI:
+        return "Math.PI";
+
+      case Math.SQRT1_2:
+        return "Math.SQRT1_2";
+
+      case Math.SQRT2:
+        return "Math.SQRT2";
+
+      case Number.EPSILON:
+        return "Number.EPSILON";
+
+      case Infinity:
+        return ctx.opts.compact ? "1/0" : "Infinity";
+
+      case -Infinity:
+        return ctx.opts.compact ? "1/-0" : "-Infinity";
+    }
+    if (isNegativeZero(obj)) return "-0";
+    if (ctx.opts.compact && Number.isInteger(obj) && obj >= 1e12) {
+        return "0x" + obj.toString(16);
+    }
+    return String(obj);
+}
+
+function serializeBigInt(obj, ctx) {
+    if (ctx.opts.compact && obj >= 1000000000000n) {
+        return "0x" + obj.toString(16) + "n";
+    }
+    return `${obj}n`;
+}
+
+function serializeStringLike(obj, ctx) {
+    const js = doSerializeStringLike(obj, ctx);
+    if (obj.length >= STRING_REF_MIN_LENGTH) {
+        const varName = ctx.refs.get(obj);
+        if (varName) {
+            ctx.seen.add(obj);
+            return `${varName}=${js}`;
+        }
+    }
+    return js;
+}
+
+function doSerializeStringLike(obj, ctx) {
+    const tmp = serializeString(String(obj), ctx);
+    if (obj instanceof String) {
+        return `new String(${tmp})`;
+    }
+    return tmp;
+}
+
+function serializeString(obj, ctx) {
+    return '"' + Array.from(obj).map((ch => {
+        const cp = ch.codePointAt(0);
+        switch (cp) {
+          case 8:
+            return "\\b";
+
+          case 12:
+            return "\\f";
+
+          case 10:
+            return "\\n";
+
+          case 13:
+            return "\\r";
+
+          case 9:
+            return "\\t";
+
+          case 11:
+            return ctx.opts.safe ? "\\x0B" : "\\v";
+
+          case 34:
+            return '\\"';
+
+          case 92:
+            return "\\\\";
+        }
+        if (cp >= 32 && cp <= 126) {
+            return ch;
+        }
+        if (cp <= 255) {
+            return "\\x" + cp.toString(16).padStart(2, "0");
+        }
+        if (cp <= 65535) {
+            return "\\u" + cp.toString(16).padStart(4, "0");
+        }
+        return "\\u{" + cp.toString(16) + "}";
+    })).join("") + '"';
+}
+
+function serializeObject(obj, ctx) {
+    if (obj[isRaw]) {
+        return obj.value;
+    }
+    if (isFunction(obj.toSource)) {
+        return obj.toSource();
+    }
+    if (isFunction(obj.toJSON)) {
+        return serializeAny(obj.toJSON(), ctx);
+    }
+    return serializePlainObject(obj, ctx);
+}
+
+function serializePlainObject(obj, ctx) {
+    let tmp = [];
+    for (let key of Reflect.ownKeys(obj)) {
+        tmp.push(serializePropertyName(key, ctx) + ":" + serializeAny(obj[key], ctx));
+    }
+    return "{" + tmp.join(",") + "}";
+}
+
+jsSerialize.raw = function raw(jsCode) {
+    return Object.create({
+        [isRaw]: true,
+        value: jsCode
+    });
+};
+
+function serializeSymbol(sym, ctx) {
+    let key = Symbol.keyFor(sym);
+    if (key === undefined) {
+        let m = sym.toString().match(/^Symbol\((.+)\)$/);
+        if (m) {
+            return `Symbol(${serializeString(m[1], ctx)})`;
+        }
+        return `Symbol()`;
+    } else {
+        return `Symbol.for(${serializeString(key, ctx)})`;
+    }
+}
+
+var keywords = new Set([ "do", "if", "in", "for", "let", "new", "try", "var", "case", "else", "enum", "eval", "false", "null", "this", "true", "void", "with", "break", "catch", "class", "const", "super", "throw", "while", "yield", "delete", "export", "import", "public", "return", "static", "switch", "typeof", "default", "extends", "finally", "package", "private", "continue", "debugger", "function", "arguments", "interface", "protected", "implements", "instanceof" ]);
+
+var propName = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
+
+function isSafePropName(name, ctx) {
+    return (!ctx.opts.safe || !keywords.has(name)) && propName.test(name);
+}
+
+function serializePropertyName(name, ctx) {
+    if (isSymbol(name)) {
+        return "[" + serializeSymbol(name, ctx) + "]";
+    }
+    if (isStringLike(name)) {
+        if (isSafePropName(name, ctx)) {
+            return name;
+        }
+        return serializeString(name, ctx);
+    }
+    throw new Error(`Cannot make property name`);
+}
+
+var src_default = jsSerialize;
+
 function mapIter(iterable, cb) {
     const out = [];
     let i = 0;
@@ -1533,7 +2139,7 @@ function scriptChild(el) {
     if (isJsxNode(el)) {
         throw new Error(`<script> cannot contain JSX nodes.`);
     }
-    return JSON.stringify(el);
+    return src_default(el);
 }
 
 function styleChild(el) {
@@ -1544,19 +2150,19 @@ function styleChild(el) {
         return "";
     }
     if (isJsxNode(el)) {
-        throw new Error(`<sty;e> cannot contain JSX nodes.`);
+        throw new Error(`<style> cannot contain JSX nodes.`);
     }
-    return CSS.escape(String(el));
+    return cssEscape(String(el));
 }
 
 function flattenChildren(children, callback) {
     return Array.isArray(children) ? children.map(callback).join("") : callback(children);
 }
 
-const isJsxComponent = isFunction;
+const isJsxComponent = isFunction$1;
 
 function isHtmlSafe(x) {
-    return isPlainObject(x) && isString(x.__html);
+    return isPlainObject(x) && isString$1(x.__html);
 }
 
 function render(el) {
@@ -1569,7 +2175,7 @@ function render(el) {
     if (isHtmlSafe(el)) {
         return el.__html;
     }
-    if (isString(el)) {
+    if (isString$1(el)) {
         return htmlContent(el);
     }
     if (isNumber(el)) {
@@ -1578,7 +2184,7 @@ function render(el) {
     if (Array.isArray(el)) {
         return el.map((x => render(x))).join("");
     }
-    if (isFunction(el)) {
+    if (isFunction$1(el)) {
         return render(el());
     }
     if (isIterable(el)) {
@@ -1587,6 +2193,37 @@ function render(el) {
     throw new Error(`Unsupported type: ${getStringTag(el)}`);
 }
 
+class JsFrag {
+    str;
+    constructor(str) {
+        this.str = str;
+    }
+    toString() {
+        return this.str;
+    }
+}
+
+function escapeJs(obj) {
+    if (obj instanceof JsFrag) {
+        return obj;
+    }
+    return src_default(obj);
+}
+
+function js(strings, ...values) {
+    return new JsFrag(strings.reduce(((out, str, i) => out + str + (i < values.length ? escapeJs(values[i]) : "")), ""));
+}
+
+class CssFrag {
+    str;
+    constructor(str) {
+        this.str = str;
+    }
+    toString() {
+        return this.str;
+    }
+}
+
 const voidElements = new Set([ "area", "base", "br", "col", "command", "embed", "hr", "img", "input", "keygen", "link", "meta", "param", "source", "track", "wbr" ]);
 
 class JsxElement extends JsxNode {
@@ -1615,10 +2252,10 @@ class JsxElement extends JsxNode {
             return `<${tag}${attrs$1}></${tag}>`;
         }
         if (normalizedTagName === "script") {
-            return `<${tag}${attrs$1}>${escapeScript(flattenChildren(children, scriptChild))}</${tag}>`;
+            return `<${tag}${attrs$1}>${escapeScript(children instanceof JsFrag ? children.toString() : flattenChildren(children, scriptChild))}</${tag}>`;
         }
         if (normalizedTagName === "style") {
-            return `<${tag}${attrs$1}>${escapeStyle(flattenChildren(children, styleChild))}</${tag}>`;
+            return `<${tag}${attrs$1}>${escapeStyle(children instanceof CssFrag ? children.toString() : flattenChildren(children, styleChild))}</${tag}>`;
         }
         return `<${tag}${attrs$1}>${flattenChildren(children, render)}</${tag}>`;
     }
@@ -1691,6 +2328,8 @@ class JsxFragment extends JsxNode {
     }
 }
 
+const JSX = {};
+
 function jsx(tag, props, key, isStaticChildren, source, self) {
     if (isJsxComponent(tag)) {
         const node = tag(props);
@@ -1717,6 +2356,8 @@ exports.EMPTY = EMPTY;
 
 exports.Fragment = Fragment;
 
+exports.JSX = JSX;
+
 exports.JsxComment = JsxComment;
 
 exports.JsxDocType = JsxDocType;
@@ -1737,6 +2378,8 @@ exports.isJsxComponent = isJsxComponent;
 
 exports.isJsxNode = isJsxNode;
 
+exports.js = js;
+
 exports.jsx = jsx;
 
 exports.jsxs = jsxs;