@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/loops.js

@@ -0,0 +1,690 @@
+import { processConditionals } from "./conditionals.js";
+import { ErrorCodes, inlineError } from "./error-handling.js";
+import { processExpressions } from "./expressions.js";
+import { findDirectiveBlocks, findMatchingDelimiter } from "./parser/index.js";
+import { createSafeFunction, freeIdentifiers, isExpressionSafe, isForExpressionSafe, sanitizeExpression, safeEvaluate, safeEvaluateObject } from "./safe-evaluator.js";
+const DEFAULT_MAX_WHILE_ITERATIONS = 1000, DEFAULT_USE_ALT_LOOP_VARIABLE = !1;
+function preEvaluateIncludeData(content, ctx) {
+  const pattern = /@(include|partial)\s*\(\s*(['"])([^'"]+)\2\s*,\s*/g;
+  let result = "", lastIndex = 0, match;
+  while ((match = pattern.exec(content)) !== null) {
+    const argsStart = match.index + match[0].length, openParen = match.index + match[0].indexOf("("), close = findMatchingDelimiter(content, "(", ")", openParen);
+    if (close === -1)
+      continue;
+    const varsString = content.slice(argsStart, close).trim();
+    if (!varsString)
+      continue;
+    if (!Object.keys(ctx).some((name) => new RegExp(`(?:^|[^\\w$.])${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w$])`).test(varsString)))
+      continue;
+    let frozen;
+    try {
+      const evaluated = safeEvaluateObject(varsString, ctx);
+      if (!evaluated || typeof evaluated !== "object")
+        continue;
+      frozen = JSON.stringify(evaluated);
+    } catch {
+      continue;
+    }
+    result += content.slice(lastIndex, argsStart) + frozen;
+    lastIndex = close;
+    pattern.lastIndex = close;
+  }
+  return lastIndex === 0 ? content : result + content.slice(lastIndex);
+}
+function preEvaluateComponentProps(content, ctx) {
+  const componentPat = /@component\s*\(/g;
+  let result = content, match;
+  const replacements = [];
+  while ((match = componentPat.exec(result)) !== null) {
+    const cStart = match.index, openP = cStart + match[0].length - 1;
+    let d = 1, p = openP + 1;
+    while (p < result.length && d > 0) {
+      if (result[p] === "(")
+        d++;
+      else if (result[p] === ")") {
+        d--;
+        if (d === 0)
+          break;
+      }
+      p++;
+    }
+    if (d !== 0)
+      continue;
+    const innerArgs = result.substring(openP + 1, p), directiveEnd = p + 1, pathMatch = innerArgs.match(/^\s*['"]([^'"]+)['"]/);
+    if (!pathMatch)
+      continue;
+    const componentPath = pathMatch[1], afterPath = innerArgs.slice(pathMatch[0].length), propsMatch = afterPath.match(/^\s*,\s*/);
+    if (!propsMatch)
+      continue;
+    const propsString = afterPath.slice(propsMatch[0].length).trim();
+    if (!propsString)
+      continue;
+    try {
+      const evaluated = safeEvaluateObject(propsString, ctx), serialized = JSON.stringify(evaluated), replacement = `@component('${componentPath}', ${serialized})`;
+      replacements.push({ start: cStart, end: directiveEnd, replacement });
+    } catch {
+      continue;
+    }
+  }
+  for (let i = replacements.length - 1;i >= 0; i--) {
+    const { start, end, replacement } = replacements[i];
+    result = result.substring(0, start) + replacement + result.substring(end);
+  }
+  return result;
+}
+function replaceWithBalancedParens(template, directive, callback) {
+  let result = template;
+  const pattern = new RegExp(`${directive.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\(`);
+  let match;
+  while ((match = pattern.exec(result)) !== null) {
+    const start = match.index, openParen = start + match[0].length - 1;
+    let depth = 1, pos = openParen + 1, inStr = null, esc = !1;
+    while (pos < result.length && depth > 0) {
+      const c = result[pos];
+      if (esc) {
+        esc = !1;
+        pos++;
+        continue;
+      }
+      if (c === "\\" && inStr) {
+        esc = !0;
+        pos++;
+        continue;
+      }
+      if (inStr) {
+        if (c === inStr)
+          inStr = null;
+        pos++;
+        continue;
+      }
+      if (c === '"' || c === "'" || c === "`") {
+        inStr = c;
+        pos++;
+        continue;
+      }
+      if (c === "(")
+        depth++;
+      else if (c === ")") {
+        depth--;
+        if (depth === 0)
+          break;
+      }
+      pos++;
+    }
+    if (depth !== 0)
+      break;
+    const expr = result.substring(openParen + 1, pos), replacement = callback(expr);
+    result = result.substring(0, start) + replacement + result.substring(pos + 1);
+  }
+  return result;
+}
+function processPropBindings(content, context) {
+  let result = content;
+  result = result.replace(/:([a-zA-Z_][a-zA-Z0-9_-]*)(?=\s+[^=]|\s*\/?>|\s*$)/g, (match, propName) => {
+    if (propName in context)
+      return `:${propName}="${propName}"`;
+    return match;
+  });
+  result = result.replace(/:([a-zA-Z_][a-zA-Z0-9_-]*)\s*=\s*"([^"]*)"/g, (match, propName, expression) => {
+    try {
+      const contextKeys = Object.keys(context), contextValues = Object.values(context);
+      sanitizeExpression(expression);
+      const value = createSafeFunction(expression, contextKeys)(...contextValues), serialized = JSON.stringify(value);
+      if (serialized === void 0) {
+        if (!freeIdentifiers(expression).some((name) => !(name in context)))
+          return "";
+        return match;
+      }
+      const encoded = Buffer.from(serialized, "utf8").toString("base64");
+      return `__stx_${propName}="${encoded}"`;
+    } catch (error) {
+      return match;
+    }
+  });
+  return result;
+}
+const BREAK_MARKER = "<!--__STX_BREAK__-->", CONTINUE_MARKER = "<!--__STX_CONTINUE__-->";
+function processConditionalLoopControl(content, context) {
+  let result = content;
+  result = replaceWithBalancedParens(result, "@break", (condition) => {
+    try {
+      const boolExpr = `!!(${condition.trim()})`;
+      let shouldBreak;
+      if (isExpressionSafe(boolExpr)) {
+        const condFn = createSafeFunction(boolExpr, Object.keys(context));
+        shouldBreak = Boolean(condFn(...Object.values(context)));
+      } else
+        shouldBreak = Boolean(safeEvaluate(boolExpr, context));
+      return shouldBreak ? BREAK_MARKER : "";
+    } catch {
+      return "";
+    }
+  });
+  result = replaceWithBalancedParens(result, "@continue", (condition) => {
+    try {
+      const boolExpr = `!!(${condition.trim()})`;
+      let shouldContinue;
+      if (isExpressionSafe(boolExpr)) {
+        const condFn = createSafeFunction(boolExpr, Object.keys(context));
+        shouldContinue = Boolean(condFn(...Object.values(context)));
+      } else
+        shouldContinue = Boolean(safeEvaluate(boolExpr, context));
+      return shouldContinue ? CONTINUE_MARKER : "";
+    } catch {
+      return "";
+    }
+  });
+  return result;
+}
+function processUnconditionalLoopControl(content) {
+  let result = content;
+  result = result.replace(/@break(?!\()/g, BREAK_MARKER);
+  result = result.replace(/@continue(?!\()/g, CONTINUE_MARKER);
+  return result;
+}
+function checkAndCleanBreak(content) {
+  const hasBreak = content.includes(BREAK_MARKER), cleanContent = hasBreak ? content.substring(0, content.indexOf(BREAK_MARKER)) : content;
+  return { hasBreak, content: cleanContent };
+}
+function checkAndCleanContinue(content) {
+  const hasContinue = content.includes(CONTINUE_MARKER), cleanContent = hasContinue ? content.substring(0, content.indexOf(CONTINUE_MARKER)) : content;
+  return { hasContinue, content: cleanContent };
+}
+function convertLoopControlToJS(content) {
+  let result = content;
+  result = replaceWithBalancedParens(result, "@break", (condition) => {
+    const trimmed = condition.trim();
+    if (!isForExpressionSafe(trimmed))
+      return "";
+    return `\`; if (${trimmed}) { break; } result += \``;
+  });
+  result = replaceWithBalancedParens(result, "@continue", (condition) => {
+    const trimmed = condition.trim();
+    if (!isForExpressionSafe(trimmed))
+      return "";
+    return `\`; if (${trimmed}) { continue; } result += \``;
+  });
+  result = result.replace(/@break(?!\()/g, "`; break; result += `");
+  result = result.replace(/@continue(?!\()/g, "`; continue; result += `");
+  return result;
+}
+function findOutermostForelse(template) {
+  const forelseRegex = /@forelse\s*\(/g;
+  let match;
+  const foreachEvents = [], foreachOpenScan = /@foreach\s*\(/g, foreachCloseScan = /@endforeach/g;
+  let scanM;
+  while ((scanM = foreachOpenScan.exec(template)) !== null)
+    foreachEvents.push({ pos: scanM.index, delta: 1 });
+  while ((scanM = foreachCloseScan.exec(template)) !== null)
+    foreachEvents.push({ pos: scanM.index, delta: -1 });
+  foreachEvents.sort((a, b) => a.pos - b.pos);
+  const depthAtEvent = [];
+  let runningDepth = 0;
+  for (const ev of foreachEvents) {
+    runningDepth += ev.delta;
+    depthAtEvent.push({ pos: ev.pos, depth: runningDepth });
+  }
+  function getForeachDepthAt(position) {
+    let lo = 0, hi = depthAtEvent.length - 1, result = 0;
+    while (lo <= hi) {
+      const mid = lo + hi >> 1;
+      if (depthAtEvent[mid].pos <= position) {
+        result = depthAtEvent[mid].depth;
+        lo = mid + 1;
+      } else
+        hi = mid - 1;
+    }
+    return result;
+  }
+  while ((match = forelseRegex.exec(template)) !== null) {
+    if (getForeachDepthAt(match.index) > 0)
+      continue;
+    const forelseStart = match.index, openParen = match.index + match[0].length - 1;
+    let parenDepth = 1, pos = openParen + 1, closeParen = -1;
+    while (pos < template.length && parenDepth > 0) {
+      if (template[pos] === "(")
+        parenDepth++;
+      else if (template[pos] === ")") {
+        parenDepth--;
+        if (parenDepth === 0) {
+          closeParen = pos;
+          break;
+        }
+      }
+      pos++;
+    }
+    if (closeParen === -1)
+      continue;
+    const params = template.substring(openParen + 1, closeParen), binding = parseLoopBinding(params);
+    if (!binding)
+      continue;
+    const { arrayExpr, itemVar } = binding, contentStart = closeParen + 1;
+    let depth = 1, searchPos = contentStart;
+    const nestedForelseRegex = /@forelse\s*\(/g, endForelseRegex = /@endforelse/g;
+    let endForelsePos = -1;
+    while (depth > 0 && searchPos < template.length) {
+      nestedForelseRegex.lastIndex = searchPos;
+      endForelseRegex.lastIndex = searchPos;
+      const nextOpen = nestedForelseRegex.exec(template), nextClose = endForelseRegex.exec(template);
+      if (!nextClose)
+        break;
+      if (nextOpen && nextOpen.index < nextClose.index) {
+        depth++;
+        searchPos = nextOpen.index + nextOpen[0].length;
+      } else {
+        depth--;
+        if (depth === 0) {
+          endForelsePos = nextClose.index;
+          break;
+        }
+        searchPos = nextClose.index + 11;
+      }
+    }
+    if (endForelsePos === -1)
+      continue;
+    const fullContent = template.substring(contentStart, endForelsePos), fullEnd = endForelsePos + 11;
+    let emptyPos = -1, nestedDepth = 0, searchI = 0;
+    while (searchI < fullContent.length) {
+      const atPos = fullContent.indexOf("@", searchI);
+      if (atPos === -1)
+        break;
+      const remaining = fullContent.substring(atPos);
+      if (/^@forelse\s*\(/.test(remaining)) {
+        nestedDepth++;
+        searchI = atPos + 1;
+      } else if (remaining.startsWith("@endforelse")) {
+        nestedDepth--;
+        searchI = atPos + 11;
+      } else if (nestedDepth === 0 && remaining.startsWith("@empty")) {
+        if (fullContent.length <= atPos + 6 || !/[a-z]/i.test(fullContent[atPos + 6])) {
+          emptyPos = atPos;
+          break;
+        }
+        searchI = atPos + 1;
+      } else
+        searchI = atPos + 1;
+    }
+    if (emptyPos === -1)
+      continue;
+    return {
+      start: forelseStart,
+      end: fullEnd,
+      arrayExpr,
+      itemVar,
+      foreachContent: fullContent.substring(0, emptyPos),
+      emptyContent: fullContent.substring(emptyPos + 6)
+    };
+  }
+  return null;
+}
+function processForelse(template, context) {
+  let output = template;
+  while (!0) {
+    const found = findOutermostForelse(output);
+    if (!found)
+      break;
+    const { start, end, arrayExpr, itemVar, foreachContent, emptyContent } = found;
+    try {
+      let array;
+      if (isExpressionSafe(arrayExpr))
+        array = createSafeFunction(arrayExpr, Object.keys(context))(...Object.values(context));
+      else
+        array = safeEvaluate(arrayExpr, context);
+      let replacement;
+      if (!Array.isArray(array) || array.length === 0)
+        replacement = emptyContent;
+      else
+        replacement = `@foreach (${arrayExpr} as ${itemVar})${foreachContent}@endforeach`;
+      output = output.substring(0, start) + replacement + output.substring(end);
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error), replacement = inlineError("Forelse", `Error in @forelse(${arrayExpr} as ${itemVar}): ${errMsg}`, ErrorCodes.EVALUATION_ERROR);
+      output = output.substring(0, start) + replacement + output.substring(end);
+    }
+  }
+  return output;
+}
+export function parseLoopBinding(params) {
+  const asIndex = params.indexOf(" as ");
+  if (asIndex !== -1) {
+    const arrayExpr = params.slice(0, asIndex).trim(), itemVar = params.slice(asIndex + 4).trim();
+    return arrayExpr && itemVar ? { arrayExpr, itemVar } : null;
+  }
+  const inMatch = /^\s*(.+?)\s+in\s+([\s\S]+)$/.exec(params);
+  if (!inMatch)
+    return null;
+  const itemVar = inMatch[1].trim().replace(/^\(([\s\S]*)\)$/, "$1").trim(), arrayExpr = inMatch[2].trim();
+  return itemVar && arrayExpr ? { arrayExpr, itemVar } : null;
+}
+export function processLoops(template, context, filePath, options) {
+  let output = template;
+  output = processForelse(output, context);
+  function findMatchingForeach(template) {
+    const foreachRegex = /@foreach\s*\(/g;
+    let match;
+    while ((match = foreachRegex.exec(template)) !== null) {
+      const foreachStart = match.index, openParen = match.index + match[0].length - 1;
+      let parenDepth = 1, pos = openParen + 1, closeParen = -1;
+      while (pos < template.length && parenDepth > 0) {
+        if (template[pos] === "(")
+          parenDepth++;
+        else if (template[pos] === ")") {
+          parenDepth--;
+          if (parenDepth === 0) {
+            closeParen = pos;
+            break;
+          }
+        }
+        pos++;
+      }
+      if (closeParen === -1)
+        continue;
+      const params = template.substring(openParen + 1, closeParen), binding = parseLoopBinding(params);
+      if (!binding)
+        continue;
+      const start = foreachStart, { arrayExpr, itemVar } = binding, contentStart = closeParen + 1;
+      let depth = 1, searchPos = contentStart;
+      const nestedForeachRegex = /@foreach\s*\(/g, endforeachRegex = /@endforeach/g;
+      while (depth > 0 && searchPos < template.length) {
+        nestedForeachRegex.lastIndex = searchPos;
+        endforeachRegex.lastIndex = searchPos;
+        const nextForeach = nestedForeachRegex.exec(template), nextEndforeach = endforeachRegex.exec(template);
+        if (!nextEndforeach)
+          break;
+        if (nextForeach && nextForeach.index < nextEndforeach.index) {
+          depth++;
+          searchPos = nextForeach.index + nextForeach[0].length;
+        } else {
+          depth--;
+          if (depth === 0) {
+            const content = template.substring(contentStart, nextEndforeach.index), end = nextEndforeach.index + 11;
+            return { start, end, arrayExpr, itemVar, content };
+          }
+          searchPos = nextEndforeach.index + 11;
+        }
+      }
+    }
+    return null;
+  }
+  function processForeachWithContext(template, ctx) {
+    let result = template;
+    while (!0) {
+      const match = findMatchingForeach(result);
+      if (!match)
+        break;
+      const { start, end, arrayExpr, itemVar, content } = match;
+      try {
+        const trimmedArrayExpr = arrayExpr.trim();
+        let array;
+        if (isExpressionSafe(trimmedArrayExpr))
+          array = createSafeFunction(trimmedArrayExpr, Object.keys(ctx))(...Object.values(ctx));
+        else
+          array = safeEvaluate(trimmedArrayExpr, ctx);
+        let isObjectEntries = !1;
+        if (!Array.isArray(array))
+          if (array instanceof Map) {
+            array = Array.from(array);
+            isObjectEntries = !0;
+          } else if (array instanceof Set)
+            array = Array.from(array);
+          else if (typeof array === "string")
+            array = Array.from(array);
+          else if (array && typeof array === "object" && !(array instanceof Date) && !(array instanceof RegExp)) {
+            array = Object.entries(array);
+            isObjectEntries = !0;
+          } else {
+            console.warn(`[stx] @foreach(${trimmedArrayExpr}) in ${filePath}: ${trimmedArrayExpr} is not iterable server-side, so the loop rendered nothing. ` + "Values a server loop reads must come from <script server> or the page context \u2014 " + "a plain <script> runs in the browser.");
+            const errorMsg = inlineError("Foreach", `Error in @foreach: ${trimmedArrayExpr} is not iterable`, ErrorCodes.TYPE_ERROR);
+            result = result.substring(0, start) + errorMsg + result.substring(end);
+            continue;
+          }
+        const _useAltLoopVar = options?.loops?.useAltLoopVariable ?? DEFAULT_USE_ALT_LOOP_VARIABLE, trimmedItemVar = itemVar.trim();
+        let indexName = null, itemName, commaIsValueIndex = !1;
+        if (trimmedItemVar.includes("=>")) {
+          const parts = trimmedItemVar.split("=>").map((p) => p.trim());
+          if (parts.length === 2 && parts[0] && parts[1]) {
+            indexName = parts[0];
+            itemName = parts[1];
+          } else
+            itemName = trimmedItemVar;
+        } else if (!trimmedItemVar.startsWith("[") && !trimmedItemVar.startsWith("{") && trimmedItemVar.includes(",")) {
+          const parts = trimmedItemVar.split(",").map((p) => p.trim());
+          if (parts.length === 2 && parts[0] && parts[1]) {
+            itemName = parts[0];
+            indexName = parts[1];
+            commaIsValueIndex = !0;
+          } else
+            itemName = trimmedItemVar;
+        } else
+          itemName = trimmedItemVar;
+        let loopResult = "";
+        const items = array;
+        for (let index = 0;index < items.length; index++) {
+          const item = items[index], loopContext = {
+            index,
+            iteration: index + 1,
+            first: index === 0,
+            last: index === items.length - 1,
+            count: items.length
+          }, itemContext = {
+            ...ctx,
+            loop: loopContext,
+            $loop: loopContext
+          };
+          if (itemName.startsWith("[") && itemName.endsWith("]")) {
+            const destructuredNames = itemName.slice(1, -1).split(",").map((n) => n.trim());
+            if (Array.isArray(item))
+              destructuredNames.forEach((name, i) => {
+                if (name)
+                  itemContext[name] = item[i];
+              });
+            else
+              itemContext[itemName] = item;
+          } else
+            itemContext[itemName] = item;
+          if (indexName)
+            if (!commaIsValueIndex && isObjectEntries && Array.isArray(item) && item.length === 2) {
+              itemContext[indexName] = item[0];
+              itemContext[itemName] = item[1];
+            } else
+              itemContext[indexName] = index;
+          let processedContent = processConditionalLoopControl(content, itemContext), continueCheck = checkAndCleanContinue(processedContent);
+          if (continueCheck.hasContinue) {
+            loopResult += continueCheck.content;
+            continue;
+          }
+          let breakCheck = checkAndCleanBreak(processedContent);
+          if (breakCheck.hasBreak) {
+            loopResult += breakCheck.content;
+            break;
+          }
+          processedContent = processForelse(processedContent, itemContext);
+          processedContent = processForeachWithContext(processedContent, itemContext);
+          processedContent = processConditionals(processedContent, itemContext, filePath);
+          processedContent = processUnconditionalLoopControl(processedContent);
+          breakCheck = checkAndCleanBreak(processedContent);
+          if (breakCheck.hasBreak) {
+            loopResult += breakCheck.content;
+            break;
+          }
+          continueCheck = checkAndCleanContinue(processedContent);
+          if (continueCheck.hasContinue) {
+            loopResult += continueCheck.content;
+            continue;
+          }
+          processedContent = processExpressions(processedContent, itemContext, filePath);
+          processedContent = processPropBindings(processedContent, itemContext);
+          processedContent = preEvaluateComponentProps(processedContent, itemContext);
+          processedContent = preEvaluateIncludeData(processedContent, itemContext);
+          loopResult += processedContent;
+        }
+        result = result.substring(0, start) + loopResult + result.substring(end);
+      } catch (error) {
+        const errorMsg = inlineError("Foreach", `Error in @foreach(${arrayExpr.trim()} as ${itemVar.trim()}): ${error instanceof Error ? error.message : String(error)}`, ErrorCodes.EVALUATION_ERROR);
+        result = result.substring(0, start) + errorMsg + result.substring(end);
+      }
+    }
+    return result;
+  }
+  output = processForeachWithContext(output, context);
+  output = processForLoops(output, context, filePath, options);
+  const maxWhileIterations = options?.loops?.maxWhileIterations ?? DEFAULT_MAX_WHILE_ITERATIONS;
+  output = processWhileLoops(output, context, maxWhileIterations);
+  return output;
+}
+function validateForExpression(expr) {
+  return isForExpressionSafe(expr);
+}
+function processForLoops(template, context, filePath, options) {
+  let output = template, processedAny = !0;
+  while (processedAny) {
+    processedAny = !1;
+    const forMatch = output.match(/@for\s*\(/);
+    if (!forMatch || forMatch.index === void 0)
+      break;
+    const startPos = forMatch.index, openParenPos = startPos + forMatch[0].length - 1, closeParenPos = findMatchingDelimiter(output, "(", ")", openParenPos);
+    if (closeParenPos === -1)
+      break;
+    const forExpr = output.slice(openParenPos + 1, closeParenPos), _contentStart = closeParenPos + 1, forBlocks = findDirectiveBlocks(output.slice(startPos), "for", "endfor");
+    if (forBlocks.length === 0)
+      break;
+    const content = forBlocks[0].content, endPos = startPos + forBlocks[0].end;
+    if (!validateForExpression(forExpr)) {
+      const errorMsg = inlineError("For", `Unsafe expression in @for: ${forExpr}`, ErrorCodes.UNSAFE_EXPRESSION);
+      output = output.substring(0, startPos) + errorMsg + output.substring(endPos);
+      processedAny = !0;
+      continue;
+    }
+    try {
+      const iterVarNames = parseForIterVarNames(forExpr), containsNestedDirectives = /@(?:for|foreach|if|unless)\s*\(/.test(content);
+      if (iterVarNames.length > 0 && containsNestedDirectives) {
+        const result = renderForLoopWithRecursion({
+          forExpr,
+          content,
+          iterVarNames,
+          context,
+          filePath,
+          options
+        });
+        output = output.substring(0, startPos) + result + output.substring(endPos);
+        processedAny = !0;
+        continue;
+      }
+      const loopKeys = Object.keys(context), loopValues = Object.values(context);
+      let processedContent = content.replace(/`/g, "\\`").replace(/\$\{/g, "\\${").replace(/\{\{([^}]+)\}\}/g, (_match, expr) => {
+        return `\${${expr}}`;
+      });
+      processedContent = convertLoopControlToJS(processedContent);
+      const result = Function(...loopKeys, `
+        let result = '';
+        for (${forExpr}) {
+          result += \`${processedContent}\`;
+        }
+        return result;
+      `)(...loopValues);
+      output = output.substring(0, startPos) + result + output.substring(endPos);
+      processedAny = !0;
+    } catch (error) {
+      const errorMsg = inlineError("For", `Error in @for(${forExpr}): ${error instanceof Error ? error.message : String(error)}`, ErrorCodes.EVALUATION_ERROR);
+      output = output.substring(0, startPos) + errorMsg + output.substring(endPos);
+      processedAny = !0;
+    }
+  }
+  return output;
+}
+function parseForIterVarNames(expr) {
+  const trimmed = expr.trim(), destructureMatch = trimmed.match(/^(?:const|let|var)\s+(\[[^\]]+\]|\{[^}]+\})\s+(?:of|in)\s+/);
+  if (destructureMatch) {
+    const inner = destructureMatch[1];
+    return inner.slice(1, -1).split(",").map((part) => {
+      const piece = part.trim();
+      if (!piece)
+        return "";
+      const colon = piece.indexOf(":");
+      if (colon >= 0 && inner.startsWith("{")) {
+        const aliasRaw = piece.slice(colon + 1).trim(), eq = aliasRaw.indexOf("=");
+        return (eq >= 0 ? aliasRaw.slice(0, eq) : aliasRaw).trim();
+      }
+      const eq = piece.indexOf("="), name = (eq >= 0 ? piece.slice(0, eq) : piece).trim();
+      return /^[A-Za-z_$][\w$]*$/.test(name) ? name : "";
+    }).filter(Boolean);
+  }
+  const ofInMatch = trimmed.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s+(?:of|in)\s+/);
+  if (ofInMatch)
+    return [ofInMatch[1]];
+  const cStyleMatch = trimmed.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=[^;]*;/);
+  if (cStyleMatch)
+    return [cStyleMatch[1]];
+  return [];
+}
+function renderForLoopWithRecursion(args) {
+  const { forExpr, content, iterVarNames, context, filePath, options } = args, contextKeys = Object.keys(context), contextValues = Object.values(context), captureFn = Function(...contextKeys, "__pushIter", `
+    for (${forExpr}) {
+      __pushIter([${iterVarNames.join(", ")}])
+    }
+  `), captured = [];
+  captureFn(...contextValues, (vals) => {
+    captured.push(vals);
+  });
+  const fp = filePath ?? "inline.stx";
+  let rendered = "";
+  for (const values of captured) {
+    const iterContext = { ...context };
+    iterVarNames.forEach((name, idx) => {
+      iterContext[name] = values[idx];
+    });
+    let chunk = processForLoops(content, iterContext, filePath, options);
+    chunk = processConditionals(chunk, iterContext, fp);
+    chunk = processExpressions(chunk, iterContext, fp);
+    rendered += chunk;
+  }
+  return rendered;
+}
+function processWhileLoops(template, context, maxIterations) {
+  let output = template, processedAny = !0;
+  while (processedAny) {
+    processedAny = !1;
+    const whileMatch = output.match(/@while\s*\(/);
+    if (!whileMatch || whileMatch.index === void 0)
+      break;
+    const startPos = whileMatch.index, openParenPos = startPos + whileMatch[0].length - 1, closeParenPos = findMatchingDelimiter(output, "(", ")", openParenPos);
+    if (closeParenPos === -1)
+      break;
+    const condition = output.slice(openParenPos + 1, closeParenPos), whileBlocks = findDirectiveBlocks(output.slice(startPos), "while", "endwhile");
+    if (whileBlocks.length === 0)
+      break;
+    const content = whileBlocks[0].content, endPos = startPos + whileBlocks[0].end;
+    if (!validateForExpression(condition)) {
+      const errorMsg = inlineError("While", `Unsafe expression in @while: ${condition}`, ErrorCodes.UNSAFE_EXPRESSION);
+      output = output.substring(0, startPos) + errorMsg + output.substring(endPos);
+      processedAny = !0;
+      continue;
+    }
+    try {
+      const loopKeys = Object.keys(context), loopValues = Object.values(context);
+      let processedContent = content.replace(/`/g, "\\`").replace(/\$\{/g, "\\${").replace(/\{\{([^}]+)\}\}/g, (_match, expr) => {
+        return `\${${expr}}`;
+      });
+      processedContent = convertLoopControlToJS(processedContent);
+      const result = Function(...loopKeys, `
+        let result = '';
+        let maxIterations = ${maxIterations}; // Configurable safety limit
+        let counter = 0;
+        while (${condition} && counter < maxIterations) {
+          counter++;
+          result += \`${processedContent}\`;
+        }
+        if (counter > maxIterations) {
+          result += '<!-- [While Error [1104]]: Maximum iterations (${maxIterations}) exceeded in while loop. Configure via options.loops.maxWhileIterations -->';
+        }
+        return result;
+      `)(...loopValues);
+      output = output.substring(0, startPos) + result + output.substring(endPos);
+      processedAny = !0;
+    } catch (error) {
+      const errorMsg = inlineError("While", `Error in @while(${condition}): ${error instanceof Error ? error.message : String(error)}`, ErrorCodes.EVALUATION_ERROR);
+      output = output.substring(0, startPos) + errorMsg + output.substring(endPos);
+      processedAny = !0;
+    }
+  }
+  return output;
+}