round-core 0.1.0 → 0.1.2

package/dist/vite-plugin.js

@@ -1,298 +1,394 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import fs from "node:fs";
 import path from "node:path";
-function transform(code) {
+function transform(code, initialDepth = 0) {
+  let result = "";
+  let i = 0;
+  let jsxDepth = initialDepth;
   function parseBlock(str, startIndex) {
     let open = 0;
     let startBlockIndex = -1;
-    let endBlockIndex = -1;
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplate = false;
-    let inCommentLine = false;
-    let inCommentMulti = false;
-    for (let i = startIndex; i < str.length; i++) {
-      const ch = str[i];
-      const prev2 = i > 0 ? str[i - 1] : "";
-      const next = i < str.length - 1 ? str[i + 1] : "";
-      if (inCommentLine) {
-        if (ch === "\n" || ch === "\r") inCommentLine = false;
+    let inSingle2 = false, inDouble2 = false, inTemplate2 = false;
+    let inCommentLine2 = false, inCommentMulti2 = false;
+    for (let j = startIndex; j < str.length; j++) {
+      const ch = str[j];
+      const prev = j > 0 ? str[j - 1] : "";
+      const next = j < str.length - 1 ? str[j + 1] : "";
+      if (inCommentLine2) {
+        if (ch === "\n" || ch === "\r") inCommentLine2 = false;
         continue;
       }
-      if (inCommentMulti) {
+      if (inCommentMulti2) {
         if (ch === "*" && next === "/") {
-          inCommentMulti = false;
-          i++;
+          inCommentMulti2 = false;
+          j++;
         }
         continue;
       }
-      if (inTemplate) {
-        if (ch === "`" && prev2 !== "\\") inTemplate = false;
+      if (inTemplate2) {
+        if (ch === "`" && prev !== "\\") inTemplate2 = false;
         continue;
       }
-      if (inSingle) {
-        if (ch === "'" && prev2 !== "\\") inSingle = false;
+      if (inSingle2) {
+        if (ch === "'" && prev !== "\\") inSingle2 = false;
         continue;
       }
-      if (inDouble) {
-        if (ch === '"' && prev2 !== "\\") inDouble = false;
+      if (inDouble2) {
+        if (ch === '"' && prev !== "\\") inDouble2 = false;
         continue;
       }
       if (ch === "/" && next === "/") {
-        inCommentLine = true;
-        i++;
+        inCommentLine2 = true;
+        j++;
         continue;
       }
       if (ch === "/" && next === "*") {
-        inCommentMulti = true;
-        i++;
+        inCommentMulti2 = true;
+        j++;
         continue;
       }
       if (ch === "`") {
-        inTemplate = true;
+        inTemplate2 = true;
         continue;
       }
       if (ch === "'") {
-        inSingle = true;
+        inSingle2 = true;
         continue;
       }
       if (ch === '"') {
-        inDouble = true;
+        inDouble2 = true;
         continue;
       }
       if (ch === "{") {
-        if (open === 0) startBlockIndex = i;
+        if (open === 0) startBlockIndex = j;
         open++;
       } else if (ch === "}") {
         open--;
         if (open === 0) {
-          endBlockIndex = i;
-          return { start: startBlockIndex, end: endBlockIndex };
+          return { start: startBlockIndex, end: j };
         }
       }
     }
     return null;
   }
-  let result = code;
-  function consumeWhitespace(str, i) {
-    while (i < str.length && /\s/.test(str[i])) i++;
-    return i;
+  __name(parseBlock, "parseBlock");
+  function consumeWhitespace(str, idx) {
+    while (idx < str.length && /\s/.test(str[idx])) idx++;
+    return idx;
   }
-  function parseIfChain(str, ifIndex) {
-    const head = str.slice(ifIndex);
-    const m = head.match(/^if\s*\((.*?)\)\s*\{/);
-    if (!m) return null;
-    let i = ifIndex;
+  __name(consumeWhitespace, "consumeWhitespace");
+  function extractCondition(str, startIndex) {
+    if (str[startIndex] !== "(") return null;
+    let depth = 1;
+    let j = startIndex + 1;
+    let inSingle2 = false, inDouble2 = false, inTemplate2 = false;
+    while (j < str.length && depth > 0) {
+      const ch = str[j], prev = str[j - 1] || "";
+      if (!inDouble2 && !inTemplate2 && ch === "'" && prev !== "\\") inSingle2 = !inSingle2;
+      else if (!inSingle2 && !inTemplate2 && ch === '"' && prev !== "\\") inDouble2 = !inDouble2;
+      else if (!inSingle2 && !inDouble2 && ch === "`" && prev !== "\\") inTemplate2 = !inTemplate2;
+      if (!inSingle2 && !inDouble2 && !inTemplate2) {
+        if (ch === "(") depth++;
+        else if (ch === ")") depth--;
+      }
+      j++;
+    }
+    if (depth !== 0) return null;
+    return { cond: str.substring(startIndex + 1, j - 1), end: j };
+  }
+  __name(extractCondition, "extractCondition");
+  function handleIf(currI, isBare = false) {
+    let startPtr = currI;
+    if (!isBare) {
+      startPtr = consumeWhitespace(code, currI + 1);
+    }
+    if (!code.startsWith("if", startPtr)) return null;
+    let ptr = startPtr + 2;
+    ptr = consumeWhitespace(code, ptr);
+    if (code[ptr] !== "(") return null;
     const cases = [];
     let elseContent = null;
+    let currentPtr = ptr;
+    let first = true;
     while (true) {
-      const cur = str.slice(i);
-      const mm = cur.match(/^if\s*\((.*?)\)\s*\{/);
-      if (!mm) return null;
-      let cond = mm[1];
-      const trimmedCond = String(cond).trim();
-      const isSimplePath = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/.test(trimmedCond);
-      if (isSimplePath && !trimmedCond.endsWith(")")) {
-        cond = `((typeof (${trimmedCond}) === 'function' && typeof (${trimmedCond}).peek === 'function' && ('value' in (${trimmedCond}))) ? (${trimmedCond})() : (${trimmedCond}))`;
-      }
-      const blockStart = i + mm[0].length - 1;
-      const block = parseBlock(str, blockStart);
+      if (!first) {
+        if (!code.startsWith("if", currentPtr)) break;
+        currentPtr += 2;
+        currentPtr = consumeWhitespace(code, currentPtr);
+      }
+      first = false;
+      const condRes = extractCondition(code, currentPtr);
+      if (!condRes) return null;
+      currentPtr = consumeWhitespace(code, condRes.end);
+      if (code[currentPtr] !== "{") return null;
+      const block = parseBlock(code, currentPtr);
       if (!block) return null;
-      const content = str.substring(block.start + 1, block.end);
-      cases.push({ cond, content });
-      i = block.end + 1;
-      i = consumeWhitespace(str, i);
-      if (!str.startsWith("else", i)) {
+      const rawContent = code.substring(block.start + 1, block.end);
+      const transformedContent = transform(rawContent, 1);
+      cases.push({ cond: condRes.cond, content: transformedContent });
+      currentPtr = block.end + 1;
+      currentPtr = consumeWhitespace(code, currentPtr);
+      if (code.startsWith("else", currentPtr)) {
+        currentPtr += 4;
+        currentPtr = consumeWhitespace(code, currentPtr);
+        if (code.startsWith("if", currentPtr)) {
+          continue;
+        } else if (code[currentPtr] === "{") {
+          const elseBlock = parseBlock(code, currentPtr);
+          if (!elseBlock) return null;
+          const rawElse = code.substring(elseBlock.start + 1, elseBlock.end);
+          elseContent = transform(rawElse, 1);
+          currentPtr = elseBlock.end + 1;
+          break;
+        } else {
+          return null;
+        }
+      } else {
         break;
       }
-      i += 4;
-      i = consumeWhitespace(str, i);
-      if (str.startsWith("if", i)) {
-        continue;
-      }
-      if (str[i] !== "{") return null;
-      const elseBlock = parseBlock(str, i);
-      if (!elseBlock) return null;
-      elseContent = str.substring(elseBlock.start + 1, elseBlock.end);
-      i = elseBlock.end + 1;
-      break;
-    }
-    const end = i;
+    }
+    let endIdx = currentPtr;
+    if (!isBare) {
+      endIdx = consumeWhitespace(code, endIdx);
+      if (code[endIdx] !== "}") return null;
+      endIdx++;
+    }
     let expr = "";
     for (let idx = 0; idx < cases.length; idx++) {
       const c = cases[idx];
-      const body = `<Fragment>${c.content}</Fragment>`;
-      if (idx === 0) {
-        expr = `(${c.cond}) ? (${body}) : `;
-      } else {
-        expr += `(${c.cond}) ? (${body}) : `;
+      let cond = c.cond.trim();
+      const isSimplePath = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/.test(cond);
+      if (isSimplePath && !cond.endsWith(")")) {
+        cond = `((typeof (${cond}) === 'function' && typeof (${cond}).peek === 'function' && ('value' in (${cond}))) ? (${cond})() : (${cond}))`;
       }
+      const body = `<Fragment>${c.content}</Fragment>`;
+      expr += `(${cond}) ? (${body}) : `;
     }
-    if (elseContent !== null) {
-      expr += `(<Fragment>${elseContent}</Fragment>)`;
-    } else {
-      expr += "null";
-    }
-    const replacement = `(() => ${expr})`;
-    return { start: ifIndex, end, replacement };
+    expr += elseContent ? `(<Fragment>${elseContent}</Fragment>)` : "null";
+    return { end: endIdx, replacement: `{(() => ${expr})}` };
   }
-  function parseIfStatement(str, ifIndex) {
-    if (!str.startsWith("if", ifIndex)) return null;
-    const chain = parseIfChain(str, ifIndex);
-    if (!chain) return null;
-    return {
-      start: chain.start,
-      end: chain.end,
-      replacement: `{${chain.replacement}}`
-    };
+  __name(handleIf, "handleIf");
+  function handleFor(currI, isBare = false) {
+    let ptr = currI;
+    if (!isBare) ptr = consumeWhitespace(code, currI + 1);
+    if (!code.startsWith("for", ptr)) return null;
+    ptr += 3;
+    ptr = consumeWhitespace(code, ptr);
+    const condRes = extractCondition(code, ptr);
+    if (!condRes) return null;
+    const forCond = condRes.cond;
+    const inMatch = forCond.match(/^\s*(\S+)\s+in\s+(.+)$/);
+    if (!inMatch) return null;
+    const item = inMatch[1].trim();
+    const list = inMatch[2].trim();
+    ptr = consumeWhitespace(code, condRes.end);
+    if (code[ptr] !== "{") return null;
+    const block = parseBlock(code, ptr);
+    if (!block) return null;
+    const rawContent = code.substring(block.start + 1, block.end);
+    const transformedContent = transform(rawContent, 1);
+    let endIdx = block.end + 1;
+    if (!isBare) {
+      endIdx = consumeWhitespace(code, endIdx);
+      if (code[endIdx] !== "}") return null;
+      endIdx++;
+    }
+    const replacement = `{(() => ${list}.map(${item} => (<Fragment>${transformedContent}</Fragment>)))}`;
+    return { end: endIdx, replacement };
   }
-  function parseIfExpression(str, exprStart) {
-    if (str[exprStart] !== "{") return null;
-    let i = consumeWhitespace(str, exprStart + 1);
-    if (!str.startsWith("if", i)) return null;
-    const outer = parseBlock(str, exprStart);
-    if (!outer) return null;
-    const chain = parseIfChain(str, i);
-    if (!chain) return null;
-    return {
-      start: exprStart,
-      end: outer.end + 1,
-      replacement: `{${chain.replacement}}`
-    };
+  __name(handleFor, "handleFor");
+  function handleSwitch(currI, isBare = false) {
+    let ptr = currI;
+    if (!isBare) ptr = consumeWhitespace(code, currI + 1);
+    if (!code.startsWith("switch", ptr)) return null;
+    ptr += 6;
+    ptr = consumeWhitespace(code, ptr);
+    const condRes = extractCondition(code, ptr);
+    if (!condRes) return null;
+    const cond = condRes.cond;
+    ptr = consumeWhitespace(code, condRes.end);
+    if (code[ptr] !== "{") return null;
+    const block = parseBlock(code, ptr);
+    if (!block) return null;
+    const rawContent = code.substring(block.start + 1, block.end);
+    const transformedInner = transform(rawContent, 0);
+    const finalContent = transformedInner.replace(/(case\s+.*?:|default:)([\s\S]*?)(?=case\s+.*?:|default:|$)/g, (m, label, body) => {
+      const trimmed = body.trim();
+      if (!trimmed) return m;
+      if (trimmed.startsWith("return ")) return m;
+      return `${label} return (<Fragment>${body}</Fragment>);`;
+    });
+    let endIdx = block.end + 1;
+    if (!isBare) {
+      endIdx = consumeWhitespace(code, endIdx);
+      if (code[endIdx] !== "}") return null;
+      endIdx++;
+    }
+    const replacement = `{function() { __ROUND_SWITCH_TOKEN__(${cond}) { ${finalContent} } }}`;
+    return { end: endIdx, replacement };
   }
-  let prev = null;
-  while (prev !== result) {
-    prev = result;
-    while (true) {
-      const match = result.match(/\{\s*if\s*\(/);
-      if (!match) break;
-      const matchIndex = match.index;
-      const parsed = parseIfExpression(result, matchIndex);
-      if (!parsed) {
-        console.warn("Unbalanced IF expression found, skipping transformation.");
-        break;
+  __name(handleSwitch, "handleSwitch");
+  let inSingle = false, inDouble = false, inTemplate = false;
+  let inCommentLine = false, inCommentMulti = false;
+  while (i < code.length) {
+    const ch = code[i];
+    const next = i < code.length - 1 ? code[i + 1] : "";
+    const prev = i > 0 ? code[i - 1] : "";
+    if (inCommentLine) {
+      result += ch;
+      if (ch === "\n" || ch === "\r") inCommentLine = false;
+      i++;
+      continue;
+    }
+    if (inCommentMulti) {
+      result += ch;
+      if (ch === "*" && next === "/") {
+        inCommentMulti = false;
+        result += "/";
+        i += 2;
+        continue;
       }
-      const before = result.substring(0, parsed.start);
-      const after = result.substring(parsed.end);
-      result = before + parsed.replacement + after;
+      i++;
+      continue;
     }
-    while (true) {
-      const match = result.match(/(^|[\n\r])\s*if\s*\(/m);
-      if (!match) break;
-      const ifIndex = match.index + match[0].lastIndexOf("if");
-      const parsed = parseIfStatement(result, ifIndex);
-      if (!parsed) break;
-      const before = result.substring(0, parsed.start);
-      const after = result.substring(parsed.end);
-      result = before + parsed.replacement + after;
+    if (inTemplate) {
+      result += ch;
+      if (ch === "`" && prev !== "\\") inTemplate = false;
+      i++;
+      continue;
     }
-    while (true) {
-      const match = result.match(/\{\s*for\s*\((.*?)\s+in\s+(.*?)\)\s*\{/);
-      if (!match) break;
-      const item = match[1];
-      const list = match[2];
-      const exprStart = match.index;
-      const outer = parseBlock(result, exprStart);
-      if (!outer) break;
-      let i = consumeWhitespace(result, exprStart + 1);
-      const head = result.slice(i);
-      const mm = head.match(/^for\s*\((.*?)\s+in\s+(.*?)\)\s*\{/);
-      if (!mm) break;
-      const forStart = i;
-      const blockStart = forStart + mm[0].length - 1;
-      const block = parseBlock(result, blockStart);
-      if (!block) break;
-      const content = result.substring(block.start + 1, block.end);
-      const replacement = `{(() => ${list}.map(${item} => (<Fragment>${content}</Fragment>)))}`;
-      const before = result.substring(0, exprStart);
-      const after = result.substring(outer.end + 1);
-      result = before + replacement + after;
+    if (inSingle) {
+      result += ch;
+      if (ch === "'" && prev !== "\\") inSingle = false;
+      i++;
+      continue;
     }
-    while (true) {
-      const match = result.match(/(^|[\n\r])\s*for\s*\((.*?)\s+in\s+(.*?)\)\s*\{/m);
-      if (!match) break;
-      const exprStart = match.index + match[0].lastIndexOf("for");
-      const item = match[2];
-      const list = match[3];
-      const forHead = result.slice(exprStart);
-      const mm = forHead.match(/^for\s*\((.*?)\s+in\s+(.*?)\)\s*\{/);
-      if (!mm) break;
-      const blockStart = exprStart + mm[0].length - 1;
-      const block = parseBlock(result, blockStart);
-      if (!block) break;
-      const content = result.substring(block.start + 1, block.end);
-      const replacement = `{(() => ${list}.map(${item} => (<Fragment>${content}</Fragment>)))}`;
-      const before = result.substring(0, exprStart);
-      const after = result.substring(block.end + 1);
-      result = before + replacement + after;
+    if (inDouble) {
+      result += ch;
+      if (ch === '"' && prev !== "\\") inDouble = false;
+      i++;
+      continue;
     }
-    while (true) {
-      const match = result.match(/\{\s*switch\s*\(/);
-      if (!match) break;
-      const exprStart = match.index;
-      const outer = parseBlock(result, exprStart);
-      if (!outer) break;
-      let i = consumeWhitespace(result, exprStart + 1);
-      const head = result.slice(i);
-      const mm = head.match(/^switch\s*\((.*?)\)\s*\{/);
-      if (!mm) break;
-      const cond = mm[1];
-      const blockStart = i + mm[0].length - 1;
-      const block = parseBlock(result, blockStart);
-      if (!block) break;
-      const content = result.substring(block.start + 1, block.end);
-      const transformedContent = content.replace(/(case\s+.*?:|default:)([\s\S]*?)(?=case\s+.*?:|default:|$)/g, (m, label, body) => {
-        const trimmedBody = body.trim();
-        if (!trimmedBody) return m;
-        if (trimmedBody.startsWith("return ")) return m;
-        return `${label} return (<Fragment>${body}</Fragment>);`;
-      });
-      const replacement = `{(() => { __ROUND_SWITCH__(${cond}) { ${transformedContent} } })}`;
-      const before = result.substring(0, exprStart);
-      const after = result.substring(outer.end + 1);
-      result = before + replacement + after;
+    if (ch === "/" && next === "/") {
+      inCommentLine = true;
+      result += "//";
+      i += 2;
+      continue;
     }
-    while (true) {
-      const match = result.match(/(^|[\n\r])\s*switch\s*\(/m);
-      if (!match) break;
-      const switchStart = match.index + match[0].lastIndexOf("switch");
-      const head = result.slice(switchStart);
-      const mm = head.match(/^switch\s*\((.*?)\)\s*\{/);
-      if (!mm) break;
-      const cond = mm[1];
-      const blockStart = switchStart + mm[0].length - 1;
-      const block = parseBlock(result, blockStart);
-      if (!block) break;
-      const content = result.substring(block.start + 1, block.end);
-      const transformedContent = content.replace(/(case\s+.*?:|default:)([\s\S]*?)(?=case\s+.*?:|default:|$)/g, (m, label, body) => {
-        const trimmedBody = body.trim();
-        if (!trimmedBody) return m;
-        if (trimmedBody.startsWith("return ")) return m;
-        return `${label} return (<Fragment>${body}</Fragment>);`;
-      });
-      const replacement = `{(() => { __ROUND_SWITCH__(${cond}) { ${transformedContent} } })}`;
-      const before = result.substring(0, switchStart);
-      const after = result.substring(block.end + 1);
-      result = before + replacement + after;
+    if (ch === "/" && next === "*") {
+      inCommentMulti = true;
+      result += "/*";
+      i += 2;
+      continue;
+    }
+    if (ch === "`") {
+      inTemplate = true;
+      result += ch;
+      i++;
+      continue;
+    }
+    if (ch === "'") {
+      inSingle = true;
+      result += ch;
+      i++;
+      continue;
     }
+    if (ch === '"') {
+      inDouble = true;
+      result += ch;
+      i++;
+      continue;
+    }
+    if (ch === "<") {
+      const isTag = /[a-zA-Z0-9_$]/.test(next) || next === ">";
+      if (isTag) jsxDepth++;
+    }
+    if (ch === "<" && next === "/") {
+      if (jsxDepth > 0) jsxDepth--;
+    }
+    if (ch === "/" && next === ">") {
+      if (jsxDepth > 0) jsxDepth--;
+    }
+    if (jsxDepth > 0) {
+      let processed = false;
+      if (ch === "{") {
+        let ptr = consumeWhitespace(code, i + 1);
+        if (code.startsWith("if", ptr)) {
+          const res = handleIf(i, false);
+          if (res) {
+            result += res.replacement;
+            i = res.end;
+            processed = true;
+          }
+        } else if (code.startsWith("for", ptr)) {
+          const res = handleFor(i, false);
+          if (res) {
+            result += res.replacement;
+            i = res.end;
+            processed = true;
+          }
+        } else if (code.startsWith("switch", ptr)) {
+          const res = handleSwitch(i, false);
+          if (res) {
+            result += res.replacement;
+            i = res.end;
+            processed = true;
+          }
+        }
+      } else if (ch === "i" && code.startsWith("if", i)) {
+        let ptr = consumeWhitespace(code, i + 2);
+        if (code[ptr] === "(") {
+          const res = handleIf(i, true);
+          if (res) {
+            result += res.replacement;
+            i = res.end;
+            processed = true;
+          }
+        }
+      } else if (ch === "f" && code.startsWith("for", i)) {
+        let ptr = consumeWhitespace(code, i + 3);
+        if (code[ptr] === "(") {
+          const res = handleFor(i, true);
+          if (res) {
+            result += res.replacement;
+            i = res.end;
+            processed = true;
+          }
+        }
+      } else if (ch === "s" && code.startsWith("switch", i)) {
+        let ptr = consumeWhitespace(code, i + 6);
+        if (code[ptr] === "(") {
+          const res = handleSwitch(i, true);
+          if (res) {
+            result += res.replacement;
+            i = res.end;
+            processed = true;
+          }
+        }
+      }
+      if (processed) continue;
+    }
+    result += ch;
+    i++;
   }
   function findJsxTagEnd(str, startIndex) {
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplate = false;
+    let inSingle2 = false, inDouble2 = false, inTemplate2 = false;
     let braceDepth = 0;
-    for (let i = startIndex; i < str.length; i++) {
-      const ch = str[i];
-      const prevCh = i > 0 ? str[i - 1] : "";
-      if (!inDouble && !inTemplate && ch === "'" && prevCh !== "\\") inSingle = !inSingle;
-      else if (!inSingle && !inTemplate && ch === '"' && prevCh !== "\\") inDouble = !inDouble;
-      else if (!inSingle && !inDouble && ch === "`" && prevCh !== "\\") inTemplate = !inTemplate;
-      if (inSingle || inDouble || inTemplate) continue;
-      if (ch === "{") braceDepth++;
-      else if (ch === "}") braceDepth = Math.max(0, braceDepth - 1);
-      else if (ch === ">" && braceDepth === 0) return i;
+    for (let k = startIndex; k < str.length; k++) {
+      const c = str[k];
+      const p = k > 0 ? str[k - 1] : "";
+      if (!inDouble2 && !inTemplate2 && c === "'" && p !== "\\") inSingle2 = !inSingle2;
+      else if (!inSingle2 && !inTemplate2 && c === '"' && p !== "\\") inDouble2 = !inDouble2;
+      else if (!inSingle2 && !inDouble2 && c === "`" && p !== "\\") inTemplate2 = !inTemplate2;
+      if (inSingle2 || inDouble2 || inTemplate2) continue;
+      if (c === "{") braceDepth++;
+      else if (c === "}") braceDepth = Math.max(0, braceDepth - 1);
+      else if (c === ">" && braceDepth === 0) return k;
     }
     return -1;
   }
+  __name(findJsxTagEnd, "findJsxTagEnd");
   function transformSuspenseBlocks(str) {
     let out = str;
     let cursor = 0;
@@ -306,41 +402,29 @@ function transform(code) {
         cursor = openEnd + 1;
         continue;
       }
-      let depth = 1;
-      let i = openEnd + 1;
-      let closeStart = -1;
-      while (i < out.length) {
-        const nextOpen = out.indexOf("<Suspense", i);
-        const nextClose = out.indexOf("</Suspense>", i);
-        if (nextClose === -1) break;
-        if (nextOpen !== -1 && nextOpen < nextClose) {
-          const innerOpenEnd = findJsxTagEnd(out, nextOpen);
-          if (innerOpenEnd === -1) break;
-          const innerOpenText = out.slice(nextOpen, innerOpenEnd + 1);
-          if (!/\/>\s*$/.test(innerOpenText)) depth++;
-          i = innerOpenEnd + 1;
-          continue;
-        }
-        depth--;
-        if (depth === 0) {
-          closeStart = nextClose;
-          break;
-        }
-        i = nextClose + "</Suspense>".length;
+      let depth = 1, k = openEnd + 1, closeStart = -1;
+      while (k < out.length) {
+        if (out.slice(k).startsWith("<Suspense")) {
+          depth++;
+          k += 9;
+        } else if (out.slice(k).startsWith("</Suspense>")) {
+          depth--;
+          if (depth === 0) {
+            closeStart = k;
+            break;
+          }
+          k += 11;
+        } else k++;
       }
       if (closeStart === -1) break;
       const inner = out.slice(openEnd + 1, closeStart);
-      const innerTrim = inner.trim();
-      if (innerTrim.startsWith("{() =>")) {
-        cursor = closeStart + "</Suspense>".length;
-        continue;
-      }
-      const wrapped = `{() => (<Fragment>${inner}</Fragment>)}`;
+      const wrapped = `{(() => (<Fragment>${inner}</Fragment>))}`;
       out = out.slice(0, openEnd + 1) + wrapped + out.slice(closeStart);
-      cursor = closeStart + wrapped.length + "</Suspense>".length;
+      cursor = closeStart + wrapped.length + 11;
     }
     return out;
   }
+  __name(transformSuspenseBlocks, "transformSuspenseBlocks");
   function transformProviderBlocks(str) {
     let out = str;
     let cursor = 0;
@@ -351,75 +435,73 @@ function transform(code) {
       if (lt === -1) break;
       const openEnd = findJsxTagEnd(out, lt);
       if (openEnd === -1) break;
-      const openTagText = out.slice(lt, openEnd + 1);
-      if (/\/>\s*$/.test(openTagText)) {
+      const tagText = out.slice(lt, openEnd + 1);
+      if (/\/>\s*$/.test(tagText)) {
         cursor = openEnd + 1;
         continue;
       }
-      const m = openTagText.match(/^<\s*([A-Za-z_$][\w$]*\.Provider)\b/);
+      const m = tagText.match(/^<\s*([A-Za-z_$][\w$]*\.Provider)\b/);
       if (!m) {
         cursor = openEnd + 1;
         continue;
       }
       const tagName = m[1];
       const closeTag = `</${tagName}>`;
-      let depth = 1;
-      let i = openEnd + 1;
-      let closeStart = -1;
-      while (i < out.length) {
-        const nextOpen = out.indexOf(`<${tagName}`, i);
-        const nextClose = out.indexOf(closeTag, i);
-        if (nextClose === -1) break;
-        if (nextOpen !== -1 && nextOpen < nextClose) {
-          const innerOpenEnd = findJsxTagEnd(out, nextOpen);
-          if (innerOpenEnd === -1) break;
-          const innerOpenText = out.slice(nextOpen, innerOpenEnd + 1);
-          if (!/\/>\s*$/.test(innerOpenText)) depth++;
-          i = innerOpenEnd + 1;
+      let depth = 1, k = openEnd + 1, closeStart = -1;
+      while (k < out.length) {
+        const nOpen = out.indexOf(`<${tagName}`, k);
+        const nClose = out.indexOf(closeTag, k);
+        if (nClose === -1) break;
+        if (nOpen !== -1 && nOpen < nClose) {
+          const innerEnd = findJsxTagEnd(out, nOpen);
+          if (innerEnd !== -1 && !/\/>\s*$/.test(out.slice(nOpen, innerEnd + 1))) depth++;
+          k = innerEnd + 1;
           continue;
         }
         depth--;
         if (depth === 0) {
-          closeStart = nextClose;
+          closeStart = nClose;
           break;
         }
-        i = nextClose + closeTag.length;
+        k = nClose + closeTag.length;
       }
       if (closeStart === -1) break;
       const inner = out.slice(openEnd + 1, closeStart);
-      const innerTrim = inner.trim();
-      if (innerTrim.startsWith("{() =>")) {
-        cursor = closeStart + closeTag.length;
-        continue;
-      }
-      const wrapped = `{() => (<Fragment>${inner}</Fragment>)}`;
+      const wrapped = `{(() => (<Fragment>${inner}</Fragment>))}`;
       out = out.slice(0, openEnd + 1) + wrapped + out.slice(closeStart);
       cursor = closeStart + wrapped.length + closeTag.length;
     }
     return out;
   }
+  __name(transformProviderBlocks, "transformProviderBlocks");
   result = transformSuspenseBlocks(result);
   result = transformProviderBlocks(result);
   result = result.replace(/\{\s*([A-Za-z_$][\w$]*)\s*\(\s*\)\s*\}/g, "{() => $1()}").replace(/=\{\s*([A-Za-z_$][\w$]*)\s*\(\s*\)\s*\}/g, "={() => $1()}");
-  return result.replace(/__ROUND_SWITCH__/g, "switch");
+  return result.replace(/__ROUND_SWITCH_TOKEN__/g, "switch");
 }
+__name(transform, "transform");
 function normalizePath(p) {
   return p.replaceAll("\\", "/");
 }
+__name(normalizePath, "normalizePath");
 function isMdRawRequest(id) {
   return typeof id === "string" && id.includes(".md") && id.includes("?raw");
 }
+__name(isMdRawRequest, "isMdRawRequest");
 function stripQuery(id) {
   return id.split("?")[0];
 }
+__name(stripQuery, "stripQuery");
 function escapeForJsString(s) {
   return String(s).replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("${", "\\${");
 }
+__name(escapeForJsString, "escapeForJsString");
 function resolveMaybeRelative(baseDir, p) {
   if (!p) return null;
   if (path.isAbsolute(p)) return p;
   return path.resolve(baseDir, p);
 }
+__name(resolveMaybeRelative, "resolveMaybeRelative");
 function inlineMarkdownInRound(code, fileAbs, addWatchFile) {
   if (typeof code !== "string" || typeof fileAbs !== "string") return code;
   const dir = path.dirname(fileAbs);
@@ -447,6 +529,7 @@ ${msg}`);
     }
   });
 }
+__name(inlineMarkdownInRound, "inlineMarkdownInRound");
 function isExcluded(fileAbsPath, excludeAbs) {
   const file = normalizePath(fileAbsPath);
   for (const pat of excludeAbs) {
@@ -456,6 +539,7 @@ function isExcluded(fileAbsPath, excludeAbs) {
   }
   return false;
 }
+__name(isExcluded, "isExcluded");
 function isIncluded(fileAbsPath, includeAbs) {
   if (!includeAbs.length) return true;
   const file = normalizePath(fileAbsPath);
@@ -466,6 +550,7 @@ function isIncluded(fileAbsPath, includeAbs) {
   }
   return false;
 }
+__name(isIncluded, "isIncluded");
 function RoundPlugin(pluginOptions = {}) {
   const state = {
     rootDir: process.cwd(),
@@ -516,6 +601,7 @@ function RoundPlugin(pluginOptions = {}) {
     state.includeAbs = Array.isArray(include) ? include.map((p) => resolveMaybeRelative(includeBase, p)).filter(Boolean) : [];
     state.excludeAbs = Array.isArray(exclude) ? exclude.map((p) => resolveMaybeRelative(excludeBase, p)).filter(Boolean) : [];
   }
+  __name(loadConfigOnce, "loadConfigOnce");
   function findBlock(str, startIndex) {
     let open = 0;
     let inSingle = false;
@@ -541,6 +627,7 @@ function RoundPlugin(pluginOptions = {}) {
     }
     return null;
   }
+  __name(findBlock, "findBlock");
   function parseStartHeadCallArgument(str, fromIndex) {
     const idx = str.indexOf("startHead", fromIndex);
     if (idx === -1) return null;
@@ -569,6 +656,7 @@ function RoundPlugin(pluginOptions = {}) {
     }
     return null;
   }
+  __name(parseStartHeadCallArgument, "parseStartHeadCallArgument");
   function parseStartHeadInDefaultExport(code) {
     const m = code.match(/export\s+default\s+function\b/);
     const hasAnyCall = /\bstartHead\s*\(/.test(code);
@@ -582,6 +670,7 @@ function RoundPlugin(pluginOptions = {}) {
     const call = parseStartHeadCallArgument(body, 0);
     return { headExpr: call ? call.arg : null, hasAny: hasAnyCall, hasOutside: hasAnyCall && !call };
   }
+  __name(parseStartHeadInDefaultExport, "parseStartHeadInDefaultExport");
   function headToHtml(head) {
     if (!head || typeof head !== "object") return "";
     let out = "";
@@ -591,10 +680,10 @@ function RoundPlugin(pluginOptions = {}) {
     }
     const meta = head.meta;
     const links = head.links;
-    const renderAttrs = (attrs) => {
+    const renderAttrs = /* @__PURE__ */ __name((attrs) => {
       if (!attrs || typeof attrs !== "object") return "";
       return Object.entries(attrs).filter(([, v]) => v !== null && v !== void 0).map(([k, v]) => ` ${k}="${String(v).replaceAll('"', "&quot;")}"`).join("");
-    };
+    }, "renderAttrs");
     if (Array.isArray(meta)) {
       meta.forEach((m) => {
         if (!m) return;
@@ -627,6 +716,7 @@ ${head.raw}`;
     }
     return out;
   }
+  __name(headToHtml, "headToHtml");
   return {
     name: "vite-plugin-round",
     enforce: "pre",
@@ -787,6 +877,7 @@ Found: ${trimmed.slice(0, 60)}...`));
     }
   };
 }
+__name(RoundPlugin, "RoundPlugin");
 export {
   RoundPlugin as default
 };