sinwan 0.1.0 → 1.0.0

package/dist/esm/renderer/index.development.js

@@ -0,0 +1,1124 @@
+// @bun
+// src/jsx/jsx-runtime.ts
+var Fragment = Symbol("Fragment");
+
+class HtmlEscapedString extends String {
+  value;
+  constructor(value) {
+    super(value);
+    this.value = value;
+  }
+  toString() {
+    return this.value;
+  }
+}
+var raw = (str) => new HtmlEscapedString(str);
+var VOID_ELEMENTS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function normalizeChildren(children) {
+  if (children == null || typeof children === "boolean")
+    return [];
+  if (Array.isArray(children))
+    return children.flat(Infinity);
+  return [children];
+}
+function buildElement(type, props, children) {
+  if (type === Fragment) {
+    return { tag: "", props: {}, children };
+  }
+  if (typeof type === "function" || typeof type === "string") {
+    const finalProps = props ?? {};
+    if (children.length > 0 && finalProps.children === undefined) {
+      finalProps.children = children.length === 1 ? children[0] : children;
+    }
+    return { tag: type, props: finalProps, children };
+  }
+  return { tag: "", props: {}, children };
+}
+function jsx(type, props, key) {
+  return buildElement(type, props, normalizeChildren(props?.children));
+}
+function jsxs(type, props, key) {
+  const children = props?.children;
+  return buildElement(type, props, Array.isArray(children) ? children.flat(Infinity) : normalizeChildren(children));
+}
+function jsxDEV(type, props, key, isStaticChildren, source, self) {
+  const children = isStaticChildren ? Array.isArray(props?.children) ? props.children.flat(Infinity) : normalizeChildren(props?.children) : normalizeChildren(props?.children);
+  const element = buildElement(type, props, children);
+  if (source) {
+    element.__source = source;
+  }
+  return element;
+}
+
+// src/renderer/dom-ops.ts
+function createDefaultDOMOps() {
+  return {
+    createElement(tag) {
+      return document.createElement(tag);
+    },
+    createElementNS(namespace, tag) {
+      return document.createElementNS(namespace, tag);
+    },
+    createTextNode(text) {
+      return document.createTextNode(text);
+    },
+    createComment(text) {
+      return document.createComment(text);
+    },
+    setAttribute(el, key, value) {
+      el.setAttribute(key, value);
+    },
+    removeAttribute(el, key) {
+      el.removeAttribute(key);
+    },
+    setProperty(el, key, value) {
+      el[key] = value;
+    },
+    insertBefore(parent, child, anchor) {
+      parent.insertBefore(child, anchor);
+    },
+    appendChild(parent, child) {
+      parent.appendChild(child);
+    },
+    remove(node) {
+      node.parentNode?.removeChild(node);
+    },
+    setTextContent(node, text) {
+      node.data = text;
+    },
+    addEventListener(el, event, handler) {
+      el.addEventListener(event, handler);
+    },
+    removeEventListener(el, event, handler) {
+      el.removeEventListener(event, handler);
+    },
+    parentNode(node) {
+      return node.parentNode;
+    },
+    nextSibling(node) {
+      return node.nextSibling;
+    }
+  };
+}
+var defaultDOMOps = createDefaultDOMOps();
+var domOps = { ...defaultDOMOps };
+function setDOMOps(overrides) {
+  Object.assign(domOps, overrides);
+}
+function resetDOMOps() {
+  for (const key of Object.keys(domOps)) {
+    delete domOps[key];
+  }
+  Object.assign(domOps, defaultDOMOps);
+}
+
+// src/reactivity/scheduler.ts
+var pendingEffects = new Set;
+var flushScheduled = false;
+var isFlushing = false;
+var pendingCallbacks = [];
+function scheduleEffect(effect) {
+  if (!effect.active)
+    return;
+  pendingEffects.add(effect);
+  scheduleFlush();
+}
+function unscheduleEffect(effect) {
+  pendingEffects.delete(effect);
+}
+function scheduleFlush() {
+  if (!flushScheduled) {
+    flushScheduled = true;
+    queueMicrotask(flush);
+  }
+}
+function flush() {
+  isFlushing = true;
+  const sorted = [...pendingEffects].sort((a, b) => a.id - b.id);
+  pendingEffects.clear();
+  for (const effect of sorted) {
+    if (effect.active) {
+      effect.run();
+    }
+  }
+  let safety = 10;
+  while (pendingEffects.size > 0 && safety-- > 0) {
+    const next = [...pendingEffects].sort((a, b) => a.id - b.id);
+    pendingEffects.clear();
+    for (const effect of next) {
+      if (effect.active) {
+        effect.run();
+      }
+    }
+  }
+  flushScheduled = false;
+  isFlushing = false;
+  const cbs = pendingCallbacks.splice(0);
+  for (const cb of cbs) {
+    cb();
+  }
+}
+function nextTick(fn) {
+  return new Promise((resolve) => {
+    const callback = () => {
+      fn?.();
+      resolve();
+    };
+    if (flushScheduled || isFlushing) {
+      pendingCallbacks.push(callback);
+    } else {
+      queueMicrotask(callback);
+    }
+  });
+}
+function flushSync() {
+  if (flushScheduled) {
+    flushScheduled = false;
+    flush();
+  }
+}
+
+// src/reactivity/effect.ts
+var activeEffect = null;
+var effectStack = [];
+var effectIdCounter = 0;
+
+class ReactiveEffect {
+  id;
+  active = true;
+  fn;
+  cleanup = undefined;
+  deps = new Set;
+  constructor(fn) {
+    this.id = effectIdCounter++;
+    this.fn = fn;
+  }
+  run() {
+    if (!this.active)
+      return;
+    if (effectStack.includes(this))
+      return;
+    this.cleanupDeps();
+    if (this.cleanup) {
+      this.cleanup();
+      this.cleanup = undefined;
+    }
+    effectStack.push(this);
+    const prevEffect = activeEffect;
+    activeEffect = this;
+    try {
+      const result = this.fn();
+      if (typeof result === "function") {
+        this.cleanup = result;
+      }
+    } finally {
+      activeEffect = prevEffect;
+      effectStack.pop();
+    }
+  }
+  cleanupDeps() {
+    for (const dep of this.deps) {
+      dep.subscribers.delete(this);
+    }
+    this.deps.clear();
+  }
+  notify() {
+    scheduleEffect(this);
+  }
+  dispose() {
+    if (!this.active)
+      return;
+    this.active = false;
+    if (this.cleanup) {
+      this.cleanup();
+      this.cleanup = undefined;
+    }
+    this.cleanupDeps();
+    unscheduleEffect(this);
+  }
+}
+function effect(fn) {
+  const e = new ReactiveEffect(fn);
+  e.run();
+  return () => e.dispose();
+}
+function track(dep) {
+  if (activeEffect) {
+    dep.subscribers.add(activeEffect);
+    activeEffect.deps.add(dep);
+  }
+}
+function trigger(dep) {
+  const effects = [...dep.subscribers];
+  for (const effect2 of effects) {
+    effect2.notify();
+  }
+}
+
+// src/reactivity/signal.ts
+var SIGNAL_BRAND = Symbol("Sinwan:signal");
+
+class SignalImpl {
+  [SIGNAL_BRAND] = true;
+  subscribers = new Set;
+  _value;
+  _manualSubs = new Set;
+  constructor(initial) {
+    this._value = initial;
+  }
+  get value() {
+    track(this);
+    return this._value;
+  }
+  set value(newValue) {
+    if (Object.is(this._value, newValue))
+      return;
+    this._value = newValue;
+    trigger(this);
+    for (const fn of this._manualSubs) {
+      fn(newValue);
+    }
+  }
+  peek() {
+    return this._value;
+  }
+  subscribe(fn) {
+    this._manualSubs.add(fn);
+    return () => {
+      this._manualSubs.delete(fn);
+    };
+  }
+  toString() {
+    return String(this.value);
+  }
+  valueOf() {
+    return this.value;
+  }
+}
+function signal(initial) {
+  return new SignalImpl(initial);
+}
+function isSignal(value) {
+  return value != null && typeof value === "object" && SIGNAL_BRAND in value;
+}
+
+// src/reactivity/computed.ts
+var COMPUTED_BRAND = Symbol("Sinwan:computed");
+
+class ComputedImpl {
+  [COMPUTED_BRAND] = true;
+  subscribers = new Set;
+  _value;
+  _dirty = true;
+  _effect;
+  constructor(getter) {
+    const self = this;
+    this._effect = new ReactiveEffect(() => {
+      self._value = getter();
+    });
+    this._effect.notify = function() {
+      if (!self._dirty) {
+        self._dirty = true;
+        trigger(self);
+      }
+    };
+    this._effect.run();
+    this._dirty = false;
+  }
+  get value() {
+    track(this);
+    if (this._dirty) {
+      this._effect.run();
+      this._dirty = false;
+    }
+    return this._value;
+  }
+  peek() {
+    if (this._dirty) {
+      this._effect.run();
+      this._dirty = false;
+    }
+    return this._value;
+  }
+  toString() {
+    return String(this.value);
+  }
+  valueOf() {
+    return this.value;
+  }
+}
+function computed(getter) {
+  return new ComputedImpl(getter);
+}
+function isComputed(value) {
+  return value != null && typeof value === "object" && COMPUTED_BRAND in value;
+}
+
+// src/renderer/events.ts
+function isEventProp(key) {
+  return key.length > 2 && key[0] === "o" && key[1] === "n" && key[2] >= "A" && key[2] <= "Z";
+}
+function toEventName(key) {
+  return key.slice(2).toLowerCase();
+}
+function bindEvent(el, eventName, handler) {
+  domOps.addEventListener(el, eventName, handler);
+  return () => {
+    domOps.removeEventListener(el, eventName, handler);
+  };
+}
+function bindEvents(el, props) {
+  const cleanups = [];
+  for (const key of Object.keys(props)) {
+    if (isEventProp(key)) {
+      const handler = props[key];
+      if (typeof handler === "function") {
+        const eventName = toEventName(key);
+        cleanups.push(bindEvent(el, eventName, handler));
+      }
+    }
+  }
+  return cleanups;
+}
+
+// src/component/instance.ts
+var uidCounter = 0;
+function createComponentInstance(component, props, parent) {
+  return {
+    uid: uidCounter++,
+    component,
+    props,
+    element: null,
+    parent,
+    children: [],
+    effects: [],
+    _mountedHooks: [],
+    _unmountedHooks: [],
+    _updatedHooks: [],
+    _errorHooks: [],
+    provides: parent ? Object.create(parent.provides) : Object.create(null),
+    isMounted: false,
+    isUnmounted: false
+  };
+}
+var currentInstance = null;
+function getCurrentInstance() {
+  return currentInstance;
+}
+function setCurrentInstance(instance) {
+  const prev = currentInstance;
+  currentInstance = instance;
+  return prev;
+}
+function withInstance(instance, fn) {
+  const prev = setCurrentInstance(instance);
+  try {
+    return fn();
+  } finally {
+    setCurrentInstance(prev);
+  }
+}
+function fireMountedHooks(instance) {
+  if (instance.isUnmounted) {
+    return;
+  }
+  for (const child of instance.children) {
+    fireMountedHooks(child);
+  }
+  if (!instance.isMounted) {
+    instance.isMounted = true;
+    for (const hook of instance._mountedHooks) {
+      hook();
+    }
+  }
+}
+function fireUnmountedHooks(instance) {
+  for (const child of instance.children) {
+    fireUnmountedHooks(child);
+  }
+  if (instance.isMounted && !instance.isUnmounted) {
+    instance.isUnmounted = true;
+    instance.isMounted = false;
+    for (const hook of instance._unmountedHooks) {
+      hook();
+    }
+    for (const dispose of instance.effects) {
+      dispose();
+    }
+    instance.effects.length = 0;
+  }
+}
+function fireUpdatedHooks(instance) {
+  for (const hook of instance._updatedHooks) {
+    hook();
+  }
+}
+var queuedUpdatedHooks = new Set;
+function queueUpdatedHooks(instance) {
+  if (!instance || !instance.isMounted || instance.isUnmounted || instance._updatedHooks.length === 0 || queuedUpdatedHooks.has(instance)) {
+    return;
+  }
+  queuedUpdatedHooks.add(instance);
+  nextTick(() => {
+    queuedUpdatedHooks.delete(instance);
+    if (instance.isMounted && !instance.isUnmounted) {
+      fireUpdatedHooks(instance);
+    }
+  });
+}
+function handleComponentError(instance, err) {
+  let current = instance;
+  while (current) {
+    if (current._errorHooks.length > 0) {
+      for (const hook of current._errorHooks) {
+        hook(err);
+      }
+      return;
+    }
+    current = current.parent;
+  }
+  console.error("[Sinwan] Unhandled component error:", err);
+}
+
+// src/renderer/attributes.ts
+var SKIP_PROPS = new Set(["children", "key", "ref", "dangerouslySetInnerHTML"]);
+var DOM_PROPERTIES = new Set(["value", "checked", "selected", "disabled", "readOnly", "multiple", "indeterminate"]);
+var PROP_ALIASES = {
+  className: "class",
+  htmlFor: "for",
+  tabIndex: "tabindex",
+  crossOrigin: "crossorigin"
+};
+function applyAttributes(el, props) {
+  const disposers = [];
+  const owner = getCurrentInstance();
+  for (const [key, value] of Object.entries(props)) {
+    if (SKIP_PROPS.has(key) || isEventProp(key))
+      continue;
+    if (isSignal(value) || isComputed(value)) {
+      let initialized = false;
+      const dispose = effect(() => {
+        setSingleAttribute(el, key, value.value);
+        if (initialized) {
+          queueUpdatedHooks(owner);
+        }
+        initialized = true;
+      });
+      disposers.push(dispose);
+    } else {
+      setSingleAttribute(el, key, value);
+    }
+  }
+  return disposers;
+}
+function setSingleAttribute(el, key, value) {
+  const attrName = PROP_ALIASES[key] ?? key;
+  if (attrName === "style" && typeof value === "object" && value !== null) {
+    applyStyle(el, value);
+    return;
+  }
+  if (attrName === "class" && typeof value === "object" && value !== null) {
+    applyClass(el, value);
+    return;
+  }
+  if (value == null || value === false) {
+    domOps.removeAttribute(el, attrName);
+    if (DOM_PROPERTIES.has(attrName)) {
+      domOps.setProperty(el, attrName, attrName === "value" ? "" : false);
+    }
+    return;
+  }
+  if (value === true) {
+    domOps.setAttribute(el, attrName, "");
+    if (DOM_PROPERTIES.has(attrName)) {
+      domOps.setProperty(el, attrName, true);
+    }
+    return;
+  }
+  if (DOM_PROPERTIES.has(attrName)) {
+    domOps.setProperty(el, attrName, value);
+    return;
+  }
+  domOps.setAttribute(el, attrName, String(value));
+}
+function applyStyle(el, styles) {
+  for (const [prop, val] of Object.entries(styles)) {
+    if (prop.includes("-")) {
+      el.style.setProperty(prop, val);
+    } else {
+      el.style[prop] = val;
+    }
+  }
+}
+function applyClass(el, value) {
+  let classStr;
+  if (Array.isArray(value)) {
+    classStr = value.filter(Boolean).join(" ");
+  } else if (typeof value === "object" && value !== null) {
+    classStr = Object.entries(value).filter(([, v]) => Boolean(v)).map(([k]) => k).join(" ");
+  } else {
+    classStr = String(value);
+  }
+  domOps.setAttribute(el, "class", classStr);
+}
+
+// src/component/control-flow.ts
+var SHOW_TYPE = Symbol.for("Sinwan.Show");
+var FOR_TYPE = Symbol.for("Sinwan.For");
+function Show(props) {
+  return {
+    tag: SHOW_TYPE,
+    props,
+    children: []
+  };
+}
+function For(props) {
+  return {
+    tag: FOR_TYPE,
+    props,
+    children: []
+  };
+}
+function isShowElement(element) {
+  return element.tag === SHOW_TYPE;
+}
+function isForElement(element) {
+  return element.tag === FOR_TYPE;
+}
+
+// src/renderer/unmount.ts
+function getMountedDomNodes(node) {
+  switch (node.type) {
+    case "text":
+    case "reactive-text":
+      return [node.node];
+    case "element":
+      return [node.node];
+    case "fragment":
+      return [
+        node.anchor,
+        ...node.children.flatMap((child) => getMountedDomNodes(child))
+      ];
+    case "reactive-block":
+      return [
+        node.startAnchor,
+        ...node.children.flatMap((child) => getMountedDomNodes(child)),
+        node.endAnchor
+      ];
+    case "component":
+      return node.children.flatMap((child) => getMountedDomNodes(child));
+  }
+}
+function unmountNode(node) {
+  switch (node.type) {
+    case "text":
+      break;
+    case "reactive-text":
+      node.dispose();
+      break;
+    case "element":
+      for (const dispose of node.attrDisposers) {
+        dispose();
+      }
+      for (const cleanup of node.eventCleanups) {
+        cleanup();
+      }
+      node.refCleanup?.();
+      for (const child of node.children) {
+        unmountNode(child);
+      }
+      break;
+    case "fragment":
+      for (const child of node.children) {
+        unmountNode(child);
+      }
+      break;
+    case "reactive-block":
+      node.dispose();
+      for (const child of node.children) {
+        unmountNode(child);
+      }
+      break;
+    case "component":
+      if (node.instance) {
+        fireUnmountedHooks(node.instance);
+      } else {
+        for (const dispose of node.disposers) {
+          dispose();
+        }
+      }
+      for (const child of node.children) {
+        unmountNode(child);
+      }
+      break;
+  }
+}
+function removeMountedNode(node) {
+  const domNodes = getMountedDomNodes(node);
+  unmountNode(node);
+  for (const domNode of domNodes) {
+    if (domNode.parentNode) {
+      domOps.remove(domNode);
+    }
+  }
+}
+
+// src/renderer/render-control-flow.ts
+function renderControlFlowToDOM(element, parent, anchor, namespace) {
+  const startAnchor = domOps.createComment("Sinwan-b");
+  const endAnchor = domOps.createComment("/Sinwan-b");
+  insertNode(parent, startAnchor, anchor);
+  insertNode(parent, endAnchor, anchor);
+  const owner = getCurrentInstance();
+  let disposeEffect = () => {};
+  const block = {
+    type: "reactive-block",
+    dispose: () => disposeEffect(),
+    children: [],
+    startAnchor,
+    endAnchor
+  };
+  if (isShowElement(element)) {
+    disposeEffect = renderShowBlock(element, block, parent, namespace, owner);
+  } else if (isForElement(element)) {
+    disposeEffect = renderForBlock(element, block, parent, namespace, owner);
+  }
+  return block;
+}
+function renderShowBlock(element, block, parent, namespace, owner) {
+  let initialized = false;
+  return effect(() => {
+    clearChildren(block);
+    const when = readReactive(element.props.when);
+    const content = withOptionalInstance(owner, () => when ? resolveShowChildren(element, when) : element.props.fallback);
+    block.children = renderBlockContent(content, parent, block.endAnchor, namespace, owner);
+    if (initialized) {
+      fireMountedAndQueueUpdated(owner);
+    }
+    initialized = true;
+  });
+}
+function renderForBlock(element, block, parent, namespace, owner) {
+  let initialized = false;
+  let records = [];
+  return effect(() => {
+    const props = element.props;
+    const items = readReactive(props.each);
+    const list = Array.isArray(items) ? items : [];
+    const renderChild = props.children;
+    if (typeof renderChild !== "function") {
+      clearChildren(block);
+      records = [];
+      if (initialized) {
+        queueUpdatedHooks(owner);
+      }
+      initialized = true;
+      return;
+    }
+    const oldByKey = new Map;
+    for (const record of records) {
+      oldByKey.set(record.key, record);
+    }
+    const nextRecords = [];
+    list.forEach((item, index) => {
+      const key = props.key ? props.key(item, index) : item;
+      const old = oldByKey.get(key);
+      if (old && old.item === item) {
+        old.index = index;
+        moveBeforeEnd(parent, old.mounted, block.endAnchor);
+        nextRecords.push(old);
+        oldByKey.delete(key);
+        return;
+      }
+      if (old) {
+        removeMountedNode(old.mounted);
+        oldByKey.delete(key);
+      }
+      const record = {
+        key,
+        item,
+        index,
+        mounted: { type: "text", node: domOps.createTextNode("") }
+      };
+      record.mounted = withOptionalInstance(owner, () => renderNodeToDOM(renderChild(item, () => record.index), parent, block.endAnchor, namespace));
+      nextRecords.push(record);
+    });
+    for (const record of oldByKey.values()) {
+      removeMountedNode(record.mounted);
+    }
+    records = nextRecords;
+    block.children = nextRecords.map((record) => record.mounted);
+    if (initialized) {
+      fireMountedAndQueueUpdated(owner);
+    }
+    initialized = true;
+  });
+}
+function resolveShowChildren(element, value) {
+  const children = element.props.children ?? element.children;
+  if (typeof children === "function") {
+    return children(value);
+  }
+  return children;
+}
+function renderBlockContent(content, parent, anchor, namespace, owner) {
+  if (content == null || typeof content === "boolean") {
+    return [];
+  }
+  const nodes = Array.isArray(content) ? content : [content];
+  return nodes.map((node) => withOptionalInstance(owner, () => renderNodeToDOM(node, parent, anchor, namespace)));
+}
+function clearChildren(block) {
+  for (const child of block.children) {
+    removeMountedNode(child);
+  }
+  block.children = [];
+}
+function moveBeforeEnd(parent, mounted, endAnchor) {
+  for (const node of getMountedDomNodes(mounted)) {
+    domOps.insertBefore(parent, node, endAnchor);
+  }
+}
+function fireMountedAndQueueUpdated(owner) {
+  if (owner) {
+    fireMountedHooks(owner);
+  }
+  queueUpdatedHooks(owner);
+}
+function withOptionalInstance(owner, fn) {
+  return owner ? withInstance(owner, fn) : fn();
+}
+function readReactive(value) {
+  return isSignal(value) || isComputed(value) ? value.value : value;
+}
+function insertNode(parent, child, anchor) {
+  if (anchor) {
+    domOps.insertBefore(parent, child, anchor);
+  } else {
+    domOps.appendChild(parent, child);
+  }
+}
+
+// src/renderer/render-element.ts
+var VOID_ELEMENTS2 = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var SVG_NS = "http://www.w3.org/2000/svg";
+var MATH_NS = "http://www.w3.org/1998/Math/MathML";
+function renderElementToDOM(element, parent, anchor = null, namespace = null) {
+  const { tag, props, children } = element;
+  if (tag === "" || tag === Fragment) {
+    return renderFragmentToDOM(children, parent, anchor, namespace);
+  }
+  if (tag === Show || tag === For) {
+    return renderElementToDOM(tag(props), parent, anchor, namespace);
+  }
+  if (isShowElement(element) || isForElement(element)) {
+    return renderControlFlowToDOM(element, parent, anchor, namespace);
+  }
+  if (typeof tag === "function") {
+    return renderComponentToDOM(tag, props, parent, anchor, namespace);
+  }
+  if (typeof tag === "string") {
+    return renderIntrinsicToDOM(tag, props, children, parent, anchor, namespace);
+  }
+  return renderFragmentToDOM(children, parent, anchor, namespace);
+}
+function renderIntrinsicToDOM(tag, props, children, parent, anchor, parentNamespace) {
+  const namespace = getElementNamespace(tag, parentNamespace);
+  const el = namespace ? domOps.createElementNS(namespace, tag) : domOps.createElement(tag);
+  const attrDisposers = applyAttributes(el, props);
+  const eventCleanups = bindEvents(el, props);
+  let mountedChildren = [];
+  if (!VOID_ELEMENTS2.has(tag)) {
+    const dangerous = props.dangerouslySetInnerHTML;
+    if (dangerous && typeof dangerous.__html === "string") {
+      el.innerHTML = dangerous.__html;
+    } else {
+      mountedChildren = renderChildrenToDOM(children, el, getChildNamespace(tag, namespace));
+    }
+  }
+  if (anchor) {
+    domOps.insertBefore(parent, el, anchor);
+  } else {
+    domOps.appendChild(parent, el);
+  }
+  const refCleanup = applyRef(el, props.ref);
+  return {
+    type: "element",
+    node: el,
+    children: mountedChildren,
+    eventCleanups,
+    attrDisposers,
+    refCleanup
+  };
+}
+function renderComponentToDOM(component, props, parent, anchor, namespace) {
+  const parentInstance = getCurrentInstance();
+  const instance = createComponentInstance(component, props, parentInstance);
+  if (parentInstance) {
+    parentInstance.children.push(instance);
+  }
+  const prevInstance = setCurrentInstance(instance);
+  let result;
+  let child;
+  try {
+    result = component(props);
+    if (result && typeof result === "object" && "tag" in result) {
+      child = renderElementToDOM(result, parent, anchor, namespace);
+    } else {
+      child = renderNodeToDOM(result, parent, anchor, namespace);
+    }
+  } catch (err) {
+    setCurrentInstance(prevInstance);
+    handleComponentError(instance, err);
+    const text = domOps.createTextNode("");
+    if (anchor) {
+      domOps.insertBefore(parent, text, anchor);
+    } else {
+      domOps.appendChild(parent, text);
+    }
+    return {
+      type: "component",
+      children: [{ type: "text", node: text }],
+      disposers: [],
+      instance
+    };
+  }
+  setCurrentInstance(prevInstance);
+  instance.element = child;
+  return {
+    type: "component",
+    children: [child],
+    disposers: instance.effects,
+    instance
+  };
+}
+function renderFragmentToDOM(children, parent, anchor, namespace) {
+  const anchorComment = domOps.createComment("Sinwan-f");
+  if (anchor) {
+    domOps.insertBefore(parent, anchorComment, anchor);
+  } else {
+    domOps.appendChild(parent, anchorComment);
+  }
+  const mounted = [];
+  for (const child of children) {
+    mounted.push(renderNodeToDOM(child, parent, anchor, namespace));
+  }
+  return { type: "fragment", children: mounted, anchor: anchorComment };
+}
+function getElementNamespace(tag, parentNamespace) {
+  if (tag === "svg")
+    return SVG_NS;
+  if (tag === "math")
+    return MATH_NS;
+  return parentNamespace;
+}
+function getChildNamespace(tag, namespace) {
+  if (namespace === SVG_NS && tag === "foreignObject") {
+    return null;
+  }
+  return namespace;
+}
+function applyRef(el, ref) {
+  const value = ref;
+  if (!value) {
+    return null;
+  }
+  if (typeof value === "function") {
+    value(el);
+    return () => value(null);
+  }
+  if (typeof value === "object" && "current" in value) {
+    value.current = el;
+    return () => {
+      value.current = null;
+    };
+  }
+  return null;
+}
+
+// src/renderer/render-children.ts
+function renderNodeToDOM(node, parent, anchor = null, namespace = null) {
+  if (node == null || typeof node === "boolean") {
+    const text2 = domOps.createTextNode("");
+    insertNode2(parent, text2, anchor);
+    return { type: "text", node: text2 };
+  }
+  if (typeof node === "string") {
+    const text2 = domOps.createTextNode(node);
+    insertNode2(parent, text2, anchor);
+    return { type: "text", node: text2 };
+  }
+  if (typeof node === "number") {
+    const text2 = domOps.createTextNode(String(node));
+    insertNode2(parent, text2, anchor);
+    return { type: "text", node: text2 };
+  }
+  if (node instanceof HtmlEscapedString) {
+    const text2 = domOps.createTextNode(node.value);
+    insertNode2(parent, text2, anchor);
+    return { type: "text", node: text2 };
+  }
+  if (isSignal(node) || isComputed(node)) {
+    const text2 = domOps.createTextNode(String(node.value));
+    insertNode2(parent, text2, anchor);
+    const owner = getCurrentInstance();
+    let initialized = false;
+    const dispose = effect(() => {
+      domOps.setTextContent(text2, String(node.value));
+      if (initialized) {
+        queueUpdatedHooks(owner);
+      }
+      initialized = true;
+    });
+    return { type: "reactive-text", node: text2, dispose };
+  }
+  if (Array.isArray(node)) {
+    return renderArrayToDOM(node, parent, anchor, namespace);
+  }
+  if (node instanceof Promise) {
+    const placeholder = domOps.createTextNode("");
+    insertNode2(parent, placeholder, anchor);
+    node.then((resolved) => {
+      const mounted = renderNodeToDOM(resolved, parent, placeholder, namespace);
+      domOps.remove(placeholder);
+    });
+    return { type: "text", node: placeholder };
+  }
+  if (typeof node === "object" && "tag" in node) {
+    return renderElementToDOM(node, parent, anchor, namespace);
+  }
+  const text = domOps.createTextNode(String(node));
+  insertNode2(parent, text, anchor);
+  return { type: "text", node: text };
+}
+function renderArrayToDOM(nodes, parent, anchor, namespace) {
+  const anchorComment = domOps.createComment("Sinwan-f");
+  insertNode2(parent, anchorComment, anchor);
+  const children = [];
+  for (const child of nodes) {
+    children.push(renderNodeToDOM(child, parent, anchor, namespace));
+  }
+  return { type: "fragment", children, anchor: anchorComment };
+}
+function renderChildrenToDOM(children, parent, namespace = null) {
+  const mounted = [];
+  for (const child of children) {
+    mounted.push(renderNodeToDOM(child, parent, null, namespace));
+  }
+  return mounted;
+}
+function insertNode2(parent, child, anchor) {
+  if (anchor) {
+    domOps.insertBefore(parent, child, anchor);
+  } else {
+    domOps.appendChild(parent, child);
+  }
+}
+
+// src/renderer/mount.ts
+function mount(component, container, props) {
+  container.innerHTML = "";
+  const mergedProps = props ?? {};
+  const instance = createComponentInstance(component, mergedProps, null);
+  let result;
+  let root;
+  setCurrentInstance(instance);
+  try {
+    result = component(mergedProps);
+    if (result instanceof Promise) {
+      const placeholder = document.createTextNode("");
+      container.appendChild(placeholder);
+      root = { type: "text", node: placeholder };
+      result.then((resolved) => {
+        container.innerHTML = "";
+        setCurrentInstance(instance);
+        root = renderElementToDOM(resolved, container);
+        setCurrentInstance(null);
+        instance.element = root;
+        fireMountedHooks(instance);
+      });
+    } else if (result && typeof result === "object" && "tag" in result) {
+      root = renderElementToDOM(result, container);
+    } else {
+      root = renderNodeToDOM(result, container);
+    }
+  } catch (err) {
+    setCurrentInstance(null);
+    handleComponentError(instance, err);
+    return {
+      root: { type: "text", node: document.createTextNode("") },
+      unmount() {}
+    };
+  }
+  setCurrentInstance(null);
+  instance.element = root;
+  fireMountedHooks(instance);
+  return {
+    root,
+    unmount() {
+      fireUnmountedHooks(instance);
+      unmountNode(root);
+      container.innerHTML = "";
+    }
+  };
+}
+function render(node, container) {
+  container.innerHTML = "";
+  const root = renderNodeToDOM(node, container);
+  return {
+    root,
+    unmount() {
+      unmountNode(root);
+      container.innerHTML = "";
+    }
+  };
+}
+export {
+  unmountNode,
+  toEventName,
+  setDOMOps,
+  resetDOMOps,
+  renderNodeToDOM,
+  renderElementToDOM,
+  renderChildrenToDOM,
+  render,
+  mount,
+  isEventProp,
+  domOps,
+  bindEvents,
+  bindEvent,
+  applyAttributes
+};
+
+//# debugId=9C1A39184F093FF264756E2164756E21
+//# sourceMappingURL=index.development.js.map