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

package/dist/conditionals.js

@@ -0,0 +1,626 @@
+import { evaluateAuthExpression } from "./auth.js";
+import { ErrorCodes, inlineError } from "./error-handling.js";
+import { extractParenthesizedExpression, findIfBlocks, findMatchingEndTag, parseSwitchBlock } from "./parser/index.js";
+import { createSafeFunction, isExpressionSafe, safeEvaluate } from "./safe-evaluator.js";
+const _NESTED_PARENS_PATTERN = "(?:[^()]|\\([^()]*\\))*";
+function _findBalancedSwitch(content, startIndex) {
+  let depth = 1, currentIndex = startIndex;
+  while (currentIndex < content.length && depth > 0) {
+    const switchMatch = content.substring(currentIndex).match(/@switch\s*\(((?:[^()]|\([^()]*\))*)\)/), endSwitchMatch = content.substring(currentIndex).match(/@endswitch/), nextSwitch = switchMatch ? currentIndex + switchMatch.index : 1 / 0, nextEnd = endSwitchMatch ? currentIndex + endSwitchMatch.index : 1 / 0;
+    if (nextSwitch < nextEnd) {
+      depth++;
+      currentIndex = nextSwitch + switchMatch[0].length;
+    } else if (nextEnd < 1 / 0) {
+      depth--;
+      if (depth === 0)
+        return {
+          end: nextEnd,
+          switchContent: content.substring(startIndex, nextEnd)
+        };
+      currentIndex = nextEnd + endSwitchMatch[0].length;
+    } else
+      break;
+  }
+  return null;
+}
+export function processSwitchStatements(template, context, _filePath) {
+  let output = template, processedAny = !0;
+  while (processedAny) {
+    processedAny = !1;
+    const switchMatch = output.match(/@switch\s*\(/);
+    if (!switchMatch || switchMatch.index === void 0)
+      break;
+    const switchStart = switchMatch.index, parsed = parseSwitchBlock(output, switchStart);
+    if (!parsed)
+      break;
+    try {
+      let switchValue;
+      if (isExpressionSafe(parsed.expression))
+        switchValue = createSafeFunction(parsed.expression, Object.keys(context))(...Object.values(context));
+      else
+        switchValue = safeEvaluate(parsed.expression, context);
+      let result = "", foundMatch = !1;
+      for (const caseItem of parsed.cases)
+        if (caseItem.type === "default") {
+          if (!foundMatch)
+            result = caseItem.content.trim();
+        } else
+          try {
+            let caseValue;
+            if (caseItem.value && isExpressionSafe(caseItem.value))
+              caseValue = createSafeFunction(caseItem.value, Object.keys(context))(...Object.values(context));
+            else if (caseItem.value)
+              caseValue = safeEvaluate(caseItem.value, context);
+            if (switchValue === caseValue) {
+              result = caseItem.content.trim();
+              foundMatch = !0;
+              break;
+            }
+          } catch {
+            continue;
+          }
+      output = output.substring(0, switchStart) + result + output.substring(parsed.end);
+      processedAny = !0;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error), errorMessage = inlineError("Switch", `Error evaluating @switch expression: ${msg}`, ErrorCodes.EVALUATION_ERROR);
+      output = output.substring(0, switchStart) + errorMessage + output.substring(parsed.end);
+      break;
+    }
+  }
+  return output;
+}
+function maskScripts(template) {
+  const scripts = [];
+  return { masked: template.replace(/<script\b[\s\S]*?<\/script\s*>/gi, (match) => {
+    scripts.push(match);
+    return `\x00stx-script-${scripts.length - 1}\x00`;
+  }), scripts };
+}
+function restoreScripts(output, scripts) {
+  if (scripts.length === 0)
+    return output;
+  return output.replace(/\u0000stx-script-(\d+)\u0000/g, (match, index) => scripts[Number(index)] ?? match);
+}
+export function processConditionals(template, context, filePath) {
+  const { masked, scripts } = maskScripts(template);
+  return restoreScripts(processConditionalsIn(masked, context, filePath), scripts);
+}
+function processConditionalsIn(template, context, filePath) {
+  let output = template;
+  output = processSwitchStatements(output, context, filePath);
+  {
+    let processedAny = !0;
+    while (processedAny) {
+      processedAny = !1;
+      const unlessMatch = output.match(/@unless\s*\(/);
+      if (!unlessMatch || unlessMatch.index === void 0)
+        break;
+      const startPos = unlessMatch.index, exprResult = extractParenthesizedExpression(output, startPos + 7);
+      if (!exprResult)
+        break;
+      const contentStart = exprResult.endPos, endPos = findMatchingEndTag(output, "unless", "endunless", contentStart);
+      if (endPos === -1) {
+        console.warn(`[stx] @unless directive at position ${startPos} has no matching @endunless \u2014 the block was skipped. Check for typos or missing closers.`);
+        break;
+      }
+      const content = output.slice(contentStart, endPos), condition = exprResult.expression;
+      let elsePos = -1;
+      {
+        let depth = 0;
+        const openRe = /@(?:if|unless)\s*\(/g, closeRe = /@(?:endif|endunless)(?![a-z])/g, elseRe = /@else(?![a-z])/g, events = [];
+        let em;
+        while ((em = openRe.exec(content)) !== null)
+          events.push({ pos: em.index, type: "open" });
+        while ((em = closeRe.exec(content)) !== null)
+          events.push({ pos: em.index, type: "close" });
+        while ((em = elseRe.exec(content)) !== null)
+          events.push({ pos: em.index, type: "else" });
+        events.sort((a, b) => a.pos - b.pos);
+        for (const ev of events)
+          if (ev.type === "open")
+            depth++;
+          else if (ev.type === "close")
+            depth--;
+          else if (ev.type === "else" && depth === 0) {
+            elsePos = ev.pos;
+            break;
+          }
+      }
+      let replacement;
+      if (elsePos !== -1) {
+        const unlessContent = content.slice(0, elsePos), elseContent = content.slice(elsePos + 5);
+        replacement = `@if (${condition})${elseContent}@else ${unlessContent}@endif`;
+      } else
+        replacement = `@if (!(${condition}))${content}@endif`;
+      output = output.substring(0, startPos) + replacement + output.substring(endPos + 10);
+      processedAny = !0;
+    }
+  }
+  output = processIssetEmptyDirectives(output, context, filePath);
+  output = processEnvDirective(output, context, filePath);
+  output = processAuthDirectives(output, context);
+  const processIfStatements = () => {
+    const ifBlocks = findIfBlocks(output);
+    if (ifBlocks.length === 0)
+      return !1;
+    const replacements = Array(ifBlocks.length);
+    for (let i = ifBlocks.length - 1;i >= 0; i--) {
+      const block = ifBlocks[i];
+      try {
+        let result = "", foundTrueBranch = !1;
+        for (const branch of block.branches) {
+          if (foundTrueBranch)
+            break;
+          if (branch.type === "else") {
+            result = branch.content;
+            foundTrueBranch = !0;
+          } else
+            try {
+              let conditionResult;
+              if (branch.condition && isExpressionSafe(branch.condition))
+                conditionResult = createSafeFunction(branch.condition, Object.keys(context))(...Object.values(context));
+              else if (branch.condition)
+                conditionResult = safeEvaluate(branch.condition, context);
+              if (conditionResult) {
+                result = branch.content;
+                foundTrueBranch = !0;
+              }
+            } catch (error) {
+              result = inlineError(branch.type === "if" ? "If" : "Elseif", `Error in @${branch.type}(${branch.condition}): ${error instanceof Error ? error.message : String(error)}`, ErrorCodes.EVALUATION_ERROR);
+              foundTrueBranch = !0;
+            }
+        }
+        replacements[i] = result;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        replacements[i] = inlineError("If", `Error processing @if block: ${msg}`, ErrorCodes.EVALUATION_ERROR);
+      }
+    }
+    const chunks = Array(ifBlocks.length * 2 + 1);
+    let cursor = 0;
+    for (let i = 0;i < ifBlocks.length; i++) {
+      const block = ifBlocks[i];
+      chunks[i * 2] = output.slice(cursor, block.start);
+      chunks[i * 2 + 1] = replacements[i];
+      cursor = block.end;
+    }
+    chunks[ifBlocks.length * 2] = output.slice(cursor);
+    output = chunks.join("");
+    return !0;
+  };
+  while (!0) {
+    const before = output;
+    if (!processIfStatements())
+      break;
+    if (output === before)
+      break;
+  }
+  return output;
+}
+function parseQuotedGuard(src) {
+  let i = 0;
+  while (i < src.length && /\s/.test(src[i]))
+    i++;
+  if (src[i] !== "(")
+    return null;
+  i++;
+  while (i < src.length && /\s/.test(src[i]))
+    i++;
+  const quote = src[i];
+  if (quote !== "'" && quote !== '"')
+    return null;
+  i++;
+  const chunks = [];
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === "\\" && i + 1 < src.length) {
+      chunks.push(src[i + 1]);
+      i += 2;
+      continue;
+    }
+    if (ch === quote) {
+      i++;
+      break;
+    }
+    chunks.push(ch);
+    i++;
+  }
+  while (i < src.length && /\s/.test(src[i]))
+    i++;
+  if (src[i] !== ")")
+    return null;
+  i++;
+  return { value: chunks.join(""), consumed: i };
+}
+export function processAuthDirectives(template, context) {
+  let output = template;
+  function findEndTag(src, startTag, endTag, from) {
+    let depth = 1, pos = from;
+    const openRe = new RegExp(`@${startTag}(?:\\s*\\(|\\s|$)`, "g"), closeRe = new RegExp(`@${endTag}(?![a-z])`, "g");
+    while (pos < src.length && depth > 0) {
+      openRe.lastIndex = pos;
+      closeRe.lastIndex = pos;
+      const openMatch = openRe.exec(src), closeMatch = closeRe.exec(src), nextOpen = openMatch ? openMatch.index : 1 / 0, nextClose = closeMatch ? closeMatch.index : 1 / 0;
+      if (nextOpen < nextClose) {
+        depth++;
+        pos = nextOpen + openMatch[0].length;
+      } else if (nextClose < 1 / 0) {
+        depth--;
+        if (depth === 0)
+          return nextClose;
+        pos = nextClose + closeMatch[0].length;
+      } else
+        break;
+    }
+    return -1;
+  }
+  function findTopLevelElse(content, startTag, endTag) {
+    let depth = 0;
+    const openRe = new RegExp(`@${startTag}(?:\\s*\\(|\\s|$)`, "g"), closeRe = new RegExp(`@${endTag}(?![a-z])`, "g"), elseRe = /@else(?![a-z])/g, events = [];
+    let m;
+    while ((m = openRe.exec(content)) !== null)
+      events.push({ pos: m.index, type: "open" });
+    while ((m = closeRe.exec(content)) !== null)
+      events.push({ pos: m.index, type: "close" });
+    while ((m = elseRe.exec(content)) !== null)
+      events.push({ pos: m.index, type: "else" });
+    events.sort((a, b) => a.pos - b.pos);
+    for (const ev of events)
+      if (ev.type === "open")
+        depth++;
+      else if (ev.type === "close")
+        depth--;
+      else if (ev.type === "else" && depth === 0)
+        return ev.pos;
+    return -1;
+  }
+  {
+    let processedAny = !0;
+    while (processedAny) {
+      processedAny = !1;
+      const authMatch = output.match(/@auth(?:\s*\(|\s|(?=\n))/);
+      if (!authMatch || authMatch.index === void 0)
+        break;
+      const startPos = authMatch.index;
+      let guard, contentStart;
+      const afterAuth = output.slice(startPos + 5), parsedGuard = parseQuotedGuard(afterAuth);
+      if (parsedGuard) {
+        guard = parsedGuard.value;
+        contentStart = startPos + 5 + parsedGuard.consumed;
+      } else
+        contentStart = startPos + 5;
+      const endPos = findEndTag(output, "auth", "endauth", contentStart);
+      if (endPos === -1) {
+        console.warn(`[stx] @auth directive at position ${startPos} has no matching @endauth \u2014 the block was skipped.`);
+        break;
+      }
+      const fullContent = output.slice(contentStart, endPos), elsePos = findTopLevelElse(fullContent, "auth", "endauth");
+      let isAuthenticated;
+      if (!context.auth)
+        isAuthenticated = !1;
+      else
+        isAuthenticated = guard ? evaluateAuthExpression(`auth?.check && auth?.user?.[${guard}]`, context) : evaluateAuthExpression("auth?.check", context);
+      let replacement;
+      if (elsePos !== -1) {
+        const trueContent = fullContent.slice(0, elsePos), falseContent = fullContent.slice(elsePos + 5);
+        replacement = isAuthenticated ? trueContent : falseContent;
+      } else
+        replacement = isAuthenticated ? fullContent : "";
+      output = output.substring(0, startPos) + replacement + output.substring(endPos + 8);
+      processedAny = !0;
+    }
+  }
+  {
+    let processedAny = !0;
+    while (processedAny) {
+      processedAny = !1;
+      const guestMatch = output.match(/@guest(?:\s*\(|\s|(?=\n))/);
+      if (!guestMatch || guestMatch.index === void 0)
+        break;
+      const startPos = guestMatch.index;
+      let guard, contentStart;
+      const afterGuest = output.slice(startPos + 6), parsedGuestGuard = parseQuotedGuard(afterGuest);
+      if (parsedGuestGuard) {
+        guard = parsedGuestGuard.value;
+        contentStart = startPos + 6 + parsedGuestGuard.consumed;
+      } else
+        contentStart = startPos + 6;
+      const endPos = findEndTag(output, "guest", "endguest", contentStart);
+      if (endPos === -1) {
+        console.warn(`[stx] @guest directive at position ${startPos} has no matching @endguest \u2014 the block was skipped.`);
+        break;
+      }
+      const fullContent = output.slice(contentStart, endPos), elsePos = findTopLevelElse(fullContent, "guest", "endguest");
+      let isGuest;
+      if (!context.auth)
+        isGuest = !0;
+      else
+        isGuest = guard ? evaluateAuthExpression(`!auth?.check || !auth?.user?.[${guard}]`, context) : evaluateAuthExpression("!auth?.check", context);
+      let replacement;
+      if (elsePos !== -1) {
+        const trueContent = fullContent.slice(0, elsePos), falseContent = fullContent.slice(elsePos + 5);
+        replacement = isGuest ? trueContent : falseContent;
+      } else
+        replacement = isGuest ? fullContent : "";
+      output = output.substring(0, startPos) + replacement + output.substring(endPos + 9);
+      processedAny = !0;
+    }
+  }
+  function checkPermission(ability, type, id) {
+    if (context.userCan && typeof context.userCan[ability] === "boolean")
+      return context.userCan[ability];
+    if (context.permissions?.check && typeof context.permissions.check === "function")
+      try {
+        const args = [ability];
+        if (type)
+          args.push(type);
+        if (id) {
+          const idValue = evaluateAuthExpression(id, context);
+          args.push(idValue);
+        }
+        return context.permissions.check(...args);
+      } catch {
+        return !1;
+      }
+    return !1;
+  }
+  function parseCanParams(afterDirective) {
+    const m = afterDirective.match(/^\s*\(\s*'([^']*)'(?:,\s*'([^']*)')?(?:,\s*([^)]*))?\)/);
+    if (!m)
+      return null;
+    return { ability: m[1], type: m[2], id: m[3]?.trim(), paramsEnd: m[0].length };
+  }
+  for (const directive of ["can", "cannot"]) {
+    const endDirective = `end${directive}`, elseDirective = directive === "can" ? "elsecan" : "elsecannot";
+    let processedAny = !0;
+    while (processedAny) {
+      processedAny = !1;
+      const canMatch = output.match(new RegExp(`@${directive}\\s*\\(`));
+      if (!canMatch || canMatch.index === void 0)
+        break;
+      const startPos = canMatch.index, afterDir = output.slice(startPos + `@${directive}`.length), parsed = parseCanParams(afterDir);
+      if (!parsed)
+        break;
+      const contentStart = startPos + `@${directive}`.length + parsed.paramsEnd, endPos = findEndTag(output, directive, endDirective, contentStart);
+      if (endPos === -1) {
+        console.warn(`[stx] @${directive} directive at position ${startPos} has no matching @${endDirective} \u2014 the block was skipped.`);
+        break;
+      }
+      const fullContent = output.slice(contentStart, endPos), topLevelBreaks = [];
+      let dpt = 0;
+      const scanOpenRe = new RegExp(`@${directive}\\s*\\(`, "g"), scanCloseRe = new RegExp(`@${endDirective}(?![a-z])`, "g"), scanElseDirRe = new RegExp(`@${elseDirective}\\s*\\(`, "g"), scanElseRe = /@else(?![a-z])/g, scanEvents = [];
+      let sm;
+      while ((sm = scanOpenRe.exec(fullContent)) !== null)
+        scanEvents.push({ pos: sm.index, type: "open" });
+      while ((sm = scanCloseRe.exec(fullContent)) !== null)
+        scanEvents.push({ pos: sm.index, type: "close" });
+      while ((sm = scanElseDirRe.exec(fullContent)) !== null)
+        scanEvents.push({ pos: sm.index, type: "elseDirective" });
+      while ((sm = scanElseRe.exec(fullContent)) !== null)
+        scanEvents.push({ pos: sm.index, type: "else" });
+      scanEvents.sort((a, b) => a.pos - b.pos);
+      for (const ev of scanEvents) {
+        if (ev.type === "open") {
+          dpt++;
+          continue;
+        }
+        if (ev.type === "close") {
+          dpt--;
+          continue;
+        }
+        if (dpt === 0)
+          topLevelBreaks.push(ev);
+      }
+      const segments = [];
+      let segStart = 0;
+      for (let brkIdx = 0;brkIdx < topLevelBreaks.length; brkIdx++) {
+        const brk = topLevelBreaks[brkIdx];
+        segments.push({ content: fullContent.slice(segStart, brk.pos), ability: void 0 });
+        if (brk.type === "elseDirective") {
+          const after = fullContent.slice(brk.pos + `@${elseDirective}`.length), ep = parseCanParams(after);
+          if (ep) {
+            segments[segments.length - 1] = { content: fullContent.slice(segStart, brk.pos) };
+            segStart = brk.pos + `@${elseDirective}`.length + ep.paramsEnd;
+            segments.push({ content: "", ability: ep.ability, type: ep.type, id: ep.id });
+            segments.pop();
+            const nextBrk = topLevelBreaks[brkIdx + 1], nextEnd = nextBrk ? nextBrk.pos : fullContent.length;
+            segments.push({ content: fullContent.slice(segStart, nextEnd), ability: ep.ability, type: ep.type, id: ep.id });
+            segStart = nextEnd;
+          }
+        } else
+          segStart = brk.pos + 5;
+      }
+      if (segStart < fullContent.length) {
+        const lastSeg = segments[segments.length - 1];
+        if (topLevelBreaks.length > 0 && topLevelBreaks[topLevelBreaks.length - 1].type === "else")
+          segments.push({ content: fullContent.slice(segStart), isFinalElse: !0 });
+        else if (segments.length === 0)
+          segments.push({ content: fullContent.slice(segStart) });
+      }
+      const primaryPerm = checkPermission(parsed.ability, parsed.type, parsed.id), primaryResult = directive === "can" ? primaryPerm : !primaryPerm;
+      let replacement = "";
+      if (primaryResult)
+        replacement = segments[0]?.content || "";
+      else {
+        let found = !1;
+        for (let si = 1;si < segments.length; si++) {
+          const seg = segments[si];
+          if (seg.isFinalElse) {
+            replacement = seg.content;
+            found = !0;
+            break;
+          }
+          if (seg.ability) {
+            const elsePerm = checkPermission(seg.ability, seg.type, seg.id);
+            if (directive === "can" ? elsePerm : !elsePerm) {
+              replacement = seg.content;
+              found = !0;
+              break;
+            }
+          }
+        }
+        if (!found && segments.length > 0) {
+          const lastSeg = segments[segments.length - 1];
+          if (lastSeg.isFinalElse)
+            replacement = lastSeg.content;
+        }
+      }
+      output = output.substring(0, startPos) + replacement + output.substring(endPos + `@${endDirective}`.length);
+      processedAny = !0;
+    }
+  }
+  return output;
+}
+export function processIssetEmptyDirectives(template, context, _filePath) {
+  let result = template;
+  function processBalancedDirective(output, directiveName, endDirectiveName, evaluator, errorLabel) {
+    let processedAny = !0;
+    while (processedAny) {
+      processedAny = !1;
+      const pattern = new RegExp(`@${directiveName}\\s*\\(`), match = output.match(pattern);
+      if (!match || match.index === void 0)
+        break;
+      const startPos = match.index, exprResult = extractParenthesizedExpression(output, startPos + `@${directiveName}`.length);
+      if (!exprResult)
+        break;
+      const contentStart = exprResult.endPos, endPos = findMatchingEndTag(output, directiveName, endDirectiveName, contentStart);
+      if (endPos === -1) {
+        console.warn(`[stx] @${directiveName} directive at position ${startPos} has no matching @${endDirectiveName} \u2014 the block was skipped.`);
+        break;
+      }
+      const fullContent = output.slice(contentStart, endPos), variable = exprResult.expression;
+      let elsePos = -1, depth = 0, searchIdx = 0;
+      while (searchIdx < fullContent.length) {
+        const atIdx = fullContent.indexOf("@", searchIdx);
+        if (atIdx === -1)
+          break;
+        const rem = fullContent.substring(atIdx);
+        if (/^@(?:if|unless|isset|empty)\s*\(/.test(rem)) {
+          depth++;
+          searchIdx = atIdx + 1;
+          continue;
+        }
+        if (/^@(?:endif|endunless|endisset|endempty)(?![a-z])/.test(rem)) {
+          depth--;
+          searchIdx = atIdx + 1;
+          continue;
+        }
+        if (depth === 0 && /^@else(?![a-z])/.test(rem)) {
+          elsePos = atIdx;
+          break;
+        }
+        searchIdx = atIdx + 1;
+      }
+      try {
+        const conditionResult = evaluator(variable.trim());
+        let replacement;
+        if (elsePos !== -1) {
+          const trueContent = fullContent.slice(0, elsePos), falseContent = fullContent.slice(elsePos + 5);
+          replacement = conditionResult ? trueContent : falseContent;
+        } else
+          replacement = conditionResult ? fullContent : "";
+        output = output.substring(0, startPos) + replacement + output.substring(endPos + `@${endDirectiveName}`.length);
+        processedAny = !0;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error), errorMessage = inlineError(errorLabel, `Error processing @${directiveName} directive: ${msg}`, ErrorCodes.EVALUATION_ERROR);
+        output = output.substring(0, startPos) + errorMessage + output.substring(endPos + `@${endDirectiveName}`.length);
+        break;
+      }
+    }
+    return output;
+  }
+  result = processBalancedDirective(result, "isset", "endisset", (variable) => {
+    const value = evaluateAuthExpression(variable, context);
+    return value !== void 0 && value !== null;
+  }, "Isset");
+  result = processBalancedDirective(result, "empty", "endempty", (variable) => {
+    const value = evaluateAuthExpression(variable, context);
+    return value === void 0 || value === null || value === "" || value === 0 || value === !1 || Array.isArray(value) && value.length === 0 || typeof value === "object" && value !== null && Object.keys(value).length === 0;
+  }, "Empty");
+  return result;
+}
+export function processEnvDirective(template, _context, _filePath) {
+  let output = template;
+  const currentEnv = "development";
+  function processEnvBlock(src, directiveName, endDirectiveName, condition) {
+    const openTagRe = new RegExp(`@${directiveName}(?![a-z])`, "g"), endTagRe = new RegExp(`@${endDirectiveName}(?![a-z])`, "g"), openTagTest = new RegExp(`^@${directiveName}(?![a-z])`), endTagTest = new RegExp(`^@${endDirectiveName}(?![a-z])`);
+    let result = src, processedAny = !0;
+    while (processedAny) {
+      processedAny = !1;
+      openTagRe.lastIndex = 0;
+      const match = openTagRe.exec(result);
+      if (!match)
+        break;
+      const startPos = match.index;
+      let contentStart = startPos + match[0].length;
+      if (directiveName === "env") {
+        const envParenMatch = result.substring(contentStart).match(/^\s*\(\s*(['"])([^'"]+)\1\s*\)/);
+        if (!envParenMatch)
+          break;
+        contentStart += envParenMatch[0].length;
+        condition = currentEnv === envParenMatch[2];
+      }
+      let depth = 1, searchPos = contentStart, endPos = -1;
+      while (depth > 0 && searchPos < result.length) {
+        openTagRe.lastIndex = searchPos;
+        endTagRe.lastIndex = searchPos;
+        const nextOpenMatch = openTagRe.exec(result), nextCloseMatch = endTagRe.exec(result), nextOpen = nextOpenMatch ? nextOpenMatch.index : 1 / 0, nextClose = nextCloseMatch ? nextCloseMatch.index : 1 / 0;
+        if (nextOpen < nextClose) {
+          depth++;
+          searchPos = nextOpen + nextOpenMatch[0].length;
+        } else if (nextClose < 1 / 0) {
+          depth--;
+          if (depth === 0) {
+            endPos = nextClose;
+            break;
+          }
+          searchPos = nextClose + nextCloseMatch[0].length;
+        } else
+          break;
+      }
+      if (endPos === -1) {
+        console.warn(`[stx] @${directiveName} directive at position ${startPos} has no matching @${endDirectiveName} \u2014 the block was skipped.`);
+        break;
+      }
+      const fullContent = result.substring(contentStart, endPos);
+      let elseIdx = -1, nestedDepth = 0, si = 0;
+      while (si < fullContent.length) {
+        const atPos = fullContent.indexOf("@", si);
+        if (atPos === -1)
+          break;
+        const rem = fullContent.substring(atPos);
+        if (openTagTest.test(rem)) {
+          nestedDepth++;
+          si = atPos + 1;
+          continue;
+        }
+        if (endTagTest.test(rem)) {
+          nestedDepth--;
+          si = atPos + 1;
+          continue;
+        }
+        if (nestedDepth === 0 && /^@else(?![a-z])/.test(rem)) {
+          elseIdx = atPos;
+          break;
+        }
+        si = atPos + 1;
+      }
+      let replacement;
+      if (elseIdx !== -1) {
+        const trueContent = fullContent.slice(0, elseIdx), falseContent = fullContent.slice(elseIdx + 5);
+        replacement = condition ? trueContent : falseContent;
+      } else
+        replacement = condition ? fullContent : "";
+      const endTagLength = `@${endDirectiveName}`.length;
+      result = result.substring(0, startPos) + replacement + result.substring(endPos + endTagLength);
+      processedAny = !0;
+    }
+    return result;
+  }
+  output = processEnvBlock(output, "env", "endenv", !1);
+  output = processEnvBlock(output, "production", "endproduction", currentEnv === "production");
+  output = processEnvBlock(output, "development", "enddevelopment", currentEnv === "development");
+  output = processEnvBlock(output, "staging", "endstaging", currentEnv === "staging");
+  output = processEnvBlock(output, "testing", "endtesting", currentEnv === "testing");
+  return output;
+}