olova 2.0.61 → 2.0.63

package/dist/core.js

@@ -0,0 +1,859 @@
+import { signal, effect as effect$1, computed as computed$1, untracked } from '@preact/signals-core';
+
+// core/signals-core.ts
+var rawToProxy = /* @__PURE__ */ new WeakMap();
+var proxyToRaw = /* @__PURE__ */ new WeakMap();
+var proxyOwner = /* @__PURE__ */ new WeakMap();
+var hmrCaptureStack = [];
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function unwrapValue(value) {
+  if (!isObject(value)) {
+    return value;
+  }
+  return proxyToRaw.get(value) ?? value;
+}
+var Signal = class {
+  source;
+  version;
+  proxy = null;
+  constructor(initial, source, version) {
+    this.source = source ?? signal(initial);
+    this.version = version ?? signal(0);
+  }
+  get value() {
+    this.version.value;
+    return this.getReactiveValue(this.source.value);
+  }
+  set value(next) {
+    const resolvedNext = unwrapValue(next);
+    if (Object.is(this.source.peek(), resolvedNext)) {
+      return;
+    }
+    this.proxy = null;
+    this.source.value = resolvedNext;
+  }
+  peek() {
+    return this.source.peek();
+  }
+  notify() {
+    this.version.value = this.version.peek() + 1;
+  }
+  subscribe(fn) {
+    return this.source.subscribe(fn);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return String(this.value);
+  }
+  toJSON() {
+    return this.peek();
+  }
+  getReactiveValue(value) {
+    if (!isObject(value)) {
+      return value;
+    }
+    if (this.proxy && proxyToRaw.get(this.proxy) === value) {
+      return this.proxy;
+    }
+    this.proxy = this.wrapObject(value);
+    return this.proxy;
+  }
+  wrapObject(value) {
+    const existing = rawToProxy.get(value);
+    if (existing) {
+      return existing;
+    }
+    const proxy = new Proxy(value, {
+      get: (target, key, receiver) => {
+        const result = Reflect.get(target, key, receiver);
+        return isObject(result) ? this.wrapNested(result) : result;
+      },
+      set: (target, key, next, receiver) => {
+        const resolvedNext = unwrapValue(next);
+        const previous = Reflect.get(target, key, receiver);
+        const changed = Reflect.set(target, key, resolvedNext, receiver);
+        if (changed && !Object.is(previous, resolvedNext)) {
+          this.notify();
+        }
+        return changed;
+      },
+      deleteProperty: (target, key) => {
+        const hadKey = Reflect.has(target, key);
+        const changed = Reflect.deleteProperty(target, key);
+        if (hadKey && changed) {
+          this.notify();
+        }
+        return changed;
+      }
+    });
+    rawToProxy.set(value, proxy);
+    proxyToRaw.set(proxy, value);
+    proxyOwner.set(proxy, this);
+    return proxy;
+  }
+  wrapNested(value) {
+    const owner = proxyOwner.get(value);
+    if (owner === this) {
+      return value;
+    }
+    return this.wrapObject(value);
+  }
+};
+function state(initial, hmrKey) {
+  const frame = hmrCaptureStack[hmrCaptureStack.length - 1];
+  let nextInitial = initial;
+  if (frame) {
+    if (hmrKey && frame.restoredByKey?.has(hmrKey)) {
+      nextInitial = frame.restoredByKey.get(hmrKey);
+    } else if (frame.cursor < frame.restoredUnkeyed.length) {
+      nextInitial = frame.restoredUnkeyed[frame.cursor];
+    }
+  }
+  const signal = new Signal(nextInitial);
+  if (frame) {
+    frame.created.push({ key: hmrKey, signal });
+    if (!hmrKey || !frame.restoredByKey?.has(hmrKey)) {
+      frame.cursor += 1;
+    }
+  }
+  return signal;
+}
+function effect(fn, options) {
+  const stop = effect$1(() => fn());
+  return () => stop();
+}
+function computed(getter) {
+  const version = signal(0);
+  const source = computed$1(() => getter());
+  effect$1(() => {
+    getter();
+    version.value = version.peek() + 1;
+  });
+  return new Signal(untracked(() => source.value), source, version);
+}
+var derived = computed;
+function beginHmrStateCapture(restoredValues) {
+  const restoredByKey = /* @__PURE__ */ new Map();
+  const restoredUnkeyed = [];
+  for (const entry of restoredValues ?? []) {
+    if (entry.key) {
+      restoredByKey.set(entry.key, entry.value);
+      continue;
+    }
+    restoredUnkeyed.push(entry.value);
+  }
+  hmrCaptureStack.push({
+    created: [],
+    restoredValues,
+    restoredByKey,
+    restoredUnkeyed,
+    cursor: 0
+  });
+}
+function endHmrStateCapture() {
+  const frame = hmrCaptureStack.pop();
+  return frame?.created ?? [];
+}
+
+// runtime/component.ts
+var EMPTY_SLOTS = Object.freeze({});
+var currentSetupContext = null;
+function requireSetupContext(apiName) {
+  if (!currentSetupContext) {
+    throw new Error(
+      `[olova] ${apiName}() can only be used during component setup.`
+    );
+  }
+  return currentSetupContext;
+}
+function toText(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (Array.isArray(value)) {
+    return value.map(toText).join("");
+  }
+  return String(value);
+}
+function normalizeClassValue(value) {
+  if (value === false || value === null || value === void 0) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    const parts = value.map((item) => normalizeClassValue(item)).filter((item) => !!item);
+    return parts.length > 0 ? parts.join(" ") : null;
+  }
+  if (typeof value === "object") {
+    const parts = Object.entries(value).filter(([, enabled]) => !!enabled).map(([name]) => name);
+    return parts.length > 0 ? parts.join(" ") : null;
+  }
+  return String(value);
+}
+function toAttr(value) {
+  if (value === false || value === null || value === void 0) {
+    return null;
+  }
+  if (value === true) {
+    return "true";
+  }
+  return String(value);
+}
+function isDangerousHtml(value) {
+  return !!(value && typeof value === "object" && "__dangerousHtml" in value && value.__dangerousHtml === true);
+}
+function sanitizeHtml(html) {
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  const blockedElements = /* @__PURE__ */ new Set(["script", "iframe", "object", "embed"]);
+  const walker = document.createTreeWalker(template.content, NodeFilter.SHOW_ELEMENT);
+  let current = walker.nextNode();
+  while (current) {
+    const element = current;
+    current = walker.nextNode();
+    if (blockedElements.has(element.tagName.toLowerCase())) {
+      element.remove();
+      continue;
+    }
+    for (const attr of Array.from(element.attributes)) {
+      const attrName = attr.name.toLowerCase();
+      const attrValue = attr.value.trim().toLowerCase();
+      if (attrName.startsWith("on")) {
+        element.removeAttribute(attr.name);
+        continue;
+      }
+      if ((attrName === "href" || attrName === "src" || attrName === "xlink:href") && attrValue.startsWith("javascript:")) {
+        element.removeAttribute(attr.name);
+      }
+    }
+  }
+  return template.innerHTML;
+}
+function toHtml(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (Array.isArray(value)) {
+    return value.map(toHtml).join("");
+  }
+  if (isDangerousHtml(value)) {
+    return value.value;
+  }
+  return sanitizeHtml(String(value));
+}
+function shallowEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (!a || !b) {
+    return false;
+  }
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  for (const key of aKeys) {
+    if (!Object.is(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function shallowEqualSlots(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (!a || !b) {
+    return false;
+  }
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  for (const key of aKeys) {
+    if (!Object.is(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function insertFragmentIntoRange(range, fragment) {
+  const nodes = Array.from(fragment.childNodes);
+  range.deleteContents();
+  if (nodes.length === 0) {
+    return;
+  }
+  range.insertNode(fragment);
+  const first = nodes[0];
+  const last = nodes[nodes.length - 1];
+  range.setStartBefore(first);
+  range.setEndAfter(last);
+}
+function bindJsxEventsInRange(range) {
+  const root = range.commonAncestorContainer.nodeType === Node.ELEMENT_NODE ? range.commonAncestorContainer : range.commonAncestorContainer.parentNode;
+  if (!root) {
+    return () => {
+    };
+  }
+  const globalObj = globalThis;
+  const handlers = globalObj.__olovaJsxHandlers;
+  if (!handlers) {
+    return () => {
+    };
+  }
+  const listeners = [];
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+  let current = walker.currentNode;
+  while (current) {
+    let intersects = false;
+    try {
+      intersects = range.intersectsNode(current);
+    } catch {
+      intersects = false;
+    }
+    if (intersects) {
+      const element = current;
+      for (const attr of Array.from(current.attributes)) {
+        if (!attr.name.startsWith("data-o-jsx-")) {
+          continue;
+        }
+        const eventName = attr.name.slice("data-o-jsx-".length);
+        const handlerId = attr.value;
+        const listener = (event) => {
+          const handler = handlers.get(handlerId);
+          if (typeof handler === "function") {
+            handler(event);
+          }
+        };
+        element.addEventListener(eventName, listener);
+        element.removeAttribute(`on${eventName}`);
+        listeners.push(() => element.removeEventListener(eventName, listener));
+      }
+    }
+    current = walker.nextNode();
+  }
+  return () => {
+    for (const cleanup of listeners) {
+      cleanup();
+    }
+  };
+}
+function replaceTokenWithTextNode(root, token) {
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  let current = walker.nextNode();
+  while (current) {
+    const textNode = current;
+    const index = textNode.data.indexOf(token);
+    if (index >= 0) {
+      const remainder = textNode.splitText(index);
+      const after = remainder.splitText(token.length);
+      const parent = remainder.parentNode;
+      if (!parent) {
+        return null;
+      }
+      const dynamic = document.createTextNode("");
+      parent.insertBefore(dynamic, after);
+      parent.removeChild(remainder);
+      return dynamic;
+    }
+    current = walker.nextNode();
+  }
+  return null;
+}
+function createRangeAtToken(root, token) {
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  let current = walker.nextNode();
+  while (current) {
+    const textNode = current;
+    const index = textNode.data.indexOf(token);
+    if (index >= 0) {
+      const marker = textNode.splitText(index);
+      const after = marker.splitText(token.length);
+      const range = document.createRange();
+      range.setStartBefore(marker);
+      range.setEndBefore(marker);
+      marker.parentNode?.removeChild(marker);
+      if (after.data.length === 0) {
+        after.parentNode?.removeChild(after);
+      }
+      return range;
+    }
+    current = walker.nextNode();
+  }
+  return null;
+}
+function createRangeAtTokenWithinRange(hostRange, token) {
+  const root = hostRange.commonAncestorContainer;
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  let current = walker.nextNode();
+  while (current) {
+    const textNode = current;
+    const index = textNode.data.indexOf(token);
+    if (index < 0) {
+      current = walker.nextNode();
+      continue;
+    }
+    let intersects = false;
+    try {
+      intersects = hostRange.intersectsNode(textNode);
+    } catch {
+      intersects = false;
+    }
+    if (!intersects) {
+      current = walker.nextNode();
+      continue;
+    }
+    const marker = textNode.splitText(index);
+    const after = marker.splitText(token.length);
+    const range = document.createRange();
+    range.setStartBefore(marker);
+    range.setEndBefore(marker);
+    marker.parentNode?.removeChild(marker);
+    if (after.data.length === 0) {
+      after.parentNode?.removeChild(after);
+    }
+    return range;
+  }
+  return null;
+}
+function resolveTokenRange(target, token) {
+  return target instanceof HTMLElement ? createRangeAtToken(target, token) : createRangeAtTokenWithinRange(target, token);
+}
+function mountDescriptor(descriptor, target, slots, context) {
+  let fragment;
+  let nodes = null;
+  if (descriptor.build) {
+    const buildResult = descriptor.build();
+    fragment = buildResult.fragment;
+    nodes = buildResult.nodes;
+  } else {
+    const template = document.createElement("template");
+    template.innerHTML = descriptor.template ? descriptor.template.trim() : "";
+    fragment = template.content;
+  }
+  const cleanups = [];
+  for (const binding of descriptor.textBindings) {
+    const token = `__O_TEXT_${binding.id}__`;
+    const textNode = nodes && nodes[binding.id] ? nodes[binding.id] : replaceTokenWithTextNode(fragment, token);
+    if (!textNode) {
+      continue;
+    }
+    const stop = effect(() => {
+      textNode.data = toText(binding.get());
+    });
+    cleanups.push(stop);
+  }
+  for (const binding of descriptor.attrBindings) {
+    const token = `__O_ATTR_${binding.id}__`;
+    const elements = nodes && nodes[binding.id] ? [nodes[binding.id]] : Array.from(fragment.querySelectorAll("*")).filter(
+      (element) => element.getAttribute(binding.attr) === token
+    );
+    for (const element of elements) {
+      const stop = effect(() => {
+        const next = binding.attr === "class" ? normalizeClassValue(binding.get()) : toAttr(binding.get());
+        if (next === null) {
+          element.removeAttribute(binding.attr);
+          return;
+        }
+        element.setAttribute(binding.attr, next);
+      });
+      cleanups.push(stop);
+    }
+  }
+  for (const binding of descriptor.eventBindings) {
+    const selector = `[data-o-on-${binding.event}="${binding.id}"]`;
+    const element = nodes && nodes[binding.id] ? nodes[binding.id] : fragment.querySelector(selector);
+    if (!element) {
+      continue;
+    }
+    if (!nodes) element.removeAttribute(`data-o-on-${binding.event}`);
+    let currentHandler;
+    const stop = effect(() => {
+      currentHandler = binding.get();
+    });
+    const listener = (event) => {
+      if (typeof currentHandler === "function") {
+        currentHandler(event);
+      }
+    };
+    element.addEventListener(binding.event, listener);
+    cleanups.push(() => {
+      stop();
+      element.removeEventListener(binding.event, listener);
+    });
+  }
+  if (target instanceof HTMLElement) {
+    target.replaceChildren(fragment);
+  } else {
+    insertFragmentIntoRange(target, fragment);
+  }
+  for (const binding of descriptor.htmlBindings) {
+    const token = `__O_HTML_${binding.id}__`;
+    let range = null;
+    if (nodes && nodes[binding.id]) {
+      range = document.createRange();
+      range.setStartBefore(nodes[binding.id]);
+      range.setEndBefore(nodes[binding.id]);
+      nodes[binding.id].parentNode?.removeChild(nodes[binding.id]);
+    } else {
+      range = resolveTokenRange(target, token);
+    }
+    if (!range) {
+      continue;
+    }
+    let lastHtml = "__OLOVA_INIT__";
+    let cleanupJsxEvents = () => {
+    };
+    const stop = effect(() => {
+      const nextHtml = toHtml(binding.get());
+      if (nextHtml === lastHtml) {
+        return;
+      }
+      lastHtml = nextHtml;
+      cleanupJsxEvents();
+      const htmlTemplate = document.createElement("template");
+      htmlTemplate.innerHTML = nextHtml;
+      insertFragmentIntoRange(range, htmlTemplate.content);
+      cleanupJsxEvents = bindJsxEventsInRange(range);
+    });
+    cleanups.push(() => {
+      cleanupJsxEvents();
+      stop();
+    });
+  }
+  for (const binding of descriptor.slotBindings) {
+    const token = `__O_SLOT_${binding.id}__`;
+    let range = null;
+    if (nodes && nodes[binding.id]) {
+      range = document.createRange();
+      range.setStartBefore(nodes[binding.id]);
+      range.setEndBefore(nodes[binding.id]);
+      nodes[binding.id].parentNode?.removeChild(nodes[binding.id]);
+    } else {
+      range = resolveTokenRange(target, token);
+    }
+    if (!range) {
+      continue;
+    }
+    const slotFactory = slots[binding.name];
+    if (!slotFactory) {
+      range.deleteContents();
+      continue;
+    }
+    const slotDescriptor = slotFactory();
+    const disposeSlot = mountDescriptor(slotDescriptor, range, slots, context);
+    cleanups.push(disposeSlot);
+  }
+  for (const binding of descriptor.componentBindings) {
+    const token = `__O_COMP_${binding.id}__`;
+    let range = null;
+    if (nodes && nodes[binding.id]) {
+      range = document.createRange();
+      range.setStartBefore(nodes[binding.id]);
+      range.setEndBefore(nodes[binding.id]);
+      nodes[binding.id].parentNode?.removeChild(nodes[binding.id]);
+    } else {
+      range = resolveTokenRange(target, token);
+    }
+    if (!range) {
+      continue;
+    }
+    let disposeChild = () => {
+    };
+    let lastComponent = null;
+    let lastProps;
+    let lastSlots;
+    const stop = effect(() => {
+      const nextComponent = binding.getComponent();
+      const nextProps = binding.getProps();
+      const nextSlots = binding.getSlots ? binding.getSlots() : EMPTY_SLOTS;
+      if (lastComponent === nextComponent && shallowEqual(lastProps, nextProps) && shallowEqualSlots(lastSlots, nextSlots)) {
+        return;
+      }
+      disposeChild();
+      disposeChild = mount(nextComponent, range, nextProps, nextSlots, context);
+      lastComponent = nextComponent;
+      lastProps = { ...nextProps };
+      lastSlots = nextSlots;
+    });
+    cleanups.push(() => {
+      stop();
+      disposeChild();
+    });
+  }
+  if (descriptor.ifBindings) {
+    for (const binding of descriptor.ifBindings) {
+      const token = `__O_IF_${binding.id}__`;
+      let range = null;
+      if (nodes && nodes[binding.id]) {
+        range = document.createRange();
+        range.setStartBefore(nodes[binding.id]);
+        range.setEndBefore(nodes[binding.id]);
+        nodes[binding.id].parentNode?.removeChild(nodes[binding.id]);
+      } else {
+        range = resolveTokenRange(target, token);
+      }
+      if (!range) {
+        continue;
+      }
+      let disposeBranch = () => {
+      };
+      let lastCondition = void 0;
+      const stop = effect(() => {
+        const condition = !!binding.get();
+        if (condition === lastCondition) {
+          return;
+        }
+        disposeBranch();
+        if (condition) {
+          const branchDescriptor = binding.trueBranch();
+          disposeBranch = mountDescriptor(branchDescriptor, range, slots, context);
+        } else if (binding.falseBranch) {
+          const branchDescriptor = binding.falseBranch();
+          disposeBranch = mountDescriptor(branchDescriptor, range, slots, context);
+        } else {
+          range.deleteContents();
+          disposeBranch = () => {
+          };
+        }
+        lastCondition = condition;
+      });
+      cleanups.push(() => {
+        stop();
+        disposeBranch();
+      });
+    }
+  }
+  return () => {
+    for (const cleanup of cleanups) {
+      cleanup();
+    }
+    if (target instanceof HTMLElement) {
+      target.replaceChildren();
+      return;
+    }
+    target.deleteContents();
+  };
+}
+function registerMountedInstance(instance) {
+  const instances = instance.component.__hmrInstances ?? (instance.component.__hmrInstances = /* @__PURE__ */ new Set());
+  instances.add(instance);
+}
+function unregisterMountedInstance(instance) {
+  instance.component.__hmrInstances?.delete(instance);
+}
+function renderMountedInstance(instance, restoredValues) {
+  const context = new Map(instance.parentContext ?? []);
+  const previousContext = currentSetupContext;
+  currentSetupContext = context;
+  beginHmrStateCapture(restoredValues);
+  try {
+    const descriptor = instance.component.setup(instance.props, instance.slots);
+    instance.disposeDescriptor = mountDescriptor(
+      descriptor,
+      instance.target,
+      instance.slots,
+      context
+    );
+    instance.hmrSignals = endHmrStateCapture();
+  } catch (error) {
+    endHmrStateCapture();
+    throw error;
+  } finally {
+    currentSetupContext = previousContext;
+  }
+}
+function collectHmrSignalValues(instance) {
+  return instance.hmrSignals.map(({ key, signal }) => ({
+    key,
+    value: signal.peek()
+  }));
+}
+function replaceComponent(current, next) {
+  const instances = current.__hmrInstances;
+  if (!instances || instances.size === 0) {
+    current.setup = next.setup;
+    next.__hmrInstances = instances;
+    current.__hmrInstances = void 0;
+    return;
+  }
+  const snapshots = Array.from(instances, (instance) => ({
+    instance,
+    restoredValues: collectHmrSignalValues(instance)
+  }));
+  next.__hmrInstances = instances;
+  current.__hmrInstances = void 0;
+  try {
+    for (const { instance, restoredValues } of snapshots) {
+      instance.component = next;
+      instance.disposeDescriptor();
+      renderMountedInstance(instance, restoredValues);
+    }
+  } catch (error) {
+    next.__hmrInstances = void 0;
+    current.__hmrInstances = instances;
+    for (const { instance, restoredValues } of snapshots) {
+      instance.component = current;
+      instance.disposeDescriptor();
+      renderMountedInstance(instance, restoredValues);
+    }
+    console.error("[olova] HMR update failed. Restored previous component.", error);
+    return;
+  }
+}
+function defineComponent(setup, hmrId) {
+  return { setup, __hmrId: hmrId };
+}
+function dangerouslySetHtml(value) {
+  return {
+    __dangerousHtml: true,
+    value: toText(value)
+  };
+}
+function setContext(key, value) {
+  const context = requireSetupContext("setContext");
+  context.set(key, value);
+  return value;
+}
+function getContext(key) {
+  const context = requireSetupContext("getContext");
+  return context.get(key);
+}
+function hasContext(key) {
+  const context = requireSetupContext("hasContext");
+  return context.has(key);
+}
+function mount(component, target, props = {}, slots = EMPTY_SLOTS, parentContext) {
+  const instance = {
+    component,
+    target,
+    props,
+    slots,
+    parentContext,
+    disposeDescriptor: () => {
+    },
+    hmrSignals: []
+  };
+  registerMountedInstance(instance);
+  renderMountedInstance(instance);
+  return () => {
+    unregisterMountedInstance(instance);
+    instance.disposeDescriptor();
+  };
+}
+function createApp(root) {
+  return {
+    mount(target) {
+      const element = typeof target === "string" ? document.querySelector(target) : target;
+      if (!element) {
+        throw new Error(`Target not found: ${String(target)}`);
+      }
+      return mount(root, element);
+    }
+  };
+}
+
+// runtime/global.ts
+var globalStates = /* @__PURE__ */ new Map();
+var persistCleanups = /* @__PURE__ */ new Map();
+var persistTargets = /* @__PURE__ */ new Map();
+function storageKey(name) {
+  return `olova:global:${name}`;
+}
+function getStorage(target) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  if (target === "localStorage") {
+    return window.localStorage;
+  }
+  return null;
+}
+function readPersisted(name, target) {
+  const storage = getStorage(target);
+  if (!storage) {
+    return void 0;
+  }
+  try {
+    const raw = storage.getItem(storageKey(name));
+    if (raw == null) {
+      return void 0;
+    }
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function setupPersistence(name, stateRef, target) {
+  const currentTarget = persistTargets.get(name);
+  if (currentTarget === target && persistCleanups.has(name)) {
+    return;
+  }
+  const previousCleanup = persistCleanups.get(name);
+  if (previousCleanup) {
+    previousCleanup();
+  }
+  persistTargets.set(name, target);
+  const stop = effect(() => {
+    const storage = getStorage(target);
+    if (!storage) {
+      return;
+    }
+    try {
+      storage.setItem(storageKey(name), JSON.stringify(stateRef.value));
+    } catch {
+    }
+  });
+  persistCleanups.set(name, stop);
+}
+function ensureState(name, initial, options) {
+  const existing = globalStates.get(name);
+  if (existing) {
+    if (existing.value === void 0 && initial !== void 0) {
+      existing.value = initial;
+    }
+    if (options?.persist) {
+      if (existing.value === void 0) {
+        const persisted = readPersisted(name, options.persist);
+        if (persisted !== void 0) {
+          existing.value = persisted;
+        }
+      }
+      setupPersistence(name, existing, options.persist);
+    }
+    return existing;
+  }
+  let resolvedInitial = initial;
+  if (options?.persist) {
+    const persisted = readPersisted(name, options.persist);
+    if (persisted !== void 0) {
+      resolvedInitial = persisted;
+    }
+  }
+  const created = state(resolvedInitial);
+  globalStates.set(name, created);
+  if (options?.persist) {
+    setupPersistence(name, created, options.persist);
+  }
+  return created;
+}
+var global = {
+  state(name, initial, options) {
+    return ensureState(name, initial, options);
+  },
+  get(name) {
+    return ensureState(name);
+  },
+  has(name) {
+    return globalStates.has(name);
+  }
+};
+
+export { Signal, beginHmrStateCapture, computed, createApp, dangerouslySetHtml, defineComponent, derived, effect, endHmrStateCapture, getContext, global, hasContext, mount, replaceComponent, setContext, state };
+//# sourceMappingURL=core.js.map
+//# sourceMappingURL=core.js.map