@clusterenvision/ui-framework 1.0.0

package/dist/chunk-W3LNNY3U.cjs

@@ -0,0 +1,729 @@
+'use strict';
+
+var chunkPVZVFICK_cjs = require('./chunk-PVZVFICK.cjs');
+var chunkIRBUKIRF_cjs = require('./chunk-IRBUKIRF.cjs');
+var chunkFFCZSYC7_cjs = require('./chunk-FFCZSYC7.cjs');
+var chunkEFOOXCY7_cjs = require('./chunk-EFOOXCY7.cjs');
+var chunkVHUXNDW2_cjs = require('./chunk-VHUXNDW2.cjs');
+
+// src/runtime/di.js
+var Injector = class _Injector {
+  constructor(parent) {
+    this.parent = parent;
+    this.records = /* @__PURE__ */ new Map();
+  }
+  register(provider) {
+    this.records.set(provider.token, createRecord(provider));
+  }
+  get(token, notFound) {
+    const record = this.records.get(token);
+    if (record) {
+      if (!record.resolved) {
+        record.value = record.factory(this);
+        record.resolved = true;
+      }
+      return record.value;
+    }
+    if (this.parent) {
+      return this.parent.get(token, notFound);
+    }
+    if (typeof notFound !== "undefined") {
+      return notFound;
+    }
+    throw new Error(`No provider for token ${token.toString()}`);
+  }
+  createChild(providers = []) {
+    const child = new _Injector(this);
+    providers.forEach((provider) => {
+      child.register(provider);
+    });
+    return child;
+  }
+};
+function createInjector(providers = [], parent) {
+  const injector = new Injector(parent);
+  providers.forEach((provider) => {
+    injector.register(provider);
+  });
+  return injector;
+}
+function createRecord(provider) {
+  if (Object.prototype.hasOwnProperty.call(provider, "useValue")) {
+    return {
+      token: provider.token,
+      resolved: true,
+      factory: () => provider.useValue,
+      value: provider.useValue
+    };
+  }
+  if (provider.useClass) {
+    const Target = provider.useClass;
+    return {
+      token: provider.token,
+      resolved: false,
+      factory: (injector) => new Target(...(provider.deps ?? []).map((dep) => injector.get(dep)))
+    };
+  }
+  if (provider.useFactory) {
+    const factory = provider.useFactory;
+    return {
+      token: provider.token,
+      resolved: false,
+      factory: (injector) => factory(...(provider.deps ?? []).map((dep) => injector.get(dep)))
+    };
+  }
+  throw new Error("Unsupported provider configuration.");
+}
+
+// src/runtime/template.js
+var expressionCache = /* @__PURE__ */ new Map();
+function compileExpression(expression) {
+  let runner = expressionCache.get(expression);
+  if (!runner) {
+    runner = new Function("ctx", `with(ctx){ return (${expression}); }`);
+    expressionCache.set(expression, runner);
+  }
+  return runner;
+}
+function toDisplay(value) {
+  if (value == null) {
+    return "";
+  }
+  if (Array.isArray(value)) {
+    return value.map(toDisplay).join(",");
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function renderTemplate(compiled, scope, target) {
+  const disposers = [];
+  const register = (dispose) => disposers.push(dispose);
+  const renderContext = { scopeAttr: compiled.scopeId };
+  compiled.instructions.forEach((instruction) => {
+    mountInstruction(instruction, target, scope, register, renderContext);
+  });
+  return {
+    destroy() {
+      disposers.slice().reverse().forEach((dispose) => {
+        dispose();
+      });
+    }
+  };
+}
+function mountInstruction(instruction, parent, scope, register, context, before) {
+  switch (instruction.type) {
+    case "text":
+      mountText(instruction.value, parent, register, before);
+      return;
+    case "expression":
+      mountExpression(instruction.expression, parent, scope, register, before);
+      return;
+    case "element":
+      mountElement(instruction, parent, scope, register, context, before);
+      return;
+    case "if":
+      mountConditional(instruction, parent, scope, register, context, before);
+      return;
+    case "for":
+      mountLoop(instruction, parent, scope, register, context, before);
+      return;
+    case "slot":
+      mountSlot(instruction, parent, scope, register, context, before);
+      return;
+    case "await":
+      mountAwait(instruction, parent, scope, register, context, before);
+      return;
+    default:
+      return;
+  }
+}
+function mountText(value, parent, register, before) {
+  const textNode = document.createTextNode(value);
+  insertNode(parent, textNode, before);
+  register(() => {
+    textNode.remove();
+  });
+}
+function mountExpression(expression, parent, scope, register, before) {
+  const textNode = document.createTextNode("");
+  insertNode(parent, textNode, before);
+  const runner = compileExpression(expression);
+  const dispose = chunkVHUXNDW2_cjs.effect(() => {
+    const value = runner(scope);
+    textNode.textContent = toDisplay(value);
+  });
+  register(() => {
+    dispose();
+    textNode.remove();
+  });
+}
+function mountElement(instruction, parent, scope, register, context, before) {
+  const el = document.createElement(instruction.tag.toLowerCase());
+  const indexedEl = el;
+  if (context.scopeAttr && !el.hasAttribute(chunkIRBUKIRF_cjs.STYLE_SCOPE_ATTR)) {
+    el.setAttribute(chunkIRBUKIRF_cjs.STYLE_SCOPE_ATTR, context.scopeAttr);
+  }
+  const attrRegister = createLocalRegister(register);
+  for (const attr of instruction.attributes) {
+    switch (attr.kind) {
+      case "static":
+        el.setAttribute(attr.name, attr.value);
+        break;
+      case "property": {
+        const runner = compileExpression(attr.expression);
+        const dispose = chunkVHUXNDW2_cjs.effect(() => {
+          const value = runner(scope);
+          indexedEl[attr.name] = value;
+        });
+        attrRegister.register(dispose);
+        break;
+      }
+      case "event": {
+        const runner = compileExpression(attr.handler);
+        const listener = (event) => {
+          const handler = runner(scope);
+          if (typeof handler === "function") {
+            handler(event);
+          }
+        };
+        el.addEventListener(attr.name, listener);
+        attrRegister.register(() => {
+          el.removeEventListener(attr.name, listener);
+        });
+        break;
+      }
+      case "class-list": {
+        const runner = compileExpression(attr.expression);
+        const dispose = chunkVHUXNDW2_cjs.effect(() => {
+          const result = runner(scope);
+          if (typeof result === "string") {
+            el.className = result;
+            return;
+          }
+          if (result && typeof result === "object") {
+            const segments = [];
+            for (const [key, value] of Object.entries(result)) {
+              if (value) {
+                segments.push(key);
+              }
+            }
+            el.className = segments.join(" ");
+          }
+        });
+        attrRegister.register(dispose);
+        break;
+      }
+    }
+  }
+  insertNode(parent, el, before);
+  instruction.children.forEach((child) => {
+    mountInstruction(child, el, scope, register, context);
+  });
+  register(() => {
+    attrRegister.flush();
+    el.remove();
+  });
+}
+function mountConditional(instruction, parent, scope, register, context, before) {
+  const anchor = document.createComment("ce:if");
+  insertNode(parent, anchor, before);
+  let current;
+  const runner = compileExpression(instruction.condition);
+  const dispose = chunkVHUXNDW2_cjs.effect(() => {
+    current?.();
+    current = void 0;
+    const condition = Boolean(runner(scope));
+    if (condition) {
+      current = mountInstructionList(instruction.truthy, parent, scope, register, context, anchor);
+      return;
+    }
+    if (instruction.falsy) {
+      current = mountInstructionList(instruction.falsy, parent, scope, register, context, anchor);
+    }
+  });
+  register(() => {
+    dispose();
+    current?.();
+    anchor.remove();
+  });
+}
+function mountLoop(instruction, parent, scope, register, context, before) {
+  const anchor = document.createComment("ce:for");
+  insertNode(parent, anchor, before);
+  let instances = [];
+  const runner = compileExpression(instruction.iterator);
+  const dispose = chunkVHUXNDW2_cjs.effect(() => {
+    instances.forEach((cleanup) => {
+      cleanup();
+    });
+    instances = [];
+    const iterable = runner(scope);
+    const values = Array.isArray(iterable) ? iterable : iterable && typeof iterable === "object" && Symbol.iterator in iterable ? Array.from(iterable) : [];
+    values.forEach((value, index) => {
+      const childScope = Object.create(scope);
+      childScope[instruction.item] = value;
+      if (instruction.index) {
+        childScope[instruction.index] = index;
+      }
+      instances.push(mountInstructionList(instruction.children, parent, childScope, register, context, anchor));
+    });
+  });
+  register(() => {
+    dispose();
+    instances.forEach((cleanup) => {
+      cleanup();
+    });
+    anchor.remove();
+  });
+}
+function mountSlot(instruction, parent, scope, register, _context, before) {
+  const slotName = instruction.name ?? "default";
+  const slotRenderer = scope.slots?.[slotName];
+  if (slotRenderer) {
+    const fragment = document.createDocumentFragment();
+    slotRenderer(fragment);
+    insertNode(parent, fragment, before);
+    const nodes = Array.from(fragment.childNodes);
+    register(() => {
+      nodes.forEach((node) => {
+        node.parentNode?.removeChild(node);
+      });
+    });
+  } else {
+    instruction.children.forEach((child) => {
+      mountInstruction(child, parent, scope, register, _context, before);
+    });
+  }
+}
+function mountAwait(instruction, parent, scope, register, context, before) {
+  const start = document.createComment("ce:await:start");
+  const end = document.createComment("ce:await:end");
+  insertNode(parent, start, before);
+  insertNode(parent, end, before);
+  let currentDispose = null;
+  let token = 0;
+  const renderBranch = (instructions, extraScope) => {
+    if (currentDispose) {
+      currentDispose();
+    }
+    if (instructions.length === 0) {
+      currentDispose = null;
+      return;
+    }
+    const branchScope = extraScope ? Object.assign(Object.create(scope), extraScope) : scope;
+    currentDispose = mountInstructionList(instructions, parent, branchScope, register, context, end);
+  };
+  const dispose = chunkVHUXNDW2_cjs.effect(() => {
+    const value = compileExpression(instruction.expression)(scope);
+    const currentToken = token += 1;
+    if (isPromiseLike(value)) {
+      renderBranch(instruction.pending);
+      value.then((resolved) => {
+        if (currentToken !== token) {
+          return;
+        }
+        const extra2 = instruction.valueName ? { [instruction.valueName]: resolved } : void 0;
+        renderBranch(instruction.resolved, extra2);
+      }).catch((error) => {
+        if (currentToken !== token) {
+          return;
+        }
+        const extra2 = instruction.errorName ? { [instruction.errorName]: error } : void 0;
+        renderBranch(instruction.rejected, extra2);
+      });
+      return;
+    }
+    const extra = instruction.valueName ? { [instruction.valueName]: value } : void 0;
+    renderBranch(instruction.resolved, extra);
+  });
+  register(() => {
+    dispose();
+    if (currentDispose) {
+      currentDispose();
+    }
+    start.remove();
+    end.remove();
+  });
+}
+function mountInstructionList(instructions, parent, scope, register, context, before) {
+  const local = createLocalRegister(register);
+  instructions.forEach((child) => {
+    mountInstruction(child, parent, scope, local.register, context, before);
+  });
+  return () => {
+    local.flush();
+  };
+}
+function insertNode(parent, node, before) {
+  if (before && before.parentNode === parent) {
+    parent.insertBefore(node, before);
+    return;
+  }
+  parent.appendChild(node);
+}
+function createLocalRegister(parent) {
+  const localDisposers = [];
+  const register = (dispose) => localDisposers.push(dispose);
+  const flush = () => {
+    localDisposers.slice().reverse().forEach((dispose) => {
+      dispose();
+    });
+    localDisposers.length = 0;
+  };
+  parent(flush);
+  return { register, flush };
+}
+function isPromiseLike(value) {
+  return Boolean(value) && typeof value === "object" && "then" in value;
+}
+
+// src/runtime/ssr.js
+function renderTemplateToString(compiled, scope) {
+  return compiled.instructions.map((instruction) => renderInstruction(instruction, scope, compiled.scopeId)).join("");
+}
+async function renderTemplateToStream(compiled, scope) {
+  const tasks = [];
+  const html = compiled.instructions.map((instruction) => renderInstruction(instruction, scope, compiled.scopeId, tasks)).join("");
+  return createStreamIterable(html, tasks);
+}
+function renderInstruction(instruction, scope, scopeAttr, tasks) {
+  switch (instruction.type) {
+    case "text":
+      return escapeHtml(instruction.value);
+    case "expression":
+      return escapeHtml(toDisplay(compileExpression(instruction.expression)(scope)));
+    case "element":
+      return renderElement(instruction, scope, scopeAttr, tasks);
+    case "if":
+      return renderConditional(instruction, scope, scopeAttr, tasks);
+    case "for":
+      return renderLoop(instruction, scope, scopeAttr, tasks);
+    case "slot":
+      return renderSlot(instruction, scope, scopeAttr, tasks);
+    case "await":
+      return renderAwait(instruction, scope, scopeAttr, tasks);
+    default:
+      return "";
+  }
+}
+function renderElement(instruction, scope, scopeAttr, tasks) {
+  const attrs = instruction.attributes.map((attr) => attributeToString(attr, scope)).filter(Boolean);
+  if (scopeAttr && !instruction.attributes.some((attr) => attr.kind === "static" && attr.name === chunkIRBUKIRF_cjs.STYLE_SCOPE_ATTR)) {
+    attrs.push(`${chunkIRBUKIRF_cjs.STYLE_SCOPE_ATTR}="${scopeAttr}"`);
+  }
+  const joinedAttrs = attrs.filter(Boolean).join(" ");
+  const children = instruction.children.map((child) => renderInstruction(child, scope, scopeAttr, tasks)).join("");
+  const open = `<${instruction.tag}${joinedAttrs ? ` ${joinedAttrs}` : ""}>`;
+  const close = `</${instruction.tag}>`;
+  return `${open}${children}${close}`;
+}
+function attributeToString(attr, scope) {
+  if (attr.kind === "static") {
+    return `${attr.name}="${escapeAttribute(attr.value)}"`;
+  }
+  if (attr.kind === "property") {
+    const value = compileExpression(attr.expression)(scope);
+    if (value === false || value === null || typeof value === "undefined") {
+      return "";
+    }
+    return `${attr.name}="${escapeAttribute(toDisplay(value))}"`;
+  }
+  if (attr.kind === "class-list") {
+    const value = compileExpression(attr.expression)(scope);
+    if (typeof value === "string") {
+      return value ? `class="${escapeAttribute(value)}"` : "";
+    }
+    if (value && typeof value === "object") {
+      const segments = Object.entries(value).filter(([, enabled]) => Boolean(enabled)).map(([key]) => key).join(" ");
+      return segments ? `class="${escapeAttribute(segments)}"` : "";
+    }
+    return "";
+  }
+  return "";
+}
+function renderConditional(instruction, scope, scopeAttr, tasks) {
+  const condition = Boolean(compileExpression(instruction.condition)(scope));
+  if (condition) {
+    return instruction.truthy.map((child) => renderInstruction(child, scope, scopeAttr, tasks)).join("");
+  }
+  if (instruction.falsy) {
+    return instruction.falsy.map((child) => renderInstruction(child, scope, scopeAttr, tasks)).join("");
+  }
+  return "";
+}
+function renderLoop(instruction, scope, scopeAttr, tasks) {
+  const iterable = compileExpression(instruction.iterator)(scope);
+  const values = Array.isArray(iterable) ? iterable : iterable && typeof iterable === "object" && Symbol.iterator in iterable ? Array.from(iterable) : [];
+  return values.map((value, index) => {
+    const childScope = Object.create(scope);
+    childScope[instruction.item] = value;
+    if (instruction.index) {
+      childScope[instruction.index] = index;
+    }
+    return instruction.children.map((child) => renderInstruction(child, childScope, scopeAttr, tasks)).join("");
+  }).join("");
+}
+function renderSlot(instruction, scope, scopeAttr, tasks) {
+  const slotName = instruction.name ?? "default";
+  const renderer = scope.slots?.[slotName];
+  if (renderer) {
+    return "";
+  }
+  return instruction.children.map((child) => renderInstruction(child, scope, scopeAttr, tasks)).join("");
+}
+function renderAwait(instruction, scope, scopeAttr, tasks) {
+  const value = compileExpression(instruction.expression)(scope);
+  if (!isPromiseLike2(value)) {
+    return renderAwaitBranch(instruction.resolved, scope, scopeAttr, tasks, instruction.valueName, value);
+  }
+  const pendingHtml = instruction.pending.map((child) => renderInstruction(child, scope, scopeAttr, tasks)).join("");
+  const awaitId = nextAwaitId();
+  if (tasks) {
+    tasks.push({
+      id: awaitId,
+      promise: value,
+      resolve: (resolved) => renderAwaitBranch(instruction.resolved, scope, scopeAttr, tasks, instruction.valueName, resolved),
+      reject: (error) => renderAwaitBranch(instruction.rejected, scope, scopeAttr, tasks, instruction.errorName, error)
+    });
+  }
+  return `<span data-ce-await="${awaitId}">${pendingHtml}</span>`;
+}
+function renderAwaitBranch(instructions, scope, scopeAttr, tasks, bindingName, bindingValue) {
+  if (instructions.length === 0) {
+    return "";
+  }
+  const branchScope = bindingName ? Object.assign(Object.create(scope), { [bindingName]: bindingValue }) : scope;
+  return instructions.map((child) => renderInstruction(child, branchScope, scopeAttr, tasks)).join("");
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttribute(value) {
+  return escapeHtml(value).replace(/"/g, "&quot;");
+}
+function isPromiseLike2(value) {
+  return Boolean(value) && typeof value === "object" && "then" in value;
+}
+function createStreamIterable(initialHtml, tasks) {
+  return {
+    async *[Symbol.asyncIterator]() {
+      yield initialHtml;
+      for (const task of tasks) {
+        try {
+          const resolved = await task.promise;
+          const html = task.resolve(resolved);
+          yield buildAwaitReplacement(task.id, html);
+        } catch (error) {
+          const html = task.reject(error);
+          yield buildAwaitReplacement(task.id, html);
+        }
+      }
+    }
+  };
+}
+function buildAwaitReplacement(id, html) {
+  const escapedId = escapeAttribute(id);
+  const template = `<template data-ce-await="${escapedId}">${html}</template>`;
+  const script = `<script>(function(){var t=document.querySelector('template[data-ce-await="${escapedId}"]');var host=document.querySelector('[data-ce-await="${escapedId}"]');if(t&&host){host.replaceWith(t.content.cloneNode(true));t.remove();}})();</script>`;
+  return `${template}${script}`;
+}
+var awaitCounter = 0;
+function nextAwaitId() {
+  awaitCounter += 1;
+  return `await-${awaitCounter}`;
+}
+
+// src/runtime/router-context.js
+var routerContextStack = [];
+function withRouterContext(router, run) {
+  routerContextStack.push({ router });
+  try {
+    return run();
+  } finally {
+    routerContextStack.pop();
+  }
+}
+function ensureRouterContext() {
+  const context = routerContextStack.at(-1) ?? null;
+  if (!context) {
+    throw new Error("Router hooks can only be used while a Router context is active.");
+  }
+  return context;
+}
+function useRouter() {
+  return ensureRouterContext().router;
+}
+function useNavigate() {
+  const router = useRouter();
+  return (path, options) => router.navigate(path, options);
+}
+function useLocation() {
+  return useRouter().currentPath;
+}
+function useRouteMatch() {
+  return useRouter().currentMatch;
+}
+function useRouteParams() {
+  const matchSignal = useRouteMatch();
+  return chunkVHUXNDW2_cjs.computed(() => matchSignal()?.params ?? {});
+}
+function useRouteData() {
+  const matchSignal = useRouteMatch();
+  return chunkVHUXNDW2_cjs.computed(() => {
+    const match = matchSignal();
+    const entry = chunkEFOOXCY7_cjs.readRouteData(match);
+    return entry?.data;
+  });
+}
+
+// src/runtime/component.js
+var ComponentRuntime = class {
+  constructor(options) {
+    this.options = options;
+  }
+  mount(mountOptions) {
+    const compiled = this.ensureTemplate();
+    styleRegistry.attach(compiled);
+    const propsSignal = chunkVHUXNDW2_cjs.signal({ ...mountOptions.props ?? {} });
+    const reactiveProps = createReactiveProps(propsSignal);
+    const emit = (event, payload) => {
+      mountOptions.on?.[event]?.(payload);
+    };
+    const injector = mountOptions.injector ? mountOptions.injector.createChild(this.options.providers ?? []) : createInjector(this.options.providers ?? []);
+    const setupResult = this.options.setup ? this.options.setup({ props: reactiveProps, emit, injector, slots: mountOptions.slots }) : {};
+    const { slots: setupSlots, ...setupState } = setupResult ?? {};
+    const scope = {
+      props: reactiveProps,
+      ...setupState,
+      slots: setupSlots ?? mountOptions.slots
+    };
+    const handle = mountOptions.router ? withRouterContext(mountOptions.router, () => renderTemplate(compiled, scope, mountOptions.target)) : renderTemplate(compiled, scope, mountOptions.target);
+    const updateProps = (partial) => {
+      propsSignal.set({ ...propsSignal(), ...partial });
+    };
+    const lifecycle = this.options.lifecycle;
+    const lifecycleContext = {
+      target: mountOptions.target,
+      props: reactiveProps,
+      emit,
+      injector,
+      updateProps
+    };
+    let cleanupTheme;
+    let cleanupA11y;
+    if (lifecycle?.onThemeUpdate && typeof document !== "undefined") {
+      cleanupTheme = chunkPVZVFICK_cjs.registerThemeAwareComponent((state) => {
+        lifecycle?.onThemeUpdate?.(state, lifecycleContext);
+      });
+    }
+    if (lifecycle?.onStylesApplied) {
+      lifecycle.onStylesApplied(compiled.styles ?? [], lifecycleContext);
+    }
+    if (lifecycle?.onA11ySetup) {
+      const cleanup = lifecycle.onA11ySetup(lifecycleContext);
+      if (typeof cleanup === "function") {
+        cleanupA11y = cleanup;
+      }
+    }
+    lifecycle?.onMount?.(lifecycleContext);
+    return {
+      destroy() {
+        cleanupTheme?.();
+        cleanupA11y?.();
+        lifecycle?.onDestroy?.(lifecycleContext);
+        handle.destroy();
+      },
+      updateProps
+    };
+  }
+  renderToString(props) {
+    const compiled = this.ensureTemplate();
+    const propsSignal = chunkVHUXNDW2_cjs.signal({ ...props ?? {} });
+    const reactiveProps = createReactiveProps(propsSignal);
+    const injector = createInjector(this.options.providers ?? []);
+    const setupResult = this.options.setup ? this.options.setup({ props: reactiveProps, emit: () => void 0, injector }) : {};
+    const scope = {
+      props: reactiveProps,
+      ...setupResult
+    };
+    return renderTemplateToString(compiled, scope);
+  }
+  ensureTemplate() {
+    if (this.compiled) {
+      return this.compiled;
+    }
+    const compiled = this.buildTemplate();
+    this.compiled = compiled;
+    return compiled;
+  }
+  buildTemplate() {
+    const base = typeof this.options.template === "string" ? chunkFFCZSYC7_cjs.compileTemplate(this.options.template, {
+      name: this.options.name,
+      ...this.options.templateOptions,
+      scopeId: this.options.scopeId
+    }) : { ...this.options.template };
+    if (this.options.styles?.length) {
+      const scopeId = base.scopeId ?? this.options.scopeId ?? chunkIRBUKIRF_cjs.createStyleScopeId(this.options.name ?? "component");
+      base.scopeId = scopeId;
+      base.styles = chunkIRBUKIRF_cjs.scopeStyles(this.options.styles, scopeId);
+    } else if (base.styles?.length && base.scopeId) {
+      base.styles = chunkIRBUKIRF_cjs.scopeStyles(base.styles, base.scopeId);
+    }
+    return base;
+  }
+};
+function defineComponent(options) {
+  return new ComponentRuntime(options);
+}
+var StyleRegistry = class {
+  constructor() {
+    this.mounted = /* @__PURE__ */ new Map();
+  }
+  attach(compiled) {
+    if (typeof document === "undefined") {
+      return;
+    }
+    if (!compiled.styles?.length) {
+      return;
+    }
+    const scopeId = compiled.scopeId ?? "component";
+    if (this.mounted.has(scopeId)) {
+      return;
+    }
+    const styleTag = document.createElement("style");
+    styleTag.dataset.ceComponent = compiled.name ?? "component";
+    styleTag.textContent = compiled.styles.join("\n");
+    document.head.appendChild(styleTag);
+    this.mounted.set(scopeId, styleTag);
+  }
+};
+var styleRegistry = new StyleRegistry();
+function renderComponent(component, options) {
+  return component.mount(options);
+}
+function createReactiveProps(propsSignal) {
+  return new Proxy({}, {
+    get: (_target, key) => {
+      const current = propsSignal();
+      return current[key];
+    }
+  });
+}
+
+exports.Injector = Injector;
+exports.createInjector = createInjector;
+exports.defineComponent = defineComponent;
+exports.renderComponent = renderComponent;
+exports.renderTemplateToStream = renderTemplateToStream;
+exports.renderTemplateToString = renderTemplateToString;
+exports.useLocation = useLocation;
+exports.useNavigate = useNavigate;
+exports.useRouteData = useRouteData;
+exports.useRouteMatch = useRouteMatch;
+exports.useRouteParams = useRouteParams;
+exports.useRouter = useRouter;
+exports.withRouterContext = withRouterContext;
+//# sourceMappingURL=chunk-W3LNNY3U.cjs.map
+//# sourceMappingURL=chunk-W3LNNY3U.cjs.map