git-viewer 3.0.0

package/dist/entry.bundled.js

@@ -0,0 +1,2212 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// node_modules/.pnpm/@remix-run+interaction@0.4.0/node_modules/@remix-run/interaction/dist/lib/interaction.js
+function createContainer(target, options) {
+  let disposed = false;
+  let { signal, onError = defaultOnError } = options ?? {};
+  let bindings = {};
+  function disposeAll() {
+    if (disposed)
+      return;
+    disposed = true;
+    for (let type in bindings) {
+      let existing = bindings[type];
+      if (existing) {
+        for (let binding of existing) {
+          binding.dispose();
+        }
+      }
+    }
+  }
+  if (signal) {
+    signal.addEventListener("abort", disposeAll, { once: true });
+  }
+  return {
+    dispose: disposeAll,
+    set: (listeners) => {
+      if (disposed) {
+        throw new Error("Container has been disposed");
+      }
+      let listenerKeys = new Set(Object.keys(listeners));
+      for (let type in bindings) {
+        let eventType = type;
+        if (!listenerKeys.has(eventType)) {
+          let existing = bindings[eventType];
+          if (existing) {
+            for (let binding of existing) {
+              binding.dispose();
+            }
+            delete bindings[eventType];
+          }
+        }
+      }
+      for (let type of listenerKeys) {
+        let updateTypeBindings = function(type2, raw2) {
+          let descriptors = normalizeDescriptors(raw2);
+          let existing = bindings[type2];
+          if (!existing) {
+            bindings[type2] = descriptors.map((d) => {
+              let { listener, ...options2 } = d;
+              return createBinding(target, type2, listener, options2, onError);
+            });
+            return;
+          }
+          let min = Math.min(existing.length, descriptors.length);
+          for (let i = 0; i < min; i++) {
+            let d = descriptors[i];
+            let b = existing[i];
+            let { listener, ...options2 } = d;
+            if (optionsChanged(options2, b.options)) {
+              b.rebind(listener, options2);
+            } else {
+              b.setListener(listener);
+            }
+          }
+          if (descriptors.length > existing.length) {
+            for (let i = existing.length; i < descriptors.length; i++) {
+              let d = descriptors[i];
+              let { listener, ...options2 } = d;
+              existing.push(createBinding(target, type2, listener, options2, onError));
+            }
+          }
+          if (existing.length > descriptors.length) {
+            for (let i = descriptors.length; i < existing.length; i++) {
+              existing[i].dispose();
+            }
+            existing.length = descriptors.length;
+          }
+        };
+        let raw = listeners[type];
+        if (raw == null)
+          continue;
+        updateTypeBindings(type, raw);
+      }
+    }
+  };
+}
+var interactions = /* @__PURE__ */ new Map();
+var initializedTargets = /* @__PURE__ */ new WeakMap();
+function defaultOnError(error) {
+  throw error;
+}
+var InteractionHandle = class {
+  constructor(target, signal, onError) {
+    __publicField(this, "target");
+    __publicField(this, "signal");
+    __publicField(this, "raise");
+    this.target = target;
+    this.signal = signal;
+    this.raise = onError;
+  }
+  on(target, listeners) {
+    let container = createContainer(target, {
+      signal: this.signal,
+      onError: this.raise
+    });
+    container.set(listeners);
+  }
+};
+function normalizeDescriptors(raw) {
+  if (Array.isArray(raw)) {
+    return raw.map((item) => isDescriptor(item) ? item : { listener: item });
+  }
+  return [isDescriptor(raw) ? raw : { listener: raw }];
+}
+function isDescriptor(value) {
+  return typeof value === "object" && value !== null && "listener" in value;
+}
+function createBinding(target, type, listener, options, onError) {
+  let reentry = null;
+  let interactionController = null;
+  let disposed = false;
+  let needsSignal = listener.length >= 2;
+  function abort() {
+    if (reentry) {
+      reentry.abort(new DOMException("", "EventReentry"));
+      reentry = new AbortController();
+    }
+  }
+  let wrappedListener = (event) => {
+    if (needsSignal) {
+      abort();
+      if (!reentry)
+        reentry = new AbortController();
+    }
+    try {
+      let result = listener(event, reentry?.signal);
+      if (result instanceof Promise) {
+        result.catch(onError);
+      }
+    } catch (error) {
+      onError(error);
+    }
+  };
+  function bind() {
+    target.addEventListener(type, wrappedListener, options);
+  }
+  function unbind() {
+    abort();
+    target.removeEventListener(type, wrappedListener, options);
+  }
+  function decrementInteractionRef() {
+    let interaction = interactions.get(type);
+    if (interaction) {
+      let refCounts = initializedTargets.get(target);
+      if (refCounts) {
+        let count = refCounts.get(interaction) ?? 0;
+        if (count > 0) {
+          count--;
+          if (count === 0) {
+            refCounts.delete(interaction);
+          } else {
+            refCounts.set(interaction, count);
+          }
+        }
+      }
+    }
+  }
+  function cleanup() {
+    if (disposed)
+      return;
+    disposed = true;
+    unbind();
+    if (interactionController)
+      interactionController.abort();
+    decrementInteractionRef();
+  }
+  if (interactions.has(type)) {
+    let interaction = interactions.get(type);
+    let refCounts = initializedTargets.get(target);
+    if (!refCounts) {
+      refCounts = /* @__PURE__ */ new Map();
+      initializedTargets.set(target, refCounts);
+    }
+    let count = refCounts.get(interaction) ?? 0;
+    if (count === 0) {
+      interactionController = new AbortController();
+      let interactionContext = new InteractionHandle(target, interactionController.signal, onError);
+      interaction(interactionContext);
+    }
+    refCounts.set(interaction, count + 1);
+  }
+  bind();
+  return {
+    type,
+    get options() {
+      return options;
+    },
+    setListener(newListener) {
+      listener = newListener;
+      needsSignal = newListener.length >= 2;
+    },
+    rebind(newListener, newOptions) {
+      unbind();
+      options = newOptions;
+      listener = newListener;
+      needsSignal = newListener.length >= 2;
+      bind();
+    },
+    dispose: cleanup
+  };
+}
+function optionsChanged(a, b) {
+  return a.capture !== b.capture || a.once !== b.once || a.passive !== b.passive || a.signal !== b.signal;
+}
+
+// node_modules/.pnpm/@remix-run+component@0.3.0/node_modules/@remix-run/component/dist/lib/component.js
+function createComponent(config) {
+  let taskQueue = [];
+  let renderCtrl = null;
+  let connectedCtrl = null;
+  let contextValue = void 0;
+  function getConnectedSignal() {
+    if (!connectedCtrl)
+      connectedCtrl = new AbortController();
+    return connectedCtrl.signal;
+  }
+  let getContent = null;
+  let scheduleUpdate = () => {
+    throw new Error("scheduleUpdate not implemented");
+  };
+  let context = {
+    set: (value) => {
+      contextValue = value;
+    },
+    get: (type) => {
+      return config.getContext(type);
+    }
+  };
+  let handle = {
+    id: config.id,
+    update: (task) => {
+      if (task)
+        taskQueue.push(task);
+      scheduleUpdate();
+    },
+    queueTask: (task) => {
+      taskQueue.push(task);
+    },
+    raise: config.raise,
+    frame: config.frame,
+    context,
+    get signal() {
+      return getConnectedSignal();
+    },
+    on: (target, listeners) => {
+      let container = createContainer(target, { signal: getConnectedSignal() });
+      container.set(listeners);
+    }
+  };
+  function dequeueTasks() {
+    let needsSignal = taskQueue.some((task) => task.length >= 1);
+    if (needsSignal && !renderCtrl) {
+      renderCtrl = new AbortController();
+    }
+    let signal = renderCtrl?.signal;
+    return taskQueue.splice(0, taskQueue.length).map((task) => () => task(signal));
+  }
+  function render(props) {
+    if (connectedCtrl?.signal.aborted) {
+      console.warn("render called after component was removed, potential application memory leak");
+      return [null, []];
+    }
+    if (renderCtrl) {
+      renderCtrl.abort();
+      renderCtrl = null;
+    }
+    if (!getContent) {
+      let { setup, ...propsWithoutSetup } = props;
+      let result = config.type(handle, setup);
+      if (typeof result !== "function") {
+        let name = config.type.name || "Anonymous";
+        throw new Error(`${name} must return a render function, received ${typeof result}`);
+      } else {
+        getContent = (props2) => {
+          let { setup: _, ...rest } = props2;
+          return result(rest);
+        };
+      }
+    }
+    let node = getContent(props);
+    return [node, dequeueTasks()];
+  }
+  function remove2() {
+    if (connectedCtrl)
+      connectedCtrl.abort();
+    return dequeueTasks();
+  }
+  function setScheduleUpdate(_scheduleUpdate) {
+    scheduleUpdate = _scheduleUpdate;
+  }
+  function getContextValue() {
+    return contextValue;
+  }
+  return { render, remove: remove2, setScheduleUpdate, frame: config.frame, getContextValue };
+}
+function Frame(handle) {
+  return (_) => null;
+}
+function Fragment() {
+  return (_) => null;
+}
+function Catch() {
+  return (_) => null;
+}
+function createFrameHandle(def) {
+  return Object.assign(new EventTarget(), {
+    src: "/",
+    replace: notImplemented("replace not implemented"),
+    reload: notImplemented("reload not implemented")
+  }, def);
+}
+function notImplemented(msg) {
+  return () => {
+    throw new Error(msg);
+  };
+}
+
+// node_modules/.pnpm/@remix-run+component@0.3.0/node_modules/@remix-run/component/dist/lib/invariant.js
+function invariant(assertion, message) {
+  let prefix = "Framework invariant";
+  if (assertion)
+    return;
+  throw new Error(message ? `${prefix}: ${message}` : prefix);
+}
+
+// node_modules/.pnpm/@remix-run+component@0.3.0/node_modules/@remix-run/component/dist/lib/document-state.js
+function createDocumentState(_doc) {
+  let doc = _doc ?? document;
+  function getActiveElement() {
+    return doc.activeElement || doc.body;
+  }
+  function hasSelectionCapabilities(elem) {
+    let nodeName = elem.nodeName.toLowerCase();
+    return nodeName === "input" && "type" in elem && (elem.type === "text" || elem.type === "search" || elem.type === "tel" || elem.type === "url" || elem.type === "password") || nodeName === "textarea" || elem instanceof HTMLElement && elem.contentEditable === "true";
+  }
+  function getSelection(input) {
+    if ("selectionStart" in input && typeof input.selectionStart === "number" && "selectionEnd" in input) {
+      let htmlInput = input;
+      return {
+        start: htmlInput.selectionStart ?? 0,
+        end: htmlInput.selectionEnd ?? htmlInput.selectionStart ?? 0
+      };
+    }
+    return null;
+  }
+  function setSelection(input, offsets) {
+    if ("selectionStart" in input && "selectionEnd" in input) {
+      try {
+        let htmlInput = input;
+        htmlInput.selectionStart = offsets.start;
+        htmlInput.selectionEnd = Math.min(offsets.end, htmlInput.value?.length ?? 0);
+      } catch {
+      }
+    }
+  }
+  function isInDocument(node) {
+    return doc.documentElement.contains(node);
+  }
+  function getSelectionInformation() {
+    let focusedElem = getActiveElement();
+    return {
+      focusedElem,
+      selectionRange: focusedElem && hasSelectionCapabilities(focusedElem) ? getSelection(focusedElem) : null
+    };
+  }
+  function restoreSelection(priorSelectionInformation) {
+    let curFocusedElem = getActiveElement();
+    let priorFocusedElem = priorSelectionInformation.focusedElem;
+    let priorSelectionRange = priorSelectionInformation.selectionRange;
+    if (curFocusedElem !== priorFocusedElem && priorFocusedElem && isInDocument(priorFocusedElem)) {
+      let ancestors = [];
+      let ancestor = priorFocusedElem;
+      while (ancestor) {
+        if (ancestor.nodeType === Node.ELEMENT_NODE) {
+          let el = ancestor;
+          ancestors.push({
+            element: el,
+            left: el.scrollLeft ?? 0,
+            top: el.scrollTop ?? 0
+          });
+        }
+        ancestor = ancestor.parentNode;
+      }
+      if (priorSelectionRange !== null && hasSelectionCapabilities(priorFocusedElem)) {
+        setSelection(priorFocusedElem, priorSelectionRange);
+      }
+      if (priorFocusedElem instanceof HTMLElement && typeof priorFocusedElem.focus === "function") {
+        priorFocusedElem.focus();
+      }
+      for (let info of ancestors) {
+        info.element.scrollLeft = info.left;
+        info.element.scrollTop = info.top;
+      }
+    }
+  }
+  let selectionInfo = null;
+  function capture() {
+    selectionInfo = getSelectionInformation();
+  }
+  function restore() {
+    if (selectionInfo !== null) {
+      restoreSelection(selectionInfo);
+    }
+    selectionInfo = null;
+  }
+  return { capture, restore };
+}
+
+// node_modules/.pnpm/@remix-run+component@0.3.0/node_modules/@remix-run/component/dist/lib/style/lib/style.js
+function camelToKebab(str) {
+  return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+var NUMERIC_CSS_PROPS = /* @__PURE__ */ new Set([
+  "z-index",
+  "opacity",
+  "flex-grow",
+  "flex-shrink",
+  "flex-order",
+  "grid-area",
+  "grid-row",
+  "grid-column",
+  "font-weight",
+  "line-height",
+  "order",
+  "orphans",
+  "widows",
+  "zoom",
+  "columns",
+  "column-count"
+]);
+function normalizeCssValue(key, value) {
+  if (value == null)
+    return String(value);
+  if (typeof value === "number" && value !== 0) {
+    let cssKey = camelToKebab(key);
+    if (!NUMERIC_CSS_PROPS.has(cssKey) && !cssKey.startsWith("--")) {
+      return `${value}px`;
+    }
+  }
+  return String(value);
+}
+function isComplexSelector(key) {
+  return key.startsWith("&") || key.startsWith("@") || key.startsWith(":") || key.startsWith("[") || key.startsWith(".");
+}
+function isKeyframesAtRule(key) {
+  if (!key.startsWith("@"))
+    return false;
+  let lower = key.toLowerCase();
+  return lower.startsWith("@keyframes") || lower.startsWith("@-webkit-keyframes") || lower.startsWith("@-moz-keyframes") || lower.startsWith("@-o-keyframes");
+}
+function hashStyle(obj) {
+  let sortedEntries = Object.entries(obj).sort(([a], [b]) => a.localeCompare(b));
+  let str = JSON.stringify(sortedEntries);
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    let char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+function styleToCss(styles, selector = "") {
+  let baseDeclarations = [];
+  let nestedBlocks = [];
+  let atRules = [];
+  let preludeAtRules = [];
+  for (let [key, value] of Object.entries(styles)) {
+    if (isComplexSelector(key)) {
+      if (key.startsWith("@")) {
+        if (key.startsWith("@function")) {
+          let body = atRuleBodyToCss(value);
+          if (body.trim().length > 0) {
+            preludeAtRules.push(`${key} {
+${indent(body, 2)}
+}`);
+          } else {
+            preludeAtRules.push(`${key} {
+}`);
+          }
+        } else if (isKeyframesAtRule(key)) {
+          let body = keyframesBodyToCss(value);
+          if (body.trim().length > 0) {
+            preludeAtRules.push(`${key} {
+${indent(body, 2)}
+}`);
+          } else {
+            preludeAtRules.push(`${key} {
+}`);
+          }
+        } else {
+          let inner = styleToCss(value, selector);
+          if (inner.trim().length > 0) {
+            atRules.push(`${key} {
+${indent(inner, 2)}
+}`);
+          } else {
+            atRules.push(`${key} {
+  ${selector} {
+  }
+}`);
+          }
+        }
+        continue;
+      }
+      let nestedContent = "";
+      for (let [prop, propValue] of Object.entries(value)) {
+        if (propValue != null) {
+          let normalizedValue = normalizeCssValue(prop, propValue);
+          nestedContent += `    ${camelToKebab(prop)}: ${normalizedValue};
+`;
+        }
+      }
+      if (nestedContent) {
+        nestedBlocks.push(`  ${key} {
+${nestedContent}  }`);
+      }
+    } else {
+      if (value != null) {
+        let normalizedValue = normalizeCssValue(key, value);
+        baseDeclarations.push(`  ${camelToKebab(key)}: ${normalizedValue};`);
+      }
+    }
+  }
+  let css = "";
+  if (preludeAtRules.length > 0) {
+    css += preludeAtRules.join("\n");
+  }
+  if (selector && (baseDeclarations.length > 0 || nestedBlocks.length > 0)) {
+    css += (css ? "\n" : "") + `${selector} {
+`;
+    if (baseDeclarations.length > 0) {
+      css += baseDeclarations.join("\n") + "\n";
+    }
+    if (nestedBlocks.length > 0) {
+      css += nestedBlocks.join("\n") + "\n";
+    }
+    css += "}";
+  }
+  if (atRules.length > 0) {
+    css += (css ? "\n" : "") + atRules.join("\n");
+  }
+  return css;
+}
+function indent(text, spaces) {
+  let pad = " ".repeat(spaces);
+  return text.split("\n").map((line) => line.length ? pad + line : line).join("\n");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function keyframesBodyToCss(frames) {
+  if (!isRecord(frames))
+    return "";
+  let blocks = [];
+  for (let [frameSelector, frameValue] of Object.entries(frames)) {
+    if (!isRecord(frameValue)) {
+      continue;
+    }
+    let declarations = [];
+    for (let [prop, propValue] of Object.entries(frameValue)) {
+      if (propValue == null)
+        continue;
+      if (isComplexSelector(prop))
+        continue;
+      let normalizedValue = normalizeCssValue(prop, propValue);
+      declarations.push(`  ${camelToKebab(prop)}: ${normalizedValue};`);
+    }
+    if (declarations.length > 0) {
+      blocks.push(`${frameSelector} {
+${declarations.join("\n")}
+}`);
+    } else {
+      blocks.push(`${frameSelector} {
+}`);
+    }
+  }
+  return blocks.join("\n");
+}
+function atRuleBodyToCss(styles) {
+  let declarations = [];
+  let nested = [];
+  for (let [key, value] of Object.entries(styles)) {
+    if (isComplexSelector(key)) {
+      if (key.startsWith("@")) {
+        let inner = atRuleBodyToCss(value);
+        if (inner.trim().length > 0) {
+          nested.push(`${key} {
+${indent(inner, 2)}
+}`);
+        } else {
+          nested.push(`${key} {
+}`);
+        }
+      } else {
+        continue;
+      }
+    } else {
+      if (value != null) {
+        let normalizedValue = normalizeCssValue(key, value);
+        declarations.push(`  ${camelToKebab(key)}: ${normalizedValue};`);
+      }
+    }
+  }
+  let body = "";
+  if (declarations.length > 0) {
+    body += declarations.join("\n");
+  }
+  if (nested.length > 0) {
+    body += (body ? "\n" : "") + nested.join("\n");
+  }
+  return body;
+}
+function processStyle(styleObj, styleCache2) {
+  if (Object.keys(styleObj).length === 0) {
+    return { className: "", css: "" };
+  }
+  let hash = hashStyle(styleObj);
+  let className = `rmx-${hash}`;
+  let cached = styleCache2.get(hash);
+  if (cached) {
+    return cached;
+  }
+  let css = styleToCss(styleObj, `.${className}`);
+  let result = { className, css };
+  styleCache2.set(hash, result);
+  return result;
+}
+
+// node_modules/.pnpm/@remix-run+component@0.3.0/node_modules/@remix-run/component/dist/lib/style/lib/stylesheet.js
+function createStyleManager(layer = "rmx") {
+  let stylesheet = new CSSStyleSheet();
+  document.adoptedStyleSheets.push(stylesheet);
+  let ruleMap = /* @__PURE__ */ new Map();
+  function has(className) {
+    let entry = ruleMap.get(className);
+    return entry !== void 0 && entry.count > 0;
+  }
+  function insert2(className, rule) {
+    let entry = ruleMap.get(className);
+    if (entry) {
+      entry.count++;
+      return;
+    }
+    let index = stylesheet.cssRules.length;
+    try {
+      stylesheet.insertRule(`@layer ${layer} { ${rule} }`, index);
+      ruleMap.set(className, { count: 1, index });
+    } catch (error) {
+      throw error;
+    }
+  }
+  function remove2(className) {
+    let entry = ruleMap.get(className);
+    if (!entry)
+      return;
+    entry.count--;
+    if (entry.count > 0) {
+      return;
+    }
+    let indexToDelete = entry.index;
+    stylesheet.deleteRule(indexToDelete);
+    ruleMap.delete(className);
+    for (let [name, data] of ruleMap.entries()) {
+      if (data.index > indexToDelete) {
+        data.index--;
+      }
+    }
+  }
+  function dispose() {
+    document.adoptedStyleSheets = Array.from(document.adoptedStyleSheets).filter((s) => s !== stylesheet);
+    ruleMap.clear();
+  }
+  return { insert: insert2, remove: remove2, has, dispose };
+}
+
+// node_modules/.pnpm/@remix-run+component@0.3.0/node_modules/@remix-run/component/dist/lib/vdom.js
+var fixmeIdCounter = 0;
+var TEXT_NODE = Symbol("TEXT_NODE");
+var SVG_NS = "http://www.w3.org/2000/svg";
+var XLINK_NS = "http://www.w3.org/1999/xlink";
+var XML_NS = "http://www.w3.org/XML/1998/namespace";
+var INSERT_VNODE = 1 << 0;
+var MATCHED = 1 << 1;
+var styleCache = /* @__PURE__ */ new Map();
+var styleManager = typeof window !== "undefined" ? createStyleManager() : null;
+function createScheduler(doc) {
+  let documentState = createDocumentState(doc);
+  let scheduled = /* @__PURE__ */ new Map();
+  let tasks = [];
+  let flushScheduled = false;
+  let scheduler;
+  function flush() {
+    flushScheduled = false;
+    let batch = new Map(scheduled);
+    scheduled.clear();
+    let hasWork = batch.size > 0 || tasks.length > 0;
+    if (!hasWork)
+      return;
+    documentState.capture();
+    if (batch.size > 0) {
+      let vnodes = Array.from(batch);
+      let noScheduledAncestor = /* @__PURE__ */ new Set();
+      for (let [vnode, [domParent, anchor]] of vnodes) {
+        if (ancestorIsScheduled(vnode, batch, noScheduledAncestor))
+          continue;
+        let handle = vnode._handle;
+        let curr = vnode._content;
+        let vParent = vnode._parent;
+        renderComponent(handle, curr, vnode, domParent, handle.frame, scheduler, vParent, anchor);
+      }
+    }
+    documentState.restore();
+    if (tasks.length > 0) {
+      for (let task of tasks) {
+        task();
+      }
+      tasks = [];
+    }
+  }
+  function scheduleFlush() {
+    if (flushScheduled)
+      return;
+    flushScheduled = true;
+    queueMicrotask(flush);
+  }
+  function ancestorIsScheduled(vnode, batch, safe) {
+    let path = [];
+    let current = vnode._parent;
+    while (current) {
+      if (safe.has(current)) {
+        for (let node of path)
+          safe.add(node);
+        return false;
+      }
+      path.push(current);
+      if (isCommittedComponentNode(current) && batch.has(current)) {
+        return true;
+      }
+      current = current._parent;
+    }
+    for (let node of path)
+      safe.add(node);
+    return false;
+  }
+  scheduler = {
+    enqueue(vnode, domParent, anchor) {
+      scheduled.set(vnode, [domParent, anchor]);
+      scheduleFlush();
+    },
+    enqueueTasks(newTasks) {
+      tasks.push(...newTasks);
+      scheduleFlush();
+    },
+    dequeue() {
+      flush();
+    }
+  };
+  return scheduler;
+}
+var ROOT_VNODE = Symbol("ROOT_VNODE");
+function createRoot(container, options = {}) {
+  let root = null;
+  let frameStub = options.frame ?? createFrameHandle();
+  let scheduler = options.scheduler ?? createScheduler(container.ownerDocument ?? document);
+  let hydrationCursor = container.innerHTML.trim() !== "" ? container.firstChild : void 0;
+  return {
+    render(element) {
+      let vnode = toVNode(element);
+      let vParent = { type: ROOT_VNODE, _svg: false };
+      scheduler.enqueueTasks([
+        () => {
+          diffVNodes(root, vnode, container, frameStub, scheduler, vParent, void 0, hydrationCursor);
+          root = vnode;
+          hydrationCursor = void 0;
+        }
+      ]);
+      scheduler.dequeue();
+    },
+    remove() {
+      root = null;
+    },
+    flush() {
+      scheduler.dequeue();
+    }
+  };
+}
+function flatMapChildrenToVNodes(node) {
+  return "children" in node.props ? Array.isArray(node.props.children) ? node.props.children.flat(Infinity).map(toVNode) : [toVNode(node.props.children)] : [];
+}
+function flattenRemixNodeArray(nodes, out = []) {
+  for (let child of nodes) {
+    if (Array.isArray(child)) {
+      flattenRemixNodeArray(child, out);
+    } else {
+      out.push(child);
+    }
+  }
+  return out;
+}
+function toVNode(node) {
+  if (node === null || node === void 0 || typeof node === "boolean") {
+    return { type: TEXT_NODE, _text: "" };
+  }
+  if (typeof node === "string" || typeof node === "number" || typeof node === "bigint") {
+    return { type: TEXT_NODE, _text: String(node) };
+  }
+  if (Array.isArray(node)) {
+    let flatChildren = flattenRemixNodeArray(node);
+    return { type: Fragment, _children: flatChildren.map(toVNode) };
+  }
+  if (node.type === Fragment) {
+    return { type: Fragment, key: node.key, _children: flatMapChildrenToVNodes(node) };
+  }
+  if (node.type === Catch) {
+    return {
+      type: Catch,
+      key: node.key,
+      _fallback: node.props.fallback,
+      _children: flatMapChildrenToVNodes(node)
+    };
+  }
+  if (isRemixElement(node)) {
+    let children = flatMapChildrenToVNodes(node);
+    return { type: node.type, key: node.key, props: node.props, _children: children };
+  }
+  invariant(false, "Unexpected RemixNode");
+}
+function diffVNodes(curr, next, domParent, frame, scheduler, vParent, anchor, rootCursor) {
+  next._parent = vParent;
+  next._svg = getSvgContext(vParent, next.type);
+  if (curr === null) {
+    insert(next, domParent, frame, scheduler, vParent, anchor, rootCursor);
+    return;
+  }
+  if (curr.type !== next.type) {
+    replace(curr, next, domParent, frame, scheduler, vParent, anchor);
+    return;
+  }
+  if (isCommittedTextNode(curr) && isTextNode(next)) {
+    diffText(curr, next, scheduler, vParent);
+    return;
+  }
+  if (isCommittedHostNode(curr) && isHostNode(next)) {
+    diffHost(curr, next, domParent, frame, scheduler, vParent);
+    return;
+  }
+  if (isCommittedComponentNode(curr) && isComponentNode(next)) {
+    diffComponent(curr, next, frame, scheduler, domParent, vParent);
+    return;
+  }
+  if (isFragmentNode(curr) && isFragmentNode(next)) {
+    diffChildren(curr._children, next._children, domParent, frame, scheduler, vParent, void 0, anchor);
+    return;
+  }
+  if (isCatchNode(curr) && isCatchNode(next)) {
+    diffCatch(curr, next, domParent, frame, scheduler, vParent);
+    return;
+  }
+  if (curr.type === Frame && next.type === Frame) {
+    throw new Error("TODO: Frame diff not implemented");
+  }
+  invariant(false, "Unexpected diff case");
+}
+function diffCatch(curr, next, domParent, frame, scheduler, vParent) {
+  if (curr._tripped) {
+    replace(curr, next, domParent, frame, scheduler, vParent);
+    return;
+  }
+  let added = [];
+  try {
+    for (let i = 0; i < curr._children.length; i++) {
+      let child = curr._children[i];
+      diffVNodes(child, next._children[i], domParent, frame, scheduler, vParent);
+      added.unshift(child);
+    }
+    curr._parent = vParent;
+    curr._tripped = false;
+    curr._added = added;
+  } catch (e) {
+    for (let child of added) {
+      remove(child, domParent, scheduler);
+    }
+    let fallbackNode = getCatchFallback(next, e);
+    let anchor = findFirstDomAnchor(curr) || findNextSiblingDomAnchor(curr, vParent) || void 0;
+    insert(fallbackNode, domParent, frame, scheduler, vParent, anchor);
+    curr._parent = vParent;
+    curr._tripped = true;
+    curr._added = [fallbackNode];
+    dispatchError(e);
+  }
+}
+function replace(curr, next, domParent, frame, scheduler, vParent, anchor) {
+  anchor = anchor || findFirstDomAnchor(curr) || findNextSiblingDomAnchor(curr, curr._parent) || void 0;
+  insert(next, domParent, frame, scheduler, vParent, anchor);
+  remove(curr, domParent, scheduler);
+}
+function diffHost(curr, next, domParent, frame, scheduler, vParent) {
+  diffChildren(curr._children, next._children, curr._dom, frame, scheduler, next);
+  diffHostProps(curr.props, next.props, curr._dom);
+  next._dom = curr._dom;
+  next._parent = vParent;
+  next._controller = curr._controller;
+  let nextOn = next.props.on;
+  if (nextOn) {
+    if (curr._events) {
+      next._events = curr._events;
+      let eventsContainer = curr._events;
+      scheduler.enqueueTasks([() => eventsContainer.set(nextOn)]);
+    } else {
+      let eventsContainer = createContainer(curr._dom, {
+        onError: (error) => raise(error, next, domParent, frame, scheduler)
+      });
+      scheduler.enqueueTasks([() => eventsContainer.set(nextOn)]);
+      next._events = eventsContainer;
+    }
+  } else if (curr._events) {
+    let eventsContainer = curr._events;
+    scheduler.enqueueTasks([() => eventsContainer.dispose()]);
+  }
+  return;
+}
+function setupHostNode(node, dom, domParent, frame, scheduler) {
+  node._dom = dom;
+  let on2 = node.props.on;
+  if (on2) {
+    let eventsContainer = createContainer(dom, {
+      onError: (error) => raise(error, node, domParent, frame, scheduler)
+    });
+    scheduler.enqueueTasks([() => eventsContainer.set(on2)]);
+    node._events = eventsContainer;
+  }
+  let connect = node.props.connect;
+  if (connect) {
+    if (connect.length >= 2) {
+      let controller = new AbortController();
+      node._controller = controller;
+      scheduler.enqueueTasks([() => connect(dom, controller.signal)]);
+    } else {
+      scheduler.enqueueTasks([() => connect(dom)]);
+    }
+  }
+}
+function diffCssProp(curr, next, dom) {
+  let prevClassName = curr.css ? processStyle(curr.css, styleCache).className : "";
+  let { className, css } = next.css ? processStyle(next.css, styleCache) : { className: "", css: "" };
+  if (prevClassName === className)
+    return;
+  if (prevClassName) {
+    dom.classList.remove(prevClassName);
+    styleManager.remove(prevClassName);
+  }
+  if (css && className) {
+    dom.classList.add(className);
+    styleManager.insert(className, css);
+  }
+}
+function diffHostProps(curr, next, dom) {
+  let isSvg = dom.namespaceURI === SVG_NS;
+  if (next.css || curr.css) {
+    diffCssProp(curr, next, dom);
+  }
+  for (let name in curr) {
+    if (isFrameworkProp(name))
+      continue;
+    if (!(name in next) || next[name] == null) {
+      if (canUseProperty(dom, name, isSvg)) {
+        try {
+          dom[name] = "";
+          continue;
+        } catch {
+        }
+      }
+      let { ns, attr } = normalizePropName(name, isSvg);
+      if (ns)
+        dom.removeAttributeNS(ns, attr);
+      else
+        dom.removeAttribute(attr);
+    }
+  }
+  for (let name in next) {
+    if (isFrameworkProp(name))
+      continue;
+    let nextValue = next[name];
+    if (nextValue == null)
+      continue;
+    let prevValue = curr[name];
+    if (prevValue !== nextValue) {
+      let { ns, attr } = normalizePropName(name, isSvg);
+      if (attr === "style" && typeof nextValue === "object" && nextValue && !Array.isArray(nextValue)) {
+        dom.setAttribute("style", serializeStyleObject(nextValue));
+        continue;
+      }
+      if (canUseProperty(dom, name, isSvg)) {
+        try {
+          dom[name] = nextValue == null ? "" : nextValue;
+          continue;
+        } catch {
+        }
+      }
+      if (typeof nextValue === "function") {
+        continue;
+      }
+      let isAriaOrData = name.startsWith("aria-") || name.startsWith("data-");
+      if (nextValue != null && (nextValue !== false || isAriaOrData)) {
+        let attrValue = name === "popover" && nextValue === true ? "" : String(nextValue);
+        if (ns)
+          dom.setAttributeNS(ns, attr, attrValue);
+        else
+          dom.setAttribute(attr, attrValue);
+      } else {
+        if (ns)
+          dom.removeAttributeNS(ns, attr);
+        else
+          dom.removeAttribute(attr);
+      }
+    }
+  }
+}
+var ATTRIBUTE_FALLBACK_NAMES = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "href",
+  "list",
+  "form",
+  "tabIndex",
+  "download",
+  "rowSpan",
+  "colSpan",
+  "role",
+  "popover"
+]);
+function canUseProperty(dom, name, isSvg) {
+  if (isSvg)
+    return false;
+  if (ATTRIBUTE_FALLBACK_NAMES.has(name))
+    return false;
+  return name in dom;
+}
+function isCommittedCatchNode(node) {
+  return isCatchNode(node) && node._added != void 0 && node._tripped != null;
+}
+function isComponentNode(node) {
+  return typeof node.type === "function" && node.type !== Frame;
+}
+function isCommittedComponentNode(node) {
+  return isComponentNode(node) && node._content !== void 0;
+}
+function isFrameworkProp(name) {
+  return name === "children" || name === "key" || name === "on" || name === "css" || name === "setup";
+}
+function serializeStyleObject(style) {
+  let parts = [];
+  for (let [key, value] of Object.entries(style)) {
+    if (value == null)
+      continue;
+    if (typeof value === "boolean")
+      continue;
+    if (typeof value === "number" && !Number.isFinite(value))
+      continue;
+    let cssKey = key.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+    let cssValue = Array.isArray(value) ? value.join(", ") : normalizeCssValue(key, value);
+    parts.push(`${cssKey}: ${cssValue};`);
+  }
+  return parts.join(" ");
+}
+function getSvgContext(vParent, nodeType) {
+  if (typeof nodeType === "string") {
+    if (nodeType === "svg")
+      return true;
+    if (nodeType === "foreignObject")
+      return false;
+  }
+  return vParent._svg ?? false;
+}
+function normalizePropName(name, isSvg) {
+  if (name.startsWith("aria-") || name.startsWith("data-"))
+    return { attr: name };
+  if (!isSvg) {
+    if (name === "className")
+      return { attr: "class" };
+    if (name === "htmlFor")
+      return { attr: "for" };
+    if (name === "tabIndex")
+      return { attr: "tabindex" };
+    if (name === "acceptCharset")
+      return { attr: "accept-charset" };
+    if (name === "httpEquiv")
+      return { attr: "http-equiv" };
+    return { attr: name.toLowerCase() };
+  }
+  if (name === "xlinkHref")
+    return { ns: XLINK_NS, attr: "xlink:href" };
+  if (name === "xmlLang")
+    return { ns: XML_NS, attr: "xml:lang" };
+  if (name === "xmlSpace")
+    return { ns: XML_NS, attr: "xml:space" };
+  if (name === "viewBox" || name === "preserveAspectRatio" || name === "gradientUnits" || name === "gradientTransform" || name === "patternUnits" || name === "patternTransform" || name === "clipPathUnits" || name === "maskUnits" || name === "maskContentUnits") {
+    return { attr: name };
+  }
+  return { attr: camelToKebab2(name) };
+}
+function camelToKebab2(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase();
+}
+function diffText(curr, next, scheduler, vParent) {
+  if (curr._text !== next._text) {
+    curr._dom.textContent = next._text;
+  }
+  next._dom = curr._dom;
+  next._parent = vParent;
+}
+function logHydrationMismatch(...msg) {
+  console.error("Hydration mismatch:", ...msg);
+}
+function insert(node, domParent, frame, scheduler, vParent, anchor, cursor) {
+  node._parent = vParent;
+  node._svg = getSvgContext(vParent, node.type);
+  cursor = skipComments(cursor ?? null);
+  let doInsert = anchor ? (dom) => domParent.insertBefore(dom, anchor) : (dom) => domParent.appendChild(dom);
+  if (isTextNode(node)) {
+    if (cursor instanceof Text) {
+      node._dom = cursor;
+      node._parent = vParent;
+      if (cursor.data !== node._text) {
+        logHydrationMismatch("text mismatch", cursor.data, node._text);
+        cursor.data = node._text;
+      }
+      return cursor.nextSibling;
+    }
+    let dom = document.createTextNode(node._text);
+    node._dom = dom;
+    node._parent = vParent;
+    doInsert(dom);
+    return cursor;
+  }
+  if (isHostNode(node)) {
+    if (cursor instanceof Element) {
+      if (cursor.tagName.toLowerCase() === node.type) {
+        diffHostProps({}, node.props, cursor);
+        setupHostNode(node, cursor, domParent, frame, scheduler);
+        let childCursor = cursor.firstChild;
+        let excess = diffChildren(null, node._children, cursor, frame, scheduler, node, childCursor);
+        if (excess) {
+          logHydrationMismatch("excess", excess);
+        }
+        return cursor.nextSibling;
+      } else {
+        logHydrationMismatch("tag", cursor.tagName.toLowerCase(), node.type);
+        cursor.remove();
+        cursor = void 0;
+      }
+    }
+    let dom = node._svg ? document.createElementNS(SVG_NS, node.type) : document.createElement(node.type);
+    diffHostProps({}, node.props, dom);
+    diffChildren(null, node._children, dom, frame, scheduler, node);
+    setupHostNode(node, dom, domParent, frame, scheduler);
+    doInsert(dom);
+    return cursor;
+  }
+  if (isFragmentNode(node)) {
+    for (let child of node._children) {
+      cursor = insert(child, domParent, frame, scheduler, vParent, anchor, cursor);
+    }
+    return cursor;
+  }
+  if (isCatchNode(node)) {
+    let added = [];
+    try {
+      for (let child of node._children) {
+        insert(child, domParent, frame, scheduler, node, anchor);
+        added.unshift(child);
+      }
+      node._parent = vParent;
+      node._tripped = false;
+      node._added = added;
+    } catch (e) {
+      let fallback = getCatchFallback(node, e);
+      for (let child of added) {
+        remove(child, domParent, scheduler);
+      }
+      insert(fallback, domParent, frame, scheduler, node, anchor);
+      node._parent = vParent;
+      node._tripped = true;
+      node._added = [fallback];
+      dispatchError(e);
+    }
+    return;
+  }
+  if (isComponentNode(node)) {
+    diffComponent(null, node, frame, scheduler, domParent, vParent, anchor, cursor);
+    return cursor;
+  }
+  if (node.type === Frame) {
+    throw new Error("TODO: Frame insert not implemented");
+  }
+  if (node.type === Catch) {
+    throw new Error("TODO: Catch insert not implemented");
+  }
+  invariant(false, "Unexpected node type");
+}
+function renderComponent(handle, currContent, next, domParent, frame, scheduler, vParent, anchor, cursor) {
+  let [element, tasks] = handle.render(next.props);
+  let content = toVNode(element);
+  diffVNodes(currContent, content, domParent, frame, scheduler, next, anchor, cursor);
+  next._content = content;
+  next._handle = handle;
+  next._parent = vParent;
+  let committed = next;
+  handle.setScheduleUpdate(() => {
+    scheduler.enqueue(committed, domParent, anchor);
+  });
+  scheduler.enqueueTasks(tasks);
+}
+function diffComponent(curr, next, frame, scheduler, domParent, vParent, anchor, cursor) {
+  if (curr === null) {
+    next._handle = createComponent({
+      id: `e${++fixmeIdCounter}`,
+      frame,
+      type: next.type,
+      raise: (error) => {
+        raise(error, next, domParent, frame, scheduler);
+      },
+      getContext: (type) => {
+        return findContextFromAncestry(vParent, type);
+      }
+    });
+    renderComponent(next._handle, null, next, domParent, frame, scheduler, vParent, anchor, cursor);
+    return;
+  }
+  next._handle = curr._handle;
+  let { _content, _handle } = curr;
+  renderComponent(_handle, _content, next, domParent, frame, scheduler, vParent, anchor, cursor);
+}
+function findContextFromAncestry(node, type) {
+  let current = node;
+  while (current) {
+    if (current.type === type && isComponentNode(current)) {
+      return current._handle.getContextValue();
+    }
+    current = current._parent;
+  }
+  return void 0;
+}
+function cleanupDescendants(node, scheduler) {
+  if (isCommittedTextNode(node)) {
+    return;
+  }
+  if (isCommittedHostNode(node)) {
+    for (let child of node._children) {
+      cleanupDescendants(child, scheduler);
+    }
+    if (node.props.css) {
+      let { className } = processStyle(node.props.css, styleCache);
+      if (className) {
+        styleManager.remove(className);
+      }
+    }
+    if (node._controller)
+      node._controller.abort();
+    let _events = node._events;
+    if (_events) {
+      scheduler.enqueueTasks([() => _events.dispose()]);
+    }
+    return;
+  }
+  if (isFragmentNode(node)) {
+    for (let child of node._children) {
+      cleanupDescendants(child, scheduler);
+    }
+    return;
+  }
+  if (isCommittedComponentNode(node)) {
+    cleanupDescendants(node._content, scheduler);
+    let tasks = node._handle.remove();
+    scheduler.enqueueTasks(tasks);
+    return;
+  }
+  if (isCommittedCatchNode(node)) {
+    for (let child of node._added) {
+      cleanupDescendants(child, scheduler);
+    }
+    return;
+  }
+}
+function remove(node, domParent, scheduler) {
+  if (isCommittedTextNode(node)) {
+    domParent.removeChild(node._dom);
+    return;
+  }
+  if (isCommittedHostNode(node)) {
+    for (let child of node._children) {
+      cleanupDescendants(child, scheduler);
+    }
+    if (node.props.css) {
+      let { className } = processStyle(node.props.css, styleCache);
+      if (className) {
+        styleManager.remove(className);
+      }
+    }
+    domParent.removeChild(node._dom);
+    if (node._controller)
+      node._controller.abort();
+    let _events = node._events;
+    if (_events) {
+      scheduler.enqueueTasks([() => _events.dispose()]);
+    }
+    return;
+  }
+  if (isFragmentNode(node)) {
+    for (let child of node._children) {
+      remove(child, domParent, scheduler);
+    }
+    return;
+  }
+  if (isCommittedComponentNode(node)) {
+    remove(node._content, domParent, scheduler);
+    let tasks = node._handle.remove();
+    scheduler.enqueueTasks(tasks);
+    return;
+  }
+  if (isCommittedCatchNode(node)) {
+    for (let child of node._added) {
+      remove(child, domParent, scheduler);
+    }
+    return;
+  }
+}
+function diffChildren(curr, next, domParent, frame, scheduler, vParent, cursor, anchor) {
+  if (curr === null) {
+    for (let node of next) {
+      cursor = insert(node, domParent, frame, scheduler, vParent, anchor, cursor);
+    }
+    vParent._children = next;
+    return cursor;
+  }
+  let currLength = curr.length;
+  let nextLength = next.length;
+  let hasKeys = false;
+  for (let i = 0; i < nextLength; i++) {
+    let node = next[i];
+    if (node && node.key != null) {
+      hasKeys = true;
+      break;
+    }
+  }
+  if (!hasKeys) {
+    for (let i = 0; i < nextLength; i++) {
+      let currentNode = i < currLength ? curr[i] : null;
+      diffVNodes(currentNode, next[i], domParent, frame, scheduler, vParent, anchor, cursor);
+    }
+    if (currLength > nextLength) {
+      for (let i = nextLength; i < currLength; i++) {
+        let node = curr[i];
+        if (node)
+          remove(node, domParent, scheduler);
+      }
+    }
+    vParent._children = next;
+    return;
+  }
+  let oldChildren = curr;
+  let oldChildrenLength = currLength;
+  let remainingOldChildren = oldChildrenLength;
+  let oldKeyMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < oldChildrenLength; i++) {
+    let c = oldChildren[i];
+    if (c) {
+      c._flags = 0;
+      if (c.key != null) {
+        oldKeyMap.set(c.key, i);
+      }
+    }
+  }
+  let skew = 0;
+  let newChildren = new Array(nextLength);
+  for (let i = 0; i < nextLength; i++) {
+    let childVNode = next[i];
+    if (!childVNode) {
+      newChildren[i] = childVNode;
+      continue;
+    }
+    newChildren[i] = childVNode;
+    childVNode._parent = vParent;
+    let skewedIndex = i + skew;
+    let matchingIndex = -1;
+    let key = childVNode.key;
+    let type = childVNode.type;
+    if (key != null) {
+      let mapIndex = oldKeyMap.get(key);
+      if (mapIndex !== void 0) {
+        let candidate = oldChildren[mapIndex];
+        let candidateFlags = candidate?._flags ?? 0;
+        if (candidate && (candidateFlags & MATCHED) === 0 && candidate.type === type) {
+          matchingIndex = mapIndex;
+        }
+      }
+    } else {
+      let searchVNode = oldChildren[skewedIndex];
+      let searchFlags = searchVNode?._flags ?? 0;
+      let available = searchVNode != null && (searchFlags & MATCHED) === 0;
+      if (available && searchVNode.key == null && type === searchVNode.type) {
+        matchingIndex = skewedIndex;
+      }
+    }
+    childVNode._index = matchingIndex;
+    let matchedOldVNode = null;
+    if (matchingIndex !== -1) {
+      matchedOldVNode = oldChildren[matchingIndex];
+      remainingOldChildren--;
+      if (matchedOldVNode) {
+        matchedOldVNode._flags = (matchedOldVNode._flags ?? 0) | MATCHED;
+      }
+    }
+    let oldDom = matchedOldVNode && findFirstDomAnchor(matchedOldVNode);
+    let isMounting = !matchedOldVNode || !oldDom;
+    if (isMounting) {
+      if (matchingIndex === -1) {
+        if (nextLength > oldChildrenLength) {
+          skew--;
+        } else if (nextLength < oldChildrenLength) {
+          skew++;
+        }
+      }
+      childVNode._flags = (childVNode._flags ?? 0) | INSERT_VNODE;
+    } else if (matchingIndex !== i + skew) {
+      if (matchingIndex === i + skew - 1) {
+        skew--;
+      } else if (matchingIndex === i + skew + 1) {
+        skew++;
+      } else {
+        if (matchingIndex > i + skew)
+          skew--;
+        else
+          skew++;
+        childVNode._flags = (childVNode._flags ?? 0) | INSERT_VNODE;
+      }
+    }
+  }
+  if (remainingOldChildren) {
+    for (let i = 0; i < oldChildrenLength; i++) {
+      let oldVNode = oldChildren[i];
+      if (oldVNode && ((oldVNode._flags ?? 0) & MATCHED) === 0) {
+        remove(oldVNode, domParent, scheduler);
+      }
+    }
+  }
+  vParent._children = newChildren;
+  let lastPlaced = null;
+  for (let i = 0; i < nextLength; i++) {
+    let childVNode = newChildren[i];
+    if (!childVNode)
+      continue;
+    let idx = childVNode._index ?? -1;
+    let oldVNode = idx >= 0 ? oldChildren[idx] : null;
+    diffVNodes(oldVNode, childVNode, domParent, frame, scheduler, vParent, anchor, cursor);
+    let shouldPlace = (childVNode._flags ?? 0) & INSERT_VNODE;
+    let firstDom = findFirstDomAnchor(childVNode);
+    if (shouldPlace && firstDom && firstDom.parentNode === domParent) {
+      if (lastPlaced === null) {
+        if (firstDom !== domParent.firstChild) {
+          domParent.insertBefore(firstDom, domParent.firstChild);
+        }
+      } else {
+        let target = lastPlaced.nextSibling;
+        if (firstDom !== target) {
+          domParent.insertBefore(firstDom, target);
+        }
+      }
+    }
+    if (firstDom)
+      lastPlaced = firstDom;
+    childVNode._flags = 0;
+    childVNode._index = void 0;
+  }
+  return;
+}
+function dispatchError(error) {
+}
+function getCatchFallback(vnode, error) {
+  let content = typeof vnode._fallback === "function" ? vnode._fallback(error) : vnode._fallback;
+  return toVNode(content);
+}
+function raise(error, descendant, domParent, frame, scheduler) {
+  let catchBoundary = findCatchBoundary(descendant);
+  if (catchBoundary) {
+    let content = getCatchFallback(catchBoundary, error);
+    let anchor = findFirstDomAnchor(catchBoundary) || findNextSiblingDomAnchor(catchBoundary, catchBoundary._parent) || void 0;
+    insert(content, domParent, frame, scheduler, catchBoundary, anchor);
+    for (let child of catchBoundary._added) {
+      remove(child, domParent, scheduler);
+    }
+    catchBoundary._tripped = true;
+    catchBoundary._added = [content];
+  } else {
+    dispatchError(error);
+  }
+}
+function findCatchBoundary(vnode) {
+  let current = vnode;
+  while (current) {
+    if (isCommittedCatchNode(current))
+      return current;
+    current = current._parent;
+  }
+  return null;
+}
+function isFragmentNode(node) {
+  return node.type === Fragment;
+}
+function isCatchNode(node) {
+  return node.type === Catch;
+}
+function isTextNode(node) {
+  return node.type === TEXT_NODE;
+}
+function isCommittedTextNode(node) {
+  return isTextNode(node) && node._dom instanceof Text;
+}
+function isHostNode(node) {
+  return typeof node.type === "string";
+}
+function isCommittedHostNode(node) {
+  return isHostNode(node) && node._dom instanceof Element;
+}
+function isRemixElement(node) {
+  return typeof node === "object" && node !== null && "$rmx" in node;
+}
+function findFirstDomAnchor(node) {
+  if (!node)
+    return null;
+  if (isCommittedTextNode(node))
+    return node._dom;
+  if (isCommittedHostNode(node))
+    return node._dom;
+  if (isCommittedComponentNode(node))
+    return findFirstDomAnchor(node._content);
+  if (isFragmentNode(node)) {
+    for (let child of node._children) {
+      let dom = findFirstDomAnchor(child);
+      if (dom)
+        return dom;
+    }
+  }
+  if (isCommittedCatchNode(node)) {
+    for (let child of node._added) {
+      let dom = findFirstDomAnchor(child);
+      if (dom)
+        return dom;
+    }
+  }
+  return null;
+}
+function findNextSiblingDomAnchor(curr, vParent) {
+  if (!vParent || !Array.isArray(vParent._children))
+    return null;
+  let children = vParent._children;
+  let idx = children.indexOf(curr);
+  if (idx === -1)
+    return null;
+  for (let i = idx + 1; i < children.length; i++) {
+    let dom = findFirstDomAnchor(children[i]);
+    if (dom)
+      return dom;
+  }
+  return null;
+}
+function skipComments(cursor) {
+  while (cursor && cursor.nodeType === Node.COMMENT_NODE) {
+    cursor = cursor.nextSibling;
+  }
+  return cursor;
+}
+
+// node_modules/.pnpm/@remix-run+component@0.3.0/node_modules/@remix-run/component/dist/lib/jsx.js
+function jsx(type, props, key) {
+  return { type, props, key, $rmx: true };
+}
+
+// entry.tsx
+var state = {
+  refs: null,
+  commits: [],
+  maxLane: 0,
+  selectedCommit: null,
+  diff: null,
+  filter: "all",
+  search: "",
+  loading: true
+};
+var updateApp;
+async function fetchRefs() {
+  let res = await fetch("/api/refs");
+  return res.json();
+}
+async function fetchCommits(ref, search) {
+  let params = new URLSearchParams();
+  if (ref) params.set("ref", ref);
+  if (search) params.set("search", search);
+  let res = await fetch(`/api/commits?${params}`);
+  let data = await res.json();
+  return { commits: data.commits, maxLane: data.maxLane };
+}
+async function fetchDiff(sha) {
+  let res = await fetch(`/api/diff/${sha}`);
+  return res.json();
+}
+async function setFilter(filter) {
+  state.filter = filter;
+  state.loading = true;
+  updateApp();
+  let ref = filter === "all" ? "all" : filter === "local" ? state.refs?.currentBranch : filter;
+  let result = await fetchCommits(ref, state.search);
+  state.commits = result.commits;
+  state.maxLane = result.maxLane;
+  state.loading = false;
+  updateApp();
+}
+async function setSearch(search) {
+  state.search = search;
+  state.loading = true;
+  updateApp();
+  let ref = state.filter === "all" ? "all" : state.filter === "local" ? state.refs?.currentBranch : state.filter;
+  let result = await fetchCommits(ref, search);
+  state.commits = result.commits;
+  state.maxLane = result.maxLane;
+  state.loading = false;
+  updateApp();
+}
+async function selectCommit(commit) {
+  state.selectedCommit = commit;
+  state.diff = null;
+  updateApp();
+  state.diff = await fetchDiff(commit.sha);
+  updateApp();
+}
+var colors = {
+  bg: "#ffffff",
+  bgLight: "#f6f8fa",
+  bgLighter: "#eaeef2",
+  border: "#d1d9e0",
+  text: "#1f2328",
+  textMuted: "#656d76",
+  accent: "#0969da",
+  accentDim: "#ddf4ff",
+  green: "#1a7f37",
+  red: "#cf222e"
+};
+var graphColors = [
+  "#0969da",
+  // blue
+  "#8250df",
+  // purple
+  "#bf3989",
+  // pink
+  "#cf222e",
+  // red
+  "#bc4c00",
+  // orange
+  "#4d2d00",
+  // brown
+  "#1a7f37",
+  // green
+  "#0550ae"
+  // dark blue
+];
+function App(handle) {
+  updateApp = () => handle.update();
+  handle.queueTask(async () => {
+    let [refs, commitsResult] = await Promise.all([
+      fetchRefs(),
+      fetchCommits("all")
+    ]);
+    state.refs = refs;
+    state.commits = commitsResult.commits;
+    state.maxLane = commitsResult.maxLane;
+    state.loading = false;
+    handle.update();
+  });
+  return () => /* @__PURE__ */ jsx(
+    "div",
+    {
+      css: {
+        display: "flex",
+        height: "100vh",
+        background: colors.bg,
+        color: colors.text,
+        fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+        fontSize: "13px"
+      },
+      children: [
+        /* @__PURE__ */ jsx(Sidebar, {}),
+        /* @__PURE__ */ jsx(MainPanel, {})
+      ]
+    }
+  );
+}
+function Sidebar() {
+  return () => /* @__PURE__ */ jsx(
+    "div",
+    {
+      css: {
+        width: "200px",
+        minWidth: "200px",
+        borderRight: `1px solid ${colors.border}`,
+        display: "flex",
+        flexDirection: "column",
+        overflow: "hidden"
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            css: {
+              padding: "12px",
+              borderBottom: `1px solid ${colors.border}`,
+              fontWeight: 600,
+              fontSize: "11px",
+              textTransform: "uppercase",
+              letterSpacing: "0.5px",
+              color: colors.textMuted
+            },
+            children: "Git Tree Viewer"
+          }
+        ),
+        /* @__PURE__ */ jsx("div", { css: { flex: 1, overflow: "auto", padding: "8px 0" }, children: state.refs && /* @__PURE__ */ jsx(Fragment, { children: [
+          /* @__PURE__ */ jsx(RefSection, { title: "LOCAL", nodes: state.refs.local }),
+          Object.entries(state.refs.remotes).map(([remote, nodes]) => /* @__PURE__ */ jsx(
+            RefSection,
+            {
+              title: remote.toUpperCase(),
+              nodes
+            },
+            remote
+          ))
+        ] }) })
+      ]
+    }
+  );
+}
+function RefSection(handle) {
+  let expanded = true;
+  return ({ title, nodes }) => /* @__PURE__ */ jsx("div", { css: { marginBottom: "8px" }, children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        css: {
+          padding: "4px 12px",
+          fontSize: "10px",
+          fontWeight: 600,
+          textTransform: "uppercase",
+          letterSpacing: "0.5px",
+          color: colors.textMuted,
+          cursor: "pointer",
+          "&:hover": { color: colors.text }
+        },
+        on: {
+          click: () => {
+            expanded = !expanded;
+            handle.update();
+          }
+        },
+        children: [
+          expanded ? "\u25BC" : "\u25B6",
+          " ",
+          title
+        ]
+      }
+    ),
+    expanded && /* @__PURE__ */ jsx("div", { css: { paddingLeft: "8px" }, children: nodes.map((node) => /* @__PURE__ */ jsx(RefNodeItem, { node, depth: 0 }, node.name)) })
+  ] });
+}
+function RefNodeItem(handle) {
+  let expanded = true;
+  return ({ node, depth }) => {
+    let paddingLeft = 12 + depth * 12;
+    if (node.type === "folder") {
+      return /* @__PURE__ */ jsx("div", { children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            css: {
+              padding: `3px 12px`,
+              paddingLeft: `${paddingLeft}px`,
+              cursor: "pointer",
+              color: colors.textMuted,
+              fontSize: "12px",
+              "&:hover": { color: colors.text }
+            },
+            on: {
+              click: () => {
+                expanded = !expanded;
+                handle.update();
+              }
+            },
+            children: [
+              expanded ? "\u25BC" : "\u25B6",
+              " ",
+              node.name,
+              "/"
+            ]
+          }
+        ),
+        expanded && node.children.map((child) => /* @__PURE__ */ jsx(RefNodeItem, { node: child, depth: depth + 1 }, child.name))
+      ] });
+    }
+    let isSelected = state.filter === node.fullName;
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        css: {
+          padding: `3px 12px`,
+          paddingLeft: `${paddingLeft}px`,
+          cursor: "pointer",
+          borderRadius: "3px",
+          marginRight: "8px",
+          background: isSelected ? colors.accentDim : "transparent",
+          color: node.current ? colors.accent : colors.text,
+          fontWeight: node.current ? 600 : 400,
+          "&:hover": {
+            background: isSelected ? colors.accentDim : colors.bgLighter
+          }
+        },
+        on: { click: () => setFilter(node.fullName) },
+        children: [
+          node.current && "\u25CF ",
+          node.name
+        ]
+      }
+    );
+  };
+}
+function MainPanel() {
+  return () => /* @__PURE__ */ jsx(
+    "div",
+    {
+      css: {
+        flex: 1,
+        display: "flex",
+        flexDirection: "column",
+        overflow: "hidden"
+      },
+      children: [
+        /* @__PURE__ */ jsx(CommitList, {}),
+        /* @__PURE__ */ jsx(DiffPanel, {})
+      ]
+    }
+  );
+}
+function CommitList() {
+  let searchTimeout = null;
+  function handleSearch(value) {
+    if (searchTimeout) clearTimeout(searchTimeout);
+    searchTimeout = setTimeout(() => setSearch(value), 300);
+  }
+  return () => /* @__PURE__ */ jsx(
+    "div",
+    {
+      css: {
+        height: "40%",
+        minHeight: "200px",
+        display: "flex",
+        flexDirection: "column",
+        borderBottom: `1px solid ${colors.border}`
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            css: {
+              display: "flex",
+              alignItems: "center",
+              gap: "8px",
+              padding: "8px 12px",
+              borderBottom: `1px solid ${colors.border}`,
+              background: colors.bgLight
+            },
+            children: [
+              /* @__PURE__ */ jsx(FilterButton, { label: "All", filter: "all" }),
+              /* @__PURE__ */ jsx(FilterButton, { label: "Local", filter: "local" }),
+              state.refs && /* @__PURE__ */ jsx(
+                FilterButton,
+                {
+                  label: state.refs.currentBranch,
+                  filter: state.refs.currentBranch
+                }
+              ),
+              /* @__PURE__ */ jsx("div", { css: { flex: 1 } }),
+              /* @__PURE__ */ jsx(
+                "input",
+                {
+                  type: "text",
+                  placeholder: "Search commits...",
+                  css: {
+                    width: "200px",
+                    padding: "4px 8px",
+                    border: `1px solid ${colors.border}`,
+                    borderRadius: "4px",
+                    background: colors.bg,
+                    color: colors.text,
+                    fontSize: "12px",
+                    "&:focus": { outline: "none", borderColor: colors.accent },
+                    "&::placeholder": { color: colors.textMuted }
+                  },
+                  on: {
+                    input: (e) => handleSearch(e.target.value)
+                  }
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx("div", { css: { flex: 1, overflow: "auto" }, children: state.loading ? /* @__PURE__ */ jsx(
+          "div",
+          {
+            css: {
+              padding: "20px",
+              textAlign: "center",
+              color: colors.textMuted
+            },
+            children: "Loading..."
+          }
+        ) : /* @__PURE__ */ jsx(
+          "table",
+          {
+            css: {
+              width: "100%",
+              borderCollapse: "collapse",
+              tableLayout: "fixed",
+              "& th, & td": {
+                padding: "6px 12px",
+                textAlign: "left",
+                borderBottom: `1px solid ${colors.border}`,
+                overflow: "hidden",
+                textOverflow: "ellipsis",
+                whiteSpace: "nowrap"
+              },
+              "& th": {
+                background: colors.bgLight,
+                fontWeight: 600,
+                fontSize: "11px",
+                textTransform: "uppercase",
+                letterSpacing: "0.5px",
+                color: colors.textMuted,
+                position: "sticky",
+                top: 0
+              },
+              "& tbody tr:hover": { background: colors.bgLighter }
+            },
+            children: [
+              /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsx("tr", { children: [
+                /* @__PURE__ */ jsx("th", { children: "Subject" }),
+                /* @__PURE__ */ jsx("th", { css: { width: "150px" }, children: "Author" }),
+                /* @__PURE__ */ jsx("th", { css: { width: "150px" }, children: "Date" }),
+                /* @__PURE__ */ jsx("th", { css: { width: "80px" }, children: "SHA" })
+              ] }) }),
+              /* @__PURE__ */ jsx("tbody", { children: state.commits.map((commit) => /* @__PURE__ */ jsx(CommitRow, { commit }, commit.sha)) })
+            ]
+          }
+        ) })
+      ]
+    }
+  );
+}
+function FilterButton() {
+  return ({ label, filter }) => {
+    let isActive = state.filter === filter;
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        css: {
+          padding: "4px 10px",
+          border: `1px solid ${isActive ? colors.accent : colors.border}`,
+          borderRadius: "4px",
+          background: isActive ? colors.accentDim : "transparent",
+          color: isActive ? colors.accent : colors.text,
+          fontSize: "12px",
+          cursor: "pointer",
+          "&:hover": { borderColor: colors.accent }
+        },
+        on: { click: () => setFilter(filter) },
+        children: label
+      }
+    );
+  };
+}
+function CommitRow() {
+  return ({ commit }) => {
+    let isSelected = state.selectedCommit?.sha === commit.sha;
+    let { graph } = commit;
+    let maxUsedLane = graph.lane;
+    for (let line of graph.lines) {
+      maxUsedLane = Math.max(maxUsedLane, line.from, line.to);
+    }
+    let graphWidth = (maxUsedLane + 1) * 16 + 8;
+    let laneColor = graphColors[graph.color % graphColors.length];
+    return /* @__PURE__ */ jsx(
+      "tr",
+      {
+        css: {
+          cursor: "pointer",
+          background: isSelected ? colors.accentDim : "transparent"
+        },
+        on: { click: () => selectCommit(commit) },
+        children: [
+          /* @__PURE__ */ jsx("td", { css: { display: "flex", alignItems: "center" }, children: [
+            /* @__PURE__ */ jsx(
+              "svg",
+              {
+                width: graphWidth,
+                height: "24",
+                css: { display: "block", flexShrink: 0 },
+                children: [
+                  graph.lines.map((line, i) => {
+                    let x1 = line.from * 16 + 8;
+                    let x2 = line.to * 16 + 8;
+                    let color = graphColors[line.color % graphColors.length];
+                    let isOwnLaneLine = line.from === graph.lane && line.to === graph.lane;
+                    if (line.from === line.to) {
+                      if (isOwnLaneLine && graph.isFirstInLane) {
+                        return /* @__PURE__ */ jsx(
+                          "line",
+                          {
+                            x1,
+                            y1: 12,
+                            x2,
+                            y2: 24,
+                            stroke: color,
+                            "stroke-width": "2"
+                          },
+                          i
+                        );
+                      }
+                      return /* @__PURE__ */ jsx(
+                        "line",
+                        {
+                          x1,
+                          y1: 0,
+                          x2,
+                          y2: 24,
+                          stroke: color,
+                          "stroke-width": "2"
+                        },
+                        i
+                      );
+                    } else {
+                      let midY = 12;
+                      return /* @__PURE__ */ jsx(
+                        "path",
+                        {
+                          d: `M ${x1} 0 Q ${x1} ${midY}, ${(x1 + x2) / 2} ${midY} Q ${x2} ${midY}, ${x2} 24`,
+                          fill: "none",
+                          stroke: color,
+                          "stroke-width": "2"
+                        },
+                        i
+                      );
+                    }
+                  }),
+                  /* @__PURE__ */ jsx(
+                    "circle",
+                    {
+                      cx: graph.lane * 16 + 8,
+                      cy: 12,
+                      r: 4,
+                      fill: laneColor,
+                      stroke: colors.bg,
+                      "stroke-width": "1"
+                    }
+                  )
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "span",
+              {
+                css: {
+                  overflow: "hidden",
+                  textOverflow: "ellipsis",
+                  whiteSpace: "nowrap"
+                },
+                children: [
+                  commit.refs.map((ref) => /* @__PURE__ */ jsx(
+                    "span",
+                    {
+                      css: {
+                        display: "inline-block",
+                        padding: "1px 6px",
+                        marginRight: "6px",
+                        borderRadius: "3px",
+                        background: laneColor,
+                        color: "#fff",
+                        fontSize: "10px",
+                        fontWeight: 600
+                      },
+                      children: ref
+                    },
+                    ref
+                  )),
+                  commit.subject
+                ]
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx("td", { css: { color: colors.textMuted }, children: commit.author }),
+          /* @__PURE__ */ jsx("td", { css: { color: colors.textMuted }, children: commit.date }),
+          /* @__PURE__ */ jsx("td", { children: /* @__PURE__ */ jsx("code", { css: { color: colors.accent, fontSize: "11px" }, children: commit.shortSha }) })
+        ]
+      }
+    );
+  };
+}
+function DiffPanel() {
+  return () => {
+    if (!state.selectedCommit) {
+      return /* @__PURE__ */ jsx(
+        "div",
+        {
+          css: {
+            flex: 1,
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            color: colors.textMuted,
+            background: colors.bgLight
+          },
+          children: "Select a commit to view diff"
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        css: {
+          flex: 1,
+          display: "flex",
+          flexDirection: "column",
+          background: colors.bgLight
+        },
+        children: [
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              css: { padding: "12px", borderBottom: `1px solid ${colors.border}` },
+              children: [
+                /* @__PURE__ */ jsx("div", { css: { fontWeight: 600, marginBottom: "4px" }, children: state.selectedCommit.subject }),
+                /* @__PURE__ */ jsx("div", { css: { fontSize: "12px", color: colors.textMuted }, children: [
+                  /* @__PURE__ */ jsx("span", { children: state.selectedCommit.author }),
+                  /* @__PURE__ */ jsx("span", { css: { margin: "0 8px" }, children: "\u2022" }),
+                  /* @__PURE__ */ jsx("span", { children: state.selectedCommit.date }),
+                  /* @__PURE__ */ jsx("span", { css: { margin: "0 8px" }, children: "\u2022" }),
+                  /* @__PURE__ */ jsx("code", { css: { color: colors.accent }, children: state.selectedCommit.shortSha })
+                ] })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx("div", { css: { flex: 1, overflow: "auto" }, children: state.diff ? /* @__PURE__ */ jsx(
+            "section",
+            {
+              css: {
+                "& .d2h-wrapper": { background: "transparent" },
+                "& .d2h-file-header": {
+                  background: colors.bgLighter,
+                  borderBottom: `1px solid ${colors.border}`,
+                  padding: "8px 12px"
+                },
+                "& .d2h-file-name": { color: colors.text },
+                "& .d2h-code-line": { padding: "0 8px" },
+                "& .d2h-code-line-ctn": { color: colors.text },
+                "& .d2h-ins": { background: "#dafbe1" },
+                "& .d2h-del": { background: "#ffebe9" },
+                "& .d2h-ins .d2h-code-line-ctn": { color: colors.green },
+                "& .d2h-del .d2h-code-line-ctn": { color: colors.red },
+                "& .d2h-code-linenumber": {
+                  color: colors.textMuted,
+                  borderRight: `1px solid ${colors.border}`
+                },
+                "& .d2h-file-diff": {
+                  borderBottom: `1px solid ${colors.border}`
+                },
+                "& .d2h-diff-tbody": { position: "relative" }
+              },
+              innerHTML: state.diff.diffHtml
+            }
+          ) : /* @__PURE__ */ jsx(
+            "div",
+            {
+              css: {
+                padding: "20px",
+                textAlign: "center",
+                color: colors.textMuted
+              },
+              children: "Loading diff..."
+            }
+          ) })
+        ]
+      }
+    );
+  };
+}
+createRoot(document.body).render(/* @__PURE__ */ jsx(App, {}));