@source-crafter/xzor-runtime 0.1.9 → 0.1.11

package/index-k290gfdd.js

@@ -0,0 +1,1054 @@
+// runtime/index.ts
+var fineHooks;
+var FINE = Symbol("xzor.fine");
+var isFine = (c) => c[FINE] === true;
+function setFineHooks(h) {
+  fineHooks = h;
+}
+function patchIsland(owner, app, scope, end, old, build) {
+  const builder = new RenderTreeBuilder(owner);
+  build(builder);
+  const next = builder.nodes;
+  batch(() => patchList(end.parentNode, old, next, end, owner, app, scope));
+  return next;
+}
+function disposeIsland(tree) {
+  for (const v of tree)
+    dispose(v);
+}
+var $isFragment = (value) => isFragment(value);
+var SVG = "http://www.w3.org/2000/svg";
+var $inSvg = (parent) => parent.namespaceURI === SVG && parent.nodeName !== "foreignObject";
+var inSvg = $inSvg;
+function fineNodes(root) {
+  const nodes = [];
+  for (let n = root.start;n !== null; n = n.nextSibling) {
+    nodes.push(n);
+    if (n === root.end)
+      break;
+  }
+  return nodes;
+}
+
+class Route {
+  path;
+  tag;
+  params;
+  query;
+  match;
+  #nav;
+  constructor(path, tag, params, query, match, nav) {
+    this.path = path;
+    this.tag = tag;
+    this.params = params;
+    this.query = query;
+    this.match = match;
+    this.#nav = nav;
+  }
+  is(tag) {
+    return this.tag === tag;
+  }
+  navigate(url, opts) {
+    if (this.#nav)
+      this.#nav.navigate(url, opts?.replace === true);
+    else
+      location.href = url;
+  }
+}
+var navigated = new Set;
+var observers = new Set;
+var EXTERNAL = /(^|\s)external(\s|$)/;
+var transitions = false;
+function viewTransitions(on) {
+  transitions = on;
+}
+function notifyNavigated() {
+  const doc = document;
+  if (transitions && doc.startViewTransition)
+    doc.startViewTransition(notifyAll).ready.catch(noop);
+  else
+    notifyAll();
+}
+function notifyAll() {
+  for (const fn of [...navigated])
+    fn();
+  for (const fn of [...observers])
+    fn();
+}
+var onPopState = () => notifyNavigated();
+function onLinkClick(e) {
+  if (e.defaultPrevented || e.button !== 0 || e.ctrlKey || e.metaKey || e.shiftKey || e.altKey)
+    return;
+  const anchor = e.target?.closest?.("a");
+  const href = anchor?.getAttribute("href");
+  if (!anchor || href == null || href.startsWith("#"))
+    return;
+  const frame = anchor.getAttribute("target");
+  if (frame !== null && frame !== "_self" || anchor.hasAttribute("download"))
+    return;
+  const rel = anchor.getAttribute("rel");
+  if (rel !== null && EXTERNAL.test(rel))
+    return;
+  const url = new URL(href, document.baseURI);
+  if (url.origin !== location.origin)
+    return;
+  if (url.hash !== "" && url.pathname === location.pathname && url.search === location.search)
+    return;
+  e.preventDefault();
+  browserNavigation.navigate(url.href, false);
+}
+var currentUrl;
+var browserNavigation = {
+  current: () => currentUrl?.href === location.href ? currentUrl : currentUrl = new URL(location.href),
+  navigate(url, replace) {
+    const href = new URL(url, document.baseURI).href;
+    if (replace)
+      history.replaceState(null, "", href);
+    else
+      history.pushState(null, "", href);
+    notifyNavigated();
+  },
+  subscribe(fn) {
+    navigated.add(fn);
+    if (navigated.size === 1) {
+      if (observers.size === 0)
+        window.addEventListener("popstate", onPopState);
+      document.addEventListener("click", onLinkClick);
+    }
+    return () => {
+      navigated.delete(fn);
+      if (navigated.size === 0) {
+        if (observers.size === 0)
+          window.removeEventListener("popstate", onPopState);
+        document.removeEventListener("click", onLinkClick);
+      }
+    };
+  },
+  observe(fn) {
+    observers.add(fn);
+    if (observers.size === 1 && navigated.size === 0)
+      window.addEventListener("popstate", onPopState);
+    return () => {
+      observers.delete(fn);
+      if (observers.size === 0 && navigated.size === 0)
+        window.removeEventListener("popstate", onPopState);
+    };
+  }
+};
+var testNavigation;
+function setNavigationForTests(nav) {
+  testNavigation = nav;
+}
+var navigationOf = () => testNavigation ?? browserNavigation;
+var ROUTER = Symbol("xzor.router");
+function segmentsOf(pathname) {
+  const rest = pathname.startsWith("/") ? pathname.slice(1) : pathname;
+  return rest === "" ? [] : rest.split("/");
+}
+var baseFor;
+var base = "";
+function basePath() {
+  const uri = document.baseURI;
+  if (uri !== baseFor) {
+    baseFor = uri;
+    const path = document.querySelector("base[href]") ? new URL(uri).pathname : "/";
+    base = path.slice(0, path.lastIndexOf("/"));
+  }
+  return base;
+}
+function routePath(pathname) {
+  const b = basePath();
+  return b !== "" && (pathname === b || pathname.startsWith(`${b}/`)) ? pathname.slice(b.length) || "/" : pathname;
+}
+function groupsOf(re, pathname) {
+  re.lastIndex = 0;
+  const m = re.exec(pathname);
+  return m ? m.groups ?? {} : null;
+}
+function resolveRoute(router, table, sections, url) {
+  const path = routePath(url.pathname);
+  const segments = segmentsOf(path);
+  let page;
+  let params = null;
+  for (const entry of table) {
+    params = entry.match(segments);
+    if (params) {
+      page = entry;
+      break;
+    }
+  }
+  let section = -1;
+  let match = {};
+  for (let i = 0;i < sections.length && section < 0; i++) {
+    const s = sections[i];
+    if (page) {
+      if (s.kind === "tag") {
+        if (s.tag === page.tag)
+          section = i;
+      } else if (s.kind === "regex" && s.page) {
+        const groups = groupsOf(s.re, path);
+        if (groups) {
+          section = i;
+          match = groups;
+        }
+      } else if (s.kind === "pattern" && s.page) {
+        const own = s.match(segments);
+        if (own) {
+          section = i;
+          match = own;
+        }
+      }
+    } else if (s.kind === "regex" && !s.page) {
+      const groups = groupsOf(s.re, path);
+      if (groups) {
+        section = i;
+        match = groups;
+      }
+    } else if (s.kind === "pattern" && !s.page) {
+      const own = s.match(segments);
+      if (own) {
+        section = i;
+        params = own;
+      }
+    }
+  }
+  if (section < 0)
+    section = sections.findIndex((s) => s.kind === (page ? "default" : "notFound"));
+  router.href = url.href;
+  router.id++;
+  router.page = page;
+  router.params = params ?? {};
+  router.section = section;
+  router.route = new Route(path, page?.tag, router.params, url.searchParams, match, router.nav);
+}
+function renavigate(owner) {
+  if (depth === 0)
+    update(owner);
+  else
+    queueMicrotask(() => update(owner));
+}
+var noop = () => {};
+var SELECTOR = /[#.[]/;
+var rethrow = (err) => queueMicrotask(() => {
+  throw err;
+});
+function surface(result) {
+  if (result instanceof Promise)
+    result.catch(rethrow);
+}
+var wellKnown = Symbol;
+function polyfillDisposeSymbols(target) {
+  target.dispose ??= Symbol.for("Symbol.dispose");
+  target.asyncDispose ??= Symbol.for("Symbol.asyncDispose");
+}
+polyfillDisposeSymbols(wellKnown);
+var ServiceProvider = () => noop;
+var Mount = (_component, _target) => noop;
+var Import = (..._providers) => noop;
+var Singleton = () => noop;
+var Scoped = () => noop;
+var Transient = () => noop;
+var SharedInstance = Symbol("xzor.sharedInstance");
+var mountedComponents = new WeakMap;
+var elementHandlers = new WeakMap;
+var FRAGMENT = Symbol("xzor.fragment");
+function isFragment(value) {
+  return typeof value === "function" && FRAGMENT in value;
+}
+
+class ComponentBase {
+  static fragment(build) {
+    return Object.assign(build, { [FRAGMENT]: true });
+  }
+  static bindValue(e, current) {
+    const input = e.target;
+    if (typeof current === "boolean")
+      return input.checked;
+    if (typeof current === "number")
+      return Number(input.value);
+    return input.value;
+  }
+  slots = {};
+  onInitialized() {}
+  onInitializedAsync() {}
+  onParametersSet() {}
+  onParametersSetAsync() {}
+  onAfterRender(_firstRender) {}
+  onAfterRenderAsync(_firstRender) {}
+  shouldRender() {
+    return true;
+  }
+  dispose() {}
+  stateHasChanged() {
+    update(this);
+  }
+}
+var hooks = (c) => c;
+
+class RenderTreeBuilder {
+  owner;
+  #root = [];
+  #open = [];
+  constructor(owner) {
+    this.owner = owner;
+  }
+  get nodes() {
+    return this.#root;
+  }
+  #append(node) {
+    (this.#open.at(-1)?.children ?? this.#root).push(node);
+  }
+  #current() {
+    const el = this.#open.at(-1);
+    if (el?.kind !== "element")
+      throw new Error("xzor: attribute outside of an element");
+    return el;
+  }
+  openElement(tag) {
+    const el = { kind: "element", tag, attrs: {}, events: {}, modifiers: {}, children: [] };
+    this.#append(el);
+    this.#open.push(el);
+  }
+  closeElement() {
+    this.#open.pop();
+  }
+  openRegion() {
+    const region = { kind: "region", children: [] };
+    this.#append(region);
+    this.#open.push(region);
+  }
+  openCascade(name, value, fixed) {
+    const region = { kind: "region", children: [], name, value, fixed: fixed === true };
+    this.#append(region);
+    this.#open.push(region);
+  }
+  closeRegion() {
+    this.#open.pop();
+  }
+  addRoutes(engine, table, sections) {
+    const owner = this.owner;
+    const nav = navigationOf();
+    let router = owner[ROUTER];
+    if (!router) {
+      router = owner[ROUTER] = {
+        nav: engine === "client" ? nav : undefined,
+        off: undefined,
+        onError: undefined,
+        caught: sections.find((s) => s.kind === "catch"),
+        href: "",
+        id: 0,
+        route: undefined,
+        section: -1,
+        page: undefined,
+        params: {},
+        error: undefined,
+        failed: false
+      };
+      const failing = router;
+      if (router.caught) {
+        router.onError = (err, id) => {
+          if (id !== failing.id)
+            return;
+          failing.error = err;
+          failing.failed = true;
+          queueMicrotask(() => update(owner));
+        };
+      }
+      if (router.nav)
+        router.off = router.nav.subscribe(() => renavigate(owner));
+    }
+    const state = router;
+    const url = nav.current();
+    if (url.href !== state.href || !state.route) {
+      state.failed = false;
+      state.error = undefined;
+      resolveRoute(state, table, sections, url);
+    }
+    const route = state.route;
+    const section = sections[state.section];
+    const page = state.page;
+    this.openCascade("route", route);
+    if (state.failed) {
+      state.caught.render(route, state.error)(this);
+    } else if (page) {
+      const entry = page;
+      const fragment = ComponentBase.fragment((b) => b.#addPage(entry, state));
+      if (section)
+        section.render(route, fragment)(this);
+      else
+        fragment(this);
+    } else if (section) {
+      section.render(route)(this);
+    }
+    this.closeRegion();
+  }
+  #addPage(entry, router) {
+    this.#append({
+      kind: "component",
+      type: entry.component,
+      props: router.params,
+      key: entry.family ?? entry.pattern,
+      onError: router.onError,
+      nav: router.id
+    });
+  }
+  addAttribute(name, value) {
+    const el = this.#current();
+    if (value === false || value == null)
+      delete el.attrs[name];
+    else
+      el.attrs[name] = value === true ? "" : String(value);
+  }
+  addAttributes(attrs) {
+    for (const [name, value] of Object.entries(attrs ?? {}))
+      this.addAttribute(name, value);
+  }
+  addEventModifier(event, modifier, enabled) {
+    const el = this.#current();
+    (el.modifiers[event] ??= {})[modifier] = enabled;
+  }
+  setKey(key) {
+    this.#current().key = key;
+  }
+  setRef(_tag, ref) {
+    this.#current().ref = ref;
+  }
+  addEventHandler(event, handler) {
+    this.#current().events[event] = handler;
+  }
+  addText(text) {
+    this.#append({ kind: "text", text });
+  }
+  addFine(build) {
+    this.#append({ kind: "fine", build });
+  }
+  addContent(value) {
+    if (isFragment(value)) {
+      this.openRegion();
+      value(this);
+      this.closeRegion();
+      return;
+    }
+    if (value === false || value == null)
+      value = "";
+    this.#append({ kind: "text", text: String(value) });
+  }
+  addComponent(type, props, slots, extra) {
+    this.#append({
+      kind: "component",
+      type,
+      props,
+      slots,
+      key: extra?.key,
+      ref: extra?.ref
+    });
+  }
+  callback(handler) {
+    const owner = this.owner;
+    if (isFine(owner))
+      return (arg) => {
+        const result = handler(arg);
+        fineHooks.handled(owner, result);
+        return result;
+      };
+    return (arg) => {
+      const result = handler(arg);
+      update(owner);
+      if (result instanceof Promise)
+        result.then(() => update(owner));
+      return result;
+    };
+  }
+}
+function setAttr(el, name, value) {
+  if (name.charCodeAt(0) === 45 && name.charCodeAt(1) === 45)
+    return el.style.setProperty(name, value);
+  el.setAttribute(name, value);
+  if (name === "value" && "value" in el)
+    el.value = value;
+  if (name === "checked" && "checked" in el)
+    el.checked = true;
+}
+function removeAttr(el, name) {
+  if (name.charCodeAt(0) === 45 && name.charCodeAt(1) === 45)
+    return void el.style.removeProperty(name);
+  el.removeAttribute(name);
+  if (name === "value" && "value" in el)
+    el.value = "";
+  if (name === "checked" && "checked" in el)
+    el.checked = false;
+}
+var observer;
+function setRenderObserver(o) {
+  observer = o;
+}
+function render(component) {
+  const builder = new RenderTreeBuilder(component);
+  if (observer === undefined)
+    hooks(component).buildRenderTree(builder);
+  else {
+    observer.begin(component);
+    try {
+      hooks(component).buildRenderTree(builder);
+    } finally {
+      observer.end(component);
+    }
+  }
+  return builder.nodes;
+}
+var depth = 0;
+var pass = 0;
+var afterRender = [];
+function batch(fn) {
+  if (depth++ === 0)
+    pass++;
+  try {
+    fn();
+  } finally {
+    if (--depth === 0)
+      for (const done of afterRender.splice(0))
+        done();
+  }
+}
+function settle(component, result, node) {
+  if (!(result instanceof Promise))
+    return;
+  result.then(() => update(component), node?.onError && ((err) => fail(node, err)));
+}
+function fail(v, err) {
+  if (v.onError)
+    v.onError(err, v.mounted?.nav ?? v.nav ?? 0);
+  else
+    rethrow(err);
+}
+function parametersSet(component) {
+  hooks(component).onParametersSet();
+  settle(component, hooks(component).onParametersSetAsync());
+}
+var cascadesOf = (type) => type.cascades;
+var fields = (c) => c;
+function findCascade(scope, name) {
+  for (let s = scope;s; s = s.parent)
+    if (s.name === name)
+      return s;
+  return;
+}
+function resolveCascades(instance, type, scope) {
+  const list = cascadesOf(type);
+  if (!list)
+    return;
+  for (const [prop, name] of list) {
+    const record = findCascade(scope, name);
+    if (!record)
+      continue;
+    fields(instance)[prop] = record.value;
+    if (!record.fixed)
+      (record.consumers ??= new Set).add(instance);
+  }
+}
+function unsubscribeCascades(instance, type, scope) {
+  const list = cascadesOf(type);
+  if (!list)
+    return;
+  for (const [, name] of list)
+    findCascade(scope, name)?.consumers?.delete(instance);
+}
+function assignCascade(record, consumers) {
+  for (const consumer of consumers) {
+    for (const [prop, name] of cascadesOf(consumer.constructor)) {
+      if (name === record.name)
+        fields(consumer)[prop] = record.value;
+    }
+  }
+}
+function notifyCascade(consumers) {
+  for (const consumer of consumers) {
+    const m = mountedComponents.get(consumer);
+    if (!m || m.pass === pass)
+      continue;
+    m.pass = pass;
+    try {
+      parametersSet(consumer);
+      update(consumer);
+    } catch (err) {
+      rethrow(err);
+    }
+  }
+}
+function queueAfterRender(component, first) {
+  afterRender.push(() => {
+    hooks(component).onAfterRender(first);
+    hooks(component).onAfterRenderAsync(first);
+  });
+}
+function update(component) {
+  batch(() => {
+    const m = mountedComponents.get(component);
+    const parent = m?.anchor.parentNode;
+    if (!m || !parent || !hooks(component).shouldRender())
+      return;
+    const next = render(component);
+    patchList(parent, m.tree, next, m.anchor, component, m.app, m.scope);
+    m.tree = next;
+    queueAfterRender(component, false);
+  });
+}
+function mountComponent(component, app, scope, into, node) {
+  hooks(component).onInitialized();
+  settle(component, hooks(component).onInitializedAsync(), node);
+  parametersSet(component);
+  const tree = render(component);
+  const mounted = into ?? { tree, anchor: document.createComment(""), app, scope, latest: undefined, pass };
+  if (into)
+    into.tree = tree;
+  mountedComponents.set(component, mounted);
+  const nodes = tree.flatMap((v) => create(v, component, app, scope));
+  queueAfterRender(component, true);
+  if (!into)
+    nodes.push(mounted.anchor);
+  return { nodes, mounted };
+}
+function construct(type, app) {
+  const inject = type.inject;
+  if (!inject?.length)
+    return new type;
+  const made = app?.createComponent?.(type);
+  if (made)
+    return made;
+  if (app)
+    throw new Error(`xzor: ${type.name} is not registered with the application`);
+  throw new Error(`xzor: ${type.name} needs injected services (${inject.join(", ")}) but has no application`);
+}
+function arrive(mounted, instance) {
+  const v = mounted.latest;
+  const parent = mounted.anchor.parentNode;
+  mounted.latest = undefined;
+  if (!v || !parent) {
+    disposeInstance(instance);
+    return;
+  }
+  try {
+    batch(() => {
+      applyProps(instance, v);
+      resolveCascades(instance, v.type, mounted.scope);
+      v.ref?.(instance);
+      for (const node of mountComponent(instance, mounted.app, mounted.scope, mounted, v).nodes)
+        parent.insertBefore(node, mounted.anchor);
+      v.instance = instance;
+    });
+  } catch (err) {
+    fail(v, err);
+    if (!v.instance) {
+      mountedComponents.delete(instance);
+      observer?.dispose(instance);
+      unsubscribeCascades(instance, v.type, mounted.scope);
+      const partial = mounted.tree;
+      mounted.tree = [];
+      for (const node of partial) {
+        try {
+          dispose(node);
+        } catch (disposeErr) {
+          rethrow(disposeErr);
+        }
+      }
+    }
+  }
+}
+function applyProps(instance, v) {
+  Object.assign(instance, v.props);
+  if (v.slots)
+    instance.slots = v.slots;
+}
+function propsChanged(o, n) {
+  if (n.slots)
+    return true;
+  for (const [key, value] of Object.entries(n.props)) {
+    if (!Object.is(o.props[key], value) || typeof value === "object" && value !== null)
+      return true;
+  }
+  return false;
+}
+var eventNames = (v) => new Set([...Object.keys(v.events), ...Object.keys(v.modifiers)]);
+function listen(el, event) {
+  elementHandlers.get(el).listening.add(event);
+  el.addEventListener(event, (e) => {
+    const record = elementHandlers.get(el);
+    if (!record)
+      return;
+    const mods = record.modifiers[event];
+    if (mods?.preventDefault)
+      e.preventDefault();
+    if (mods?.stopPropagation)
+      e.stopPropagation();
+    const handler = record.events[event];
+    if (!handler)
+      return;
+    const result = handler(e);
+    if (isFine(record.owner))
+      return fineHooks.handled(record.owner, result);
+    update(record.owner);
+    if (result instanceof Promise)
+      result.then(() => update(record.owner));
+  });
+}
+function create(v, owner, app, scope, svg = false) {
+  switch (v.kind) {
+    case "text":
+      v.dom = document.createTextNode(v.text);
+      return [v.dom];
+    case "element": {
+      const el = svg || v.tag === "svg" ? document.createElementNS(SVG, v.tag) : document.createElement(v.tag);
+      for (const [name, value] of Object.entries(v.attrs))
+        setAttr(el, name, value);
+      elementHandlers.set(el, { owner, events: v.events, modifiers: v.modifiers, listening: new Set });
+      for (const event of eventNames(v))
+        listen(el, event);
+      const inner = inSvg(el);
+      for (const child of v.children)
+        el.append(...create(child, owner, app, scope, inner));
+      v.dom = el;
+      v.ref?.(el);
+      return [el];
+    }
+    case "region": {
+      v.anchor = document.createComment("");
+      const inner = v.name === undefined ? scope : v.cascade = { name: v.name, value: v.value, fixed: v.fixed === true, consumers: undefined, parent: scope };
+      return [...v.children.flatMap((c) => create(c, owner, app, inner, svg)), v.anchor];
+    }
+    case "component": {
+      if (!v.onError)
+        return createComponent(v, app, scope);
+      try {
+        return createComponent(v, app, scope);
+      } catch (err) {
+        return failedComponent(v, err, app, scope);
+      }
+    }
+    case "fine": {
+      if (!fineHooks)
+        throw new Error("xzor: a @fine component needs @source-crafter/xzor-runtime/model");
+      return fineNodes(v.root = fineHooks.create(v.build, owner, app, scope));
+    }
+  }
+}
+function createComponent(v, app, scope) {
+  const made = construct(v.type, app);
+  if (made instanceof Promise) {
+    const mounted2 = v.mounted = {
+      tree: [],
+      anchor: document.createComment(""),
+      app,
+      scope,
+      latest: v,
+      pass
+    };
+    made.then((instance) => arrive(mounted2, instance), (err) => {
+      const latest = mounted2.latest;
+      mounted2.latest = undefined;
+      if (latest)
+        fail(latest, err);
+      else if (!v.onError)
+        rethrow(err);
+    });
+    return [mounted2.anchor];
+  }
+  v.instance = made;
+  applyProps(made, v);
+  resolveCascades(made, v.type, scope);
+  v.ref?.(made);
+  const { nodes, mounted } = mountComponent(made, app, scope, undefined, v);
+  v.mounted = mounted;
+  return nodes;
+}
+function failedComponent(v, err, app, scope) {
+  const instance = v.instance;
+  v.instance = undefined;
+  if (instance) {
+    const partial = mountedComponents.get(instance);
+    mountedComponents.delete(instance);
+    observer?.dispose(instance);
+    unsubscribeCascades(instance, v.type, scope);
+    for (const node of partial?.tree ?? []) {
+      try {
+        dispose(node);
+      } catch (disposeErr) {
+        rethrow(disposeErr);
+      }
+    }
+  }
+  v.mounted = { tree: [], anchor: document.createComment(""), app, scope, latest: undefined, pass };
+  fail(v, err);
+  return [v.mounted.anchor];
+}
+function nodesOf(v) {
+  switch (v.kind) {
+    case "text":
+    case "element":
+      return [v.dom];
+    case "region":
+      return [...v.children.flatMap(nodesOf), v.anchor];
+    case "component":
+      return [...v.mounted.tree.flatMap(nodesOf), v.mounted.anchor];
+    case "fine":
+      return fineNodes(v.root);
+  }
+}
+function same(o, n) {
+  if (o.kind !== n.kind)
+    return false;
+  if (o.kind === "element")
+    return o.tag === n.tag && o.key === n.key;
+  if (o.kind === "component")
+    return o.type === n.type && o.key === n.key;
+  if (o.kind === "region")
+    return o.name === n.name && o.fixed === n.fixed;
+  return true;
+}
+function dispose(v) {
+  switch (v.kind) {
+    case "element":
+      v.children.forEach(dispose);
+      return;
+    case "region":
+      if (v.cascade)
+        v.cascade.consumers = undefined;
+      v.children.forEach(dispose);
+      return;
+    case "component":
+      if (!v.instance) {
+        if (v.mounted)
+          v.mounted.latest = undefined;
+        return;
+      }
+      v.mounted?.tree.forEach(dispose);
+      mountedComponents.delete(v.instance);
+      unsubscribeCascades(v.instance, v.type, v.mounted?.scope);
+      disposeInstance(v.instance);
+      return;
+    case "fine":
+      fineHooks.dispose(v.root);
+      return;
+  }
+}
+function disposeInstance(c) {
+  observer?.dispose(c);
+  c[ROUTER]?.off?.();
+  hooks(c).dispose();
+  const d = c;
+  d[wellKnown.dispose]?.();
+  surface(d[wellKnown.asyncDispose]?.());
+}
+function remove(parent, v) {
+  for (const node of nodesOf(v))
+    parent.removeChild(node);
+  dispose(v);
+}
+function patch(o, n, owner, app, scope) {
+  switch (n.kind) {
+    case "text": {
+      const dom = n.dom = o.dom;
+      if (dom.data !== n.text)
+        dom.data = n.text;
+      return;
+    }
+    case "element": {
+      const old = o;
+      const el = n.dom = old.dom;
+      for (const name of Object.keys(old.attrs))
+        if (!(name in n.attrs))
+          removeAttr(el, name);
+      for (const [name, value] of Object.entries(n.attrs)) {
+        const live = name === "value" ? el.value : undefined;
+        if (old.attrs[name] !== value || live !== undefined && live !== value)
+          setAttr(el, name, value);
+      }
+      const record = elementHandlers.get(el);
+      record.events = n.events;
+      record.modifiers = n.modifiers;
+      for (const event of eventNames(n))
+        if (!record.listening.has(event))
+          listen(el, event);
+      patchList(el, old.children, n.children, null, owner, app, scope);
+      n.ref?.(el);
+      return;
+    }
+    case "region": {
+      const old = o;
+      const anchor = n.anchor = old.anchor;
+      const record = old.cascade;
+      let subscribers;
+      let inner = scope;
+      if (record) {
+        record.parent = scope;
+        n.cascade = record;
+        inner = record;
+        if (!record.fixed && !Object.is(record.value, n.value)) {
+          record.value = n.value;
+          if (record.consumers?.size) {
+            subscribers = [...record.consumers];
+            assignCascade(record, subscribers);
+          }
+        }
+      }
+      patchList(anchor.parentNode, old.children, n.children, anchor, owner, app, inner);
+      if (subscribers)
+        notifyCascade(subscribers);
+      return;
+    }
+    case "component": {
+      const old = o;
+      n.mounted = old.mounted;
+      if (!old.instance) {
+        if (n.mounted.latest)
+          n.mounted.latest = n;
+        return;
+      }
+      const instance = n.instance = old.instance;
+      const changed = n.nav !== old.nav || propsChanged(old, n);
+      if (n.nav !== undefined)
+        n.mounted.nav = n.nav;
+      applyProps(instance, n);
+      n.ref?.(instance);
+      if (changed) {
+        n.mounted.pass = pass;
+        parametersSet(instance);
+        update(instance);
+      }
+      return;
+    }
+    case "fine": {
+      fineHooks.refresh(n.root = o.root);
+      return;
+    }
+  }
+}
+var keyOf = (v) => v && (v.kind === "element" || v.kind === "component") ? v.key : undefined;
+function patchList(parent, old, next, end, owner, app, scope) {
+  if (old.some((v) => keyOf(v) != null) || next.some((v) => keyOf(v) != null)) {
+    patchKeyed(parent, old, next, end, owner, app, scope);
+    return;
+  }
+  for (let i = 0;i < next.length; i++) {
+    const n = next[i];
+    const o = old[i];
+    if (o && same(o, n)) {
+      patch(o, n, owner, app, scope);
+      continue;
+    }
+    const ref = o ? nodesOf(o)[0] : end;
+    for (const node of create(n, owner, app, scope, inSvg(parent)))
+      parent.insertBefore(node, ref);
+    if (o)
+      remove(parent, o);
+  }
+  for (const o of old.slice(next.length))
+    remove(parent, o);
+}
+function patchKeyed(parent, old, next, end, owner, app, scope) {
+  const byKey = new Map;
+  for (const o of old)
+    if (keyOf(o) != null)
+      byKey.set(keyOf(o), o);
+  const used = new Set;
+  const matches = next.map((n, i) => {
+    const key = keyOf(n);
+    const o = key != null ? byKey.get(key) : keyOf(old[i]) == null ? old[i] : undefined;
+    if (o && !used.has(o) && same(o, n)) {
+      used.add(o);
+      return o;
+    }
+    return;
+  });
+  for (const o of old)
+    if (!used.has(o))
+      remove(parent, o);
+  let ref = end;
+  for (let i = next.length - 1;i >= 0; i--) {
+    const n = next[i];
+    const o = matches[i];
+    let nodes;
+    if (o) {
+      patch(o, n, owner, app, scope);
+      nodes = nodesOf(n);
+    } else {
+      nodes = create(n, owner, app, scope, inSvg(parent));
+    }
+    for (let j = nodes.length - 1;j >= 0; j--) {
+      const node = nodes[j];
+      if (node.parentNode !== parent || node.nextSibling !== ref)
+        parent.insertBefore(node, ref);
+      ref = node;
+    }
+  }
+}
+function resolveTarget(target) {
+  if (typeof target !== "string")
+    return target;
+  const found = SELECTOR.test(target) ? document.querySelector(target) : document.getElementById(target);
+  if (!found)
+    throw new Error(`xzor: mount target "${target}" not found`);
+  return found;
+}
+function mount(type, target, app) {
+  const host = resolveTarget(target);
+  const root = construct(type, app);
+  if (root instanceof Promise)
+    throw new Error(`xzor: root component ${type.name} cannot be asynchronous`);
+  batch(() => host.replaceChildren(...mountComponent(root, app, undefined).nodes));
+  surface(app?.onStarted?.());
+  return root;
+}
+
+class NavLink extends ComponentBase {
+  href = "";
+  activeClass = "active";
+  match = "prefix";
+  #path = "";
+  #for;
+  #target = null;
+  #off;
+  onInitialized() {
+    const nav = navigationOf();
+    this.#path = nav.current().pathname;
+    const fn = () => {
+      const path = nav.current().pathname;
+      if (path === this.#path)
+        return;
+      this.#path = path;
+      this.stateHasChanged();
+    };
+    this.#off = nav.observe ? nav.observe(fn) : nav.subscribe(fn);
+  }
+  dispose() {
+    this.#off?.();
+  }
+  #active() {
+    if (this.#for !== this.href) {
+      this.#for = this.href;
+      const url = new URL(this.href, document.baseURI);
+      this.#target = url.origin === location.origin ? url.pathname : null;
+    }
+    const target = this.#target;
+    if (target === null)
+      return false;
+    const path = this.#path;
+    if (this.match === "exact" || target === `${basePath()}/`)
+      return path === target;
+    return path === target || path.startsWith(target.endsWith("/") ? target : `${target}/`);
+  }
+  buildRenderTree(b) {
+    b.openElement("a");
+    b.addAttribute("href", this.href);
+    if (this.#active()) {
+      b.addAttribute("class", this.activeClass);
+      b.addAttribute("aria-current", "page");
+    }
+    b.addContent(this.slots.default?.() ?? null);
+    b.closeElement();
+  }
+}
+
+export { FINE, setFineHooks, patchIsland, disposeIsland, $isFragment, SVG, $inSvg, Route, viewTransitions, setNavigationForTests, basePath, polyfillDisposeSymbols, ServiceProvider, Mount, Import, Singleton, Scoped, Transient, SharedInstance, ComponentBase, RenderTreeBuilder, setRenderObserver, mount, NavLink };
+
+//# debugId=085B9300273EBAC364756E2164756E21
+//# sourceMappingURL=index-k290gfdd.js.map