@jxsuite/runtime 0.28.2 → 0.28.4

package/dist/runtime.js

@@ -1,4 +1,4 @@
-// ../../node_modules/.bun/@vue+shared@3.5.35/node_modules/@vue/shared/dist/shared.esm-bundler.js
+// ../../node_modules/.bun/@vue+shared@3.5.38/node_modules/@vue/shared/dist/shared.esm-bundler.js
 function makeMap(str) {
   const map = /* @__PURE__ */ Object.create(null);
   for (const key of str.split(","))
@@ -46,7 +46,7 @@ var hasChanged = (value, oldValue) => !Object.is(value, oldValue);
 var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
 var isBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
 
-// ../../node_modules/.bun/@vue+reactivity@3.5.35/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+// ../../node_modules/.bun/@vue+reactivity@3.5.38/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
 function warn(msg, ...args) {
   console.warn(`[Vue warn] ${msg}`, ...args);
 }
@@ -1259,6 +1259,10 @@ function computed(getterOrOptions, debugOptions, isSSR = false) {
 }
 
 // src/expression.ts
+function scopeMap(state) {
+  const map = state.$map;
+  return map && typeof map === "object" ? map : undefined;
+}
 var MUTATING_OPS = new Set([
   "=",
   "+=",
@@ -1300,8 +1304,9 @@ function isMutating(op) {
   return MUTATING_OPS.has(op);
 }
 function resolveOperand(operand, state, event, iterCtx) {
-  if (operand === null || operand === undefined)
+  if (operand === null || operand === undefined) {
     return operand;
+  }
   if (typeof operand === "object" && !Array.isArray(operand) && "operator" in operand) {
     return evaluateExpression(operand, state, event, iterCtx);
   }
@@ -1326,66 +1331,76 @@ function resolveExprRef(ref2, state, event, iterCtx) {
   }
   if (ref2.startsWith("$map/")) {
     const parts = ref2.split("/");
-    const key = parts[1];
+    const [, key] = parts;
     let base;
-    if (key === "item")
-      base = iterCtx?.item ?? state.$map?.item ?? state["$map/item"];
-    else if (key === "index")
-      base = iterCtx?.index ?? state.$map?.index ?? state["$map/index"];
-    else
-      base = state.$map?.[key] ?? state["$map/" + key];
+    const map = scopeMap(state);
+    if (key === "item") {
+      base = iterCtx?.item ?? map?.item ?? state["$map/item"];
+    } else if (key === "index") {
+      base = iterCtx?.index ?? map?.index ?? state["$map/index"];
+    } else {
+      base = map?.[key] ?? state[`$map/${key}`];
+    }
     return parts.length > 2 ? getPath(base, parts.slice(2).join("/")) : base;
   }
   if (ref2.startsWith("#/state/")) {
     const sub = ref2.slice("#/state/".length);
     const slash = sub.indexOf("/");
-    if (slash < 0)
+    if (slash === -1) {
       return state[sub];
+    }
     return getPath(state[sub.slice(0, slash)], sub.slice(slash + 1));
   }
-  if (ref2.startsWith("parent#/"))
+  if (ref2.startsWith("parent#/")) {
     return state[ref2.slice("parent#/".length)];
-  if (ref2.startsWith("window#/"))
+  }
+  if (ref2.startsWith("window#/")) {
     return getPath(globalThis.window, ref2.slice("window#/".length));
-  if (ref2.startsWith("document#/"))
+  }
+  if (ref2.startsWith("document#/")) {
     return getPath(globalThis.document, ref2.slice("document#/".length));
+  }
   return state[ref2] ?? null;
 }
 function resolveWritableRef(ref2, state, event, iterCtx) {
   if (ref2.startsWith("$map/")) {
     const parts = ref2.split("/");
-    const key = parts[1];
+    const [, key] = parts;
     let base;
-    if (key === "item")
-      base = iterCtx?.item ?? state.$map?.item ?? state["$map/item"];
-    else if (key === "index")
-      base = iterCtx?.index ?? state.$map?.index ?? state["$map/index"];
-    else
-      base = state.$map?.[key] ?? state["$map/" + key];
+    const map = scopeMap(state);
+    if (key === "item") {
+      base = iterCtx?.item ?? map?.item ?? state["$map/item"];
+    } else if (key === "index") {
+      base = iterCtx?.index ?? map?.index ?? state["$map/index"];
+    } else {
+      base = map?.[key] ?? state[`$map/${key}`];
+    }
     if (parts.length > 2) {
       const pathParts = parts.slice(2);
       const lastKey = pathParts.pop();
       const obj = pathParts.length > 0 ? getPath(base, pathParts.join("/")) : base;
-      return { obj, key: lastKey };
+      return { key: lastKey, obj };
     }
     return {
-      obj: state.$map ?? state,
-      key: key === "item" ? "$map/item" : "$map/index"
+      key: key === "item" ? "$map/item" : "$map/index",
+      obj: scopeMap(state) ?? state
     };
   }
   if (ref2.startsWith("#/state/")) {
     const sub = ref2.slice("#/state/".length);
     const slash = sub.indexOf("/");
-    if (slash < 0)
-      return { obj: state, key: sub };
+    if (slash === -1) {
+      return { key: sub, obj: state };
+    }
     const parts = sub.split("/");
     const lastKey = parts.pop();
     let obj = state;
-    for (const p of parts)
+    for (const p of parts) {
       obj = obj[p];
-    return { obj, key: lastKey };
+    }
+    return { key: lastKey, obj };
   }
-  return { obj: state, key: ref2 };
+  return { key: ref2, obj: state };
 }
 function evaluateExpression(node, state, event, iterCtx) {
   const { operator, target, value, initial } = node;
@@ -1394,117 +1409,200 @@ function evaluateExpression(node, state, event, iterCtx) {
   }
   if (UNARY_OPS.has(operator) && !("value" in node)) {
     const operand = resolveOperand(target, state, event, iterCtx);
-    if (operator === "!")
+    if (operator === "!") {
       return !operand;
-    if (operator === "-")
+    }
+    if (operator === "-") {
       return -operand;
+    }
   }
   if (BINARY_OPS.has(operator)) {
     const left = resolveOperand(target, state, event, iterCtx);
     const right = resolveOperand(value, state, event, iterCtx);
     switch (operator) {
-      case "+":
+      case "+": {
         return left + right;
-      case "-":
+      }
+      case "-": {
         return left - right;
-      case "*":
+      }
+      case "*": {
         return left * right;
-      case "/":
+      }
+      case "/": {
         return left / right;
-      case "%":
+      }
+      case "%": {
         return left % right;
-      case "===":
+      }
+      case "===": {
         return left === right;
-      case "!==":
+      }
+      case "!==": {
         return left !== right;
-      case "<":
+      }
+      case "<": {
         return left < right;
-      case "<=":
+      }
+      case "<=": {
         return left <= right;
-      case ">":
+      }
+      case ">": {
         return left > right;
-      case ">=":
+      }
+      case ">=": {
         return left >= right;
-      case "&&":
+      }
+      case "&&": {
         return left && right;
-      case "||":
+      }
+      case "||": {
         return left || right;
+      }
+      default: {
+        break;
+      }
     }
   }
   if (ASSIGNMENT_OPS.has(operator)) {
     const rhs = resolveOperand(value, state, event, iterCtx);
     const { obj, key } = resolveWritableRef(target.$ref, state, event, iterCtx);
     switch (operator) {
-      case "=":
+      case "=": {
         obj[key] = rhs;
         break;
-      case "+=":
-        obj[key] += rhs;
+      }
+      case "+=": {
+        const current = obj[key];
+        obj[key] = current + rhs;
         break;
-      case "-=":
-        obj[key] -= rhs;
+      }
+      case "-=": {
+        const current = obj[key];
+        obj[key] = current - rhs;
         break;
-      case "*=":
-        obj[key] *= rhs;
+      }
+      case "*=": {
+        const current = obj[key];
+        obj[key] = current * rhs;
         break;
-      case "/=":
-        obj[key] /= rhs;
+      }
+      case "/=": {
+        const current = obj[key];
+        obj[key] = current / rhs;
         break;
+      }
+      default: {
+        break;
+      }
     }
     return;
   }
   if (ARRAY_METHOD_OPS.has(operator)) {
     const arr = resolveOperand(target, state, event, iterCtx);
     switch (operator) {
-      case "push":
+      case "push": {
         return arr.push(resolveOperand(value, state, event, iterCtx));
-      case "unshift":
+      }
+      case "unshift": {
         return arr.unshift(resolveOperand(value, state, event, iterCtx));
-      case "pop":
+      }
+      case "pop": {
         return arr.pop();
-      case "shift":
+      }
+      case "shift": {
         return arr.shift();
+      }
       case "splice": {
         const args = resolveOperand(value, state, event, iterCtx);
         return arr.splice(...args);
       }
+      default: {
+        break;
+      }
     }
   }
   if (AGGREGATE_OPS.has(operator)) {
     const arr = resolveOperand(target, state, event, iterCtx);
     if (operator === "reduce") {
-      const seed = resolveOperand(initial, state, event, iterCtx);
-      return arr.reduce((acc, item, index) => {
-        return evaluateExpression(value, state, event, {
+      let acc = resolveOperand(initial, state, event, iterCtx);
+      for (const [index, item] of arr.entries()) {
+        acc = evaluateExpression(value, state, event, {
           acc,
-          item,
-          index
+          index,
+          item
         });
-      }, seed);
+      }
+      return acc;
     }
     if (operator === "map") {
-      return arr.map((item, index) => {
-        return evaluateExpression(value, state, event, {
-          ...iterCtx,
-          item,
-          index
-        });
-      });
+      return arr.map((item, index) => evaluateExpression(value, state, event, {
+        ...iterCtx,
+        index,
+        item
+      }));
     }
     if (operator === "filter") {
-      return arr.filter((item, index) => {
-        return evaluateExpression(value, state, event, {
-          ...iterCtx,
-          item,
-          index
-        });
-      });
+      return arr.filter((item, index) => evaluateExpression(value, state, event, {
+        ...iterCtx,
+        index,
+        item
+      }));
     }
   }
   return;
 }
 function getPath(obj, path) {
-  return path.split(/[./]/).reduce((o, k) => o?.[k], obj);
+  let current = obj;
+  for (const k of path.split(/[./]/)) {
+    current = current?.[k];
+  }
+  return current;
+}
+
+// ../schema/src/guards.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRef2(value) {
+  return isJsonObject(value) && typeof value.$ref === "string";
+}
+function isFunctionDef(value) {
+  return isJsonObject(value) && value.$prototype === "Function";
+}
+function isExpressionDef(value) {
+  return isJsonObject(value) && isJsonObject(value.$expression);
+}
+function isPrototypeDef(value) {
+  return isJsonObject(value) && typeof value.$prototype === "string" && value.$prototype !== "Function";
+}
+function isServerFnDef(value) {
+  return isJsonObject(value) && value.timing === "server" && typeof value.$src === "string" && typeof value.$export === "string" && !value.$prototype;
+}
+var SCHEMA_KEYWORDS = new Set([
+  "type",
+  "enum",
+  "minimum",
+  "maximum",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "format",
+  "items",
+  "properties",
+  "required",
+  "description",
+  "title",
+  "$comment"
+]);
+function isMappedArray(value) {
+  return isJsonObject(value) && value.$prototype === "Array";
+}
+function paramNames(parameters) {
+  if (!parameters) {
+    return [];
+  }
+  return parameters.map((p) => typeof p === "string" ? p : p.name);
 }
 
 // src/runtime.ts
@@ -1521,26 +1619,30 @@ async function Jx(source, target = document.body, options) {
     _rootMedia = doc.$media;
   }
   const state = await buildScope(doc, {}, base);
-  target.appendChild(renderNode(doc, state, options));
-  if (typeof state.onMount === "function")
+  target.append(renderNode(doc, state, options));
+  if (typeof state.onMount === "function") {
     state.onMount(state);
+  }
   return state;
 }
 var _resolveCache = new Map;
 async function resolve(source) {
-  if (typeof source !== "string")
+  if (typeof source !== "string") {
     return source;
-  if (_resolveCache.has(source))
+  }
+  if (_resolveCache.has(source)) {
     return _resolveCache.get(source);
+  }
   const p = fetch(source).then((res) => {
-    if (!res.ok)
+    if (!res.ok) {
       throw new Error(`Jx: failed to fetch ${source} (${res.status})`);
+    }
     return res.json();
   });
   _resolveCache.set(source, p);
   return p;
 }
-var SCHEMA_KEYWORDS = new Set([
+var SCHEMA_KEYWORDS2 = new Set([
   "type",
   "properties",
   "items",
@@ -1566,10 +1668,10 @@ async function buildScope(doc, parentScope = {}, base = location.href) {
   const defs = doc.state ?? {};
   const imports = doc.imports ?? {};
   for (const [, def2] of Object.entries(defs)) {
-    if (def2 && typeof def2 === "object" && !Array.isArray(def2) && def2.$prototype && def2.$prototype !== "Function" && !def2.$src) {
+    if (isPrototypeDef(def2) && !def2.$src) {
       const mapped = imports[def2.$prototype];
       if (mapped) {
-        if (typeof mapped !== "string" || !mapped.endsWith(".class.json")) {
+        if (!mapped.endsWith(".class.json")) {
           console.warn(`Jx: import "${def2.$prototype}" must map to a .class.json path, got "${mapped}"`);
           continue;
         }
@@ -1579,8 +1681,9 @@ async function buildScope(doc, parentScope = {}, base = location.href) {
   }
   for (const [key, def2] of Object.entries(defs)) {
     if (typeof def2 === "string") {
-      if (!def2.includes("${"))
+      if (!def2.includes("${")) {
         raw[key] = def2;
+      }
       continue;
     }
     if (typeof def2 === "number" || typeof def2 === "boolean" || def2 === null) {
@@ -1592,19 +1695,22 @@ async function buildScope(doc, parentScope = {}, base = location.href) {
       continue;
     }
     if (typeof def2 === "object") {
-      const d = def2;
-      if (d.$prototype)
+      if (def2.$prototype) {
         continue;
-      if ("$expression" in d)
+      }
+      if (isExpressionDef(def2)) {
         continue;
-      if (d.timing === "server" && d.$src && d.$export)
+      }
+      if (isServerFnDef(def2)) {
         continue;
-      if ("default" in d) {
-        raw[key] = d.default;
+      }
+      if ("default" in def2) {
+        raw[key] = def2.default;
         continue;
       }
-      if (hasSchemaKeywords(d))
+      if (hasSchemaKeywords(def2)) {
         continue;
+      }
       raw[key] = def2;
     }
   }
@@ -1615,28 +1721,29 @@ async function buildScope(doc, parentScope = {}, base = location.href) {
     }
   }
   for (const [key, def2] of Object.entries(defs)) {
-    if (def2 && typeof def2 === "object" && !Array.isArray(def2) && "$expression" in def2) {
+    if (isExpressionDef(def2)) {
       const node = def2.$expression;
       if (isMutating(node.operator)) {
-        state[key] = (s, event) => evaluateExpression(node, s, event);
+        const handler = (s, event) => evaluateExpression(node, s, event);
+        state[key] = handler;
       } else {
         state[key] = computed(() => evaluateExpression(node, state, null));
       }
     }
   }
   for (const [key, def2] of Object.entries(defs)) {
-    if (typeof def2 === "object" && def2?.$prototype === "Function") {
+    if (isFunctionDef(def2)) {
       state[key] = await resolveFunction(def2, state, key, base);
     }
   }
   for (const [key, def2] of Object.entries(defs)) {
-    if (typeof def2 === "object" && def2?.$prototype && def2.$prototype !== "Function") {
+    if (isPrototypeDef(def2)) {
       state[key] = await resolvePrototype(def2, state, key, base);
     }
   }
   if (!_serverFnConfig.skip) {
     for (const [key, def2] of Object.entries(defs)) {
-      if (def2 != null && typeof def2 === "object" && def2.timing === "server" && def2.$src && def2.$export && !def2.$prototype) {
+      if (isServerFnDef(def2)) {
         state[key] = await resolveServerFunction(def2, state, key, base);
       }
     }
@@ -1650,8 +1757,9 @@ async function buildScope(doc, parentScope = {}, base = location.href) {
 }
 function hasSchemaKeywords(obj) {
   for (const k of Object.keys(obj)) {
-    if (SCHEMA_KEYWORDS.has(k))
+    if (SCHEMA_KEYWORDS2.has(k)) {
       return true;
+    }
   }
   return false;
 }
@@ -1669,8 +1777,8 @@ async function resolveFunction(def2, state, key, base) {
     const params = resolveParamNames(def2);
     const noop = new Function(...params, "");
     Object.defineProperty(noop, "name", {
-      value: def2.name ?? key,
-      configurable: true
+      configurable: true,
+      value: def2.name ?? key
     });
     return noop;
   }
@@ -1679,11 +1787,14 @@ async function resolveFunction(def2, state, key, base) {
     const params = resolveParamNames(def2);
     fn = new Function(...params, def2.body);
     Object.defineProperty(fn, "name", {
-      value: def2.name ?? key,
-      configurable: true
+      configurable: true,
+      value: def2.name ?? key
     });
   } else {
     const src = def2.$src;
+    if (!src) {
+      throw new Error(`Jx: '${key}' has neither body nor $src`);
+    }
     const exportName = def2.$export ?? key;
     let mod;
     if (_moduleCache.has(src)) {
@@ -1703,7 +1814,7 @@ async function resolveFunction(def2, state, key, base) {
     }
     fn = mod[exportName] ?? mod.default?.[exportName];
     if (typeof fn !== "function") {
-      throw new Error(`Jx: export "${exportName}" not found or not a function in "${src}"`);
+      throw new TypeError(`Jx: export "${exportName}" not found or not a function in "${src}"`);
     }
   }
   const hasParams = (def2.parameters ?? def2.arguments ?? []).length > 0;
@@ -1721,13 +1832,7 @@ async function resolveFunction(def2, state, key, base) {
   return fn;
 }
 function resolveParamNames(def2) {
-  const raw = def2.parameters ?? def2.arguments ?? [];
-  let names;
-  if (Array.isArray(raw) && raw.length > 0 && typeof raw[0] === "object") {
-    names = raw.map((p) => p.name ?? p.identifier ?? "arg");
-  } else {
-    names = raw;
-  }
+  const names = def2.parameters ? paramNames(def2.parameters) : def2.arguments ?? [];
   return names.length > 0 && names[0] === "state" ? names : ["state", ...names];
 }
 var RESERVED_KEYS = new Set([
@@ -1778,8 +1883,9 @@ function renderNode(def2, state, options) {
   let localState = state;
   for (const [key, val] of Object.entries(def2)) {
     if (key.startsWith("$") && !RESERVED_KEYS.has(key)) {
-      if (localState === state)
+      if (localState === state) {
         localState = Object.create(state);
+      }
       localState[key] = isRefObj(val) ? resolveRef(val.$ref, state) : val;
     }
   }
@@ -1792,20 +1898,23 @@ function renderNode(def2, state, options) {
     const { $props: _$props, ...rest } = def2;
     return renderNode(rest, mergeProps(def2, localState), options);
   }
-  if (def2.$switch)
+  if (def2.$switch) {
     return renderSwitch(def2, localState, options);
-  if (def2.children?.$prototype === "Array")
-    return renderMappedArray(def2, localState, options);
+  }
+  if (isMappedArray(def2.children)) {
+    return renderMappedArray(def2, def2.children, localState, options);
+  }
   const el = document.createElement(tagName);
-  if (options?.onNodeCreated)
+  if (options?.onNodeCreated) {
     options.onNodeCreated(el, path, def2);
+  }
   applyProperties(el, def2, localState);
   applyStyle(el, def2.style ?? {}, localState["$media"] ?? {}, localState);
   applyAttributes(el, def2.attributes ?? {}, localState);
   const children = Array.isArray(def2.children) ? def2.children : [];
   for (let i = 0;i < children.length; i++) {
     const childOpts = options ? { ...options, _path: [...path, "children", i] } : undefined;
-    el.appendChild(renderNode(children[i], localState, childOpts));
+    el.append(renderNode(children[i], localState, childOpts));
   }
   return el;
 }
@@ -1814,10 +1923,12 @@ function isTemplateString(val) {
 }
 function applyProperties(el, def2, state) {
   for (const [key, val] of Object.entries(def2)) {
-    if (RESERVED_KEYS.has(key))
+    if (RESERVED_KEYS.has(key)) {
       continue;
-    if (key.startsWith("$"))
+    }
+    if (key.startsWith("$")) {
       continue;
+    }
     if (key.startsWith("on")) {
       if (isRefObj(val)) {
         const handler = resolveRef(val.$ref, state);
@@ -1827,14 +1938,14 @@ function applyProperties(el, def2, state) {
         }
         continue;
       }
-      if (val && typeof val === "object" && val.$prototype === "Function" && val.body) {
+      if (isFunctionDef(val) && val.body) {
         const params = resolveParamNames(val);
         const fn = new Function(...params, val.body);
         const scope = state;
         el.addEventListener(key.slice(2), (e) => fn(scope, e));
         continue;
       }
-      if (val && typeof val === "object" && "$expression" in val) {
+      if (isExpressionDef(val)) {
         const node = val.$expression;
         const scope = state;
         el.addEventListener(key.slice(2), (e) => evaluateExpression(node, scope, e));
@@ -1880,50 +1991,66 @@ function applyStyle(el, styleDef, mediaQueries = {}, state = {}) {
     }
   }
   for (const [prop, val] of Object.entries(styleDef)) {
-    if (prop.startsWith("@"))
-      media[prop] = val;
-    else if (isNestedSelector(prop))
-      nested[prop] = val;
-    else if (val !== null && typeof val === "object" && !Array.isArray(val))
-      nested[prop] = val;
-    else if (prop.startsWith("--")) {
-      if (isTemplateString(val))
+    if (val !== null && typeof val === "object" && !Array.isArray(val)) {
+      if (prop.startsWith("@")) {
+        media[prop] = val;
+      } else {
+        nested[prop] = val;
+      }
+      continue;
+    }
+    if (prop.startsWith("@") || isNestedSelector(prop)) {
+      continue;
+    }
+    if (val === undefined) {
+      continue;
+    }
+    const scalar = String(val);
+    if (prop.startsWith("--")) {
+      if (isTemplateString(val)) {
         effect(() => {
           el.style.setProperty(prop, evaluateTemplate(val, state));
         });
-      else
-        el.style.setProperty(prop, val);
-    } else if (isTemplateString(val))
+      } else {
+        el.style.setProperty(prop, scalar);
+      }
+    } else if (isTemplateString(val)) {
       effect(() => {
         el.style[prop] = evaluateTemplate(val, state);
       });
-    else if (mediaOverriddenProps.has(prop))
-      baseDecls[prop] = val;
-    else
-      el.style[prop] = val;
+    } else if (mediaOverriddenProps.has(prop)) {
+      baseDecls[prop] = scalar;
+    } else {
+      el.style[prop] = scalar;
+    }
   }
   const hasNested = Object.keys(nested).length > 0;
   const hasMedia = Object.keys(media).length > 0;
   const hasBaseDecls = Object.keys(baseDecls).length > 0;
-  if (!hasNested && !hasMedia && !hasBaseDecls)
+  if (!hasNested && !hasMedia && !hasBaseDecls) {
     return;
+  }
   const uid = `jx-${Math.random().toString(36).slice(2, 7)}`;
   el.dataset.jx = uid;
   let css = "";
   const baseCSS = toCSSText(baseDecls);
-  if (baseCSS)
+  if (baseCSS) {
     css += `[data-jx="${uid}"] { ${baseCSS} }
 `;
+  }
   function emitNested(scope, rules) {
     const props = toCSSText(rules);
-    if (props)
+    if (props) {
       css += `${scope} { ${props} }
 `;
+    }
     for (const [sel, sub] of Object.entries(rules)) {
-      if (sub === null || typeof sub !== "object" || Array.isArray(sub))
+      if (sub === null || typeof sub !== "object" || Array.isArray(sub)) {
         continue;
-      if (sel.startsWith("@"))
+      }
+      if (sel.startsWith("@")) {
         continue;
+      }
       const resolved = sel.startsWith("&") ? sel.replace("&", scope) : sel.startsWith("[") ? `${scope}${sel}` : sel.startsWith(":") || sel.startsWith(".") ? `${scope}${sel}` : `${scope} ${sel}`;
       emitNested(resolved, sub);
     }
@@ -1932,32 +2059,36 @@ function applyStyle(el, styleDef, mediaQueries = {}, state = {}) {
     const resolved = sel.startsWith("&") ? sel.replace("&", `[data-jx="${uid}"]`) : sel.startsWith("[") ? `[data-jx="${uid}"]${sel}` : sel.startsWith(":") || sel.startsWith(".") ? `[data-jx="${uid}"]${sel}` : `[data-jx="${uid}"] ${sel}`;
     emitNested(resolved, rules);
   }
-  for (const [key, rules] of Object.entries(media)) {
-    let emitMediaNested = function(parentSel, obj) {
-      for (const [sel, sub] of Object.entries(obj)) {
-        if (sub === null || typeof sub !== "object" || Array.isArray(sub))
-          continue;
-        if (sel.startsWith("@"))
-          continue;
-        const resolved = sel.startsWith("&") ? sel.replace("&", parentSel) : sel.startsWith("[") ? `${parentSel}${sel}` : sel.startsWith(":") || sel.startsWith(".") ? `${parentSel}${sel}` : `${parentSel} ${sel}`;
-        const props = toCSSText(sub);
-        if (props)
-          css += `${atRule} { ${resolved} { ${props} } }
+  function emitMediaNested(atRule, parentSel, obj) {
+    for (const [sel, sub] of Object.entries(obj)) {
+      if (sub === null || typeof sub !== "object" || Array.isArray(sub)) {
+        continue;
+      }
+      if (sel.startsWith("@")) {
+        continue;
+      }
+      const resolved = sel.startsWith("&") ? sel.replace("&", parentSel) : sel.startsWith("[") ? `${parentSel}${sel}` : sel.startsWith(":") || sel.startsWith(".") ? `${parentSel}${sel}` : `${parentSel} ${sel}`;
+      const props = toCSSText(sub);
+      if (props) {
+        css += `${atRule} { ${resolved} { ${props} } }
 `;
-        emitMediaNested(resolved, sub);
       }
-    };
-    if (key === "@--")
+      emitMediaNested(atRule, resolved, sub);
+    }
+  }
+  for (const [key, rules] of Object.entries(media)) {
+    if (key === "@--") {
       continue;
+    }
     const atRule = key.startsWith("@--") ? `@media ${mediaQueries[key.slice(1)] ?? key.slice(1)}` : key.startsWith("@(") ? `@media ${key.slice(1)}` : key;
     const scope = `[data-jx="${uid}"]`;
     css += `${atRule} { ${scope} { ${toCSSText(rules)} } }
 `;
-    emitMediaNested(scope, rules);
+    emitMediaNested(atRule, scope, rules);
   }
   const tag = document.createElement("style");
   tag.textContent = css;
-  document.head.appendChild(tag);
+  document.head.append(tag);
 }
 function applyAttributes(el, attrs, state) {
   for (const [k, v] of Object.entries(attrs)) {
@@ -1970,78 +2101,87 @@ function applyAttributes(el, attrs, state) {
     }
   }
 }
-function renderMappedArray(def2, state, options) {
+function renderMappedArray(def2, arrayDef, state, options) {
   const path = options?._path ?? [];
   const container = document.createElement(def2.tagName ?? "div");
-  if (options?.onNodeCreated)
+  if (options?.onNodeCreated) {
     options.onNodeCreated(container, path, def2);
+  }
   applyProperties(container, def2, state);
   applyStyle(container, def2.style ?? {}, state["$media"] ?? {}, state);
   applyAttributes(container, def2.attributes ?? {}, state);
-  const { items: itemsSrc, map: mapDef, filter: filterRef, sort: sortRef } = def2.children;
+  const { items: itemsSrc, map: mapDef, filter: filterRef, sort: sortRef } = arrayDef;
   effect(() => {
     container.innerHTML = "";
     let items;
-    if (isRefObj(itemsSrc)) {
-      items = resolveRef(itemsSrc.$ref, state);
-    } else {
-      items = itemsSrc;
-    }
-    if (!Array.isArray(items))
+    items = isRefObj(itemsSrc) ? resolveRef(itemsSrc.$ref, state) : itemsSrc;
+    if (!Array.isArray(items)) {
       return;
-    if (filterRef) {
+    }
+    if (isRefObj(filterRef)) {
       const fn = resolveRef(filterRef.$ref, state);
-      if (typeof fn === "function")
+      if (typeof fn === "function") {
         items = items.filter(fn);
+      }
     }
-    if (sortRef) {
+    if (isRefObj(sortRef)) {
       const fn = resolveRef(sortRef.$ref, state);
-      if (typeof fn === "function")
-        items = [...items].sort(fn);
+      if (typeof fn === "function") {
+        items = [...items].toSorted(fn);
+      }
     }
-    items.forEach((item, index) => {
+    for (const [index, item] of items.entries()) {
       const child = Object.create(state);
-      child.$map = { item, index };
+      child.$map = { index, item };
       child["$map/item"] = item;
       child["$map/index"] = index;
       const childOpts = options ? { ...options, _path: [...path, "children", "map", index] } : undefined;
-      container.appendChild(renderNode(mapDef, child, childOpts));
-    });
+      if (mapDef) {
+        container.append(renderNode(mapDef, child, childOpts));
+      }
+    }
   });
   return container;
 }
 function renderSwitch(def2, state, options) {
   const path = options?._path ?? [];
   const container = document.createElement(def2.tagName ?? "div");
-  if (options?.onNodeCreated)
+  if (options?.onNodeCreated) {
     options.onNodeCreated(container, path, def2);
+  }
   applyProperties(container, def2, state);
   applyStyle(container, def2.style ?? {}, state["$media"] ?? {}, state);
   applyAttributes(container, def2.attributes ?? {}, state);
   let generation = 0;
   effect(() => {
     container.innerHTML = "";
+    if (!isRefObj(def2.$switch)) {
+      return;
+    }
     const key = resolveRef(def2.$switch.$ref, state);
     const caseDef = def2.cases?.[key];
-    if (!caseDef)
+    if (!caseDef) {
       return;
+    }
     if (isRefObj(caseDef)) {
-      const gen = ++generation;
-      const href = new URL(caseDef.$ref, location.href).href;
+      const gen = generation += 1;
+      const { href } = new URL(caseDef.$ref, location.href);
       resolve(href).then(async (doc) => {
-        if (gen !== generation)
+        if (gen !== generation) {
           return;
+        }
         const childScope = await buildScope(doc, {}, href);
-        if (gen !== generation)
+        if (gen !== generation) {
           return;
+        }
         container.innerHTML = "";
         const childOpts2 = options ? { ...options, _path: [...path, "cases", key] } : undefined;
-        container.appendChild(renderNode(doc, childScope, childOpts2));
-      }).catch((e) => console.error("Jx $switch: failed to load external case", caseDef.$ref, e));
+        container.append(renderNode(doc, childScope, childOpts2));
+      }).catch((error) => console.error("Jx $switch: failed to load external case", caseDef.$ref, error));
       return;
     }
     const childOpts = options ? { ...options, _path: [...path, "cases", key] } : undefined;
-    container.appendChild(renderNode(caseDef, state, childOpts));
+    container.append(renderNode(caseDef, state, childOpts));
   });
   return container;
 }
@@ -2060,28 +2200,31 @@ async function resolvePrototype(def2, state, key, base) {
           if (isTemplateString(def2.url)) {
             url = evaluateTemplate(def2.url, state);
           } else {
-            url = def2.url;
+            ({ url } = def2);
           }
-          if (!url || url === "undefined" || url.includes("undefined"))
+          if (!url || url === "undefined" || url.includes("undefined")) {
             return;
+          }
           const controller = new AbortController;
           onEffectCleanup(() => {
             controller.abort();
-            if (debounceTimer !== null)
+            if (debounceTimer !== null) {
               clearTimeout(debounceTimer);
+            }
           });
           const doFetch = () => fetch(url, {
-            signal: controller.signal,
             method: def2.method ?? "GET",
+            signal: controller.signal,
             ...def2.headers && { headers: def2.headers },
             ...def2.body && {
               body: typeof def2.body === "object" ? JSON.stringify(def2.body) : def2.body
             }
           }).then((r) => r.ok ? r.json() : Promise.reject(r.statusText)).then((d) => {
             s.value = d;
-          }).catch((e) => {
-            if (e.name !== "AbortError")
-              s.value = { error: String(e) };
+          }).catch((error) => {
+            if (!(error instanceof Error && error.name === "AbortError")) {
+              s.value = { error: String(error) };
+            }
           });
           if (debounceMs > 0) {
             debounceTimer = setTimeout(doFetch, debounceMs);
@@ -2092,7 +2235,7 @@ async function resolvePrototype(def2, state, key, base) {
       }
       return s;
     }
-    case "URLSearchParams":
+    case "URLSearchParams": {
       return computed(() => {
         const p = {};
         for (const [k, v] of Object.entries(def2)) {
@@ -2102,6 +2245,7 @@ async function resolvePrototype(def2, state, key, base) {
         }
         return new URLSearchParams(p).toString();
       });
+    }
     case "LocalStorage":
     case "SessionStorage": {
       const store = def2.$prototype === "LocalStorage" ? localStorage : sessionStorage;
@@ -2131,9 +2275,10 @@ async function resolvePrototype(def2, state, key, base) {
     case "Cookie": {
       const name = def2.name ?? key;
       const read = () => {
-        const m = document.cookie.match(new RegExp("(?:^|; )" + name + "=([^;]*)"));
-        if (!m)
+        const m = document.cookie.match(new RegExp(`(?:^|; )${name}=([^;]*)`));
+        if (!m) {
           return null;
+        }
         try {
           return JSON.parse(decodeURIComponent(m[1]));
         } catch {
@@ -2144,16 +2289,21 @@ async function resolvePrototype(def2, state, key, base) {
       effect(() => {
         const v = cookieState.value;
         let s = `${name}=${encodeURIComponent(JSON.stringify(v))}`;
-        if (def2.maxAge !== undefined)
+        if (def2.maxAge !== undefined) {
           s += `; Max-Age=${def2.maxAge}`;
-        if (def2.path)
+        }
+        if (def2.path) {
           s += `; Path=${def2.path}`;
-        if (def2.domain)
+        }
+        if (def2.domain) {
           s += `; Domain=${def2.domain}`;
-        if (def2.secure)
+        }
+        if (def2.secure) {
           s += `; Secure`;
-        if (def2.sameSite)
+        }
+        if (def2.sameSite) {
           s += `; SameSite=${def2.sameSite}`;
+        }
         document.cookie = s;
       });
       return cookieState;
@@ -2168,47 +2318,59 @@ async function resolvePrototype(def2, state, key, base) {
         autoIncrement = true,
         indexes = []
       } = def2;
+      if (!database || !store) {
+        throw new Error(`Jx: IndexedDB entry '${key}' requires database and store`);
+      }
       const req = indexedDB.open(database, version);
-      req.onupgradeneeded = (e) => {
+      req.addEventListener("upgradeneeded", (e) => {
         const db = e.target.result;
         if (!db.objectStoreNames.contains(store)) {
-          const os = db.createObjectStore(store, { keyPath, autoIncrement });
-          for (const i of indexes)
+          const os = db.createObjectStore(store, { autoIncrement, keyPath });
+          for (const i of indexes) {
             os.createIndex(i.name, i.keyPath, { unique: i.unique ?? false });
+          }
         }
-      };
-      req.onsuccess = (e) => {
+      });
+      req.addEventListener("success", (e) => {
         const db = e.target.result;
         idbState.value = {
           database,
-          store,
-          version,
+          getStore: (mode = "readwrite") => Promise.resolve(db.transaction(store, mode).objectStore(store)),
           isReady: true,
-          getStore: (mode = "readwrite") => Promise.resolve(db.transaction(store, mode).objectStore(store))
+          store,
+          version
         };
-      };
-      req.onerror = () => {
+      });
+      req.addEventListener("error", () => {
         idbState.value = { error: req.error?.message };
-      };
+      });
       return idbState;
     }
-    case "Set":
-      return new Set(def2.default ?? []);
-    case "Map":
-      return new Map(Object.entries(def2.default ?? {}));
+    case "Set": {
+      return new Set(Array.isArray(def2.default) ? def2.default : []);
+    }
+    case "Map": {
+      return new Map(Object.entries(isJsonObject(def2.default) ? def2.default : {}));
+    }
     case "FormData": {
       const fd = new FormData;
-      for (const [k, v] of Object.entries(def2.fields ?? {}))
+      for (const [k, v] of Object.entries(def2.fields ?? {})) {
         fd.append(k, v);
+      }
       return fd;
     }
-    case "Blob":
-      return new Blob(def2.parts ?? [], { type: def2.type ?? "text/plain" });
-    case "ReadableStream":
+    case "Blob": {
+      return new Blob(def2.parts ?? [], {
+        type: typeof def2.type === "string" ? def2.type : "text/plain"
+      });
+    }
+    case "ReadableStream": {
       return null;
-    default:
+    }
+    default: {
       console.warn(`Jx: unknown $prototype "${def2.$prototype}" for "${key}". Did you mean to add '$src'?`);
       return ref(null);
+    }
   }
 }
 var EXTERNAL_RESERVED = new Set([
@@ -2225,7 +2387,7 @@ var EXTERNAL_RESERVED = new Set([
 ]);
 async function resolveExternalPrototype(def2, state, key, base) {
   const src = def2.$src;
-  if (!src.endsWith(".class.json")) {
+  if (!src || !src.endsWith(".class.json")) {
     throw new Error(`Jx: $prototype "${def2.$prototype}" requires a .class.json $src, got "${src}". Wrap the class in a .class.json schema with $implementation.`);
   }
   return resolveClassJson(def2, state, key, base);
@@ -2252,19 +2414,20 @@ async function importAndInstantiate(def2, src, exportName, base) {
     throw new Error(`Jx: export "${exportName}" not found in "${src}"`);
   }
   if (typeof ExportedClass !== "function") {
-    throw new Error(`Jx: "${exportName}" from "${src}" is not a class`);
+    throw new TypeError(`Jx: "${exportName}" from "${src}" is not a class`);
   }
   const config = {};
   for (const [k, v] of Object.entries(def2)) {
-    if (!EXTERNAL_RESERVED.has(k))
+    if (!EXTERNAL_RESERVED.has(k)) {
       config[k] = v;
+    }
   }
   const instance = new ExportedClass(config);
   let value;
   if (typeof instance.resolve === "function") {
     value = await instance.resolve();
   } else if ("value" in instance) {
-    value = instance.value;
+    ({ value } = instance);
   } else {
     value = instance;
   }
@@ -2278,6 +2441,9 @@ async function importAndInstantiate(def2, src, exportName, base) {
 }
 async function resolveClassJson(def2, state, key, base) {
   const src = def2.$src;
+  if (!src) {
+    throw new Error(`Jx: class entry '${key}' has no $src`);
+  }
   let classDef;
   const isBareSpecifier = !src.startsWith(".") && !src.startsWith("/") && !src.startsWith("http") && !src.startsWith("file:");
   if (isBareSpecifier) {
@@ -2286,8 +2452,9 @@ async function resolveClassJson(def2, state, key, base) {
   try {
     const url = base ? new URL(src, base).href : src;
     const res = await fetch(url);
-    if (!res.ok)
+    if (!res.ok) {
       throw new Error(`HTTP ${res.status}`);
+    }
     classDef = await res.json();
   } catch {
     return resolveViaDevProxy(def2, state, key, base);
@@ -2309,15 +2476,16 @@ async function resolveClassJson(def2, state, key, base) {
   const DynClass = classFromSchema(classDef);
   const config = {};
   for (const [k, v] of Object.entries(def2)) {
-    if (!EXTERNAL_RESERVED.has(k))
+    if (!EXTERNAL_RESERVED.has(k)) {
       config[k] = v;
+    }
   }
   const instance = new DynClass(config);
   let value;
   if (typeof instance.resolve === "function") {
     value = await instance.resolve();
   } else if ("value" in instance) {
-    value = instance.value;
+    ({ value } = instance);
   } else {
     value = instance;
   }
@@ -2331,23 +2499,24 @@ async function resolveClassJson(def2, state, key, base) {
 }
 function classFromSchema(classDef) {
   const fields = classDef.$defs?.fields ?? {};
-  const ctor = classDef.$defs?.constructor;
+  const rawCtor = classDef.$defs?.constructor;
+  const ctor = typeof rawCtor === "object" ? rawCtor : undefined;
   const methods = classDef.$defs?.methods ?? {};
 
   class DynClass {
     constructor(config = {}) {
-      for (const [key, field] of Object.entries(fields)) {
-        const typedField = field;
+      for (const [key, typedField] of Object.entries(fields)) {
         const id = typedField.identifier ?? key;
         const propName = typedField.access === "private" ? `_${id}` : id;
-        if (config[id] !== undefined)
+        if (config[id] !== undefined) {
           this[propName] = config[id];
-        else if (typedField.initializer !== undefined)
+        } else if (typedField.initializer !== undefined) {
           this[propName] = typedField.initializer;
-        else if (typedField.default !== undefined)
+        } else if (typedField.default !== undefined) {
           this[propName] = structuredClone(typedField.default);
-        else
+        } else {
           this[propName] = null;
+        }
       }
       if (ctor?.body) {
         const bodyStr = Array.isArray(ctor.body) ? ctor.body.join(`
@@ -2356,23 +2525,25 @@ function classFromSchema(classDef) {
       }
     }
   }
-  for (const [key, method] of Object.entries(methods)) {
-    const typedMethod = method;
+  for (const [key, typedMethod] of Object.entries(methods)) {
     const name = typedMethod.identifier ?? key;
     const params = (typedMethod.parameters ?? []).map((p) => {
-      if (p.$ref)
+      if (p.$ref) {
         return p.$ref.split("/").pop();
-      return p.identifier ?? p.name ?? "arg";
+      }
+      const n = p.identifier ?? p.name;
+      return typeof n === "string" ? n : "arg";
     });
     const bodyStr = Array.isArray(typedMethod.body) ? typedMethod.body.join(`
 `) : typedMethod.body ?? "";
     if (typedMethod.role === "accessor") {
       const descriptor = {};
-      if (typedMethod.getter)
-        descriptor.get = new Function(typedMethod.getter.body);
+      if (typedMethod.getter) {
+        descriptor.get = new Function(typedMethod.getter.body ?? "");
+      }
       if (typedMethod.setter) {
         const sp = (typedMethod.setter.parameters ?? []).map((p) => p.$ref?.split("/").pop() ?? "v");
-        descriptor.set = new Function(...sp, typedMethod.setter.body);
+        descriptor.set = new Function(...sp, typedMethod.setter.body ?? "");
       }
       Object.defineProperty(DynClass.prototype, name, {
         ...descriptor,
@@ -2385,8 +2556,8 @@ function classFromSchema(classDef) {
     }
   }
   Object.defineProperty(DynClass, "name", {
-    value: classDef.title,
-    configurable: true
+    configurable: true,
+    value: classDef.title
   });
   const dynCtor = DynClass;
   return dynCtor;
@@ -2394,23 +2565,25 @@ function classFromSchema(classDef) {
 async function resolveViaDevProxy(def2, state, key, base) {
   const config = {};
   for (const [k, v] of Object.entries(def2)) {
-    if (!EXTERNAL_RESERVED.has(k))
+    if (!EXTERNAL_RESERVED.has(k)) {
       config[k] = v;
+    }
   }
   const hasTemplates = Object.values(config).some((v) => isTemplateString(v));
   const doResolve = (resolvedConfig) => fetch("/__jx_resolve__", {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
-      $src: def2.$src,
-      $prototype: def2.$prototype,
-      $export: def2.$export,
       $base: base,
+      $export: def2.$export,
+      $prototype: def2.$prototype,
+      $src: def2.$src,
       ...resolvedConfig
-    })
+    }),
+    headers: { "Content-Type": "application/json" },
+    method: "POST"
   }).then((r) => {
-    if (!r.ok)
+    if (!r.ok) {
       throw new Error(`Jx dev proxy ${r.status} for "${key}"`);
+    }
     return r.json();
   });
   const s = ref(null);
@@ -2422,12 +2595,12 @@ async function resolveViaDevProxy(def2, state, key, base) {
       }
       doResolve(resolvedConfig).then((value) => {
         s.value = value;
-      }).catch((e) => console.error("Jx dev proxy:", e));
+      }).catch((error) => console.error("Jx dev proxy:", error));
     });
   } else {
     doResolve(config).then((value) => {
       s.value = value;
-    }).catch((e) => console.error("Jx dev proxy:", e));
+    }).catch((error) => console.error("Jx dev proxy:", error));
   }
   return s;
 }
@@ -2455,10 +2628,12 @@ async function resolveServerFunction(def2, state, key, base) {
     _moduleCache.set(src, mod);
   }
   const fn = mod[exportName] ?? mod.default?.[exportName];
-  if (!fn)
+  if (!fn) {
     throw new Error(`Jx: export "${exportName}" not found in "${src}" for "${key}"`);
-  if (typeof fn !== "function")
-    throw new Error(`Jx: "${exportName}" from "${src}" is not a function`);
+  }
+  if (typeof fn !== "function") {
+    throw new TypeError(`Jx: "${exportName}" from "${src}" is not a function`);
+  }
   const rawArgs = def2.arguments ?? {};
   const hasReactiveArg = Object.values(rawArgs).some((v) => isRefObj(v));
   const resolveArgs = () => {
@@ -2493,17 +2668,18 @@ async function resolveServerFunctionViaProxy(def2, state, key, base) {
     return args;
   };
   const doResolve = (args) => fetch("/__jx_server__", {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
-      $src: def2.$src,
-      $export: def2.$export,
       $base: base,
+      $export: def2.$export,
+      $src: def2.$src,
       arguments: args
-    })
+    }),
+    headers: { "Content-Type": "application/json" },
+    method: "POST"
   }).then((r) => {
-    if (!r.ok)
+    if (!r.ok) {
       throw new Error(`Jx server proxy ${r.status} for "${key}"`);
+    }
     return r.json();
   });
   const s = ref(null);
@@ -2513,50 +2689,60 @@ async function resolveServerFunctionViaProxy(def2, state, key, base) {
       onEffectCleanup(() => {});
       doResolve(args).then((result) => {
         s.value = result;
-      }).catch((e) => console.error("Jx server proxy:", e));
+      }).catch((error) => console.error("Jx server proxy:", error));
     });
   } else {
     doResolve(resolveArgs()).then((result) => {
       s.value = result;
-    }).catch((e) => console.error("Jx server proxy:", e));
+    }).catch((error) => console.error("Jx server proxy:", error));
   }
   return s;
 }
-function resolveRef(ref2, state) {
-  if (typeof ref2 !== "string")
-    return ref2;
-  if (ref2.startsWith("$map/")) {
-    const parts = ref2.split("/");
-    const key = parts[1];
-    const base = state.$map?.[key] ?? state["$map/" + key];
+function resolveRef(refPath, state) {
+  if (typeof refPath !== "string") {
+    return refPath;
+  }
+  if (refPath.startsWith("$map/")) {
+    const parts = refPath.split("/");
+    const [, key] = parts;
+    const map = state.$map;
+    const base = map?.[key] ?? state[`$map/${key}`];
     return parts.length > 2 ? getPath2(base, parts.slice(2).join("/")) : base;
   }
-  if (ref2.startsWith("#/state/")) {
-    const sub = ref2.slice("#/state/".length);
+  if (refPath.startsWith("#/state/")) {
+    const sub = refPath.slice("#/state/".length);
     const slash = sub.indexOf("/");
-    if (slash < 0)
+    if (slash === -1) {
       return state[sub];
+    }
     return getPath2(state[sub.slice(0, slash)], sub.slice(slash + 1));
   }
-  if (ref2.startsWith("parent#/"))
-    return state[ref2.slice("parent#/".length)];
-  if (ref2.startsWith("window#/"))
-    return getPath2(globalThis.window, ref2.slice("window#/".length));
-  if (ref2.startsWith("document#/"))
-    return getPath2(globalThis.document, ref2.slice("document#/".length));
-  return state[ref2] ?? null;
+  if (refPath.startsWith("parent#/")) {
+    return state[refPath.slice("parent#/".length)];
+  }
+  if (refPath.startsWith("window#/")) {
+    return getPath2(globalThis.window, refPath.slice("window#/".length));
+  }
+  if (refPath.startsWith("document#/")) {
+    return getPath2(globalThis.document, refPath.slice("document#/".length));
+  }
+  return state[refPath] ?? null;
 }
 function isSignal(v) {
   return isRef(v);
 }
 function isRefObj(v) {
-  return v !== null && typeof v === "object" && typeof v.$ref === "string";
+  return isRef2(v);
 }
 function isNestedSelector(k) {
   return k.startsWith(":") || k.startsWith(".") || k.startsWith("&") || k.startsWith("[");
 }
 function getPath2(obj, path) {
-  return path.split(/[./]/).reduce((o, k) => o?.[k], obj);
+  let current = obj;
+  for (const k of path.split(/[./]/)) {
+    current = current?.[k];
+  }
+  return current;
 }
 function mergeProps(def2, parentState) {
   const child = Object.create(parentState);
@@ -2566,7 +2752,7 @@ function mergeProps(def2, parentState) {
   return child;
 }
 function camelToKebab(s) {
-  return s.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+  return s.replaceAll(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
 }
 function toCSSText(rules) {
   return Object.entries(rules).filter(([k, v]) => !isNestedSelector(k) && (v === null || typeof v !== "object")).map(([p, v]) => `${camelToKebab(p)}: ${v}`).join("; ");
@@ -2579,19 +2765,22 @@ async function registerElements(elements, base) {
       try {
         const specifier = entry.startsWith("/") || entry.startsWith(".") ? entry : `/node_modules/${entry}`;
         await import(specifier);
-      } catch (e) {
-        console.warn(`Jx: failed to import package "${entry}"`, e);
+      } catch (error) {
+        console.warn(`Jx: failed to import package "${entry}"`, error);
       }
       continue;
     }
-    if (!isRefObj(entry))
+    if (!isRefObj(entry)) {
       continue;
-    const href = new URL(entry.$ref, base).href;
+    }
+    const { href } = new URL(entry.$ref, base);
     const doc = await resolve(href);
-    if (!doc.tagName || !doc.tagName.includes("-"))
+    if (!doc.tagName || !doc.tagName.includes("-")) {
       continue;
-    if (customElements.get(doc.tagName))
+    }
+    if (customElements.get(doc.tagName)) {
       continue;
+    }
     if (doc.$elements) {
       await registerElements(doc.$elements, href);
     }
@@ -2600,48 +2789,56 @@ async function registerElements(elements, base) {
 }
 function injectHead(entries, _base) {
   for (const entry of entries) {
-    if (!entry || !entry.tagName)
+    if (!entry || !entry.tagName) {
       continue;
+    }
     const tag = entry.tagName.toLowerCase();
     const attrs = { ...entry.attributes };
     for (const key of ["href", "src"]) {
-      if (attrs[key] && !attrs[key].startsWith("/") && !attrs[key].startsWith(".") && !attrs[key].startsWith("http")) {
-        attrs[key] = `/node_modules/${attrs[key]}`;
+      const v = attrs[key];
+      if (typeof v === "string" && v && !v.startsWith("/") && !v.startsWith(".") && !v.startsWith("http")) {
+        attrs[key] = `/node_modules/${v}`;
       }
     }
     const selector = `${tag}${attrs.href ? `[href="${attrs.href}"]` : ""}${attrs.src ? `[src="${attrs.src}"]` : ""}`;
-    if (selector !== tag && document.head.querySelector(selector))
+    if (selector !== tag && document.head.querySelector(selector)) {
       continue;
+    }
     const el = document.createElement(tag);
     for (const [k, v] of Object.entries(attrs)) {
-      el.setAttribute(k, v);
+      el.setAttribute(k, String(v));
     }
-    if (entry.textContent)
+    if (entry.textContent) {
       el.textContent = entry.textContent;
-    document.head.appendChild(el);
+    }
+    document.head.append(el);
   }
 }
 var _definedSources = new Set;
-async function defineElement(source, base) {
+async function defineElement(source, baseUrl) {
+  let base = baseUrl;
+  let doc = source;
   if (typeof source === "string") {
     base = new URL(source, base ?? location.href).href;
-    if (_definedSources.has(base))
+    if (_definedSources.has(base)) {
       return;
+    }
     _definedSources.add(base);
-    source = await resolve(source);
+    doc = await resolve(source);
   }
-  base = base ?? location.href;
-  const source_ = source;
-  const tagName = source_.tagName;
+  base ??= location.href;
+  const source_ = doc;
+  const { tagName } = source_;
   if (!tagName || !tagName.includes("-")) {
     throw new Error(`Jx defineElement: tagName "${tagName}" must contain a hyphen`);
   }
-  if (customElements.get(tagName))
+  if (customElements.get(tagName)) {
     return;
+  }
   if (source_.$elements) {
     await registerElements(source_.$elements, base);
   }
-  _elementDefs.set(tagName, { doc: source_, base });
+  _elementDefs.set(tagName, { base, doc: source_ });
   const def2 = source_;
   const observedAttrs = def2.observedAttributes ?? [];
   const ElementClass = class extends HTMLElement {
@@ -2651,20 +2848,22 @@ async function defineElement(source, base) {
       return observedAttrs;
     }
     async connectedCallback() {
-      if (this._jxInitialized)
+      if (this._jxInitialized) {
         return;
+      }
       this._jxInitialized = true;
       const state = await buildScope(def2, {}, base);
-      const propsAttr = this.getAttribute("data-jx-props");
+      const propsAttr = this.dataset.jxProps;
       if (propsAttr) {
         try {
           const props = JSON.parse(propsAttr);
           for (const [key, val] of Object.entries(props)) {
-            if (key in (def2.state ?? {}))
+            if (key in (def2.state ?? {})) {
               state[key] = val;
+            }
           }
         } catch {}
-        this.removeAttribute("data-jx-props");
+        delete this.dataset.jxProps;
       }
       for (const key of Object.keys(def2.state ?? {})) {
         if (key in this && this[key] !== undefined) {
@@ -2674,28 +2873,30 @@ async function defineElement(source, base) {
       for (const key of Object.keys(def2.state ?? {})) {
         if (!(key in HTMLElement.prototype)) {
           Object.defineProperty(this, key, {
+            configurable: true,
             get: () => state[key],
             set: (v) => {
               state[key] = v;
-            },
-            configurable: true
+            }
           });
         }
       }
       this._state = state;
-      const slottedChildren = Array.from(this.childNodes);
+      const slottedChildren = [...this.childNodes];
       this.innerHTML = "";
-      if (!this.style.display)
+      if (!this.style.display) {
         this.style.display = "block";
+      }
       applyStyle(this, def2.style ?? {}, state["$media"] ?? {}, state);
       applyAttributes(this, def2.attributes ?? {}, state);
       const children = Array.isArray(def2.children) ? def2.children : [];
       for (const childDef of children) {
-        this.appendChild(renderNode(childDef, state));
+        this.append(renderNode(childDef, state));
       }
       distributeSlots(this, slottedChildren);
-      if (typeof state.onMount === "function") {
-        queueMicrotask(() => state.onMount(state));
+      const { onMount } = state;
+      if (typeof onMount === "function") {
+        queueMicrotask(() => onMount(state));
       }
     }
     disconnectedCallback() {
@@ -2709,24 +2910,27 @@ async function defineElement(source, base) {
       }
     }
     attributeChangedCallback(name, oldVal, newVal) {
-      if (!this._state || oldVal === newVal)
+      if (!this._state || oldVal === newVal) {
         return;
-      const camelKey = name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+      }
+      const camelKey = name.replaceAll(/-([a-z])/g, (_, c) => c.toUpperCase());
       const current = this._state[camelKey];
-      if (typeof current === "number")
+      if (typeof current === "number") {
         this._state[camelKey] = Number(newVal);
-      else if (typeof current === "boolean")
+      } else if (typeof current === "boolean") {
         this._state[camelKey] = newVal !== null && newVal !== "false";
-      else
+      } else {
         this._state[camelKey] = newVal;
+      }
     }
   };
   customElements.define(tagName, ElementClass);
 }
 function renderCustomElementWithProps(def2, state, options, path) {
-  const el = document.createElement(def2.tagName);
-  if (options?.onNodeCreated)
+  const el = document.createElement(def2.tagName ?? "div");
+  if (options?.onNodeCreated) {
     options.onNodeCreated(el, path ?? [], def2);
+  }
   for (const [key, val] of Object.entries(def2.$props ?? {})) {
     if (isRefObj(val)) {
       const refVal = val;
@@ -2748,23 +2952,26 @@ function renderCustomElementWithProps(def2, state, options, path) {
   const children = Array.isArray(def2.children) ? def2.children : [];
   for (let i = 0;i < children.length; i++) {
     const childOpts = options && path ? { ...options, _path: [...path, "children", i] } : undefined;
-    el.appendChild(renderNode(children[i], state, childOpts));
+    el.append(renderNode(children[i], state, childOpts));
   }
   return el;
 }
 function distributeSlots(host, slottedChildren) {
-  if (slottedChildren.length === 0)
+  if (slottedChildren.length === 0) {
     return;
+  }
   const slots = host.querySelectorAll("slot");
-  if (slots.length === 0)
+  if (slots.length === 0) {
     return;
+  }
   const named = new Map;
   const unnamed = [];
   for (const child of slottedChildren) {
     if (child.nodeType === Node.ELEMENT_NODE && child.getAttribute("slot")) {
       const name = child.getAttribute("slot");
-      if (!named.has(name))
+      if (!named.has(name)) {
         named.set(name, []);
+      }
       named.get(name).push(child);
     } else {
       unnamed.push(child);
@@ -2776,7 +2983,7 @@ function distributeSlots(host, slottedChildren) {
     if (matches.length > 0) {
       slot.innerHTML = "";
       for (const child of matches) {
-        slot.appendChild(child);
+        slot.append(child);
       }
     }
   }
@@ -2799,5 +3006,5 @@ export {
   Jx
 };
 
-//# debugId=D6000E7448ED71C464756E2164756E21
+//# debugId=32F6E02650EECC3864756E2164756E21
 //# sourceMappingURL=runtime.js.map