@mpen/jsxhtml 0.2.2 → 0.4.0

package/dist/{jsx-runtime-CsQM2fQb.js → jsx-runtime-DlHYwToA.js}

@@ -1316,29 +1316,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) {
@@ -1349,7 +1363,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");
 }
 
@@ -1359,7 +1373,7 @@ function isPlainObject(obj) {
     return proto === null || proto === Object.prototype;
 }
 
-function isString(obj) {
+function isString$1(obj) {
     return typeof obj === "string";
 }
 
@@ -1414,7 +1428,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) {
@@ -1426,15 +1440,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) {
@@ -1443,8 +1457,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);
@@ -1454,7 +1468,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("");
@@ -1482,6 +1496,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;
@@ -1531,7 +2137,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) {
@@ -1542,19 +2148,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) {
@@ -1567,7 +2173,7 @@ function render(el) {
     if (isHtmlSafe(el)) {
         return el.__html;
     }
-    if (isString(el)) {
+    if (isString$1(el)) {
         return htmlContent(el);
     }
     if (isNumber(el)) {
@@ -1576,7 +2182,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)) {
@@ -1585,6 +2191,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 {
@@ -1613,10 +2250,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}>`;
     }
@@ -1689,6 +2326,8 @@ class JsxFragment extends JsxNode {
     }
 }
 
+const JSX = {};
+
 function jsx(tag, props, key, isStaticChildren, source, self) {
     if (isJsxComponent(tag)) {
         const node = tag(props);
@@ -1711,4 +2350,4 @@ function Fragment({children}) {
     return new JsxFragment(children);
 }
 
-export { EMPTY as E, Fragment as F, JsxRawHtml as J, JsxDocType as a, jsx as b, JsxElement as c, JsxComment as d, JsxEmpty as e, flattenString as f, JsxFragment as g, JsxNode as h, isJsxNode as i, jsxs as j, isJsxComponent as k };
+export { EMPTY as E, Fragment as F, JsxDocType as J, jsxs as a, JsxRawHtml as b, js as c, JsxElement as d, JsxComment as e, flattenString as f, JsxEmpty as g, JsxFragment as h, isJsxNode as i, jsx as j, JsxNode as k, isJsxComponent as l, JSX as m };