@jxsuite/runtime 0.0.1

package/dist/runtime.js

@@ -0,0 +1,2409 @@
+// ../../node_modules/@vue/shared/dist/shared.esm-bundler.js
+function makeMap(str) {
+  const map = /* @__PURE__ */ Object.create(null);
+  for (const key of str.split(","))
+    map[key] = 1;
+  return (val) => (val in map);
+}
+var EMPTY_OBJ = Object.freeze({});
+var EMPTY_ARR = Object.freeze([]);
+var extend = Object.assign;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var hasOwn = (val, key) => hasOwnProperty.call(val, key);
+var isArray = Array.isArray;
+var isMap = (val) => toTypeString(val) === "[object Map]";
+var isFunction = (val) => typeof val === "function";
+var isString = (val) => typeof val === "string";
+var isSymbol = (val) => typeof val === "symbol";
+var isObject = (val) => val !== null && typeof val === "object";
+var objectToString = Object.prototype.toString;
+var toTypeString = (value) => objectToString.call(value);
+var toRawType = (value) => {
+  return toTypeString(value).slice(8, -1);
+};
+var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+var cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+};
+var camelizeRE = /-\w/g;
+var camelize = cacheStringFunction((str) => {
+  return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
+});
+var hyphenateRE = /\B([A-Z])/g;
+var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+var capitalize = cacheStringFunction((str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+});
+var toHandlerKey = cacheStringFunction((str) => {
+  const s = str ? `on${capitalize(str)}` : ``;
+  return s;
+});
+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/@vue/reactivity/dist/reactivity.esm-bundler.js
+function warn(msg, ...args) {
+  console.warn(`[Vue warn] ${msg}`, ...args);
+}
+var activeEffectScope;
+var activeSub;
+var pausedQueueEffects = /* @__PURE__ */ new WeakSet;
+
+class ReactiveEffect {
+  constructor(fn) {
+    this.fn = fn;
+    this.deps = undefined;
+    this.depsTail = undefined;
+    this.flags = 1 | 4;
+    this.next = undefined;
+    this.cleanup = undefined;
+    this.scheduler = undefined;
+    if (activeEffectScope && activeEffectScope.active) {
+      activeEffectScope.effects.push(this);
+    }
+  }
+  pause() {
+    this.flags |= 64;
+  }
+  resume() {
+    if (this.flags & 64) {
+      this.flags &= -65;
+      if (pausedQueueEffects.has(this)) {
+        pausedQueueEffects.delete(this);
+        this.trigger();
+      }
+    }
+  }
+  notify() {
+    if (this.flags & 2 && !(this.flags & 32)) {
+      return;
+    }
+    if (!(this.flags & 8)) {
+      batch(this);
+    }
+  }
+  run() {
+    if (!(this.flags & 1)) {
+      return this.fn();
+    }
+    this.flags |= 2;
+    cleanupEffect(this);
+    prepareDeps(this);
+    const prevEffect = activeSub;
+    const prevShouldTrack = shouldTrack;
+    activeSub = this;
+    shouldTrack = true;
+    try {
+      return this.fn();
+    } finally {
+      if (activeSub !== this) {
+        warn("Active effect was not restored correctly - this is likely a Vue internal bug.");
+      }
+      cleanupDeps(this);
+      activeSub = prevEffect;
+      shouldTrack = prevShouldTrack;
+      this.flags &= -3;
+    }
+  }
+  stop() {
+    if (this.flags & 1) {
+      for (let link = this.deps;link; link = link.nextDep) {
+        removeSub(link);
+      }
+      this.deps = this.depsTail = undefined;
+      cleanupEffect(this);
+      this.onStop && this.onStop();
+      this.flags &= -2;
+    }
+  }
+  trigger() {
+    if (this.flags & 64) {
+      pausedQueueEffects.add(this);
+    } else if (this.scheduler) {
+      this.scheduler();
+    } else {
+      this.runIfDirty();
+    }
+  }
+  runIfDirty() {
+    if (isDirty(this)) {
+      this.run();
+    }
+  }
+  get dirty() {
+    return isDirty(this);
+  }
+}
+var batchDepth = 0;
+var batchedSub;
+var batchedComputed;
+function batch(sub, isComputed = false) {
+  sub.flags |= 8;
+  if (isComputed) {
+    sub.next = batchedComputed;
+    batchedComputed = sub;
+    return;
+  }
+  sub.next = batchedSub;
+  batchedSub = sub;
+}
+function startBatch() {
+  batchDepth++;
+}
+function endBatch() {
+  if (--batchDepth > 0) {
+    return;
+  }
+  if (batchedComputed) {
+    let e = batchedComputed;
+    batchedComputed = undefined;
+    while (e) {
+      const next = e.next;
+      e.next = undefined;
+      e.flags &= -9;
+      e = next;
+    }
+  }
+  let error;
+  while (batchedSub) {
+    let e = batchedSub;
+    batchedSub = undefined;
+    while (e) {
+      const next = e.next;
+      e.next = undefined;
+      e.flags &= -9;
+      if (e.flags & 1) {
+        try {
+          e.trigger();
+        } catch (err) {
+          if (!error)
+            error = err;
+        }
+      }
+      e = next;
+    }
+  }
+  if (error)
+    throw error;
+}
+function prepareDeps(sub) {
+  for (let link = sub.deps;link; link = link.nextDep) {
+    link.version = -1;
+    link.prevActiveLink = link.dep.activeLink;
+    link.dep.activeLink = link;
+  }
+}
+function cleanupDeps(sub) {
+  let head;
+  let tail = sub.depsTail;
+  let link = tail;
+  while (link) {
+    const prev = link.prevDep;
+    if (link.version === -1) {
+      if (link === tail)
+        tail = prev;
+      removeSub(link);
+      removeDep(link);
+    } else {
+      head = link;
+    }
+    link.dep.activeLink = link.prevActiveLink;
+    link.prevActiveLink = undefined;
+    link = prev;
+  }
+  sub.deps = head;
+  sub.depsTail = tail;
+}
+function isDirty(sub) {
+  for (let link = sub.deps;link; link = link.nextDep) {
+    if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
+      return true;
+    }
+  }
+  if (sub._dirty) {
+    return true;
+  }
+  return false;
+}
+function refreshComputed(computed) {
+  if (computed.flags & 4 && !(computed.flags & 16)) {
+    return;
+  }
+  computed.flags &= -17;
+  if (computed.globalVersion === globalVersion) {
+    return;
+  }
+  computed.globalVersion = globalVersion;
+  if (!computed.isSSR && computed.flags & 128 && (!computed.deps && !computed._dirty || !isDirty(computed))) {
+    return;
+  }
+  computed.flags |= 2;
+  const dep = computed.dep;
+  const prevSub = activeSub;
+  const prevShouldTrack = shouldTrack;
+  activeSub = computed;
+  shouldTrack = true;
+  try {
+    prepareDeps(computed);
+    const value = computed.fn(computed._value);
+    if (dep.version === 0 || hasChanged(value, computed._value)) {
+      computed.flags |= 128;
+      computed._value = value;
+      dep.version++;
+    }
+  } catch (err) {
+    dep.version++;
+    throw err;
+  } finally {
+    activeSub = prevSub;
+    shouldTrack = prevShouldTrack;
+    cleanupDeps(computed);
+    computed.flags &= -3;
+  }
+}
+function removeSub(link, soft = false) {
+  const { dep, prevSub, nextSub } = link;
+  if (prevSub) {
+    prevSub.nextSub = nextSub;
+    link.prevSub = undefined;
+  }
+  if (nextSub) {
+    nextSub.prevSub = prevSub;
+    link.nextSub = undefined;
+  }
+  if (dep.subsHead === link) {
+    dep.subsHead = nextSub;
+  }
+  if (dep.subs === link) {
+    dep.subs = prevSub;
+    if (!prevSub && dep.computed) {
+      dep.computed.flags &= -5;
+      for (let l = dep.computed.deps;l; l = l.nextDep) {
+        removeSub(l, true);
+      }
+    }
+  }
+  if (!soft && !--dep.sc && dep.map) {
+    dep.map.delete(dep.key);
+  }
+}
+function removeDep(link) {
+  const { prevDep, nextDep } = link;
+  if (prevDep) {
+    prevDep.nextDep = nextDep;
+    link.prevDep = undefined;
+  }
+  if (nextDep) {
+    nextDep.prevDep = prevDep;
+    link.nextDep = undefined;
+  }
+}
+function effect(fn, options) {
+  if (fn.effect instanceof ReactiveEffect) {
+    fn = fn.effect.fn;
+  }
+  const e = new ReactiveEffect(fn);
+  if (options) {
+    extend(e, options);
+  }
+  try {
+    e.run();
+  } catch (err) {
+    e.stop();
+    throw err;
+  }
+  const runner = e.run.bind(e);
+  runner.effect = e;
+  return runner;
+}
+var shouldTrack = true;
+var trackStack = [];
+function pauseTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = false;
+}
+function resetTracking() {
+  const last = trackStack.pop();
+  shouldTrack = last === undefined ? true : last;
+}
+function onEffectCleanup(fn, failSilently = false) {
+  if (activeSub instanceof ReactiveEffect) {
+    activeSub.cleanup = fn;
+  } else if (!failSilently) {
+    warn(`onEffectCleanup() was called when there was no active effect to associate with.`);
+  }
+}
+function cleanupEffect(e) {
+  const { cleanup } = e;
+  e.cleanup = undefined;
+  if (cleanup) {
+    const prevSub = activeSub;
+    activeSub = undefined;
+    try {
+      cleanup();
+    } finally {
+      activeSub = prevSub;
+    }
+  }
+}
+var globalVersion = 0;
+
+class Link {
+  constructor(sub, dep) {
+    this.sub = sub;
+    this.dep = dep;
+    this.version = dep.version;
+    this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = undefined;
+  }
+}
+
+class Dep {
+  constructor(computed) {
+    this.computed = computed;
+    this.version = 0;
+    this.activeLink = undefined;
+    this.subs = undefined;
+    this.map = undefined;
+    this.key = undefined;
+    this.sc = 0;
+    this.__v_skip = true;
+    if (true) {
+      this.subsHead = undefined;
+    }
+  }
+  track(debugInfo) {
+    if (!activeSub || !shouldTrack || activeSub === this.computed) {
+      return;
+    }
+    let link = this.activeLink;
+    if (link === undefined || link.sub !== activeSub) {
+      link = this.activeLink = new Link(activeSub, this);
+      if (!activeSub.deps) {
+        activeSub.deps = activeSub.depsTail = link;
+      } else {
+        link.prevDep = activeSub.depsTail;
+        activeSub.depsTail.nextDep = link;
+        activeSub.depsTail = link;
+      }
+      addSub(link);
+    } else if (link.version === -1) {
+      link.version = this.version;
+      if (link.nextDep) {
+        const next = link.nextDep;
+        next.prevDep = link.prevDep;
+        if (link.prevDep) {
+          link.prevDep.nextDep = next;
+        }
+        link.prevDep = activeSub.depsTail;
+        link.nextDep = undefined;
+        activeSub.depsTail.nextDep = link;
+        activeSub.depsTail = link;
+        if (activeSub.deps === link) {
+          activeSub.deps = next;
+        }
+      }
+    }
+    if (activeSub.onTrack) {
+      activeSub.onTrack(extend({
+        effect: activeSub
+      }, debugInfo));
+    }
+    return link;
+  }
+  trigger(debugInfo) {
+    this.version++;
+    globalVersion++;
+    this.notify(debugInfo);
+  }
+  notify(debugInfo) {
+    startBatch();
+    try {
+      if (true) {
+        for (let head = this.subsHead;head; head = head.nextSub) {
+          if (head.sub.onTrigger && !(head.sub.flags & 8)) {
+            head.sub.onTrigger(extend({
+              effect: head.sub
+            }, debugInfo));
+          }
+        }
+      }
+      for (let link = this.subs;link; link = link.prevSub) {
+        if (link.sub.notify()) {
+          link.sub.dep.notify();
+        }
+      }
+    } finally {
+      endBatch();
+    }
+  }
+}
+function addSub(link) {
+  link.dep.sc++;
+  if (link.sub.flags & 4) {
+    const computed = link.dep.computed;
+    if (computed && !link.dep.subs) {
+      computed.flags |= 4 | 16;
+      for (let l = computed.deps;l; l = l.nextDep) {
+        addSub(l);
+      }
+    }
+    const currentTail = link.dep.subs;
+    if (currentTail !== link) {
+      link.prevSub = currentTail;
+      if (currentTail)
+        currentTail.nextSub = link;
+    }
+    if (link.dep.subsHead === undefined) {
+      link.dep.subsHead = link;
+    }
+    link.dep.subs = link;
+  }
+}
+var targetMap = /* @__PURE__ */ new WeakMap;
+var ITERATE_KEY = /* @__PURE__ */ Symbol("Object iterate");
+var MAP_KEY_ITERATE_KEY = /* @__PURE__ */ Symbol("Map keys iterate");
+var ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol("Array iterate");
+function track(target, type, key) {
+  if (shouldTrack && activeSub) {
+    let depsMap = targetMap.get(target);
+    if (!depsMap) {
+      targetMap.set(target, depsMap = /* @__PURE__ */ new Map);
+    }
+    let dep = depsMap.get(key);
+    if (!dep) {
+      depsMap.set(key, dep = new Dep);
+      dep.map = depsMap;
+      dep.key = key;
+    }
+    if (true) {
+      dep.track({
+        target,
+        type,
+        key
+      });
+    } else {}
+  }
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) {
+    globalVersion++;
+    return;
+  }
+  const run = (dep) => {
+    if (dep) {
+      if (true) {
+        dep.trigger({
+          target,
+          type,
+          key,
+          newValue,
+          oldValue,
+          oldTarget
+        });
+      } else {}
+    }
+  };
+  startBatch();
+  if (type === "clear") {
+    depsMap.forEach(run);
+  } else {
+    const targetIsArray = isArray(target);
+    const isArrayIndex = targetIsArray && isIntegerKey(key);
+    if (targetIsArray && key === "length") {
+      const newLength = Number(newValue);
+      depsMap.forEach((dep, key2) => {
+        if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
+          run(dep);
+        }
+      });
+    } else {
+      if (key !== undefined || depsMap.has(undefined)) {
+        run(depsMap.get(key));
+      }
+      if (isArrayIndex) {
+        run(depsMap.get(ARRAY_ITERATE_KEY));
+      }
+      switch (type) {
+        case "add":
+          if (!targetIsArray) {
+            run(depsMap.get(ITERATE_KEY));
+            if (isMap(target)) {
+              run(depsMap.get(MAP_KEY_ITERATE_KEY));
+            }
+          } else if (isArrayIndex) {
+            run(depsMap.get("length"));
+          }
+          break;
+        case "delete":
+          if (!targetIsArray) {
+            run(depsMap.get(ITERATE_KEY));
+            if (isMap(target)) {
+              run(depsMap.get(MAP_KEY_ITERATE_KEY));
+            }
+          }
+          break;
+        case "set":
+          if (isMap(target)) {
+            run(depsMap.get(ITERATE_KEY));
+          }
+          break;
+      }
+    }
+  }
+  endBatch();
+}
+function reactiveReadArray(array) {
+  const raw = toRaw(array);
+  if (raw === array)
+    return raw;
+  track(raw, "iterate", ARRAY_ITERATE_KEY);
+  return isShallow(array) ? raw : raw.map(toReactive);
+}
+function shallowReadArray(arr) {
+  track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
+  return arr;
+}
+function toWrapped(target, item) {
+  if (isReadonly(target)) {
+    return isReactive(target) ? toReadonly(toReactive(item)) : toReadonly(item);
+  }
+  return toReactive(item);
+}
+var arrayInstrumentations = {
+  __proto__: null,
+  [Symbol.iterator]() {
+    return iterator(this, Symbol.iterator, (item) => toWrapped(this, item));
+  },
+  concat(...args) {
+    return reactiveReadArray(this).concat(...args.map((x) => isArray(x) ? reactiveReadArray(x) : x));
+  },
+  entries() {
+    return iterator(this, "entries", (value) => {
+      value[1] = toWrapped(this, value[1]);
+      return value;
+    });
+  },
+  every(fn, thisArg) {
+    return apply(this, "every", fn, thisArg, undefined, arguments);
+  },
+  filter(fn, thisArg) {
+    return apply(this, "filter", fn, thisArg, (v) => v.map((item) => toWrapped(this, item)), arguments);
+  },
+  find(fn, thisArg) {
+    return apply(this, "find", fn, thisArg, (item) => toWrapped(this, item), arguments);
+  },
+  findIndex(fn, thisArg) {
+    return apply(this, "findIndex", fn, thisArg, undefined, arguments);
+  },
+  findLast(fn, thisArg) {
+    return apply(this, "findLast", fn, thisArg, (item) => toWrapped(this, item), arguments);
+  },
+  findLastIndex(fn, thisArg) {
+    return apply(this, "findLastIndex", fn, thisArg, undefined, arguments);
+  },
+  forEach(fn, thisArg) {
+    return apply(this, "forEach", fn, thisArg, undefined, arguments);
+  },
+  includes(...args) {
+    return searchProxy(this, "includes", args);
+  },
+  indexOf(...args) {
+    return searchProxy(this, "indexOf", args);
+  },
+  join(separator) {
+    return reactiveReadArray(this).join(separator);
+  },
+  lastIndexOf(...args) {
+    return searchProxy(this, "lastIndexOf", args);
+  },
+  map(fn, thisArg) {
+    return apply(this, "map", fn, thisArg, undefined, arguments);
+  },
+  pop() {
+    return noTracking(this, "pop");
+  },
+  push(...args) {
+    return noTracking(this, "push", args);
+  },
+  reduce(fn, ...args) {
+    return reduce(this, "reduce", fn, args);
+  },
+  reduceRight(fn, ...args) {
+    return reduce(this, "reduceRight", fn, args);
+  },
+  shift() {
+    return noTracking(this, "shift");
+  },
+  some(fn, thisArg) {
+    return apply(this, "some", fn, thisArg, undefined, arguments);
+  },
+  splice(...args) {
+    return noTracking(this, "splice", args);
+  },
+  toReversed() {
+    return reactiveReadArray(this).toReversed();
+  },
+  toSorted(comparer) {
+    return reactiveReadArray(this).toSorted(comparer);
+  },
+  toSpliced(...args) {
+    return reactiveReadArray(this).toSpliced(...args);
+  },
+  unshift(...args) {
+    return noTracking(this, "unshift", args);
+  },
+  values() {
+    return iterator(this, "values", (item) => toWrapped(this, item));
+  }
+};
+function iterator(self2, method, wrapValue) {
+  const arr = shallowReadArray(self2);
+  const iter = arr[method]();
+  if (arr !== self2 && !isShallow(self2)) {
+    iter._next = iter.next;
+    iter.next = () => {
+      const result = iter._next();
+      if (!result.done) {
+        result.value = wrapValue(result.value);
+      }
+      return result;
+    };
+  }
+  return iter;
+}
+var arrayProto = Array.prototype;
+function apply(self2, method, fn, thisArg, wrappedRetFn, args) {
+  const arr = shallowReadArray(self2);
+  const needsWrap = arr !== self2 && !isShallow(self2);
+  const methodFn = arr[method];
+  if (methodFn !== arrayProto[method]) {
+    const result2 = methodFn.apply(self2, args);
+    return needsWrap ? toReactive(result2) : result2;
+  }
+  let wrappedFn = fn;
+  if (arr !== self2) {
+    if (needsWrap) {
+      wrappedFn = function(item, index) {
+        return fn.call(this, toWrapped(self2, item), index, self2);
+      };
+    } else if (fn.length > 2) {
+      wrappedFn = function(item, index) {
+        return fn.call(this, item, index, self2);
+      };
+    }
+  }
+  const result = methodFn.call(arr, wrappedFn, thisArg);
+  return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
+}
+function reduce(self2, method, fn, args) {
+  const arr = shallowReadArray(self2);
+  const needsWrap = arr !== self2 && !isShallow(self2);
+  let wrappedFn = fn;
+  let wrapInitialAccumulator = false;
+  if (arr !== self2) {
+    if (needsWrap) {
+      wrapInitialAccumulator = args.length === 0;
+      wrappedFn = function(acc, item, index) {
+        if (wrapInitialAccumulator) {
+          wrapInitialAccumulator = false;
+          acc = toWrapped(self2, acc);
+        }
+        return fn.call(this, acc, toWrapped(self2, item), index, self2);
+      };
+    } else if (fn.length > 3) {
+      wrappedFn = function(acc, item, index) {
+        return fn.call(this, acc, item, index, self2);
+      };
+    }
+  }
+  const result = arr[method](wrappedFn, ...args);
+  return wrapInitialAccumulator ? toWrapped(self2, result) : result;
+}
+function searchProxy(self2, method, args) {
+  const arr = toRaw(self2);
+  track(arr, "iterate", ARRAY_ITERATE_KEY);
+  const res = arr[method](...args);
+  if ((res === -1 || res === false) && isProxy(args[0])) {
+    args[0] = toRaw(args[0]);
+    return arr[method](...args);
+  }
+  return res;
+}
+function noTracking(self2, method, args = []) {
+  pauseTracking();
+  startBatch();
+  const res = toRaw(self2)[method].apply(self2, args);
+  endBatch();
+  resetTracking();
+  return res;
+}
+var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
+var builtInSymbols = new Set(/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol));
+function hasOwnProperty2(key) {
+  if (!isSymbol(key))
+    key = String(key);
+  const obj = toRaw(this);
+  track(obj, "has", key);
+  return obj.hasOwnProperty(key);
+}
+
+class BaseReactiveHandler {
+  constructor(_isReadonly = false, _isShallow = false) {
+    this._isReadonly = _isReadonly;
+    this._isShallow = _isShallow;
+  }
+  get(target, key, receiver) {
+    if (key === "__v_skip")
+      return target["__v_skip"];
+    const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_isShallow") {
+      return isShallow2;
+    } else if (key === "__v_raw") {
+      if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
+        return target;
+      }
+      return;
+    }
+    const targetIsArray = isArray(target);
+    if (!isReadonly2) {
+      let fn;
+      if (targetIsArray && (fn = arrayInstrumentations[key])) {
+        return fn;
+      }
+      if (key === "hasOwnProperty") {
+        return hasOwnProperty2;
+      }
+    }
+    const res = Reflect.get(target, key, isRef(target) ? target : receiver);
+    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+      return res;
+    }
+    if (!isReadonly2) {
+      track(target, "get", key);
+    }
+    if (isShallow2) {
+      return res;
+    }
+    if (isRef(res)) {
+      const value = targetIsArray && isIntegerKey(key) ? res : res.value;
+      return isReadonly2 && isObject(value) ? readonly(value) : value;
+    }
+    if (isObject(res)) {
+      return isReadonly2 ? readonly(res) : reactive(res);
+    }
+    return res;
+  }
+}
+
+class MutableReactiveHandler extends BaseReactiveHandler {
+  constructor(isShallow2 = false) {
+    super(false, isShallow2);
+  }
+  set(target, key, value, receiver) {
+    let oldValue = target[key];
+    const isArrayWithIntegerKey = isArray(target) && isIntegerKey(key);
+    if (!this._isShallow) {
+      const isOldValueReadonly = isReadonly(oldValue);
+      if (!isShallow(value) && !isReadonly(value)) {
+        oldValue = toRaw(oldValue);
+        value = toRaw(value);
+      }
+      if (!isArrayWithIntegerKey && isRef(oldValue) && !isRef(value)) {
+        if (isOldValueReadonly) {
+          if (true) {
+            warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target[key]);
+          }
+          return true;
+        } else {
+          oldValue.value = value;
+          return true;
+        }
+      }
+    }
+    const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn(target, key);
+    const result = Reflect.set(target, key, value, isRef(target) ? target : receiver);
+    if (target === toRaw(receiver)) {
+      if (!hadKey) {
+        trigger(target, "add", key, value);
+      } else if (hasChanged(value, oldValue)) {
+        trigger(target, "set", key, value, oldValue);
+      }
+    }
+    return result;
+  }
+  deleteProperty(target, key) {
+    const hadKey = hasOwn(target, key);
+    const oldValue = target[key];
+    const result = Reflect.deleteProperty(target, key);
+    if (result && hadKey) {
+      trigger(target, "delete", key, undefined, oldValue);
+    }
+    return result;
+  }
+  has(target, key) {
+    const result = Reflect.has(target, key);
+    if (!isSymbol(key) || !builtInSymbols.has(key)) {
+      track(target, "has", key);
+    }
+    return result;
+  }
+  ownKeys(target) {
+    track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
+    return Reflect.ownKeys(target);
+  }
+}
+
+class ReadonlyReactiveHandler extends BaseReactiveHandler {
+  constructor(isShallow2 = false) {
+    super(true, isShallow2);
+  }
+  set(target, key) {
+    if (true) {
+      warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
+    }
+    return true;
+  }
+  deleteProperty(target, key) {
+    if (true) {
+      warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
+    }
+    return true;
+  }
+}
+var mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler;
+var readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler;
+var toShallow = (value) => value;
+var getProto = (v) => Reflect.getPrototypeOf(v);
+function createIterableMethod(method, isReadonly2, isShallow2) {
+  return function(...args) {
+    const target = this["__v_raw"];
+    const rawTarget = toRaw(target);
+    const targetIsMap = isMap(rawTarget);
+    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+    const isKeyOnly = method === "keys" && targetIsMap;
+    const innerIterator = target[method](...args);
+    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+    !isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
+    return extend(Object.create(innerIterator), {
+      next() {
+        const { value, done } = innerIterator.next();
+        return done ? { value, done } : {
+          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+          done
+        };
+      }
+    });
+  };
+}
+function createReadonlyMethod(type) {
+  return function(...args) {
+    if (true) {
+      const key = args[0] ? `on key "${args[0]}" ` : ``;
+      warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
+    }
+    return type === "delete" ? false : type === "clear" ? undefined : this;
+  };
+}
+function createInstrumentations(readonly, shallow) {
+  const instrumentations = {
+    get(key) {
+      const target = this["__v_raw"];
+      const rawTarget = toRaw(target);
+      const rawKey = toRaw(key);
+      if (!readonly) {
+        if (hasChanged(key, rawKey)) {
+          track(rawTarget, "get", key);
+        }
+        track(rawTarget, "get", rawKey);
+      }
+      const { has } = getProto(rawTarget);
+      const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+      if (has.call(rawTarget, key)) {
+        return wrap(target.get(key));
+      } else if (has.call(rawTarget, rawKey)) {
+        return wrap(target.get(rawKey));
+      } else if (target !== rawTarget) {
+        target.get(key);
+      }
+    },
+    get size() {
+      const target = this["__v_raw"];
+      !readonly && track(toRaw(target), "iterate", ITERATE_KEY);
+      return target.size;
+    },
+    has(key) {
+      const target = this["__v_raw"];
+      const rawTarget = toRaw(target);
+      const rawKey = toRaw(key);
+      if (!readonly) {
+        if (hasChanged(key, rawKey)) {
+          track(rawTarget, "has", key);
+        }
+        track(rawTarget, "has", rawKey);
+      }
+      return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+    },
+    forEach(callback, thisArg) {
+      const observed = this;
+      const target = observed["__v_raw"];
+      const rawTarget = toRaw(target);
+      const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+      !readonly && track(rawTarget, "iterate", ITERATE_KEY);
+      return target.forEach((value, key) => {
+        return callback.call(thisArg, wrap(value), wrap(key), observed);
+      });
+    }
+  };
+  extend(instrumentations, readonly ? {
+    add: createReadonlyMethod("add"),
+    set: createReadonlyMethod("set"),
+    delete: createReadonlyMethod("delete"),
+    clear: createReadonlyMethod("clear")
+  } : {
+    add(value) {
+      const target = toRaw(this);
+      const proto = getProto(target);
+      const rawValue = toRaw(value);
+      const valueToAdd = !shallow && !isShallow(value) && !isReadonly(value) ? rawValue : value;
+      const hadKey = proto.has.call(target, valueToAdd) || hasChanged(value, valueToAdd) && proto.has.call(target, value) || hasChanged(rawValue, valueToAdd) && proto.has.call(target, rawValue);
+      if (!hadKey) {
+        target.add(valueToAdd);
+        trigger(target, "add", valueToAdd, valueToAdd);
+      }
+      return this;
+    },
+    set(key, value) {
+      if (!shallow && !isShallow(value) && !isReadonly(value)) {
+        value = toRaw(value);
+      }
+      const target = toRaw(this);
+      const { has, get } = getProto(target);
+      let hadKey = has.call(target, key);
+      if (!hadKey) {
+        key = toRaw(key);
+        hadKey = has.call(target, key);
+      } else if (true) {
+        checkIdentityKeys(target, has, key);
+      }
+      const oldValue = get.call(target, key);
+      target.set(key, value);
+      if (!hadKey) {
+        trigger(target, "add", key, value);
+      } else if (hasChanged(value, oldValue)) {
+        trigger(target, "set", key, value, oldValue);
+      }
+      return this;
+    },
+    delete(key) {
+      const target = toRaw(this);
+      const { has, get } = getProto(target);
+      let hadKey = has.call(target, key);
+      if (!hadKey) {
+        key = toRaw(key);
+        hadKey = has.call(target, key);
+      } else if (true) {
+        checkIdentityKeys(target, has, key);
+      }
+      const oldValue = get ? get.call(target, key) : undefined;
+      const result = target.delete(key);
+      if (hadKey) {
+        trigger(target, "delete", key, undefined, oldValue);
+      }
+      return result;
+    },
+    clear() {
+      const target = toRaw(this);
+      const hadItems = target.size !== 0;
+      const oldTarget = isMap(target) ? new Map(target) : new Set(target);
+      const result = target.clear();
+      if (hadItems) {
+        trigger(target, "clear", undefined, undefined, oldTarget);
+      }
+      return result;
+    }
+  });
+  const iteratorMethods = [
+    "keys",
+    "values",
+    "entries",
+    Symbol.iterator
+  ];
+  iteratorMethods.forEach((method) => {
+    instrumentations[method] = createIterableMethod(method, readonly, shallow);
+  });
+  return instrumentations;
+}
+function createInstrumentationGetter(isReadonly2, shallow) {
+  const instrumentations = createInstrumentations(isReadonly2, shallow);
+  return (target, key, receiver) => {
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_raw") {
+      return target;
+    }
+    return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
+  };
+}
+var mutableCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
+};
+var readonlyCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
+};
+function checkIdentityKeys(target, has, key) {
+  const rawKey = toRaw(key);
+  if (rawKey !== key && has.call(target, rawKey)) {
+    const type = toRawType(target);
+    warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`);
+  }
+}
+var reactiveMap = /* @__PURE__ */ new WeakMap;
+var shallowReactiveMap = /* @__PURE__ */ new WeakMap;
+var readonlyMap = /* @__PURE__ */ new WeakMap;
+var shallowReadonlyMap = /* @__PURE__ */ new WeakMap;
+function targetTypeMap(rawType) {
+  switch (rawType) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function getTargetType(value) {
+  return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
+}
+function reactive(target) {
+  if (/* @__PURE__ */ isReadonly(target)) {
+    return target;
+  }
+  return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
+}
+function readonly(target) {
+  return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
+}
+function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+  if (!isObject(target)) {
+    if (true) {
+      warn(`value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(target)}`);
+    }
+    return target;
+  }
+  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
+    return target;
+  }
+  const targetType = getTargetType(target);
+  if (targetType === 0) {
+    return target;
+  }
+  const existingProxy = proxyMap.get(target);
+  if (existingProxy) {
+    return existingProxy;
+  }
+  const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
+  proxyMap.set(target, proxy);
+  return proxy;
+}
+function isReactive(value) {
+  if (/* @__PURE__ */ isReadonly(value)) {
+    return /* @__PURE__ */ isReactive(value["__v_raw"]);
+  }
+  return !!(value && value["__v_isReactive"]);
+}
+function isReadonly(value) {
+  return !!(value && value["__v_isReadonly"]);
+}
+function isShallow(value) {
+  return !!(value && value["__v_isShallow"]);
+}
+function isProxy(value) {
+  return value ? !!value["__v_raw"] : false;
+}
+function toRaw(observed) {
+  const raw = observed && observed["__v_raw"];
+  return raw ? /* @__PURE__ */ toRaw(raw) : observed;
+}
+var toReactive = (value) => isObject(value) ? /* @__PURE__ */ reactive(value) : value;
+var toReadonly = (value) => isObject(value) ? /* @__PURE__ */ readonly(value) : value;
+function isRef(r) {
+  return r ? r["__v_isRef"] === true : false;
+}
+function ref(value) {
+  return createRef(value, false);
+}
+function createRef(rawValue, shallow) {
+  if (/* @__PURE__ */ isRef(rawValue)) {
+    return rawValue;
+  }
+  return new RefImpl(rawValue, shallow);
+}
+
+class RefImpl {
+  constructor(value, isShallow2) {
+    this.dep = new Dep;
+    this["__v_isRef"] = true;
+    this["__v_isShallow"] = false;
+    this._rawValue = isShallow2 ? value : toRaw(value);
+    this._value = isShallow2 ? value : toReactive(value);
+    this["__v_isShallow"] = isShallow2;
+  }
+  get value() {
+    if (true) {
+      this.dep.track({
+        target: this,
+        type: "get",
+        key: "value"
+      });
+    } else {}
+    return this._value;
+  }
+  set value(newValue) {
+    const oldValue = this._rawValue;
+    const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
+    newValue = useDirectValue ? newValue : toRaw(newValue);
+    if (hasChanged(newValue, oldValue)) {
+      this._rawValue = newValue;
+      this._value = useDirectValue ? newValue : toReactive(newValue);
+      if (true) {
+        this.dep.trigger({
+          target: this,
+          type: "set",
+          key: "value",
+          newValue,
+          oldValue
+        });
+      } else {}
+    }
+  }
+}
+class ComputedRefImpl {
+  constructor(fn, setter, isSSR) {
+    this.fn = fn;
+    this.setter = setter;
+    this._value = undefined;
+    this.dep = new Dep(this);
+    this.__v_isRef = true;
+    this.deps = undefined;
+    this.depsTail = undefined;
+    this.flags = 16;
+    this.globalVersion = globalVersion - 1;
+    this.next = undefined;
+    this.effect = this;
+    this["__v_isReadonly"] = !setter;
+    this.isSSR = isSSR;
+  }
+  notify() {
+    this.flags |= 16;
+    if (!(this.flags & 8) && activeSub !== this) {
+      batch(this, true);
+      return true;
+    } else if (true)
+      ;
+  }
+  get value() {
+    const link = this.dep.track({
+      target: this,
+      type: "get",
+      key: "value"
+    });
+    refreshComputed(this);
+    if (link) {
+      link.version = this.dep.version;
+    }
+    return this._value;
+  }
+  set value(newValue) {
+    if (this.setter) {
+      this.setter(newValue);
+    } else if (true) {
+      warn("Write operation failed: computed value is readonly");
+    }
+  }
+}
+function computed(getterOrOptions, debugOptions, isSSR = false) {
+  let getter;
+  let setter;
+  if (isFunction(getterOrOptions)) {
+    getter = getterOrOptions;
+  } else {
+    getter = getterOrOptions.get;
+    setter = getterOrOptions.set;
+  }
+  const cRef = new ComputedRefImpl(getter, setter, isSSR);
+  if (debugOptions && !isSSR) {
+    cRef.onTrack = debugOptions.onTrack;
+    cRef.onTrigger = debugOptions.onTrigger;
+  }
+  return cRef;
+}
+
+// src/runtime.js
+async function Jx(source, target = document.body, options) {
+  const base = typeof source === "string" ? new URL(source, location.href).href : location.href;
+  const doc = await resolve(source);
+  if (doc.$elements) {
+    await registerElements(doc.$elements, base);
+  }
+  if (doc.$head) {
+    injectHead(doc.$head, base);
+  }
+  const state = await buildScope(doc, {}, base);
+  target.appendChild(renderNode(doc, state, options));
+  if (typeof state.onMount === "function")
+    state.onMount(state);
+  return state;
+}
+async function resolve(source) {
+  if (typeof source !== "string")
+    return source;
+  const res = await fetch(source);
+  if (!res.ok)
+    throw new Error(`Jx: failed to fetch ${source} (${res.status})`);
+  return res.json();
+}
+var SCHEMA_KEYWORDS = new Set([
+  "type",
+  "properties",
+  "items",
+  "enum",
+  "minimum",
+  "maximum",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "required",
+  "examples"
+]);
+async function buildScope(doc, parentScope = {}, base = location.href) {
+  const raw = {};
+  for (const [key, val] of Object.entries(parentScope)) {
+    raw[key] = val;
+  }
+  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) {
+      const mapped = imports[def2.$prototype];
+      if (mapped) {
+        if (typeof mapped !== "string" || !mapped.endsWith(".class.json")) {
+          console.warn(`Jx: import "${def2.$prototype}" must map to a .class.json path, got "${mapped}"`);
+          continue;
+        }
+        def2.$src = mapped;
+      }
+    }
+  }
+  for (const [key, def2] of Object.entries(defs)) {
+    if (typeof def2 === "string") {
+      if (!def2.includes("${"))
+        raw[key] = def2;
+      continue;
+    }
+    if (typeof def2 === "number" || typeof def2 === "boolean" || def2 === null) {
+      raw[key] = def2;
+      continue;
+    }
+    if (Array.isArray(def2)) {
+      raw[key] = def2;
+      continue;
+    }
+    if (typeof def2 === "object") {
+      if (def2.$prototype)
+        continue;
+      if (def2.timing === "server" && def2.$src && def2.$export)
+        continue;
+      if ("default" in def2) {
+        raw[key] = def2.default;
+        continue;
+      }
+      if (hasSchemaKeywords(def2))
+        continue;
+      raw[key] = def2;
+    }
+  }
+  const state = reactive(raw);
+  for (const [key, def2] of Object.entries(defs)) {
+    if (typeof def2 === "string" && def2.includes("${")) {
+      state[key] = computed(() => evaluateTemplate(def2, state));
+    }
+  }
+  for (const [key, def2] of Object.entries(defs)) {
+    if (typeof def2 === "object" && def2?.$prototype === "Function") {
+      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") {
+      state[key] = await resolvePrototype(def2, state, key, base);
+    }
+  }
+  for (const [key, def2] of Object.entries(defs)) {
+    if (def2 != null && typeof def2 === "object" && def2.timing === "server" && def2.$src && def2.$export && !def2.$prototype) {
+      state[key] = await resolveServerFunction(def2, state, key, base);
+    }
+  }
+  if (doc.$media) {
+    state["$media"] = doc.$media;
+  }
+  return state;
+}
+function hasSchemaKeywords(obj) {
+  for (const k of Object.keys(obj)) {
+    if (SCHEMA_KEYWORDS.has(k))
+      return true;
+  }
+  return false;
+}
+function evaluateTemplate(str, state) {
+  const fn = new Function("state", "$map", `return \`${str}\``);
+  return fn(state, state?.$map);
+}
+var _moduleCache = new Map;
+async function resolveFunction(def2, state, key, base) {
+  if (def2.body && def2.$src) {
+    throw new Error(`Jx: '${key}' declares both body and $src — these are mutually exclusive`);
+  }
+  if (!def2.body && !def2.$src) {
+    throw new Error(`Jx: '${key}' is a Function prototype with no body or $src`);
+  }
+  let fn;
+  if (def2.body) {
+    const params = resolveParamNames(def2);
+    fn = new Function(...params, def2.body);
+    Object.defineProperty(fn, "name", { value: def2.name ?? key, configurable: true });
+  } else {
+    const src = def2.$src;
+    const exportName = def2.$export ?? key;
+    let mod;
+    if (_moduleCache.has(src)) {
+      mod = _moduleCache.get(src);
+    } else {
+      try {
+        mod = await import(src);
+      } catch {
+        if (base) {
+          const resolvedSrc = new URL(src, base).href;
+          mod = await import(resolvedSrc);
+        } else {
+          throw new Error(`Jx: failed to import '$src' "${src}" for "${key}"`);
+        }
+      }
+      _moduleCache.set(src, mod);
+    }
+    fn = mod[exportName] ?? mod.default?.[exportName];
+    if (typeof fn !== "function") {
+      throw new Error(`Jx: export "${exportName}" not found or not a function in "${src}"`);
+    }
+  }
+  if (def2.body && /\breturn\b/.test(def2.body)) {
+    return computed(() => fn(state));
+  }
+  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;
+  }
+  return names.length > 0 && names[0] === "state" ? names : ["state", ...names];
+}
+var RESERVED_KEYS = new Set([
+  "$schema",
+  "$id",
+  "$defs",
+  "state",
+  "$ref",
+  "$props",
+  "$elements",
+  "$switch",
+  "$prototype",
+  "$src",
+  "$export",
+  "$media",
+  "$map",
+  "timing",
+  "default",
+  "description",
+  "body",
+  "parameters",
+  "arguments",
+  "name",
+  "tagName",
+  "children",
+  "style",
+  "attributes",
+  "items",
+  "map",
+  "filter",
+  "sort",
+  "cases",
+  "observedAttributes"
+]);
+function renderNode(def2, state, options) {
+  const path = options?._path ?? [];
+  if (typeof def2 === "string" || typeof def2 === "number" || typeof def2 === "boolean") {
+    const textNode = document.createTextNode(String(def2));
+    if (typeof def2 === "string" && isTemplateString(def2)) {
+      effect(() => {
+        textNode.textContent = evaluateTemplate(def2, state);
+      });
+    }
+    return textNode;
+  }
+  let localState = state;
+  for (const [key, val] of Object.entries(def2)) {
+    if (key.startsWith("$") && !RESERVED_KEYS.has(key)) {
+      if (localState === state)
+        localState = Object.create(state);
+      localState[key] = isRefObj(val) ? resolveRef(val.$ref, state) : val;
+    }
+  }
+  const tagName = def2.tagName ?? "div";
+  const isCustomEl = tagName.includes("-") && customElements.get(tagName);
+  if (def2.$props && isCustomEl) {
+    return renderCustomElementWithProps(def2, localState, options, path);
+  }
+  if (def2.$props) {
+    const { $props: _$props, ...rest } = def2;
+    return renderNode(rest, mergeProps(def2, localState), options);
+  }
+  if (def2.$switch)
+    return renderSwitch(def2, localState, options);
+  if (def2.children?.$prototype === "Array")
+    return renderMappedArray(def2, localState, options);
+  const el = document.createElement(tagName);
+  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));
+  }
+  return el;
+}
+function isTemplateString(val) {
+  return typeof val === "string" && val.includes("${");
+}
+function applyProperties(el, def2, state) {
+  for (const [key, val] of Object.entries(def2)) {
+    if (RESERVED_KEYS.has(key))
+      continue;
+    if (key.startsWith("$"))
+      continue;
+    if (key.startsWith("on")) {
+      if (isRefObj(val)) {
+        const handler = resolveRef(val.$ref, state);
+        if (typeof handler === "function") {
+          const scope = state;
+          el.addEventListener(key.slice(2), (e) => handler(scope, e));
+        }
+        continue;
+      }
+      if (val && typeof val === "object" && val.$prototype === "Function" && 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;
+      }
+    }
+    bindProperty(el, key, val, state);
+  }
+}
+function bindProperty(el, key, val, state) {
+  if (isRefObj(val)) {
+    if (key === "id") {
+      el[key] = resolveRef(val.$ref, state);
+      return;
+    }
+    effect(() => {
+      el[key] = resolveRef(val.$ref, state);
+    });
+    return;
+  }
+  if (isTemplateString(val)) {
+    effect(() => {
+      el[key] = evaluateTemplate(val, state);
+    });
+    return;
+  }
+  el[key] = val;
+}
+function applyStyle(el, styleDef, mediaQueries = {}, state = {}) {
+  const nested = {};
+  const media = {};
+  for (const [prop, val] of Object.entries(styleDef)) {
+    if (prop.startsWith("@"))
+      media[prop] = val;
+    else if (isNestedSelector(prop))
+      nested[prop] = val;
+    else if (prop.startsWith("--")) {
+      if (isTemplateString(val))
+        effect(() => {
+          el.style.setProperty(prop, evaluateTemplate(val, state));
+        });
+      else
+        el.style.setProperty(prop, val);
+    } else if (isTemplateString(val))
+      effect(() => {
+        el.style[prop] = evaluateTemplate(val, state);
+      });
+    else
+      el.style[prop] = val;
+  }
+  const hasNested = Object.keys(nested).length > 0;
+  const hasMedia = Object.keys(media).length > 0;
+  if (!hasNested && !hasMedia)
+    return;
+  const uid = `jx-${Math.random().toString(36).slice(2, 7)}`;
+  el.dataset.jx = uid;
+  let css = "";
+  for (const [sel, rules] of Object.entries(nested)) {
+    const resolved = sel.startsWith("&") ? sel.replace("&", `[data-jx="${uid}"]`) : sel.startsWith("[") ? `[data-jx="${uid}"]${sel}` : `[data-jx="${uid}"] ${sel}`;
+    css += `${resolved} { ${toCSSText(rules)} }
+`;
+  }
+  for (const [key, rules] of Object.entries(media)) {
+    if (key === "@--")
+      continue;
+    const query = key.startsWith("@--") ? mediaQueries[key.slice(1)] ?? key.slice(1) : key.slice(1);
+    const scope = `[data-jx="${uid}"]`;
+    css += `@media ${query} { ${scope} { ${toCSSText(rules)} } }
+`;
+    for (const [sel, nestedRules] of Object.entries(rules)) {
+      if (!isNestedSelector(sel))
+        continue;
+      const resolved = sel.startsWith("&") ? sel.replace("&", scope) : sel.startsWith("[") ? `${scope}${sel}` : `${scope} ${sel}`;
+      css += `@media ${query} { ${resolved} { ${toCSSText(nestedRules)} } }
+`;
+    }
+  }
+  const tag = document.createElement("style");
+  tag.textContent = css;
+  document.head.appendChild(tag);
+}
+function applyAttributes(el, attrs, state) {
+  for (const [k, v] of Object.entries(attrs)) {
+    if (isRefObj(v)) {
+      effect(() => el.setAttribute(k, String(resolveRef(v.$ref, state) ?? "")));
+    } else if (isTemplateString(v)) {
+      effect(() => el.setAttribute(k, String(evaluateTemplate(v, state))));
+    } else {
+      el.setAttribute(k, String(v));
+    }
+  }
+}
+function renderMappedArray(def2, state, options) {
+  const path = options?._path ?? [];
+  const container = document.createElement(def2.tagName ?? "div");
+  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;
+  effect(() => {
+    container.innerHTML = "";
+    let items;
+    if (isRefObj(itemsSrc)) {
+      items = resolveRef(itemsSrc.$ref, state);
+    } else {
+      items = itemsSrc;
+    }
+    if (!Array.isArray(items))
+      return;
+    if (filterRef) {
+      const fn = resolveRef(filterRef.$ref, state);
+      if (typeof fn === "function")
+        items = items.filter(fn);
+    }
+    if (sortRef) {
+      const fn = resolveRef(sortRef.$ref, state);
+      if (typeof fn === "function")
+        items = [...items].sort(fn);
+    }
+    items.forEach((item, index) => {
+      const child = Object.create(state);
+      child.$map = { item, index };
+      child["$map/item"] = item;
+      child["$map/index"] = index;
+      const childOpts = options ? { ...options, _path: [...path, "children", "map", index] } : undefined;
+      container.appendChild(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)
+    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 = "";
+    const key = resolveRef(def2.$switch.$ref, state);
+    const caseDef = def2.cases?.[key];
+    if (!caseDef)
+      return;
+    if (isRefObj(caseDef)) {
+      const gen = ++generation;
+      const href = new URL(caseDef.$ref, location.href).href;
+      resolve(href).then(async (doc) => {
+        if (gen !== generation)
+          return;
+        const childScope = await buildScope(doc, {}, href);
+        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));
+      return;
+    }
+    const childOpts = options ? { ...options, _path: [...path, "cases", key] } : undefined;
+    container.appendChild(renderNode(caseDef, state, childOpts));
+  });
+  return container;
+}
+async function resolvePrototype(def2, state, key, base) {
+  if (def2.$src) {
+    return resolveExternalPrototype(def2, state, key, base);
+  }
+  switch (def2.$prototype) {
+    case "Request": {
+      const s = ref(null);
+      const debounceMs = def2.debounce ?? 0;
+      let debounceTimer = null;
+      if (!def2.manual) {
+        effect(() => {
+          let url;
+          if (isTemplateString(def2.url)) {
+            url = evaluateTemplate(def2.url, state);
+          } else {
+            url = def2.url;
+          }
+          if (!url || url === "undefined" || url.includes("undefined"))
+            return;
+          const controller = new AbortController;
+          onEffectCleanup(() => {
+            controller.abort();
+            clearTimeout(debounceTimer);
+          });
+          const doFetch = () => fetch(url, {
+            signal: controller.signal,
+            method: def2.method ?? "GET",
+            ...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) };
+          });
+          if (debounceMs > 0) {
+            debounceTimer = setTimeout(doFetch, debounceMs);
+          } else {
+            doFetch();
+          }
+        });
+      }
+      return s;
+    }
+    case "URLSearchParams":
+      return computed(() => {
+        const p = {};
+        for (const [k, v] of Object.entries(def2)) {
+          if (k !== "$prototype") {
+            p[k] = isRefObj(v) ? resolveRef(v.$ref, state) : isTemplateString(v) ? evaluateTemplate(v, state) : v;
+          }
+        }
+        return new URLSearchParams(p).toString();
+      });
+    case "LocalStorage":
+    case "SessionStorage": {
+      const store = def2.$prototype === "LocalStorage" ? localStorage : sessionStorage;
+      const k = def2.key ?? key;
+      let init;
+      try {
+        const s = store.getItem(k);
+        init = s !== null ? JSON.parse(s) : def2.default ?? null;
+      } catch {
+        init = def2.default ?? null;
+      }
+      const storageState = ref(init);
+      effect(() => {
+        const v = storageState.value;
+        if (v === null) {
+          try {
+            store.removeItem(k);
+          } catch {}
+        } else {
+          try {
+            store.setItem(k, JSON.stringify(v));
+          } catch {}
+        }
+      });
+      return storageState;
+    }
+    case "Cookie": {
+      const name = def2.name ?? key;
+      const read = () => {
+        const m = document.cookie.match(new RegExp("(?:^|; )" + name + "=([^;]*)"));
+        if (!m)
+          return null;
+        try {
+          return JSON.parse(decodeURIComponent(m[1]));
+        } catch {
+          return m[1];
+        }
+      };
+      const cookieState = ref(read() ?? def2.default ?? null);
+      effect(() => {
+        const v = cookieState.value;
+        let s = `${name}=${encodeURIComponent(JSON.stringify(v))}`;
+        if (def2.maxAge !== undefined)
+          s += `; Max-Age=${def2.maxAge}`;
+        if (def2.path)
+          s += `; Path=${def2.path}`;
+        if (def2.domain)
+          s += `; Domain=${def2.domain}`;
+        if (def2.secure)
+          s += `; Secure`;
+        if (def2.sameSite)
+          s += `; SameSite=${def2.sameSite}`;
+        document.cookie = s;
+      });
+      return cookieState;
+    }
+    case "IndexedDB": {
+      const idbState = ref(null);
+      const {
+        database,
+        store,
+        version = 1,
+        keyPath = "id",
+        autoIncrement = true,
+        indexes = []
+      } = def2;
+      const req = indexedDB.open(database, version);
+      req.onupgradeneeded = (e) => {
+        const db = e.target?.result;
+        if (!db.objectStoreNames.contains(store)) {
+          const os = db.createObjectStore(store, { keyPath, autoIncrement });
+          for (const i of indexes)
+            os.createIndex(i.name, i.keyPath, { unique: i.unique ?? false });
+        }
+      };
+      req.onsuccess = (e) => {
+        const db = e.target?.result;
+        idbState.value = {
+          database,
+          store,
+          version,
+          isReady: true,
+          getStore: (mode = "readwrite") => Promise.resolve(db.transaction(store, mode).objectStore(store))
+        };
+      };
+      req.onerror = () => {
+        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 "FormData": {
+      const fd = new FormData;
+      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":
+      return null;
+    default:
+      console.warn(`Jx: unknown $prototype "${def2.$prototype}" for "${key}". Did you mean to add '$src'?`);
+      return ref(null);
+  }
+}
+var EXTERNAL_RESERVED = new Set([
+  "$prototype",
+  "$src",
+  "$export",
+  "timing",
+  "default",
+  "description",
+  "body",
+  "parameters",
+  "arguments",
+  "name"
+]);
+async function resolveExternalPrototype(def2, state, key, base) {
+  const src = def2.$src;
+  if (!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);
+}
+async function importAndInstantiate(def2, src, exportName, base) {
+  let mod;
+  if (_moduleCache.has(src)) {
+    mod = _moduleCache.get(src);
+  } else {
+    try {
+      mod = await import(src);
+    } catch {
+      if (base) {
+        const resolvedSrc = new URL(src, base).href;
+        mod = await import(resolvedSrc);
+      } else {
+        throw new Error(`Failed to import "${src}"`);
+      }
+    }
+    _moduleCache.set(src, mod);
+  }
+  const ExportedClass = mod[exportName] ?? mod.default?.[exportName];
+  if (!ExportedClass) {
+    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`);
+  }
+  const config = {};
+  for (const [k, v] of Object.entries(def2)) {
+    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;
+  } else {
+    value = instance;
+  }
+  const s = ref(value);
+  if (typeof instance.subscribe === "function") {
+    instance.subscribe((newVal) => {
+      s.value = newVal;
+    });
+  }
+  return s;
+}
+async function resolveClassJson(def2, state, key, base) {
+  const src = def2.$src;
+  let classDef;
+  try {
+    const url = base ? new URL(src, base).href : src;
+    const res = await fetch(url);
+    if (!res.ok)
+      throw new Error(`HTTP ${res.status}`);
+    classDef = await res.json();
+  } catch {
+    return resolveViaDevProxy(def2, state, key, base);
+  }
+  if (classDef.$implementation) {
+    const schemaUrl = base ? new URL(src, base).href : new URL(src, location.href).href;
+    const implSrc = new URL(classDef.$implementation, schemaUrl).href;
+    const exportName = def2.$export ?? classDef.title ?? def2.$prototype;
+    try {
+      return await importAndInstantiate(def2, implSrc, exportName, base);
+    } catch {
+      return resolveViaDevProxy(def2, state, key, base);
+    }
+  }
+  const DynClass = classFromSchema(classDef);
+  const config = {};
+  for (const [k, v] of Object.entries(def2)) {
+    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;
+  } else {
+    value = instance;
+  }
+  const s = ref(value);
+  if (typeof instance.subscribe === "function") {
+    instance.subscribe((newVal) => {
+      s.value = newVal;
+    });
+  }
+  return s;
+}
+function classFromSchema(classDef) {
+  const fields = classDef.$defs?.fields ?? {};
+  const ctor = classDef.$defs?.constructor;
+  const methods = classDef.$defs?.methods ?? {};
+
+  class DynClass {
+    constructor(config = {}) {
+      for (const [key, field] of Object.entries(fields)) {
+        const typedField = field;
+        const id = typedField.identifier ?? key;
+        const propName = typedField.access === "private" ? `_${id}` : id;
+        if (config[id] !== undefined)
+          this[propName] = config[id];
+        else if (typedField.initializer !== undefined)
+          this[propName] = typedField.initializer;
+        else if (typedField.default !== undefined)
+          this[propName] = structuredClone(typedField.default);
+        else
+          this[propName] = null;
+      }
+      if (ctor?.body) {
+        const bodyStr = Array.isArray(ctor.body) ? ctor.body.join(`
+`) : ctor.body;
+        new Function("config", bodyStr).call(this, config);
+      }
+    }
+  }
+  for (const [key, method] of Object.entries(methods)) {
+    const typedMethod = method;
+    const name = typedMethod.identifier ?? key;
+    const params = (typedMethod.parameters ?? []).map((p) => {
+      if (p.$ref)
+        return p.$ref.split("/").pop();
+      return p.identifier ?? p.name ?? "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.setter) {
+        const sp = (typedMethod.setter.parameters ?? []).map((p) => p.$ref?.split("/").pop() ?? "v");
+        descriptor.set = new Function(...sp, typedMethod.setter.body);
+      }
+      Object.defineProperty(DynClass.prototype, name, { ...descriptor, configurable: true });
+    } else if (typedMethod.scope === "static") {
+      DynClass[name] = new Function(...params, bodyStr);
+    } else {
+      DynClass.prototype[name] = new Function(...params, bodyStr);
+    }
+  }
+  Object.defineProperty(DynClass, "name", { value: classDef.title, configurable: true });
+  return DynClass;
+}
+async function resolveViaDevProxy(def2, state, key, base) {
+  const config = {};
+  for (const [k, v] of Object.entries(def2)) {
+    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,
+      ...resolvedConfig
+    })
+  }).then((r) => {
+    if (!r.ok)
+      throw new Error(`Jx dev proxy ${r.status} for "${key}"`);
+    return r.json();
+  });
+  const s = ref(null);
+  if (hasTemplates) {
+    effect(() => {
+      const resolvedConfig = {};
+      for (const [k, v] of Object.entries(config)) {
+        resolvedConfig[k] = isTemplateString(v) ? evaluateTemplate(v, state) : v;
+      }
+      doResolve(resolvedConfig).then((value) => {
+        s.value = value;
+      }).catch((e) => console.error("Jx dev proxy:", e));
+    });
+  } else {
+    doResolve(config).then((value) => {
+      s.value = value;
+    }).catch((e) => console.error("Jx dev proxy:", e));
+  }
+  return s;
+}
+async function resolveServerFunction(def2, state, key, base) {
+  const src = def2.$src;
+  const exportName = def2.$export;
+  let mod;
+  if (_moduleCache.has(src)) {
+    mod = _moduleCache.get(src);
+  } else {
+    try {
+      mod = await import(src);
+    } catch {
+      if (base) {
+        try {
+          const resolvedSrc = new URL(src, base).href;
+          mod = await import(resolvedSrc);
+        } catch {
+          return resolveServerFunctionViaProxy(def2, state, key, base);
+        }
+      } else {
+        return resolveServerFunctionViaProxy(def2, state, key, base);
+      }
+    }
+    _moduleCache.set(src, mod);
+  }
+  const fn = mod[exportName] ?? mod.default?.[exportName];
+  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`);
+  const rawArgs = def2.arguments ?? {};
+  const hasReactiveArg = Object.values(rawArgs).some((v) => isRefObj(v));
+  const resolveArgs = () => {
+    const args = {};
+    for (const [k, v] of Object.entries(rawArgs)) {
+      args[k] = isRefObj(v) ? resolveRef(v.$ref, state) : v;
+    }
+    return args;
+  };
+  const s = ref(null);
+  if (hasReactiveArg) {
+    effect(() => {
+      const args = resolveArgs();
+      onEffectCleanup(() => {});
+      fn(args).then((result) => {
+        s.value = result;
+      }).catch(() => {});
+    });
+  } else {
+    s.value = await fn(resolveArgs());
+  }
+  return s;
+}
+async function resolveServerFunctionViaProxy(def2, state, key, base) {
+  const rawArgs = def2.arguments ?? {};
+  const hasReactiveArg = Object.values(rawArgs).some((v) => isRefObj(v));
+  const resolveArgs = () => {
+    const args = {};
+    for (const [k, v] of Object.entries(rawArgs)) {
+      args[k] = isRefObj(v) ? resolveRef(v.$ref, state) : v;
+    }
+    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,
+      arguments: args
+    })
+  }).then((r) => {
+    if (!r.ok)
+      throw new Error(`Jx server proxy ${r.status} for "${key}"`);
+    return r.json();
+  });
+  const s = ref(null);
+  if (hasReactiveArg) {
+    effect(() => {
+      const args = resolveArgs();
+      onEffectCleanup(() => {});
+      doResolve(args).then((result) => {
+        s.value = result;
+      }).catch((e) => console.error("Jx server proxy:", e));
+    });
+  } else {
+    doResolve(resolveArgs()).then((result) => {
+      s.value = result;
+    }).catch((e) => console.error("Jx server proxy:", e));
+  }
+  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];
+    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)
+      return state[sub];
+    return getPath(state[sub.slice(0, slash)], sub.slice(slash + 1));
+  }
+  if (ref2.startsWith("parent#/"))
+    return state[ref2.slice("parent#/".length)];
+  if (ref2.startsWith("window#/"))
+    return getPath(globalThis.window, ref2.slice("window#/".length));
+  if (ref2.startsWith("document#/"))
+    return getPath(globalThis.document, ref2.slice("document#/".length));
+  return state[ref2] ?? null;
+}
+function isSignal(v) {
+  return isRef(v);
+}
+function isRefObj(v) {
+  return v !== null && typeof v === "object" && typeof v.$ref === "string";
+}
+function isNestedSelector(k) {
+  return k.startsWith(":") || k.startsWith(".") || k.startsWith("&") || k.startsWith("[");
+}
+function getPath(obj, path) {
+  return path.split(/[./]/).reduce((o, k) => o?.[k], obj);
+}
+function mergeProps(def2, parentState) {
+  const child = Object.create(parentState);
+  for (const [k, v] of Object.entries(def2.$props ?? {})) {
+    child[k] = isRefObj(v) ? resolveRef(v.$ref, parentState) : v;
+  }
+  return child;
+}
+function camelToKebab(s) {
+  return s.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+}
+function toCSSText(rules) {
+  return Object.entries(rules).filter(([k]) => !isNestedSelector(k)).map(([p, v]) => `${camelToKebab(p)}: ${v}`).join("; ");
+}
+var _elementDefs = new Map;
+async function registerElements(elements, base) {
+  for (const entry of elements) {
+    if (typeof entry === "string") {
+      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);
+      }
+      continue;
+    }
+    if (!isRefObj(entry))
+      continue;
+    const href = new URL(entry.$ref, base).href;
+    const doc = await resolve(href);
+    if (!doc.tagName || !doc.tagName.includes("-"))
+      continue;
+    if (customElements.get(doc.tagName))
+      continue;
+    if (doc.$elements) {
+      await registerElements(doc.$elements, href);
+    }
+    await defineElement(doc, href);
+  }
+}
+function injectHead(entries, _base) {
+  for (const entry of entries) {
+    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 selector = `${tag}${attrs.href ? `[href="${attrs.href}"]` : ""}${attrs.src ? `[src="${attrs.src}"]` : ""}`;
+    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);
+    }
+    if (entry.textContent)
+      el.textContent = entry.textContent;
+    document.head.appendChild(el);
+  }
+}
+async function defineElement(source, base) {
+  if (typeof source === "string") {
+    base = new URL(source, base ?? location.href).href;
+    source = await resolve(source);
+  }
+  base = base ?? location.href;
+  const source_ = source;
+  const tagName = source_.tagName;
+  if (!tagName || !tagName.includes("-")) {
+    throw new Error(`Jx defineElement: tagName "${tagName}" must contain a hyphen`);
+  }
+  if (customElements.get(tagName))
+    return;
+  if (source_.$elements) {
+    await registerElements(source_.$elements, base);
+  }
+  _elementDefs.set(tagName, { doc: source_, base });
+  const def2 = source_;
+  const observedAttrs = def2.observedAttributes ?? [];
+  const ElementClass = class extends HTMLElement {
+    static get observedAttributes() {
+      return observedAttrs;
+    }
+    async connectedCallback() {
+      const state = await buildScope(def2, {}, base);
+      for (const key of Object.keys(def2.state ?? {})) {
+        if (key in this && this[key] !== undefined) {
+          state[key] = this[key];
+        }
+      }
+      for (const key of Object.keys(def2.state ?? {})) {
+        if (!(key in HTMLElement.prototype)) {
+          Object.defineProperty(this, key, {
+            get: () => state[key],
+            set: (v) => {
+              state[key] = v;
+            },
+            configurable: true
+          });
+        }
+      }
+      this._state = state;
+      const slottedChildren = Array.from(this.childNodes);
+      this.innerHTML = "";
+      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));
+      }
+      distributeSlots(this, slottedChildren);
+      if (typeof state.onMount === "function") {
+        queueMicrotask(() => state.onMount(state));
+      }
+    }
+    disconnectedCallback() {
+      const self2 = this;
+      if (typeof self2._state?.onUnmount === "function") {
+        self2._state.onUnmount(self2._state);
+      }
+    }
+    adoptedCallback() {
+      const self2 = this;
+      if (typeof self2._state?.onAdopted === "function") {
+        self2._state.onAdopted(self2._state);
+      }
+    }
+    attributeChangedCallback(name, oldVal, newVal) {
+      const self2 = this;
+      if (!self2._state || oldVal === newVal)
+        return;
+      const camelKey = name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+      const current = self2._state[camelKey];
+      if (typeof current === "number")
+        self2._state[camelKey] = Number(newVal);
+      else if (typeof current === "boolean")
+        self2._state[camelKey] = newVal !== null && newVal !== "false";
+      else
+        self2._state[camelKey] = newVal;
+    }
+  };
+  customElements.define(tagName, ElementClass);
+}
+function renderCustomElementWithProps(def2, state, options, path) {
+  const el = document.createElement(def2.tagName);
+  if (options?.onNodeCreated)
+    options.onNodeCreated(el, path, def2);
+  for (const [key, val] of Object.entries(def2.$props ?? {})) {
+    if (isRefObj(val)) {
+      const resolved = resolveRef(val.$ref, state);
+      el[key] = resolved;
+      effect(() => {
+        el[key] = resolveRef(val.$ref, state);
+      });
+    } else if (isTemplateString(val)) {
+      effect(() => {
+        el[key] = evaluateTemplate(val, state);
+      });
+    } else {
+      el[key] = val;
+    }
+  }
+  applyStyle(el, def2.style ?? {}, state["$media"] ?? {}, state);
+  applyAttributes(el, def2.attributes ?? {}, state);
+  const children = Array.isArray(def2.children) ? def2.children : [];
+  for (let i = 0;i < children.length; i++) {
+    el.appendChild(renderNode(children[i], state, options));
+  }
+  return el;
+}
+function distributeSlots(host, slottedChildren) {
+  if (slottedChildren.length === 0)
+    return;
+  const slots = host.querySelectorAll("slot");
+  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))
+        named.set(name, []);
+      named.get(name).push(child);
+    } else {
+      unnamed.push(child);
+    }
+  }
+  for (const slot of slots) {
+    const name = slot.getAttribute("name");
+    const matches = name ? named.get(name) ?? [] : unnamed;
+    if (matches.length > 0) {
+      slot.innerHTML = "";
+      for (const child of matches) {
+        slot.appendChild(child);
+      }
+    }
+  }
+}
+export {
+  toCSSText,
+  resolveRef,
+  resolvePrototype,
+  resolve,
+  renderNode,
+  isSignal,
+  hasSchemaKeywords,
+  defineElement,
+  camelToKebab,
+  buildScope,
+  applyStyle,
+  RESERVED_KEYS,
+  Jx
+};
+
+//# debugId=302268380091C32C64756E2164756E21
+//# sourceMappingURL=runtime.js.map