sibujs 1.0.0-beta.1

package/dist/build.cjs

@@ -0,0 +1,4970 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// build.ts
+var build_exports = {};
+__export(build_exports, {
+  analyzeBundle: () => analyzeBundle,
+  analyzeStaticTemplates: () => analyzeStaticTemplates,
+  buildRouteEntries: () => buildRouteEntries,
+  cdnUrls: () => cdnUrls,
+  compileHtmlTemplates: () => compileHtmlTemplates,
+  createPureAnnotationsLoader: () => createPureAnnotationsLoader,
+  createViteConfig: () => createViteConfig,
+  createWebpackConfig: () => createWebpackConfig,
+  estimateImportSize: () => estimateImportSize,
+  fileToRoute: () => fileToRoute,
+  generateEslintConfig: () => generateEslintConfig,
+  generateImportMap: () => generateImportMap,
+  generateLanguageConfig: () => generateLanguageConfig,
+  generateTsConfig: () => generateTsConfig,
+  generateTypeStubs: () => generateTypeStubs,
+  generateVSCodeSnippets: () => generateVSCodeSnippets,
+  getComponentMetadata: () => getComponentMetadata,
+  lintRules: () => lintRules,
+  lintSource: () => lintSource,
+  moduleSizes: () => moduleSizes,
+  registerGlobal: () => registerGlobal,
+  sibuRouteSplitting: () => sibuRouteSplitting,
+  sibuVitePlugin: () => sibuVitePlugin,
+  sibuWebpackPlugin: () => sibuWebpackPlugin,
+  umdWrapper: () => umdWrapper,
+  validateTsConfig: () => validateTsConfig
+});
+module.exports = __toCommonJS(build_exports);
+
+// src/build/compileTemplates.ts
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var SVG_TAGS = /* @__PURE__ */ new Set([
+  "svg",
+  "circle",
+  "ellipse",
+  "g",
+  "line",
+  "path",
+  "polygon",
+  "polyline",
+  "rect",
+  "text",
+  "tspan",
+  "defs",
+  "clipPath",
+  "mask",
+  "pattern",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "use",
+  "symbol",
+  "marker"
+]);
+function findHtmlTemplates(code2) {
+  const results = [];
+  const tagRegex = /\bhtml\s*`/g;
+  let match2;
+  while ((match2 = tagRegex.exec(code2)) !== null) {
+    const start = match2.index;
+    const backtickStart = code2.indexOf("`", start + 4);
+    if (backtickStart === -1) continue;
+    const parsed = parseTemplateLiteral(code2, backtickStart);
+    if (!parsed) continue;
+    results.push({
+      start,
+      end: parsed.end,
+      strings: parsed.strings,
+      exprCount: parsed.exprCount
+    });
+    tagRegex.lastIndex = parsed.end;
+  }
+  return results;
+}
+function parseTemplateLiteral(code2, openBacktick) {
+  const strings = [];
+  let exprCount = 0;
+  let pos = openBacktick + 1;
+  let current = "";
+  while (pos < code2.length) {
+    const ch = code2[pos];
+    if (ch === "`") {
+      strings.push(current);
+      return { end: pos + 1, strings, exprCount };
+    }
+    if (ch === "$" && pos + 1 < code2.length && code2[pos + 1] === "{") {
+      strings.push(current);
+      current = "";
+      exprCount++;
+      pos += 2;
+      let depth = 1;
+      while (pos < code2.length && depth > 0) {
+        const c = code2[pos];
+        if (c === "{") depth++;
+        else if (c === "}") depth--;
+        else if (c === '"' || c === "'" || c === "`") {
+          pos = skipString(code2, pos);
+          continue;
+        }
+        if (depth > 0) pos++;
+      }
+      if (depth !== 0) return null;
+      pos++;
+      continue;
+    }
+    if (ch === "\\") {
+      current += code2[pos] + (code2[pos + 1] || "");
+      pos += 2;
+      continue;
+    }
+    current += ch;
+    pos++;
+  }
+  return null;
+}
+function skipString(code2, start) {
+  const quote = code2[start];
+  let pos = start + 1;
+  while (pos < code2.length) {
+    if (code2[pos] === "\\") {
+      pos += 2;
+      continue;
+    }
+    if (code2[pos] === quote) return pos + 1;
+    if (quote === "`" && code2[pos] === "$" && code2[pos + 1] === "{") {
+      pos += 2;
+      let depth = 1;
+      while (pos < code2.length && depth > 0) {
+        if (code2[pos] === "{") depth++;
+        else if (code2[pos] === "}") depth--;
+        else if (code2[pos] === '"' || code2[pos] === "'" || code2[pos] === "`") {
+          pos = skipString(code2, pos);
+          continue;
+        }
+        if (depth > 0) pos++;
+      }
+      pos++;
+      continue;
+    }
+    pos++;
+  }
+  return pos;
+}
+function parseTemplateToAST(strings) {
+  const exprCount = strings.length - 1;
+  let template2 = strings[0];
+  for (let i2 = 0; i2 < exprCount; i2++) {
+    template2 += `\0${i2}\0${strings[i2 + 1]}`;
+  }
+  let pos = 0;
+  const len = template2.length;
+  function skipWs() {
+    while (pos < len && /\s/.test(template2[pos])) pos++;
+  }
+  function tryExprIdx() {
+    if (template2[pos] !== "\0") return -1;
+    const start = pos;
+    pos++;
+    let idxStr = "";
+    while (pos < len && template2[pos] !== "\0") idxStr += template2[pos++];
+    if (pos < len) pos++;
+    const idx = Number.parseInt(idxStr, 10);
+    if (Number.isNaN(idx) || idx < 0 || idx >= exprCount) {
+      pos = start;
+      return -1;
+    }
+    return idx;
+  }
+  function readTagName() {
+    let name = "";
+    while (pos < len && /[a-zA-Z0-9-]/.test(template2[pos])) name += template2[pos++];
+    return name;
+  }
+  function parseAttrValue() {
+    skipWs();
+    if (template2[pos] !== "=") return { kind: "bool" };
+    pos++;
+    skipWs();
+    const exprIdx = tryExprIdx();
+    if (exprIdx >= 0) return { kind: "expr", index: exprIdx };
+    const quote = template2[pos];
+    if (quote === '"' || quote === "'") {
+      pos++;
+      const parts = [];
+      let current = "";
+      while (pos < len && template2[pos] !== quote) {
+        const innerIdx = tryExprIdx();
+        if (innerIdx >= 0) {
+          if (current) parts.push({ kind: "static", value: current });
+          current = "";
+          parts.push({ kind: "expr", index: innerIdx });
+        } else {
+          current += template2[pos++];
+        }
+      }
+      if (pos < len) pos++;
+      if (current) parts.push({ kind: "static", value: current });
+      if (parts.length === 1 && parts[0].kind === "static") {
+        return { kind: "static", value: parts[0].value };
+      }
+      if (parts.some((p2) => p2.kind === "expr")) {
+        return { kind: "mixed", parts };
+      }
+      return { kind: "static", value: parts.map((p2) => p2.value).join("") };
+    }
+    let val = "";
+    while (pos < len && !/[\s>/]/.test(template2[pos])) val += template2[pos++];
+    return { kind: "static", value: val };
+  }
+  function parseAttrs() {
+    const attrs = [];
+    while (pos < len) {
+      skipWs();
+      if (template2[pos] === ">" || template2[pos] === "/") break;
+      let attrName = "";
+      while (pos < len && /[a-zA-Z0-9\-:_.]/.test(template2[pos])) attrName += template2[pos++];
+      if (!attrName) break;
+      const val = parseAttrValue();
+      if (attrName.startsWith("on:")) {
+        if (val.kind === "expr") {
+          attrs.push({ name: attrName.slice(3), value: { kind: "event", index: val.index } });
+        }
+      } else {
+        attrs.push({ name: attrName, value: val });
+      }
+    }
+    return attrs;
+  }
+  function collapseWs(s2) {
+    return s2.replace(/\s+/g, " ");
+  }
+  function parseTextChildren(children) {
+    let text2 = "";
+    while (pos < len && template2[pos] !== "<") {
+      const idx = tryExprIdx();
+      if (idx >= 0) {
+        const collapsed2 = collapseWs(text2);
+        if (collapsed2) children.push({ kind: "text", value: collapsed2 });
+        text2 = "";
+        children.push({ kind: "expr", index: idx });
+      } else {
+        text2 += template2[pos++];
+      }
+    }
+    const collapsed = collapseWs(text2);
+    if (collapsed) children.push({ kind: "text", value: collapsed });
+  }
+  function parseChildren() {
+    const children = [];
+    while (pos < len) {
+      if (template2[pos] === "<" && pos + 1 < len && template2[pos + 1] === "/") break;
+      if (template2[pos] === "<") {
+        pos++;
+        const tag = readTagName();
+        const attrs = parseAttrs();
+        skipWs();
+        const isVoid = VOID_ELEMENTS.has(tag);
+        const isSelfClosing = template2[pos] === "/";
+        if (isSelfClosing) pos++;
+        if (pos < len) pos++;
+        if (isVoid || isSelfClosing) {
+          children.push({ kind: "element", el: { tag, attrs, children: [] } });
+        } else {
+          const inner = parseChildren();
+          if (template2[pos] === "<" && pos + 1 < len && template2[pos + 1] === "/") {
+            pos += 2;
+            readTagName();
+            skipWs();
+            if (pos < len && template2[pos] === ">") pos++;
+          }
+          children.push({ kind: "element", el: { tag, attrs, children: inner } });
+        }
+      } else {
+        parseTextChildren(children);
+      }
+    }
+    return children;
+  }
+  return parseChildren();
+}
+function generateElement(el, valuesVar) {
+  const tag = el.tag;
+  const isSvg = SVG_TAGS.has(tag);
+  const parts = [];
+  for (const attr of el.attrs) {
+    const v = attr.value;
+    switch (v.kind) {
+      case "static":
+        parts.push(`${JSON.stringify(attr.name)}: ${JSON.stringify(v.value)}`);
+        break;
+      case "expr":
+        parts.push(`${JSON.stringify(attr.name)}: ${valuesVar}[${v.index}]`);
+        break;
+      case "mixed": {
+        const concat = v.parts.map((p2) => p2.kind === "static" ? JSON.stringify(p2.value) : `String(${valuesVar}[${p2.index}])`).join(" + ");
+        parts.push(`${JSON.stringify(attr.name)}: ${concat}`);
+        break;
+      }
+      case "bool":
+        parts.push(`${JSON.stringify(attr.name)}: true`);
+        break;
+      case "event":
+        break;
+    }
+  }
+  const events = el.attrs.filter((a2) => a2.value.kind === "event");
+  if (events.length > 0) {
+    const eventEntries = events.map((a2) => {
+      const v = a2.value;
+      return `${JSON.stringify(a2.name)}: ${valuesVar}[${v.index}]`;
+    });
+    parts.push(`on: { ${eventEntries.join(", ")} }`);
+  }
+  if (el.children.length > 0) {
+    const childExprs = el.children.map((c) => generateChild(c, valuesVar));
+    if (childExprs.length === 1) {
+      parts.push(`nodes: ${childExprs[0]}`);
+    } else {
+      parts.push(`nodes: [${childExprs.join(", ")}]`);
+    }
+  }
+  const propsStr = parts.length > 0 ? `{ ${parts.join(", ")} }` : void 0;
+  if (isSvg) {
+    return propsStr ? `__sbTagFactory(${JSON.stringify(tag)}, __sbSVG_NS)(${propsStr})` : `__sbTagFactory(${JSON.stringify(tag)}, __sbSVG_NS)({})`;
+  }
+  return propsStr ? `${tag}(${propsStr})` : `${tag}({})`;
+}
+function generateChild(child, valuesVar) {
+  switch (child.kind) {
+    case "element":
+      return generateElement(child.el, valuesVar);
+    case "text":
+      return JSON.stringify(child.value);
+    case "expr":
+      return `${valuesVar}[${child.index}]`;
+  }
+}
+function compileHtmlTemplates(code2) {
+  const templates = findHtmlTemplates(code2);
+  if (templates.length === 0) {
+    return { code: null, usedTags: /* @__PURE__ */ new Set(), usesSvg: false, compiledCount: 0 };
+  }
+  const usedTags = /* @__PURE__ */ new Set();
+  let usesSvg = false;
+  let result = code2;
+  for (let i2 = templates.length - 1; i2 >= 0; i2--) {
+    const tmpl = templates[i2];
+    const ast = parseTemplateToAST(tmpl.strings);
+    collectTags(ast, usedTags);
+    if (Array.from(usedTags).some((t) => SVG_TAGS.has(t))) usesSvg = true;
+    const valuesVar = "__v";
+    const childExprs = ast.map((c) => generateChild(c, valuesVar));
+    let compiled;
+    if (tmpl.exprCount === 0) {
+      compiled = childExprs.length === 1 ? childExprs[0] : childExprs[0];
+    } else {
+      const body2 = childExprs.length === 1 ? childExprs[0] : childExprs[0];
+      const exprSource = extractExpressions(code2, tmpl.start, tmpl.end, tmpl.exprCount);
+      compiled = `((${valuesVar}) => ${body2})([${exprSource.join(", ")}])`;
+    }
+    result = result.slice(0, tmpl.start) + compiled + result.slice(tmpl.end);
+  }
+  return { code: result, usedTags, usesSvg, compiledCount: templates.length };
+}
+function collectTags(children, tags) {
+  for (const child of children) {
+    if (child.kind === "element") {
+      tags.add(child.el.tag);
+      collectTags(child.el.children, tags);
+    }
+  }
+}
+function extractExpressions(code2, templateStart, templateEnd, count) {
+  const exprs = [];
+  const backtickStart = code2.indexOf("`", templateStart + 4);
+  let pos = backtickStart + 1;
+  for (let i2 = 0; i2 < count; i2++) {
+    while (pos < templateEnd) {
+      if (code2[pos] === "$" && code2[pos + 1] === "{") {
+        pos += 2;
+        break;
+      }
+      if (code2[pos] === "\\") {
+        pos += 2;
+        continue;
+      }
+      pos++;
+    }
+    const exprStart = pos;
+    let depth = 1;
+    while (pos < templateEnd && depth > 0) {
+      const c = code2[pos];
+      if (c === "{") depth++;
+      else if (c === "}") {
+        depth--;
+        if (depth === 0) break;
+      } else if (c === '"' || c === "'" || c === "`") {
+        pos = skipString(code2, pos);
+        continue;
+      }
+      pos++;
+    }
+    exprs.push(code2.slice(exprStart, pos).trim());
+    pos++;
+  }
+  return exprs;
+}
+
+// src/build/staticAnalysis.ts
+var HTML_TAGS = /* @__PURE__ */ new Set([
+  "div",
+  "span",
+  "section",
+  "article",
+  "header",
+  "footer",
+  "nav",
+  "main",
+  "aside",
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "blockquote",
+  "li",
+  "ol",
+  "ul",
+  "pre",
+  "a",
+  "b",
+  "em",
+  "i",
+  "strong",
+  "small",
+  "code",
+  "mark",
+  "img",
+  "br",
+  "hr",
+  "input",
+  "button",
+  "form",
+  "label",
+  "select",
+  "textarea",
+  "option",
+  "table",
+  "tbody",
+  "thead",
+  "tfoot",
+  "tr",
+  "td",
+  "th",
+  "details",
+  "summary",
+  "dialog"
+]);
+var VOID_ELEMENTS2 = /* @__PURE__ */ new Set([
+  "br",
+  "hr",
+  "img",
+  "input",
+  "meta",
+  "link",
+  "area",
+  "base",
+  "col",
+  "embed",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function analyzeStaticTemplates(code2) {
+  const patterns = [];
+  const tagCallRegex = new RegExp(`\\b(${Array.from(HTML_TAGS).join("|")})\\s*\\(\\s*\\{([^}]*)\\}\\s*\\)`, "g");
+  let match2;
+  while ((match2 = tagCallRegex.exec(code2)) !== null) {
+    const [fullMatch, tag, propsContent] = match2;
+    const start = match2.index;
+    const end = start + fullMatch.length;
+    if (isStaticPropsContent(propsContent)) {
+      const templateHtml = propsToHtml(tag, propsContent);
+      if (templateHtml) {
+        patterns.push({ original: fullMatch, tag, templateHtml, start, end });
+      }
+    }
+  }
+  return {
+    hasStaticPatterns: patterns.length > 0,
+    patterns
+  };
+}
+function isStaticPropsContent(propsContent) {
+  if (/=>|function\s*\(|\bref\b|\bon\s*:/.test(propsContent)) {
+    return false;
+  }
+  const props = propsContent.split(",").map((p2) => p2.trim()).filter(Boolean);
+  for (const prop of props) {
+    const colonIndex = prop.indexOf(":");
+    if (colonIndex === -1) continue;
+    const value = prop.substring(colonIndex + 1).trim();
+    if (!isStaticValue(value)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isStaticValue(value) {
+  if (/^["'].*["']$/.test(value)) return true;
+  if (/^-?\d+(\.\d+)?$/.test(value)) return true;
+  if (value === "true" || value === "false") return true;
+  if (value === "null" || value === "undefined") return true;
+  return false;
+}
+function propsToHtml(tag, propsContent) {
+  const attrs = [];
+  let nodesContent = "";
+  const props = propsContent.split(",").map((p2) => p2.trim()).filter(Boolean);
+  for (const prop of props) {
+    const colonIndex = prop.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = prop.substring(0, colonIndex).trim();
+    let value = prop.substring(colonIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key === "nodes") {
+      nodesContent = escapeHtml(value);
+    } else if (key === "class" || key === "id") {
+      attrs.push(`${key}="${escapeAttr(value)}"`);
+    } else if (key !== "on" && key !== "ref" && key !== "style") {
+      attrs.push(`${key}="${escapeAttr(String(value))}"`);
+    }
+  }
+  const attrStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+  if (VOID_ELEMENTS2.has(tag)) {
+    return `<${tag}${attrStr} />`;
+  }
+  return `<${tag}${attrStr}>${nodesContent}</${tag}>`;
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/build/vite.ts
+var SVG_TAGS_SET = /* @__PURE__ */ new Set([
+  "svg",
+  "circle",
+  "ellipse",
+  "g",
+  "line",
+  "path",
+  "polygon",
+  "polyline",
+  "rect",
+  "text",
+  "tspan",
+  "defs",
+  "clipPath",
+  "mask",
+  "pattern",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "use",
+  "symbol",
+  "marker"
+]);
+var DEFAULT_INCLUDE = ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"];
+var DEFAULT_EXCLUDE = ["node_modules/**", "dist/**", "**/*.test.*", "**/*.spec.*"];
+function matchesPattern(filePath, patterns) {
+  const normalized = filePath.replace(/\\/g, "/");
+  return patterns.some((pattern2) => {
+    const regexStr = pattern2.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+    return new RegExp(regexStr).test(normalized);
+  });
+}
+function injectPureAnnotations(code2) {
+  const sibuFactories = [
+    "tagFactory",
+    "context",
+    "composable",
+    "defineComponent",
+    "withProps",
+    "withDefaults",
+    "pure",
+    "noSideEffect"
+  ];
+  let result = code2;
+  for (const factory of sibuFactories) {
+    const pattern2 = new RegExp(`(?<!/\\*#__PURE__\\*/\\s*)\\b(${factory})\\s*\\(`, "g");
+    result = result.replace(pattern2, "/*#__PURE__*/ $1(");
+  }
+  return result;
+}
+function injectDevHelpers(code2) {
+  if (code2.includes('from "sibu"') || code2.includes("from 'sibu'") || code2.includes('from "sibu/') || code2.includes("from 'sibu/")) {
+    return `/* SibuJS Dev Mode */
+if (typeof globalThis !== 'undefined') { (globalThis as unknown as Record<string, unknown>).__SIBU_DEV__ = true; }
+${code2}`;
+  }
+  return code2;
+}
+function sibuVitePlugin(options = {}) {
+  const {
+    hmr = true,
+    pureAnnotations = true,
+    include = DEFAULT_INCLUDE,
+    exclude = DEFAULT_EXCLUDE,
+    devMode,
+    staticOptimize,
+    compileTemplates
+  } = options;
+  const isDevMode = devMode ?? (typeof process !== "undefined" && process.env?.NODE_ENV !== "production");
+  return {
+    name: "sibu-vite-plugin",
+    enforce: "pre",
+    config() {
+      return {
+        // Optimize dependency pre-bundling for sibu
+        optimizeDeps: {
+          include: ["sibu"]
+        },
+        // Ensure sibu is treated correctly for SSR
+        ssr: {
+          noExternal: ["sibu"]
+        },
+        // Define global constants for dead code elimination
+        define: {
+          __SIBU_DEV__: JSON.stringify(isDevMode),
+          __SIBU_HMR__: JSON.stringify(hmr)
+        },
+        // Enable source maps in dev
+        build: {
+          sourcemap: isDevMode
+        }
+      };
+    },
+    transform(code2, id) {
+      if (!matchesPattern(id, include) || matchesPattern(id, exclude)) {
+        return null;
+      }
+      let transformed = code2;
+      let modified = false;
+      if (pureAnnotations) {
+        const annotated = injectPureAnnotations(transformed);
+        if (annotated !== transformed) {
+          transformed = annotated;
+          modified = true;
+        }
+      }
+      if (isDevMode) {
+        const withDevHelpers = injectDevHelpers(transformed);
+        if (withDevHelpers !== transformed) {
+          transformed = withDevHelpers;
+          modified = true;
+        }
+      }
+      const shouldCompile = compileTemplates ?? !isDevMode;
+      if (shouldCompile && transformed.includes("html`")) {
+        const compiled = compileHtmlTemplates(transformed);
+        if (compiled.code) {
+          const tagImports = Array.from(compiled.usedTags).filter((t) => !SVG_TAGS_SET.has(t));
+          const needsSvg = compiled.usesSvg;
+          const imports = [];
+          if (tagImports.length > 0) {
+            imports.push(`import { ${tagImports.join(", ")} } from "sibu";`);
+          }
+          if (needsSvg) {
+            imports.push(`import { tagFactory as __sbTagFactory, SVG_NS as __sbSVG_NS } from "sibu";`);
+          }
+          const newImports = imports.filter((imp) => !transformed.includes(imp));
+          if (newImports.length > 0) {
+            compiled.code = `${newImports.join("\n")}
+${compiled.code}`;
+          }
+          transformed = compiled.code;
+          modified = true;
+        }
+      }
+      const shouldOptimize = staticOptimize ?? !isDevMode;
+      if (shouldOptimize) {
+        const analysis = analyzeStaticTemplates(transformed);
+        if (analysis.hasStaticPatterns) {
+          const sorted = [...analysis.patterns].sort((a2, b2) => b2.start - a2.start);
+          for (const pattern2 of sorted) {
+            const replacement = `staticTemplate(${JSON.stringify(pattern2.templateHtml)})`;
+            transformed = transformed.slice(0, pattern2.start) + replacement + transformed.slice(pattern2.end);
+          }
+          if (!transformed.includes("import") || !transformed.includes("staticTemplate")) {
+            transformed = `import { staticTemplate } from "sibu";
+${transformed}`;
+          }
+          modified = true;
+        }
+      }
+      if (!modified) return null;
+      return {
+        code: transformed,
+        map: void 0
+        // Let Vite handle source maps
+      };
+    },
+    handleHotUpdate(ctx) {
+      if (!hmr) return;
+      const { file } = ctx;
+      if (matchesPattern(file, include) && !matchesPattern(file, exclude)) {
+        if (isDevMode) {
+          console.log(`[sibu-vite-plugin] HMR update: ${file}`);
+        }
+        return;
+      }
+    }
+  };
+}
+function createViteConfig(options = {}) {
+  const { entry = "src/main.ts", outDir = "dist", ssr = false, overrides = {} } = options;
+  const baseConfig = {
+    // Use the SibuJS Vite plugin
+    plugins: [sibuVitePlugin()],
+    // Build configuration
+    build: {
+      outDir,
+      target: "es2020",
+      minify: "esbuild",
+      sourcemap: true,
+      // Library mode configuration when building a library
+      lib: ssr ? void 0 : {
+        entry,
+        formats: ["es", "cjs"]
+      },
+      // Rollup-specific options
+      rollupOptions: {
+        input: ssr ? entry : void 0,
+        output: {
+          // Ensure consistent chunk naming
+          chunkFileNames: "chunks/[name]-[hash].js",
+          // Preserve pure annotations
+          generatedCode: {
+            constBindings: true
+          }
+        },
+        // Tree-shaking configuration
+        treeshake: {
+          moduleSideEffects: false,
+          propertyReadSideEffects: false,
+          annotations: true
+        }
+      }
+    },
+    // Resolve configuration
+    resolve: {
+      // Prefer ESM versions of packages
+      mainFields: ["module", "jsnext:main", "jsnext", "main"],
+      extensions: [".ts", ".tsx", ".js", ".jsx", ".json"]
+    },
+    // SSR configuration
+    ...ssr ? {
+      ssr: {
+        noExternal: ["sibu"],
+        target: "node"
+      },
+      build: {
+        outDir,
+        target: "node18",
+        ssr: true,
+        rollupOptions: {
+          input: entry,
+          output: {
+            format: "esm"
+          }
+        }
+      }
+    } : {},
+    // Optimize dependency handling
+    optimizeDeps: {
+      include: ["sibu"],
+      // Force pre-bundling of sibu for faster dev startup
+      force: false
+    },
+    // Environment variable handling
+    define: {
+      __SIBU_SSR__: JSON.stringify(ssr)
+    }
+  };
+  return deepMerge(baseConfig, overrides);
+}
+function deepMerge(target, source2) {
+  const result = { ...target };
+  for (const key of Object.keys(source2)) {
+    if (source2[key] && typeof source2[key] === "object" && !Array.isArray(source2[key]) && target[key] && typeof target[key] === "object" && !Array.isArray(target[key])) {
+      result[key] = deepMerge(target[key], source2[key]);
+    } else {
+      result[key] = source2[key];
+    }
+  }
+  return result;
+}
+
+// src/build/webpack.ts
+var PURE_FACTORIES = [
+  "tagFactory",
+  "context",
+  "composable",
+  "defineComponent",
+  "withProps",
+  "withDefaults",
+  "pure",
+  "noSideEffect"
+];
+function addPureAnnotations(source2) {
+  let result = source2;
+  for (const factory of PURE_FACTORIES) {
+    const pattern2 = new RegExp(`(?<!/\\*#__PURE__\\*/\\s*)\\b(${factory})\\s*\\(`, "g");
+    result = result.replace(pattern2, "/*#__PURE__*/ $1(");
+  }
+  return result;
+}
+function sibuWebpackPlugin(options = {}) {
+  const { pureAnnotations = true, devMode } = options;
+  const isDevMode = devMode ?? (typeof process !== "undefined" && process.env?.NODE_ENV !== "production");
+  return {
+    name: "SibuWebpackPlugin",
+    apply(compiler) {
+      compiler.hooks?.compilation?.tap("SibuWebpackPlugin", (compilation) => {
+        const comp = compilation;
+        if (comp.hooks?.optimizeModules) {
+          comp.hooks.optimizeModules.tap("SibuWebpackPlugin", () => {
+          });
+        }
+      });
+      if (pureAnnotations) {
+        compiler.hooks?.afterEnvironment?.tap("SibuWebpackPlugin", () => {
+          if (!compiler.options.module) {
+            compiler.options.module = { rules: [] };
+          }
+          if (!compiler.options.module.rules) {
+            compiler.options.module.rules = [];
+          }
+          compiler.options.module.rules.push({
+            test: /\.[jt]sx?$/,
+            exclude: /node_modules/,
+            enforce: "pre",
+            use: [
+              {
+                loader: {
+                  // Inline loader function
+                  ident: "sibu-pure-annotations-loader",
+                  loader: "__sibu_inline_loader__",
+                  options: {}
+                }
+              }
+            ]
+          });
+        });
+      }
+      compiler.hooks?.afterResolvers?.tap("SibuWebpackPlugin", () => {
+        if (!compiler.options.resolve) {
+          compiler.options.resolve = {};
+        }
+        if (!compiler.options.resolve.mainFields) {
+          compiler.options.resolve.mainFields = ["module", "main"];
+        }
+        if (!compiler.options.resolve.mainFields.includes("module")) {
+          compiler.options.resolve.mainFields.unshift("module");
+        }
+      });
+      if (isDevMode) {
+        compiler.hooks?.done?.tap("SibuWebpackPlugin", (stats) => {
+          const statsObj = stats;
+          const info = statsObj?.toJson?.({ modules: false, chunks: false });
+          if (info) {
+            console.log(`[SibuWebpackPlugin] Build completed in ${info.time || 0}ms`);
+            const warnings = info.warnings;
+            if (warnings?.length) {
+              console.log(`[SibuWebpackPlugin] ${warnings.length} warning(s)`);
+            }
+          }
+        });
+      }
+      compiler.hooks?.environment?.tap("SibuWebpackPlugin", () => {
+        if (!compiler.options.plugins) {
+          compiler.options.plugins = [];
+        }
+        const defines = {
+          __SIBU_DEV__: JSON.stringify(isDevMode)
+        };
+        compiler.__sibuDefines = defines;
+      });
+    }
+  };
+}
+function createPureAnnotationsLoader() {
+  return function sibuPureAnnotationsLoader(source2) {
+    return addPureAnnotations(source2);
+  };
+}
+function createWebpackConfig(options = {}) {
+  const { entry = "./src/index.ts", outputPath = "dist", mode = "production" } = options;
+  const isDev2 = mode === "development";
+  return {
+    mode,
+    entry,
+    output: {
+      path: outputPath,
+      filename: isDev2 ? "[name].js" : "[name].[contenthash:8].js",
+      chunkFilename: isDev2 ? "[name].chunk.js" : "[name].[contenthash:8].chunk.js",
+      clean: true,
+      // Use ESM output
+      module: true,
+      library: {
+        type: "module"
+      }
+    },
+    // Enable experiments for ESM output
+    experiments: {
+      outputModule: true
+    },
+    resolve: {
+      extensions: [".ts", ".tsx", ".js", ".jsx", ".json"],
+      mainFields: ["module", "main"],
+      alias: {}
+    },
+    module: {
+      rules: [
+        // TypeScript/JavaScript handling
+        {
+          test: /\.[jt]sx?$/,
+          exclude: /node_modules/,
+          use: [
+            {
+              // Users should configure their preferred TS loader
+              // (ts-loader, babel-loader, esbuild-loader, swc-loader)
+              loader: "ts-loader",
+              options: {
+                transpileOnly: true,
+                compilerOptions: {
+                  module: "esnext",
+                  moduleResolution: "node",
+                  target: "es2020"
+                }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    plugins: [
+      // SibuJS plugin for optimizations
+      sibuWebpackPlugin({ devMode: isDev2 })
+    ],
+    optimization: {
+      minimize: !isDev2,
+      // Enable tree-shaking
+      usedExports: true,
+      sideEffects: true,
+      // Split chunks for better caching
+      splitChunks: isDev2 ? false : {
+        chunks: "all",
+        cacheGroups: {
+          // Separate sibu framework code into its own chunk
+          sibu: {
+            test: /[\\/]node_modules[\\/]sibu[\\/]/,
+            name: "sibu",
+            chunks: "all",
+            priority: 20
+          },
+          // Separate other vendor code
+          vendor: {
+            test: /[\\/]node_modules[\\/]/,
+            name: "vendor",
+            chunks: "all",
+            priority: 10
+          }
+        }
+      }
+    },
+    // Source maps
+    devtool: isDev2 ? "eval-cheap-module-source-map" : "source-map",
+    // Dev server configuration
+    devServer: isDev2 ? {
+      hot: true,
+      open: true,
+      port: 3e3,
+      historyApiFallback: true
+    } : void 0,
+    // Performance hints
+    performance: {
+      hints: isDev2 ? false : "warning",
+      maxEntrypointSize: 25e4,
+      maxAssetSize: 25e4
+    },
+    // Cache for faster rebuilds
+    cache: {
+      type: "filesystem",
+      buildDependencies: {
+        config: []
+      }
+    }
+  };
+}
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  DynamicComponent: () => DynamicComponent,
+  ErrorBoundary: () => ErrorBoundary,
+  Fragment: () => Fragment,
+  Loading: () => Loading,
+  Portal: () => Portal,
+  SVG_NS: () => SVG_NS,
+  Suspense: () => Suspense,
+  a: () => a,
+  abbr: () => abbr,
+  address: () => address,
+  area: () => area,
+  array: () => array,
+  article: () => article,
+  aside: () => aside,
+  audio: () => audio,
+  b: () => b,
+  base: () => base,
+  batch: () => batch,
+  bdi: () => bdi,
+  bdo: () => bdo,
+  bindDynamic: () => bindDynamic,
+  blockquote: () => blockquote,
+  body: () => body,
+  br: () => br,
+  button: () => button,
+  canvas: () => canvas,
+  caption: () => caption,
+  catchError: () => catchError,
+  catchErrorAsync: () => catchErrorAsync,
+  center: () => center,
+  checkLeaks: () => checkLeaks,
+  circle: () => circle,
+  cite: () => cite,
+  clipPath: () => clipPath,
+  code: () => code,
+  col: () => col,
+  colgroup: () => colgroup,
+  context: () => context,
+  customElement: () => customElement,
+  data: () => data,
+  datalist: () => datalist,
+  dd: () => dd,
+  deepSignal: () => deepSignal,
+  defs: () => defs,
+  del: () => del,
+  derived: () => derived,
+  details: () => details,
+  dfn: () => dfn,
+  dialog: () => dialog,
+  disableSSR: () => disableSSR,
+  dispose: () => dispose,
+  div: () => div,
+  dl: () => dl,
+  dt: () => dt,
+  each: () => each,
+  effect: () => effect,
+  ellipse: () => ellipse,
+  em: () => em,
+  embed: () => embed,
+  enableSSR: () => enableSSR,
+  enqueueBatchedSignal: () => enqueueBatchedSignal,
+  fieldset: () => fieldset,
+  figcaption: () => figcaption,
+  figure: () => figure,
+  font: () => font,
+  footer: () => footer,
+  form: () => form,
+  g: () => g,
+  getSlot: () => getSlot,
+  h1: () => h1,
+  h2: () => h2,
+  h3: () => h3,
+  h4: () => h4,
+  h5: () => h5,
+  h6: () => h6,
+  head: () => head,
+  header: () => header,
+  hr: () => hr,
+  html: () => html2,
+  i: () => i,
+  iframe: () => iframe,
+  img: () => img,
+  input: () => input,
+  ins: () => ins,
+  isBatching: () => isBatching,
+  isSSR: () => isSSR,
+  kbd: () => kbd,
+  label: () => label,
+  lazy: () => lazy,
+  legend: () => legend,
+  li: () => li,
+  line: () => line,
+  linearGradient: () => linearGradient,
+  link: () => link,
+  main: () => main,
+  map: () => map,
+  mark: () => mark,
+  marker: () => marker,
+  marquee: () => marquee,
+  mask: () => mask,
+  match: () => match,
+  math: () => math,
+  memo: () => memo,
+  memoFn: () => memoFn,
+  menu: () => menu,
+  meta: () => meta,
+  meter: () => meter,
+  mount: () => mount,
+  nav: () => nav,
+  noscript: () => noscript,
+  object: () => object,
+  ol: () => ol,
+  onMount: () => onMount,
+  onUnmount: () => onUnmount,
+  optgroup: () => optgroup,
+  option: () => option,
+  output: () => output,
+  p: () => p,
+  param: () => param,
+  path: () => path,
+  pattern: () => pattern,
+  picture: () => picture,
+  polygon: () => polygon,
+  polyline: () => polyline,
+  portal: () => portal,
+  pre: () => pre,
+  progress: () => progress,
+  q: () => q,
+  radialGradient: () => radialGradient,
+  reactiveArray: () => reactiveArray,
+  rect: () => rect,
+  ref: () => ref,
+  registerComponent: () => registerComponent,
+  registerDisposer: () => registerDisposer,
+  resolveComponent: () => resolveComponent,
+  rp: () => rp,
+  rt: () => rt,
+  ruby: () => ruby,
+  s: () => s,
+  samp: () => samp,
+  script: () => script,
+  section: () => section,
+  select: () => select,
+  setGlobalErrorHandler: () => setGlobalErrorHandler,
+  show: () => show,
+  signal: () => signal,
+  slot: () => slot,
+  small: () => small,
+  source: () => source,
+  span: () => span,
+  stop: () => stop,
+  store: () => store,
+  strong: () => strong,
+  style: () => style,
+  sub: () => sub,
+  summary: () => summary,
+  sup: () => sup,
+  svg: () => svg,
+  symbol: () => symbol,
+  table: () => table,
+  tagFactory: () => tagFactory,
+  tbody: () => tbody,
+  td: () => td,
+  template: () => template,
+  text: () => text,
+  textarea: () => textarea,
+  tfoot: () => tfoot,
+  th: () => th,
+  thead: () => thead,
+  time: () => time,
+  title: () => title,
+  tr: () => tr,
+  track: () => track2,
+  tspan: () => tspan,
+  u: () => u,
+  ul: () => ul,
+  unregisterComponent: () => unregisterComponent,
+  use: () => use,
+  var_: () => var_,
+  video: () => video,
+  watch: () => watch,
+  when: () => when,
+  withSSR: () => withSSR
+});
+
+// src/utils/sanitize.ts
+function sanitize(value) {
+  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function sanitizeUrl(url) {
+  const trimmed = url.replace(/[\x00-\x20\x7f-\x9f]+/g, "").trim();
+  if (!trimmed) return "";
+  const lower = trimmed.toLowerCase();
+  if (lower.startsWith("javascript:") || lower.startsWith("data:") || lower.startsWith("vbscript:") || lower.startsWith("blob:")) {
+    return "";
+  }
+  return trimmed;
+}
+var URL_ATTRIBUTES = /* @__PURE__ */ new Set(["href", "src", "action", "formaction", "cite", "poster", "background", "srcset"]);
+function isUrlAttribute(attr) {
+  return URL_ATTRIBUTES.has(attr);
+}
+function sanitizeAttribute(attr, value) {
+  if (isUrlAttribute(attr)) {
+    return sanitizeUrl(value);
+  }
+  return sanitize(value);
+}
+
+// src/reactivity/track.ts
+var subscriberStack = [];
+var currentSubscriber = null;
+var signalSubscribers = /* @__PURE__ */ new WeakMap();
+var SUBS = "__s";
+var notifyDepth = 0;
+var pendingQueue = [];
+var pendingSet = /* @__PURE__ */ new Set();
+var suspendDepth = 0;
+var trackingSuspended = false;
+function track(effectFn, subscriber) {
+  if (!subscriber) subscriber = effectFn;
+  cleanup(subscriber);
+  subscriberStack.push(subscriber);
+  currentSubscriber = subscriber;
+  effectFn();
+  subscriberStack.pop();
+  currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+  return () => cleanup(subscriber);
+}
+function suspendTracking() {
+  if (suspendDepth === 0) {
+    subscriberStack.push(null);
+    currentSubscriber = null;
+    trackingSuspended = true;
+  }
+  suspendDepth++;
+}
+function resumeTracking() {
+  suspendDepth--;
+  if (suspendDepth === 0) {
+    subscriberStack.pop();
+    currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+    trackingSuspended = false;
+  }
+}
+function recordDependency(signal2) {
+  if (!currentSubscriber) return;
+  let deps = currentSubscriber._deps;
+  if (!deps) {
+    deps = /* @__PURE__ */ new Set();
+    currentSubscriber._deps = deps;
+  }
+  if (!deps.has(signal2)) {
+    deps.add(signal2);
+    let subs = signal2[SUBS];
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      signalSubscribers.set(signal2, subs);
+      signal2[SUBS] = subs;
+    }
+    subs.add(currentSubscriber);
+    if (subs.size === 1) {
+      signal2.__f = currentSubscriber;
+    } else if (signal2.__f !== void 0) {
+      signal2.__f = void 0;
+    }
+  }
+}
+function queueSignalNotification(signal2) {
+  const subs = signal2[SUBS];
+  if (!subs) return;
+  for (const sub2 of subs) {
+    if (sub2._c) {
+      propagateDirty(sub2);
+    } else if (!pendingSet.has(sub2)) {
+      pendingSet.add(sub2);
+      pendingQueue.push(sub2);
+    }
+  }
+}
+function drainNotificationQueue() {
+  if (notifyDepth > 0) return;
+  notifyDepth++;
+  try {
+    let i2 = 0;
+    while (i2 < pendingQueue.length) {
+      pendingQueue[i2]();
+      i2++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function propagateDirty(sub2) {
+  sub2();
+  let sig = sub2._sig;
+  let suspended = false;
+  if (sig && sig._g) {
+    const sDeps = sub2._deps;
+    if (sDeps && sDeps.size === 1) {
+      suspendTracking();
+      suspended = true;
+      const s2 = sig;
+      s2._d = false;
+      s2._v = s2._g();
+    }
+  }
+  while (sig) {
+    const first = sig.__f;
+    if (first) {
+      if (first._c) {
+        const nSig = first._sig;
+        nSig._d = true;
+        if (suspended && nSig._g) {
+          const fDeps = first._deps;
+          if (fDeps && fDeps.size === 1) {
+            nSig._d = false;
+            nSig._v = nSig._g();
+          }
+        }
+        sig = nSig;
+        continue;
+      }
+      if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      break;
+    }
+    const subs = sig[SUBS];
+    if (!subs) break;
+    let nextSig;
+    for (const s2 of subs) {
+      if (s2._c) {
+        s2();
+        const nSig = s2._sig;
+        if (nSig && !nextSig) {
+          nextSig = nSig;
+        } else if (nSig) {
+          propagateDirty(s2);
+        }
+      } else if (!pendingSet.has(s2)) {
+        pendingSet.add(s2);
+        pendingQueue.push(s2);
+      }
+    }
+    sig = nextSig;
+  }
+  if (suspended) resumeTracking();
+}
+function notifySubscribers(signal2) {
+  const first = signal2.__f;
+  if (first) {
+    if (notifyDepth > 0) {
+      if (first._c) {
+        propagateDirty(first);
+      } else if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      return;
+    }
+    notifyDepth++;
+    try {
+      if (first._c) {
+        propagateDirty(first);
+      } else {
+        first();
+      }
+      let i2 = 0;
+      while (i2 < pendingQueue.length) {
+        pendingQueue[i2]();
+        i2++;
+      }
+    } finally {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+      notifyDepth--;
+    }
+    return;
+  }
+  const subs = signal2[SUBS];
+  if (!subs || subs.size === 0) return;
+  if (notifyDepth > 0) {
+    for (const sub2 of subs) {
+      if (sub2._c) {
+        propagateDirty(sub2);
+      } else if (!pendingSet.has(sub2)) {
+        pendingSet.add(sub2);
+        pendingQueue.push(sub2);
+      }
+    }
+    return;
+  }
+  notifyDepth++;
+  try {
+    let directCount = 0;
+    for (const sub2 of subs) {
+      pendingQueue[directCount++] = sub2;
+    }
+    for (let i3 = 0; i3 < directCount; i3++) {
+      if (pendingQueue[i3]._c) {
+        propagateDirty(pendingQueue[i3]);
+      }
+    }
+    for (let i3 = 0; i3 < directCount; i3++) {
+      if (!pendingQueue[i3]._c) {
+        if (!pendingSet.has(pendingQueue[i3])) {
+          pendingQueue[i3]();
+        }
+      }
+    }
+    let i2 = directCount;
+    while (i2 < pendingQueue.length) {
+      pendingQueue[i2]();
+      i2++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function cleanup(subscriber) {
+  const deps = subscriber._deps;
+  if (!deps || deps.size === 0) return;
+  for (const signal2 of deps) {
+    const subs = signal2[SUBS];
+    if (subs) {
+      subs.delete(subscriber);
+      if (signal2.__f === subscriber) {
+        signal2.__f = void 0;
+      }
+    }
+  }
+  deps.clear();
+}
+
+// src/reactivity/bindAttribute.ts
+function bindAttribute(el, attr, getter) {
+  function commit() {
+    let value;
+    try {
+      value = getter();
+    } catch {
+      return;
+    }
+    if (typeof value === "boolean") {
+      if (attr in el && (attr === "checked" || attr === "disabled" || attr === "selected")) {
+        el[attr] = value;
+      } else if (value) {
+        el.setAttribute(attr, "");
+      } else {
+        el.removeAttribute(attr);
+      }
+      return;
+    }
+    const str = sanitizeAttribute(attr, String(value));
+    if ((attr === "value" || attr === "checked") && attr in el) {
+      el[attr] = attr === "checked" ? Boolean(value) : str;
+    } else {
+      el.setAttribute(attr, str);
+    }
+  }
+  const teardown = track(commit);
+  return teardown;
+}
+function bindDynamic(el, nameGetter, valueGetter) {
+  let prevName = null;
+  function commit() {
+    let name;
+    try {
+      name = typeof nameGetter === "function" ? nameGetter() : nameGetter;
+    } catch {
+      return;
+    }
+    let value;
+    try {
+      value = typeof valueGetter === "function" ? valueGetter() : valueGetter;
+    } catch {
+      return;
+    }
+    if (name.toLowerCase().startsWith("on")) return;
+    if (prevName !== null && prevName !== name) {
+      el.removeAttribute(prevName);
+    }
+    const str = sanitizeAttribute(name, String(value));
+    if ((name === "value" || name === "checked") && name in el) {
+      el[name] = name === "checked" ? Boolean(value) : str;
+    } else {
+      el.setAttribute(name, str);
+    }
+    prevName = name;
+  }
+  const teardown = track(commit);
+  return () => {
+    teardown();
+    if (prevName !== null) {
+      el.removeAttribute(prevName);
+    }
+  };
+}
+
+// src/reactivity/bindChildNode.ts
+function bindChildNode(placeholder, getter) {
+  let lastNodes = [];
+  function commit() {
+    let result;
+    try {
+      result = getter();
+    } catch {
+      return;
+    }
+    for (const node of lastNodes) {
+      node.parentNode?.removeChild(node);
+    }
+    lastNodes = [];
+    if (result == null) return;
+    const parent = placeholder.parentNode;
+    if (!parent) return;
+    const anchor = placeholder.nextSibling;
+    const newNodes = [];
+    const insertItem = (item) => {
+      const node = item instanceof Node ? item : document.createTextNode(String(item));
+      parent.insertBefore(node, anchor);
+      newNodes.push(node);
+    };
+    if (Array.isArray(result)) {
+      for (const item of result) insertItem(item);
+    } else {
+      insertItem(result);
+    }
+    lastNodes = newNodes;
+  }
+  return track(commit);
+}
+
+// src/core/dev.ts
+function isDev() {
+  return typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : true;
+}
+function devAssert(condition, message) {
+  if (isDev() && !condition) {
+    throw new Error(`[Sibu] ${message}`);
+  }
+}
+function devWarn(message) {
+  if (isDev()) {
+    console.warn(`[Sibu] ${message}`);
+  }
+}
+
+// src/core/rendering/dispose.ts
+var elementDisposers = /* @__PURE__ */ new WeakMap();
+var activeBindingCount = 0;
+function registerDisposer(node, teardown) {
+  let disposers = elementDisposers.get(node);
+  if (!disposers) {
+    disposers = [];
+    elementDisposers.set(node, disposers);
+  }
+  disposers.push(teardown);
+  activeBindingCount++;
+}
+function dispose(node) {
+  const children = node.childNodes;
+  for (const child of children) {
+    dispose(child);
+  }
+  const disposers = elementDisposers.get(node);
+  if (disposers) {
+    activeBindingCount -= disposers.length;
+    for (const d of disposers) d();
+    elementDisposers.delete(node);
+  }
+}
+function checkLeaks(warnThreshold = 0) {
+  if (activeBindingCount > warnThreshold) {
+    devWarn(
+      `checkLeaks: ${activeBindingCount} active DOM bindings detected. Expected \u2264${warnThreshold}. This may indicate a component was removed from the DOM without calling dispose().`
+    );
+  }
+  return activeBindingCount;
+}
+
+// src/core/rendering/tagFactory.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var kebabCache = /* @__PURE__ */ new Map();
+function toKebab(prop) {
+  let cached = kebabCache.get(prop);
+  if (cached !== void 0) return cached;
+  cached = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+  kebabCache.set(prop, cached);
+  return cached;
+}
+function applyStyle(el, style2) {
+  if (!style2) return;
+  if (typeof style2 === "function") {
+    const teardown = track(() => {
+      el.setAttribute("style", style2());
+    });
+    registerDisposer(el, teardown);
+    return;
+  }
+  if (typeof style2 === "string") {
+    el.setAttribute("style", style2);
+    return;
+  }
+  const htmlEl = el;
+  for (const prop in style2) {
+    const val = style2[prop];
+    const name = toKebab(prop);
+    if (typeof val === "function") {
+      const getter = val;
+      const teardown = track(() => {
+        htmlEl.style.setProperty(name, String(getter()));
+      });
+      registerDisposer(el, teardown);
+    } else {
+      htmlEl.style.setProperty(name, String(val));
+    }
+  }
+}
+function applyClass(el, cls) {
+  if (cls == null) return;
+  if (typeof cls === "string") {
+    el.setAttribute("class", cls);
+    return;
+  }
+  if (typeof cls === "function") {
+    const getter = cls;
+    const teardown = track(() => {
+      el.setAttribute("class", getter());
+    });
+    registerDisposer(el, teardown);
+    return;
+  }
+  if (typeof cls === "object") {
+    const obj = cls;
+    let hasReactive = false;
+    for (const name in obj) {
+      if (typeof obj[name] === "function") {
+        hasReactive = true;
+        break;
+      }
+    }
+    if (hasReactive) {
+      const update = () => {
+        let result = "";
+        for (const name in obj) {
+          const val = obj[name];
+          const active = typeof val === "function" ? val() : val;
+          if (active) result = result ? `${result} ${name}` : name;
+        }
+        el.setAttribute("class", result);
+      };
+      const teardown = track(update);
+      registerDisposer(el, teardown);
+    } else {
+      let result = "";
+      for (const name in obj) {
+        if (obj[name]) result = result ? `${result} ${name}` : name;
+      }
+      el.setAttribute("class", result);
+    }
+  }
+}
+function renderChild(child) {
+  if (child == null) {
+    return document.createTextNode("");
+  }
+  if (child instanceof Node) {
+    return child;
+  }
+  return document.createTextNode(String(child));
+}
+function appendOneChild(el, child) {
+  if (typeof child === "function") {
+    const placeholder = document.createComment("bind:child");
+    el.appendChild(placeholder);
+    const teardown = bindChildNode(placeholder, child);
+    registerDisposer(el, teardown);
+  } else {
+    el.appendChild(renderChild(child));
+  }
+}
+function appendChildren(el, nodes) {
+  if (Array.isArray(nodes)) {
+    for (let i2 = 0; i2 < nodes.length; i2++) {
+      const c = nodes[i2];
+      if (Array.isArray(c)) {
+        for (let j = 0; j < c.length; j++) {
+          appendOneChild(el, c[j]);
+        }
+      } else {
+        appendOneChild(el, c);
+      }
+    }
+  } else {
+    appendOneChild(el, nodes);
+  }
+}
+function isTagProps(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Node);
+}
+var tagFactory = (tag, ns) => (first, second) => {
+  let props;
+  if (first === void 0) {
+    props = {};
+  } else if (isTagProps(first)) {
+    props = first;
+  } else if (second !== void 0) {
+    props = { class: first, nodes: second };
+  } else {
+    props = { nodes: first };
+  }
+  const el = ns ? document.createElementNS(ns, tag) : document.createElement(tag);
+  for (const key in props) {
+    const value = props[key];
+    if (value == null) continue;
+    switch (key) {
+      case "id":
+        el.id = value;
+        break;
+      case "class":
+        applyClass(el, value);
+        break;
+      case "style":
+        applyStyle(el, value);
+        break;
+      case "ref":
+        if (value && typeof value === "object" && "current" in value) {
+          value.current = el;
+        }
+        break;
+      case "on": {
+        const handlers = value;
+        const eventNames = [];
+        for (const ev in handlers) {
+          el.addEventListener(ev, handlers[ev]);
+          eventNames.push(ev);
+        }
+        if (eventNames.length) {
+          el.__sibu_events__ = eventNames;
+        }
+        break;
+      }
+      case "nodes":
+        appendChildren(el, value);
+        break;
+      default:
+        if (key.toLowerCase().startsWith("on")) break;
+        if (typeof value === "function") {
+          const teardown = bindAttribute(el, key, value);
+          registerDisposer(el, teardown);
+        } else if (typeof value === "boolean") {
+          if (value) el.setAttribute(key, "");
+          else el.removeAttribute(key);
+        } else {
+          el.setAttribute(key, sanitizeAttribute(key, String(value)));
+        }
+    }
+  }
+  return el;
+};
+
+// src/core/rendering/html.ts
+var html = tagFactory("html");
+var head = tagFactory("head");
+var body = tagFactory("body");
+var title = tagFactory("title");
+var div = tagFactory("div");
+var span = tagFactory("span");
+var section = tagFactory("section");
+var article = tagFactory("article");
+var header = tagFactory("header");
+var footer = tagFactory("footer");
+var nav = tagFactory("nav");
+var main = tagFactory("main");
+var aside = tagFactory("aside");
+var address = tagFactory("address");
+var p = tagFactory("p");
+var h1 = tagFactory("h1");
+var h2 = tagFactory("h2");
+var h3 = tagFactory("h3");
+var h4 = tagFactory("h4");
+var h5 = tagFactory("h5");
+var h6 = tagFactory("h6");
+var blockquote = tagFactory("blockquote");
+var dd = tagFactory("dd");
+var dl = tagFactory("dl");
+var dt = tagFactory("dt");
+var figcaption = tagFactory("figcaption");
+var figure = tagFactory("figure");
+var hr = tagFactory("hr");
+var li = tagFactory("li");
+var ol = tagFactory("ol");
+var ul = tagFactory("ul");
+var pre = tagFactory("pre");
+var a = tagFactory("a");
+var abbr = tagFactory("abbr");
+var b = tagFactory("b");
+var bdi = tagFactory("bdi");
+var bdo = tagFactory("bdo");
+var br = tagFactory("br");
+var cite = tagFactory("cite");
+var code = tagFactory("code");
+var data = tagFactory("data");
+var dfn = tagFactory("dfn");
+var em = tagFactory("em");
+var i = tagFactory("i");
+var kbd = tagFactory("kbd");
+var mark = tagFactory("mark");
+var q = tagFactory("q");
+var rp = tagFactory("rp");
+var rt = tagFactory("rt");
+var ruby = tagFactory("ruby");
+var s = tagFactory("s");
+var samp = tagFactory("samp");
+var small = tagFactory("small");
+var strong = tagFactory("strong");
+var sub = tagFactory("sub");
+var sup = tagFactory("sup");
+var time = tagFactory("time");
+var u = tagFactory("u");
+var var_ = tagFactory("var");
+var area = tagFactory("area");
+var audio = tagFactory("audio");
+var img = tagFactory("img");
+var map = tagFactory("map");
+var track2 = tagFactory("track");
+var video = tagFactory("video");
+var embed = tagFactory("embed");
+var iframe = tagFactory("iframe");
+var object = tagFactory("object");
+var param = tagFactory("param");
+var picture = tagFactory("picture");
+var portal = tagFactory("portal");
+var source = tagFactory("source");
+var svg = tagFactory("svg", SVG_NS);
+var math = tagFactory("math");
+var canvas = tagFactory("canvas");
+var noscript = tagFactory("noscript");
+var script = tagFactory("script");
+var del = tagFactory("del");
+var ins = tagFactory("ins");
+var caption = tagFactory("caption");
+var col = tagFactory("col");
+var colgroup = tagFactory("colgroup");
+var table = tagFactory("table");
+var tbody = tagFactory("tbody");
+var td = tagFactory("td");
+var tfoot = tagFactory("tfoot");
+var th = tagFactory("th");
+var thead = tagFactory("thead");
+var tr = tagFactory("tr");
+var button = tagFactory("button");
+var datalist = tagFactory("datalist");
+var fieldset = tagFactory("fieldset");
+var form = tagFactory("form");
+var input = tagFactory("input");
+var label = tagFactory("label");
+var legend = tagFactory("legend");
+var meter = tagFactory("meter");
+var optgroup = tagFactory("optgroup");
+var option = tagFactory("option");
+var output = tagFactory("output");
+var progress = tagFactory("progress");
+var select = tagFactory("select");
+var textarea = tagFactory("textarea");
+var details = tagFactory("details");
+var dialog = tagFactory("dialog");
+var menu = tagFactory("menu");
+var summary = tagFactory("summary");
+var slot = tagFactory("slot");
+var template = tagFactory("template");
+var base = tagFactory("base");
+var link = tagFactory("link");
+var meta = tagFactory("meta");
+var style = tagFactory("style");
+var circle = tagFactory("circle", SVG_NS);
+var ellipse = tagFactory("ellipse", SVG_NS);
+var g = tagFactory("g", SVG_NS);
+var line = tagFactory("line", SVG_NS);
+var path = tagFactory("path", SVG_NS);
+var polygon = tagFactory("polygon", SVG_NS);
+var polyline = tagFactory("polyline", SVG_NS);
+var rect = tagFactory("rect", SVG_NS);
+var text = tagFactory("text", SVG_NS);
+var tspan = tagFactory("tspan", SVG_NS);
+var defs = tagFactory("defs", SVG_NS);
+var clipPath = tagFactory("clipPath", SVG_NS);
+var mask = tagFactory("mask", SVG_NS);
+var pattern = tagFactory("pattern", SVG_NS);
+var linearGradient = tagFactory("linearGradient", SVG_NS);
+var radialGradient = tagFactory("radialGradient", SVG_NS);
+var stop = tagFactory("stop", SVG_NS);
+var use = tagFactory("use", SVG_NS);
+var symbol = tagFactory("symbol", SVG_NS);
+var marker = tagFactory("marker", SVG_NS);
+var center = tagFactory("center");
+var font = tagFactory("font");
+var marquee = tagFactory("marquee");
+var customElement = (tagName) => tagFactory(tagName);
+
+// src/core/rendering/htm.ts
+var VOID_ELEMENTS3 = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var SVG_TAGS2 = /* @__PURE__ */ new Set([
+  "svg",
+  "circle",
+  "ellipse",
+  "g",
+  "line",
+  "path",
+  "polygon",
+  "polyline",
+  "rect",
+  "text",
+  "tspan",
+  "defs",
+  "clipPath",
+  "mask",
+  "pattern",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "use",
+  "symbol",
+  "marker"
+]);
+var cache = /* @__PURE__ */ new WeakMap();
+function parseTemplate(strings) {
+  const exprCount = strings.length - 1;
+  let template2 = strings[0];
+  for (let i2 = 0; i2 < exprCount; i2++) {
+    template2 += `\0${i2}\0${strings[i2 + 1]}`;
+  }
+  let pos = 0;
+  const len = template2.length;
+  function skipWs() {
+    while (pos < len && (template2[pos] === " " || template2[pos] === "	" || template2[pos] === "\n" || template2[pos] === "\r"))
+      pos++;
+  }
+  function tryExprIdx() {
+    if (template2[pos] !== "\0") return -1;
+    const start = pos;
+    pos++;
+    let idxStr = "";
+    while (pos < len && template2[pos] !== "\0") idxStr += template2[pos++];
+    if (pos < len) pos++;
+    const idx = Number.parseInt(idxStr, 10);
+    if (Number.isNaN(idx) || idx < 0 || idx >= exprCount) {
+      pos = start;
+      return -1;
+    }
+    return idx;
+  }
+  function readTagName() {
+    let name = "";
+    while (pos < len && /[a-zA-Z0-9-]/.test(template2[pos])) name += template2[pos++];
+    return name;
+  }
+  function parseAttrValue() {
+    skipWs();
+    if (template2[pos] !== "=") return { kind: "bool" };
+    pos++;
+    skipWs();
+    const exprIdx = tryExprIdx();
+    if (exprIdx >= 0) return { kind: "expr", idx: exprIdx };
+    const quote = template2[pos];
+    if (quote === '"' || quote === "'") {
+      pos++;
+      const statics = [];
+      const exprs = [];
+      let current = "";
+      while (pos < len && template2[pos] !== quote) {
+        const innerIdx = tryExprIdx();
+        if (innerIdx >= 0) {
+          statics.push(current);
+          current = "";
+          exprs.push(innerIdx);
+        } else {
+          current += template2[pos++];
+        }
+      }
+      if (pos < len) pos++;
+      statics.push(current);
+      if (exprs.length === 0) {
+        return { kind: "static", value: statics[0] };
+      }
+      return { kind: "mixed", statics, exprs };
+    }
+    let val = "";
+    while (pos < len && !/[\s>/]/.test(template2[pos])) val += template2[pos++];
+    return { kind: "static", value: val };
+  }
+  function parseAttrs() {
+    const attrs = [];
+    while (pos < len) {
+      skipWs();
+      if (template2[pos] === ">" || template2[pos] === "/") break;
+      let attrName = "";
+      while (pos < len && /[a-zA-Z0-9\-:_.]/.test(template2[pos])) attrName += template2[pos++];
+      if (!attrName) break;
+      const val = parseAttrValue();
+      if (attrName.startsWith("on:")) {
+        if (val.kind === "expr") {
+          attrs.push({ t: 3, name: attrName.slice(3), idx: val.idx });
+        }
+      } else if (val.kind === "bool") {
+        attrs.push({ t: 4, name: attrName });
+      } else if (val.kind === "static") {
+        attrs.push({ t: 0, name: attrName, value: val.value });
+      } else if (val.kind === "expr") {
+        attrs.push({ t: 1, name: attrName, idx: val.idx });
+      } else if (val.kind === "mixed") {
+        attrs.push({ t: 2, name: attrName, statics: val.statics, exprs: val.exprs });
+      }
+    }
+    return attrs;
+  }
+  function collapseWs(s2) {
+    return s2.replace(/\s+/g, " ");
+  }
+  function parseTextChildren(children) {
+    let text2 = "";
+    while (pos < len && template2[pos] !== "<") {
+      const idx = tryExprIdx();
+      if (idx >= 0) {
+        const collapsed2 = collapseWs(text2);
+        if (collapsed2) children.push({ t: 1, value: collapsed2 });
+        text2 = "";
+        children.push({ t: 2, idx });
+      } else {
+        text2 += template2[pos++];
+      }
+    }
+    const collapsed = collapseWs(text2);
+    if (collapsed) children.push({ t: 1, value: collapsed });
+  }
+  function parseChildren() {
+    const children = [];
+    while (pos < len) {
+      if (template2[pos] === "<" && pos + 1 < len && template2[pos + 1] === "/") break;
+      if (template2[pos] === "<") {
+        pos++;
+        const tag = readTagName();
+        const attrs = parseAttrs();
+        skipWs();
+        const isVoid = VOID_ELEMENTS3.has(tag);
+        const isSelfClosing = template2[pos] === "/";
+        if (isSelfClosing) pos++;
+        if (pos < len) pos++;
+        if (isVoid || isSelfClosing) {
+          children.push({ t: 0, el: { tag, svg: SVG_TAGS2.has(tag), attrs, children: [] } });
+        } else {
+          const inner = parseChildren();
+          if (template2[pos] === "<" && pos + 1 < len && template2[pos + 1] === "/") {
+            pos += 2;
+            readTagName();
+            skipWs();
+            if (pos < len && template2[pos] === ">") pos++;
+          }
+          children.push({ t: 0, el: { tag, svg: SVG_TAGS2.has(tag), attrs, children: inner } });
+        }
+      } else {
+        parseTextChildren(children);
+      }
+    }
+    return children;
+  }
+  return parseChildren();
+}
+var factoryCache = /* @__PURE__ */ new Map();
+function getFactory(tag, svg2) {
+  const key = svg2 ? `svg:${tag}` : tag;
+  let f = factoryCache.get(key);
+  if (!f) {
+    f = tagFactory(tag, svg2 ? SVG_NS : void 0);
+    factoryCache.set(key, f);
+  }
+  return f;
+}
+function executeElement(tmpl, values) {
+  const props = {};
+  const events = {};
+  let hasEvents = false;
+  for (let i2 = 0; i2 < tmpl.attrs.length; i2++) {
+    const attr = tmpl.attrs[i2];
+    switch (attr.t) {
+      case 0:
+        props[attr.name] = attr.value;
+        break;
+      case 1:
+        props[attr.name] = values[attr.idx];
+        break;
+      case 2: {
+        let val = attr.statics[0];
+        for (let j = 0; j < attr.exprs.length; j++) {
+          val += String(values[attr.exprs[j]]) + attr.statics[j + 1];
+        }
+        props[attr.name] = val;
+        break;
+      }
+      case 3:
+        events[attr.name] = values[attr.idx];
+        hasEvents = true;
+        break;
+      case 4:
+        props[attr.name] = true;
+        break;
+    }
+  }
+  if (hasEvents) props.on = events;
+  if (tmpl.children.length > 0) {
+    const nodes = executeChildList(tmpl.children, values);
+    props.nodes = nodes.length === 1 ? nodes[0] : nodes;
+  }
+  return getFactory(tmpl.tag, tmpl.svg)(props);
+}
+function executeChildList(children, values) {
+  const nodes = [];
+  for (let i2 = 0; i2 < children.length; i2++) {
+    const child = children[i2];
+    switch (child.t) {
+      case 0:
+        nodes.push(executeElement(child.el, values));
+        break;
+      case 1:
+        nodes.push(child.value);
+        break;
+      case 2:
+        nodes.push(values[child.idx]);
+        break;
+    }
+  }
+  return nodes;
+}
+function html2(strings, ...values) {
+  let tmpl = cache.get(strings);
+  if (!tmpl) {
+    tmpl = parseTemplate(strings);
+    cache.set(strings, tmpl);
+  }
+  const result = executeChildList(tmpl, values);
+  if (result.length === 1 && result[0] instanceof Node) {
+    return result[0];
+  }
+  const wrapper = document.createElement("div");
+  for (const node of result) {
+    if (node instanceof Node) {
+      wrapper.appendChild(node);
+    } else if (typeof node === "function") {
+      const placeholder = document.createComment("bind:htm");
+      wrapper.appendChild(placeholder);
+      const teardown = bindChildNode(placeholder, node);
+      registerDisposer(wrapper, teardown);
+    } else if (node != null) {
+      wrapper.appendChild(document.createTextNode(String(node)));
+    }
+  }
+  return wrapper;
+}
+
+// src/core/rendering/mount.ts
+function mount(component, container) {
+  if (!container) {
+    throw new Error(
+      "[Sibu] mount: container element not found. Make sure the DOM element exists before calling mount()."
+    );
+  }
+  devAssert(
+    typeof component === "function" || component instanceof Node,
+    "mount: first argument must be a component function or a DOM Node."
+  );
+  const startTime = typeof performance !== "undefined" ? performance.now() : 0;
+  const node = typeof component === "function" ? component() : component;
+  const duration = typeof performance !== "undefined" ? performance.now() - startTime : 0;
+  container.appendChild(node);
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook) {
+    hook.emit("app:init", { rootElement: node, container, duration });
+  }
+  return {
+    node,
+    unmount() {
+      if (hook) hook.emit("app:unmount", { rootElement: node });
+      dispose(node);
+      if (node.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    }
+  };
+}
+
+// src/core/rendering/each.ts
+function resolveNodeChild(child) {
+  if (typeof child === "function") {
+    return resolveNodeChild(child());
+  }
+  if (child instanceof Node) {
+    return child;
+  }
+  return document.createTextNode(String(child));
+}
+function longestIncreasingSubsequence(arr, len) {
+  if (len === 0) return [];
+  const tails = [];
+  const predecessor = new Array(len);
+  for (let i2 = 0; i2 < len; i2++) {
+    const val = arr[i2];
+    let lo = 0;
+    let hi = tails.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (arr[tails[mid]] < val) {
+        lo = mid + 1;
+      } else {
+        hi = mid;
+      }
+    }
+    tails[lo] = i2;
+    predecessor[i2] = lo > 0 ? tails[lo - 1] : -1;
+  }
+  const lisLength = tails.length;
+  const result = new Array(lisLength);
+  let k = tails[lisLength - 1];
+  for (let i2 = lisLength - 1; i2 >= 0; i2--) {
+    result[i2] = k;
+    k = predecessor[k];
+  }
+  return result;
+}
+function each(getArray, render, options) {
+  devAssert(typeof getArray === "function", "each: first argument must be a function that returns an array.");
+  devAssert(typeof render === "function", "each: second argument must be a render function.");
+  devAssert(
+    options && typeof options.key === "function",
+    "each: options.key must be a function that returns a unique key per item."
+  );
+  const anchor = document.createComment("each:anchor");
+  const end = document.createComment("each:end");
+  let oldKeys = [];
+  let nodeMap = /* @__PURE__ */ new Map();
+  let workMap = /* @__PURE__ */ new Map();
+  let newNodes = [];
+  const oldKeyIndex = /* @__PURE__ */ new Map();
+  let reusedNewBuf = [];
+  let reusedOldBuf = [];
+  let initialized = false;
+  let sentinelInserted = false;
+  const keyFn = options.key;
+  const update = () => {
+    const arr = getArray();
+    const newLen = arr.length;
+    const parent = anchor.parentNode;
+    if (!parent) return;
+    if (!sentinelInserted) {
+      parent.insertBefore(end, anchor.nextSibling);
+      sentinelInserted = true;
+    }
+    const newKeys = new Array(newLen);
+    for (let i2 = 0; i2 < newLen; i2++) {
+      newKeys[i2] = keyFn(arr[i2]);
+    }
+    if (newNodes.length < newLen) {
+      newNodes = new Array(newLen);
+    }
+    workMap.clear();
+    for (let i2 = 0; i2 < newLen; i2++) {
+      const key = newKeys[i2];
+      const existing = nodeMap.get(key);
+      let node;
+      if (existing !== void 0) {
+        node = existing;
+      } else {
+        node = resolveNodeChild(render(arr[i2], i2));
+      }
+      workMap.set(key, node);
+      newNodes[i2] = node;
+    }
+    for (const [key, node] of nodeMap) {
+      if (!workMap.has(key) && node.parentNode) {
+        parent.removeChild(node);
+      }
+    }
+    if (newLen === 0) {
+      oldKeys = newKeys;
+      const tmp2 = nodeMap;
+      nodeMap = workMap;
+      workMap = tmp2;
+      return;
+    }
+    const oldLen = oldKeys.length;
+    oldKeyIndex.clear();
+    for (let i2 = 0; i2 < oldLen; i2++) {
+      oldKeyIndex.set(oldKeys[i2], i2);
+    }
+    if (reusedNewBuf.length < newLen) {
+      reusedNewBuf = new Array(newLen);
+      reusedOldBuf = new Array(newLen);
+    }
+    let reusedCount = 0;
+    for (let i2 = 0; i2 < newLen; i2++) {
+      const oldIdx = oldKeyIndex.get(newKeys[i2]);
+      if (oldIdx !== void 0) {
+        reusedNewBuf[reusedCount] = i2;
+        reusedOldBuf[reusedCount] = oldIdx;
+        reusedCount++;
+      }
+    }
+    const lisIndices = longestIncreasingSubsequence(reusedOldBuf, reusedCount);
+    const isStable = new Uint8Array(newLen);
+    for (let i2 = 0; i2 < lisIndices.length; i2++) {
+      isStable[reusedNewBuf[lisIndices[i2]]] = 1;
+    }
+    let nextRef = end;
+    for (let i2 = newLen - 1; i2 >= 0; i2--) {
+      const node = newNodes[i2];
+      if (isStable[i2]) {
+        nextRef = node;
+      } else {
+        if (node.nextSibling !== nextRef) {
+          parent.insertBefore(node, nextRef);
+        }
+        nextRef = node;
+      }
+    }
+    oldKeys = newKeys;
+    const tmp = nodeMap;
+    nodeMap = workMap;
+    workMap = tmp;
+    initialized = true;
+  };
+  track(update);
+  if (!initialized) {
+    queueMicrotask(() => {
+      if (!initialized && anchor.parentNode) {
+        update();
+      }
+    });
+  }
+  return anchor;
+}
+
+// src/core/rendering/fragment.ts
+function Fragment(nodes) {
+  const frag = document.createDocumentFragment();
+  for (const child of nodes) {
+    if (child == null) continue;
+    if (Array.isArray(child)) {
+      for (const nested of child) {
+        frag.appendChild(resolveChild(nested));
+      }
+    } else {
+      frag.appendChild(resolveChild(child));
+    }
+  }
+  return frag;
+}
+function resolveChild(child) {
+  if (child == null) {
+    return document.createTextNode("");
+  }
+  if (child instanceof Node) {
+    return child;
+  }
+  if (typeof child === "function") {
+    const result = child();
+    if (result instanceof Node) return result;
+    return document.createTextNode(String(result ?? ""));
+  }
+  return document.createTextNode(String(child));
+}
+
+// src/core/rendering/portal.ts
+function Portal(nodes, target) {
+  const anchor = document.createComment("portal");
+  const container = target || document.body;
+  let portalContent = null;
+  queueMicrotask(() => {
+    try {
+      portalContent = nodes();
+      container.appendChild(portalContent);
+    } catch (err) {
+      console.error("[Portal] Render error:", err);
+    }
+  });
+  const observer = new MutationObserver(() => {
+    if (!anchor.isConnected && portalContent) {
+      portalContent.remove();
+      portalContent = null;
+      observer.disconnect();
+    }
+  });
+  queueMicrotask(() => {
+    if (anchor.parentNode) {
+      observer.observe(anchor.parentNode, { childList: true });
+    }
+  });
+  return anchor;
+}
+
+// src/core/rendering/dynamic.ts
+var componentRegistry = /* @__PURE__ */ new Map();
+function registerComponent(name, component) {
+  componentRegistry.set(name, component);
+}
+function unregisterComponent(name) {
+  componentRegistry.delete(name);
+}
+function resolveComponent(name) {
+  const component = componentRegistry.get(name);
+  if (component) {
+    return component();
+  }
+  return div({ nodes: `[Component "${name}" not found]` });
+}
+function DynamicComponent(is) {
+  const container = div({ class: "sibu-dynamic" });
+  function render() {
+    const target = is();
+    let el;
+    if (typeof target === "function") {
+      el = target();
+    } else {
+      el = resolveComponent(target);
+    }
+    container.replaceChildren(el);
+  }
+  track(render);
+  return container;
+}
+
+// src/core/rendering/slots.ts
+function getSlot(slots, name = "default") {
+  return slots?.[name];
+}
+
+// src/core/rendering/directives.ts
+function show(condition, element) {
+  const update = () => {
+    element.style.display = condition() ? "" : "none";
+  };
+  track(update);
+  return element;
+}
+function when(condition, thenBranch, elseBranch) {
+  const anchor = document.createComment("when");
+  let currentNode = null;
+  let initialized = false;
+  const update = () => {
+    const show2 = condition();
+    const parent = anchor.parentNode;
+    if (!parent) return;
+    if (currentNode?.parentNode) {
+      currentNode.parentNode.removeChild(currentNode);
+      currentNode = null;
+    }
+    const result = show2 ? thenBranch() : elseBranch ? elseBranch() : null;
+    if (result != null) {
+      const node = result instanceof Node ? result : document.createTextNode(String(result));
+      parent.insertBefore(node, anchor.nextSibling);
+      currentNode = node;
+    }
+    initialized = true;
+  };
+  track(update);
+  if (!initialized) {
+    queueMicrotask(() => {
+      if (!initialized && anchor.parentNode) update();
+    });
+  }
+  return anchor;
+}
+function match(value, cases, fallback) {
+  const anchor = document.createComment("match");
+  let currentNode = null;
+  let initialized = false;
+  const update = () => {
+    const key = String(value());
+    const parent = anchor.parentNode;
+    if (!parent) return;
+    if (currentNode?.parentNode) {
+      currentNode.parentNode.removeChild(currentNode);
+      currentNode = null;
+    }
+    const renderFn = cases[key] || fallback;
+    if (renderFn) {
+      const result = renderFn();
+      if (result != null) {
+        const node = result instanceof Node ? result : document.createTextNode(String(result));
+        parent.insertBefore(node, anchor.nextSibling);
+        currentNode = node;
+      }
+    }
+    initialized = true;
+  };
+  track(update);
+  if (!initialized) {
+    queueMicrotask(() => {
+      if (!initialized && anchor.parentNode) update();
+    });
+  }
+  return anchor;
+}
+
+// src/core/rendering/catch.ts
+var globalErrorHandler = null;
+function catchError(fn, onError) {
+  try {
+    const result = fn();
+    if (result && typeof result.then === "function") {
+      result.catch((err) => {
+        if (onError) {
+          onError(err, "async");
+        } else if (globalErrorHandler) {
+          globalErrorHandler(err, "async");
+        } else {
+          console.error("Unhandled async error in Sibu.catchError:", err);
+        }
+      });
+    }
+    return result;
+  } catch (err) {
+    if (onError) {
+      onError(err, "sync");
+    } else if (globalErrorHandler) {
+      globalErrorHandler(err, "sync");
+    } else {
+      console.error("Unhandled error in Sibu.catchError:", err);
+    }
+    return null;
+  }
+}
+async function catchErrorAsync(fn, onError) {
+  try {
+    return await fn();
+  } catch (err) {
+    if (onError) {
+      onError(err, "async");
+    } else if (globalErrorHandler) {
+      globalErrorHandler(err, "async");
+    } else {
+      console.error("Unhandled async error in Sibu.catchErrorAsync:", err);
+    }
+    return null;
+  }
+}
+function setGlobalErrorHandler(handler) {
+  globalErrorHandler = handler;
+}
+
+// src/reactivity/batch.ts
+var batchDepth = 0;
+var pendingSignals = /* @__PURE__ */ new Set();
+function batch(fn) {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushBatch();
+    }
+  }
+}
+function enqueueBatchedSignal(signal2) {
+  if (batchDepth === 0) return false;
+  pendingSignals.add(signal2);
+  return true;
+}
+function isBatching() {
+  return batchDepth > 0;
+}
+function flushBatch() {
+  const signals = Array.from(pendingSignals);
+  pendingSignals.clear();
+  for (const signal2 of signals) {
+    queueSignalNotification(signal2);
+  }
+  drainNotificationQueue();
+}
+
+// src/core/signals/signal.ts
+function signal(initial, options) {
+  const state = { value: initial };
+  const debugName = options?.name;
+  if (debugName) {
+    state.__name = debugName;
+  }
+  function get() {
+    recordDependency(state);
+    return state.value;
+  }
+  get.__signal = state;
+  if (debugName) get.__name = debugName;
+  function set(next) {
+    const newValue = typeof next === "function" ? next(state.value) : next;
+    if (Object.is(newValue, state.value)) return;
+    const oldValue = state.value;
+    state.value = newValue;
+    const hook2 = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (hook2) hook2.emit("signal:update", { signal: state, name: debugName, oldValue, newValue });
+    if (!enqueueBatchedSignal(state)) {
+      notifySubscribers(state);
+    }
+  }
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
+  return [get, set];
+}
+
+// src/core/ssr-context.ts
+var ssrMode = false;
+function isSSR() {
+  return ssrMode;
+}
+function enableSSR() {
+  ssrMode = true;
+}
+function disableSSR() {
+  ssrMode = false;
+}
+function withSSR(fn) {
+  enableSSR();
+  try {
+    return fn();
+  } finally {
+    disableSSR();
+  }
+}
+
+// src/core/signals/effect.ts
+function effect(effectFn) {
+  devAssert(typeof effectFn === "function", "effect: argument must be a function.");
+  if (isSSR()) return () => {
+  };
+  let runCount = 0;
+  let cleanupHandle = () => {
+  };
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  const subscriber = () => {
+    cleanupHandle();
+    runCount++;
+    if (hook) hook.emit("effect:run", { effectFn, runCount });
+    cleanupHandle = track(effectFn, subscriber);
+  };
+  cleanupHandle = track(effectFn, subscriber);
+  runCount = 1;
+  if (hook) hook.emit("effect:create", { effectFn });
+  return () => {
+    if (hook) hook.emit("effect:destroy", { effectFn });
+    cleanupHandle();
+  };
+}
+
+// src/core/signals/derived.ts
+function derived(getter, options) {
+  devAssert(typeof getter === "function", "derived: argument must be a getter function.");
+  const debugName = options?.name;
+  const cs = {};
+  cs._d = false;
+  cs._g = getter;
+  const markDirty = () => {
+    if (cs._d) return;
+    cs._d = true;
+  };
+  markDirty._c = 1;
+  markDirty._sig = cs;
+  track(() => {
+    cs._d = false;
+    cs._v = getter();
+  }, markDirty);
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  function computedGetter() {
+    if (trackingSuspended) {
+      if (cs._d) {
+        cs._d = false;
+        cs._v = getter();
+      }
+      return cs._v;
+    }
+    recordDependency(cs);
+    if (cs._d) {
+      const oldValue = cs._v;
+      cs._d = false;
+      suspendTracking();
+      try {
+        cs._v = getter();
+      } finally {
+        resumeTracking();
+      }
+      if (hook && oldValue !== cs._v) {
+        hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
+      }
+    }
+    return cs._v;
+  }
+  if (debugName) {
+    computedGetter.__name = debugName;
+    cs.__name = debugName;
+  }
+  computedGetter.__signal = cs;
+  if (hook) hook.emit("computed:create", { signal: cs, name: debugName, getter: computedGetter });
+  return computedGetter;
+}
+
+// src/core/signals/watch.ts
+function watch(getter, callback) {
+  devAssert(typeof getter === "function", "watch: first argument must be a getter function.");
+  devAssert(typeof callback === "function", "watch: second argument must be a callback function.");
+  if (isSSR()) return () => {
+  };
+  let oldValue = getter();
+  const subscriber = () => {
+    const newValue = getter();
+    if (!Object.is(newValue, oldValue)) {
+      callback(newValue, oldValue);
+      oldValue = newValue;
+    }
+  };
+  const teardown = track(subscriber);
+  return teardown;
+}
+
+// src/core/signals/store.ts
+function store(initialState) {
+  devAssert(
+    initialState !== null && typeof initialState === "object" && !Array.isArray(initialState),
+    "store: argument must be a plain object. For arrays, use array() instead."
+  );
+  const signals = {};
+  Object.keys(initialState).forEach((key) => {
+    const [getter, setter] = signal(initialState[key]);
+    signals[key] = [getter, setter];
+  });
+  const store2 = new Proxy({}, {
+    get(_, prop) {
+      if (prop in signals) {
+        const getter = signals[prop][0];
+        return getter();
+      }
+      return void 0;
+    },
+    set() {
+      throw new Error(
+        "[Sibu] store: Direct mutation is not allowed. Use actions.setState() to update store properties."
+      );
+    }
+  });
+  const getSnapshot = () => {
+    const snapshot = {};
+    Object.keys(signals).forEach((key) => {
+      snapshot[key] = signals[key][0]();
+    });
+    return snapshot;
+  };
+  const setState = (patch) => {
+    const current = getSnapshot();
+    const nextState = typeof patch === "function" ? patch(current) : patch;
+    Object.entries(nextState).forEach(([key, value]) => {
+      if (key in signals) {
+        signals[key][1](value);
+      }
+    });
+  };
+  const reset = () => {
+    Object.keys(initialState).forEach((key) => {
+      const setter = signals[key][1];
+      setter(initialState[key]);
+    });
+  };
+  const subscribe = (callback) => {
+    return effect(() => {
+      const snapshot = getSnapshot();
+      callback(snapshot);
+    });
+  };
+  const subscribeKey = (key, callback) => {
+    let prev = signals[key][0]();
+    return effect(() => {
+      const current = signals[key][0]();
+      if (!Object.is(current, prev)) {
+        const oldPrev = prev;
+        prev = current;
+        callback(current, oldPrev);
+      }
+    });
+  };
+  return [store2, { setState, reset, subscribe, subscribeKey, getSnapshot }];
+}
+
+// src/core/signals/ref.ts
+function ref(initial) {
+  return { current: initial };
+}
+
+// src/core/signals/memo.ts
+function memo(factory) {
+  return derived(factory);
+}
+
+// src/core/signals/memoFn.ts
+function memoFn(callback) {
+  return derived(callback);
+}
+
+// src/core/signals/array.ts
+function array(initial = []) {
+  const [arr, setArr] = signal([...initial]);
+  const actions = {
+    push(...items) {
+      setArr((prev) => [...prev, ...items]);
+    },
+    pop() {
+      let removed;
+      setArr((prev) => {
+        const copy = [...prev];
+        removed = copy.pop();
+        return copy;
+      });
+      return removed;
+    },
+    shift() {
+      let removed;
+      setArr((prev) => {
+        const copy = [...prev];
+        removed = copy.shift();
+        return copy;
+      });
+      return removed;
+    },
+    unshift(...items) {
+      setArr((prev) => [...items, ...prev]);
+    },
+    splice(start, deleteCount = 0, ...items) {
+      let removed = [];
+      setArr((prev) => {
+        const copy = [...prev];
+        removed = copy.splice(start, deleteCount, ...items);
+        return copy;
+      });
+      return removed;
+    },
+    remove(index) {
+      setArr((prev) => prev.filter((_, i2) => i2 !== index));
+    },
+    removeWhere(predicate) {
+      setArr((prev) => {
+        const idx = prev.findIndex(predicate);
+        if (idx === -1) return prev;
+        return prev.filter((_, i2) => i2 !== idx);
+      });
+    },
+    set(items) {
+      setArr([...items]);
+    },
+    update(index, value) {
+      setArr((prev) => prev.map((item, i2) => i2 === index ? value : item));
+    },
+    updateWhere(predicate, updater) {
+      setArr((prev) => prev.map((item) => predicate(item) ? updater(item) : item));
+    },
+    sort(compareFn) {
+      setArr((prev) => [...prev].sort(compareFn));
+    },
+    reverse() {
+      setArr((prev) => [...prev].reverse());
+    },
+    filter(predicate) {
+      setArr((prev) => prev.filter(predicate));
+    },
+    map(transform) {
+      setArr((prev) => prev.map(transform));
+    },
+    clear() {
+      setArr([]);
+    }
+  };
+  return [arr, actions];
+}
+function reactiveArray(initial = []) {
+  let data2 = [...initial];
+  let snapshot = null;
+  const signal2 = {};
+  function notify() {
+    snapshot = null;
+    if (!enqueueBatchedSignal(signal2)) {
+      notifySubscribers(signal2);
+    }
+  }
+  function get() {
+    recordDependency(signal2);
+    if (snapshot === null) {
+      snapshot = Object.freeze([...data2]);
+    }
+    return snapshot;
+  }
+  const actions = {
+    push(...items) {
+      if (items.length === 0) return;
+      data2.push(...items);
+      notify();
+    },
+    pop() {
+      if (data2.length === 0) return void 0;
+      const removed = data2.pop();
+      notify();
+      return removed;
+    },
+    shift() {
+      if (data2.length === 0) return void 0;
+      const removed = data2.shift();
+      notify();
+      return removed;
+    },
+    unshift(...items) {
+      if (items.length === 0) return;
+      data2.unshift(...items);
+      notify();
+    },
+    splice(start, deleteCount = 0, ...items) {
+      const removed = data2.splice(start, deleteCount, ...items);
+      if (removed.length > 0 || items.length > 0) {
+        notify();
+      }
+      return removed;
+    },
+    remove(index) {
+      if (index < 0 || index >= data2.length) return;
+      data2.splice(index, 1);
+      notify();
+    },
+    removeWhere(predicate) {
+      const idx = data2.findIndex(predicate);
+      if (idx === -1) return;
+      data2.splice(idx, 1);
+      notify();
+    },
+    set(items) {
+      data2 = [...items];
+      notify();
+    },
+    update(index, value) {
+      if (index < 0 || index >= data2.length) return;
+      if (Object.is(data2[index], value)) return;
+      data2[index] = value;
+      notify();
+    },
+    updateWhere(predicate, updater) {
+      let changed = false;
+      for (let i2 = 0; i2 < data2.length; i2++) {
+        if (predicate(data2[i2])) {
+          const updated = updater(data2[i2]);
+          if (!Object.is(data2[i2], updated)) {
+            data2[i2] = updated;
+            changed = true;
+          }
+        }
+      }
+      if (changed) notify();
+    },
+    sort(compareFn) {
+      if (data2.length <= 1) return;
+      data2.sort(compareFn);
+      notify();
+    },
+    reverse() {
+      if (data2.length <= 1) return;
+      data2.reverse();
+      notify();
+    },
+    filter(predicate) {
+      const filtered = data2.filter(predicate);
+      if (filtered.length === data2.length) return;
+      data2 = filtered;
+      notify();
+    },
+    map(transform) {
+      let changed = false;
+      for (let i2 = 0; i2 < data2.length; i2++) {
+        const transformed = transform(data2[i2], i2);
+        if (!Object.is(data2[i2], transformed)) {
+          data2[i2] = transformed;
+          changed = true;
+        }
+      }
+      if (changed) notify();
+    },
+    clear() {
+      if (data2.length === 0) return;
+      data2 = [];
+      notify();
+    }
+  };
+  return [get, actions];
+}
+
+// src/core/signals/deepSignal.ts
+function deepEqual(a2, b2) {
+  if (Object.is(a2, b2)) return true;
+  if (a2 == null || b2 == null) return false;
+  if (typeof a2 !== typeof b2) return false;
+  if (typeof a2 !== "object") return false;
+  if (Array.isArray(a2)) {
+    if (!Array.isArray(b2)) return false;
+    if (a2.length !== b2.length) return false;
+    return a2.every((val, i2) => deepEqual(val, b2[i2]));
+  }
+  const keysA = Object.keys(a2);
+  const keysB = Object.keys(b2);
+  if (keysA.length !== keysB.length) return false;
+  return keysA.every((key) => deepEqual(a2[key], b2[key]));
+}
+function deepSignal(initial) {
+  const state = { value: initial };
+  function get() {
+    recordDependency(state);
+    return state.value;
+  }
+  function set(next) {
+    const newValue = typeof next === "function" ? next(state.value) : next;
+    if (deepEqual(newValue, state.value)) return;
+    state.value = newValue;
+    if (!enqueueBatchedSignal(state)) {
+      notifySubscribers(state);
+    }
+  }
+  return [get, set];
+}
+
+// src/core/rendering/lifecycle.ts
+function onMount(callback, element) {
+  if (typeof document === "undefined") return;
+  if (element) {
+    if (element.isConnected) {
+      queueMicrotask(() => {
+        callback();
+      });
+      return;
+    }
+    const observer = new MutationObserver(() => {
+      if (element.isConnected) {
+        observer.disconnect();
+        callback();
+      }
+    });
+    queueMicrotask(() => {
+      if (element.isConnected) {
+        callback();
+      } else {
+        observer.observe(document.body, { childList: true, subtree: true });
+      }
+    });
+  } else {
+    queueMicrotask(() => {
+      callback();
+    });
+  }
+}
+function onUnmount(callback, element) {
+  const startObserving = () => {
+    const observer = new MutationObserver(() => {
+      if (!element.isConnected) {
+        observer.disconnect();
+        callback();
+      }
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+  };
+  if (element.isConnected) {
+    startObserving();
+  } else {
+    onMount(() => {
+      startObserving();
+      return void 0;
+    }, element);
+  }
+}
+
+// src/core/rendering/context.ts
+function context(defaultValue) {
+  const [getValue, setValue] = signal(defaultValue);
+  return {
+    provide(value) {
+      setValue(value);
+    },
+    use() {
+      return getValue;
+    },
+    get() {
+      return getValue();
+    },
+    set(value) {
+      setValue(value);
+    }
+  };
+}
+
+// src/core/rendering/lazy.ts
+function lazy(importFn) {
+  let cached = null;
+  return function LazyComponent() {
+    if (cached) {
+      return cached();
+    }
+    const [_status, setStatus] = signal("loading");
+    const [_error, setError] = signal(null);
+    const container = div({ class: "sibu-lazy" });
+    importFn().then((mod) => {
+      cached = mod.default;
+      const rendered = cached();
+      container.replaceChildren(rendered);
+      setStatus("loaded");
+    }).catch((err) => {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      setError(errorObj);
+      setStatus("error");
+      container.replaceChildren(
+        div({
+          class: "sibu-lazy-error",
+          nodes: `Failed to load component: ${errorObj.message}`
+        })
+      );
+    });
+    container.appendChild(span({ class: "sibu-lazy-loading", nodes: "Loading..." }));
+    return container;
+  };
+}
+function Suspense({ nodes, fallback }) {
+  const container = div({ class: "sibu-suspense" });
+  const fallbackEl = fallback();
+  container.appendChild(fallbackEl);
+  queueMicrotask(() => {
+    try {
+      const childEl = nodes();
+      if (childEl.classList.contains("sibu-lazy")) {
+        const observer = new MutationObserver(() => {
+          const loading = childEl.querySelector(".sibu-lazy-loading");
+          if (!loading) {
+            observer.disconnect();
+            container.replaceChildren(childEl);
+          }
+        });
+        observer.observe(childEl, { childList: true, subtree: true });
+        if (!childEl.querySelector(".sibu-lazy-loading")) {
+          container.replaceChildren(childEl);
+        }
+      } else {
+        container.replaceChildren(childEl);
+      }
+    } catch {
+    }
+  });
+  return container;
+}
+
+// src/components/ErrorBoundary.ts
+var errorBoundaryStyles = `
+  .sibu-error-boundary {
+    position: relative;
+  }
+
+  .sibu-error-fallback {
+    border: 2px solid #dc3545;
+    border-radius: 8px;
+    padding: 20px;
+    margin: 10px 0;
+    background: linear-gradient(135deg, #fff5f5 0%, #ffebee 100%);
+    box-shadow: 0 2px 12px rgba(220, 53, 69, 0.15);
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  }
+
+  .sibu-error-fallback .sibu-error-title {
+    margin: 0 0 12px 0;
+    color: #dc3545;
+    font-size: 1.1em;
+    font-weight: 600;
+  }
+
+  .sibu-error-fallback .sibu-error-message {
+    font-family: 'SF Mono', 'Fira Code', 'Roboto Mono', monospace;
+    background-color: rgba(0, 0, 0, 0.04);
+    padding: 10px 14px;
+    border-radius: 6px;
+    border: 1px solid rgba(0, 0, 0, 0.08);
+    margin: 10px 0;
+    color: #495057;
+    word-break: break-word;
+    font-size: 0.9em;
+    line-height: 1.5;
+  }
+
+  .sibu-error-fallback .sibu-error-btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 8px 18px;
+    border: none;
+    border-radius: 6px;
+    cursor: pointer;
+    font-size: 14px;
+    font-weight: 500;
+    transition: all 0.2s ease;
+    margin-top: 8px;
+    background-color: #dc3545;
+    color: white;
+  }
+
+  .sibu-error-fallback .sibu-error-btn:hover {
+    background-color: #c82333;
+    transform: translateY(-1px);
+    box-shadow: 0 2px 8px rgba(220, 53, 69, 0.3);
+  }
+
+  .sibu-error-fallback .sibu-error-btn:active {
+    transform: translateY(0);
+  }
+`;
+var stylesInjected = false;
+function injectStyles() {
+  if (!stylesInjected && typeof document !== "undefined") {
+    const styleElement = style({ nodes: errorBoundaryStyles });
+    document.head.appendChild(styleElement);
+    stylesInjected = true;
+  }
+}
+var fallbackCache = /* @__PURE__ */ new WeakMap();
+function getMemoizedFallback(fallbackFn, error, retry) {
+  let cache2 = fallbackCache.get(fallbackFn);
+  if (!cache2) {
+    cache2 = /* @__PURE__ */ new Map();
+    fallbackCache.set(fallbackFn, cache2);
+  }
+  const key = error.message;
+  if (!cache2.has(key)) {
+    cache2.set(key, fallbackFn(error, retry));
+  }
+  return cache2.get(key);
+}
+function ErrorBoundary({ nodes, fallback, onError }) {
+  injectStyles();
+  const [error, setError] = signal(null);
+  const retry = () => {
+    if (fallback) {
+      fallbackCache.delete(fallback);
+    }
+    setError(null);
+  };
+  const handleError = (e) => {
+    const errorObj = e instanceof Error ? e : new Error(String(e));
+    setError(errorObj);
+    onError?.(errorObj);
+    return errorObj;
+  };
+  const defaultFallback = (err, retryFn) => div({
+    class: "sibu-error-fallback",
+    nodes: [
+      h3({
+        nodes: "Something went wrong",
+        class: "sibu-error-title"
+      }),
+      p({
+        nodes: err.message,
+        class: "sibu-error-message"
+      }),
+      button({
+        nodes: "Retry",
+        class: "sibu-error-btn",
+        on: { click: retryFn }
+      })
+    ]
+  });
+  const tryRenderFallback = (err) => {
+    const fn = fallback || defaultFallback;
+    try {
+      return getMemoizedFallback(fn, err, retry);
+    } catch (fallbackError) {
+      const propagateError = fallbackError instanceof Error ? fallbackError : new Error(String(fallbackError));
+      queueMicrotask(() => {
+        if (container.parentNode) {
+          container.dispatchEvent(
+            new CustomEvent("sibu:error-propagate", {
+              bubbles: true,
+              detail: { error: propagateError }
+            })
+          );
+        }
+      });
+      return document.createComment("error-boundary-failed");
+    }
+  };
+  const container = div({
+    class: "sibu-error-boundary",
+    nodes: () => {
+      const currentError = error();
+      if (currentError) {
+        return tryRenderFallback(currentError);
+      }
+      try {
+        const result = nodes();
+        if (result && typeof result.then === "function") {
+          const asyncContainer = div({ class: "sibu-error-async" });
+          asyncContainer.appendChild(span({ class: "sibu-lazy-loading", nodes: "Loading..." }));
+          result.then((el) => {
+            asyncContainer.replaceChildren(el);
+          }).catch((e) => {
+            const err = handleError(e);
+            asyncContainer.replaceChildren(tryRenderFallback(err));
+          });
+          return asyncContainer;
+        }
+        return result;
+      } catch (e) {
+        const errorObj = handleError(e);
+        return tryRenderFallback(errorObj);
+      }
+    }
+  });
+  container.addEventListener("sibu:error-propagate", (e) => {
+    if (error()) return;
+    e.stopPropagation();
+    const customEvent = e;
+    const propagatedError = customEvent.detail?.error;
+    if (propagatedError) {
+      handleError(propagatedError);
+    }
+  });
+  return container;
+}
+
+// src/components/Loading.ts
+var loadingStyles = `
+  @keyframes sibu-spin {
+    to { transform: rotate(360deg); }
+  }
+
+  @keyframes sibu-pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.4; }
+  }
+
+  .sibu-loading {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 20px;
+    gap: 10px;
+  }
+
+  .sibu-loading-spinner {
+    width: 24px;
+    height: 24px;
+    border: 3px solid #e0e0e0;
+    border-top-color: #3b82f6;
+    border-radius: 50%;
+    animation: sibu-spin 0.8s linear infinite;
+  }
+
+  .sibu-loading-dots {
+    display: flex;
+    gap: 4px;
+  }
+
+  .sibu-loading-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background-color: #3b82f6;
+    animation: sibu-pulse 1.2s ease-in-out infinite;
+  }
+
+  .sibu-loading-dot:nth-child(2) { animation-delay: 0.2s; }
+  .sibu-loading-dot:nth-child(3) { animation-delay: 0.4s; }
+
+  .sibu-loading-text {
+    color: #6b7280;
+    font-size: 14px;
+  }
+
+  .sibu-loading-sm .sibu-loading-spinner { width: 16px; height: 16px; border-width: 2px; }
+  .sibu-loading-sm .sibu-loading-dot { width: 6px; height: 6px; }
+  .sibu-loading-lg .sibu-loading-spinner { width: 40px; height: 40px; border-width: 4px; }
+  .sibu-loading-lg .sibu-loading-dot { width: 12px; height: 12px; }
+  .sibu-loading-lg .sibu-loading-dots { gap: 6px; }
+`;
+var loadingStylesInjected = false;
+function injectLoadingStyles() {
+  if (!loadingStylesInjected && typeof document !== "undefined") {
+    document.head.appendChild(style({ nodes: loadingStyles }));
+    loadingStylesInjected = true;
+  }
+}
+function Loading(props = {}) {
+  injectLoadingStyles();
+  const { text: text2, variant = "spinner", size = "md" } = props;
+  const sizeClass = size !== "md" ? ` sibu-loading-${size}` : "";
+  if (variant === "dots") {
+    return div({
+      class: `sibu-loading${sizeClass}`,
+      nodes: [
+        div({
+          class: "sibu-loading-dots",
+          nodes: [
+            span({ class: "sibu-loading-dot" }),
+            span({ class: "sibu-loading-dot" }),
+            span({ class: "sibu-loading-dot" })
+          ]
+        }),
+        text2 ? span({ class: "sibu-loading-text", nodes: text2 }) : null
+      ].filter(Boolean)
+    });
+  }
+  return div({
+    class: `sibu-loading${sizeClass}`,
+    nodes: [
+      div({ class: "sibu-loading-spinner" }),
+      text2 ? span({ class: "sibu-loading-text", nodes: text2 }) : null
+    ].filter(Boolean)
+  });
+}
+
+// src/build/cdn.ts
+var PACKAGE_NAME = "sibu";
+function registerGlobal() {
+  if (typeof window === "undefined") return;
+  window.Sibu = { ...index_exports };
+}
+function umdWrapper(name, factory) {
+  const factoryStr = factory.toString();
+  return `(function (root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD (RequireJS)
+    define([], factory);
+  } else if (typeof module === 'object' && module.exports) {
+    // CommonJS (Node.js)
+    module.exports = factory();
+  } else {
+    // Browser globals
+    root.${name} = factory();
+  }
+}(typeof self !== 'undefined' ? self : this, ${factoryStr}));`;
+}
+var cdnUrls = {
+  /**
+   * Generate an unpkg CDN URL.
+   * @param version - Package version (defaults to 'latest')
+   */
+  unpkg: (version) => `https://unpkg.com/${PACKAGE_NAME}@${version || "latest"}/dist/cdn.global.js`,
+  /**
+   * Generate a jsDelivr CDN URL.
+   * @param version - Package version (defaults to 'latest')
+   */
+  jsdelivr: (version) => `https://cdn.jsdelivr.net/npm/${PACKAGE_NAME}@${version || "latest"}/dist/cdn.global.js`,
+  /**
+   * Generate a Skypack CDN URL (ESM-native).
+   * @param version - Package version (defaults to 'latest')
+   */
+  skypack: (version) => `https://cdn.skypack.dev/${PACKAGE_NAME}@${version || "latest"}`,
+  /**
+   * Generate a complete HTML script tag for including SibuJS from a CDN.
+   *
+   * @param provider - CDN provider to use (defaults to 'jsdelivr')
+   * @param version - Package version (defaults to 'latest')
+   * @returns An HTML script tag string
+   *
+   * @example
+   * ```ts
+   * cdnUrls.scriptTag('jsdelivr', '1.0.0')
+   * // => '<script src="https://cdn.jsdelivr.net/npm/sibu@1.0.0/dist/cdn.global.js"></script>'
+   * ```
+   */
+  scriptTag: (provider = "jsdelivr", version) => {
+    const url = cdnUrls[provider](version);
+    if (provider === "skypack") {
+      return `<script type="module">
+import * as Sibu from '${url}';
+window.Sibu = Sibu;
+</script>`;
+    }
+    return `<script src="${url}"></script>`;
+  }
+};
+function generateImportMap(baseUrl) {
+  const base2 = baseUrl || `https://cdn.jsdelivr.net/npm/${PACKAGE_NAME}@latest`;
+  const imports = {
+    // Main package entry
+    [PACKAGE_NAME]: `${base2}/dist/index.js`,
+    // Sub-path imports for tree-shaking in browsers
+    [`${PACKAGE_NAME}/core`]: `${base2}/dist/core/index.js`,
+    [`${PACKAGE_NAME}/reactivity`]: `${base2}/dist/reactivity/index.js`,
+    [`${PACKAGE_NAME}/plugins`]: `${base2}/dist/plugins/index.js`,
+    [`${PACKAGE_NAME}/components`]: `${base2}/dist/components/index.js`,
+    [`${PACKAGE_NAME}/testing`]: `${base2}/dist/testing/index.js`,
+    [`${PACKAGE_NAME}/build`]: `${base2}/dist/build/index.js`
+  };
+  return {
+    imports,
+    /**
+     * Serialize the import map to a JSON string.
+     */
+    toJSON() {
+      return JSON.stringify({ imports }, null, 2);
+    },
+    /**
+     * Generate a complete `<script type="importmap">` tag.
+     */
+    toScriptTag() {
+      return `<script type="importmap">
+${JSON.stringify({ imports }, null, 2)}
+</script>`;
+    }
+  };
+}
+
+// src/build/declarations.ts
+var RECOMMENDED_OPTIONS = {
+  target: "ES2020",
+  module: "ESNext",
+  moduleResolution: "bundler",
+  strict: true,
+  esModuleInterop: true,
+  skipLibCheck: true,
+  declaration: true,
+  declarationMap: true,
+  sourceMap: true,
+  jsx: "preserve",
+  lib: ["ES2020", "DOM", "DOM.Iterable"],
+  isolatedModules: true,
+  resolveJsonModule: true,
+  allowSyntheticDefaultImports: true,
+  forceConsistentCasingInFileNames: true,
+  noUncheckedIndexedAccess: true,
+  noEmit: false
+};
+var REQUIRED_OPTIONS = {
+  strict: {
+    value: true,
+    reason: "SibuJS relies on strict type checking for safe reactive state handling."
+  },
+  esModuleInterop: {
+    value: true,
+    reason: "Required for correct ESM interop with SibuJS module exports."
+  },
+  moduleResolution: {
+    value: ["node", "bundler", "node16", "nodenext"],
+    reason: "SibuJS requires a module resolution strategy that supports package.json exports."
+  }
+};
+var SUGGESTED_OPTIONS = {
+  declarationMap: {
+    value: true,
+    reason: 'Enables "Go to Definition" to navigate to SibuJS source files in your IDE.'
+  },
+  sourceMap: {
+    value: true,
+    reason: "Enables source map debugging for SibuJS components."
+  },
+  noUncheckedIndexedAccess: {
+    value: true,
+    reason: "Improves type safety when accessing reactive state objects."
+  },
+  isolatedModules: {
+    value: true,
+    reason: "Required for compatibility with esbuild/swc transpilers used by Vite."
+  }
+};
+function generateTsConfig(options) {
+  const { target = "ES2020", outDir = "dist", declarationMap = true, paths } = options || {};
+  const compilerOptions = {
+    ...RECOMMENDED_OPTIONS,
+    target,
+    outDir,
+    declarationMap
+  };
+  if (paths && Object.keys(paths).length > 0) {
+    compilerOptions.baseUrl = ".";
+    compilerOptions.paths = {
+      // Default sibu alias
+      sibu: ["node_modules/sibu/dist/index.d.ts"],
+      "sibu/*": ["node_modules/sibu/dist/*"],
+      // User-provided paths
+      ...paths
+    };
+  }
+  return {
+    compilerOptions,
+    include: ["src/**/*.ts", "src/**/*.tsx"],
+    exclude: ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+  };
+}
+function validateTsConfig(config) {
+  const warnings = [];
+  const suggestions = [];
+  const compilerOptions = config.compilerOptions || {};
+  for (const [option2, requirement] of Object.entries(REQUIRED_OPTIONS)) {
+    const currentValue = compilerOptions[option2];
+    if (Array.isArray(requirement.value)) {
+      if (currentValue === void 0) {
+        warnings.push(
+          `Missing required option "${option2}". ${requirement.reason} Recommended value: one of ${requirement.value.map((v) => `"${v}"`).join(", ")}.`
+        );
+      } else if (!requirement.value.includes(currentValue)) {
+        warnings.push(
+          `Option "${option2}" is set to "${currentValue}" which may not be compatible with SibuJS. ${requirement.reason} Recommended: one of ${requirement.value.map((v) => `"${v}"`).join(", ")}.`
+        );
+      }
+    } else {
+      if (currentValue === void 0) {
+        warnings.push(
+          `Missing required option "${option2}". ${requirement.reason} Recommended value: ${JSON.stringify(requirement.value)}.`
+        );
+      } else if (currentValue !== requirement.value) {
+        warnings.push(
+          `Option "${option2}" is set to ${JSON.stringify(currentValue)} but SibuJS recommends ${JSON.stringify(requirement.value)}. ${requirement.reason}`
+        );
+      }
+    }
+  }
+  for (const [option2, suggestion] of Object.entries(SUGGESTED_OPTIONS)) {
+    const currentValue = compilerOptions[option2];
+    if (currentValue === void 0 || currentValue !== suggestion.value) {
+      suggestions.push(`Consider setting "${option2}" to ${JSON.stringify(suggestion.value)}. ${suggestion.reason}`);
+    }
+  }
+  const target = typeof compilerOptions.target === "string" ? compilerOptions.target.toUpperCase() : void 0;
+  if (target) {
+    const es2020Plus = ["ES2020", "ES2021", "ES2022", "ES2023", "ES2024", "ESNEXT"];
+    if (!es2020Plus.includes(target)) {
+      warnings.push(
+        `Target "${target}" may not support all features used by SibuJS. Recommended: "ES2020" or newer. SibuJS uses optional chaining, nullish coalescing, and other ES2020+ features.`
+      );
+    }
+  }
+  const module2 = typeof compilerOptions.module === "string" ? compilerOptions.module.toLowerCase() : void 0;
+  if (module2 && !["esnext", "es2020", "es2022", "node16", "nodenext"].includes(module2)) {
+    suggestions.push(
+      `Module "${compilerOptions.module}" may not provide optimal results with SibuJS. Consider using "ESNext" for best tree-shaking and bundle optimization.`
+    );
+  }
+  const lib = compilerOptions.lib;
+  if (Array.isArray(lib)) {
+    const hasDom = lib.some((l) => l.toUpperCase() === "DOM" || l.toUpperCase() === "DOM.ITERABLE");
+    if (!hasDom) {
+      suggestions.push(
+        'The "lib" array does not include "DOM". SibuJS requires DOM types for component rendering. Add "DOM" and "DOM.Iterable" to your lib array.'
+      );
+    }
+  }
+  if (Array.isArray(config.include)) {
+    const includesTs = config.include.some(
+      (pattern2) => pattern2.includes(".ts") || pattern2.includes("*")
+    );
+    if (!includesTs) {
+      suggestions.push(
+        'Your "include" patterns may not capture TypeScript files. Ensure patterns like "src/**/*.ts" are included.'
+      );
+    }
+  }
+  return {
+    valid: warnings.length === 0,
+    warnings,
+    suggestions
+  };
+}
+
+// src/build/analyzer.ts
+var moduleSizes = {
+  // Core modules
+  "core/html": 1800,
+  "core/mount": 120,
+  "core/each": 450,
+  "core/slots": 200,
+  "core/fragment": 180,
+  "core/catch": 280,
+  "core/portal": 350,
+  "core/directives": 520,
+  "core/dynamic": 380,
+  "core/head": 300,
+  "core/ssr": 1200,
+  "core/customElement": 650,
+  "core/scopedStyle": 480,
+  "core/domRecycler": 420,
+  "core/bundleOptimize": 200,
+  "core/compiled": 350,
+  "core/normalize": 280,
+  "core/reactiveAttr": 320,
+  "core/componentProps": 400,
+  "core/contracts": 350,
+  "core/worker": 550,
+  "core/wasm": 480,
+  "core/concurrent": 600,
+  "core/microfrontend": 700,
+  "core/chunkLoader": 450,
+  "core/versioning": 300,
+  "core/ecosystem": 250,
+  // Signals
+  "core/signal": 280,
+  "core/effect": 350,
+  "core/derived": 250,
+  "core/watch": 300,
+  "core/store": 380,
+  "core/ref": 150,
+  "core/memo": 180,
+  "core/memoFn": 160,
+  "core/array": 420,
+  "core/deepSignal": 500,
+  "core/lifecycle": 300,
+  "core/context": 350,
+  "core/persist": 400,
+  "core/primitives": 200,
+  "core/hoc": 280,
+  "core/transition": 600,
+  "core/form": 750,
+  "core/globalStore": 450,
+  "core/machine": 550,
+  "core/optimistic": 380,
+  "core/timeTravel": 500,
+  "core/scheduler": 350,
+  "core/plugin": 300,
+  "core/virtualList": 800,
+  "core/intersection": 350,
+  "core/inputMask": 450,
+  "core/a11y": 500,
+  "core/debug": 400,
+  "core/serviceWorker": 350,
+  "core/composable": 280,
+  // Reactivity
+  "reactivity/signal": 100,
+  "reactivity/track": 250,
+  "reactivity/batch": 200,
+  "reactivity/bindAttribute": 300,
+  "reactivity/bindChildNode": 250,
+  "reactivity/bindTextNode": 200,
+  // Components
+  "components/ErrorBoundary": 350,
+  "components/Loading": 250,
+  // Plugins
+  "plugins/i18n": 600,
+  "plugins/router": 900,
+  "plugins/routerSSR": 500,
+  // Build utilities
+  "build/vite": 800,
+  "build/webpack": 750,
+  "build/cdn": 400,
+  "build/declarations": 500,
+  "build/analyzer": 600,
+  // Testing
+  "testing/index": 700,
+  "testing/e2e": 500
+};
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+function analyzeBundle(modules) {
+  const sizes = {};
+  let totalSize = 0;
+  for (const [name, source2] of Object.entries(modules)) {
+    let byteLength;
+    if (typeof TextEncoder !== "undefined") {
+      byteLength = new TextEncoder().encode(source2).length;
+    } else {
+      byteLength = source2.length;
+    }
+    sizes[name] = byteLength;
+    totalSize += byteLength;
+  }
+  const sorted = Object.entries(sizes).map(([name, size]) => ({
+    name,
+    size,
+    percentage: totalSize > 0 ? size / totalSize * 100 : 0
+  })).sort((a2, b2) => b2.size - a2.size);
+  return {
+    totalSize,
+    moduleSizes: sizes,
+    sorted,
+    report() {
+      const lines = [
+        "=== SibuJS Bundle Analysis ===",
+        "",
+        `Total size: ${formatBytes(totalSize)}`,
+        `Modules: ${sorted.length}`,
+        "",
+        "Module breakdown:",
+        "-".repeat(60)
+      ];
+      for (const entry of sorted) {
+        const sizeStr = formatBytes(entry.size).padStart(10);
+        const pctStr = `${entry.percentage.toFixed(1)}%`.padStart(6);
+        const bar = generateBar(entry.percentage, 20);
+        lines.push(`  ${sizeStr}  ${pctStr}  ${bar}  ${entry.name}`);
+      }
+      lines.push("-".repeat(60));
+      return lines.join("\n");
+    }
+  };
+}
+function generateBar(percentage, width) {
+  const filled = Math.round(percentage / 100 * width);
+  const empty = width - filled;
+  return `[${"#".repeat(filled)}${".".repeat(empty)}]`;
+}
+function estimateImportSize(imports) {
+  const breakdown = {};
+  let estimated = 0;
+  const implicitDeps = ["reactivity/signal", "reactivity/track"];
+  const allImports = [.../* @__PURE__ */ new Set([...implicitDeps, ...imports])];
+  for (const importPath of allImports) {
+    const size = moduleSizes[importPath];
+    if (size !== void 0) {
+      breakdown[importPath] = size;
+      estimated += size;
+    } else {
+      const avgSize = 350;
+      breakdown[importPath] = avgSize;
+      estimated += avgSize;
+    }
+  }
+  const sortedEntries = Object.entries(breakdown).sort(([, a2], [, b2]) => b2 - a2);
+  const lines = [`Estimated bundle size: ${formatBytes(estimated)} (minified + gzipped)`, ""];
+  for (const [modulePath, size] of sortedEntries) {
+    const known = moduleSizes[modulePath] !== void 0;
+    lines.push(`  ${modulePath}: ${formatBytes(size)}${known ? "" : " (estimated)"}`);
+  }
+  if (imports.length > 0) {
+    lines.push("");
+    lines.push("Note: Actual sizes may vary based on tree-shaking and build configuration.");
+    lines.push("Implicit dependencies (reactivity/signal, reactivity/track) are included.");
+  }
+  return {
+    estimated,
+    breakdown,
+    formatted: lines.join("\n")
+  };
+}
+
+// src/build/linting.ts
+function getLineNumber(source2, index) {
+  let line2 = 1;
+  for (let i2 = 0; i2 < index && i2 < source2.length; i2++) {
+    if (source2[i2] === "\n") line2++;
+  }
+  return line2;
+}
+function getColumnNumber(source2, index) {
+  let col2 = 1;
+  for (let i2 = index - 1; i2 >= 0; i2--) {
+    if (source2[i2] === "\n") break;
+    col2++;
+  }
+  return col2;
+}
+var lintRules = {
+  /** Detect signal inside loops or conditionals */
+  "no-signals-in-conditionals": {
+    name: "no-signals-in-conditionals",
+    description: "Signal functions should not be called inside conditionals, loops, or nested functions",
+    check(source2) {
+      const violations = [];
+      const hookNames = ["signal", "effect", "derived", "memo", "memoFn", "ref", "watch", "store"];
+      const hookPattern = new RegExp(`\\b(${hookNames.join("|")})\\s*\\(`, "g");
+      const lines = source2.split("\n");
+      for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const line2 = lines[lineIdx];
+        const trimmed = line2.trim();
+        if (trimmed.startsWith("import ")) continue;
+        hookPattern.lastIndex = 0;
+        const hookMatch = hookPattern.exec(line2);
+        if (!hookMatch) continue;
+        const hookName = hookMatch[1];
+        let braceDepth = 0;
+        let insideConditionalOrLoop = false;
+        let insideNestedFunction = false;
+        let functionDepth = 0;
+        for (let i2 = 0; i2 <= lineIdx; i2++) {
+          const scanLine = lines[i2].trim();
+          if (/\b(function\s+\w+|function\s*\(|=>\s*\{)/.test(scanLine) && i2 < lineIdx) {
+            functionDepth++;
+          }
+          if (i2 < lineIdx && /^\s*(if|else\s+if|else|for|while|do|switch)\s*[({]/.test(lines[i2])) {
+            insideConditionalOrLoop = true;
+          }
+          for (const ch of lines[i2]) {
+            if (ch === "{") braceDepth++;
+            if (ch === "}") {
+              braceDepth--;
+              if (braceDepth <= 1) {
+                insideConditionalOrLoop = false;
+              }
+            }
+          }
+        }
+        const beforeHook = line2.substring(0, line2.indexOf(hookMatch[0]));
+        const inlineConditional = /\b(if|else|for|while|switch)\s*\(/.test(beforeHook) || /\?\s*$/.test(beforeHook.trim());
+        if (insideConditionalOrLoop || inlineConditional) {
+          violations.push({
+            rule: "no-signals-in-conditionals",
+            message: `"${hookName}" should not be called inside a conditional or loop. Signal functions must be called at the top level of a component.`,
+            severity: "error",
+            line: lineIdx + 1,
+            column: (hookMatch.index || 0) + 1
+          });
+        }
+        if (functionDepth > 1) {
+          insideNestedFunction = true;
+        }
+        if (insideNestedFunction) {
+          violations.push({
+            rule: "no-signals-in-conditionals",
+            message: `"${hookName}" should not be called inside a nested function. Signal functions must be called at the top level of a component.`,
+            severity: "error",
+            line: lineIdx + 1,
+            column: (hookMatch.index || 0) + 1
+          });
+        }
+      }
+      return violations;
+    }
+  },
+  /** Detect missing cleanup in effect */
+  "effect-cleanup": {
+    name: "effect-cleanup",
+    description: "effect with subscriptions or timers should return a cleanup function",
+    check(source2) {
+      const violations = [];
+      const subscriptionPatterns = [
+        "addEventListener",
+        "setTimeout",
+        "setInterval",
+        "requestAnimationFrame",
+        "subscribe",
+        "observe",
+        "WebSocket",
+        "EventSource"
+      ];
+      const effectRegex = /\beffect\s*\(\s*((?:function\s*\(?\)?\s*\{|\(\s*\)\s*=>\s*\{|(?=\(\))))/g;
+      let match2;
+      while ((match2 = effectRegex.exec(source2)) !== null) {
+        const startIndex = match2.index;
+        const line2 = getLineNumber(source2, startIndex);
+        const column = getColumnNumber(source2, startIndex);
+        const bodyStart = source2.indexOf("{", match2.index + match2[0].length - 1);
+        if (bodyStart === -1) continue;
+        let depth = 0;
+        let bodyEnd = bodyStart;
+        for (let i2 = bodyStart; i2 < source2.length; i2++) {
+          if (source2[i2] === "{") depth++;
+          if (source2[i2] === "}") {
+            depth--;
+            if (depth === 0) {
+              bodyEnd = i2;
+              break;
+            }
+          }
+        }
+        const effectBody = source2.substring(bodyStart, bodyEnd + 1);
+        const hasSubscription = subscriptionPatterns.some((p2) => effectBody.includes(p2));
+        if (hasSubscription) {
+          const hasRemoveListener = effectBody.includes("removeEventListener");
+          const hasClearTimeout = effectBody.includes("clearTimeout");
+          const hasClearInterval = effectBody.includes("clearInterval");
+          const hasCancelRAF = effectBody.includes("cancelAnimationFrame");
+          const hasUnsubscribe = effectBody.includes("unsubscribe") || effectBody.includes("disconnect") || effectBody.includes(".close(");
+          const hasReturnCleanup = /return\s+/.test(effectBody);
+          const hasCleanup = hasRemoveListener || hasClearTimeout || hasClearInterval || hasCancelRAF || hasUnsubscribe || hasReturnCleanup;
+          if (!hasCleanup) {
+            const foundSubscriptions = [];
+            for (const pattern2 of subscriptionPatterns) {
+              if (effectBody.includes(pattern2)) {
+                foundSubscriptions.push(pattern2);
+              }
+            }
+            violations.push({
+              rule: "effect-cleanup",
+              message: `effect uses ${foundSubscriptions.join(", ")} but does not appear to clean up. Consider returning a cleanup function.`,
+              severity: "warning",
+              line: line2,
+              column
+            });
+          }
+        }
+      }
+      return violations;
+    }
+  },
+  /** Detect direct DOM mutation outside of reactive context */
+  "no-direct-dom-mutation": {
+    name: "no-direct-dom-mutation",
+    description: "Avoid direct DOM mutations; use reactive bindings instead",
+    check(source2) {
+      const violations = [];
+      const mutationPatterns = [
+        {
+          pattern: /\.innerHTML\s*=/g,
+          name: "innerHTML assignment",
+          suggestion: "Use reactive nodes or bindChildNode instead"
+        },
+        {
+          pattern: /\.outerHTML\s*=/g,
+          name: "outerHTML assignment",
+          suggestion: "Use reactive component rendering instead"
+        },
+        {
+          pattern: /document\.write\s*\(/g,
+          name: "document.write()",
+          suggestion: "Use mount() or component rendering instead"
+        },
+        {
+          pattern: /\.insertAdjacentHTML\s*\(/g,
+          name: "insertAdjacentHTML()",
+          suggestion: "Use reactive nodes or each() instead"
+        }
+      ];
+      const lines = source2.split("\n");
+      for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const line2 = lines[lineIdx];
+        const trimmed = line2.trim();
+        if (trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
+        for (const { pattern: pattern2, name, suggestion } of mutationPatterns) {
+          pattern2.lastIndex = 0;
+          const match2 = pattern2.exec(line2);
+          if (match2) {
+            violations.push({
+              rule: "no-direct-dom-mutation",
+              message: `Direct DOM mutation via ${name} detected. ${suggestion}.`,
+              severity: "warning",
+              line: lineIdx + 1,
+              column: (match2.index || 0) + 1
+            });
+          }
+        }
+      }
+      return violations;
+    }
+  },
+  /** Detect missing key prop in each() calls */
+  "each-requires-key": {
+    name: "each-requires-key",
+    description: "each() should include a key function for efficient reconciliation",
+    check(source2) {
+      const violations = [];
+      const eachCallRegex = /\beach\s*\(/g;
+      let match2;
+      while ((match2 = eachCallRegex.exec(source2)) !== null) {
+        const startIndex = match2.index;
+        const line2 = getLineNumber(source2, startIndex);
+        const column = getColumnNumber(source2, startIndex);
+        const parenStart = source2.indexOf("(", startIndex);
+        if (parenStart === -1) continue;
+        let depth = 0;
+        let parenEnd = parenStart;
+        for (let i2 = parenStart; i2 < source2.length; i2++) {
+          if (source2[i2] === "(") depth++;
+          if (source2[i2] === ")") {
+            depth--;
+            if (depth === 0) {
+              parenEnd = i2;
+              break;
+            }
+          }
+        }
+        const callBody = source2.substring(parenStart, parenEnd + 1);
+        const hasKey = /\bkey\s*:/.test(callBody);
+        if (!hasKey) {
+          violations.push({
+            rule: "each-requires-key",
+            message: "each() should include a key function in the options argument (e.g., { key: item => item.id }) for efficient list reconciliation.",
+            severity: "warning",
+            line: line2,
+            column
+          });
+        }
+      }
+      return violations;
+    }
+  },
+  /** Detect unused reactive state */
+  "no-unused-state": {
+    name: "no-unused-state",
+    description: "signal variables should be used in the component",
+    check(source2) {
+      const violations = [];
+      const signalDeclRegex = /\bconst\s+\[\s*(\w+)\s*,\s*(\w+)\s*\]\s*=\s*signal\s*\(/g;
+      let match2;
+      while ((match2 = signalDeclRegex.exec(source2)) !== null) {
+        const getterName = match2[1];
+        const setterName = match2[2];
+        const line2 = getLineNumber(source2, match2.index);
+        const column = getColumnNumber(source2, match2.index);
+        const declarationLine = source2.substring(match2.index, source2.indexOf("\n", match2.index));
+        const restOfSource = source2.replace(declarationLine, "");
+        const getterUsageRegex = new RegExp(`\\b${escapeRegex(getterName)}\\b`, "g");
+        const getterUsages = restOfSource.match(getterUsageRegex);
+        const getterUsed = getterUsages !== null && getterUsages.length > 0;
+        const setterUsageRegex = new RegExp(`\\b${escapeRegex(setterName)}\\b`, "g");
+        const setterUsages = restOfSource.match(setterUsageRegex);
+        const setterUsed = setterUsages !== null && setterUsages.length > 0;
+        if (!getterUsed && !setterUsed) {
+          violations.push({
+            rule: "no-unused-state",
+            message: `signal variable "${getterName}" and setter "${setterName}" are declared but never used. Remove unused state or use the values.`,
+            severity: "warning",
+            line: line2,
+            column
+          });
+        } else if (!getterUsed) {
+          violations.push({
+            rule: "no-unused-state",
+            message: `signal getter "${getterName}" is declared but never read. If the value is not needed, consider using a simple variable instead of reactive state.`,
+            severity: "warning",
+            line: line2,
+            column
+          });
+        } else if (!setterUsed) {
+          violations.push({
+            rule: "no-unused-state",
+            message: `signal setter "${setterName}" is declared but never called. If the state never changes, consider using a plain constant instead.`,
+            severity: "warning",
+            line: line2,
+            column
+          });
+        }
+      }
+      return violations;
+    }
+  }
+};
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function lintSource(source2, rules) {
+  const violations = [];
+  const ruleEntries = Object.entries(lintRules);
+  for (const [ruleName, rule] of ruleEntries) {
+    if (rules && rules.length > 0 && !rules.includes(ruleName)) {
+      continue;
+    }
+    const ruleViolations = rule.check(source2);
+    violations.push(...ruleViolations);
+  }
+  violations.sort((a2, b2) => {
+    const lineDiff = (a2.line || 0) - (b2.line || 0);
+    if (lineDiff !== 0) return lineDiff;
+    return (a2.column || 0) - (b2.column || 0);
+  });
+  return violations;
+}
+function generateEslintConfig(options) {
+  const severity = options?.severity || "warning";
+  const rulePrefix = "sibujs";
+  const rulesConfig = {};
+  for (const ruleName of Object.keys(lintRules)) {
+    rulesConfig[`${rulePrefix}/${ruleName}`] = severity;
+  }
+  return {
+    plugins: [rulePrefix],
+    rules: rulesConfig,
+    settings: {
+      sibujs: {
+        version: "detect"
+      }
+    },
+    overrides: [
+      {
+        files: ["*.ts", "*.tsx", "*.js", "*.jsx"],
+        rules: rulesConfig
+      }
+    ]
+  };
+}
+
+// src/build/ide.ts
+function getComponentMetadata() {
+  return [
+    // ── Reactive Primitives ──────────────────────────────────────────
+    {
+      name: "signal",
+      description: "Creates a reactive signal that holds a value. Returns a [getter, setter] tuple. The getter registers reactive dependencies when called.",
+      props: [
+        {
+          name: "initial",
+          type: "T",
+          required: true,
+          description: "The initial value of the state"
+        }
+      ]
+    },
+    {
+      name: "effect",
+      description: "Runs a side effect function immediately and re-runs it whenever any reactive dependency changes. Returns a cleanup function.",
+      props: [
+        {
+          name: "effectFn",
+          type: "() => void",
+          required: true,
+          description: "The effect function to run. It is tracked for reactive dependencies."
+        }
+      ]
+    },
+    {
+      name: "derived",
+      description: "Creates a derived reactive signal whose value updates automatically when dependencies change. Returns a getter function.",
+      props: [
+        {
+          name: "getter",
+          type: "() => T",
+          required: true,
+          description: "Function returning the computed value based on reactive signals"
+        }
+      ]
+    },
+    {
+      name: "memo",
+      description: "Returns a memoized value that only recomputes when its reactive dependencies change. Alias for derived.",
+      props: [
+        {
+          name: "factory",
+          type: "() => T",
+          required: true,
+          description: "Function that computes the memoized value"
+        }
+      ]
+    },
+    {
+      name: "memoFn",
+      description: "Returns a memoized callback that only updates when its reactive dependencies change.",
+      props: [
+        {
+          name: "callback",
+          type: "() => T",
+          required: true,
+          description: "The callback factory function to memoize"
+        }
+      ]
+    },
+    {
+      name: "ref",
+      description: "Creates a mutable reference object that persists across renders. Updating a ref does NOT trigger re-renders.",
+      props: [
+        {
+          name: "initial",
+          type: "T",
+          required: false,
+          default: "undefined",
+          description: "Optional initial value for the ref"
+        }
+      ]
+    },
+    {
+      name: "watch",
+      description: "Watches a reactive getter and calls a callback with (newValue, oldValue) when the watched value changes. Returns a teardown function.",
+      props: [
+        {
+          name: "getter",
+          type: "() => T",
+          required: true,
+          description: "Function that returns the value to watch"
+        },
+        {
+          name: "callback",
+          type: "(value: T, prev: T | undefined) => void",
+          required: true,
+          description: "Function called when the watched value changes"
+        }
+      ]
+    },
+    {
+      name: "store",
+      description: "Creates a global store with reactive properties and subscription support. Returns a [store, actions] tuple.",
+      props: [
+        {
+          name: "initialState",
+          type: "T extends object",
+          required: true,
+          description: "Initial state object for the store"
+        }
+      ]
+    },
+    // ── SolidJS-style Primitives ─────────────────────────────────────
+    {
+      name: "createSignal",
+      description: "Creates a reactive signal. SolidJS-style alias for signal. Returns [getter, setter].",
+      props: [
+        {
+          name: "value",
+          type: "T",
+          required: true,
+          description: "Initial value"
+        }
+      ]
+    },
+    {
+      name: "createMemo",
+      description: "Creates a derived/computed reactive value. SolidJS-style alias for derived.",
+      props: [
+        {
+          name: "fn",
+          type: "() => T",
+          required: true,
+          description: "Computation function that reads other signals"
+        }
+      ]
+    },
+    {
+      name: "createEffect",
+      description: "Creates a reactive side effect. SolidJS-style alias for effect.",
+      props: [
+        {
+          name: "fn",
+          type: "() => void",
+          required: true,
+          description: "Effect function that reads reactive signals"
+        }
+      ]
+    },
+    // ── Lifecycle ────────────────────────────────────────────────────
+    {
+      name: "onMount",
+      description: "Runs a callback once the component element has been inserted into the DOM. Uses queueMicrotask for deferred execution.",
+      props: [
+        {
+          name: "callback",
+          type: "() => void | CleanupFn",
+          required: true,
+          description: "Function to run after mount. May return a cleanup function."
+        },
+        {
+          name: "element",
+          type: "HTMLElement",
+          required: false,
+          description: "Optional element to observe; if provided, waits until it is connected."
+        }
+      ]
+    },
+    {
+      name: "onUnmount",
+      description: "Runs a callback when the given element is removed from the DOM. Uses MutationObserver to watch for disconnection.",
+      props: [
+        {
+          name: "callback",
+          type: "() => void",
+          required: true,
+          description: "Function to run on unmount"
+        },
+        {
+          name: "element",
+          type: "HTMLElement",
+          required: true,
+          description: "The element to watch for removal"
+        }
+      ]
+    },
+    // ── Rendering ────────────────────────────────────────────────────
+    {
+      name: "mount",
+      description: "Mounts a root component into a DOM element. Returns an object with the mounted node and an unmount function.",
+      props: [
+        {
+          name: "component",
+          type: "(() => HTMLElement) | HTMLElement | Node",
+          required: true,
+          description: "Function returning HTMLElement, or an HTMLElement directly"
+        },
+        {
+          name: "container",
+          type: "HTMLElement",
+          required: true,
+          description: "Target DOM element to append the result"
+        }
+      ]
+    },
+    {
+      name: "each",
+      description: "Renders a list of nodes efficiently with key-based diffing and LIS-based move minimization.",
+      props: [
+        {
+          name: "getArray",
+          type: "() => T[]",
+          required: true,
+          description: "A reactive getter returning an array"
+        },
+        {
+          name: "render",
+          type: "(item: T, index: number) => NodeChild",
+          required: true,
+          description: "A function that returns a NodeChild for each item"
+        },
+        {
+          name: "options",
+          type: "{ key: (item: T) => string | number }",
+          required: true,
+          description: "A key function for unique identity of items"
+        }
+      ]
+    },
+    {
+      name: "lazy",
+      description: "Enables code-splitting by deferring the import of a component until it is first rendered.",
+      props: [
+        {
+          name: "importFn",
+          type: "() => Promise<{ default: Component }>",
+          required: true,
+          description: "Dynamic import function returning { default: Component }"
+        }
+      ]
+    },
+    {
+      name: "Suspense",
+      description: "Provides a fallback UI while lazy or async nodes are loading.",
+      props: [
+        {
+          name: "nodes",
+          type: "() => HTMLElement",
+          required: true,
+          description: "Function that returns the async/lazy component"
+        },
+        {
+          name: "fallback",
+          type: "() => HTMLElement",
+          required: true,
+          description: "Function that returns the loading UI"
+        }
+      ]
+    },
+    // ── Context ──────────────────────────────────────────────────────
+    {
+      name: "context",
+      description: "Creates a context for dependency injection across component trees without prop drilling. Returns a Context object with provide, use, get, and set methods.",
+      props: [
+        {
+          name: "defaultValue",
+          type: "T",
+          required: true,
+          description: "The fallback value when no provider is found"
+        }
+      ]
+    },
+    // ── Dynamic Components ───────────────────────────────────────────
+    {
+      name: "DynamicComponent",
+      description: "Reactively switches between components based on a reactive getter returning a component name or function.",
+      props: [
+        {
+          name: "is",
+          type: "() => string | Component",
+          required: true,
+          description: "Reactive getter returning component name (string) or component function"
+        }
+      ]
+    },
+    {
+      name: "registerComponent",
+      description: "Registers a component by name for dynamic resolution via DynamicComponent or resolveComponent.",
+      props: [
+        {
+          name: "name",
+          type: "string",
+          required: true,
+          description: "Unique component identifier"
+        },
+        {
+          name: "component",
+          type: "() => HTMLElement",
+          required: true,
+          description: "The component function"
+        }
+      ]
+    },
+    // ── HTML Tag Factories ───────────────────────────────────────────
+    {
+      name: "div",
+      description: "Creates a reactive <div> element. Accepts TagProps including class, style, on, nodes, and arbitrary attributes.",
+      props: [
+        {
+          name: "props",
+          type: "TagProps",
+          required: false,
+          default: "{}",
+          description: "Props object with id, class, style, ref, nodes, on, and other attributes"
+        }
+      ],
+      events: [
+        {
+          name: "click",
+          description: "Fires when the element is clicked"
+        },
+        {
+          name: "input",
+          description: "Fires when user input is received"
+        }
+      ]
+    }
+  ];
+}
+function generateVSCodeSnippets() {
+  return {
+    "SibuJS Component": {
+      prefix: "sibu-component",
+      body: [
+        "import { div } from 'sibujs';",
+        "",
+        "export function ${1:ComponentName}(): HTMLElement {",
+        "	return div({",
+        "		class: '${2:component-class}',",
+        "		nodes: [",
+        "			${3:// nodes here}",
+        "		],",
+        "	});",
+        "}"
+      ],
+      description: "Create a basic SibuJS component"
+    },
+    "SibuJS Component with State": {
+      prefix: "sibu-component-state",
+      body: [
+        "import { div, span } from 'sibujs';",
+        "import { signal } from 'sibujs';",
+        "",
+        "export function ${1:ComponentName}(): HTMLElement {",
+        "	const [${2:value}, ${3:setValue}] = signal(${4:initialValue});",
+        "",
+        "	return div({",
+        "		class: '${5:component-class}',",
+        "		nodes: [",
+        "			() => span({ nodes: String(${2:value}()) }),",
+        "		],",
+        "	});",
+        "}"
+      ],
+      description: "Create a SibuJS component with reactive state"
+    },
+    "SibuJS signal": {
+      prefix: "sibu-state",
+      body: ["const [${1:value}, ${2:setValue}] = signal(${3:initialValue});"],
+      description: "Create a reactive state with signal"
+    },
+    "SibuJS effect": {
+      prefix: "sibu-effect",
+      body: ["const cleanup = effect(() => {", "	${1:// effect logic}", "});"],
+      description: "Create a reactive side effect with effect"
+    },
+    "SibuJS derived": {
+      prefix: "sibu-computed",
+      body: ["const ${1:computed} = derived(() => {", "	return ${2:// derived value};", "});"],
+      description: "Create a derived reactive value with derived"
+    },
+    "SibuJS watch": {
+      prefix: "sibu-watch",
+      body: [
+        "const teardown = watch(",
+        "	() => ${1:watchedValue}(),",
+        "	(newVal, oldVal) => {",
+        "		${2:// handle change}",
+        "	}",
+        ");"
+      ],
+      description: "Watch a reactive value for changes"
+    },
+    "SibuJS each": {
+      prefix: "sibu-each",
+      body: [
+        "each(",
+        "	() => ${1:items}(),",
+        "	(item, index) => {",
+        "		return ${2:div({ nodes: String(item) })};",
+        "	},",
+        "	{ key: (item) => ${3:item.id} }",
+        ")"
+      ],
+      description: "Create a reactive list with each()"
+    },
+    "SibuJS Context": {
+      prefix: "sibu-context",
+      body: [
+        "const ${1:MyContext} = context(${2:defaultValue});",
+        "",
+        "// In provider component:",
+        "// ${1:MyContext}.provide(value);",
+        "",
+        "// In consumer component:",
+        "// const ${3:value} = ${1:MyContext}.use();"
+      ],
+      description: "Create a context for dependency injection"
+    },
+    "SibuJS store": {
+      prefix: "sibu-store",
+      body: [
+        "const [${1:store}, { setState: ${2:setStore}, reset, subscribe }] = store({",
+        "	${3:key}: ${4:value},",
+        "});"
+      ],
+      description: "Create a reactive global store"
+    },
+    "SibuJS Lazy Component": {
+      prefix: "sibu-lazy",
+      body: ["const ${1:LazyComponent} = lazy(() => import('./${2:ComponentPath}'));"],
+      description: "Create a lazy-loaded component"
+    },
+    "SibuJS Suspense": {
+      prefix: "sibu-suspense",
+      body: [
+        "Suspense({",
+        "	nodes: () => ${1:LazyComponent}(),",
+        "	fallback: () => div({ nodes: '${2:Loading...}' }),",
+        "})"
+      ],
+      description: "Wrap a lazy component with a loading fallback"
+    },
+    "SibuJS onMount": {
+      prefix: "sibu-mount",
+      body: ["onMount(() => {", "	${1:// runs after component enters the DOM}", "});"],
+      description: "Schedule a callback to run after mount"
+    },
+    "SibuJS onUnmount": {
+      prefix: "sibu-unmount",
+      body: ["onUnmount(() => {", "	${1:// cleanup when removed from DOM}", "}, ${2:element});"],
+      description: "Schedule a callback to run on unmount"
+    },
+    "SibuJS Event Handler": {
+      prefix: "sibu-event",
+      body: [
+        "div({",
+        "	on: {",
+        "		${1:click}: (e) => {",
+        "			${2:// handle event}",
+        "		},",
+        "	},",
+        "	nodes: '${3:Click me}',",
+        "})"
+      ],
+      description: "Create an element with event handlers"
+    },
+    "SibuJS Form": {
+      prefix: "sibu-form",
+      body: [
+        "const form = form({",
+        "	${1:fieldName}: {",
+        "		initial: '${2:}',",
+        "		validators: [",
+        "			(value) => !value ? '${3:Required}' : null,",
+        "		],",
+        "	},",
+        "});"
+      ],
+      description: "Create a reactive form with validation"
+    },
+    "SibuJS createSignal": {
+      prefix: "sibu-signal",
+      body: ["const [${1:value}, ${2:setValue}] = createSignal(${3:initialValue});"],
+      description: "Create a reactive signal (SolidJS-style alias for signal)"
+    }
+  };
+}
+function generateLanguageConfig() {
+  return {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"],
+      ["<", ">"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" },
+      { open: "'", close: "'" },
+      { open: '"', close: '"' },
+      { open: "`", close: "`" }
+    ]
+  };
+}
+function generateTypeStubs() {
+  return {
+    signal: ["declare function signal<T>(initial: T): [() => T, (next: T | ((prev: T) => T)) => void];"].join("\n"),
+    effect: ["declare function effect(effectFn: () => void): () => void;"].join("\n"),
+    derived: ["declare function derived<T>(getter: () => T): () => T;"].join("\n"),
+    memo: ["declare function memo<T>(factory: () => T): () => T;"].join("\n"),
+    memoFn: ["declare function memoFn<T extends (...args: unknown[]) => unknown>(callback: () => T): () => T;"].join(
+      "\n"
+    ),
+    ref: [
+      "interface Ref<T> { current: T; }",
+      "declare function ref<T>(initial: T): Ref<T>;",
+      "declare function ref<T = undefined>(): Ref<T | undefined>;"
+    ].join("\n"),
+    watch: [
+      "declare function watch<T>(getter: () => T, callback: (value: T, prev: T | undefined) => void): () => void;"
+    ].join("\n"),
+    store: [
+      "interface StoreActions<T> {",
+      "  setState: (patch: Partial<T> | ((state: T) => T)) => void;",
+      "  reset: () => void;",
+      "  subscribe: (callback: (state: T) => void) => () => void;",
+      "  subscribeKey: <K extends keyof T>(key: K, callback: (value: T[K], prev: T[K]) => void) => () => void;",
+      "  getSnapshot: () => T;",
+      "}",
+      "declare function store<T extends object>(initialState: T): [{ readonly [K in keyof T]: T[K] }, StoreActions<T>];"
+    ].join("\n"),
+    createSignal: ["declare function createSignal<T>(value: T): [() => T, (next: T | ((prev: T) => T)) => void];"].join(
+      "\n"
+    ),
+    createMemo: ["declare function createMemo<T>(fn: () => T): () => T;"].join("\n"),
+    createEffect: ["declare function createEffect(fn: () => void): () => void;"].join("\n"),
+    mount: [
+      "declare function mount(component: (() => HTMLElement) | HTMLElement | Node, container: HTMLElement | null): { node: Node; unmount: () => void };"
+    ].join("\n"),
+    each: [
+      "declare function each<T>(getArray: () => T[], render: (item: T, index: number) => NodeChild, options: { key: (item: T) => string | number }): Comment;"
+    ].join("\n"),
+    onMount: ["declare function onMount(callback: () => void | (() => void), element?: HTMLElement): void;"].join("\n"),
+    onUnmount: ["declare function onUnmount(callback: () => void, element: HTMLElement): void;"].join("\n"),
+    context: [
+      "interface Context<T> {",
+      "  provide(value: T): void;",
+      "  use(): () => T;",
+      "  get(): T;",
+      "  set(value: T): void;",
+      "}",
+      "declare function context<T>(defaultValue: T): Context<T>;"
+    ].join("\n"),
+    lazy: ["declare function lazy(importFn: () => Promise<{ default: () => HTMLElement }>): () => HTMLElement;"].join(
+      "\n"
+    ),
+    Suspense: [
+      "interface SuspenseProps { nodes: () => HTMLElement; fallback: () => HTMLElement; }",
+      "declare function Suspense(props: SuspenseProps): HTMLElement;"
+    ].join("\n"),
+    tagFactory: [
+      "interface TagProps {",
+      "  id?: string;",
+      "  class?: string | (() => string) | Record<string, boolean | (() => boolean)>;",
+      "  style?: Record<string, string | number | (() => string | number)> | string | (() => string);",
+      "  ref?: { current: unknown };",
+      "  nodes?: NodeChildren;",
+      "  on?: Record<string, (ev: Event) => void>;",
+      "  [attr: string]: unknown;",
+      "}",
+      "declare function tagFactory(tag: string, ns?: string): (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;"
+    ].join("\n"),
+    DynamicComponent: ["declare function DynamicComponent(is: () => string | (() => HTMLElement)): HTMLElement;"].join(
+      "\n"
+    ),
+    registerComponent: ["declare function registerComponent(name: string, component: () => HTMLElement): void;"].join(
+      "\n"
+    )
+  };
+}
+
+// src/build/routeSplitting.ts
+function fileToRoute(relativePath) {
+  const basename = relativePath.split("/").pop() || "";
+  if (basename.startsWith("_")) return null;
+  let route = relativePath.replace(/\.(ts|tsx|js|jsx)$/, "");
+  route = route.replace(/\/index$/, "").replace(/^index$/, "");
+  route = route.replace(/\[\.\.\.(\w+)\]/g, "*");
+  route = route.replace(/\[(\w+)\]/g, ":$1");
+  return `/${route}`;
+}
+async function scanRoutes(routesDir, exclude, fs) {
+  const entries = await fs.readdir(routesDir, { withFileTypes: true, recursive: true });
+  const files = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (!/\.(ts|tsx|js|jsx)$/.test(entry.name)) continue;
+    const dir = (entry.parentPath || entry.path || routesDir).replace(/\\/g, "/");
+    const routesDirNorm = routesDir.replace(/\\/g, "/");
+    const relative = `${dir}/${entry.name}`.replace(`${routesDirNorm}/`, "").replace(/\\/g, "/");
+    const excluded = exclude.some((pattern2) => {
+      const regex = pattern2.replace(/\*/g, ".*");
+      return new RegExp(regex).test(relative);
+    });
+    if (!excluded) {
+      files.push(relative);
+    }
+  }
+  return files.sort();
+}
+function buildRouteEntries(files, chunkPrefix) {
+  const entries = [];
+  for (const file of files) {
+    const path2 = fileToRoute(file);
+    if (path2 === null) continue;
+    const chunkName = `${chunkPrefix}${file.replace(/\.(ts|tsx|js|jsx)$/, "").replace(/[/\\[\].]/g, "-").replace(/^-+|-+$/g, "").toLowerCase()}`;
+    entries.push({
+      path: path2,
+      importPath: file,
+      chunkName,
+      isDynamic: path2.includes(":") || path2.includes("*")
+    });
+  }
+  return entries.sort((a2, b2) => {
+    if (a2.path.includes("*") && !b2.path.includes("*")) return 1;
+    if (!a2.path.includes("*") && b2.path.includes("*")) return -1;
+    if (a2.isDynamic && !b2.isDynamic) return 1;
+    if (!a2.isDynamic && b2.isDynamic) return -1;
+    return a2.path.localeCompare(b2.path);
+  });
+}
+function generateRouteModule(entries, routesDir) {
+  const imports = entries.map(
+    (e, i2) => `const route${i2} = () => import(/* webpackChunkName: "${e.chunkName}" */ "${routesDir}/${e.importPath}");`
+  ).join("\n");
+  const routes = entries.map((e, i2) => `  { path: "${e.path}", component: lazy(route${i2}) }`).join(",\n");
+  return `import { lazy } from "sibu";
+
+${imports}
+
+export const routes = [
+${routes}
+];
+`;
+}
+var VIRTUAL_ID = "virtual:sibu-routes";
+var RESOLVED_VIRTUAL_ID = `\0${VIRTUAL_ID}`;
+function sibuRouteSplitting(options = {}) {
+  const { routesDir = "src/routes", exclude = [], chunkPrefix = "route-" } = options;
+  let projectRoot = "";
+  return {
+    name: "sibu-route-splitting",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === VIRTUAL_ID) {
+        return RESOLVED_VIRTUAL_ID;
+      }
+      return void 0;
+    },
+    async load(id) {
+      if (id !== RESOLVED_VIRTUAL_ID) return void 0;
+      const { readdir } = await import("fs/promises");
+      const { resolve } = await import("path");
+      if (!projectRoot) {
+        projectRoot = process.cwd();
+      }
+      const fullRoutesDir = resolve(projectRoot, routesDir);
+      try {
+        const files = await scanRoutes(fullRoutesDir, exclude, {
+          readdir
+        });
+        const entries = buildRouteEntries(files, chunkPrefix);
+        return generateRouteModule(entries, routesDir.startsWith("/") ? routesDir : `./${routesDir}`);
+      } catch {
+        return "export const routes = [];\n";
+      }
+    },
+    handleHotUpdate(ctx) {
+      const normalizedRoutesDir = routesDir.replace(/\\/g, "/");
+      if (ctx.file.replace(/\\/g, "/").includes(normalizedRoutesDir)) {
+        const mod = ctx.server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ID);
+        if (mod) {
+          ctx.server.moduleGraph.invalidateModule(mod);
+          ctx.server.ws.send({ type: "full-reload" });
+        }
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyzeBundle,
+  analyzeStaticTemplates,
+  buildRouteEntries,
+  cdnUrls,
+  compileHtmlTemplates,
+  createPureAnnotationsLoader,
+  createViteConfig,
+  createWebpackConfig,
+  estimateImportSize,
+  fileToRoute,
+  generateEslintConfig,
+  generateImportMap,
+  generateLanguageConfig,
+  generateTsConfig,
+  generateTypeStubs,
+  generateVSCodeSnippets,
+  getComponentMetadata,
+  lintRules,
+  lintSource,
+  moduleSizes,
+  registerGlobal,
+  sibuRouteSplitting,
+  sibuVitePlugin,
+  sibuWebpackPlugin,
+  umdWrapper,
+  validateTsConfig
+});