sinwan 0.0.0 → 0.1.0

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

@@ -0,0 +1,878 @@
+// @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") {
+    if (type._SinwanComponent || type._SinwanPage) {
+      const result2 = type(props);
+      if (result2 && typeof result2 === "object" && "tag" in result2) {
+        return result2;
+      }
+      return { tag: "", props: {}, children: normalizeChildren(result2) };
+    }
+    const result = type(props);
+    if (result && typeof result === "object" && "tag" in result) {
+      return result;
+    }
+    return { tag: "", props: {}, children: normalizeChildren(result) };
+  }
+  if (typeof type === "string") {
+    return { tag: type, props: props || {}, 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/escaper.ts
+var _bun = globalThis.Bun;
+var _nativeEscape = typeof _bun?.escapeHTML === "function" ? _bun.escapeHTML.bind(_bun) : undefined;
+var HTML_ESCAPE_RE = /[&<>"']/g;
+var HTML_ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function portableEscape(str) {
+  HTML_ESCAPE_RE.lastIndex = 0;
+  if (!HTML_ESCAPE_RE.test(str))
+    return str;
+  return str.replace(HTML_ESCAPE_RE, (c) => HTML_ESCAPE_MAP[c]);
+}
+function escapeHtml(value) {
+  if (value == null || typeof value === "boolean")
+    return "";
+  if (typeof value === "number")
+    return String(value);
+  if (value instanceof HtmlEscapedString)
+    return value.value;
+  const s = String(value);
+  return _nativeEscape ? _nativeEscape(s) : portableEscape(s);
+}
+function safeHtml(html) {
+  return raw(html);
+}
+function isSafeHtml(value) {
+  return value instanceof HtmlEscapedString;
+}
+
+// src/server/renderer.ts
+var componentCache = new WeakMap;
+var pageRegistry = new Map;
+function registerPage(name, page) {
+  pageRegistry.set(name, page);
+}
+function getPage(name) {
+  return pageRegistry.get(name);
+}
+function hasPage(name) {
+  return pageRegistry.has(name);
+}
+async function renderPage(name, data) {
+  const page = getPage(name);
+  if (!page) {
+    throw new Error(`Page "${name}" not found in registry`);
+  }
+  const element = await page(data);
+  return renderToString(element);
+}
+async function renderToString(node) {
+  if (node == null || typeof node === "boolean") {
+    return "";
+  }
+  if (typeof node === "string") {
+    return escapeHtml(node);
+  }
+  if (typeof node === "number") {
+    return String(node);
+  }
+  if (node instanceof HtmlEscapedString) {
+    return node.value;
+  }
+  if (Array.isArray(node)) {
+    const results = await Promise.all(node.map((child) => renderToString(child)));
+    return results.join("");
+  }
+  if (node instanceof Promise) {
+    return renderElement(await node);
+  }
+  return renderElement(node);
+}
+async function renderElement(element) {
+  const { tag, props, children } = element;
+  if (typeof tag === "function") {
+    const result = await tag(props);
+    return renderToString(result);
+  }
+  if (typeof tag === "string") {
+    return renderIntrinsicElement(tag, props, children);
+  }
+  return renderToString(children);
+}
+var VOID_ELEMENTS2 = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+async function renderIntrinsicElement(tag, props, children) {
+  const attrs = renderAttributes(props);
+  if (VOID_ELEMENTS2.has(tag)) {
+    return attrs ? `<${tag}${attrs}>` : `<${tag}>`;
+  }
+  const childrenHtml = await renderChildren(children, props);
+  return attrs ? `<${tag}${attrs}>${childrenHtml}</${tag}>` : `<${tag}>${childrenHtml}</${tag}>`;
+}
+function renderAttributes(props) {
+  let attrs = "";
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "children")
+      continue;
+    if (value == null || value === false)
+      continue;
+    if (value === true) {
+      attrs += ` ${key}`;
+      continue;
+    }
+    if (key === "dangerouslySetInnerHTML") {
+      continue;
+    }
+    const attrName = key === "className" ? "class" : key;
+    const finalName = attrName === "htmlFor" ? "for" : attrName;
+    const attrValue = escapeHtml(String(value));
+    attrs += ` ${finalName}="${attrValue}"`;
+  }
+  return attrs;
+}
+async function renderChildren(children, props) {
+  const dangerous = props.dangerouslySetInnerHTML;
+  if (dangerous && typeof dangerous.__html === "string") {
+    return dangerous.__html;
+  }
+  return renderToString(children);
+}
+function isSlots(children) {
+  return children != null && typeof children === "object" && !Array.isArray(children) && !(children instanceof HtmlEscapedString);
+}
+// src/server/stream.ts
+var VOID_ELEMENTS3 = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function streamPage(page, data) {
+  const encoder = new TextEncoder;
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        const element = await page(data);
+        await streamNode(element, controller, encoder);
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+}
+async function streamNode(node, controller, encoder) {
+  if (node == null || typeof node === "boolean") {
+    return;
+  }
+  if (typeof node === "string") {
+    controller.enqueue(encoder.encode(escapeHtml(node)));
+    return;
+  }
+  if (typeof node === "number") {
+    controller.enqueue(encoder.encode(String(node)));
+    return;
+  }
+  if (node instanceof HtmlEscapedString) {
+    controller.enqueue(encoder.encode(node.value));
+    return;
+  }
+  if (Array.isArray(node)) {
+    for (const child of node) {
+      await streamNode(child, controller, encoder);
+    }
+    return;
+  }
+  if (node instanceof Promise) {
+    const resolved = await node;
+    await streamElement(resolved, controller, encoder);
+    return;
+  }
+  await streamElement(node, controller, encoder);
+}
+async function streamElement(element, controller, encoder) {
+  const { tag, props, children } = element;
+  if (typeof tag === "function") {
+    const result = await tag(props);
+    await streamNode(result, controller, encoder);
+    return;
+  }
+  if (typeof tag === "string") {
+    await streamIntrinsicElement(tag, props, children, controller, encoder);
+    return;
+  }
+  await streamNode(children, controller, encoder);
+}
+async function streamIntrinsicElement(tag, props, children, controller, encoder) {
+  const attrs = renderAttributes2(props);
+  const dangerous = props.dangerouslySetInnerHTML;
+  if (VOID_ELEMENTS3.has(tag)) {
+    const html = attrs ? `<${tag}${attrs}>` : `<${tag}>`;
+    controller.enqueue(encoder.encode(html));
+    return;
+  }
+  const openTag = attrs ? `<${tag}${attrs}>` : `<${tag}>`;
+  controller.enqueue(encoder.encode(openTag));
+  if (dangerous && typeof dangerous.__html === "string") {
+    controller.enqueue(encoder.encode(dangerous.__html));
+  } else {
+    await streamNode(children, controller, encoder);
+  }
+  controller.enqueue(encoder.encode(`</${tag}>`));
+}
+function renderAttributes2(props) {
+  let attrs = "";
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "children" || key === "dangerouslySetInnerHTML")
+      continue;
+    if (value == null || value === false)
+      continue;
+    if (value === true) {
+      attrs += ` ${key}`;
+      continue;
+    }
+    const attrName = key === "className" ? "class" : key === "htmlFor" ? "for" : key;
+    const attrValue = escapeHtml(String(value));
+    attrs += ` ${attrName}="${attrValue}"`;
+  }
+  return attrs;
+}
+// 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/hydration/markers.ts
+var COMP_ID_ATTR = "data-sinwan-id";
+var COMP_ID_PREFIX = "c";
+var TEXT_MARKER_OPEN = "sinwan-t:";
+var TEXT_MARKER_CLOSE = "/sinwan-t";
+var EVENT_ATTR = "data-sinwan-ev";
+function compId(index) {
+  return `${COMP_ID_PREFIX}${index}`;
+}
+function textMarkerOpen(index) {
+  return `<!--${TEXT_MARKER_OPEN}${index}-->`;
+}
+function textMarkerCloseStr() {
+  return `<!--${TEXT_MARKER_CLOSE}-->`;
+}
+function parseTextOpenMarker(node) {
+  const data = node.data;
+  if (data.startsWith(TEXT_MARKER_OPEN)) {
+    const idx = parseInt(data.slice(TEXT_MARKER_OPEN.length), 10);
+    return Number.isNaN(idx) ? -1 : idx;
+  }
+  return -1;
+}
+function isTextCloseMarker(node) {
+  return node.data === TEXT_MARKER_CLOSE;
+}
+
+// src/renderer/dom-ops.ts
+var domOps = {
+  createElement(tag) {
+    return document.createElement(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;
+  }
+};
+
+// 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 fireMountedHooks(instance) {
+  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 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/server/hydration-markers.ts
+function createHydrationContext() {
+  return { componentIndex: 0, textIndex: 0, eventIndex: 0 };
+}
+async function renderToHydratableString(component, props) {
+  const ctx = createHydrationContext();
+  const mergedProps = props ?? {};
+  const instance = createComponentInstance(component, mergedProps, null);
+  setCurrentInstance(instance);
+  const result = await component(mergedProps);
+  setCurrentInstance(null);
+  if (result && typeof result === "object" && "tag" in result) {
+    return renderElementH(result, ctx, true);
+  }
+  return renderNodeH(result, ctx);
+}
+async function renderNodeToHydratableString(node) {
+  const ctx = createHydrationContext();
+  return renderNodeH(node, ctx);
+}
+var VOID_ELEMENTS4 = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function renderNodeH(node, ctx) {
+  if (node == null || typeof node === "boolean")
+    return "";
+  if (typeof node === "string")
+    return escapeHtml(node);
+  if (typeof node === "number")
+    return String(node);
+  if (node instanceof HtmlEscapedString)
+    return node.value;
+  if (isSignal(node) || isComputed(node)) {
+    const value = node.value;
+    const idx = ctx.textIndex++;
+    return `${textMarkerOpen(idx)}${escapeHtml(String(value))}${textMarkerCloseStr()}`;
+  }
+  if (Array.isArray(node)) {
+    return node.map((child) => renderNodeH(child, ctx)).join("");
+  }
+  if (node instanceof Promise) {
+    return "";
+  }
+  if (typeof node === "object" && "tag" in node) {
+    return renderElementH(node, ctx, false);
+  }
+  return escapeHtml(String(node));
+}
+function renderElementH(element, ctx, isComponentRoot) {
+  const { tag, props, children } = element;
+  if (tag === "") {
+    return children.map((child) => renderNodeH(child, ctx)).join("");
+  }
+  if (typeof tag === "function") {
+    return renderComponentH(tag, props, ctx);
+  }
+  if (typeof tag === "string") {
+    return renderIntrinsicH(tag, props, children, ctx, isComponentRoot);
+  }
+  return children.map((child) => renderNodeH(child, ctx)).join("");
+}
+function renderComponentH(component, props, ctx) {
+  const parentInstance = globalThis.__SinwanCurrentInstance;
+  const instance = createComponentInstance(component, props, null);
+  const prev = setCurrentInstance(instance);
+  const result = component(props);
+  setCurrentInstance(prev);
+  if (result && typeof result === "object" && "tag" in result) {
+    return renderElementH(result, ctx, true);
+  }
+  return renderNodeH(result, ctx);
+}
+function renderIntrinsicH(tag, props, children, ctx, isComponentRoot) {
+  let attrs = "";
+  if (isComponentRoot) {
+    attrs += ` ${COMP_ID_ATTR}="${compId(ctx.componentIndex++)}"`;
+  }
+  const eventParts = [];
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "children" || key === "dangerouslySetInnerHTML")
+      continue;
+    if (isEventProp(key)) {
+      const eventName = toEventName(key);
+      eventParts.push(`${eventName}:${ctx.eventIndex++}`);
+      continue;
+    }
+    if (value == null || value === false)
+      continue;
+    let resolvedValue = value;
+    if (isSignal(value) || isComputed(value)) {
+      resolvedValue = value.value;
+    }
+    if (resolvedValue === true) {
+      const attrName2 = key === "className" ? "class" : key === "htmlFor" ? "for" : key;
+      attrs += ` ${attrName2}`;
+      continue;
+    }
+    const attrName = key === "className" ? "class" : key === "htmlFor" ? "for" : key;
+    attrs += ` ${attrName}="${escapeHtml(String(resolvedValue))}"`;
+  }
+  if (eventParts.length > 0) {
+    attrs += ` ${EVENT_ATTR}="${eventParts.join(",")}"`;
+  }
+  if (VOID_ELEMENTS4.has(tag)) {
+    return `<${tag}${attrs}>`;
+  }
+  const dangerous = props.dangerouslySetInnerHTML;
+  if (dangerous && typeof dangerous.__html === "string") {
+    return `<${tag}${attrs}>${dangerous.__html}</${tag}>`;
+  }
+  const childrenHtml = children.map((child) => renderNodeH(child, ctx)).join("");
+  return `<${tag}${attrs}>${childrenHtml}</${tag}>`;
+}
+export {
+  streamPage,
+  renderToString,
+  renderToHydratableString,
+  renderPage,
+  renderNodeToHydratableString,
+  registerPage,
+  isSlots,
+  hasPage,
+  getPage
+};
+
+//# debugId=46FB02649D98C84264756E2164756E21
+//# sourceMappingURL=index.development.js.map